javascript中创建对象的方式

/*javascript中创建对象的方式(js中没有类的概念)*/

//1.基于已有对象扩充器属性和方法

var object=new Object();
object.name="zhangsan";
object.setName=function(name){//这种方式有弊端: 在创建另一个对象时,其它的对象不能使用该方法,需要重新定义
       this.name=name;
}
object.getName=function(){
       return this.name;
}
alert(object.name);//zhangsan
object.setName("zhanfei");
alert(object.name);//zhangfei
alert(object.getName());

//2.工厂方式创建对象:(类似于java中的静态工厂方法)

function createObject(username,password){//调用方法时为属性赋值
       var object=new Object();
       object.username=username;
       object.password=password;//在java中: 一个类有属性有方法,不管定义了多少个方法,不管生成多少个对象,方法只有一份,会被多个对象共享,在对象调用方法时会隐含的传一个this的引用表示是谁调用的这个方法
       object.getUsername=function(){//我们期望,不管创建多少个对象,方法只有一份,属性有多份---改成多个对象共享一个方法
              return this.username;
       }
       object.getPassword=function(){
              return this.password;
       }
       object.setUsername=function(name){
              this.username=name;
       }
       object.setPassword=function(pwd){
              this.password=pwd;
       }
       return object;
}

//var object=createObject();
//alert("username: "+object.username+", password: "+object.password);
//object.setUsername("lisi");
//object.setPassword("234");
//alert("username: "+object.username+", password: "+object.password);
var object=createObject("wangwu","123");
alert(object.getUsername()+","+object.getPassword());//在调用一个对象的方法时,如果没有写小括号就会把该方法的定义以字符串的形式显示出来
object.setUsername("lisi");
object.setPassword("234");
alert(object.getUsername()+","+object.getPassword());

//改成多个对象共享同一个方法的方式:(上面那种方式创建对象的方法会为每一个对象都创建方法)
//创建共享方法对象  --缺点:对象的定义与方法的定义分离,容易造成误解

function getUsername(){
       return this.username;
}
function getPassword(){
       return this.password;
}
function setUsername(name){
       this.username=name;
}
function setPassword(pwd){
       this.password=pwd;
}

function createObject(username,password){//调用方法时为属性赋值
       var object=new Object();
       object.username=username;
       object.password=password;//在java中: 一个类有属性有方法,不管定义了多少个方法,不管生成多少个对象,方法只有一份,会被多个对象共享,在对象调用方法时会隐含的传一个this的引用表示是谁调用的这个方法
       object.getUsername=getUsername;//我们期望,不管创建多少个对象,方法只有一份,属性有多份---改成多个对象共享一个方法
       object.getPassword=getPassword;//------------将对象的方法指向外部创建的方法,这样就可以实现方法的共享


       object.setUsername=setUsername;
       object.setPassword=setPassword
       return object;
}


var object=createObject("wangwu","123");
alert(object.getUsername()+","+object.getPassword());//在调用一个对象的方法时,如果没有写小括号就会把该方法的定义以字符串的形式显示出来
object.setUsername("lisi");
object.setPassword("234");
alert(object.getUsername()+","+object.getPassword());

//3.构造函数方式:

function Person(username,password){//只有在使用new来创建该对象时,下面注释中的解释才成立,直接调用Person方法则不会有注释中的情况发生
//1.在执行第一行代码前,js引擎会为我们生成一个对象(this)
       this.username=username;
       this.password=password;
       this.getInfo=function(){
              alert(this.username+", "+this.password);
       }
//2.此处有一个隐藏的return语句,用于将之前生成的对象返回
}
var person=new Person("zhangsan","123");
person.getInfo();

//4.原型("prototype")方式(prototype是object中的一个属性对象,所以每一个对象都会拥有该属性)

function Person(){//空对象

}
Person.prototype.username="zhangsan";//给Person的prototype属性附加username属性,此时我们就宣称Person对象也就拥有了username这个属性
//给一个对象的原型属性附加的任何内容,都会直接的被对象访问到
//我们可以根据一个对象的原型给它赋上属性,方法 原型所属的对象就宣称它拥有了这些属性也拥有了这些方法
Person.prototype.password="123";
Person.prototype.getInfo=function(){
       alert(this.username+", "+this.password);
}
var person=new Person();
var person2=new Person();
person.username="lisi";//改变person对象的username属性,对person2没任何影响,实际上是我们使用了字符串造成的巧合而已,对于字符串来说在java中是不变的,对于javascript来说字符串也是不变的(它也是个常量)
person.getInfo();
person2.getInfo();
//---------------------
function Person(){//空对象

}
Person.prototype.username=new Array();
Person.prototype.password="123";
Person.prototype.getInfo=function(){
       alert(this.username+", "+this.password);
}
var person=new Person();
var person2=new Person();
person.username.push("lisi");
person.username.push("zhangsan");//改变person对象的username属性,对person2没任何影响,实际上是我们使用了字符串造成的巧合而已,对于字符串来说在java中是不变的,对于
person.password="456";
person2.password="000";
person.getInfo();
person2.getInfo();
//--结果 在为person对象push元素时也改变了person2对象的username属性
//单纯的使用原型这种方式有两个很重要的问题:
//1. 无法在构造函数中为属性赋初始值,只能在生成对象后再去改变属性的值
//2. 会导致程序错误,如果使用原型方式对象,那么生成的所有对象会共享原型中的属性,这样一个对象改变了该属性也会反应到其他对象中
//--对于字符串对象js和java是一样的(都是不变的),一旦改变一个字符串对象,实际上会把引用指向新的字符串对象

//5.使用原型+构造函数方式来定义对象(将属性定义在构造方法中[不共享],将方法定义在原型中[共享])

function Person(username,password){//把属性定义在构造方法中----每个对象都会独立的拥有各自的属性
       this.username=username;
       this.password=password;
}
Person.prototype.getInfo=function(){//把方法定义在原型当中----对于所有对象都会共享该方法
       alert(this.username+", "+this.password);
}
var person=new Person("张三","123");
person.getInfo();

//6.动态原型方式 :在构造函数中通过标志量让所有对象共享一个方法,而每个对象都拥有自己的属性

function Person(){
       this.username="zhangsan";
       this.password="123";
       if(typeof Person.flag == "undefined"){//flag标识
              alert("invoked");//只生成一个方法对象,所以这里只执行一次
              Person.prototype.getInfo=function(){
              alert(this.username+", "+this.password);
              }
              Person.flag=true;
       }
}
var person=new Person();
person.getInfo();
var person2=new Person();
person2.getInfo();