javascript：類的介紹

一、類的三個部分

構造函數內的

這是提供是列對象複用的

var Book=function(){
    this.name="a";
    this.age=12;
}

構造函數外的

直接通過點語法添加的，實例對象訪問不到

Book.color="red";

是原型中的

實力化對象可以通過其原型鏈間接訪問到，也是爲所有實例化對象所共用的

Book.prototype.say=function(){}

或：

Book.prototype={
    say:function(){
    }
}

二、js中繼承的實現方法

js 常用的繼承方法有：原型鏈繼承（對象間的繼承）、類式繼承（構造函數間的繼承）
主要使用js的原型prototype機制或則用apply和call方式實現

1、原型式繼承與類式繼承

類式繼承實在子類型構造函數的內部調用超類型的構造函數。嚴格的類式繼承並不常見，一般組合使用

function Super(){
    this.colors=["red","blue"];
}

function Sub(){
    Super.call(this);
}

原型式繼承是藉助已有的對象創建新的對象，將子類的原型指向父類，就相當於加入了父類這條原型鏈
爲了讓子類繼承父類的屬性（也包括方法），首先需要定義一個構造函數。然而，將父類的新實例賦值給構造函數的原型。

function Parent()}{
    this.name='mike';
}
function Child(){
    this.age=12;
}
Child.prototype=new Parent();//Child繼承Parent，通過原型，形成鏈條

var test=new Child();
alert(test.age);
alert(test.name);//得到被繼承的屬性

function Brothor(){
    this.weight=60;
}
Brother.prototype=new Child();//繼續原型鏈繼承
var brother=new Brother();
alert(brother.name) //mike
alert(brother.age); //12

以上原型鏈繼承還缺少一環，那就是Object，所有的構造函數都繼承自Object。而繼承Object是自動完成的，並不需要我們手動繼承，name他們的從屬關係是怎麼樣的呢？
可以通過兩種方式確定原型與實例之間的關係，操作符，instanceof和isPrototypeof()方法：

alert(brother instanceof Object) //true
alert(test instanceof Brother) //false,test是brother的超類
alert(brother instanceof Child) //true
alert(brother instanceof Parent) //true

只要原型鏈中出現過的原型，都可以說是該原型鏈派生的實例的原型，因此，isPrototype()方法也會返回true。

在js中，被繼承的函數稱爲超類型（父類，基類也行），繼承的函數稱爲子類型（子類，派生類）。使用原型繼承主要由兩個問題：
一是字面量重寫原型會中斷關係，使用引用類型的原型，並且子類型還無法給超類型傳遞參數。

僞類解決引用共享和超類型無法傳參的問題，我們可以採用“借用構造函數”技術

2、借用構造函數（類繼承）

function Parent(age){
    this.name=["mike","jack","smith"];
    this.age=age;
}

function Child(age){
    Parent.call(this,age);
}
var test=new Child(21);
alert(test.age);//21
alert(test.name);//mike,jack,smith

借用構造函數雖然解決了剛纔兩個問題，但沒有原型，複用無從談起，所以我們需要原型鏈+構造函數的模式，這種模式稱爲‘組合繼承’

3、組合繼承

function Parent(age){
    this.name=["mike","jack","smith"];
    this.age=age;
}
Parent.prototype.run=function(){
    return this.name+' are both'+this.age;
}
function Child(age){
    Parent.call(this,age);//對象冒充給超類傳參
}
Child.prototype=new Parent();//原型鏈繼承
var test=new Child(21);
alert(test.run());//mike,jack,smith are both21

組合式繼承是比較常用的一種繼承方法，其背後的思路是使用原型鏈實現對原型屬性和方法的繼承，而通過借用構造函數來實現對實例屬性的繼承。
這樣，既通過在原型上定義方法實現了函數複用，又保證每個實例都有它自己的屬性。
call()的用法：調用一個對象的一個方法，以另一個對象替換當前對象。
call([thisObj[,arg1[, arg2[, [,.argN]]]]])

4、原型式繼承

這種繼承藉助原型並基於已有的對象創建對象，同時還不用創建自定義類型的方式稱爲 ‘原型式繼承’

function obj(o){
    function F(){};
    F.prototype=o;
    return new F();
}
var box = {
    name:'trigkit4',
    arr:['brother','sister','baba']
}
var b1=obj(box);
alert(b1.name); //trigkit4

alert(b1.arr); //brother,sister,baba
b1.arr.push('parents');
alert(b1.arr); //brother,sister,baba,parents

var b2=obj(box);
alert(b2.name); //trigkit4
alert(b2.arr); //brother,sister,baba,parents

原型式繼承首先在obj()函數內部創建一個臨時性的構造函數，
然後將傳入的對象作爲這個構造函數的原型，最後返回這個臨時類型的一個新實例。

5、寄生式繼承

這種方式是把‘原型式+工場模式’結合起來，目的是爲了封裝創建的過程

function create(o){
    var f=obj(o);
    f.run=function(){
        return this.arr;//同樣，會共享引用
    }
    return f;
}

組合式繼承的小問題

組合繼承式js繼承最常用的繼承方式，但組合繼承的超類型在使用過程中會調用兩次，一次是創建子類型的時候，一次是子類型構造
函數內部。

function Parent(name){
    this.name=name;
    this.arr=["哥哥","妹妹","父母"];
}
Parent.prototype.run=function(){
    return this.name;
}
function Child(name,age){
    Parent.call(this,age);//第二次調用
    this.age=age;
}
Child.prototype=new Parent();//第一次調用

以上代碼是之前的組合繼承，那麼寄生組合繼承，解決了兩次調用的問題

6、寄生組合繼承

function obj(o){
    function F(){};
    F.prototype=o;
    return new F();
}
function create(parent,test){
    var f = obj(parent.prototype); //創建對象
    f.constructor=test; //增強對象
}
function Parent(name){
    this.name=name;
    this.arr=['brother','sister','parents'];
}
Parent.prototype.run=function(){
    return this.name; 
}
function Child(name,age){
    Parent.call(this,name);
    this.age=age;
}
create(Parent,Child);//通過這裏實現繼承
var test=new Child('trigkit4',21);
test.arr.push('nephew');
alert(test.arr);
alert(test.run()); //只共享了方法

var test2=new Child('jack',22);
alert(test2.arr);  //引用問題解決

六、call和apply

全局函數apply和call可以用來改變函數中this的指向，如下：

function foo(){
    console.log(this.fruit);
}
var fruit="apple";
var pack={
    fruit:"orange"
}
foo.apply(window); //"apple",因此this等於window
foo.apply(pack); //"orange"

javascript：類的介紹