封装、继承、多态——简介

封装

封装将属性或方法隐藏，对外开放接口。

在写项目的时候，咱们常常会在不一样的地方须要用到相同的方法或属性，假若每一个地方都要写一遍，不只代码量大并且也会浪费咱们的时间，这时候咱们就能够将这些方法或属性封装起来

//  定义一个运算的函数
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(￣▽￣)ブ