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(); // 事件被触发
}
}
### 总结
通过深入分析开闭原则，我们可以发现它在软件设计中的紧张性。遵循开闭原则可以让我们的代码更加机动、可维护和可扩展。无论是通过接口、抽象类、策略模式照旧工厂模式，大概联合变乱驱动架构，我们都可以实现这一原则。
1. **机动性**：可以轻松添加新功能，而不需要修改现有代码。
2. **降低耦合**：通过接口和抽象类，系统的各个部分相互独立。
3. **提高可维护性**：现有代码的稳固性得以保证，维护本钱降低。
通过这些示例，可以看到怎样在实际开发中应用开闭原则，以构建更高质量的软件系统。
更多实用教程资源：
http://sj.ysok.net/jydoraemon 访问码：JYAM
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]