構(gòu)造函數(shù)
var Book=function(id,name,price){
var a=1;
this.id=id;
this.name=name;
this.price=price;
this.getPirce=function(){
return this.price
}
}
Book.prototype.display=function(){//展示這本書}
var book1=new Book(1,'js設(shè)計',100);
var book2=new Book(2,'nodejs指南',50);
Book.isChinese=true //類靜態(tài)公有屬性（實例化對象不能訪問）
//打印book1
//Book
getPirce:function()
id:1
name:"js設(shè)計"
price:100
__proto__:Object
constructor:function(id,name,price)
display:function()
__proto__:Object
子類的原型對象-類式繼承
缺點，如果父類公有屬性是引用類型如數(shù)組兔簇，就會被所有子類的實例公有，其中一個實例更改公有數(shù)據(jù)會直接影響到其他子類
function Father(){
this.fVal=true;
}
Father.prototype.getFatherVal=function(){
return this.fVal
}
function Children(){
this.cVal=false;
}
Children.prototype=new Father();
Children.prototype.getChildVal=function(){
return this.cVal
}
var instance=new Children();
打印instance:
cVal:false
__proto__:Father
fVal:true
getChildVal:function()
__proto__:Object
constructor:function Father()
getFatherVal:function()
__proto__:Object
創(chuàng)建即繼承-構(gòu)造函數(shù)繼承
缺點：父類的原型方法不會被子類繼承
//申明父類
function Father(id){
//值類型共有屬性
this.id=id
//引用類型共用屬性
this.books=['Javascript','nodejs','css']
}
Father.prototype.showBooks=function(){
return this.books
}
//申明子類
function Children(id){
Father.call(this,id) //call改變函數(shù)的作用環(huán)境硬耍，子類繼承父類的共有屬性和方法垄琐。
}
var instance1=new Children(10);
var instance2=new Children(12);
instance1.books.push('設(shè)計模式')
console.log(instance1.id,instance1.books) //10,["Javascript", "nodejs", "css", "設(shè)計模式"]
console.log(instance1.id,instance2.books) //12,["Javascript", "nodejs", "css"]
instance1.showBooks() //TypeError
組合繼承
缺點:構(gòu)造函數(shù)式繼承執(zhí)行一遍父類的構(gòu)造函數(shù)，子類原型的類方式繼承又調(diào)用一次父類的構(gòu)造函數(shù)
//申明父類的構(gòu)造函數(shù)
function Father(id){
//值類型共有屬性
this.id=id
//引用類型共用屬性
this.books=['Javascript','nodejs','css']
}
//父類申明原型方法
Father.prototype.getId=function(){
console.log(this.id)
}
//申明子類
function Children(id,price){
//構(gòu)造函數(shù)式繼承父類id屬性和books
Father.call(this,id);
//子類新增共用屬性
this.price=price
}
Children.prototype=new Father();
Children.prototype.getPrice=function(){
console.log(this.price)
}
var instance1=new Children(10,50.00)
instance1.books.push('設(shè)計模式');
var instance2=new Children(12,65.00);
打印instance1
id:10
books:['Javascript','nodejs','css','設(shè)計模式']
price:50,
__proto__:Father
id:undefind
books:['Javascript','nodejs','css']
getPrice:function()
__proto__:Object
constructor:function Father(id)
getId:function()
__proto__:Object
潔凈的繼承者-原型式繼承
缺點：同類式繼承
function inhertObject(o){
//過渡函數(shù)對象
function F(){}
//過渡對象原型繼承父對象
F.prototype=o
//返回過渡對象的一個實例经柴，該實例原型繼承父對象
return new F()
}
var books={
name:'js book',
alikebook:['css','html']
}
var book1=inhertObject(books);
book1.name='ajax book'
book1.alikebook.push('xml')
var book2=inhertObject(books);
book2.name='flash book'
book2.alikebook.push('actionscript')
終極組合繼承
function inhertObject(o){
//過渡函數(shù)對象
function F(){}
//過渡對象原型繼承父對象
F.prototype=o
//返回過渡對象的一個實例狸窘，該實例原型繼承父對象
return new F()
}
function inhertProto(children,father){
//復(fù)制一份父類的原型副本保存在變量中
var p=inhertObject(father.prototype)
//修正因為改寫子類導(dǎo)致子類的constructor熟悉被修改
p.constructor=children;
//修改子類的原型
children.prototype=p;
}
//申明父類的構(gòu)造函數(shù)
function Father(id){
//值類型共有屬性
this.id=id
//引用類型共用屬性
this.books=['Javascript','nodejs','css']
}
//父類申明原型方法
Father.prototype.getId=function(){
console.log(this.id)
}
//申明子類
function Children(id,price){
//構(gòu)造函數(shù)式繼承父類id屬性和books
Father.call(this,id);
//子類新增共用屬性
this.price=price
}
//Children.prototype=new Father();
inhertProto(Children,Father);
Children.prototype.getPrice=function(){
console.log(this.price)
}
var instance1=new Children(10,50.00)
instance1.books.push('設(shè)計模式');
var instance2=new Children(12,65.00);
打印instance1
id:10
books:['Javascript','nodejs','css','設(shè)計模式']
price:50,
__proto__:Father
constructor:function Children(id,price)
getPrice:function()
__proto__:Object
constructor:function Father(id)
getId:function()
__proto__:Object
