学习笔记：javascript中的六种继承

今天学习了javascript中的继承，以下是总结的笔记，有不足或者欠妥的地方希望能和亲爱的你一起谈论：

第一种：原型链式继承方式

function Box(){

this.name="lily";

}

function Desk(myage){

this.age=myage;

}

Desk.prototype=new Box(); //用这种方式写函数，否则每次使用该方法都会开辟空间，浪费内存

var desk=new Desk(20);

alert(desk.name); //结果为：lily

alert(desk.age); //j结果为：20
使用这种方式不能给父类的变量初始化值

第二种：对象冒充方式

function Box(name,age){

this.name=name;

this.age=age;

this.myprint=function(){

return this.name+this.age ;

}

}

function Desk(name,age){

Box.call(this,name,age);

}

var desk=new Desk('lily',20);

var p=desk.myprint();

alert(p); //结果为：lily20

这种方式解决了不能给父类传递参数的问题

第三种：组合方式

function Box(myname)

{

this.name=myname;

}

Box.prototype.myprint=function(){

return '名字：'+this.name ;

}

function Desk(myage)

{

this.age=myage;

Box.call(this,'lily'); //对象冒充

}

Desk.prototype=new Box(); //原型链的方法

var desk = new Desk(20);

var a=desk.myprint();

alert(a); //输出结果为：名字：lily

alert(desk.age); //输出结果为:20

这种方式是JavaScript中最常用的一种方法

第四种：原型式继承

function obj(o){

function F(){}

F.prototype=o;

return new F();

}

var box={

name:'lily'

}

var box1=obj(box);

alert(box1.name); //输出结果为：lily

//这种继承借助原型并基于已有的对象创建新对象，同时还不必此创建自定义类型

第五种：寄生式继承

function obj(o){

function F(){}

F.prototype=o;

return new F();

}

//寄生函数

function create(o)

{

var f=obj(o);

f.fun=function(){

return '请确认：'+this.name+this.age;

}

return f;

}

var p={

name:'lily',

age:20

}

var p1=create(p);

alert(p1.fun()); //输出结果是：请确认：lily20

alert(p1.name); //lily

第六种：寄生式组合继承

function obj(o){

function F(){}

F.prototype=o;

return new F();

}

//寄生函数

function create(box,desk)

{

var f=obj(box);

f.constructor=desk; //调整原型构造指针，避免出错

desk.prototype=f;

}

function Box(myname,myage)

{

this.name=myname;

this.age=myage;

}

function Desk()

{

Box.call(this,'lily',20); //对象冒充

}

create(Box,Desk);

var desk=new Desk();

alert(desk.name); //输出结果为：lily

alert(desk.age); //输出结果为：20