js继承

js里面的继承

概念 ：继承  子类继承父类
做面向对象的开发以及框架库的封装
 面向对象 有三大特征： 封装  继承  多态
子类继承父类  
**第一种方式**   **原型链继承**
其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。
核心： 将父类的实例作为子类的原型
其代码大致如下：

// 定义一个动物类
function Animal() {
// 属性
        this.name = null;
        this.sex = null;
        // 实例方法
        this.sleep = function () {
            return "睡觉";
        };
        this.eat = function () {
            return "吃";
        }
    }
    function Dog() {
        this.type = "犬科";
    }
    //原型链继承  继承完成之后  在__proto__里面
    Dog.prototype = new Animal();

    /*
     * 原型链追加
      */
    Dog.prototype.color = "red";
    var dog = new Dog();
    /*检测对象的类型的*/
    console.log(typeof dog);
    //确定原型和实例的关系
    console.log(dog instanceof Dog);//true
    console.log(dog instanceof Animal);//true
    console.log(dog);

特点
非常纯粹的继承关系，实例是子类的实例，也是父类的实例
父类新增原型方法/原型属性，子类都能访问到
简单，易于实现
缺点
要想为子类新增属性和方法，必须要在new Animal()这样的语句之后执行，不能放到构造器中无法实现多继承
创建子类实例时，无法向父类构造函数传参
第二种：构造继承
在解决原型中包含引用类型值所带来问题的过程，开始使用构造函数，这种技术其思想相当简单，即在子类型构造函数的内部调用超类型构造函数。
核心：使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）
通过使用call()和apply()方法可以在新创建的对象上执行构造函数。

function People() {
        this.name = arguments[0];
        this.sex = arguments[1];
        this.eat = function () {
            return this.name + "正在吃饭！";
        }
    }

    function Student() {
        this.score = arguments[0];
        this.writezuoye = function () {
            return this.name + "写作业";
        }
    }
    //构造继承不能继承父类的原型方法和属性
    Student.prototype.work = function () {
        return this.name + "跑步";
    }

    function smallchildren(name, sex, score) {
        /* People.call(this,name,sex);*/
        People.apply(this, [name, sex]);
        Student.call(this, score);
    }
    var small = new smallchildren("毛豆", "男", 487);
    console.log(small instanceof  People);//false
    console.log(small instanceof  smallchildren);//true实例是自身的实例，不是父类的实例
    console.log(small);
    console.log(small.eat());
    console.log(small.writezuoye());

特点
创建子类实例时，可以向父类传递参数
可以实现多继承（call多个父类对象）
缺点
实例并不是父类的实例，只是子类的实例
只能继承父类的实例属性和方法，不能继承原型属性/方法
无法实现函数复用，每个子类都有父类实例函数的副本，影响性能
第三种：实例继承
new对象返回对象，不能实现多继承

function f1() {
        this.name = null;
        this.sleep = function () {
            return "睡觉";
        }
    }

    function f2() {
        var f = new f1();
        return f;
    }
    var fchild = new f2();//调用的方法不限
    // var ff = f2();
    console.log(fchild);
    console.log(fchild instanceof f2);//false
    console.log(fchild instanceof f1);//true

   

特点
不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
缺点
实例是父类的实例，不是子类的实例
第四种：组合继承

function Mutou() {
        this.name = arguments[0];
        this.make = function () {
            return "制作" + this.name;
        }
    }

    function Bandeng(name) {
        Mutou.call(this, name);
    }
    Bandeng.prototype = new Mutou();
    var ban = new Bandeng("板凳");
    console.log(ban);
    console.log(ban.make());
    console.log(ban instanceof Bandeng);
    console.log(ban instanceof Mutou);

特点
弥补了第二种 的缺陷 去弥补原型链继承和构造继承的缺点
缺点
生成了两个实例，消耗内存；