面向对象的程序设计(JS)

1    创建自定义对象，再添加属性和方法同时带有一些特征值，而JavaScript解释通过这些特征值定义它们的行为的。那么就有这三个方法是对属性的特征行为读写：

//描述符对象(configurable、enumerable、writrable和value)无法直接使用需要用下面的方法操作;

 Object.defienProprety();//对属性的特性行为操作，三个参数：属性所在的对象、属性的名字，一个描述符对象;
 Object.definenProperties();//通过描述符定义多个属性，两个参数:要添加和修改属性的对象，对第一个参数对应的变动的值；
 Object.getOwnPropertyDescriptor();//取给定属性的描述符，两个参数属性所在的对象，要读取其描述符的属性名称；

2  工厂模式：用函数来封装以特定接口创建对象的细节

function createPerson(name, age, job) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function (){
        alert(this.name);
    };
    return o;        
}    
var person1 = createPerson("Tom", 22, "Student");
var person2 = createPerson("Greg", 24, "Doctor");

　　函数creatPerson()能够根据接收的参数来构建一个包含所有必要信息的Person对象。每次调用就每次返回一个包含三个属性一个方法的对象。

　　工厂模式虽然解决了创建的多个相似对象的问题，但却没有解决对象识别的问题(即怎样知道一个对象的类型)，

3  构造函数模式：创建特定的类型的对象

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function (){
       alert(this.name);    
  };    
}
var person1 = new Person("Tom", 22, "student");
var person2 = new Person("Greg", 24, "Doctor");

　　其中没有显示对象，直接将属性和方法赋值了this对象保存，没有return语句(构造函数相似不反回值下，默认返回新对象实例)；

　　注意创建Person新实例，必须用 new 操作符，由此调用构造函数会经历4个步骤：

　　　　(1)创建一个对象；

　　　　(2)将构造函数的作用域赋给新的对象(因此this就只想了这个新对象)；

　　　　(3)执行构造函数中的代码（为这个新对象添加属性）；

　　　　(4)返回新对象；

　　缺点：每个方法都要在每个实例上重新创建一遍。

4  原型模式：每个函数都有一个prototype(原型)属性，将信息直接添加到原型对象中，在共享

function Person() {}
Person.prototype.name = "Tom";
Person.prototype.age = 22;
Person.prototype.job = "student";
Person.prototype.sayName = function (){
  alert(this.name);  
};
var person1 = new Person();
person1.sayName(); //"Tom"
var person2 = new Person();
person2.sayName(); //"Tom"
alert(person1.sayName == person2.sayName); //true

　　将sayName()方法和所有属性直接添加到了Person的prototype属性中，构造函数变成了空函数，但是仍可调用构造函数创建，并新对象拥有相同的属性和方法。

5  动态原型模式：通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型

function Person(name, age, job){
  //属性
  this.name = name;    
  this.age = age;
  this.job = job;
  //方法
  if (typeof this.sayName != "function"){
        Person.prototype.sayName = function (){    
            alert(this.name);
        }
    }  
}
var friend = new Person("Tom"， 22， "student");
friend.sayName();

　　注意在加粗的部分，需要sayName()不存在下，才能添加到原型中。在初次调用执行就会完成初始化，这里对原型所做的修改，都能立即在所有实例中得到反映。

　　使用动态原型模式时，不能使用对象字面量重写原型，否则会切断现有实例与新原型之间的联系。

6  寄生构造函数模式：基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后返回新创建的对象(类似典型构造函数)

function Person(name, age, job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function (){
        alert(this.name);    
    };
    return o;
}
var friend = new Person("Tom", 22, "student");
friend.sayName(); //"Tom"

　　除了new操作符把使用包装函数叫做构造函数外，就是工厂模式。返回的对象与构造函数或构造函数的原型属性之间没有关系。

7  稳妥构造函数模式：类似寄生模式，但不引用this，也不用new操作符调用构造函数

function Person(name, age, job){
    //创建要返回的对象
    var o = new Object();
    //可以定义私有书变量和函数
   
    //添加方法  
    o.sayName = function (){
        alert(name);    
    };
    //返回对象
    return o;
}
//注意，这个模式对象中，除了sayName()方法外，就无法访问name的值；可以像下使用
var friend = new Person("Tom", 22, "student");
friend.sayName(); //"Tom"    

　　变量friend中保存的是一个稳妥对象，除了调用sayName()方法外，没有其他方法可以访问其数据成员。适合在安全执行环境。

 

个人笔记，有点乱，有错望指正！