JS繼承的實現

JS繼承的實現

繼承的概念：繼承的是對象，對象具有三大特徵：（封裝、繼承、多態），繼承的是屬性和行爲。
要實現繼承，首先我們需要有一個父類，代碼如下：

function Animal(){
	//在其中寫關於父類這一類的特徵和行爲
	this.name=null;
            this.AnimalColor=null;
            this.sex=null;
            this.age=null;
            this.type=null;
            this.sleep=function (){
            return this.name+"會睡覺";
}

原型鏈追加（繼承） 給原型方法裏面追加屬性和行爲

Animal.prototype.eat=function (){
            return this.name+"會吃飯";
        }

定義一個子類對象

function Cat(){
            this.catchMouse=function (){
                return this.name+"抓老鼠";
            }
        }

1.原型鏈繼承
原理：將父類的實例作爲子類的原型繼承

		var a=new Animal();//實例對象，實例化父類對象
        Cat.prototype=a;
        Cat.prototype.speed=function (){
            return 5.0;
        }

		var c=new Cat();//實例化子類對象，此時子類就繼承了父類的屬性和行爲
        c.name="小花";
        c.type="貓科";
        c.AnimalColor="白家黑";
        c.age="2";
        c.sex="母";

優缺點：
優：簡單，易於實現，父類新增屬性，行爲，子類都能訪問到
缺：要給子類追加屬性，行爲，只能放在實例化語句之後，且無法多繼承，無法向構造函數傳參。

2.構造函數
原理：將父類的實例複製給子類
先定義一個父類，代碼如下：

function Animal(name,color,sex,age,type){
            /*動物類有什麼特徵和行爲*/
            this.name=name;
            this.AnimalColor=color;
            this.sex=sex;
            this.age=age;
            this.type=type;
            this.sleep=function (){
                return this.name+"會睡覺";
            }
        }
        Animal.prototype.solo=function (){
            return "哈哈"
        }
        function rou(name){
            this.name=name;
            this.eat=function (){
                return this.name+"吃肉";
            }
        }

定義一個子類

function Cat(name,color,sex,age,type){
           /* call apply  在args上有區別   call 序列傳參  apply  爲數組傳參，即寫成數組*/
            Animal.call(this,name,color,sex,age,type);
           /* Animal.apply(this,[1,2,3,4,5]);*/
            /*this.name=name;*/

            rou.apply(this,[name]);

        }
        var c=new Cat("小貓","白色","母",2,"貓");//實例子類

優缺點：
優：可以實現多繼承
缺：無法繼承父類新增的屬性和行爲

3.實例繼承
原理：子類直接指向父類
先去定義一個父類對象

function Animal(){
            /*動物類有什麼特徵和行爲*/
            this.name=null;
            this.AnimalColor=null;
            this.sex=null;
            this.age=null;
            this.type=null;
            this.sleep=function (){
                return this.name+"會睡覺";
            }
        }
        Animal.prototype.speed=function (){
            return 5.0;
        }

定義一個子類

function Cat(){
            var a=new Animal();//a直接實例到了父類，且返回給了子類，相當於子類直接指向父類
            a.name="小貓";
            return a;

        }
        var c=new Cat();

優缺點：
優：不限制調用方式
缺：實例是父類的實例，不是子類的實例。

4.組合繼承
原理：組合原型鏈和構造繼承的優點
先去定義一個父類

function Animal(){
            /*動物類有什麼特徵和行爲*/
            this.name=null;
            this.AnimalColor=null;
            this.sex=null;
            this.age=null;
            this.type=null;
            this.sleep=function (){
                return this.name+"會睡覺";
            }
        }
        Animal.prototype.speed=function (){
            return 5.0;
        }
        function rou(){
            this.eat=function (){
                return "吃肉";
            }
        }
        //定義一個子類對象
        function Cat(){
            Animal.call(this);
            rou.call(this);
        }
        Cat.prototype=new Animal();
        var c=new Cat();

優缺點：
優：二者的優點結合。
缺：生成了兩個實例，消耗內存。

5.單例模式
單例模式的思路：一個類能返回一個對象的引用（並且永遠是同一個）和一個獲得該實例的方法（靜態方法，通常使用 getInstance 名稱）。那麼當我們調用這個方法時，如果類持有的引用不爲空就返回該引用，否者就創建該類的實例，並且將實例引用賦值給該類保持的那個引用再返回。同時將該類的構造函數定義爲私有方法，避免其他函數使用該構造函數來實例化對象，只通過該類的靜態方法來得到該類的唯一實例。

var data=(function (){ //唯一的對象
            function student(){
                this.name="小明"
            }
            function getStuinfo(){
                var s=new student();
                return s;
            }
            return {
                info:getStuinfo()
            }
        })();
        console.log(data);