【JavaScript】难点1-继承

一、创建对象

1、工厂模式

用函数来封装以特定接口创建对象的细节

function createPerson (name,age,job) {    var o = new Object();    o.name = name;    o.age = age;    o.job = job;    o.sayName = function () {        alert(this.name);    };    return o;}var person = createPerson("vicky",20,"student");

缺点：没有解决对象识别的问题。

2、构造函数模式

function Person (name,age,job) {    this.name = name;    this.age = age;    this.job = job;    this.sayName = function () {        alert(this.name);    };}var person = new Person("vicky",20,"student");

注：
        1、任何函数只要通过new操作符调用，就可以作为构造函数；
        2、问题：每个方法都要在实例上重复一遍。

3、原型模式

function Person(){}Person.prototype.name = "vicky";Person.prototype.age = 20;Person.prototype.job = "student";Person.prototype.sayName = function () {    alert(this.name);};var person = new Person();

无论什么时候，只要创建了一个心函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象，原型对象都有要给constructor属性指向prototype属性所在的函数。

每当代码读取某个对象的某个属性时，都会执行一次搜索，搜索首先从对象实例本身开始，若找不到，则搜索指针指向的原型对象。
使用对象字面量来定义原型：

function Person () {}Person.prototype = {    constructor:Person,    name:"vicky",    age:20,    job:"student",    sayName:function () {        alert(this.name);    }}

使用对象字面量，使得construtor不在指向Person构造函数，所以，在需要的时候可以以显示的设置constructor属性

问题：
        1、省略掉了为构造函数传递初始化参数，使得所有实例在默认情况下都取得相同的属性值；
        2、属性共享。

4、组合模式 (最常用*)

组合使用构造函数模式和原型模式，使用构造函数定义实例属性，用原型模式定义方法和共享属性。

function Person (name,age,job) {    this.name = name;    this.age = age;    this.job = job;}Person.prototype = {    constructor:Person,    sayName:function (){        alert(this.name);    }   }

5、动态原型模式

把所有信息都封装在构造函数中，通过在构造函数中初始化原型。

function Person (name,age,job) {    this.name = name;    this.age = age;    this.job = job;    if(typeof this.sayName!="function"){        Person.prototype.sayName = function () {             alert(this.name);        };    }}

6、寄生构造函数

创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象。

function Person (name,age,job) {    var o = new Object();    o.name = name;    o.age = age;    o.job = job;    o.sayName = function () {         alert(this.name);    };    return o;}

构造函数返回的对象与在构造函数外部创建的对象没有什么不同，不推荐使用。

7、稳妥构造函数模式

稳妥对象：没有公共属性，且其方法也不引用this对象。
与寄生构造函数类似，不同之处：
1、新创建对象的实例方法不引用this；
2、不使用new调用构造函数

二、继承

依靠原型链实现继承

1、原型链

利用原型让一个引用类型继承另一个引用类型的属性和方法

        function SuperType () {            this.value = "super";        }        SuperType.prototype.getSuperValue = function () {            return this.value;        };        function SubType () {            this.subValue = "sub";        }        SubType.prototype = new SuperType ();//继承父类        SubType.prototype.getSubValue = function () {            return this.subValue;        }        var instance = new SubType();        console.log(instance.getSubValue());//sub        console.log(instance.getSuperValue());//super

问题：
        1、包含引用类型的原型属性会被所有实例共享；
        2、创建子类型的实例时，不能向父类的构造函数中传递参数

2、借用构造函数

基本思想：在子类型构造函数的内部调用超类型的构造函数

//借用构造函数实现继承        function Father () {            this.array = [1,2,3];        }        function Son () {            Father.call(this);        }        var instance = new Son();        instance.array.push(5);        var instance3 = new Son();        console.log(instance.array);//[1,2,3,5]        console.log(instance3.array);//[1,2,3]

通过使用call（），在新创建的子类实例的环境下调用了父类的构造函数

问题：方法都在构造函数中定义，因此函数无法复用。

3、组合继承

思路：使用原型链实现对原型共享属性和方法的继承，使用借用构造函数来实现对实例属性的继承

        function Super (name) {            this.name = name;            this.array = [1,2,3];        }//父类        Super.prototype.sayName = function () {            console.log(this.name);        };//父类原型的方法        function Sub (name,age) {            Super.call(this,name);//继承父类属性            this.age = age;        }//子类        Sub.prototype = new Super();//继承父类方法        Sub.prototype.constructor = Sub();        Sub.prototype.sayAge = function () {            console.log(this.age);        };        var a = new Sub("vicky",20);        a.array.pop(1);        a.sayName();//vicky        a.sayAge();//20        var b = new Sub("jay",37);        console.log(b.array);//[1,2,3]        console.log(a.array);//[1,2]

4、原型式继承

function object(o) {    function F(){}    F.prototype = o;    return new F();}

    var Chinese = {　　　　nation:'中国'　　};    function object (o) {        function F() {}        F.prototype = o;        return new F();    }    var Student = object(Chinese);    Student.job = "xuesheng";    alert(Student.nation);//“中国”

先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回了这个临时类型的新实例。

5、寄生式继承

创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真的是它做了所有工作一样返回对象

function createAnother(original) {    var clone = Object(original);    clone.sayHi = function (){         console.log("hi");    };    return clone;}

6、寄生组合式继承

通过借用构造函数来继承属性，通过原型链来继承方法

function inheritPrototype (subType,superType){    var prototype = object(superType.prototype);    prototype.constructor = subType;    subType.prototype = prototype;}