面向对象的编程（2）

之前讲过什么是面向对象编程，然后写了两个简单的小实例，今天继续研究。

一 包装对象

1.什么是包装对象

先来看这段代码：

var str = 'hello';
alert( typeof str ); //string

str.charAt(0);
str.indexOf('e');

很明显，str的类型是string，按理说只有对象才会有属性和方法，为什么字符串可以使用方法呢？

其实这就是包装对象。

分别与数值、字符串、布尔值相对应的Number、String、Boolean这三个原生对象可以把原始类型的值变成（包装成）对象。

这三个对象作为构造函数使用（带有new）时，可以将原始类型的值转为对象；作为普通函数使用时（不带有new），可以将任意类型的值，转为原始类型的值。

2.原始类型的自动转换

在上面的代码中，执行到str.charAt(0);的时候， 基本类型会找到对应的包装对象类型，然后包装对象把所有的属性和方法给了基本类型，然后包装对象消失。这就叫原始类型的自动转换。

但是这个对象是临时的，我们不能对它进行修改。

var str = 'hello';
alert(str.length);  //5

str.number = 10;
alert( str.number );  //undefined

上面代码中，str是一个字符串，本身不是对象，不能调用length属性。JavaScript引擎自动将其转为包装对象，在这个对象上调用length属性。这个临时对象是只读的，无法修改。所以，字符串无法添加新属性。

3.包装对象自定义方法

包装对象还可以在原型上添加自定义方法和属性，供原始类型的值直接调用。

var str = 'hello';

String.prototype.lastValue = function(){
    return this.charAt(this.length-1);
};

alert( str.lastValue() );  //o

二 原型链

1 什么是原型链

在下面的例子中，我们创建了两个构造函数，其中LandRover的原型对象又是以Car的原型对象为原型创建的。图示中的红色线即为原型链。

function Car(Logo) {
    this.logo = logo || "unknown name";
}
//设置Car的prototype属性
Car.prototype = {
    start:function() {
         console.log('%s start',this.logo);
    },
    run:function() {
         console.log('%s run',this.logo);
    },
    stop:function() {
         console.log('%s stop',this.logo);
    }
};

//又创建一个构造函数landRover
function LandRover(serialno) {
    this.serialNumber = serialno;  //序列号
}
//设置LandRover的prototype属性
LandRover.prototype = new Car("landRover"); //使用Car创建一个新对象，并把它赋给LandRover构造函数的原型

//创建LandRover对象
var landRover1 = new LandRover("1000");
var landRover2 = new LandRover("1001");

Paste_Image.png

Car.prototype对象也是由Object来创建的，所以它的原型指向Object.prototype

2 修改、删除属性时，只能修改、删除对象自身的属性

①访问：假如我们想访问landRover1的serialNumber属性，那么直接在它的本身就可以找到；如果我们要访问landRover1的toString方法，它本身是没有的，就会顺着原型链一直网上寻找，知道找到或者没有。

②修改及删除：

操作1：

landRover1.Logo = landRover1;

因为landRover1本身并没有Logo，虽然它可以访问landRover.protoype的Logo属性，但是它无法修改，所以这时它会在自己身上加一个Logo属性，并赋值为landRover1，对landRover.protoype中的Logo属性并无影响

操作2：

delete(landRover1.Logo);

我们把landRover1的Logo属性删除了，但是当我们访问landRover1.Logo时，还是可以访问到的，因为它删除的是自身的属性，对原型上的属性无影响，即使再次做修改操作，也是无效的

3 在javascript中，一切都是对象

①函数在JS中也是对象，所以，Car和LandRover 这些构造函数其实也是一个对象，既然是对象，肯定就有原型，而Car和LandRover 则是由new Function创建出来的，所以LandRover和Car都有一个原型即Function.prototype。

②而Function.prototype是由new Object创建出来的，所以Function.prototype的原型指向Object的原型，也就是Object.prototype。

③Object.prototype是所有原型的顶层。

Paste_Image.png

三 面向对象的一些属性和方法

1.hasOwnProperty()

1）作用：判断传入的属性是否为对象自身的属性

理解原型查找原理：对象查找先在该构造函数内查找对应的属性，如果该对象没有该属性的话，那么javascript会试着从该原型上去查找，如果原型对象中也没有该属性的话，那么它们会从原型中的原型去查找，直到查找的Object.prototype也没有该属性的话，那么就会返回undefined。

2）实例

因此我们仅想在该对象内查找的话，为了提高性能，我们可以使用hasOwnProperty()来判断该对象内有没有该属性，如果有的话，就执行代码(使用for-in循环查找)，如下：

var obj = {
    "name":'moon',
    "age":'28'
};
// 使用for-in循环
for(var i in obj) {
    if(obj.hasOwnProperty(i)) {
        console.log(obj[i]);    //moon 28
    }
}

如上使用for-in循环查找对象里面的属性，但是我们需要明白的是：for-in循环查找对象的属性，它是不保证顺序的，for-in循环和for循环最本质的区别是：for循环是有顺序的，for-in循环遍历对象是无序的，因此我们如果需要对象保证顺序的话，可以把对象转换为数组来，然后再使用for循环遍历即可;

2.constructor

1）作用：查看对象的构造函数

function Aaa(){
}
var a1 = new Aaa();
alert( a1.constructor );  //Aaa

2）每个原型都会自动添加constructor属性

prototype对象有一个constructor属性，默认指向prototype对象所在的构造函数。

function Aaa(){
}
//系统会自动添加上
//Aaa.prototype.constructor = Aaa;   
//每一个函数都会有的，都是自动生成的

由于constructor属性定义在prototype对象上面，意味着可以被所有实例对象继承。

3）避免修改construtor属性

function A() {}
var a = new A();
a instanceof A // true

function B() {}
A.prototype = B.prototype;
a instanceof A // false

上面代码中，a是A的实例。修改了A.prototype以后，constructor属性的指向就变了，导致instanceof运算符失真。

所以，修改原型对象时，一般要同时校正constructor属性的指向。

// 避免这种写法
C.prototype = {
  method1: function (...) { ... },
  // ...
};

// 较好的写法
C.prototype = {
  constructor: C,
  method1: function (...) { ... },
  // ...
};

// 好的写法
C.prototype.method1 = function (...) { ... };

3.instanceof运算符

1）作用：对象与构造函数在原型链上是否有关系

function Aaa(){
}

var a1 = new Aaa();
alert( a1 instanceof Object );  //true

2）可以用来判断数据类型

4.toString() :

1）作用：把对象转成字符串

这个方法是原型上的，我们可以修改这个方法，但是不建议这样做

var arr = [1,2,3];

Array.prototype.toString = function(){
    return this.join('+');
};

alert( arr.toString() );  //'1+2+3'

2）利用toString方法来做类型判断

四 对象的继承

1.什么是继承

• 在原有对象的基础上，略作修改，得到一个新的对象
• 不影响原有对象的功能

当新创建的对象添加了新的属性和方法时，肯定不能直接用new+构造函数这种方法来直接创建了，因为在添加属性或者方法的时候，也会影响到原来的对象。那我们应该如何实现呢？

2.拷贝继承

方式：

• 属性的继承 : 调用父类的构造函数 call
• 方法的继承 : for in : 拷贝继承 (jquery也是采用拷贝继承extend)

function Person(name) {
    this.name = name;
}
Person.prototype.talk = function(name) {
    console.log('My name is '+this.name);
};
var p1 = new Person('moon');
// console.log(p1.name);
// p1.talk();
function Person1(name,age) {
    Person.call(this,name); //这里需要改变this的指向
    this.age = age;
}
function extend(obj1,obj2){
    for (var attr in obj2) {
        obj1[attr] = obj2[attr]; //这个地方不能用"."
    }
}
extend(Person1.prototype,Person.prototype);
var p2 = new Person1('yao',18);
console.log(p1.name); //moon
console.log(p2.name); //yao
p2.talk(); //My name is yao

3.类继承

利用构造函数(类)继承的方式。

首先声明，JS中是没有类的概念的，这里说的类是把JS中的构造函数看做类。

先来看看所谓的一步继承法

function Person1() {
    this.name = [1,2,3];
}
Person1.prototype.talk = function(name) {
    alert(this.name);
};

function Person2() {}
Person2.prototype = new Person1();

var p1 = new Person2();
p1.talk();
alert( p1.constructor ); //Person1

p1.name.push(4);
var p2 = new Person2();
console.log(p1.name);  //[1,2,3,4]
console.log(p2.name);  //[1,2,3,4]

缺陷：

1.修改了构造函数的指向

2.创建出来的对象之间会相互影响

正确做法：
属性和方法分开继承。

function Person1() {
    this.name = [1,2,3];
}
Person1.prototype.talk = function(name) {
    alert(this.name);
};

function Person2() {
    Person1.call(this); //属性继承仍采取之前的call调用父类的构造函数的方法
}
function Foo() {}  //避免继承属性，只继承方法
Foo.prototype = Person1.prototype;
Person2.prototype = new Foo();
Person2.prototype.constructor = Person2; //修正指向问题

var p1 = new Person2();

p1.talk();
alert( p1.constructor );
p1.name.push(4);
var p2 = new Person2();
console.log(p1.name);  //[1,2,3,4]
console.log(p2.name);  //[1,2,3]

4.原型继承

利用原型prototype来实现继承，一般用来下面这种情况：

function cloneObj(obj){

    var F = function(){};
    F.prototype = obj;
    return new F();

}
var a = {
    name : '小明'
};

var b = cloneObj(a);
alert( b.name ); // 小明

b.name = '小强';
alert( b.name ); //小强
alert( a.name ); //小明

我们来看一下关系图，假设 new F() =f1

无标题.png

 第一次执行alert( b.name );时，因为b没有这个属性，所以它会顺着原型链往上找，知道找到a下面的name:小明

 执行b.name = '小强';因为b本身是没有name这个属性的，它虽然可以访问a下面的name属性，但是无法修改，所以这时它会在自己身上加一个name属性，并赋值为“小强”，对a中的name属性并无影响

 执行alert( a.name ); 的时候，根据原型链的查找规则，它肯定不会查找到b下面去，更何况a本身就有name属性，所以弹出来的还是“小明”

5.小结：

• 拷贝继承: 通用型的,有new或无new的时候都可以

• 类式继承: 通过new构造函数形式

• 原型继承: 无new的对象

如有错误，烦请告知，非常感谢。