第一种：new一个Object的实例。
    通过object构造器new一个对象，再丰富成员信息。

    1. <script>
    2.         //创建对象
    3.         var obj1=new Object();
    5.         //设置对象属性的第一种方法
    6.         obj1.name="刘鸿伟";
    7.         obj1.age=20;
    9.         //设置对象属性的第二种方法
    10.         obj1["123"]=123;
    11.         obj1["1242536"]="孙悟空";
    12.         var n="1242536";
    14.         //取
    15.         console.log(obj1.name);
    16.         console.log(obj1["123"]);
    17.         //[]里面可以传递一个变量，这样的话就比较灵活
    18.         console.log(obj1[n]);
    19.     </script>
    1. <script>
    2.         /*
    3.          * 对象的属性值可以是任意类型，甚至是对象，例如：
    4.          */
    5.       var obj1=new Object();//创建第一个对象
    7.         var obj2=new Object();//创建第二个对象
    8.         obj2.name="曾志勇";
    9.         obj2.age=19;
    11.         //设置对象属性：将obj1的属性值person设置为对象obj2
    12.         obj1.person=obj2;
    13.         console.log(obj1.person);//打印一下obj这个对象的属性person(是一个对象)。
    14.         console.log((obj1.person).name);//打印一下obj对象的属性person(对象)的属性值。
    15.         console.log((obj1.person).age);//打印一下obj对象的属性person(对象)的属性值。
    16.     </script>
    1. <script>    
    2.         /*
    3.          * 对象的属性值可以是任意类型，甚至是函数,
    4.          * 如果一个函数作为一个对象的属性保存，那么我们称这函数是这对象的方法
    5.          * 调用函数就说是调用对象的方法
    6.          */
    7.       var obj=new Object();//创建一个对象    
    8.         obj.name="猪八戒";
    9.       //给对象的属性设置为函数
    10.         obj.sayHello=function(){
    11.             console.log("HelloWorld");
    12.         };
    13.         //调用一下对象的这个属性，即调用对象的方法
    14.         obj.sayHello();
    15.     </script>

    第二种：使用对象字面量模式。
    将成员信息写到{}中，并且赋值给一个变量。此时的这个变量就是一个对象

    1. <script>    
    2.         /*
    3.          * 使用对象字面量可以在创建对象时，直接指定对象的属性
    4.          * 对象的属性名，可以加引号，也可以不加，建议不加，如果需要使用一些特殊的名字作为属性值，             则必须加引号
    5.          */
    6.         var obj={
    7.             name:"猪八戒",
    8.             age:18,
    9.             sex:"男",
    10.             "anchor(42&*A87324)":"傻逼"//这是特殊的名字，属性名必须加引号    
    11.         };
    12.         console.log(obj);//打印对象
    13.        console.log(obj.name);//打印属性        
    14. </script>
    1. <script>
    2.         /*
    3.          * 在使用对象字面量创建对象的过程中，同样也可以将属性值指定为一个对象
    4.          */
    5.         var obj={
    6.             name:"孙悟空",
    7.             age:1000,
    8.             //这里将test的属性值指定为一个对象
    9.             test:{
    10.                 name:"沙和尚",
    11.                 age:28
    12.             }
    13.         };    
    14.         //调用test属性值里面的对象的属性
    15.         console.log((obj.test).name);
    16.         console.log((obj.test).age);
    17. </script>
    1. <script>
    2.         /*
    3.          * 在使用对象字面量创建对象的过程中，同样也可以将属性值设置为一个函数
    4.          */
    5.         var obj={
    6.             name:"猪八戒",
    7.             age:24,
    8.             //这里将sayHello的属性值指定为一个函数
    9.             sayHello:function(){
    10.                 console.log("Hello")
    11.             }            
    12.         };        
    13.         //调用sayHello的属性——函数
    14.         obj.sayHello();    
    15. </script>

    第三种：使用工厂模式。

    1. <script>        
    2.             /*
    3.              * 使用工厂方法创建对象
    4.              */
    5.             function creatPerson(name,age,sex){
    6.                 //先创建一个对象
    7.                 var obj=new Object();        
    9.                 //赋值
    10.                 obj.name=name;
    11.                 obj.age=age;
    12.                 obj.sex=sex;
    13.                 obj.sayName=function(){
    14.                     console.log(this.name);
    15.                 };            
    17.                 //返回一个对象
    18.                 return obj;                
    19.             }
    21.             //使用工厂方法，获取三个对象
    22.             var obj1=creatPerson("孙悟空",19,"男");
    23.             var obj2=creatPerson("猪八戒",20,"男");
    24.             var obj3=creatPerson("白骨精",20,"女");
    26.             //打印一下三个对象
    27.             console.log(obj1);
    28.             console.log(obj2);
    29.             console.log(obj3);    
    31.             //调用一下对象里面的方法
    32.             obj1.sayName();
    33.             obj2.sayName();
    34.             obj3.sayName();
    36.         </script>

    第四种：使用构造函数模式。

    1. <script>                
    2.             /*
    3.              * 利用构造函数来创建对象
    4.              * 语法格式：
    5.              *         function  构造函数名(){
    6.              *               this.属性=值；
    7.              *               this.方法=function() {};
    8.              *         }
    9.              * 
    10.              * new 构造函数名();
    11.              */
    13.         /*
    14.          * 1，构造函数首字母一般大写
    15.          * 2，构造函数不需要return就可以返回结果
    16.          * 3，我们调用构造函数必须使用new
    17.          */
    18.       //创建一个构造函数
    19.         function Star(name,age,sex){
    20.             this.name=name;
    21.             this.age=age;
    22.             this.sex=sex;
    23.             this.say=function(sang){
    24.                 console.log(sang);
    25.             }
    26.         }
    28.       //使用构造函数创建对象
    29.         var obj=new Star("刘德华",18,"男");
    30.       //打印对象的属性,调用方法
    31.         console.log(obj);
    32.         console.log(obj.name);
    33.         console.log(obj.age);
    34.         console.log(obj.sex);
    35.         obj.say("冰雨");
    37.       //使用构造函数创建另外一个对象
    38.         var obj2=new Star("张学友",19,"男");
    39.       //打印对象的属性，调用方法
    40.         console.log(obj2);
    41.         obj2.say("李香兰");
    43.     </script>