原型链继承-prototype属性

常见方法
Student.prototype=new Person();
Student的prototype指向一个Person的实例,所有“学生”的实例,就能继承Person了
注意:
如果替换了prototype对象:o.prototype={};要为新的prototype对象加上constructor属性,并将这个属性指回原来的构造函数:o.prototype.constructor=o;

原型链继承prototype属性实例:
function Per1(){
this.foot=2;
this.head=1;
}
function Stu1(name,no){
this.name=name;
this.no=no;
}
Stu1.prototype=new Per1();//通过prototype属性实现继承
//Stu1的prototype属性指向一个Per1实例的写法,相当于完全删除了prototype原先的值,赋了一个新值
//手工理顺继承链
Stu1.prototype.constructor=Stu1;
//每个实例的prototype对象都有一个construction属性
// alert(Stu1.prototype.constructor);
var stue=new Stu1(‘张三’,’001′);
alert(stue.constructor);//继承链紊乱
alert(stue.name);
alert(stue.no);
alert(stue.foot);
alert(stue.head);

原型链继承-直接继承prototype

对上一种方法的改进
由于Person对象中,不变的属性都可以直接写入Person.prototype,所以可以让Student()跳过Person(),直接继承Person.prototype
优点:
效率比较高,不用执行和建立Person的实例
缺点:
Student.prototype和Person.prototype现在指向了同一个对象,任何对Student.prototype的修改,都会反映到Person.prototype

原型链直接继承prototype属性实例:
function Per1(){
}
Per1.prototype.foot=2;
Per1.prototype.head=1;
function Stu1(name,no){
this.name=name;
this.no=no;
}

//通过直接继承prototype属性实现继承
//优点,相较于第一种,不用执行和建立Per1实例,节省内存
//缺点,把父类Per1的construction也同步改掉了
// alert(Per1.prototype.constructor);
Stu1.prototype=Per1.prototype;
//手工理顺继承链
Stu1.prototype.constructor=Stu1;
//每个实例的prototype对象都有一个construction属性
// alert(Stu1.prototype.constructor);
var stue=new Stu1(‘张三’,’001′);
// alert(stue.constructor);//继承链紊乱
// alert(stue.name);
// alert(stue.no);
// alert(stue.foot);
// alert(stue.head);

利用空对象作为中介

空对象几乎不占内存
修改Student的prototype对象,不会影响Person的prototype对象可以封装函数

实例:
function Per1(){
}
Per1.prototype.foot=2;
Per1.prototype.head=1;
function Stu1(name,no){
this.name=name;
this.no=no;
}

//定义一个空对象,几乎不占内存
var F=function(){};
F.prototype=Per1.prototype;
Stu1.prototype=new F();
//以上写法固定写法
//缺点,把父类Per1的construction也同步改掉了
//F空对象作为中介解决了以上缺点
// alert(Per1.prototype.constructor);
var stue=new Stu1(‘张三’,’001′);
Stu1.prototype.constructor=Stu1;
// alert(stue.constructor);//继承链紊乱
// alert(stue.name);
// alert(stue.no);
// alert(stue.foot);
// alert(stue.head);

使用空对象作为中介封装函数实例:
function Per1(){
}
Per1.prototype.foot=2;
Per1.prototype.head=1;
function Stu1(name,no){
this.name=name;
this.no=no;
}
//空对象作为中介完成继承
function ext(Child,Par){
var F=function(){};
F.prototype=Par.prototype;
Child.prototype=new F();
Child.prototype.constructor=Child;
}
ext(Stu1,Per1);

//缺点,把父类Per1的construction也同步改掉了
//F空对象作为中介解决了以上缺点
// alert(Per1.prototype.constructor);
var stue=new Stu1(‘张三’,’001′);
Stu1.prototype.constructor=Stu1;
alert(stue.constructor);//继承链紊乱
// alert(stue.name);
// alert(stue.no);
// alert(stue.foot);
// alert(stue.head);

构造函数绑定

在子类型构造函数的内部调用父类型构造函数通过call()或apply()方法
function.call(thisObj[,arg1[,arg2[,[,…argN]]]])调用一个对象的一个方法,以另一个对象替换当前对象。例如:B.call(A,args1,args2);即A对象调用B对象的方法
function.apply(thisObj[,argArray])应用某一个对象的一个方法,用另一个对象替换当前对象。例如:B.apply(A,arguments);即A对象应用B对象的方法
两方法产生的作用相同,传参不同

call和apply实例:
function Per1(){
this.foot=2;
this.head=1;
this.favorColor=[‘red’,’yellow’];
}
function Stu1(name,no){
//将父对象的构造函数绑定到子对象上面
//‘借调’父类的构造函数
// Per1.call(this);
Per1.apply(this);
this.name=name;
this.no=no;
}
//Stu1的prototype属性指向一个Per1实例的写法,相当于完全删除了prototype原先的值,赋了一个新值
Stu1.prototype=new Per1();
Stu1.prototype.constructor=Stu1;
var stue=new Stu1(‘张三’,’001′);
stue.favorColor.push(‘blue’);
// alert(stue.foot);
// alert(stue.head);
// alert(stue.favorColor);
// var stue2=new Stu1(‘李四’,’002′);
// alert(stue2.favorColor);

call与apply的区别实例:call传参数逗号隔开,apply传参数数组

function Per1(addre,sex){
this.foot=2;
this.head=1;
this.addre=addre;
this.sex=sex;
}
function Stu1(name,no){
//使用call,apply实现继承
// Per1.call(this,’北京’,’女’);
Per1.apply(this,[‘北京’,’女’]);
this.name=name;
this.no=no;
}
var stue3=new Stu1(‘张三’,’004′);
// alert(stue3.foot);
// alert(stue3.head);
// alert(stue3.addre);
// alert(stue3.sex);

组合继承

将原型链继承和构造函数继承组合在一块
原型链实现对原型属性和方法的继承
借用构造函数实现对实例属性的继承

组合继承实例:
function Per1(){
this.foot=2;
this.head=1;
this.favorColor=[‘red’,’yellow’];
}
Per1.prototype.sayColor=function(){
alert(‘hello’+this.favorColor);
}
function Stu1(name,no){
//使用构造函数绑定实现对父类属性的继承
Per1.call(this);
this.name=name;
this.no=no;
}
//原型链继承-继承prototype对象的属性和方法
Stu1.prototype=new Per1();
Stu1.prototype.constructor=Stu1;
var stue4=new Stu1(‘张三’,’005′);
// alert(stue4.foot);
// alert(stue4.head);
// alert(stue4.favorColor);
var stue5=new Stu1(‘李四’,’008′);
// alert(stue5.foot);
// alert(stue5.head);
// alert(stue5.favorColor);

拷贝继承

把父对象的所以属性和方法拷贝进子对象
把父对象的prototype对象中的属性一一拷贝给Child对象的prototype对象

拷贝继承实例:
function Per1(){}
Per1.prototype.foot=2;
Per1.prototype.head=1;
Per1.prototype.sayse=function(){
alert(‘hello’+this.foot+’脚’+this.head+’头’);
}
function Stu1(name,no){
this.name=name;
this.no=no;
}
//拷贝继承
function ett(Child,Par){
var p=Par.prototype;
var c=Child.prototype;
for(i in p){
c[i]=p[i];
}
}
ett(Stu1,Per1);
var stue6=new Stu1(‘王麻子’,’007′);
// alert(stue6.foot);
// alert(stue6.head);
// alert(stue6.name);
// alert(stue6.no);
stue6.sayse();

        👍赞 0
说点什么
支持Markdown语法
好耶,沙发还空着ヾ(≧▽≦*)o
Loading...