四：//原型式继承
//原型是继承
function inheritObject(o){
//声明一个过度函数对象
function F(){}
//过渡对象的原型继承父对象
F.prototype = o;
//返回过度对象的一个实例，该实例的原型继承了父对象
return new F();
}
// 原型式继承是对类式继承的一个封装，其中的过度对象就相当于类式继承中的子类，只不过在原型式中作为一个过度对象出现的，目的式为了创建要返回的新的实例化对象。
var book = {
name: 'js Book',
alikeBook: ['css','html','python']
};
var newBook = inheritObject(book);
newBook.name = "ajax book";
newBook.alikeBook.push("javascript设计模式")
var otherBook = inheritObject(book);
otherBook.name = "css book";
console.log(newBook.name) //["css", "html", "python", "javascript设计模式"]
console.log(newBook.alikeBook) //ajax book
console.log(otherBook.name) //css book
console.log(otherBook.alikeBook) //["css", "html", "python", "javascript设计模式"]
// 缺点：和类式继承一样，父对象book中的值类型的属性被复制引用类型的属性被共用
//寄生式继承
function inheritObject(o){
//声明一个过度函数对象
function F(){}
//过渡对象的原型继承父对象
F.prototype = o;
//返回过度对象的一个实例，该实例的原型继承了父对象
return new F();
}
//声明基对象
var book = {
name: 'js Book',
alikeBook: ['css','html','python']
};
function createBook(obj){
//通过原型继承方式创建新对象
var o = new inheritObject(obj)
//扩展对象
o.getName = function(){
console.log(name)
};
//返回新对象
return o
}
var b1 = createBook(book)
console.log(b1)
b1.name = "jax book";
b1.alikeBook.push("Linux")
var b2 = createBook(book)
console.log(b1)
b2.name = "css book";
console.log(b1.name)
console.log(b1.alikeBook) //["css", "html", "python", "Linux"]
console.log(b2.name)
console.log(b2.alikeBook) //["css", "html", "python", "Linux"]
// 寄生组合式继承
// 寄生组合式继承是哪两种模式？
// 寄生是寄生式继承，寄生式继承依托于原型继承，原型继承由于类式继承相似，另一种应该式构造函数继承。这里寄生式继承它处理的不是对象，而是类的原型。
/**
*寄生式继承 继承原型
*传递参数 subClass 子类
*传递参数 superClass 父类
**/
function inheritObject(o){
//声明一个过度函数对象
function F(){}
//过渡对象的原型继承父对象
F.prototype = o;
//返回过度对象的一个实例，该实例的原型继承了父对象
return new F();
}
function inheritPrototype(subClass, superClass){
//复制一份父类的原型副本保存在变量中
var p = inheritObject(superClass.prototype);
//修正因为重写子类原型导致子类的constructoe属性被修改
p.constructor = subClass
//设置子类的原型
subClass.prototype = p
}
//定义父类
function SuperClass(name){
this.name = name;
this.color = ['red','green','blue'];
}
//定义父类原型的方法
SuperClass.prototype.getName = function(){
console.log(this.name)
}
//定义子类
function SubClass(name,time){
//构造函数式继承
SuperClass.call(this,name)
//子类添加新属性
this.time = time;
}
//寄生式继承父类原型
inheritPrototype(SubClass,SuperClass);
//为子类新增原型方法
SubClass.prototype.getTime = function(){
console.log(this.time)
}
//创建
var instance1 = new SubClass("js book", 2019);
var instance2 = new SubClass("css book", 2018);
instance1.color.push("blank");
console.log(instance1.color) //["red", "green", "blue", "blank"]
console.log(instance2.color) //["red", "green", "blue"]
寄生组合式继承 最大的改变就是对子类原型的处理，被赋予父类原型的一个引用，这是一个对象。