/* 创建对象 */

   function createCar(color, passengers, brand) {
      var car = new Object();
      car.color = color;
      car.passengers = color;
      car.brand = brand;
      car.outBrand = function () {
        console.log(this.brand)
      }
      return car;
    }

/* 方法1: 构造函数和原型的：组合继承

//优点是：构造函数可以传参；缺点：继承的时候调用了父类构造函数，并且子类原型上多了不需要的父类的属性，存在内存的浪费*/
   function Parent(value) {
      this.val = value;
    }
    Parent.prototype.getValue = function () {
      console.log(this.value);
    }
    function Child(value) {
      Parent.call(this, value); // 继承父类的属性
    }
    Child.prototype = new Parent();
    const child = new Child(1);
    console.log(child, child instanceof Child, child instanceof Parent);

    /* 方法2:寄生组合继承：优化掉组合继承的缺点，继承父类函数时调用了父类构造函数的缺点，使用Object.create重写子类构造函数 */ 

    function Parent(value) {
      this.val = value;
    };
    Parent.prototype.getValue = function () {
      console.log(this.val);
    };
    function Child(value) {
      Parent.call(this, value)
    };
    Child.prototype = Object.create(Parent.prototype, {
      constructor: {
        value: Child,
        enumerable: false,
        writeable: true,
        configurable: true,
      }
    });
    const child = new Child(1);
    child.getValue();
    console.log(child, child instanceof Parent);

/* 方法3： class类extends继承 */

• class本质是函数
• extends表示继承自哪个父类
• 子类构造函数中必须调用super，这个可以看成是调用父类构造函数：Parent.call(this,value)

class Parent {
  constructor() {
    this.val = 1;
  }
  getValue() {
    console.log(this.val);
  }
}

class Child extends Parent {
  constructor(value) {
    super(value);
    this.val = value;
  };
};
let child = new Child(1);
console.log(child);
child.getValue();