一般面向物件的語言都具有三大特徵，封裝、繼承，多型，例如像java 和c++。但是javaScript它可以說不是完全的面向物件的語言，因為它沒有類的概念，但是它又是面向物件的，因為它可以封裝屬性和方法，並且也可以實現繼承。

1、字面量模式

字面量的模式來建立一個物件

var person = {
    name : 'wzj',
    age : 25
}

console.log(person.name);// wzj
console.log(typeof person);//Object 

但是這種方式比較麻煩,如果生成多個例項，寫起來比較繁瑣。

2、通過函式模式

可以通過函式來解決上面程式碼重複的問題

function person(name, age){
    var person = new Object();
    person.name = name;
    person.age = age;
    return person;
}

var person1 = person('wzj',25);//會返回一個物件
var person2 = person('dxy',22);//也會返回一個物件
console.log(person.name);//wzj

可以看出二者並沒有必然的聯絡，不能反映他們是同一個 person 創建出來的。

我們通過控制檯可以看到,這兩個物件不僅具有age和name屬性還有一個 proto

3、通過建構函式封裝屬性和方法

建構函式的概念我們並不陌生，在java中建構函式是用來實現物件屬性的初始化的，並且建構函式也可以實現過載。但是在javaScript中的建構函式和一般的函式沒有多大區別。
javaScript中的建構函式大致具有以下特徵：

1. 建構函式就是一個普通的函式，但是首字母要大寫例如 Person(name, age)。
2. 建構函式內部具有this，變數,並且this會繫結在例項物件上。
3. 建構函式需要通過new 關鍵字來例項化物件，並且通過new關鍵字建立的物件都具有constructor屬性。

function Person(name, age){
    this.name = name;
    this.age = age;
    this.sayName = function () {
        console.log(this.name);
    }
}

var person1 = new Person('wzj',25);
var person2 = new Person('dxy',23);

//二者指向同一個建構函式,返回true
console.log(person1.constructor == person2.constructor);
//可以判斷出例項物件和原型物件之間的關係,返回true
console.log(person1 instanceof Person);

通過建構函式的方法建立物件不僅消除那種字面量冗餘的問題，也解決了原型物件和例項物件之間的關聯問題，但是建構函式也具有一些問題，例如方法和屬性的共有部分如何抽取問題，在java中我們可以宣告介面來實現共有方法的抽取，那麼在javaScript中我們如何實現呢？

4、建構函式的一些問題

首先來看一個示例：

function Car(name, color){
      this.name = name;
      this.color = color;
      this.sayName = function () {
          console.log(this.name);
      }

      this.material = '金屬';
      this.start = function () {
          console.log("啟動引擎!")
      }
  }

  var car1 = new Car('梅賽德斯',"黑色");
  var car2 = new Car('凱迪拉克','白色');

  //這個方法每個物件都具有
  car1.start();
  car2.start();
  //返回false,因為所有的例項的這個方法 都是存在一個自己獨立的地址中
  console.log(car1.start == car2.start);

然後在看下控制檯

可以看到兩個物件有公共的部分，這種方式造成了記憶體的浪費，因為這兩個對像所共有的方法，是在各自的記憶體中存放著，並不是存在公共的區域，那麼我們能不能實現java中樣把這種共有的方法，宣告為static的放在類載入區呢，很顯然不能，因為javaScript沒有類的概念的。
並且，瀏覽沒有類載入區的概念，所以我們不能借鑑。但是並不是說不能實現那種方式。
javaScript規定 每個建構函式都預設具有prototype屬性,並且這個屬性指向一個物件，這個被指向的物件的所有屬性和方法都將被次建構函式所繼承。

function Car2(name, color){
     this.name = name;
     this.color = color;
     this.sayName = function () {
         console.log(this.name);
     }
 }

 //通過 prototype 來實現共有方法的抽取,並且實現了物件方法的繼承
 Car2.prototype.start = function () {
     console.log("引擎啟動!")
 }
 Car2.prototype.material = '金屬';

 /**
 1. 此時所有的例項的start方法和material屬性,其實都指向同一個記憶體地址,即 指向prototype物件.
 2. @type {Car2}
  */
 var car1 = new Car2('梅賽德斯','黑色');
 var car2 = new Car2('凱迪拉克','白色');

 car1.start();
 car2.start();
 console.log(car1.start == car2.start);//返回true,因為所有例項的方法都指向同一個地址

通過控制檯可以發現，car1和car2自身並沒有start()方法和material屬性，但是可以呼叫start方法。

通過原型鏈可以看到，start()方法和material屬性 存在。因此可以通過建構函式的prototype屬性來實現方法和屬性的共有和擴充套件。

5、驗證prototype的一般方法

• 1、isPrototypeOf(): 用來判斷,某個prototype物件和某個例項之間的關係.
• 2、hasOwnPrototype(): 用來判斷,某個屬性是例項自身的屬性還是繼承自Prototype物件的屬性.
• 3、in： 用來判斷某個例項是否含有某個屬性，不管是否是自身屬性，還可以用來遍歷某個物件的 所有屬性。
  這些方法是繼承自Object()物件.

console.log(Car2.prototype.isPrototypeOf(car1));//true
console.log(car1.hasOwnProperty('start'));//false start是 prototype物件的屬性
console.log(car1.hasOwnProperty('name')); //true name是car1自身的屬性

console.log('start' in car1);//true
console.log('name' in car1); //true
console.log('age' in car1);  //false
console.log('-------------------------\n')
for (var prop in car1){
      console.log("car1["+prop+"] = "+car1[prop]);
}

控制檯列印結果

5、prototype的使用

知道了prototype的作用，name應該怎麼使用它呢？如果通過原型新增得方法和物件自身所具有的方法和屬性重複了，會優先呼叫哪一個方法？

function Car2(name, color){
    this.name = name;
    this.color = color;
    this.sayName = function () {
        console.log(this.name);
    }
}

//通過 prototype 來實現共有方法的抽取,並且實現了物件方法的繼承
Car2.prototype.start = function () {
    console.log("引擎啟動!")
}
Car2.prototype.material = '金屬';

Car2.prototype.name = "default";
Car2.prototype.sayName = function () {
    console.log(this.name+"覆蓋建構函式中已經具有的方法!")
}

var car = new Car2('梅賽德斯','黑色');
car.sayName();//列印梅賽德斯
console.log(car.name);//列印梅賽德斯
console.log(car.material);//列印黑色

通過控制檯可以發現，物件本身所具有的的方法，並沒有被通過建構函式建立的方法所覆蓋

得出以下結論

當物件本身的屬性或方法與原型的屬性和方法同名的時候

• 預設呼叫的物件自身的屬性和方法
• 通過原型增加的屬性和方法是確實存在的
• 函式本身的屬性和方法要優先於原型的屬性和方法

當通過delete方法刪除物件中的方法的時候不會刪除建構函式中的.

var car = new Car2('梅賽德斯','黑色');
Car2.prototype.name = "default";
Car2.prototype.sayName = function () {
    console.log(this.name+"覆蓋建構函式中已經具有的方法!")
}
//刪除物件car 中的方法sayName(),此時物件本身並不具有這個方法
delete (car.sayName);

car.sayName();//列印default覆蓋建構函式中已經具有的方法!
console.log(car.name);//列印default
console.log(car.material);//列印黑色