分为六步，能看完的话，不会你打我
类式继承、构造函数继承、组合继承、原型继承、寄生式继承、寄生组合式继承
/**
* 一、类式继承
* 优点：原型链会被继承类使用
* 缺点：多个继承类 会公用构造函数的this的公用属性，一个修改会影响到其他
*/
// 父类
function superClass(name) {
this.name = name || 'superClass';
this.friends = ['zhangsan', 'lisi', 'wanger'];
}
superClass.prototype.showSomething = function () {
console.log(this.name, 'showSomething of superClass');
}
// 子类
function subClass(name) {
this.name = name || 'subClass';
}
// 将子类的原型指向父类的实例 父类实例可访问父类原型和构造函数的方法及属性 实现了继承
subClass.prototype = new superClass();
subClass.prototype.showSomethingOfSub = function() {
console.log(this.name, 'showSomething of subClass');
}
// 此时instance1、instance2继承了superClass
instance1 = new subClass('chencheng');
instance2 = new subClass('wuxuanyu');
// 测试
console.log(instance1.name, 'instance1.name');
console.log(instance1.friends, 'instance1.friends');
instance1.showSomething();
instance1.friends.push('nigulasi-zhaosi'); // 修改数组 看结果如何
console.log(instance2.name, 'instance2.name');
console.log(instance2.friends, 'instance2.friends');
instance2.showSomething();
// 结果
// chencheng instance1.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance1.friends'
// chencheng showSomething of superClass
// wuxuanyu instance2.name
// [ 'zhangsan', 'lisi', 'wanger', 'nigulasi-zhaosi' ] 'instance2.friends'
// wuxuanyu showSomething of superClass
// 结论：第一继承类修改了friends数组 结果第二个继承类的friends也跟着变了，所以有瑕疵，接下来看第二种
// --------------------------------------------------------------------------------------
/**
* 二、构造函数继承
* 优点：多个继承类 不会公用构造函数的this的公用属性，避免了类式继承的缺点
* 缺点：原型链不会被继承类使用
*/
// 父类
function superClass(name) {
this.name = name || 'superClass';
this.friends = ['zhangsan', 'lisi', 'wanger'];
}
superClass.prototype.showSomething = function () {
console.log(this.name, 'showSomething of superClass');
}
// 子类
function subClass(name) {
this.name = name || 'subClass';
// 请注意，继承精髓在此，利用了call方法的改变this继承类创建了新的this属性，避免了引用类型指向一个
superClass.call(this, this.name);
}
// 此时instance1、instance2继承了superClass
instance1 = new subClass('chencheng');
instance2 = new subClass('wuxuanyu');
// 测试
console.log(instance1.name, 'instance1.name');
console.log(instance1.friends, 'instance1.friends');
instance1.showSomething();
instance1.friends.push('nigulasi-zhaosi'); // 修改数组 看结果如何
console.log(instance2.name, 'instance2.name');
console.log(instance2.friends, 'instance2.friends');
instance2.showSomething();
// 结果
// superClass instance1.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance1.friends'
// 报错
// superClass instance2.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance2.friends'
// 报错
// 结论：子类修改数组不会相互影响了，开心哦，但是instance1.showSomething()、instance2.showSomething()都报错了，尴尬
// 说明了子类并没有父类原型链的方法，有瑕疵，接下来看第三种
// --------------------------------------------------------------------------------------
/**
* 三、组合继承
* 优点：多个继承类 不会公用构造函数的this的公用属性，避免了类式继承的缺点，原型链也会被继承类使用
* 缺点：构造函数在原型链被复制过程中，又被搞了一回，资源浪费啊，原型链里有个constructor也被一起复制了，没必要的
*/
// 父类
function superClass(name) {
this.name = name || 'superClass';
this.friends = ['zhangsan', 'lisi', 'wanger'];
}
superClass.prototype.showSomething = function () {
console.log(this.name, 'showSomething of superClass');
}
// 子类
function subClass(name) {
this.name = name || 'subClass';
// 请注意，继承精髓在此，利用了call方法的改变this继承类创建了新的this属性，避免了引用类型指向一个
superClass.call(this, this.name);
}
// 原型链我也指向一次，这样我实例化的对象就能用父类原型链的方法，哈哈哈，可惜啊，这个父类实例化对象带有父类的构造函数，上面已经superClass.call(this)了，在这没必要了，浪费了
subClass.prototype = new superClass();
subClass.prototype.showSomethingOfSub = function() {
console.log(this.name, 'showSomething of subClass');
}
// 此时instance1、instance2继承了superClass
instance1 = new subClass('chencheng');
instance2 = new subClass('wuxuanyu');
// 测试
console.log(instance1.name, 'instance1.name');
console.log(instance1.friends, 'instance1.friends');
instance1.showSomething();
instance1.friends.push('nigulasi-zhaosi'); // 修改数组 看结果如何
console.log(instance2.name, 'instance2.name');
console.log(instance2.friends, 'instance2.friends');
instance2.showSomething();
// 结果
// superClass instance1.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance1.friends'
// superClass showSomething of superClass
// superClass instance2.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance2.friends'
// superClass showSomething of superClass
// 结论：子类修改数组不会相互影响了，开心哦，而且也能用父类的原型的方法了，但是父类构造函数第二次在原型中有点浪费了接下来看第四种吧，还有耐心不啊
// --------------------------------------------------------------------------------------
/**
* 四、原型式继承-类式继承subClass不带构造函数的封装
* 优点：洁净板的类式继承
* 缺点：缺点同第一种
*/
function inheritObject(o) {
function F() {}
F.prototype = o; // 为什么不是new o呢？因为这个例子里o不是构造函数啦 是个非构造函数对象
return new F();
}
// 测试
let people = {
name: 'chencheng',
friends: ['zhangsan', 'lisi', 'wanger']
}
let instance1 = inheritObject(people);
let instance2 = inheritObject(people);
console.log(instance1.name, 'instance1.name');
console.log(instance1.friends, 'instance1.friends');
instance1.friends.push('nigulasi-zhaosi'); // 修改数组 看结果如何
console.log(instance2.name, 'instance2.name');
console.log(instance2.friends, 'instance2.friends');
// 结果
// chencheng instance1.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance1.friends'
// chencheng instance2.name
// [ 'zhangsan', 'lisi', 'wanger', 'nigulasi-zhaosi' ] 'instance2.friends'
// 结论：跟第一种问题一样，妈的瑕疵 整第五种吧，我也累了 哈哈
// --------------------------------------------------------------------------------------
/**
* 五、寄生式继承
* 优点：洁净板的类式继承的升级
* 缺点：缺点同第一种
*/
function inheritObject(o) {
function F() {}
F.prototype = o; // 为什么不是new o呢？因为这个例子里o不是构造函数啦 是个非构造函数对象
return new F();
}
function createPeople(obj) {
let o = new inheritObject(obj);
// 重点在此 可拓展了
o.doSomething = function () {
console.log('do something ba');
}
return o;
}
// 测试
let people = {
name: 'chencheng',
friends: ['zhangsan', 'lisi', 'wanger']
}
let instance1 = createPeople(people);
let instance2 = createPeople(people);
console.log(instance1.name, 'instance1.name');
console.log(instance1.friends, 'instance1.friends');
instance1.doSomething();
instance1.friends.push('nigulasi-zhaosi'); // 修改数组 看结果如何
console.log(instance2.name, 'instance2.name');
console.log(instance2.friends, 'instance2.friends');
// 结果
// chencheng instance1.name
// [ 'zhangsan', 'lisi', 'wanger' ] 'instance1.friends'
// chencheng instance2.name
// [ 'zhangsan', 'lisi', 'wanger', 'nigulasi-zhaosi' ] 'instance2.friends'
// 结论：跟上一种问题一样，接下来到完美的继承了 好累
// --------------------------------------------------------------------------------------
/**
* 六、寄生式组合式继承-就叫完美继承吧
* 优点：完美
* 缺点：看了半天才到完美继承 坑爹
*/
function inheritObject(o) {
function F() {}
F.prototype = o; // 为什么不是new o呢？因为这个例子里o不是构造函数啦 是个非构造函数对象
return new F();
}
function inheritPrototype(subClass, superClass) {
// 复制父类原型保存一份给p
let p = inheritObject(superClass.prototype);
// 修正因为修改F()子类原型导致子类的constructor属性被修改
p.constructor = subClass;
// 设置子类原型
subClass.prototype = p;
}
// 恭喜你 找到了完美继承的方式 太累了
困了 安
