javascript object oriented programming ，一

/*
  * 1. 生成对象的原始模式
  * 这就是最简单的封装了。但是，这样的写法有两个缺点
  *             1.一是如果多生成几个实例，写起来就非常麻烦
  *             2.二是实例与原型对象之间，没有任何办法，可以看出有什么联系
  */

        var Cat = {
                name : '',
                color : ''
        }
　　var cat1 = {}; // 创建一个空对象

　　　　cat1.name = "大毛"; // 按照原型对象的属性赋值

　　　　cat1.color = "黄色";

　　var cat2 = {};

　　　　cat2.name = "二毛";

　　　　cat2.color = "黑色";

        /*
        * 2. 原始模式的改进,我们可以写一个函数，解决代码重复的问题。
        * 这种方法的问题依然是，cat1和cat2之间没有内在的联系，不能反映出它们是同一个原型对象的实例。
        */
        
        function Cat(name,color){
                return {
                        name:name,
                        color:color
                }
        }
        var cat1 = Cat('cat1','red');
        var cat2 = Cat('cat2','blue');
        console.log(cat1);
        console.log(cat2);

        /*
        * 3. 构造函数模式
        *       所谓"构造函数"，其实就是一个普通函数，但是内部使用了this变量。
        *       对构造函数使用new运算符，就能生成实例，并且this变量会绑定在实例对象上
        *
        */

         function Cat(name,color){
                this.name =  name;
                this.color = color;
         }
         //生成实例对象
         var cat1 = new Cat('大黄','yellow');
         var cat2 = new Cat('大黑','black');
         console.log(cat1);
         console.log(cat2);
         //cat1和cat2会自动含有一个constructor属性，指向它们的构造函数
         console.log(cat1.constructor === Cat);   //true
         console.log(cat2.constructor === Cat);   //true

         //Javascript还提供了一个instanceof运算符，验证原型对象与实例对象之间的关系。
         console.log(cat1 instanceof Cat)        //true
         console.log(cat2 instanceof Cat)        //truev


        /*
        * 4. 构造函数模式的问题
        *       每一个实例对象，type属性和eat()方法都是一模一样的内容，
        *       每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺乏效率。
        *       所以有了prototype，可以把共享的方法放到prototype里。每个实例对象特有的方法放在构造函数里
        */

　　function Cat(name,color){

　　　　this.name = name;

　　　　this.color = color;

　　　　this.type = "猫科动物";

　　　　this.eat = function(){alert("吃老鼠");};

　　}
                var cat1 = new Cat("大毛","黄色");

        　　var cat2 = new Cat ("二毛","黑色");

        　　console.log(cat1.type); // 猫科动物

        　　cat1.eat(); // 吃老鼠 

        //可以让type属性和eat()方法在内存中只生成一次，然后所有实例都指向那个内存地址呢？回答是可以的。
                console.log(cat1.eat == cat2.eat); //false

        /*
        * 5. Prototype模式 
        *       Javascript规定，每一个构造函数都有一个prototype属性，指向另一个对象(其实就是prototype对象，)。
        *       这个对象的所有属性和方法，都会被构造函数的实例继承。
        *       我们只需要把想让实例对象共享的对象和方法放到prototype对象里就可以了。
        */
        function Cat(name,color){
                this.name = name;
                this.color = color;
        }
        Cat.prototype.type = '猫科动物';                                    //可以理解为属性
        Cat.prototype.eat = function(){alert('吃老鼠')};      //可以理解为方法

        var cat1 = new Cat('大黄','yellow');
        var cat2 = new Cat('大蓝','blue');
        console.log(cat1.type);
        cat1.eat();

        //所有实例的type属性和eat()方法，其实都是同一个内存地址，指向prototype对象，因此就提高了运行效率。

        console.log(cat1.eat === cat2.eat);   //true  cat1和cat2的eat方法的引用是同一个内存地址。
        /* 6. Prototype模式的验证方法  */

        //6.1 isPrototypeOf()这个方法用来判断，某个proptotype对象和某个实例之间的关系。
        console.log(Cat.prototype.isPrototypeOf(cat1));     //实例对象cat1是否与prototype对象有关系，true
        console.log(Cat.prototype.isPrototypeOf(cat2));

        //6.2 hasOwnProperty()
        //每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。
        //如果是prototype对象上的属性 返回false.
        console.log(cat1.hasOwnProperty('name'));      //是本地属性，构造函数内的，不是继承prototype上的属性。返回true
        console.log(cat1.hasOwnProperty('type'));          //继承prototype对象的属性，返回false
        console.log(cat1.hasOwnProperty('eat'));           //同type属性一样是 继承自prototype对象的属性

        //6.3 in运算符
        //in运算符可以用来判断，某个实例是否含有某个属性，无论本地属性,还是prototype对象的属性，只要含有就返回true
        console.log('name' in cat1);        //true 
        console.log('type' in cat2);            //true
        console.log('eat' in cat1);                     //true

        //in运算符还可以用来遍历某个对象的所有属性。
        for(var prop in cat1) { alert("cat1["+prop+"]="+cat1[prop]); } 
        for(var prop in cat1){
                console.log("cat1["+prop+"]="+cat1[prop]);
        }
        //cat1[name]=大黄
        //cat1[color]=yellow
        //cat1[type]=猫科动物

以上只是学习笔记，记录下。

原文地址：http://www.ruanyifeng.com/blog/2010/05/object-oriented_javascript_encapsulation.html