js面向对象中的继承

继承含义：通过某种方式，让一个对象能够访问并使用另一个对象中的内容
继承作用：节省了构造函数中大量重复声明的属性和方法，提高了开发效率；节省了内存空间，提高了性能。

1、原型链继承：
将父类的实例化对象赋值给子类的原型
所以，父类所有的属性和方法都可以被所有子类共享
　　重点：让新实例的原型等于父类的实例。
　　特点：构造函数和原型中的所有数据都可以获取。
实例可继承的属性有：实例的构造函数的属性，父类构造函数属性，父类原型的属性。（新实例不会继承父类实例的属性！）
　　缺点：
　　（1）新实例无法向父类构造函数传参。原型链继承自身没有办法传参
　　（2）继承单一。
　　（3）所有新实例都会共享父类实例的属性。（原型上的属性是共享的，一个实例修改了原型属性，另一个实例的原型属性也会被修改！）

<script>
      //父类
        function Person(name,age){
            this.name = name;
            this.age = age;
        }
         
        //实例化父类
        let person = new Person();
        // 下面父类实例person的属性，子类不会继承
        person.name = "tom";
        person.age = 20;
        //添加父类原型对象的方法
//直接给原型赋值一个对象，可以简化批量赋值。等于重构了原型
        //重构原型时，需要手动创建constructor: 构造函数。  否则原型的指向链条会断
        Person.prototype = {
            constructor:Person,
            run : function(){
            console.log("跑步");
        }
        //子类
        function Child(name,age,sex){
             this.name = name;
             this.age = age;
             this.sex = sex;
        }
        
        Child.prototype = new Person(); //继承父类
        let chi = new Child("child01","nan","26"); //实例化子类
        console.log(chi.name);
        chi.run();
        
      // instanceof判断子类是否在父类的原型链上，是返回true，否则返回false
        console.log(chi instanceof Person);//true
       
    </script>

2、构造函数继承
　 通过call和apply，实现构造函数的继承
重点：用.call()和.apply()将父类构造函数引入子类函数
特点：
（1）只继承了父类构造函数的属性，没有继承父类原型的属性。
　（2）解决了原型链继承的三个缺点
（3）可以继承多个构造函数属性（call多个）。
（4）在子实例中可向父实例传参。
　 缺点：
　 （1）只能继承父类构造函数的属性。
　 （2）无法实现构造函数的复用。（每次用每次都要重新调用）
　 （3）每个新实例都有父类构造函数的副本，臃肿。
　
// call()方法
// 语法格式：obj1.call(obj2[,param1,param2,…])
// 定义：用obj2对象来代替obj1，调用obj1的方法。即将obj1应用到obj2上。
// 说明：call 方法可以用来代替另一个对象调用一个方法。
call 方法可将一个函数的对象上下文从初始的上下文改变为由 obj2 指定的新对象。
如果没有提供 obj2参数，那么全局对象被用作 obj2。

// apply()方法
// 语法格式：obj1.call(obj2[,arrArg])
// 定义：用obj2对象来代替obj1，调用obj1的方法。即将obj1应用到obj2上。
// 说明：call ()和apply()作用一样，但是call()可以接收任何类型的参数，而apply()只能接收数组参数。

// call与apply的对比：
// 相同点：
// 都是借用对象，作用都是在特定的作用域中调用函数,能改变函数的作用域，
// 实际上是改变函数体内 this 的值 。
// 不同点：
// call()接收参数时，数量根据被借者需要的参数而定，任何类型的参数
// apply()只有两个参数，借用者和数组(存放所有的参数)

<script>
        function fn() {
            console.log(this);
        }
        function Animal(name, sex) {
            this.name = name;
            this.sex = sex;
            this.jiao = function () {
                console.log(this);
            }
        }
        let obj = new Animal("猴子", "公");
        fn();//this指点window
        fn.call(obj, "大象", "公");//Animal {name: "猴子", sex: "公", jiao: ƒ}
//子类
        function Tiger(name, sex, age, hobby) {
            // this.name = name;
            // this.sex = sex;
            // this.jiao = function(){
            //     console.log(this);
            // }
            Animal.call(this, name, sex);
            //使用call()继承Animal对象,以上注释掉的重复的属性及方法就可以省略不写
            this.age = age;
            this.hobby = hobby;
        }
        
//子类的子类
        function Smalltiger(name, age, sex, hobby) {
            // Tiger.call(this,name,age,sex,hobby);
            let arr = [name, age, sex, hobby];
            Tiger.apply(this, arr);
        }
        let tiger = new Tiger("老虎", "10", "公", "咆哮");
        // tiger.jiao();
        console.log(tiger.name);
        let per = new Smalltiger("小老虎", "1", "母", "爬树");
        per.jiao();
        console.log(per);
    </script>

3、组合继承（原型链继承+构造函数继承）
组合继承： 类式继承，无法获取父类的原型链
原型链继承,无法直接给父类传参
重点：结合了两种模式的优点，互相弥补了各自的缺点，可传参和复用
　　特点：
　　（1）可以继承父类原型上的属性，可以传参，可复用。
　　（2）每个新实例引入的构造函数属性是私有的。
　　缺点：调用了两次父类构造函数（耗内存），子类的构造函数会代替原型上的那个父类构造函数。

  <script>
        function Car(name,year){
            this.name = name;
            this.year = year;
        }
        Car.prototype.run = function(){
                console.log("飞一般的速度");
            }
        // let car = new Car("车","2010");
        
        // 构造函数继承
        function Benchi(name,year,size){  
            //Benchi继承Car       
            Car.call(this,name,year);   
            this.size = size;
        }
        function Changan(name,year,size,color){
            //继承Benchi
            Benchi.call(this,name,year,size);
            this.color = color;
        }
       
        Benchi.prototype = new Car(); // 原型链继承
        // console.log(Benchi.prototype.constructor);
        // Benchi.prototype.constructor=Benchi;
        // console.log(Benchi.prototype.constructor);
        let benchi = new Benchi("奔驰","2012","big");
        console.log(benchi);
        benchi.run();//继承父类原型的方法
        console.log(benchi.name);//继承父类构造函数属性
        
        Changan.prototype = new Benchi();//原型链继承
        let changan = new Changan("长安","2019","middle","white");
        console.log(changan);
        changan.run();
        console.log(changan.name);
    </script>