JavaScript面向?qū)ο螅?br> 注意啦在這其實面向?qū)ο笫且环N編程的方式，它的思想是通用的，因此 我強烈的建議你去查看我在python，面向?qū)ο缶幊讨凶龅墓P記。

面向?qū)ο笈c面向過程

這里還是相對比較容易理解的，這是兩種截然不同的編程方式。

對象還有類

對象

對象有屬性還有行為，

• 屬性是對象的特性，名詞
• 方法是對象的行為，動詞
  什么是對象的實例化？事實上對象來源于類，你把類變成一個真正意義上的存在的可以使用的對象的時候 就叫對象實例化，對象實例化是一個過程 ，實例對象指的是你實例化出來的對象

//以下代碼是對對象的復習
//字面量創(chuàng)建對象
var ldh = {
    name: '劉德華',
    age: 18
}
console.log(ldh);

//構(gòu)造函數(shù)創(chuàng)建對象,
  function Star(name, age) {
    this.name = name;
    this.age = age;
 }
var ldh = new Star('劉德華', 18)//實例化對象
console.log(ldh);

類

基礎(chǔ)的語法

有關(guān)于類的概念其實是在es6中提出的，我們可以通過class關(guān)鍵字來聲明一個類，然后使用new關(guān)鍵之，實例化一個對象出來

1. 語法:

//步驟1 使用class關(guān)鍵字
class name {
  // class body
}     
//步驟2使用定義的類創(chuàng)建實例  注意new關(guān)鍵字
var xx = new name();     

2. 示例

 // 1. 創(chuàng)建類 class  創(chuàng)建一個 明星類
 class Star {
   // 類的共有屬性放到 constructor 里面，這是一個構(gòu)造函數(shù)你也可以稱它是構(gòu)造器 ，作用就是用于傳遞參數(shù)，返回實例對象，類似于python中的__init__函數(shù)
   constructor(name, age) {
   this.name = name;
   this.age = age;
   }
 }
   // 2. 利用類創(chuàng)建對象 new
   var ldh = new Star('劉德華', 18);
   console.log(ldh);

給類添加屬性還有方法

實際上這些代碼是非常容易理解的

 // 1. 創(chuàng)建類 class  創(chuàng)建一個類
class Star {
    // 類的共有屬性放到 constructor 里面 constructor是 構(gòu)造器或者構(gòu)造函數(shù)
    constructor(uname, age) {
      this.uname = uname;
      this.age = age;
    }//------------------------------------------->注意,方法與方法之間不需要添加逗號 加上也沒什么關(guān)系，建議不加，以區(qū)分是類還是對象
    sing(song) {
      console.log(this.uname + '唱' + song);
    }
}
// 2. 利用類創(chuàng)建對象 new
var ldh = new Star('張學友', 18);
console.log(ldh);
ldh.sing('吻別'); 

• 你需要注意的地方：

1. 通過class 關(guān)鍵字創(chuàng)建類, 類名我們還是習慣性定義首字母大寫
2. 類里面有個constructor 構(gòu)造函數(shù),可以接受傳遞過來的參數(shù),同時返回的是實例對象
3. constructor 函數(shù) 只要 new 生成實例時,就會自動調(diào)用這個函數(shù), 如果我們不寫這個函數(shù),類也會自動生成這個函數(shù)
4. 多個函數(shù)方法之間不需要添加逗號分隔
5. 生成實例 new 不能省略
6. 語法規(guī)范, 創(chuàng)建類 類名后面不要加小括號,生成實例 類名后面加小括號, 構(gòu)造函數(shù)不需要加function

面向?qū)ο蟮娜筇匦裕悍庋b，繼承，多態(tài)

1. 封裝
   實際上這個是最容易理解的，就是把一個類的事物的公用的特點，功能封裝起來。抽象出來組合成一個類

// 父類
class Father{   
} 

// 子類繼承父類
class  Son  extends Father {  
}       

2. 繼承
   所謂的繼承也很容易理解，繼承就是把父類的一些東西繼承到，現(xiàn)有的“我”這個對象的類中，從而讓我不必要在重復定義一些父類中已經(jīng)存在的屬性或者方法

請你思考如下問題

• 我們繼承過來的屬性和方法如何表示？如何使用
• 我們是否可以修改繼承出來的方法或者屬性？

  //定義了父類
  class Father {
     constructor(x, y) {
     this.x = x;
     this.y = y;
     }
     sum() {
     console.log(this.x + this.y);
  }
   }
  //子元素繼承父類
      class Son extends Father {
      constructor(x, y) {
      super(x, y); //使用super調(diào)用了父類中的構(gòu)造函數(shù)
      }
      }
      var son = new Son(1, 2);
      son.sum(); //結(jié)果為3

      // 父類有加法方法
      class Father {
        constructor(x, y) {
        this.x = x;
        this.y = y;
        }
        sum() {
        console.log(this.x + this.y);
        }
      }
      // 子類繼承父類加法方法 同時 擴展減法方法
      class Son extends Father {
        constructor(x, y) {
        // 利用super 調(diào)用父類的構(gòu)造函數(shù) super 必須在子類this之前調(diào)用,放到this之后會報錯
        super(x, y);
        this.x = x;
        this.y = y;

       }
       subtract() {
       console.log(this.x - this.y);
       }
     }
     var son = new Son(5, 3);
     son.subtract(); //2
     son.sum();//8

注意：

• 時刻注意this的指向問題,類里面的共有的屬性和方法一定要加this使用.
• constructor中的this指向的是new出來的實例對象
• 自定義的方法,一般也指向的new出來的實例對象
• 綁定事件之后this指向的就是觸發(fā)事件的事件源
• 在 ES6 中類沒有變量提升，所以必須先定義類，才能通過類實例化對象

使用我們的super關(guān)鍵字訪問我們的父類里面的方法

• 注意，繼承是向上查找的

• 繼承中,如果實例化子類輸出一個方法,先看子類有沒有這個方法,如果有就先執(zhí)行子類的

• 繼承中,如果子類里面沒有,就去查找父類有沒有這個方法,如果有,就執(zhí)行父類的這個方法(就近原則)

• 如果子類想要繼承父類的方法,同時在自己內(nèi)部擴展自己的方法,利用super 調(diào)用父類的構(gòu)造函數(shù),super 必須在子類this之前調(diào)用

3.多態(tài)