封裝、繼承、多態——簡介

封裝

封裝將屬性或方法隱藏，對外開放接口。

在寫項目的時候，咱們常常會在不一樣的地方須要用到相同的方法或屬性，假若每一個地方都要寫一遍，不只代碼量大並且也會浪費咱們的時間，這時候咱們就能夠將這些方法或屬性封裝起來

//  定義一個運算的函數
class Operation{
  constructor(){}
  // 寫一個加法函數
  add(x, y){
    return x + y
  }
  // 寫一個減法函數
  subtraction(x, y){
    return x - y
  }
}
// 須要的時候，咱們只須要實例化就能夠調用寫好的函數
let num = new Operation()
console.log(num.add(1,5))   // 6
console.log(num.subtraction(1,5))   //-4

繼承

子類能夠繼承父類的屬性和方法，而不須要再次編寫，子類也能夠有本身的屬性和方法

// 定義一個父類，裏面存在一個說話的方法
class Person{
  constructor(){}
  say(name, age){
    return `我叫${name},今年${age}歲`
  }
}
// 實例化父類並調用方法
let people = new Person()
console.log(people.say('小明',14))

// 定義一個字類繼承父類
class Exercise extends Person{
  constructor(){
    super()
  }
  // 定義一個愛好的方法
  like(name, love){
    return `我是${name},我喜歡${love}`
  }
}

// 實例化子類
let children = new Exercise()
// 子類的實例化對象能夠直接調用父類的方法
console.log(children.say('小花', 11))
// 子類的實例化對象調用本身的方法
console.log(children.like('小花', '寫代碼'))

多態

字面意思即‘多種狀態’，能夠理解爲相同的方法，相同的參數，結果不一樣

多態的表現形式重寫與重載

重寫

子類繼承父類後可使用父類的方法，當子類想用父類的方法但須要一些改變時，子類能夠對父類的方法進行重寫

// 定義一個父類，裏面存在一個說話的方法
class Person{
  constructor(){}
  say(name, age){
    return `我叫${name},今年${age}歲`
  }
}
// 實例化父類並調用方法
let people = new Person()
console.log(people.say('小明',14)) // 我叫小明,今年14歲

// 定義一個字類繼承父類
class Exercise extends Person{
  constructor(){
    super()
  }
  // 重寫父類說話方法
  say(name, age){
    return `你好,我是${name},今年${age}歲`
  }
}

// 實例化子對象
let children = new Exercise()
// 調用重寫方法
console.log(children.say('小花', 11)) // 你好,我是小花,今年11歲

重載

相同的方法，接收的參數不一樣，返回的結果不同

嚴格來說，js並無重載的概念，但咱們能夠進行模擬

// 定義一個類，經過判斷參數的類型來返回不一樣的結果
class Person{
  constructor(adjustment){
    switch(typeof adjustment){
      case 'number':
        console.log('數字')
        break;
      case 'string':
        console.log('字符串')
        break;
      case 'boolean':
        console.log('布爾')
        break;
    }
  }
}
new Person(123)     // 數字
new Person('abc')   // 字符串
new Person(true)    // 布爾

最後，關於封裝、繼承、多態還有不少更細的知識沒有寫到，此次只是簡單的瞭解，之後會詳細的介紹每個o(￣▽￣)ブ