JavaScript中的构造函数

时间:2022-11-05 14:39:52

目录:

  1. constructor & prototype
  2. 为构造函数添加属性和方法的多种不同方法
  3. 组合使用this和prototype关键字创建构造函数(常用方法)
  4. 用对象直接量作为构造函数的参数
  5. 方法的链式调用
  6. 继承:JavaScript中通过对象的原型链实现原型继承
  7. 多态:将某个方法替换为一个同名的功能类似的方法,只是做了针对性的改变。只需要重写一个函数并给它和原方法相同的方法即可
  8. JavaScript函数的apply和call方法
  9. JavaScript函数的apply和call方法(待完善)
  10. 公有、私有以及受保护的属性和方法

 

1.constructor & prototype

function Accom(){};    //创建一个构造函数

//创建两个对象

var house=new Accom();

var apartment=new Accom();

通过构造函数创建的对象有一个属性constructor,这个属性指向创建该对象时所用的Javascript构造函数。

house.constructor===Accom;  或者   house instanceof Accom;     //true

JavaScript中的每个构造函数都有一个prototype的属性,这个属性指向一个对象。当用关键字new来创建一个对象实例时,实例中所包含的属性和方法都来自prototype所指向的这个对象


 2.为构造函数添加属性和方法的多种不同方法

 

function Accom(){};
Accom.prototype
={
share:
false,
unlock:
function(){}
};
//通过对象直接量为构造函数添加属性和方法
Accom.prototype.rooms=5; //通过protype关键字添加属性
Accom.prototype.lock=function(){}; //通过protype关键字添加方法

在所有嵌套函数中都可以访问定义在其父函数中的变量


 

 3.组合使用this和prototype关键字创建构造函数(常用方法)

一般用this关键字来初始化那些希望在对象创建时进行初始化的属性,而用prototype设置其他属性以及对象的方法。每次通过构造器创建一个新的对象实例,构造函数都会被执行一次,而通过prototype关键字来定义只需要定义一次。

function Accom(floors,rooms){
this.floors=floors||0; //设置默认值0
this.rooms=rooms||7; //设置默认值7
}
Accom.prototype.isLocked=false; Accom.prototype.lock
=function(){
this.isLock=true;
};

var house=new Accom(2,5); //实例化类

 


 

 4.用对象直接量作为构造函数的参数

当类的规模越来越大时给对象实例的属性设置初始值比较麻烦,可以用对象直接量

function Accom(defaults){
defaults
=defaults||{} //如果没有传入值默认为空的对象直接量
//如果defaults对象含有某个属性,就将实例对象中同名属性的值设为defaults提供的值,否则设为默认值
this.floors=defaults.floors||0;
this.rooms=defaults.rooms||0;
}

Accom.prototype.isLock
=false;
Accom.prototype.lock
=function(){
this.isLock=true;
}

//实例化一个对象
var house=new Accom({
floors:
2,
rooms:
7
});

5.方法的链式调用  

只需要在“类”中的每个方法最后通过this关键字返回对象实例的引用就可以实现链式调用

function Accom(){}
Accom.prototype.lock
=function(){
this.isLocked=false;
return this; //通过返回上下文返回的是调用这个函数的对象,这个对象包含所有的方法,因此可以在本方法后调用其他方法
};

Accom.prototype.alarm
=function(){
alert(
"Sounding alarm!");
return this;
};

var house=new Accom();

house.lock().alarm();
//实现链式调用

6.继承:JavaScript中通过对象的原型链实现原型继承

function Accom(){
this.isLocked=false;
this.isAlarmed=false;
} //父类Accom.prototype.lock=function(){
this.islocked=true;
};Accom.prototype.unlock
=function(){};

function House(defaults){
defaults
=defaults||{};
this.floors=2;
this.rooms=defaults.rooms||7;
}

//将House类的原型设为Accom类的一个实例,这个实例包含其所有属性和方法,然后传递给House类的原型
House.prototype=new Accom();

House.prototype.constructor
=House; //上一步传递给House过程constructor的值也被复制,需要重设constructor使其指向新的子类

var myHouse=new House;
myHouse.lock();
//继承了Accom的方法
alert(myHouse instanceof Accom); //true,因为House继承自Accom

 


 

 7.多态:将某个方法替换为一个同名的功能类似的方法,只是做了针对性的改变。只需要重写一个函数并给它和原方法相同的方法即可。

//上面的例子中,针对House类重定义lock方法,即多态
House.prototype.lock=function(){
//通过call方法将上下文传递给父类Accom的lock方法,从而确保lock方法中任何对this的引用都指向当前这个House的对象实例
Accom.prototype.lock.call(this);
alert(
this.isLocked); //true,说明调用正确
}

8.JavaScript函数的apply和call方法。call和apply区别在于,使用apply时,所有参数都放在一个单独数组中,而call中参数依次列出用逗号隔开。

function Accom(){
this.isAlarmed=false;
}
//定义一个类

var Alarm={
arm:
function(message){
this.isAlarmed=true;
alert(message);
}
};
//创建一个对象,其方法可以被代码中其他对象所使用

var myHouse=new Accom();

Alarm.arm.call(myHouse,
"Alarm activated"); //通过call将对象实例myHouse上下文传入arm函数

alert(myHouse.isAlarmed);
//true,改变了

9.arguments对象 依次包含了传入函数的各个参数的一个数组,该数组不具备标准数组的其他方法(例如排序)

使用函数apply方法时,arguments就可以体现其价值,因为apply方法将所有参数放入一个数组内进行传递。


 

10.公有、私有以及受保护的属性和方法

var Accom=(function(){
function Accom(){};
//此处定义为私有变量
var _isLocked=false,_alarmMessage="Alarm activated!";
//在当前作用域上定义的函数(而未在构造函数原型删定义)为“私有的”
function _alarm(){
_isLocked
=true;
alert(_alarmMessage);
}

//所有在原型上定义的方法为公有的,此处可以访问私有方法和变量
Accom.prototype.lock=function(){
_isLocked
=false;
_alarm();
};

//定义一个函数对私有变量进行只读访问
Accom.prototype.getIsLocked=function(){
return _isLocked;
};

//定义一个函数对私有变量进行只写访问
Accom.prototype.setAlarmMessage=function(message){
_alarmMessage
=message;
};

//返回这个作用域中的类,使之在外层作用域中可用
return Accom;
}());

var house=new Accom();
house.lock();      //弹出警告消息 “Alarm activated”
house.alarm();     //错误!_alarm函数从未被公开