JS继承方式

1.指定prototype继承

但是这样有缺点，由于所有子类都共用父类的实例，当实例里的属性为引用值时，一个子类实例进行修改时，其他子类实例的属性也会被修改

// 父类
function Person(){
    this.id = 0;
    this.books = ['js', 'java', 'python']
}
// 子类
function Stu(id){
    this.id = id;
}

// 令子类Stu的prototype指向父类的实例
Stu.prototype = new Person();

let stu1 = new Stu(1);
let stu2 = new Stu(2);
stu1.books.push('php')
console.log(stu2.books) // ['js','java','python','php']

2.通过call绑定子类的实例调用父类构造函数

但是这样继承不了父类原型上的属性

function Person(){
    this.id = 0;
    this.books = ['js', 'java', 'python']
}
Person.prototype.superVal = 8888;
function Stu(id){
    Person.call(this) 
    this.id = id;
}

//  创建对象时，用子类实例的this调用Person，所以books是子类实例上的属性，
//  stu1改变不会影响stu2
let stu1 = new Stu(1);
let stu2 = new Stu(2);
stu1.books.push('php');
console.log(stu2.books); // ['js', 'java', 'python']
console.log(stu1.superVal); // undefined

3.组合式继承

结合上面的两种方法；但是这样执行了两次父类的构造函数。

function Person(){
    this.id = 0;
    this.books = ['js', 'java', 'python']
}
Person.prototype.superVal = 8888;
function Stu(id){
    Person.call(this) // 第一次
    this.id = id;
}
Stu.prototype = new Person(); // 第二次

let stu1 = new Stu(1);
let stu2 = new Stu(2);
stu1.books.push('php');
console.log(stu2.books); // ['js', 'java', 'python']
console.log(stu1.superVal); // 8888

4.原型式继承

向函数中传入一个对象，函数返回一个以这个对象为原型的对象；和第一种方法一样，有着同样的缺点，相当于是对一种方法的封装，Object.create()就是这种继承的实现

function inheritObject(obj){
    function F(){}
    // 指定子类的构造函数的原型为obj
    F.prototype = obj;
    return new F();
}

let book = {
    name: 'sun',
    catalog: ['js','java']
}
let newBook = inheritObject(book);
newBook.name = 'newB';
newBook.catalog.push('python');

let otherBook = inheritObject(book);
console.log(otherBook.name); //sun
console.log(otherBook.catalog); //['js','java','python']

5.寄生式继承

对原型式继承的拓展

let book = {
    name: 'sun',
    catalog: ['js','java']
}
function createBook(obj){
    let o = inheritObject(obj);
    // 对对象进行拓展
    o.getName = function(){
        console.log(name);
    }
    return o;
}

6.寄生式组合继承

在组合式继承中由于直接将Person实例赋给Stu的原型对象，Stu的constructor会指向Person构造函数

function Person(){
    this.id = 0;
    this.books = ['js', 'java', 'python']
}
Person.prototype.superVal = 8888;
function Stu(id){
    Person.call(this) // 第一次
    this.id = id;
}
Stu.prototype = new Person(); // 第二次

let stu1 = new Stu(1);
console.log(stu1.constructor)
// ƒ Person(){
//    this.id = 0;
//    this.books = ['js', 'java', 'python']
// }

function inheritObject(obj){
    function F(){}
    // 指定子类的构造函数的原型为obj
    F.prototype = obj;
    return new F();
}

function inheritPrototype(subClass, superClass){
    // 复制父类的原型，p的构造函数的原型就是superClass的原型，p.__proto__ = superClass.prototype
    let p = inheritObject(superClass.prototype);
    // 让实例p的构造函数指向子类
    p.constructor = subClass;
    // 子类的原型指向p
    subClass.prototype = p;
}

// 父类
function Person(){
    this.id = 0;
    this.books = ['js', 'java', 'python']
}
Person.prototype.fly = function(){console.log('I can fly')};

// 子类
function Stu(id){
    Person.call(this);
    this.id = id;
}
// 继承父类原型
inheritPrototype(Stu, Person);
// 子类新增原型方法
Stu.prototype.walk = function(){console.log('I can walk')};

let stu1 = new Stu(1); // 这里子类实例stu的__proto__指向p，即stu.__proto__ = p, 
let stu2 = new Stu(2); // p__proto__ = Person.prototype，于是实例可以向上进行属性查找

// 测试
stu1.books.push('golang');
console.log(stu2.books); // ['js', 'java', 'python']
stu2.fly(); // fly
stu2.walk(); // walk