1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)：
var obj = new Object()
obj.name="userObject"
obj.printName = function(name){
this.name = name
alert(this.name)
}
obj.printName("newUserObject")
2.工厂方式创建对象(每次创建一个object后，其中对应的方法(本例中是get)也被创建一次，方法不能被所创建的所有对象(本例中是obj1和obj2)共享)：
a.
function createObject(){
var obj = new Object()
obj.name="userObject"
obj.password = "12345"
obj.get = function(){
alert(this.name + ", " + this.password)
}
return obj
}
var obj1 = createObject()
var obj2 = createObject()
obj1.get()
obj2.get()
b.带参数的构造方法：
function createObject(username,password){
var obj = new Object()
obj.username = username
obj.password = password
obj.get = function(){
alert(this.username + ", " + this.password)
}
return obj
}
var obj1 = createObject("zhangsan","123456")
obj1.get()
c.让函数被多个创建的对象所共享，而不是每一个对象都创建一个相同的函数(缺点:对象定义本身和方法分离了)：
function get(){
alert(this.username + ", " + this.password)
}
function createObject(username,password){
var obj = new Object()
obj.username = username
obj.password = password
obj.get = get
return obj
}
var obj1 = createObject("zhangsan","123456")
var obj2 = createObject("lisi","54321")
obj1.get()
obj2.get()
3.构造函数方式：
a.
function Person(){
this.username = "zhangsan"
this.password = "123"
this.getInfo = function(){
alert(this.username + ", " + this.password)
}
}
var person = new Person()
person.getInfo()
b.可以在构造函数是传递参数：
function Person(username,password){
this.username = username
this.password = password
this.getInfo = function(){
alert(this.username + ", " + this.password)
}
}
var person = new Person("zhangsan","123")
person.getInfo()
4.使用原型(prototype)方式创建对象：
优点：创建的多个对象共享同一个方法(getInfo)
缺点：创建的多个对象在共享同一个方法的同时也共享了同样的属性(username,password)，实际开发中这样儿是
不行的，必须是多个对象都要有自己的属性。
采用该方式创建对象通常是用来扩展已有对象的某一个方法。
a.
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.username = "lisi"
person.getInfo()
person2.getInfo()
b.如果使用原型方式创建对象，那么生成的所有对象将会共享原型中的属性，这样儿一个对象改变了该属性也会反应到其他的对象上：
function Person(){}
Person.prototype.username = new Array(0
Person.prototype.password = "123"
Person.prototype.getInfo = function(){
alert(this.username + ", " + this.password)
}
var person = new Person()
var person2 = new Person()
person.username.push("zhangsan")
person.username.push("lisi")
person.password = "456"
person.getInfo()
person2.getInfo()
c.使用原型和构造函数方式来创建对象：
function Person(){
this.username = new Array()
this.password = "123"
}
Person.prototype.getInfo = function(){
alert(this.username + ", " + this.password)
}
var person = new Person()
var person2 = new Person()
person.username.push("zhangsan")
person.username.push("lisi")
person.getInfo()
person2.getInfo()
5.动态原型方式：在构造函数中通过标志量让所有对象共享一个方法，而每个对象拥有自己的属性。
function Persion(){
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()
1.对象字面量。var clock={
hour:12,
minute:10,
second:10,
showTime:function(){
alert(this.hour+":"+this.minute+":"+this.second)
}
}
clock.showTime()//调用
2.创建Object实例
var clock = new Object()
clock.hour=12
clock.minute=10
clock.showHour=function(){alert(clock.hour)}
clock.showHour()//调用
由此可见 属性是可以动态添加，修改的
对象创建模式：
1.工厂模式：就是一个函数，然后放入参数，返回对象，流水线工作
function createClock(hour,minute,second){
var clock = new Object()
clock.hour=hour
clock.minute=minute
clock.second=second
clock.showHour=function(){
alert(this.hour+":"+this.minute+":"+this.second)
}
return clock
}
var newClock = createClock(12,12,12)//实例化
newClock.showHour()//调用
优点：总算优点抽象的概念了。但是不能识别对象的类型呢！
2.构造函数模式
function clock(hour,minute,second){
this.hour = hour
this.minute = minute
this.second = second
this.showTime = function(){
alert(this.hour+":"+this.minute+":"+this.second)
}
}
var newClock =new clock(12,12,12)
alert(newClock.hour)
注意:这个new关键字是必须，如果不加，clock就不会当成构造函数调用，而只是一个普通的函数。同时，还会意外地给他的外部作用域即window添加属性，因为此时构造函数内部的this已经映射到了外部作用域了。所以为了安全起见，可以这样创建
function clock(hour,minute,second){
if(this instanceof clock){
this.hour = hour
this.minute = minute
this.second = second
this.showTime = function(){
alert(this.hour+":"+this.minute+":"+this.second)
}
}
else{
throw new Error("please add 'new' to make a instance")
}
}
构造函数的缺点：由于this指针在对象实例的时候发生改变指向新的实例。这时新实例的方法也要重新创建，如果n个实例就要n次重建相同的方法。于是让来揭开原型模式吧
3.原型模式
function clock(hour,minute,second){
}
clock.prototype.hour=12
clock.prototype.minute=12
clock.prototype.second=12
clock.prototype.showTime=function(){
alert(this.hour+":"+this.minute+":"+this.second)
}
var newClock = new clock()
newClock.showTime()
深度理解原型模型很重要，
首先，每个函数都有一个prototype(原型)属性，这个指针指向的就是clock.prototype对象。而这个原型对象在默认的时候有一个属性constructor，指向clock，这个属性可读可写。而当在实例化一个对象的时候，实例newClock除了具有构造函数定义的属性和方法外（注意，只是构造函数中的）,还有一个指向构造函数的原型的指针，ECMAScript管他叫[[prototype]]，这样实例化对象的时候，原型对象的方法并没有在某个具体的实例中，因为原型没有被实例。（废话有点多，没有误导您吧。别晕）
所以这种模式定义的对象，在调用方法的时候过程：调用newClock.showTime()先看实例中有没有，有调之，无追踪到原型，有调之，无出错，调用失败。
当然可以这样写：
function clock(hour,minute,second){
}
clock.prototype={
constructor:clock,//必须手动设置这个属性，不然就断了与构造函数的联系了。没有实例共享原型的意义了。
hour:12,
minute:12,
second:12,
showTime:function(){
alert(this.hour+":"+this.minute+":"+this.second)
}
}
var newClock = new clock()
newClock.showTime()
注意：实例与构造函数原型的联系也是通过指针来联系的，故可以动态添加修改原型的方法。
这种纯原型的模式问题也很明显，所有的属性，方法都是共享的，不能让对象具体化。常常想每个对象有自己的属性。于是，结合前两种，产生新的模式
4.构造-原型组合模式。
function clock(hour,minute,second){
this.hour = hour
this.minute = minute
this.second = second
}
clock.prototype.showTime=function(){alert(this.hour+":"+this.minute+":"+this.second)}
var newClock = new clock(12,12,12)
newClock.showTime()
这里将属性放在构造函数中，更显得对象的具体性。
js中定义对象的几种方式1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)：
var obj = new Object()
obj.name="userObject"
obj.printName = function(name){
this.name = name
alert(this.name)
}
obj.printName("newUserObject")
2.工厂方式创建对象(每次创建一个object后，其中对应的方法(本例中是get)也被创建一次，方法不能被所创建的所有对象(本例中是obj1和obj2)共享)：
a.
function createObject(){
var obj = new Object()
obj.name="userObject"
obj.password = "12345"
obj.get = function(){
alert(this.name + ", " + this.password)
}
return obj
}
var obj1 = createObject()
var obj2 = createObject()
obj1.get()
obj2.get()
b.带参数的构造方法：
function createObject(username,password){
var obj = new Object()
obj.username = username
obj.password = password
obj.get = function(){
alert(this.username + ", " + this.password)
}
return obj
}
var obj1 = createObject("zhangsan","123456")
obj1.get()
c.让函数被多个创建的对象所共享，而不是每一个对象都创建一个相同的函数(缺点:对象定义本身和方法分离了)：
function get(){
alert(this.username + ", " + this.password)
}
function createObject(username,password){
var obj = new Object()
obj.username = username
obj.password = password
obj.get = get
return obj
}
var obj1 = createObject("zhangsan","123456")
var obj2 = createObject("lisi","54321")
obj1.get()
obj2.get()
3.构造函数方式：
a.
function Person(){
this.username = "zhangsan"
this.password = "123"
this.getInfo = function(){
alert(this.username + ", " + this.password)
}
}
var person = new Person()
person.getInfo()
b.可以在构造函数是传递参数：
function Person(username,password){
this.username = username
this.password = password
this.getInfo = function(){
alert(this.username + ", " + this.password)
}
}
var person = new Person("zhangsan","123")
person.getInfo()
4.使用原型(prototype)方式创建对象：
优点：创建的多个对象共享同一个方法(getInfo)
缺点：创建的多个对象在共享同一个方法的同时也共享了同样的属性(username,password)，实际开发中这样儿是
不行的，必须是多个对象都要有自己的属性。
采用该方式创建对象通常是用来扩展已有对象的某一个方法。
a.
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.username = "lisi"
person.getInfo()
person2.getInfo()
b.如果使用原型方式创建对象，那么生成的所有对象将会共享原型中的属性，这样儿一个对象改变了该属性也会反应到其他的对象上：
function Person(){}
Person.prototype.username = new Array(0
Person.prototype.password = "123"
Person.prototype.getInfo = function(){
alert(this.username + ", " + this.password)
}
var person = new Person()
var person2 = new Person()
person.username.push("zhangsan")
person.username.push("lisi")
person.password = "456"
person.getInfo()
person2.getInfo()
c.使用原型和构造函数方式来创建对象：
function Person(){
this.username = new Array()
this.password = "123"
}
Person.prototype.getInfo = function(){
alert(this.username + ", " + this.password)
}
var person = new Person()
var person2 = new Person()
person.username.push("zhangsan")
person.username.push("lisi")
person.getInfo()
person2.getInfo()
5.动态原型方式：在构造函数中通过标志量让所有对象共享一个方法，而每个对象拥有自己的属性。
function Persion(){
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()
