面向对象编程

　　　　　　//自己手写案例
　　　　　　function Fruits(){ // 构造函数
                
            }
            Fruits.prototype={ // 原型函数
                name:"Joe",
                age:16,
                init:function(){
                    console.log('hello world')
                }
            }
            Apple=new Fruits(); //实例对象
            Apple.init();//hello  world
            Apple.init=function(){
                console.log('我是实例方法');
            }
            Apple.init();//我是实例方法
//          console.log(Apple.__proto__) //实例可以通过原型链找到原型
            console.log(Apple)
            console.log(Fruits.prototype) 
//          console.log(Apple.constructor == Fruits) //false（如果没有原型对象，此处会为true，应该每一个实例都有一个constructor属性，默认调用prototype对象的constructor属性）

//          console.log(Apple instanceof Fruits) //true  Apple是Fruits原型对象的实例对象

　　以上案例，包括了构造函数，原型函数和实例对象，实例对象可以通过__proto__原型链找到原型，实例对象也可以自己定义函数，比如例子中的Apple.init，此时实例对象本身和原型对象上都有init帆方法，此时实例对象会优先调用本身的方法，如果没有，再去prototype上找。

理解原型对象

　　无论什么时候，只要创建一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会自动获得一个constructor(构造函数)属性,这个属性是一个指向prototype属性所在函数的指针。

　　　　　　　function New(){
                
            }
            console.log(New.prototype)
　　　　　　　console.log(New.prototype.constructor==New) //true

而通过这个构造函数，我们还可以为原型对象添加其他的属性和方法。

　　创建了自定义的构造函数之后，其原型对象默认只会取得constructor属性，至于其他方法，则都是从Object继承来的。当构造函数创建了一个新实例后，该实例的内部将包含一个指针（内部属性），指向构造函数的原型对象。

ECMA-262第5版中管这个指针交[[Prototype]]。虽然在脚本中没有标准的方式访问[[Prototype]]，但Firefox,Safari和Chrome在每个对象上都支持一个属性__proto__;而在其他实现中，这个属性对脚本则是完全不可见的。不过，要

明确的真正重要的一点是，这个连接存在于实例和构造函数的原型对象之间，而不是存在于实例与构造函数之间。（换句话说，实例对象与构造函数没有直接的关系）

方法：

isPrototypeOf()

如果[[Prototype]]指向调用isPrototypeOf()方法的对象（New.prototype），那这个方法就返回true

　　　　　　function New(){
                
            }
            New.prototype={
                name:'jane',
                getName:function(){
                    console.log(this.name);
                }
            }
            var fn=new New();
            console.log(New.prototype.isPrototypeOf(fn));//true

在ECMAScript5中新增了一个方法，叫Object.getPrototypeOf(),在所有支持的实现中，这个方法返回[[Prototype]]的值，例如：

Object.getPrototypeOf(fn)==New.prototype;//true
Object.getPrototypeOf(fn).name;//jane

Object.getPrototypeOf()返回的对象实际就是这个对象的原型。使用这个方法可以方便的取得一个对象的原型。

每当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性。搜索首先是从对戏那个实例本身开始。如果在实例中找到了具有给定名字的属性，则返回该属性的值；如果没有找到，则继续搜索指针指向的原型对象，在原型对象中

查找具有给定名字的属性。如果在原型对象中找到了这个属性，则返回该属性的值。

首先js中对象(函数（function）也是对象)，可以访问到原型（prototype），
然后你通过对象得到的原型（prototype）中也会有一个给对象的指针（即constructor）
例如 ：
function Person(){};
var pro = Person.prototype;//得到对象的原型 
var obj = pro.constructor ; // 这样可以得到Person对象。
对象创建对象的实例就不多说了 
var p = new Person(); // 创建一个对象实例 。
对象实例中也会隐含的包含一个指向prototype的指针（在safrai ,firefox,chrome,opera等浏览器中可以使用 '__proto__'来访问）
例如：
var p2 = new Person();
var proro = p2.__proto__ ;// 可以得到对象原型(prototype)的引用 ，
var bool = p2.__proto__ == Person.prototype;
alert(bool); // true 对象的原型和实例获取的原型是同一个对象，
总结： 
对象和实例都可以访问到原型 
对象：Person.prototype;
实例：p.__proto__ ;
原型可以访问到对象
Person.prototype.constructor;
则实例也可以访问到对象
p.__proto__.constructor ;

读阮一峰文章总结

一生成对象的原始模式

　假设把一个猫看成一个对象，它有‘颜色’和‘名字’两个属性，

var Cat={
  name:''.
  color:''    
}

现在我们需要根据原型对象的规格，生成两个实例

var cat1 = {}; // 创建一个空对象
　　　　cat1.name = "大毛"; // 按照原型对象的属性赋值
　　　　cat1.color = "黄色";
var cat2 = {};
　　　　cat2.name = "二毛";
　　　　cat2.color = "黑色";

好了，这就是最简单的封装了，把两个属性封装在一个对象里面。但是，这样的写法有两个缺点，一是如果多生成几个实例，写起来就非常麻烦；而是实例与原型之间，没有任何的办法，可以看出有什么联系。

二原始模式的改进

我们可以写一个函数，解决代码重复的问题

　　　　　　　function Cat(name,color){
                return{
                    name:name,
                    color:color
                }
            }

然后生成实例对象，就等于是在调用函数

var cat1=new Cat('大黄','黄色');
console.log(cat1)//{name: "大黄", color: "黄色"}

var cat2=new Cat('二黄','白色');
console.log(cat1)//{name: "二黄", color: "白色"}

这种方法的问题依然是，cat1和cat2之间没有内在的联系，不能反映出它们是同一原型对象的实例。

三构造函数模式

为了解决从原型对象生成实例的问题，javascript提供了一个构造函数（Constructor）模式

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

比如，猫的原型对象现在可以这样写，

　function Cat(name,color){
　　　　this.name=name;
　　　　this.color=color;
　　}

现在就可以生成实例对象了。

　　var cat1 = new Cat("大毛","黄色");
　　var cat2 = new Cat("二毛","黑色");
　　alert(cat1.name); // 大毛
　　alert(cat1.color); // 黄色

这时cat1和cat2会自动含有一个constructor属性，指向它们的构造函数。

alert(cat1.constructor == Cat); //true
alert(cat2.constructor == Cat); //true

Javascript还提供了一个instanceof运算符，验证原型对象与实例对象之间的关系。

alert(cat1 instanceof Cat); //true
alert(cat2 instanceof Cat); //true

四构造函数的问题

构造函数方法很好用，但是存在一个浪费内存的问题。

请看，我们现在为Cat对象添加一个不变的属性type（种类），再添加一个方法eat（吃）。那么，原型对象Cat就变成了下面这样：

function Cat(name,color){
　　　　this.name = name;
　　　　this.color = color;
　　　　this.type = "猫科动物";
　　　　this.eat = function(){alert("吃老鼠");};
　　}

　//还是采用同样的方法生成实例
  var cat1 = new Cat("大毛","黄色");
　　var cat2 = new Cat ("二毛","黑色");
　　alert(cat1.type); // 猫科动物
　　cat1.eat(); // 吃老鼠

表面上好像没什么问题，但是实际上这样做，有一个很大的弊端。那就是对于每一个实例对象，type属性和eat()方法都是一模一样的内容，每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺乏效率。

　　alert(cat1.eat == cat2.eat); //false

能不能让type属性和eat()方法在内存中只生成一次，然后所有实例都指向那个内存地址呢？回答是可以的。

五、 Prototype模式

Javascript规定，每一个构造函数都有一个prototype属性，指向另一个对象。这个对象的所有属性和方法，都会被构造函数的实例继承。

这意味着，我们可以把那些不变的属性和方法，直接定义在prototype对象上。

　　function Cat(name,color){

　　　　this.name = name;

　　　　this.color = color;

　　}

　　Cat.prototype.type = "猫科动物";

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

然后，生成实例。

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

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

　　alert(cat1.type); // 猫科动物

　　cat1.eat(); // 吃老鼠

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

　　alert(cat1.eat == cat2.eat); //true

六、 Prototype模式的验证方法

为了配合prototype属性，Javascript定义了一些辅助方法，帮助我们使用它。，

6.1 isPrototypeOf()

这个方法用来判断，某个proptotype对象和某个实例之间的关系。

　　alert(Cat.prototype.isPrototypeOf(cat1)); //true

　　alert(Cat.prototype.isPrototypeOf(cat2)); //true

6.2 hasOwnProperty()

每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。

　　alert(cat1.hasOwnProperty("name")); // true

　　alert(cat1.hasOwnProperty("type")); // false

6.3 in运算符

in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。

　　alert("name" in cat1); // true

　　alert("type" in cat1); // true

in运算符还可以用来遍历某个对象的所有属性。

　　for(var prop in cat1) { alert("cat1["+prop+"]="+cat1[prop]); }

七原型链

我们知道所有的函数都有一个叫做toString的方法。那么这个方法到底是在哪里的呢？

先随意声明一个函数：

function add() {}

那么我们可以用如下的图来表示这个函数的原型链。

原型链

其中add是Function对象的实例。而Function的原型对象同时又是Object原型的实例。这样就构成了一条原型链。原型链的访问，其实跟作用域链有很大的相似之处，

他们都是一次单向的查找过程。因此实例对象能够通过原型链，访问到处于原型链上对象的所有属性与方法。这也是foo最终能够访问到处于Object原型对象上的toString方法的原因。

基于原型链的特性，我们可以很轻松的实现继承。

参考：

http://www.ruanyifeng.com/blog/2010/05/object-oriented_javascript_encapsulation.html

http://www.ruanyifeng.com/blog/2010/05/object-oriented_javascript_inheritance.html

http://www.ruanyifeng.com/blog/2010/05/object-oriented_javascript_inheritance_continued.html