Javascript是一種基於面向物件的語言，你所遇到的東西幾乎幾乎都是物件。面向物件重要的兩個概念：類和物件。這裡要分2種情況，在ES6之前，和ES6語法，這裡先說ES6之前，ES6之前是沒有類的概念的，於是就通過建構函式去模擬類，你可以理解為他們只是人類為了移民火星yy出來的一個概念，他並不是實際存在的只是一個概念，然後就靠著這個概念去一點點的摸索創造，最後終於給造出來了一個飛向火星的太空船，那麼這個太空船就是類的例項化的體現。這就是物件。類又是什麼？屬性和行為。太空船是什麼顏色的由什麼組成，這是他的屬性，他能飛這就是他的行為，那麼ES6之前通過這樣通過函式來模擬類的存在。那麼怎麼建立一個建構函式，有以下三種方式：
一、建構函式的建立
1.js內建的建構函式（String、Object、Array、New、Date、number、function）等,再為他建立屬性和方法

var obj = new Object()
obj.name = "小明"
obj.age = "20"
obj.sayName = function(){
    alert(obj.name)  //小明
}

2.通過字面量建立，還是上面這個例子

var obj = {
name = “小明”,
age = 20,
sayName : function(){
alert(this.name)
}
};
通過這兩個例子你會發現，有很多是重複的程式碼，這並不是一個好的選擇，講完了這2個方式咱們穿插一下，為了解決這個問題，人們開始使用工廠模式

function createObj(name,age) {
         var a = new Object()
             a.name = name
             a.age = age
             a.sayName = function(){
             alert(this.name)
     }
     return a
}
var a1 = createObj("小明",18)
var a2 = createObj("小紅"
 
,20)
console.log(a1)  

通過createObj( )能夠根據接收的引數來構建一個包含所有必要資訊的Obj物件，可以無數次的呼叫，每次返回包含2個屬性一個方法的物件。不用重複的去寫相同的程式碼，但是，工廠模式雖然解決了這種重複性的問題，但卻沒有解決怎樣去知道這樣一個物件的型別，怎麼去識別物件。我們來看一下第三種建構函式模式
3.自定義建構函式

function createObj(name,age) {
        this.name = name;
        this.age = age;
        this.sayName = function() {
        alert(this.name)
     }
}
var obj1 = new Person('小明',20)
var obj2 = new Person('小紅',18)

細心的朋友可以找一下，這種方式和上一種的不同之處（1）直接將屬性和方法賦給了this物件。（2）沒有return語句。（3）建立例項物件使用了new操作符
在這個例子中obj1 和obj2分別儲存著createObj的兩個不同的例項，這兩個物件都有一個constructor（建構函式）屬性，該屬性指向createObj
可以這樣測試
alert(obj1.constructor == createObj); //true
constructor最初是用來標示物件型別的，但是提到檢測物件型別可以使用instanceof操作符更可靠一些

alert(obj1 instanceof createObj);//true

建構函式和其他函式的唯一區別：呼叫的方式不同，任何函式通過new操作符來呼叫，那他就可以作為建構函式，同理，如果不通過new操作符來呼叫他就是普通函式。
任何事情再好也總是有缺憾，這又上升到哲學層面上了，所以不懂哲學大的IT工程師不是好藝術家。。。那麼建構函式的問題是什麼呢？就是每個方法都要在每個例項上重新建立一遍，因此每定義一個函式也就是例項化一個物件，這樣一來我們就要定義很多個函式，這樣自定義函式也就沒有任何的封裝性了，好在我們可以使用原型模式來解決。
二、原型模式
首先我們要知道，什麼是原型？需不需要我們自己去建立？通過一個程式碼你就知道。原型的兩個關鍵詞： 1.prototype 2. proto

    function Person(name,age) {
            this.name = name;
            this.eat = function() {
                alert('吃飯')
            }
        }
        Person.prototype.age = 20
        var p1 = new Person("小明",20)
        console.log(p1)

在這個基礎上我們再給他新增一個方法

    function Person(name,age) {
            this.name = name;
            this.eat = function() {
                alert('吃飯')
            }
        }
        Person.prototype.age = 20
        Person.prototype.run = function(){
            console.log('我能跑')
        }
        var p1 = new Person("小明",20)
        p1.run()
        console.log(p1)

你就可以看到通過prototype新增的原型物件是儲存在proto裡的。他d的私有屬性是name,age和run是儲存在原型裡的。由此原型物件最重要的一點就是，通過調研建構函式而建立的那個物件例項的原型物件，使用原型物件的好處他是共享的！那麼如果程式碼非常多的話，我們又怎麼知道哪些是共享的哪些是私有的

console.log(Person.prototype.isPrototypeOf(p1)) //判斷物件是否指向建構函式的原型物件，返回true/false
console.log(p1.hasOwnProperty('name')) // 判斷物件的屬性是在原型中還是例項中

既然說到在原型裡是可以共享的，那該怎麼得到他的屬性和方法呢？
在控制檯裡你可以看到，每一個建構函式都有一個原型物件。proto
假如一個原型又是另一個型別的例項，如此層層遞進，就構成了例項與原型的鏈條，這就是所謂的原型鏈的基本概念，在業務中，我們父類和子類的屬性或者方法是相同的我們就可以繼承原型裡的屬性和方法。原型是可以共享的！前提是要有相同的業務場景和邏輯，這就是繼承，許多的OO語言都支援兩種繼承方式，介面繼承和實現繼承，ECMAscript只支援實現繼承，而實現繼承主要依靠原型鏈。原型鏈的繼承首選會通過自身查詢如果自己找不到會一直像上級查詢一直找到object。我們還是通過程式碼來了解繼承！
原型繼承這裡介紹2種方式
三、繼承
1.原型繼承、
首選還要知道一個概念，被繼承的建構函式叫做（父類、基類）

    function Father(name,money) {
            this.name = name;
            this.money = money;
        }
        Father.prototype.height = 180
        Father.prototype.eat = function() {
            console.log('我會吃飯')
        }
        var f = new Father('王','1000萬')

        function Son(name,money) {
        }
        Son.prototype = new Father()
        var s = new Son()
        s.eat()
        s.name = "jack"
        console.log(s)

這裡父親的私有屬性並沒有賦值，原型裡的height =180 eat()

此時Son已經繼承了Father的height和方法eat
原型繼承的缺憾：沒有自己的私有屬性，繼承來的都放在裡原型裡
只有通過自己手動去新增。s.name = jack，如果新增到原型裡是s.proto.name = “jack”
2.物件冒充（call、apply）
要知道call,和apply的用法


物件冒充的缺點：1.不能繼承父類原型的屬性和方法;2.繼承之後會形成私有屬性和方法。
3.組合繼承：
既可以繼承之後形成私有屬性,也可以繼承父類原型中的屬性行為

以上說的都是ES6之前的語法，大家都知道ES6已經有了類的概念，也非常的簡單。ES6的class沒有變數提升， 類必須先宣告再使用，否則會出現異常。ES6的類是class，繼承是extends，敲完下面的程式碼你就會明白


class Father {
//constructor建構函式，初始化一些屬性值
constructor(name,age){
this.name = name;
this.age = age;
}
run() {
alert('跑起來')
}
//static 關鍵字，用來定義一個類的靜態方法，通過類名呼叫 Father.eat()
static eat() {
alert('吃飯')
}
speak() {
alert(this.name+'Father.speak')
}
}
let F = new Father('大毛',60)
console.log(F)
// F.run()
// F.eat()是錯的
// Father.eat()