JavaScript学习笔记(三)

JavaScript面向对象程序设计


JS中也可以自己设计引用类型!


创建对象

(1)工厂模式

function createPerson(name,age) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.showName = function() {alert(this.name);};
    return o;
}
var person1 = createPerson("Alen",21);
这个模式的问题是无法识别person1的类型,只能用typeof测出为Object类型的。


(2)构造函数模式

function Person(name,age) {
    this.name = name;
    this.age = age;
    this.showName = function() {alert(this.name);};
}

var person1 = new Person("Alen",21);
alert(typeof person1); //"Person"
这里的new做了下面四件事:首先创建一个空Object,然后将构造函数的作用域赋给新对象,然后执行构造函数,然后返回新对象。这本质上原理其实是,任何对象都有一个protoype属性,这个东西指向一个Propotype节点,里面一般包含对象的通用方法。这里每当创建的是函数对象时,就会自动在函数对象propotype节点中加一个constructor属性,指向propotype属性所在的函数。

当用构造函数创建一个实例之后(即new Constructor() ),会在返回的实例中自动添加一个__proto__属性,指向其构造函数的propotype属性。如图:


所以其实是靠constructor这些来进行类型识别的。使用构造函数模式的缺点是,每个方法都要在一个实例中创建一遍!可以用一下代码使方法公用:

function showName() {
    alert(this.name);
}

function Person(name,age) {
    this.name = name;
    this.age = age;
    this.showName = showName;
}
这样需要创建很多的全局函数来当做实例的Person的方法,很不好。


(3)原型模式

原型模式即将属性和方法放在propotype而不是实例中,这样由于所有的Person的实例都指向同一个propotype,所以可以共享属性和方法。

//创建空的构造函数,这样里面只有propotype
function Person() {
}
//为propotype添加属性和方法
Person.propotype.name = "Alen";
Person.propotype.age = 21;
Person.propotype.showName = function() {
    alert(this.name);
};
//创建Person实例
var person1 = new Person();
person1.showName(); //Alen
这样的缺点,一个是不能初始化构造实例,只能默认值。另一个是很零散。

Person.propotype = {
    name:"Alen",
    age:21,
    showName: function() {alert(this.name);};
}
但这样相当于重新定义propotype对象,里面的constructor指针属性会丢失。可以在里面加一个constructor: Person。缺点还是有, 最大的问题是原型模式共享的本性。实例间共享属性和方法。

共享基本类型的属性不是问题,当person.name="Ben"这样重新设置属性的时候,会在实例对象中重新加一个name属性,同时不修改propotype中的name属性,以后访问person.name根据原型链,会先在实例中找name属性,找不到才去propotype中找。这样就保证了每个实例的基本类型属性的独立。但是引用类型的属性,在修改时不会在实例中重建,所以原型模式有问题。


(4)组合原型模式和构造函数模式

将方法放在原型中,将属性放在构造函数中:


function Person(name,age) {
    this.name = name;
    this.age = age;
}

Person.propotype.showName = function() {
    alert(this.name);
};
var person1 = new Person("Alen",21);

/*或者*/
function Person(name,age) {
    this.name = name;
    this.age = age;
    //一次判断,即可用于所有方法
    if(typeof this.showName != "function") {
        Person.propotype.showName = function() {
            alert(this.name);
        };
    }
}



继承

(1)原型链

当把一个类的构造函数的propotype属性赋值为另一种类的实例对象时,就实现了继承。



如图,当把SubType的propotype设为:

function SuperType() {
    this.property = true;
}
SuperType.propotype.getSuperValue = function() {
    return this.property;
};
function SubType() {
    this.subproperty = false;
}
SubType.propotype = new SuperType();
//注意一定不能在继承之前添加方法,否则会被继承重置
SubType.propotype.getSubValue = function() {return this.subproperty;};
var instance = new SubType();<pre>
 

 那么可以在图中看到,继承之后,instance的propotype中有SuperType实例应有的getSuperValue方法,__proto__属性。就这样,通过__proto__指针形成一个原型链,实现继承关系。 
那么问题来了,由于会把实例整个赋值给propotype,因此propotype中会包含属性(严重的问题在于引用类型的属性)。 

(2)借用构造函数

function SuperType() {
    this.color = ["red" , "blue" , "black"];
}
/*用子类的作用域调用父类的构造函数,则可继承父类属性*/
function SubType() {
    SuperType.call(this);
}

(3)组合继承

将父类属性先用借用构造函数的方法继承到实例中来,再用原型链复制父类实例到原型中,这样则父类的属性继承了两份,一份在实例中,一份在原型中,由于属性的搜索顺序,这样修改子类实例的属性值不会修改原型中的,因此是正确的属性继承。而方法只继承了一份,在原型的__proto__指向的父类原型propotype中。如:

/*父类*/
function SuperType(name) {
    this.name = name;
}
SuperType.propotype.showName = function() {
    alert(this.name);
};
/*子类*/
function SubType(age) {
    SuperType.call(this,"Alen");
}
SubType.propotype = new SuperType();
SubType.propotype.showAge = function() {
    alert(this.age);
};


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值