学习编程都应该知道的面向对象

什么是面向对象

面向对象编程，Object-Oriented-Program（简称 OOP）是一种目前主流的编程思想。而 OOP 引入了“对象”概念，对象即对应生活中的实物，这样就把编程具象化了。

类和对象

注意：以下用ts来作为示例代码

类，即模板

class People {
    name: string
    age: number
​
    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
​
    eat() {
        alert(`${this.name} eat something`)
    }
​
    speak() {
        alert(`My name is${this.name}`)
    }
}

对象，即实例。一个类可以 new 出很多个对象。

const zhangsan = new People('张三', 20)
zhangsan.eat()
zhangsan.speak()
zhangsan.age
​
const lisi = new People('李四', 21)
lisi.eat()
lisi.speak()
lisi.age

面向对象的三要素：继承，封装，多态

继承：抽离公共代码，实现代码复用

class Student extends People {
    school: string
    constructor(name: string, age: number, school: string) {
        super(name, age)
        this.school = school
    }
    study() {
        alert(`${this.name} study`)
    }
}
​
class Teacher extends People {
    major: string
    constructor(name: string, age: number, major: string) {
        super(name, age)
        this.major = major
    }
    teach() {
        alert(`$${this.name} teach ${this.major}`)
    }
}

可继续派生其他子类

const xiaoming = new Student('小明', 10, '小学')
xiaoming.study()
xiaoming.eat()
xiaoming.speak()
const turtle = new Teacher('乌龟',21,'前端')
turtle.teach()
turtle.eat()
turtle.speak()

封装：高内聚，低耦合

在设计代码的时候尽可能让内聚多一些，耦合少一些。代码尽量模块化，这样在修改代码的时候，改动代码的部分不会对其它部分代码造成影响

- public 外部可访问，默认

- protected 内部或子类可访问

- private 只有内部可访问

class People {
    name: string
    age: number
    protected weight：number = 100
    private girlfriend：string = 'xxx'
    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
​
    eat() {
        alert(`${this.name} eat something`)
    }
​
    speak() {
        alert(`My name is${this.name}`)
    }
}
​
//protected举例
class Student extends People {
    this.weight // 可以正常调用
}
const xiaoming = new Student()
xiaoming.weight // 报错，不可以调用，只能在People和Student中访问
​
//private举例
class Student extends People {
    this.girlfriend // 报错，不可以调用，只能在People中访问
}
const xiaoming = new Student()
xiaoming.girlfriend // 报错，不可以调用，只能在People中访问

多态：重写，重载

重写意味着在子类中重新实现（覆盖）从父类继承而来的方法。在这种情况下，我们将重写 makeSound 方法。

//重写
class Animal {
  makeSound() {
    console.log('发出一种声音');
  }
}
​
class Dog extends Animal {
  makeSound() {
    console.log('狗在汪汪叫');
  }
}
​
class Cat extends Animal {
  makeSound() {
    console.log('猫在喵喵叫');
  }
}
​
const dog = new Dog();
const cat = new Cat();
​
dog.makeSound(); // 输出: "狗在汪汪叫"
cat.makeSound(); // 输出: "猫在喵喵叫"

重载意味着在一个类中定义多个具有相同名称但参数列表不同的方法。在这种情况下，我们将重载 makeSound 方法，并根据传递的参数类型执行不同的逻辑。

class Animal {
  makeSound() {
    console.log('发出一种声音');
  }
​
  makeSound(sound: string) {
    console.log('发出声音：' + sound);
  }
}
​
const animal = new Animal();
​
animal.makeSound(); // 输出: "发出一种声音"
animal.makeSound('喵喵'); // 输出: "发出声音：喵喵"