1.工厂方式
工厂方式是指创建一个返回特定对象类型的工厂函数
eg.
　　function createObject(){
　　　　var object = new Object();
　　　　object.username = "zhangsan";
　　　　object.password = "123";

　　　　object.get = function(){
　　　　　　alert(this.username + ", " + this.password);
　　　　}
　　　　return object;
　　　　}

　　var object1 = createObject();
　　var object2 = createObject();

　　object1.get();
但是问题也来了，就是每创建一个对象，对象的方法是新对象，很浪费资源；

2.构造函数方式

方法类似：
eg.
　　function Car(sColor,iDoors,iMpg){
　　　　this.color=sColor;
　　　　this.doors=iDoors;
　　　　this.mpg=iMpg;
　　　　this.showColor=function(){
　　　　　　alert(this.color);
　　　　}
　　}
　　var oCar1=new Car("red",4,23);
　　var oCar2=new Car("blue",3,25);
它的问题与上面一样；

3、原型方式
该方式利用了对象的prototype属性，可把它看成创建新对象所依赖的原型。

eg.
　　function Person(){
　　　　Person.prototype.username = "zhangsan";

　　　　Person.prototype.password = "123";

　　　　Person.prototype.getInfo = function(){

　　　　　　alert(this.username + ", " + this.password);
　　　　}

　　}

　　var person = new Person();
　　var person2 = new Person();

　　person.getInfo();

　　person2.getInfo();

使用原型的缺点：

　　1.不能传参数；

　　2.所有对象共享属性,有可能会导致程序错误。

　　如果使用原型方式来定义对象，那么生成的所有对象会共享原型中的属性，这样一个对象改变了该属性也会反映到其他对象当中。

　　单纯使用原型方式定义对象无法在构造函数中为属性赋初值，只能在对象生成后再去改变属性值。

4.混合的构造函数/原型方式
eg.
　　function Person(name){
　　　　this.name = name;
　　}
　　Person.prototype.say = function(){
　　　　alert("I am "+this.name);
　　}
　　var p1 = new Person("wang");
　　var p2 = new Person("li");
　　p1.say();
　　p2.say();
　　alert(p1.say==p2.say); 
5、动态原形方式
在构造函数中通过标志量让所有对象共享一个方法，而每个对象拥有自己的属性。
eg.

　　function Person(){
　　　　this.username = "zhangsan";
　　　　this.password = "123";

　　　　if(typeof Person.flag == "undefined"){
　　　　　　Person.prototype.getInfo = function(){
　　　　　　　　alert(this.username + ", " + this.password);
　　　　　　}

　　　　　　Person.flag = true;

　　　　}
　　}

　　var p = new Person();
　　var p2 = new Person();

　　p.getInfo();
　　p2.getInfo();

对象之间的属性互不干扰，各个对象间共享同一个方法.

js高级（类和对象）