Js：面向对象的特点

一、封装：安全性

二、继承：扩展性

可以通过 extends 关键字实现继承

1、减少重复的代码：

class Animals { // 父类（超类）
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    run(){
        console.log('跑')
    }
}

class Dog extends Animals { // 子类，将 Animals 类中的代码复制到 Dog 类中
}
class Cat extends Animals { // 子类，将 Animals 类中的代码复制到 Cat 类中
}

let dog = new Dog('大黄',2)
let cat = new Cat('喵喵',3)
console.log(dog)
console.log(cat)

2、在不修改一个类的情况下，对其进行扩展： OCP原则

重写父类中的方法

// 父类（超类）
class Animals {
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    run(){
        console.log('跑')
    }
}
// 子类
class Dog extends Animals {
    // 定义一个和父类同名的函数，来重写父类中的方法
    run(){
        console.log('狗狗在跑')
    }
}
class Cat extends Animals {
    // 定义一个和父类同名的函数，来重写父类中的方法
    run(){
        console.log('猫猫在跑')
    }
}

let dog = new Dog('大黄',2)
let cat = new Cat('喵喵',3)
dog.run()
cat.run()

重写父类的构造函数 / 在子类的构造函数中新增属性

// 父类（超类）
class Animals {
     constructor(name,age){
         this.name = name;
         this.age = age;
     }
     run(){
         console.log('跑')
     }
 }
 // 子类
 class Dog extends Animals {
     constructor(name,age,gender){
         // 重写构造函数时，构造函数的第一行必须是super()
         super(name,age) // 调用父类的构造函数，并且将原本的参数传入
         this.gender = gender
     }
 }
 class Cat extends Animals {
     // 定义一个和父类同名的函数，来重写父类中的方法
     run(){
         console.log('猫猫在跑')
         // 调用父类中的方法
         super.run()
     }
 }

 let dog = new Dog('大黄',2,'公') // 前两个参数传给了父类的构造函数
 let cat = new Cat('喵喵',3)
 console.log(dog)
 cat.run()

三、多态：给代码提供了灵活性

多态是指参数的多态，即很多个对象都可以调用同一个方法。在该方法中，不对入参的类型进行限制，只需要满足某些条件，就能够返回不同的值。