ES6继承

 // ES6继承
    //父类 People
    class People{
        constructor(name,age,sex){
            this.name=name;
            this.age=age;
            this.sex=sex;
        }
        say(){
            console.log(this.name+'hello')
        }
    }

    var xiaoming=new People("小明",22,"男");
    // xiaoming.say()

    //子类 Man
    class Man extends People{
        // 子类可以不写构造函数，写就一定要写上supper
        constructor(name,age,sex){
            super(name,age,sex);
            // this.name=name;//this不允许出现在supper前面
         }
        // 重写say()方法
        say() {
            super.say();//调用父类的say()方法
            console.log(this.name+"hello子类")
        }

        Manfun(){
            console.log(this.name+'我是子类')
        }
    }
    var xiaogang=new Man("小刚",5,"男");
    // console.table(xiaogang);
    xiaogang.say();
    xiaogang.Manfun();

二、构造继承

//People 父类
    function Father(name,age,sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    Father.prototype.say=function () {
        console.log(`my name is ${this.name}`);
    };
    //Son 子类    构造继承   核心：使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）
    //     特点：
    //
    // 解决了1中，子类实例共享父类引用属性的问题
    //     创建子类实例时，可以向父类传递参数
    //     可以实现多继承（call多个父类对象）
    // 缺点：
    //
    // 实例并不是父类的实例，只是子类的实例
    //     只能继承父类的实例属性和方法，不能继承原型属性/方法
    function Son(name,age,sex) {
        Father.call(this,name,age,sex)
    }

原型继承

    //People 父类
    function Father(name,age,sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    Father.prototype.say=function () {
        console.log(`my name is ${this.name}`);
    };
     //Brother 子类    原型继承   核心： 将父类的实例作为子类的原型
    //         特点：
    //
    // 非常纯粹的继承关系，实例是子类的实例，也是父类的实例
    //         父类新增原型方法/原型属性，子类都能访问到
    //         简单，易于实现
    //         缺点：
    //
    // 要想为子类新增属性和方法，必须要在new Animal()这样的语句之后执行，不能放到构造器中
    //         无法实现多继承
    //         来自原型对象的所有属性被所有实例共享（来自原型对象的引用属性是所有实例共享的）（详细请看附录代码： 示例1）
    // 创建子类实例时，无法向父类构造函数传参
    //     无法实现函数复用，每个子类都有父类实例函数的副本，影响性能
    function Brother() {

    }
    Brother.prototype=new Father();

实例继承

    //People 父类
    function Father(name,age,sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    Father.prototype.say=function () {
        console.log(`my name is ${this.name}`);
    };
    //实例继承   核心：为父类实例添加新特性，作为子类实例返回
    //     特点：
    //
    // 不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
    //     缺点：
    //
    // 实例是父类的实例，不是子类的实例
    //     不支持多继承
    function Sister(name,age,sex) {
          var insetance=new Father();
           insetance.name=name;
           insetance.age=age;
           insetance.sex=sex;
        return insetance;
    }

组合继承

    //People 父类
    function Father(name,age,sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    Father.prototype.say=function () {
        console.log(`my name is ${this.name}`);
    };
     //Grandson子类  组合继承  核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用
    //     特点：
    //
    // 弥补了方式2的缺陷，可以继承实例属性/方法，也可以继承原型属性/方法
    //     既是子类的实例，也是父类的实例
    //     不存在引用属性共享问题
    //     可传参
    //     函数可复用
    //     缺点：
    //
    // 调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）
    function Grandson(name,age,sex) {
        Father.call(this,name,age,sex);
    }
    Grandson.prototype=new Father();