面向对象——继承

继承

通过“某一种方式”让一个对象，可以访问并使用到另一个对象中的内容。这种行为我们叫做 继承！

继承的作用：
节省了各个构造函数中，大量重复声明的属性和方法。
提高了开发效率，并节省了内存

构造函数继承

继承的方式： call和apply方法的使用 ，达成了构造函数继承的作用

function fn(){
     console.log(this);  
}
        
function Animal(name,sex){
    this.name = name;
    this.sex = sex;
    this.jiao = function(){
         console.log(this);
    }
}

直接给原型赋值一个对象，可以简化批量赋值。 但，等于重构了原型
重构原型时，需要手动创建constructor: 构造函数。 否则原型的指向链条会断

Animal.prototype = {
    constructor:Animal,
    ll:"lala"
};
let obj = new Animal("猴子","公");
obj.jiao();      

call： 对象冒充， 又叫做对象借用

fn.call(obj,"大象","公");

function Tiger(name,age,sex,hobby){
     Animal.call(this,name,sex);
     this.age = age;
     this.hobby = hobby;           
}

apply： 作用和call 一致， 都借用对象。

区别：
call 接受参数时，数量根据被借者需要的参数而定
apply: 只有两个参数 1.借用者 2.数组(这里存放着所有的参数)

function Person(name,age,sex,hobby){
       let arr = [name,age,sex,hobby];
       Tiger.apply(this,arr);
}

let per = new Person("小四","18","待定","打篮球");
per.jiao();

console.log(per);
//name: "小四"
//sex: "待定"
//jiao: ƒ ()
//age: "18"
//hobby: "打篮球"

原型链继承

将父类的实例化对象 赋值 给子类的原型

优点： 类似于复制了一个对象，构造函数和原型中所有的数据都可以获取到。简约方便使用

缺点：
原型链继承自身没有办法传参。
父类所有的属性和方法都可以被所有子类共享

function Parent(name,age){
    this.name = name;
    this.age = age;
}
Parent.prototype.love = function(){
    console.log("喜欢小孩,尤其是自己的");
 }
function Ding(name,sex,age){
    //构造函数继承，又叫类式继承
    Parent.call(this,name,age);
    this.h = "d";
}
Ding.prototype = new Parent();

组合继承

1. 类式继承，无法获取父类的原型链
2. 原型链继承,无法直接给父类传参
3. 组合继承 = 类式继承 + 原型链继承
4. 结合了两种继承的优点，互相弥补了各自的缺点

let d = new Ding("小丁","男","20");
console.log(d.name);
d.love();