Java设计模式实战指南

设计模式是在软件工程中用来解决常见问题的一种标准解决方案。通过使用设计模式，开发者可以编写出更加灵活、可维护和易于扩展的代码。本文将介绍几种常见的设计模式，并通过具体的Java代码示例来展示它们的实际应用。

1. 单例模式

单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。

实战代码示例

java

深色版本

1public class Singleton {
2    private static Singleton instance;
3
4    private Singleton() {}
5
6    public static synchronized Singleton getInstance() {
7        if (instance == null) {
8            instance = new Singleton();
9        }
10        return instance;
11    }
12}

应用场景

• 当系统只需要一个对象来协调某些活动时。
• 当对象的创建成本很高时。

2. 工厂模式

工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪一个类。

实战代码示例

java

深色版本

1interface Shape {
2    void draw();
3}
4
5class Circle implements Shape {
6    @Override
7    public void draw() {
8        System.out.println("Drawing a circle");
9    }
10}
11
12class Square implements Shape {
13    @Override
14    public void draw() {
15        System.out.println("Drawing a square");
16    }
17}
18
19class ShapeFactory {
20    public Shape getShape(String shapeType) {
21        if (shapeType == null) {
22            return null;
23        }
24        if (shapeType.equalsIgnoreCase("CIRCLE")) {
25            return new Circle();
26        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
27            return new Square();
28        }
29        return null;
30    }
31}

应用场景

• 当客户端不知道应该实例化哪个类时。
• 当创建对象的逻辑很复杂时。

3. 建造者模式

建造者模式是一种创建型设计模式，它允许你逐步构建一个复杂的对象。

实战代码示例

java

深色版本

1class Meal {
2    private List<String> items = new ArrayList<>();
3
4    public void addItem(String item) {
5        items.add(item);
6    }
7
8    @Override
9    public String toString() {
10        return "Meal{" +
11                "items=" + items +
12                '}';
13    }
14}
15
16interface MealBuilder {
17    void buildFood();
18    void buildDrink();
19    Meal getMeal();
20}
21
22class VegMealBuilder implements MealBuilder {
23    private Meal meal;
24
25    public VegMealBuilder() {
26        this.meal = new Meal();
27    }
28
29    @Override
30    public void buildFood() {
31        meal.addItem("Vegetarian Burger");
32    }
33
34    @Override
35    public void buildDrink() {
36        meal.addItem("Orange Juice");
37    }
38
39    @Override
40    public Meal getMeal() {
41        return meal;
42    }
43}
44
45class MealDirector {
46    private MealBuilder mealBuilder;
47
48    public MealDirector(MealBuilder mealBuilder) {
49        this.mealBuilder = mealBuilder;
50    }
51
52    public Meal construct() {
53        mealBuilder.buildFood();
54        mealBuilder.buildDrink();
55        return mealBuilder.getMeal();
56    }
57}

应用场景

• 当对象的构建过程很复杂时。
• 当需要构建的对象有多个变体时。

4. 装饰者模式

装饰者模式是一种结构型设计模式，它允许向对象添加新的功能，同时保持类结构的灵活性。

实战代码示例

java

深色版本

1interface Component {
2    String operation();
3}
4
5class ConcreteComponent implements Component {
6    @Override
7    public String operation() {
8        return "ConcreteComponent";
9    }
10}
11
12abstract class Decorator implements Component {
13    protected Component component;
14
15    public Decorator(Component component) {
16        this.component = component;
17    }
18
19    @Override
20    public String operation() {
21        return component.operation();
22    }
23}
24
25class ConcreteDecoratorA extends Decorator {
26    public ConcreteDecoratorA(Component component) {
27        super(component);
28    }
29
30    @Override
31    public String operation() {
32        return "ConcreteDecoratorA(" + super.operation() + ")";
33    }
34}
35
36class ConcreteDecoratorB extends Decorator {
37    public ConcreteDecoratorB(Component component) {
38        super(component);
39    }
40
41    @Override
42    public String operation() {
43        return "ConcreteDecoratorB(" + super.operation() + ")";
44    }
45}

应用场景

• 当需要扩展一个类的功能，但是不希望使用继承。
• 当需要动态地给对象添加职责时。

5. 观察者模式

观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

实战代码示例

java

深色版本

1import java.util.ArrayList;
2import java.util.List;
3
4interface Observer {
5    void update(String message);
6}
7
8interface Subject {
9    void registerObserver(Observer o);
10    void removeObserver(Observer o);
11    void notifyObservers(String message);
12}
13
14class ConcreteSubject implements Subject {
15    private List<Observer> observers = new ArrayList<>();
16    private String message;
17
18    @Override
19    public void registerObserver(Observer o) {
20        observers.add(o);
21    }
22
23    @Override
24    public void removeObserver(Observer o) {
25        observers.remove(o);
26    }
27
28    @Override
29    public void notifyObservers(String message) {
30        this.message = message;
31        for (Observer observer : observers) {
32            observer.update(message);
33        }
34    }
35}
36
37class ConcreteObserver implements Observer {
38    private String name;
39
40    public ConcreteObserver(String name) {
41        this.name = name;
42    }
43
44    @Override
45    public void update(String message) {
46        System.out.println(name + " received: " + message);
47    }
48}

应用场景

• 当一个对象的状态发生变化时，需要通知其他对象。
• 当一个对象需要维护一组依赖对象，但不知道有多少个这样的对象时。

总结

本文介绍了五种常用的设计模式，并给出了它们在Java中的实战代码示例。通过使用这些设计模式，开发者可以更好地组织代码，提高程序的可维护性和可扩展性。

每种设计模式都有其适用场景，了解这些模式可以帮助你在遇到相关问题时做出更好的设计决策。