目的：不重复写类的相同属性和方法

function Box(_a) {
    console.log("aaa");
    this.a = _a;
    this.play();
}

Box.prototype.a = 10;
Object.defineProperty(Box.prototype, "num", {
    set: function (value) {
        this._num = value;
    },
    get: function () {
        if (!this._num) this._num = 0;
        return this._num;
    }
})
Box.prototype.play = function () {
    console.log("play");
}
Box.run = function () {

}
Box.b = 20;

继承的分类

冒充式继承

子类没有父类下的方法

function Ball(_a){
    console.log(this); 
    Box.call(this, _a);
}
var b = new Ball(10);
console.log(b); 

组合式继承

会丢失带入的数据以及会重复执行

function Ball(_a){
         Box.call(this,_a);
}
Ball.prototype=new Box();
Ball.prototype.constructor=Ball;
var b=new Ball(10);
console.log(b)

原型式继承

创建一个空的类，这样就可以不执行Box中的constructor了

function Ball(_a){
    Box.call(this._a)
}
function F(){}
F.prototype=Box.prototype;
Ball.prototype=new F();
Ball.prototype.constructor=Ball;
let b=new Ball(10);
console.log(b);

寄生式继承

function Ball(_a){
    
}
function extend(subClass,supClass){
    function F(){}
    F.prototype=supClass.prototype;
    //Object.assign(subClass.prototype,new f());
    subClass.prototype=new F();
    subClass.prototype.constructor=subClass;
    subClass.prototype.superClass=supClass.prototype;
    if(supClaass.prototype.constructor!==supClass){
        supClaass.prototype.constructor=supClass
    }
}
function Ball(_a){
    this.superClass.constructor.call(this._a)
}
extend(Ball,Box);
Ball.prototype.play=function(){
    this.superClass.play.call(this);//执行超类的play方法
}
var b=new Ball(10);