摘要：面向對象的三大特點封裝，繼承，多態(tài)缺一不可。構造函數(shù)，是一種特殊的方法。特別的一個類可以有多個構造函數(shù)，可根據(jù)其參數(shù)個數(shù)的不同或參數(shù)類型的不同來區(qū)分它們即構造函數(shù)的重載。

面向對象程序設計（OOP：Object-oriented programming）是一種程序設計范型，同時也是一種程序開發(fā)的方法。對象指的是類的實例。
面向對象(Object Oriented,OO)是一種對現(xiàn)實世界理解和抽象的方法，是計算機編程技術[1] 發(fā)展到一定階段后的產(chǎn)物。

面向對象的三大特點（封裝，繼承，多態(tài)）缺一不可。通?！盎趯ο蟆笔鞘褂脤ο?，但是無法利用現(xiàn)有的對象模板產(chǎn)生新的對象類型，繼而產(chǎn)生新的對象，也就是說“基于對象”沒有繼承的特點。而“多態(tài)”表示為運行時類型確定（父類類型的子類對象實例），動態(tài)綁定執(zhí)行對象，沒有了繼承的概念也就無從談論“多態(tài)”。
示例：繪制一個圖形，圖形已有為三角形、圓；
Java 示例

// 父類：抽象、封裝
public class  Graph {
 void draw() {
  System.out.println("draw a Graph");
 }
}

// 繼承：子類type1
public class Triangle extends Graph {
 @Override
 void draw() {
  System.out.println("draw a Triangle");
 }
}
 
// 繼承：子類type2
public class Circle extends Graph {
 @Override
 void draw() {
  System.out.println("draw a Circle");
 }
}

// 多態(tài)：運行時類型確定
public class Drawer {
 static void draw(Graph a) {
  a.draw();
}

// 運行調(diào)用
public static void main(String args[]) {
  Graph p = new Triangle();
  Drawer.draw(p); // "draw a Triangle"
  p = new Circle();
  Drawer.draw(p); //"draw a Circle"
}

Javascript ES5示例

// 封裝
function Graph(){}
Graph.prototype.draw = function (){
  console.log("draw a Graph");
}
// 原型鏈引用
function Trianggle(){}
Trianggle.prototype = new Graph();
Trianggle.prototype.draw =  function (){
  console.log("draw a Trianggle");
}
// 原型鏈引用
function Circle(){}
Circle.prototype = new Graph();
Circle.prototype.draw =  function (){
  console.log("draw a Circle");
}

// 相對多態(tài)：無顯示對象類型
function Drawer(obj){
  obj.draw();
}
// 運行時類型確定
var p = new Trianggle();
Drawer(p);
p = new Circle();
Drawer(p); 

大多面向對象語言中，面向對象一般基于面向’類‘的設計。類是代碼抽象的模式之一：實例化（instantiation）、繼承（inheritance）、和 （相對）多態(tài)（polymorphism）。類和實例的關系好比房屋建造。建筑師會繪制建筑藍圖，建筑工人根據(jù)藍圖落地成實際建筑，建筑就是藍圖的復制（概念和物理上的復制）。類就是建筑的抽象，含有一個建筑的所有特性。實例就是實際的建筑，包含了門、窗以及實際材料、地理位置。類通過復制操作被實例化為對象形式，實例間無直接關系。但這無法直接對應到 JavaScript 的實現(xiàn)機制，因為 Javascript 沒有實質類的概念，ES6的 class也是一種語法糖¹。

面向對象編程強調(diào)的是數(shù)據(jù)和操作數(shù)據(jù)行為的的相互關聯(lián)，因此最好的設計就是把數(shù)據(jù)和它相關的行為打包（封裝）起來。
封裝（Encapsulation）是指一種將抽象性函數(shù)式接口的實現(xiàn)細節(jié)部份包裝、隱藏起來的方法。

(1) 良好的封裝能降低耦合度
(2) 方面數(shù)據(jù)統(tǒng)一管理、對象內(nèi)部結構靈活修改
(3) 對其成員有更精確的控制，易于擴展
(4) 隱藏實現(xiàn)信息、細節(jié)，只暴露需要的 API

(1)工廠模式 - 函數(shù) 【內(nèi)部對象創(chuàng)建屬性方法并返回對象，使用this】

 function createPerson(name, age, job){
        var o = new Object();
        o.name = name;
        o.age = age;
        o.job = job;
        o.sayName = function(){
            alert(this.name);
        }
        return o;
 }
var person1 = createPerson(“John”, 18, “Teacher");
var person2 = createPerson(“Greg”, 30, “Doctor”);

(2) 構造函數(shù)模式【內(nèi)部 this創(chuàng)建屬性、方法；無 return； 通過改變 this指向創(chuàng)建實例】

**原生構造函數(shù)**：隱式創(chuàng)建對象，屬性、方法賦值給 this對象，無 return；

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}
var person1 = new Person(“John”, 18, “Teacher");
var person2 = new Person(“Greg”, 30, “Doctor”);

構造函數(shù)： new 顯示創(chuàng)建 對象

步驟1： 創(chuàng)建一個新對象
步驟2：講構造函數(shù)的作用是賦值給新對象 （this 只向新對象 詞法作用域發(fā)生改變）
步驟3：執(zhí)行構造函數(shù)的代碼 （為新對象 添加屬性 ）
步驟4：返回新對象

function Person(name, age, job){
   this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}

構造函數(shù)作為函數(shù)； 問題：作用域改變，每個傳入的對象重建一遍；）
var person1 = new Object();

 Person.call( person1, “John”, 18, “Teacher");

var person2 = new Person(“Greg”, 30, “Doctor”);

(3) 原型模式 【原型對象創(chuàng)建屬性、方法】

   構造函數(shù)無傳參， 共享原型對象的屬性，其中一個實例對原型對象的引用類型屬性做修改，影響所有其他實例對該屬性的使用；
 （* 引用類型屬性受影響  內(nèi)存分配機制不同引起）

function Person(){}

Person.prototype.name =  "Nicholas";
Person.prototype.age = 27;
Person.prototype.job = "Doctor";
Person.prototype.friends =  ["Lily", "John", "Alex"]
Person.prototype.sayName = function() {
     console.log(this.name);
}
Person.prototype.getFriends = function() {
     console.log(this.friends);
}

 var person1 = new Person();
 person1.name = "person1";

 var person2 = new Person();
 person2.name = "person2";
 person2.sayName();  //“person2"
 person2.getFriends(); // ["Lily", "John", "Alex"]
 person1.friends.push(“Van");
 person1.sayName(); //“person1"
 person2.getFriends();  //["Lily", "John", "Alex", "Van"]

(4) 構造函數(shù) & 原型模式結合 【構造函數(shù)獨立屬性方法，原型對象創(chuàng)建公用屬性、方法】
好處：構造函數(shù)模式 定義實例個性化屬性；原型模式定義方法和共享屬性；功能模塊化 職責單一

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = [‘Lily", "John", "Alex"];
}

Person.prototype ={
    constructor: Person,
      sayName: function(){
         alert(this.name);
     }
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
person1.friends.push("Van");
var person2 = new Person(“Greg", 27, "Doctor");

(5) 動態(tài)原型模式 （使用：功能模塊化）【構造函數(shù)獨立屬性方法，原型對象按需創(chuàng)建公用屬性、方法】

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = [‘Lily’, "John", "Alex"]；
    
    if(typeof this.sayName != ‘function’){
            Person.prototype.sayName = function(){
                    alert(this.name);
            };
    }
}

(6) 寄生構造函數(shù)模式 -【 已有對象擴展 - 原型鏈 】 （使用：第三方庫擴展 ）

   1.寫法上和工廠模式一樣 調(diào)用時多加 new  
   2.此模式創(chuàng)建的對象 與構造函數(shù)無關系， instanceof操作符無意義

function  Person(name, age, job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        alert(this.name);
    }
    return o;
}
 // 工廠模式
// var person1 =  Person(“John”, 18, “Teacher”);
// 寄生模式
 var friend  =  new Person(“John”, 18, “Teacher”); // 返回新對象的實例

(7) 穩(wěn)妥模式 【 內(nèi)部建對象不用 this 閉包 - 詞法作用域 】（穩(wěn)妥對象-無公共屬性，方法不引用 this）(使用：適用于安全環(huán)境 - 禁用 this 和 new)

 1.寫法上和寄生模式類似 ， 除方法不使用 this  
 2.此模式創(chuàng)建的對象 與構造函數(shù)無關系， instanceof操作符無意義

function  Person(name, age, job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        alert(name); //無 this
    }
    return o;
}
var friend = Person(“John”, 18, “Teacher”); //無 new