JS面向对象（3）之Object类，静态属性，闭包，私有属性， call和apply的使用，继承的三种实现方法
1.Object类
在JS中，Object是所有类的基类，使用Object类来创建自定义对象时，可以无需定义构造函数（constructor，prototype，hasOwnProperty(property)）
varper=newObject(); per.name='zhangsan'; per.age=; alert(per.name+per.age);
我们想在程序中得到一个对象变量，只要能存储大量数据即可，这个时候，我们可以考虑使用Object类。Object类避免了对构造器的定义。Object类下另一个常用的属性：hasOwnProperty
varper=newObject();
per.name='zhangsan';
per.age=;
ifper.hasOwnProperty('email'){
alert('具有email');
}else{
alert('无email');
}
2.静态属性
在有些面向对象的语言当中，可以使用static关键字定义类的静态属性或者静态方法，在JS中，可以进行模拟。
语法：
类名.属性名
类名.属性=function(){}
functionPerson(){
}
Person.count=;
varp=newPerson();
Person.count++;
varp=newPerson();
Person.count++;
varp=newPerson();
Person.count++;
alert(Person.count);
添加静态属性和静态方法：
functionPerson(){
Person.count++;//静态属性
Person.getCount=function(){//静态方法
alert('当前共有'+Person.count+'个人');
}
}
Person.count=;
varp=newPerson();
varp=newPerson();
varp=newPerson();
Person.getCount();
3.闭包
概念：所谓闭包，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因此这些变量也是该表达式的一部分。
提出一个问题：
functiondisplay(){
vari=;
}
display();
//在这里，想访问局部变量i
在全局中，不能访问局部变量i，因为作用域不同，而且，在display函数执行完毕后，局部变量i会被回收。闭包的功能：“访问局部变量”和“使变量所占的内存不被释放”
//例
functionfn(){
functionfn(){
alert('hello');
}
returnfn;//返回fn函数首地址
}
vartest=fn();//test也指向了fn函数的首地址
test();
通过例1我们知道：变量是可以指向函数的首地址的，函数也可以返回另一个函数的首地址。
//例
functionfn(){
vari=;
functionfn(){
alert(i);
}
returnfn;//返回fn函数首地址
}
vartest=fn();//test也指向了fn函数的首地址
test();
通过例2我们知道：使用一个拒不函数包含变量i，这样局部变量i的内存不会被回收。
//例
functionfn(){
vari=;
functionfn(){
alert(i++);
}
returnfn;//返回fn函数首地址
}
vartest=fn();//test也指向了fn函数的首地址
test();
test();
test();
在例3中，因为i的内存永远不会被回收，所以每次调用fn2，i的值会+1。运行的结果是弹出10，弹出11，弹出12。
闭包的原理：在例3中，共有三个作用域：全局作用域，fn1的作用域，fn2的作用域。在全局作用域里有test=fn1(),其实这句话就相当于test=fn2。在fn1作用域里有vari=10和returnfn2，在fn2作用域例有alert(i++)。当全局作用域下的test=fn1()执行时，test指向了fn2的作用域，这个时候fn2作用域下的i被全局作用域钩住，根据作用域链的法则，fn2下并没有定义i，所以在fn2下的i往上一层作用域上找，找到了fn1作用域下的vari=10。所以全局的test钩住了fn2的i，fn2的i钩住了fn1的i，所以fn1运行完毕后，不会被回收。
4.私有属性
在面向对象思想中，对于有些敏感的，不想公开的成员可以定义为私有的，在JavaScript中可以模拟这个功能。
语法：
functionPerson(p_name){
varname=p_name;
this.age
}
var：私有
this：公有
functionPerson(p_name,p_age){
this.name=p_name;
varage=p_age;
}
varp=newPerson('zhangsan',);
alert(p.name);
alert(p.age);
在上面这个例子中，我们想用var来表示私有成员属性，但Person构造函数执行完毕后，age会被回收，不能当做成员属性来使用。
functionPerson(p_name,p_age){
this.name=p_name;
varage=p_age;
this.setAge=function(a){
age=a;
}
this.getAge=function(){
return(age);
}
}
varp=newPerson('zhangsan',);
p.setAge();
alert(p.getAge());
this.setAge和this.getAge两个方法使用到了局部变量age,所以age不会被回收。
如果只有set方法，说明该属性是只写属性。
如果只有get方法，说明该属性是只读属性。
5.call和apply的使用
call和apply的功能：使用指定的对象调用当前函数。call和apply的功能完全相同，只是在语法上略有不同。
语法：
call([thisObj[,arg1[,arg2[,argN]]]])
第一个参数：函数执行时，this指向谁
后面的参数：根据需要顺序指定
apply([thisObj[,argArray]])
第一个参数：函数执行时，this指向谁
第二个参数：数组，表示参数集合
在js中，函数有几种调用形式：
Person();//Person内的this指向window
varp=newPerson();//Person内的this指向p
per.Person();//Person内的this指向per
functionPerson(p_name,p_age){
this.name=p_name;
this.age=p_age;
}
functionspeak(){
alert(this.name+this.age);
}
varp=newPerson('zhangsan',);
//speak();这样调用this指向window
//p.speak();p对象没有speak属性
使用call和apply来调用
functionPerson(p_name,p_age){
this.name=p_name;
this.age=p_age;
}
functionspeak(){
alert(this.name+this.age);
}
varp=newPerson('zhangsan',);
speak.call(p);
speak.apply(p);
call和apply在执行时做了两件事：1）将函数内部this指向了第一个参数2）调用函数
另外：还可以这样解决问题：
P1.say=speak;
P1.say();
这样解决和上面解决方法有本质上的区别：
上面的解决办法是直接调用speak函数，只不过函数内部this的指向发生改变。
下面的解决办法会为p1对象增加属性，p1对象的“体积”会变大。
举例说明：
<script>
functionfn(){
this.style.color='red';
}
functionfn(){
this.style.fontSize='px';
}
window.onload=function(){
document.getElementById('btn').onclick=function(){
vardiv=document.getElementById('div');
fn.call(div);
fn.apply(div);
};
};
</script>
<divid='div'>hellojavascript</div>
<inputtype='button'id='btn'value='确定'>
6.继承的三种实现方法
概念：在有些面向对象语言中，可以使用一个类（子类）继承另一个类（父类），子类可以拥有父类的属性和方法，这个功能可以在js中进行模拟。
三种方法：
第一种：扩展Object方法
Object.prototype.方法=function(父类对象){
for(variin父类对象){
this[i]=父类对象[i];
}
};
举例说明：
Object.prototype.ext=function(parObject){
//循环遍历父类对象所有属性
for(variinparObject){
//为子类对象添加这个遍历到的属性
//它的值是父类对象这个属性的属性值
this[i]=parObject[i];
}
}
functionPerson(p_name,p_age){
this.name=p_name;
this.age=p_age;
this.speak=function(){
alert(this.name+this.age);
}
}
functionStudent(p_no){
this.no=p_no;
this.say=function(){
alert(this.no+this.name_this.age);
}
}
varstu=newStudent();
stu.ext(newPerson('xiaoqiang',));
stu.speak();
stu.say();
第二种：使用call和apply方法
语法：
父类构造器.call(this,.......);
functionPerson(p_name,p_age){
this.name=p_name;
this.age=p_age;
this.speak=function(){
alert(this.name+this.age);
}
}
functionStudent(p_no,p_name,p_age){
this.no=p_no;
this.say=function(){
alert(this.name+this.age+this.no);
}
Person.call(this,p_name,p_age);
}
varstu=newStudent(,'zhagsan',);
stu.speak();
stu.say();
第三种：原型继承
语法：
子类.prototype=new父类();
functionPerson(p_name,p_age){
this.name=p_name;
this.age=p_age;
this.speak=function(){
alert(this.name+this.age);
}
}
functionStudent(p_no){
this.no=p_no;
this.say=function(){
alert(this.name+this.age+this.no);
}
}
Student.prototype=newPerson('wangwu',);
varstu=newStudent();
stu.speak();
stu.say();
以上内容给大家介绍了JS面向对象（3）之Object类，静态属性，闭包，私有属性，call和apply的使用，继承的三种实现方法，希望对大家有所帮助！