Java中如何使用设计模式

在Java中使用设计模式可以帮助你编写更加优雅、可维护和可扩展的代码。设计模式是解决特定问题的通用解决方案，它们已经被广泛接受并在实践中证明是有效的。以下是一些常见的设计模式以及如何在Java中使用它们的简要说明：

1. 单例模式（Singleton Pattern）: 确保一个类只有一个实例，并提供一个全局访问点。

   public class Singleton {
       private static Singleton instance;
       private Singleton() {}
       public static Singleton getInstance() {
           if (instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }
   

2. 工厂模式（Factory Pattern）: 提供一个创建对象的接口，但由子类决定要实例化的类是哪一个。

   interface Shape {
       void draw();
   }
   class Rectangle implements Shape {
       public void draw() { System.out.println("Inside Rectangle::draw() method."); }
   }
   class Square implements Shape {
       public void draw() { System.out.println("Inside Square::draw() method."); }
   }
   class ShapeFactory {
       // Use getShape method to get object of type shape
       public Shape getShape(String shapeType){
           if(shapeType == null){
               return null;
           }
           if(shapeType.equalsIgnoreCase("CIRCLE")){
               return new Circle();
           } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
               return new Rectangle();
           } else if(shapeType.equalsIgnoreCase("SQUARE")){
               return new Square();
           }
           return null;
       }
   }
   

3. 观察者模式（Observer Pattern）: 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

   import java.util.ArrayList;
   import java.util.List;
   
   interface Observer {
       void update(String message);
   }
   
   class ConcreteObserver implements Observer {
       private String name;
       public ConcreteObserver(String name) {
           this.name = name;
       }
       public void update(String message) {
           System.out.println(name + " received message: " + message);
       }
   }
   
   class Subject {
       private List<Observer> observers = new ArrayList<>();
       public void attach(Observer observer) {
           observers.add(observer);
       }
       public void notifyObservers(String message) {
           for (Observer observer : observers) {
               observer.update(message);
           }
       }
   }
   

4. 策略模式（Strategy Pattern）: 定义一系列的算法,把它们一个个封装起来, 并且使它们可互换。

   interface Strategy {
       int doOperation(int num1, int num2);
   }
   class OperationAdd implements Strategy {
       public int doOperation(int num1, int num2) {
           return num1 + num2;
       }
   }
   class OperationSubtract implements Strategy {
       public int doOperation(int num1, int num2) {
           return num1 - num2;
       }
   }
   class Context {
       private Strategy strategy;
       public Context(Strategy strategy) {
           this.strategy = strategy;
       }
       public int executeStrategy(int num1, int num2) {
           return strategy.doOperation(num1, num2);
       }
   }
   

5. 装饰者模式（Decorator Pattern）: 动态地给一个对象添加一些额外的职责。

   interface Coffee {
       String getDescription();
       double cost();
   }
   class SimpleCoffee implements Coffee {
       public String getDescription() { return "Simple Coffee"; }
       public double cost() { return 1; }
   }
   abstract class CoffeeDecorator implements Coffee {
       protected Coffee decoratedCoffee;
       public CoffeeDecorator(Coffee coffee) {
           this.decoratedCoffee = coffee;
       }
       public String getDescription() {
           return decoratedCoffee.getDescription();
       }
       public double cost() {
           return decoratedCoffee.cost();
       }
   }
   class MilkDecorator extends CoffeeDecorator {
       public MilkDecorator(Coffee coffee) {
           super(coffee);
       }
       public String getDescription() {
           return decoratedCoffee.getDescription() + ", Milk";
       }
       public double cost() {
           return decoratedCoffee.cost() + 0.5;
       }
   }
   

使用设计模式时，应该根据具体的问题和上下文来选择最合适的设计模式。不要为了使用设计模式而使用设计模式，而是要理解每种模式的适用场景和目的。