本文整理自阮一峰老师blog。

封装、继承、多态都是对对象而言，在js中提到封装也是对属性和方法的一种包装。

下面是一个最简单的封装对象：

var cat1 = {};//create object
    cat1.name = "tiny";
    cat1.eat = function () {
        console.log('eat mouse');
    }

显然这么去做的话，需要每次手动实例对象，使得代码冗余同时占用大量内存。有没有更好的方法咧。是有的！

我们可以用函数把对象的属性和方法封装

var Cat = function(name) {
    return {
        name: name,
        eat: function (){
            console.log('eat mouse');
        }
    }
}
var cat1 = Cat("tiny");
var cat2 = Cat("heihei")

函数封装不能反映属于同一原型，cat1和cat2之间内在联系不紧密，有没有更好的呢？有的！用构造函数封装。这样不同的实例对象就有了共同的原型。

var Cat = function(name) {
    this.name = name;
    this.eat = function () {
        console.log('eat mouse');
    }
}
var cat1 = new Cat("tiny");
var cat2 = new Cat("heihei")

//基于构造函数的实例对象默认有一个constructor属性，指向其构造函数
alert(cat1.constructor == Cat); //true
alert(cat2.constructor == Cat); //true

//instanceof运算符，验证实例与原型对象的关系
alert(cat1 instanceof Cat); //true
alert(cat2 instanceof Cat); //true

不知道大家发现没有，对于同一个对象，名字name是各部相同的，但是方法eat却是一样的。每次实例对象再实例一次相同的方法，意味着浪费内存。因此原型排上用场了.你可以简单的理解原型上的属性和方法是公用内存的，意味着该属性和方法是公有的。对次实例对象时，共有属性不占用多余内存。

由于javacsript中都是对象，包括函数，他们都有个原型属性prototype，那么原型过度到原型链就很自然了，原型链的尽头是Object对象的_prototype = null。

var Cat = function(name) {
    this.name = name;
}
Cat.prototype.eat = function(){
    console.log('eat mouse');
}

var cat1 = new Cat("tiny");
var cat2 = new Cat("heihei")

//hasOwnProperty方法判断属性是本地属性还是原型属性
alert(cat1.hasOwnProperty("name")); // true
alert(cat1.hasOwnProperty("type")); // false

//in运算符，判断实例是否含有某属性或者遍历所有属性
alert('name' in cat1);
for(var prop in cat1){
    console.log('cat1[' + prop + ']');
}

有了封装就有继承啦，继承可以理解为公用属性，自然而然就使用原型啦，或者在构造函数中apply/call重新绑定对象。下面代码封装好了继承，仔细琢磨

function Cat(name,color){
    Animal.apply(this, arguments);
    this.name = name;
    this.color = color;
}
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

function extend(Child, Parent) {
    var F = function(){};
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
    Child.uber = Parent.prototype;
}

extend(Cat,Animal);//species是Animal的属性
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

上面是构造函数的继承，下面介绍非构造函数的继承。（还有一种思路是，将父对象中的属性拷贝到子对象中，嗯，暴力。。。）

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}
var Doctor = object(Chinese);
Doctor.career = '医生';
alert(Doctor.nation); //中国

浅拷贝，浅拷贝有一个问题。那就是，如果父对象的属性等于数组或另一个对象，那么实际上，子对象获得的只是一个内存地址，而不是真正拷贝，因此存在父对象被篡改的可能。

function extendCopy(p) {
    var c = {};
    for (var i in p) {
        c[i] = p[i];
    }
    c.uber = p;
    return c;
}

var Doctor = extendCopy(Chinese);
Doctor.career = '医生';
alert(Doctor.nation); // 中国

Chinese.birthPlaces = ['北京','上海','香港'];
var Doctor = extendCopy(Chinese);
//然后，我们为Doctor的"出生地"添加一个城市：
Doctor.birthPlaces.push('厦门');
//发生了什么事？Chinese的"出生地"也被改掉了！
alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
alert(Chinese.birthPlaces); //北京, 上海, 香港, 厦门

深拷贝，目前jQuery库使用的就是深拷贝。

function deepCopy(p, c) {
    var c = c || {};
    for (var i in p) {
        if (typeof p[i] === 'object') {
            c[i] = (p[i].constructor === Array) ? [] : {};
            deepCopy(p[i], c[i]);
        } else {
            c[i] = p[i];
        }
    }
    return c;
}

var Doctor = deepCopy(Chinese);

Chinese.birthPlaces = ['北京','上海','香港'];
Doctor.birthPlaces.push('厦门');

alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
alert(Chinese.birthPlaces); //北京, 上海, 香港