摘要：也就是說(shuō)，并不知道，等是屬于哪個(gè)對(duì)象的哪個(gè)構(gòu)造函數(shù)或者類。構(gòu)造函數(shù)模式與原型模式相結(jié)合的模式。給新建的對(duì)象，添加屬性，建立與構(gòu)造函數(shù)之間的聯(lián)系。另一種就是構(gòu)造函數(shù)繼承了。

前面講完原型鏈，現(xiàn)在來(lái)講繼承，加深理解下。

什么是對(duì)象？ 就是一些無(wú)序的 key : value 集合， 這個(gè)value 可以是 基本值，函數(shù)，對(duì)象。(注意 key 和 value 之間 是冒號(hào) : ,每個(gè) key : value 之間 是逗號(hào) , )

var person = {
    name: "zdx",
    age: 18,
    get: function(){
        return "名字：" + this.name + "年紀(jì)：" + this.age;
    }
}

這時(shí)的 person 就是一個(gè)對(duì)象

讀取對(duì)象的屬性，有兩種方式：點(diǎn) 和 [" "]，（使用中括號(hào)，里面是有引號(hào)的）

person.name   //"zdx"
person["age"]    //18

之前說(shuō)過(guò)，對(duì)象的創(chuàng)建 有三種 方式： 字面量，new，Object.create；

但是，這種簡(jiǎn)單的創(chuàng)建，并不能滿足，我們實(shí)際開(kāi)發(fā)的要求。

比如，每個(gè)人的名字，年紀(jì)不一樣，我們不可能，每個(gè)人都寫一個(gè)對(duì)象，那不得炸了。

var personA = {
    name: "A",
    age: 28
}

var personB = {
    name: "B",
    age: 22
}

所以，這時(shí)候，我們就需要一些創(chuàng)建模式。

工廠模式呢，就是我們寫一個(gè)方法，然后通過(guò)這個(gè)方法復(fù)制出我們需要的對(duì)象。我們需要多少個(gè)，就復(fù)制多少個(gè)。(注意這里是用方法（函數(shù)） 來(lái)生成對(duì)象)

var createPerson = function(name,age){
    var obj = {},
    obj.name = name,
    obj.age = age
}

然后我們就可以這樣使用了。

var personA = createPerson("A", 28);
var personB = createPerson("B", 22);

但是呢，這種模式，創(chuàng)建的對(duì)象，無(wú)法歸類。也就是說(shuō)，并不知道 personA，personB 等 是 屬于哪個(gè)對(duì)象的（哪個(gè)構(gòu)造函數(shù)或者類）。

具有相同特性的一類事物，把它總結(jié)成一個(gè) 類；比如，人類，有男人，女人，小孩。把他們總結(jié)成了人類。

比如:

var obj = {};
obj instanceof Object;    //true
//instanceof  方法 可以判斷 前者是否是 后者的實(shí)例對(duì)象

var arr = [];
arr instanceof Array;    //true

于是，構(gòu)造函數(shù)模式來(lái)了。

要想知道，男人，女人 屬于什么類， 人類？ 獸類？ 這時(shí)候就需要 構(gòu)造函數(shù)（類）了。

function Person(name, sex){     //注意，我們通常把構(gòu)造函數(shù)（類）的首字母大寫！
    this.name = name;
    this.sex = sex;
}
var personA = new Person("張三", "男");
var personB = new Person("李四", "女");

console.log( personA instanceof Person );    //true
console.log( personB instanceof Person );    //true

這時(shí)候 創(chuàng)建出來(lái)的對(duì)象， 就知道 它屬于哪個(gè)構(gòu)造函數(shù)（類）了。

這里為啥用了 this 呢？new 一個(gè)函數(shù)， 為啥會(huì)創(chuàng)建出 一個(gè)實(shí)例對(duì)象（我們把 new 出來(lái)的對(duì)象 稱為 實(shí)例對(duì)象，簡(jiǎn)稱實(shí)例）呢？

這步，之前的原型鏈中說(shuō)過(guò)，如果你懂了，可以簡(jiǎn)單過(guò)一眼，增強(qiáng)記憶。

這個(gè)呢，就要理解new 到底干了啥呢：

新建一個(gè)對(duì)象；

將該對(duì)象，即實(shí)例指向構(gòu)造函數(shù)的原型；

將構(gòu)造函數(shù)的this，指向該新建的對(duì)象；

返回該對(duì)象，即返回實(shí)例。下面，手寫一個(gè)方法 實(shí)現(xiàn)new 的功能。

function New(func){    //func 指?jìng)鬟M(jìn)來(lái)的構(gòu)造函數(shù)
    var obj = {};   //這里就直接新建一個(gè)空對(duì)象了，不用new Object了，效果一樣的，因?yàn)槲腋杏X(jué)這里講實(shí)現(xiàn)new的功能   再用 new 就不太好。
    
    if(func.prototype != null){
        obj.__proto__ = func.prototype;
    }
  
    func.apply(obj,Array.prototype.slice.call(arguments, 1));
    //把func構(gòu)造函數(shù)里的this 指向obj對(duì)象（你可以理解成func構(gòu)造函數(shù)的this 替換成 obj對(duì)象）；
    //Array.prototype.slice.call(arguments, 1)；這個(gè)就是把New 函數(shù)，func 之后傳進(jìn)來(lái)的參數(shù)，轉(zhuǎn)成數(shù)組。
   //把該參數(shù)數(shù)組，傳入func構(gòu)造函數(shù)里，并執(zhí)行func構(gòu)造函數(shù)，比如：屬性賦值。

    return obj;
    
}

驗(yàn)證下：

function Person(name, sex){
    this.name = name;
    this.sex = sex;
    this.getName = function(){
        return this.name;
    }
}

var p = New(Person,"周大俠啊", "男");

console.log( p.getName() );   //"周大俠啊"

console.log( p instanceof Person );    //true

去掉new 的寫法就是這樣：

function Person(name, sex){
    var obj = {};
    obj.__proto__ = Person.prototype;
    obj.name = name;
    obj.sex = sex;
    obj.getName = function(){
        return obj.name;
    }
    return obj;
}

var p = Person("周大俠啊", "男");

console.log( p.getName() );   //"周大俠啊"

console.log( p instanceof Person );    //true

使用 new 就簡(jiǎn)化了步驟。

這種模式，也有弊端，你看出來(lái)了嗎？ 有木有發(fā)現(xiàn)，每個(gè)實(shí)例對(duì)象 都有 相同 的 getName 方法，這樣，是不是就但占資源了呢，100個(gè)實(shí)例對(duì)象，就新建了 100 個(gè) getName 方法。

原型模式開(kāi)始！

之前的原型鏈說(shuō)過(guò)，屬性、方法的讀取是沿著原型鏈查找的，也就是說(shuō)，在構(gòu)造函數(shù)的原型對(duì)象上 創(chuàng)建的 屬性、方法，它的實(shí)例對(duì)象都能夠使用。

function Person(){};
Person.prototype.name = "周大俠啊";
Person.prototype.sex = "男";
Person.prototype.getName  = function(){
    return Person.prototype.name;
}

var p = new Person();
console.log( p.getName() );   //"周大俠啊"
console.log( p.hasOwnProperty("getName") );   //false   getName 不是 p實(shí)例的屬性

這樣，創(chuàng)建的實(shí)例對(duì)象 都能使用 getName ，并且，也不會(huì)給每個(gè)實(shí)例對(duì)象，添加該屬性。

不過(guò)，你發(fā)現(xiàn)了嗎，這樣創(chuàng)建的實(shí)例對(duì)象，都是固定的屬性值， 一更改，所有的實(shí)例對(duì)象獲取的值，也都改變了。

那么說(shuō)了半天，這都是啥呢，別急，正因?yàn)樯厦孀龅匿亯|，才有更好的 方法。我覺(jué)得，眼尖的同學(xué)，可能已經(jīng)知道了。

構(gòu)造函數(shù)模式 與 原型模式 相結(jié)合的模式。

構(gòu)造函數(shù)模式，可以創(chuàng)建 每個(gè) 實(shí)例對(duì)象 自己的屬性， 而原型模式，可以共享，同一個(gè)方法。

所以，我們一般，把對(duì)象自己的屬性、方法 ，用構(gòu)造函數(shù)模式創(chuàng)建； 公共的方法，用原型模式 創(chuàng)建。

function Person(name, age){
    this.name = name;
    this.age = age;
}

Person.prototype.getName = function(){
    return this.name;
}

var p = new Person("周大俠啊", 22);
p.getName();

這樣就可以完美的創(chuàng)建對(duì)象了。

要是你有余力，可以想想，這里的 this.name 中 this 是怎么回事。

但是，上面這個(gè)還可以優(yōu)化，要是 Person.prototype 上有很多方法， 這種寫法就很不好，一般，我們用這種寫法：

function Person(name, age){
    this.name = name;
    this.age = age;
}
//新建一個(gè)對(duì)象，給該對(duì)象添加 方法， 然后把該對(duì)象 賦值給Person.prototype ，該對(duì)象就成為 Person （構(gòu)造函數(shù)）的原型對(duì)象了。

Person.prototype = {
    constructor : Person,   //給新建的對(duì)象，添加constructor 屬性，建立與構(gòu)造函數(shù)之間的聯(lián)系。
    getName : function(){
        return this.name;
    },
    getAge : function(){
        return this.age;
    }
}

var p = new Person("周大俠啊", 22);

p.getName();

這里的 this 又看懂是怎么回事了嗎？ 那我就簡(jiǎn)單說(shuō)一下 this 的知識(shí)吧。

關(guān)于 this 估計(jì)都聽(tīng)說(shuō)過(guò) 誰(shuí)調(diào)用它，this就指向誰(shuí)，這種說(shuō)法，不嚴(yán)謹(jǐn)，this 的指向，是 在函數(shù)調(diào)用（運(yùn)行）時(shí)確定的！

上面的:

Person.prototype = {
    constructor : Person, 
    getName : function(){
        return this.name;
    },
}
var p = new Person("周大俠啊", 22);
p.getName();

this 在getName 函數(shù)里，而getName 真正運(yùn)行 的地方 是 p.getName，p 是調(diào)用者，所以， this 就指向 p（換句話說(shuō)，這時(shí)的this 就是 p）。

你要理解 精髓， 函數(shù)調(diào)用（運(yùn)行）時(shí) 確定的調(diào)用者 之間的關(guān)系。

看這個(gè)：

var a = 10;
var b = {
    a : 20,
    say : function(){
        console.log(this.a);
    }
}

var c = b.say;
c();    //10   非嚴(yán)格模式下，獨(dú)立調(diào)用（無(wú)調(diào)用者）this 指向全局對(duì)象

包含 this 的函數(shù) 正在調(diào)用（運(yùn)行） 的時(shí)候 是 c(); 此時(shí)，無(wú)調(diào)用者，指向全局對(duì)象。

上面做了辣么多鋪墊，終于要開(kāi)始繼承的講解啦！什么是繼承呢，其實(shí)呢，就是你 想要使用 別人的屬性，或者方法； 這時(shí)候就要利用繼承來(lái)實(shí)現(xiàn)。

既然是 得到別人的屬性，方法，就是繼承，那么不就是 除了 Object.prototype 其他都是繼承了？ dui ！ 你說(shuō)的沒(méi)錯(cuò)...哈哈

所以，繼承的一種就是基于 原型鏈的了 ，就是屬性的查找，讀取。

另一種就是 構(gòu)造函數(shù)繼承了。

首先來(lái)一個(gè)需要被繼承的目標(biāo)

//父類：
function Person(name) {
    this.name = name;
}

Person.prototype = {
    constructor: Person,
    getName : function() {
        return this.name;
    }
}

//子類：
function Son(name, age) {   
    Person.call(this, name);    //call 方法，把前面函數(shù)的this 指向 給定的對(duì)象，第二個(gè)參數(shù)開(kāi)始，傳入 參數(shù)，并執(zhí)行函數(shù)。
    this.age = age;
}

//就相當(dāng)于
function Son(name, age) {
    //Person(name); 此時(shí) Person 里的 this  等于當(dāng)前的this
    this.age = age;
}

//等同于
function Son(name, age) {
    this.name = name,
    this.age = age
}

下面檢驗(yàn)一下：

var s1 = new Son("周大俠啊", 22);
console.log(s1.name);  //"周大俠啊" 
console.log(s1.getName());   //報(bào)錯(cuò)，這是Person原型對(duì)象上的方法

這種是，new 一個(gè)父類實(shí)例，然后把son.prototype 添加到原型鏈上去。

//new 一個(gè) Person 實(shí)例 賦給 Son.prototype
Son.prototype = new Person();

//給子類的原型加方法：
Son.prototype.get = function() {
        return this.name + this.age;
}

上面的 Son.prototype = new Person() 實(shí)際上就是這樣的

//內(nèi)部就是
var obj = {};

obj.__proto__ = Person.prototype;

Son.prototype = obj

//把 obj 賦給 Son.prototype 。而obj 這個(gè)實(shí)例  又指向了Person的原型對(duì)象，
//這樣，Son 就添加到了 Person 的原型鏈上了。

所以：

//給子類的原型加方法：
Son.prototype.get = function() {
        return this.name + this.age;
} 

//就是:
obj.get = function(){    //通過(guò)給obj添加方法 然后賦值給Son的原型對(duì)象
    return this.name + this.age;
};

驗(yàn)證：

var s2 = new Son("周大俠啊", 22);

console.log(s2.get());  //"周大俠啊22" 

console.log(s2.getName());   //"周大俠啊"

function create(proto, options){     //proto表示父類的原型對(duì)象，options表示給子類添加的屬性
    var obj = {};
    obj.__proto__ = proto;
    return Object.defineProperties(obj,options);    //Object.defineProperties方法直接在一個(gè)對(duì)象上定義新的屬性或修改現(xiàn)有屬性，并返回該對(duì)象。所以這里就直接return了
    }
    
//繼承  就這樣寫了
Son.prototype = create(Person.prototype,{
    constructor: {    //這種格式的賦值寫法， 是 defineProperties 方法規(guī)定的寫法。
        value: Son
    },
    get: {
        value: function(){
            return this.name + this.age;
        }
    }
})

//驗(yàn)證一下
var s3 = new Son("zdx",22);

console.log(s3.getName());     //"zdx"

console.log(s3.get());         //"zdx22"

Object.defineProperties具體用法點(diǎn)這里

這里是它具體用法

可以直接使用它來(lái)完成繼承：

Son.prototype = Object.create(Person.prototype,{
    constructor: {
        value: Son
    },
    get: {
        value: function(){
            return this.name + this.age;
        }
    }
})

//驗(yàn)證一下
var s4 = new Son("zdx",22);

console.log(s4.getName());     //zdx

console.log(s4.get());         //zdx22