首页 > 代码库 > JavaScript OOP 思想

JavaScript OOP 思想

2024-08-07 06:56:41   218人阅读

JS的核心是对象

{},

new function(){}这种形式也是对象。

 

http://www.nowamagic.net/librarys/veda/detail/241

 

整理一些网上的资料，供参考

 

 

1.创建对象 



1.1 new

 

用new进行创建对象：

[javascript] view plaincopyprint?
 
  1. var user = new Object();  
  2. user.age = 12;//同时为对象添加属性  
  3. user.name = ‘ajun’;  

 

1.2{}

用{}创建对象，如：

 

[javascript] view plaincopyprint?
 
  1. var user = {  
  2.        ‘name’:’ajun,  
  3.            ‘age’:12  
  4. }  

 

这里同时候为user添加了两个属性分别为：name,age

在以上代码稍加改造，你还可以为一个对象添加一个方法，如：

 

[javascript] view plaincopyprint?
 
  1. var user = {  
  2.     ‘name’:’ajun’,  
  3.     ‘age’:12  
  4.     ‘say’:function(){  
  5.         alert(this.name);//this代表当前对象  
  6.   }  
  7. }  

 

2．类和构造函数



2.1如何定义



 

在javascript中，所有的变量和方法都是对象，都可以用做参数相互传递的。

看以下这个方法：

[javascript] view plaincopyprint?
 
  1. function User(name,age){  
  2.         this.name = name;  
  3.         this.age = age;  
  4.         this.say = function(){  
  5.              alert(this.name+’ say hello!!’);  
  6.                 }  
  7. }  

此时你可以这样理解，User你可以看成一个类的名字，而User()就是这个类得构造方法，这点有点类似于java中的类和构造方法必须同名，在new的时候调用其构造方法，一些初始化操作，可以放在你的构造方法内，这里我们用于初始化name和age属性的值，以下创建User对象的代码：

[javascript] view plaincopyprint?
 
  1. var user = new User(‘ajun’ ,24);  
  2. user.say();//ajun say hello!!  

 

在这里解释以下this：

当我们在new对象的时候，实际会调用一个被叫做的call(),将当前对象做为参数传递进行，赋值给this，所以this就是指当前引用对象

3.原型



3.1 prototype



在 JavaScript 中，每个方法都有名为“prototype”的属性，用于引用原型对象，看如下代码：

[javascript] view plaincopyprint?
 
  1. function User(){  
  2.         this.name = ‘ajun’;  
  3.         this.age = 24;  
  4.         this.say = function(){  
  5.             alert(this.name+’ say hello!!’);  
  6.               }  
  7. }  

这个User就会有prototype的属性，引用的时候就可以这样 User.prototype 就可以了，当你new User对象的时候，这个对象就会继承来自User. prototype的所有的属性,而User. prototype又继承自Object.prototype的所有的属性，所以你才可以在你对象上调用toString()等方法，其实他都是Object. Prototype的属性，只是被你的对象继承过来了而已，在这里你可以理解为java的类得继承，子类继承父类。

有prototype的概念，我们就可以通过prototype给User添加方法、属性了，这样以后每个user对象都共享方法和属性，而不是每个对象都会有他们的副本了。

 

[javascript] view plaincopyprint?
 
  1. function User(){  
  2.         this.name = ‘ajun’;  
  3.         this.age = 24;  
  4. }  
  5. User. prototype. say = function(){  
  6.         alert(this.name+’ say hello!!’);  
  7. }  
  8. var user = new User();  
  9. user.say();  
  10. var user2 = new User();  
  11. user2.say();  

这样我们在new 完一个User对象的时候,调用完这个方法的时候，他还可以供其他方法继续使用。

 

 

3.2原型链



 

每个 JavaScript对象都继承一个原型链，而所有原型都终止于 Object.prototype。注意，迄今为止您看到的这种继承是活动对象之间的继承。它不同于继承的常见概念，后者是指在声明类时类之间的发生的继承。因此，JavaScript 继承动态性更强。它使用简单算法实现这一点，如下所示：当您尝试访问对象的属性/方法时，JavaScript 将检查该属性/方法是否是在该对象中定义的。如果不是，则检查对象的原型。如果还不是，则检查该对象的原型的原型，如此继续，一直检查到 Object.prototype。

 JavaScript 动态地解析属性访问和方法调用的方式产生了一些特殊效果：

   @ 继承原型对象的对象上可以立即呈现对原型所做的更改，即使是在创建这些对象之后。

   @ 如果在对象中定义了属性/方法 X，则该对象的原型中将隐藏同名的属性/方法。例如，

     通过在 User.prototype 中定义 toString 方法，可以改写Object.prototype 的 toString 方法。

   @ 更改只沿一个方向传递，即从原型到它的派生对象，但不能沿相反方向传递。

例子：

[javascript] view plaincopyprint?
 
  1. function User(){  
  2.         this.name = ‘ajun’;  
  3.         this.age = 24;  
  4. }  
  5. User. prototype. toString = function(){  
  6.         alert(this.name+’ say hello!!’);  
  7. }  
  8. var user = new User();  
  9. user. toString ();  

此时Object.prototype的toString会被覆盖掉。这样就不会调用Object.prototype的toString了，也就不会输出[Object Object],而输出的是ajun say hello!!了

 

 

4.静态属性和方法



 

有的时候 ，你想不想就像java中那样，通过类直接来操作你的属性和方法，其实在java中这些都是静态属性啦，直接通过类名来引用，在JavaScript中也是可以做的，请看下面的代码：

[javascript] view plaincopyprint?
 
  1. function User(){}  
  2. User.age = 12;  
  3. User.name = ‘ajun’;  
  4. User.say = function(){  
  5.         return ‘ajun’;  
  6. }  
  7. alert(User.say());  

之后就可以用方法名字直接引用你的方法或者属性了，而不用在new一次对象了。

 

 

5.私有属性


正常情况下，无法从函数以外访问函数内的本地变量。函数退出之后，由于各种实际原因，该本地变量将永远消失。但是，如果该本地变量被内部函数的闭包捕获，它就会生存下来。这一事实是模拟 JavaScript 私有属性的关键，如：

 

 

[javascript] view plaincopyprint?
 
  1. function User(name,age){  
  2.     this.setName = function(newName){  
  3.          name = newName;//name相当于setName的name属性  
  4.     };  
  5.     this.getName = function(){  
  6.         return name;  
  7.     }  
  8.     this.getAge = function(){   
  9.         return age;   
  10.     };  
  11.     this.setAge = function(newAge){   
  12.         age = newAge;   
  13.     };  
  14. }  
  15. var user = new User(‘ajun‘,24);  
  16. alert(user.getName)//ajun  
  17. user.setName(‘lisi‘,12);  
  18. var newName = user.getName();  
  19. alert(newName);//lisi  

 

或者这样也是可以模拟似有属性的，因为name超出其作用域，是不可以被访问的

[javascript] view plaincopyprint?
 
  1. function User (name, age) {  
  2.     var name;  
  3.     this.getName = function() { return name; };  
  4. this.setName = function(newName) {  
  5.  name =  newName;   
  6. };  
  7. }  
  8. var user = new User (‘ajun’,12);  
  9. user. setName(‘qq‘);  
  10. alert(p.getName());  

注意：你设定的私有属性，是不能被这个方法内的其他公共方法访问的(指的是共享的方法，通过User.prototype定义的方法)，这一点和java是不类似的

 

只能通过在其闭包内拥有这些私有成员的方法来访问私有成员

如：下面的代码 ，是不可以工作的

 

[javascript] view plaincopyprint?
 
  1. User.prototype.somePublicMethod= function() {  
  2.     alert(this.getName());  
  3. }  

 

 

5.命名空间


这里所说的命名空间就相当于我们在java中使用包的概念，这样可以防止方法名冲突，代码如下：

 

 

[javascript] view plaincopyprint?
 
  1. //命名空间  
  2. var AJUN = {};  
  3. AJUN.Examples = {};  
  4. AJUN.Examples.User=function(){  
  5.     this.setName = function(newName){  
  6.          name = newName;  
  7.     };  
  8.     this.getName = function(){  
  9.         return name;  
  10.     }  
  11.     this.getAge = function(){   
  12.         return age;   
  13.     };  
  14.     this.setAge = function(newAge){   
  15.         age = newAge;   
  16.     };  
  17. }  
  18. var user = new AJUN.Examples.User();  
  19. user.setName(‘ajun‘);  
  20. alert(user.getName());  


补充：其实用javascript还可以实现类继承等，会用到prototype属性，后续会补上。。。。偷笑

 

http://blog.csdn.net/ajun_studio/article/details/6837182

 

JavaScript OOP 思想


联系
我们