java 开闭原则（ocp）详解刨析和示例-牛翰网

part01

开闭原则（Open/Closed Principle，OCP）是面向对象编程中的一个重要设计原则，属于SOLID原则之一。它的核心思想是“软件实体（类、模块、函数等）应该对扩展开放，对修改关闭”。这意味着在软件需求变化时，我们应该能够通过扩展现有代码而不是修改现有代码来实现功能的变化。

### 原则的解释

– **开放**：系统应该能够通过添加新功能或新模块来扩展，而不需要更改现有代码。
– **关闭**：现有的代码在功能上应该是稳定的，不应该因为新的需求而被修改。

### 实现方式

实现开闭原则的常见方法有：

1. **抽象类和接口**：通过定义抽象类或接口来创建可扩展的框架。
2. **多态**：利用多态性，允许通过接口或基类引用来调用子类的具体实现。

### 示例代码

以下是一个简单的示例，展示如何使用开闭原则来设计一个图形绘制程序。

#### 违反开闭原则的实现

“`java

// 形状类
public class Shape {
public int type; // 1: 圆形, 2: 矩形

public Shape(int type) {
this.type = type;
}
}

// 绘制器类
public class ShapeDrawer {
public void draw(Shape shape) {
if (shape.type == 1) {
System.out.println("Drawing a Circle");
} else if (shape.type == 2) {
System.out.println("Drawing a Rectangle");
}
}
}

// 使用示例

public class Main {
public static void main(String[] args) {
Shape circle = new Shape(1);
Shape rectangle = new Shape(2);
ShapeDrawer drawer = new ShapeDrawer();

drawer.draw(circle);
drawer.draw(rectangle);
}
}

在这个例子中，`ShapeDrawer`类的`draw`方法依赖于`Shape`类的实现细节。如果我们想添加新的形状，比如三角形，就需要修改`ShapeDrawer`类，这违背了开闭原则。

#### 遵循开闭原则的实现

我们可以使用接口和多态来重构这个例子，使其遵循开闭原则。

// 形状接口
public interface Shape {
void draw(); // 抽象方法
}

// 圆形类
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}

// 矩形类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}

// 三角形类
public class Triangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Triangle");
}
}

// 绘制器类
public class ShapeDrawer {
public void draw(Shape shape) {
shape.draw(); // 多态调用
}
}

// 使用示例
public class Main {
public static void main(String[] args) {
Shape circle = new Circle();
Shape rectangle = new Rectangle();
Shape triangle = new Triangle();

ShapeDrawer drawer = new ShapeDrawer();

drawer.draw(circle);
drawer.draw(rectangle);
drawer.draw(triangle); // 添加新形状不需要修改ShapeDrawer
}
}

### 代码分析

1. **接口 `Shape`**：定义了一个抽象的绘制方法 `draw()`，所有具体形状都实现了这个接口。
2. **具体形状类**：`Circle`、`Rectangle` 和 `Triangle` 类分别实现了 `Shape` 接口，提供了各自的 `draw()` 方法。
3. **绘制器类 `ShapeDrawer`**：`draw` 方法接受 `Shape` 接口类型的参数，通过多态性调用具体形状的 `draw()` 方法。
4. **扩展性**：如果需要添加新的形状，比如 `Triangle`，只需创建一个新的类实现 `Shape` 接口，而不需要修改 `ShapeDrawer` 的任何代码。

### 优势

– **可扩展性**：新增功能时只需添加新类，而不需要修改已有代码，减少了引入错误的风险。
– **维护性**：现有代码的稳定性得到了保证，维护成本降低。
– **灵活性**：通过接口和多态，系统的灵活性提高，可以轻松实现不同的功能需求。

### 总结

开闭原则是软件设计中的重要原则，通过合理地使用抽象类和接口，可以使系统在面对需求变化时，能够扩展而不必修改现有代码。遵循这个原则可以提高代码的可维护性、可扩展性和灵活性，是构建高质量软件的关键。

part02

让我们更详细地探讨开闭原则（OCP），并考虑更多的情况和例子。

### 开闭原则的深入分析

开闭原则强调的是在需求变化时，应该尽量避免对已实现代码的修改。这可以通过以下几种方式实现：

1. **使用抽象类和接口**：通过定义接口或抽象类来提供统一的行为。
2. **策略模式**：通过定义一系列算法，将它们封装起来，使它们可以互相替换，从而使算法的变化独立于使用算法的客户端。
3. **工厂模式**：使用工厂模式来创建对象，从而使对象的创建与使用分离。
4. **事件驱动架构**：通过事件和观察者模式来实现系统的松耦合。

### 示例：图形绘制程序的多种实现

#### 1. 初始实现（违反开闭原则）

// 形状类
public class Shape {
public int type; // 1: 圆形, 2: 矩形

public Shape(int type) {
this.type = type;
}
}

// 绘制器类
public class ShapeDrawer {
public void draw(Shape shape) {
if (shape.type == 1) {
System.out.println("Drawing a Circle");
} else if (shape.type == 2) {
System.out.println("Drawing a Rectangle");
}
// 如果要添加新的形状，比如三角形，需要修改此处
}
}

#### 2. 使用接口和多态的实现（遵循开闭原则）

// 形状接口
public interface Shape {
void draw(); // 抽象方法
}

// 圆形类
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}

// 矩形类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}

// 三角形类
public class Triangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Triangle");
}
}

// 绘制器类
public class ShapeDrawer {
public void draw(Shape shape) {
shape.draw(); // 多态调用
}
}

// 使用示例
public class Main {
public static void main(String[] args) {
Shape circle = new Circle();
Shape rectangle = new Rectangle();
Shape triangle = new Triangle();

ShapeDrawer drawer = new ShapeDrawer();

drawer.draw(circle);
drawer.draw(rectangle);
drawer.draw(triangle); // 添加新形状不需要修改ShapeDrawer
}
}

### 进一步扩展：策略模式和工厂模式

#### 3. 使用策略模式

假设我们希望根据不同的绘图策略来绘制形状，而不是在 `ShapeDrawer` 中硬编码每种形状的绘制逻辑。

// 绘制策略接口
public interface DrawStrategy {
void draw();
}

// 圆形绘制策略
public class CircleDrawStrategy implements DrawStrategy {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}

// 矩形绘制策略
public class RectangleDrawStrategy implements DrawStrategy {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}

// 三角形绘制策略
public class TriangleDrawStrategy implements DrawStrategy {
@Override
public void draw() {
System.out.println("Drawing a Triangle");
}
}

// 形状类
public class Shape {
private DrawStrategy drawStrategy;

public Shape(DrawStrategy drawStrategy) {
this.drawStrategy = drawStrategy;
}

public void draw() {
drawStrategy.draw();
}
}

// 使用示例
public class Main {
public static void main(String[] args) {
Shape circle = new Shape(new CircleDrawStrategy());
Shape rectangle = new Shape(new RectangleDrawStrategy());
Shape triangle = new Shape(new TriangleDrawStrategy());

circle.draw();
rectangle.draw();
triangle.draw(); // 添加新策略不需要修改Shape
}
}

### 4. 使用工厂模式

工厂模式可以用于创建形状对象，从而将对象的创建与使用分离。

// 形状工厂接口
public interface ShapeFactory {
Shape createShape();
}

// 圆形工厂
public class CircleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Shape(new CircleDrawStrategy());
}
}

// 矩形工厂
public class RectangleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Shape(new RectangleDrawStrategy());
}
}

// 三角形工厂
public class TriangleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Shape(new TriangleDrawStrategy());
}
}

// 使用示例
public class Main {
public static void main(String[] args) {
ShapeFactory circleFactory = new CircleFactory();
ShapeFactory rectangleFactory = new RectangleFactory();
ShapeFactory triangleFactory = new TriangleFactory();

Shape circle = circleFactory.createShape();
Shape rectangle = rectangleFactory.createShape();
Shape triangle = triangleFactory.createShape();

circle.draw();
rectangle.draw();
triangle.draw(); // 添加新形状只需新建工厂类
}
}

### 5. 事件驱动架构

如果我们希望在绘制形状时能够触发事件，可以使用事件驱动架构。我们可以定义一个事件监听器接口，并在绘制时触发事件。

// 事件监听器接口
public interface DrawListener {
void onDraw();
}

// 形状类
public class Shape {
private DrawStrategy drawStrategy;
private DrawListener listener;

public Shape(DrawStrategy drawStrategy, DrawListener listener) {
this.drawStrategy = drawStrategy;
this.listener = listener;
}

public void draw() {
if (listener != null) {
listener.onDraw(); // 触发事件
}
drawStrategy.draw();
}
}

// 使用示例
public class Main {
public static void main(String[] args) {
Shape circle = new Shape(new CircleDrawStrategy(), () -> System.out.println("Circle is being drawn"));
Shape rectangle = new Shape(new RectangleDrawStrategy(), () -> System.out.println("Rectangle is being drawn"));

circle.draw();
rectangle.draw(); // 事件被触发
}
}