JavaScript面向对象初探——封装和继承

 

1.封装类

怎么封装一个类，也就是创建自定义对象？

• 构造函数式

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.showColor = function() {
    alert(this.color);
  };
}

var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);

和Java模式最像。缺点是每生成实例都会创建一次showColor。

• 原型方式

function Car() {}

Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.showColor = function() {
  alert(this.color);
};

var oCar1 = new Car();

利用了前述prototype。缺点是不灵活，无法传参数。

通过给this添加属性的方式创建成员变量都是公有的，在函数体内var的变量都是私有的。类用一个Function来声明，这个Function就是构造函数，如果变量再构造函数外声明就等同静态变量，不需要new就可以访问。

• 构造函数和原型混合式

这种方式为了避免重复创建函数副本。

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");
}

Car.prototype.showColor = function() {
  alert(this.color);
};

var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);

但第12行如果不小心忘写了new，Car中的this就是window了，为了避免几个属性加载window上，可以在Car内添加this instanceof Car判断。

2.原型链

所有对象都拥有prototype属性，这个属性也是一个对象。给obj.prototype添加属性和方法意味着这些属性和方法挂在了原型链上，原型链下游的对象（子类）可以继承到原型链上所有的方法。也就是说，obj的prototype对象中的属性一般情况下不是给自己用的，用obj.hasOwnProperty(obj.prototype.attr)结果都为false，给自己添加属性直接obj.attr=XXX。

当一个子类查找一个属性时，首先在自己的属性中查找（注意不去找自己的prototype里的属性），然后查找父类的prototype，一直找到原型链顶端Object.prototype。这个原型链的链接是由prototype.__proto__这个私有属性实现的，子类的prototype.__proto__指向父类的prototype。所有类的基类Object的prototype.__proto__指向null，所以原型链总是有穷的。

对象实例与上面说的子类类似。

3.继承

先看一下call和prototype方式实现继承。

function BMW(sColor,iDoors,iMpg,len){
    Car.call(this,sColor,iDoors,iMpg); //继承父类Car的属性，可以是一部分. 详见aguments对象可实现重载
    this.len = len;  //子类自有属性
};
BMW.prototype = new Car();  //获得父类Car的所有方法
BMW.prototype.showLen = function(){  //子类自有方法
    alert(this.len);
};
var x5 = new BMW("green",4,35,5);
x5.showColor(); 
x5.showLen();   //结果弹出"green","5"

• 上面代码第2行使用了call继承父类Car的属性。

原理：call方法的用法是func.call(obj,args)，使obj可以调用本不是自己的方法func，从而改变this，args是参数。与它类似的是apply方法，只是传参时参数是数组形式。

• 代码第5行使用了prototype继承父类所有方法。

原理：对象的任何属性和方法都被传递给那个对象的所有实例。子类的prototype设置成父类的实例，就继承了父类的所有属性和方法。但子类的 prototype 属性被覆盖了，原来的方法不复存在，所以子类自有属性需要在prototype设置之后添加。

继承的顺序：

上面的代码是先使用call继承属性，同时添加自有属性，再使用prototype继承方法，最后添加自己方法。不要疑惑这个顺序会产生覆盖。如果第5行改为BMW.prototype = new Car('yellow',3,25)才会覆盖。原因是JS的aguments对象，它的特性就不在这里细说了，可以利用它实现函数重载。其实使用call并没有继承到父类的任何属性，因为父类构造函数的参数undefined，父类实例中并没有添加上前几个几个属性，drivers属性有。

call和prototype的区别：

这里将父类实例赋给子类prototype有明显限制，引用类型成员在子类中以浅拷贝的方式存在，即一个子类修改引用类型成员，其他类都会受到影响。而call方式没有这个问题，只是每次都产生副本。

显而易见，call方法可以方便的实现多继承，而原型链方法不能支持多继承。

另外，call方法继承可以获取父类的一部分属性，而prototype继承只是全盘接收。

最后一点也相当重要，instanceof可以识别prototype继承，也就是下面两行代码结果都是真。

alert(x5 instanceof BMW);
alert(x5 instanceof Car);

另一种安全的继承：复制继承

把属性复制都新对象上，是对象的深拷贝。当然也可以区分父类自有属性和继承属性，有取舍的复制。

var foo = {};
var prop;
for(prop in props){
     if(!foo[prop]){
           foo[attr] = obj[attr];
     }
}

再谈原型继承

上面的

BMW.prototype = new Car();

如果换成

BMW.prototype = Car.prototype;

会有什么不一样呢？

如果直接把prototype赋值给子类，子类中改变引用类型的属性会影响到父类。而实例是通过分配空间，构造出来的个体，不会出现这种情况。看下面的例子：

　　　　　　 function People(){}
            People.prototype.name = 'human';
            People.prototype.hi = function(msg){
                console.log(msg);
            }

            var Student = function(){};
            //Student.prototype = new People();
            Student.prototype = People.prototype;

            var stu = new Student();
            stu.hi && stu.hi('stu');
            Student.prototype.hi = {};
            People.prototype.hi('people');   //不是一个函数

ES5支持的Object.create()方法。其特点是洁净继承，和方式2相比，没有实例化父类这一步，而是使用一个新对象，把父类的原型复制给新对象的原型。

模拟Object.create()：

function create(proto){ //要继承的父类的原型
　　function F(){};
　　F.prototype = proto; 　　
   return new F(); 
}

var student = create(People.prototype);