阅读量:0
设计模式是在软件工程中用来解决常见问题的一种标准解决方案。通过使用设计模式，开发者可以编写出更加灵活、可维护和易于扩展的代码。本文将介绍几种常见的设计模式，并通过具体的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中的实战代码示例。通过使用这些设计模式，开发者可以更好地组织代码，提高程序的可维护性和可扩展性。
每种设计模式都有其适用场景，了解这些模式可以帮助你在遇到相关问题时做出更好的设计决策。
