JavaScript 创建对象的4种方法
所谓对象就是用来帮助你完成一些事情是，对象是有特征和行为的，是具体特指的某一个事物。使用对象可以使程序更加整洁

1. 通过Object()方法来创建
   Object()是JavaScript内部的对象，使用Object创建对象的语法：
   
   我们通过Object创建的一个Dog对象，这个对象有name,color,eat属性；并且给这个对象定义了两个方法，因此我们想用这两个方法时可以直接通过 Dog.describe() Dog.language() 来访问，即 对象.方法
   注意：注意这里不能用this.name 应该用Dog.name因为Object()是一个对象，我们的Dog也是创建出来的一个对象，所以用this会是undefined,但是Dog这个describe()方法中使用this就可以，因为是用过这个Dog对象构造出来的函数

2. 同过字面量法创建对象
   var 对象={name:“小明”,age:20,sex:“男”…} 这是字面量表示法的语法 ，缺点:一次性对象，不方便修改，不利于提高效率，一般不建议使用
   
   
   优化版的创建对象，对象中的属性都是在一个整体中，便于访问加粗样式

3. 通过自定义函数创建对象：就是自己定义一个函数，然后赋予它对象的思想。这个函数的名字首字母需要是大写的
   要创建Image的新实例，必须要使用new 操作符。以这种方式调用构造函数实际上会经历一下4个步骤
   （1）创建一个新对象，在内存中开辟一个空闲的空间
   （2）将构造函数的作用域个给新对象（因此this就指向了这个新对象）
   （3）执行构造函数中的代码（为这个新对象添加属性）
   （4）返回新对象
   
   优点：提高代码复用率，代码可以灵活调用，方便修改，自己传的参数是什么就是什么， 既解决的重复实例化的问题又解决了对象识别的问题
   缺点：没有显示的创建对象，直接将属性和方法赋给了this对象，没有return语句

4. 通过工厂模式创建对象
   
   语法：function create 对象名() 这里我们用Object能够根据接受的参数来构建一个包含所有必要信息的 Object对象。可以无数次的调用这个函数，而每次它都会返回一个包含三个属性一个方法的对象。工厂模式虽然解决了创建多个相似对象的问题，但是却没有解决对象识别的问题（即怎样知道一个对象的类型）

方式1：调用系统的构造函数创建对象

表达式: var 变量名= new Object();

例子：
			//实例化对象,创建对象
			var obj = new Object();
			//对象有特征和行为 （属性和方法）
			//添加属性-----如何添加属性?          对象.名字=值;
			obj.name = "小明";
			obj.age = 38;
			obj.sex = "女";
			//添加方法----如何添加方法?       对象.名字=函数;   （匿名函数）
			obj.eat = function () {
			       console.log("吃饭，这是一个方法");
			 };
			obj.play = function () {
			            console.log("我喜欢玩飞机模型");
			 };
			console.log(obj.name);//获取--输出了
			//方法的调用
			 obj.eat();
			 obj.play();

方式2:自定义构造函数创建对象

表达式: var 变量名 = new 自定义构造函数
函数和构造函数的区别: 名字是不是大写(构造函数首字母是大写的)

例子:
	        //自定义构造函数
	        function Person(name,age) {
	            this.name = name;
	            this.age = age;
	            this.sayHi=function () {
	                console.log("我叫:"+this.name+",年龄是:"+this.age);
	            };
	        }
	
	        //自定义构造函数创建对象:先自定义一个构造函数,然后new创建对象
	        var obj=new Person("小明",18);
	        console.log(obj.name);
	        console.log(obj.age);
	        obj.sayHi();
	
	        var obj2=new Person("小红",20);
	        console.log(obj2.name);
	        console.log(obj2.age);
	        obj2.sayHi();

方式3:字面量的方式创建对象

例子：
//变量，数组 字面量方式创建的创建
/*    var num = 10;
      var array = []; 
*/
				 var obj = {};   //空对象
				 //添加属性
				 obj.name= "小白";
				 obj.age = 20;
				 //添加方法
				 obj.sayHi = function () {
				       console.log("我是"+this.name+"今年"+this.age+"岁")
				 };      //末尾记得加 ;
				 obj.sayHi();


优化后的写法：
				 /*多个属性方法用逗号隔开，最后的不用加逗号*/
		        var obj = {
		            name:"小明",
		            age:18,
		            sayHi:function () {
		                console.log("我是"+this.name+"今年"+this.age+"岁");
		            },
		            eat:function () {
		                console.log("吃了");
		            }
		        };
		        obj.sayHi();
		        obj.eat();

1、工厂模式

 工厂模式是用函数来封装创建对象的细节，在函数里面创建对象并返回对象，就有些像工厂里的流水线一样。

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("a",29,"cc");
var person2 = createPerson("b",26,"cc"); 

但是工厂模式有个缺点，就是对象识别问题，即它不知道一个对象的类型。

2、构造函数模式

构造函数模式，即通过给构造函数传递不同的参数，然后调用构造函数来创建不同对象。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayname = function(){
        alert(this.name);
    };
}
var person1 = new Person("a",29,"cc");
var person2 = new Person("b",26,"cc");

使用自定义的构造函数，可以将它的实例标识为一种特定的类型，这正是构造函数模式胜过工厂模式的地方。

比如（instanceof用于检测对象类型）：

person1 instanceof Person  //true    这里可以看到person1也是Person的实例，而工厂模式没有能具体检测对象类型的这一特定
person1 instanceof Object //true    所有对象均继承自Object

构造函数模式的主要问题，就是每个方法都要在每个实例对象上重新创建一遍，j即使是同名方法或者两个方法的作用一样，而不同实例对象上的同名方法其实是不一样的，这样就造成了一种冗余，比如：

person1.sayname != person2.sayname

3、原型模式

有关原型和原型链的知识已经在点击打开链接介绍过了，这里不作过多介绍。

使用原型对象的好处就是，可以让所有对象实例共享它所包含的属性和方法。

function Person(){}
Person.prototype.name="a";
Person.prototype.age="29";
Person.prototype.job="cc";
Person.prototype.sayname = function(){
        alert(this.name);
};
var person1 = new Person();
var person2 = new Person();
这样person1.sayname == person2.sayname

还有就是重写原型的时候，切断了现有原型与任何之前已存在的对象实例之间的联系，它们引用的仍是最初的原型。可以通过在重写原型里添加constructor:Person来建立新联系。

原型模式的问题就是共享问题，在实例或原型上改变一下，在其他实例中都会相应的改变。这样我们引入组合使用构造函数模式和原型模式。

4、组合使用构造函数模式和原型模式

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
}
Person.prototype = {
    constructor: Person,
    sayname: function(){
        alert(this.name);
    }
}
var person1 = new Person("a",29,"cc");
var person2 = new Person("b",26,"cc");

这种构造函数与原型混合的模式，是目前使用较多的。其它创建对象的方式还有动态原型模式、寄生构造函数模式、稳妥构造函数模式。