编程思想：面向对象(OOP)、面向过程(OPP)

#面向对象(OOP)

#定义

• 面向对象编程(Object Oriented Programming)，以类或对象为组织代码的基本单元，并将 封装、抽象、继承、多态 四个特性，作为代码设计和实现的基石。
  • 封装: 将数据和操作封装在对象内部，暴露有限的访问接口。
  • 抽象: 方法的实现。
  • 继承: 对象（子类）可以继承另一个对象（父类）的属性和方法。
  • 多态: 利用接口类、Duck Typing 的特性实现多态，子类可以代替父类。

#优势

• 可维护性：将代码组织成对象的形式，易于理解和维护。
• 可复用性：通过继承和多态，有效地复用代码。
• 可扩展性：通过继承和多态来扩展代码，适应不同的需求变化。

#例子1

class People {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  getName() {
    return `Halo, my name is ${this.name}.`;
  }
}

const peopleTom = new People("Tom", 24);
console.log(peopleTom.getName()); // Halo, my name is Tom.

class SuperMan extends People {
  constructor(name, age, fly) {
    super(name, age);
    this.fly = fly;
  }

  getName() {
    return `Ok, I'm ${this.name}.`;
  }

  canFly() {
    return this.fly ? "Yes." : "No.";
  }
}

const superManJunny = new SuperMan("Junny", 20, true);
console.log(superManJunny.getName()); // Ok, I'm Junny.
console.log(superManJunny.canFly()); // Yes.

#例子2

class Circle {
  constructor(radius) {
    this.radius = radius;
  }

  getArea() {
    return Math.PI * this.radius ** 2;
  }

  getCircumference() {
    return 2 * Math.PI * this.radius;
  }
}

const circle = new Circle(2);
console.log(circle.getArea()); // ≈ 12.57

#设计思想与原则(SOLID)

• SOLID 是一个面向对象设计和编程中的五个基本原则的缩写

#单一职责原则（SRP, Single Responsibility Principle）

• 一个类或者模块只负责完成一个职责（或者功能）

class Man {
  doWork() {}
}
class ManFree {
  takeHoliday() {}
}

#开放/封闭原则（OCP, Open/Closed Principle）

• 类、模块、函数等应该对扩展开放，对修改关闭。即：一个模块在扩展新功能时不应该修改原有的代码，而是通过添加新的代码来实现扩展。

class People {
  constructor(name) {
    this.name = name;
  }
  sleep() {
    console.log(`${this.name} can sleep.`);
  }
}

class Coder extends People {
  constructor(name) {
    super(name);
  }
  writeCode() {
    console.log(`${this.name} can write code.`);
  }
}

var cer = new Coder("Tom");
cer.sleep();
cer.writeCode();

#里氏替换原则（LSP, Liskov Substitution Principle）

• 在任何需要基类的地方，都可以使用子类而不产生错误（子类不破坏基类原有的约定）

#接口隔离原则（ISP, Interface Segregation Principle）

• 不应该让一个类依赖它不需要的接口
• 一个类对另一个类的依赖应该建立在最小的接口上

class Coder {
  writeCode() {}
}

class Cat {
  sleep() {}
}

#依赖反转原则（DIP, Dependency Inversion Principle）

• 倡导通过抽象来解耦高层和低层模块之间的依赖关系

#面向过程(OPP)

#定义

• 面向过程编程(Procedure Oriented Programming)，以过程（方法、函数、操作）作为组织代码的基本单元，通过拼接一组顺序执行的方法来操作数据完成一项功能。
  • 操作过程化
  • 数据和函数分离
  • 可复用性较低

#优势

• 简单易懂
• 资源消耗少
• 执行效率高
• 易于调试和维护

#例子

const getArea = (radius) => {
  return Math.PI * radius ** 2;
};

const getCircumference = (radius) => {
  return 2 * Math.PI * radius;
};

console.log(getArea(2)); // ≈ 12.57