设计模式实践：Java编程中常见设计模式应用实例

原创今天药忘吃喽~ 2024-09-27 23:57 72阅读 0赞

设计模式是软件工程中的经验和教训的总结，它们提供了一种通用的解决方案来解决常见的设计问题。下面是一些在Java编程中常见的设计模式应用实例：

1. **单例模式**（Singleton Pattern）
   - 实现：通过饿汉式和懒汉式两种方式实现。
   - 例子：
     ```java
     // 饿汉式单例
     private static class Singleton {
         private Singleton() {}
         public static getInstance() {
             return Singleton.instance;
         }
         private static volatile Singleton instance;
     }

// 懒汉式单例
     private Singleton() {}

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

2. **工厂模式**（Factory Pattern）
   - 实现：可以是简单工厂、工厂方法和抽象工厂等。
   - 例子：
     ```java
     // 简单工厂
     interface ProductFactory {
         Product createProduct();
     }

class ConcreteProduct1 implements Product {
         @Override
         public void doSomething() {
             System.out.println("ConcreteProduct1 doing something");
         }
     }

class ConcreteProduct2 implements Product {
         @Override
         public void doSomethingElse() {
             System.out.println("ConcreteProduct2 doing something else");
         }
     }

// 工厂方法
     class ProductFactoryImpl implements ProductFactory {
         private List<Product> products = new ArrayList<>();

public void addProduct(Product product) {
             products.add(product);
         }

@Override
         public Product createProduct() {
             if (products.isEmpty()) {
                 throw new IllegalStateException("No products to choose from.");
             }
             return products.get(0);
         }
     ```

3. **观察者模式**（Observer Pattern）
   - 实现：通过抽象的观察者接口和具体的观察者类实现。
   - 例子：
     ```java
     // 观察者接口
     interface Observer {
         void update(String message);
     }

// 具体观察者类
     class ConcreteObserver implements Observer {
         @Override
         public void update(String message) {
             System.out.println("ConcreteObserver received: " + message);
         }
     }

// 主控对象（发布者）
     class Subject {
         private List<Observer> observers = new ArrayList<>();

public void addObserver(Observer observer) {
             observers.add(observer);
         }

public void removeObserver(Observer observer) {
             observers.remove(observer);
         }

public void update(String message) {
             for (Observer observer : observers) {
                 observer.update(message);
             }
         }
     ```

以上就是一些在Java编程中常见的设计模式应用实例。根据实际需求，可以选择合适的设计模式来提高代码的复用性和可维护性。