设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代

码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

•  接口：定义了一组抽象方法，但没有具体的实现。

  // 接口定义
  interface Drawable {
      void draw(); // 接口中的方法默认为抽象方法
  }
  
  class Circle implements Drawable {
      @Override
      public void draw() {
          System.out.println("Drawing a circle");
      }
  }
  
  class Rectangle implements Drawable {
      @Override
      public void draw() {
          System.out.println("Drawing a rectangle");
      }
  }

• 抽象类：

  // 抽象类定义
  abstract class Shape {
      abstract void draw(); // 抽象类中可以有抽象方法
  }
  
  class Circle extends Shape {
      @Override
      void draw() {
          System.out.println("Drawing a circle");
      }
  }
  
  class Rectangle extends Shape {
      @Override
      void draw() {
          System.out.println("Drawing a rectangle");
      }
  }

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

• 基类：
  基类是一个通用的抽象类，它定义了共同的属性和方法，用于派生子类。基类通常包含程序的核心逻辑，但它也可以包含一些抽象方法供子类实现。
  示例：参考上述抽象类定义Shape
• 子类：
  子类是基类的直接扩展，它继承了基类的属性和方法，并可以添加新的属性和方法。子类通常用于具体化基类的行为。
  示例：

  // 基类 Shape 定义了计算面积的方法
  public abstract class Shape {
      public abstract double getArea();
  }
  
  // 子类 Rectangle 继承自 Shape，具体实现了计算矩形面积的方法
  public class Rectangle extends Shape {
      private double width;
      private double height;
  
      public Rectangle(double width, double height) {
          this.width = width;
          this.height = height;
      }
  
      @Override
      public double getArea() {
          return width * height;
      }
  }
  
  

• 派生类：
  派生类是子类的扩展，它继承了子类的属性和方法，并可以进一步添加新的属性和方法。派生类的关系可以延续下去，形成继承层次结构
  示例

  // 派生类 Square 继承自 Rectangle，实现正方形的计算面积方法
  public class Square extends Rectangle {
      public Square(double side) {
          super(side, side);
      }
  }
  

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

• 实体：对象

6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成 / 聚合的方式，而不是使用继承。

• 合成：
  合成是一种通过将现有类的实例作为新类的成员来实现代码复用的机制。新类可以使用现有类的功能，但不继承现有类的行为。这种方式降低了类之间的耦合度，使系统更加灵活。
  示例：

  class Engine {
      void start() {
          // 启动引擎
      }
  }
  
  class Car {
      private Engine engine;
  
      Car() {
          engine = new Engine();
      }
  
      void startCar() {
          engine.start();
          // 启动车辆
      }
  }
  

• 聚合：

  聚合是一种特殊的合成，其中一个类表示整体，而另一个类表示部分。部分对象可以存在独立于整体对象，但它们通常会关联在一起。聚合关系比合成关系更松散允许部分对象独立存在。
  示例：

  class Department {
      // 部门相关信息
  }
  
  class Company {
      private List<Department> departments;
  
      Company() {
          departments = new ArrayList<>();
      }
  
      void addDepartment(Department department) {
          departments.add(department);
      }
  }
  

• 继承：
  继承是一种通过从已有类派生新类的方式来实现代码复用的机制。派生类继承了基类的属性和方法，可以通过重写方法来修改或扩展其行为。继承是一种强耦合的机制，因为它将派生类与基类紧密联系在一起
  示例：

  class Vehicle {
      void start() {
          // 启动车辆
      }
  }
  
  class Car extends Vehicle {
      void openRoof() {
          // 打开车顶
      }
  }