/**
 * ES6继承：原理是基于寄生组合继承
*/
// ES6中基于class创建出来的类不能当做普通函数执行(也就是说call继承在ES6的class继承中行不通，call继承需要在子类的构造函数中把父类的构造函数当做普通函数执行)。
class Parent {
    constructor(name) {
        this.name = name;
    }
    getName() {
        console.log(this.name);
    }
}

class Child extends Parent {
    constructor(age) {
        // 需要注意：子类只要继承父类，可以不写constructor。但是一旦写了constructor，则在constructor中的第一行必须是super()。
        // 如果不调用super方法，子类就得不到this对象。
        super('lisi'); // super相当于Parent.call(this, 'lisi')，把父类当做普通函数执行，给父类构造函数传递参数，让父类构造函数中的this指向子类的实例。
        this.age = age;
    }
    getAge() {
        console.log(this.age);
    }
}

// Child.prototype = Object.create(Parent.prototype); 不允许重定向原型指向
const child = new Child(12);
console.log(child);

console.log(Object.getPrototypeOf(Child) === Parent); // true

class Parent {
    constructor() {
        // new.target指向当前正在执行的函数
        // 这里输出Child，说明在super执行时，它指向的是子类Child的构造函数，而不是父类Parent的构造函数。也就是说，super内部的this指向的是Child。
        console.log(new.target.name); // Child
    }
}
class Child extends Parent {
    constructor() {
        // super作为函数调用时，只能用在子类的构造函数之中，用在其他地方就会报错。
        super();
    }
}

const child = new Child();

class Parent {
    constructor() {
        this.name = 'lisi';
    }
    sayName() {
        return '父类';
    }
}
Parent.prototype.age = 12;
class Child extends Parent {
    constructor() {
        super();
        // 这里将super当作对象使用，并且在普通方法中，此时super指向Parent.prototype
        // super.sayName()相当于Parent.prototype.sayName()
        console.log(super.sayName());
        // 由于super指向父类的原型对象，所以定义在父类实例上的方法或属性，是无法通过super调用的。
        console.log(super.name); // undefined
        // 父类原型上的属性是可以访问到的
        console.log(super.age); // 12
    }
}

const child = new Child();

class Parent {
    constructor() {
        this.name = '父类';
    }
    sayName() {
        console.log(this.name);
    }
}

class Child extends Parent {
    constructor() {
        super();
        this.name = '子类';
    }
    print() {
        super.sayName(); // 调用父类的原型方法sayName
    }
}

const child = new Child();
child.print(); // 子类

class Parent {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    say() {
        console.log(`${this.name}--${this.age}`);
    }
}

const p = new Parent('lisi', 24);
p.say();

class Child extends Parent {
    constructor(name, age, hobbies) {
        super(name, age); // 调用父类的构造函数
        this.hobbies = hobbies;
    }
    // 重写从父类中继承的普通方法
    say() {
        console.log(`${this.name}--${this.age}--${this.hobbies}`);
    }
}
const c = new Child('wangwu', 12, '🏀');
c.say();