JavaScript继承的实现方式：原型语言对象继承对象原理剖析

function People(name){
  //属性
  this.name  = name || Annie
  //实例方法
  this.sleep=function(){
    console.log(this.name + '正在睡觉')
  }
}
//原型方法
People.prototype.eat = function(food){
  console.log(this.name + '正在吃：' + food);
}

function Woman(){ 
    this.name= "SubType"; // 子类属性
}
// 如果此处有Woman的原型对象上的方法，由于原型重定向，下面的代码会覆盖此方法
Woman.prototype= new People();// 重写原型对象，代之以一个新类型的实例
// 这里实例化一个 People时， 实际上执行了两步
// 1，新创建的对象复制了父类构造函数内的所有属性及方法
// 2，并将原型 __proto__ 指向了父类的原型对象
Woman.prototype.name = 'haixia';//子原型的属性
Woman.prototype.name = ()=>{};//子原型方法
let womanObj = new Woman();

function Parent () {
  this.a = 1;
  this.b = [1, 2, this.a];
  this.c = {demo: 5};
  this.show = function () {
    console.log(this.a + ' ' + this.c.demo + ':' + this.b + '\n');
  };
}

function Child () {
  this.a = 2;
  this.change = function () {
    this.b.push(this.a);
    this.a = this.b.length;
    this.c.demo = this.a++;
  };
}

Child.prototype = new Parent();
var parent = new Parent();
var child1 = new Child();
var child2 = new Child();
child1.a = 11;
child2.a = 12;
child1.change();
child2.change();
parent.show();
child1.show();
child2.show();

function extendObj(obj) {
  if (Object.create) {
    return Object.create(obj)
  } else {
    function F () { } 
    F.prototype = obj; 
    return new F()
  }
}
var obj = { name: "smd", age: 26, sayHi: function () { } }
var newObj = createObj(obj)
/* Extend Function */  
function extend(subClass,superClass){  
    var Func = function(){} ;  
    Func.prototype = superClass.prototype ;  
    subClass.prototype = new Func() ;  
    subClass.prototype.constructor = subClass ;  
} ;

function Wonman(name){
  let instance = new People();
  instance.name = name || 'wangxiaoxia';
  return instance;
}
let wonmanObj = new Wonman();

// 父类
function People (name) {
  this.colors = ["red", "blue", "green"];
  this.name = name; // 父类属性
}
People.prototype.sayName = function () { // 父类原型方法
  return this.name;
};

/** 第一步 */
// 子类，通过 call 继承父类的实例属性和方法，不能继承原型属性/方法
function Woman (name, subName) {
  People.call(this, name); // 调用 People 的构造函数，并向其传参 
  this.subName = subName;
}

/** 第二步 */
// 解决 call 无法继承父类原型属性/方法的问题
// Object.create 方法接受传入一个作为新创建对象的原型的对象，创建一个拥有指定原型和若干个指定属性的对象
// 通过这种方法指定的任何属性都会覆盖原型对象上的同名属性
Woman.prototype = Object.create(People.prototype, {
  constructor: { // 注意指定 Woman.prototype.constructor = Woman
    value: Woman,
    enumerable: false,
    writable: true,
    configurable: true
  },
  run : {
    value: function(){ // override
      People.prototype.run.apply(this, arguments);
      // call super
      // ...
    },
    enumerable: true,
    configurable: true,
    writable: true
  }
})

/** 第三步 */
// 最后：解决 Woman.prototype.constructor === People 的问题
// 这里，在上一步已经指定，这里不需要再操作
//Woman.prototype.constructor = Woman;

var instance = new Woman('An', 'sistenAn')

function Wonman (name) {
  let instance = new People();
  for (var p in instance) {
    Wonman.prototype[p] = instance[p];
  }
  Wonman.prototype.name=name||'Tom'
}

let wonmanObj = new Wonman();

function Woman(name, age) {
  //3行关键代码 此三行用于获取父类的成员及方法
  //用子类的this去冒充父类的this,实现继承
  //父类People中的this.name、sleep，分别成为了子类的成员、子类的方法
  this.method = People;
  //接收子类的参数 传给父类
  this.method(name);
  //删除父类
  delete this.method;

  //此后的this均指子类
  this.age = age;
  this.sayWorld = function() {
    alert(age);
  }
}

function Woman(name){
 //继承了People，子类的this传给父类
  People.call(this); //People.call(this，'zhoulujun'); 
  this.name = name || 'andy'
}
let womanObj = new Woman();

function Woman(name,age){
  People.call(this,name,age)
}
Woman.prototype = new People();
Woman.prototype.constructor = Woman;
let wonmanObj = new Woman(ren,27);
wonmanObj.eat();

function Woman(name,age){
  //继承父类属性
  People.call(this,name,age)
}
//继承父类方法，可以简化为：Woman.prototype = Object.create(People.prototype)；
(function(){
  // 创建空类
  function Super (){};
  Super.prototype = People.prototype;
  //父类的实例作为子类的原型
  Woman.prototype = new Super();
})();
//修复构造函数指向问题
Woman.prototype.constructor = Woman;
let womanObj = new Woman();

//class 相当于es5中构造函数
//class中定义方法时，前后不能加function，全部定义在class的protopyte属性中
//class中定义的所有方法是不可枚举的
//class中只能定义方法，不能定义对象，变量等
//class和方法内默认都是严格模式
//es5中constructor为隐式属性
class People{
  constructor(name='wang',age='27'){
    this.name = name;
    this.age = age;
  }
  eat(){
    console.log(`${this.name} ${this.age} eat food`)
  }
}
// 继承父类属性，super关键字，它在这里表示父类的构造函数，用来新建父类的this对象。
// 子类必须在constructor方法中调用super方法，否则新建实例时会报错。如果子类没有定义constructor方法，这个方法会被默认添加，不管有没有显式定义，任何一个子类都有constructor方法。
class Woman extends People{ 
   constructor(name = 'ren',age = '27'){ 
     super(name, age); 
   } 
    eat(){ 
     //继承父类方法
      super.eat() 
    } 
} 
let wonmanObj=new Woman('xiaoxiami'); 
wonmanObj.eat();

/**
 * 继承
 * @param {*} subClass 子类
 * @param {*} superClass 父类
 */
function _inherits(subClass, superClass) {
  // 类型检测
  if (!superClass || typeof superClass !== "function" ) {
    throw new TypeError("Super expression must either be null or a function, not " +typeof superClass);
  }
  /**
   * Object.create 接受两个参数
   * 指定原型创建对象
   * @param {*} 目标原型
   * @param {*} 添加属性
   */
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass, // subClass.prototype.constructor 指向 subClass
      enumerable: false, // constructor 不可枚举
      writable: true,
      configurable: true
    }
  });

  /**
   * Object.setPrototypeOf 方法
   * 设置子类的 __proto__ 属性指向父类
   * @param {*} 子类
   * @param {*} 父类
   */
  if (superClass) {
    // 设置子类的__proto__ 让 Child 能访问父类静态属性
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
  }
}