设计模式是在软件工程中用来解决常见问题的一种标准解决方案。通过使用设计模式，开发者可以编写出更加灵活、可维护和易于扩展的代码。本文将介绍几种常见的设计模式，并通过具体的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 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 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中的实战代码示例。通过使用这些设计模式，开发者可以更好地组织代码，提高程序的可维护性和可扩展性。

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