javascript 中的面向对像（一）

var obj = new Object();               //创建一个空对像
    obj.name = '小明';                  //给对像添加一个属性
    obj.showName = function () {      //给对像添加一个方法
        alert(obj.name)
    };
    obj.showName()                    //调用对像的方法;

var obj2 = new Object();              //创建一个空对像
    obj2.name = '小强';                 //给对像添加一个属性
    obj2.showName = function () {     //给对像添加一个方法
        alert(obj.name)
    };
    obj2.showName()                   //调用对像的方法;

//面向对像的工厂方法 （个人理解就是封装方法）

    function createPerson (name) {      //声明一个普通函数接收一个参数;
        var obj = new Object();         // 创建一个空对象
            obj.name=name;              //给对像添加一个属性等于传来的参数
            obj.showName = function(){  //给对像添加一个方法
                alert(obj.name);
            };
        return obj;                     //返回这个对像
    };
    var person1 = createPerson('小明'); //调用函数接收对像
        person1.showName();             //调用对像的方法
    var person2 = createPerson('小强');
        person2.showName();

/**
 *  这种方式创建对像调用时发现和系统中的对像调用方式不一样
 *  如系统中 var arr = new Array(); 少了一个new;其实是封到createPerson普通函数里面了
 *  可以继续改写
 */ 

    function createPerson(name) {
        this.name=name;
        this.showName = function (){
            alert(this.name);
        }
     };
    var person1= new createPerson('小明');
        person1.showName();
    var person2= new createPerson('小强');
        person2.showName();

/**
 *  会发现这种方式多了个this,js语法中当用new调用一个函数时，
 *  这个函数中的this就指创建出来的对像，并且是隐式返回，
 *  new后面调用的函数是当前对像的构造函数

/**
* 调用person1.showName和person2.showName
*/
console.log(person1.showName)
console.log(person2.showName)

      /**
       *    运行结果都是
       *    function (){
       *        alert(this.name);
       *    }
       */
     ` console.log(person1.showName== person2.showName) ` //false

   /**
    * 这就会很奇怪，既然结果相同，而进行比较时得出的结果却是false
    * 牵出js 中的数据类型，引用类型和基本类型的区别。
    */

 var a=5;
        var b=a;
            b+=5;
            console.log(b);         //10
            console.log(a);         //5
            console.log(a==b)       //true;

        var arr=[1,2,3];
        var arr2=arr;
            arr2.push(4);
            console.log(arr);       //1,2,3,4
            console.log(arr2);      //1,2,3,4
            console.log(arr==arr2); //true

        var arr3=[1,2,3];
        var arr4=arr3;
            arr4=[1,2,3,4];
            console.log(arr4);      //1,2,3,4
            console.log(arr3);      //1,2,3
            console.log(arr3==arr4) //false;

        /**
         * 以上三个例子
         * 第一个，是基本类型，基本类型的赋值只是值的拷贝，
         * 比较也是只是值的比较，比较好理解。
         * 第二个，是引用类型，引用类型的赋值是地址的引用，比较也是引用地址的比较，
         * 声明arr=[1,2,3],等于内存中开辟一块空间，存放着arr的值。
         * 把arr赋值给arr2，等于把存放着arr值的内存空间地址赋值给了arr2，这时arr和arr2所指向的
         * 是同一个内存空间地址，所以修改任何一个的值，都同等于修改同一个内存空间的值。比较当然
         * 也是true了
         * 第三个，同样是引用类型，arr3赋值给arr4,同样是地址的引用，但到了arr4=[1,2,3,4]这一步
         * 赋值时，只要在程序中出现赋值，必然在内存中重新生成，又在内存中开辟了一个新的地址。
         * arr4指向这个新的地址，所以互不影响，比较当然false
         */
         /**
          * 根据以上三个例子，得出一个结论 person1.showName和person2.showName在内存中存在两份
          * 也就是new n+个person,就会有n+份person.showName,
          * 同样一个方法在内存中存在这么多就会显得浪费内存空间。
          * 所以面向对像中有prototype，原型的概念就是让同样的方法和属性在内存中只存在一份，
          * 这样就会提高性能，减少浪费。
          * 原型写在构造函数上，公用部分写在原型上面，可以改写成以下：
          */

    function createPerson(name) {
                this.name=name;
            };
            createPerson.prototype.showName=function(){
                alert(this.name);
            };
            var person1= new createPerson('小明');
                person1.showName();
            var person2= new createPerson('小强');
                person2.showName();
            console.log( person1.showName ==person2.showName )  //true

“`