设计模式解析：在Java开发中，常见设计模式是如何实现的？

原创缺乏、安全感 2024-11-28 05:54 43阅读 0赞

设计模式是解决特定问题的解决方案，它们被抽象出来，以便开发者可以复用这些已证明有效的解决方案。

以下是一些常见的Java设计模式及其实现：

1. **单例模式**（Singleton）
   - 实现：使用`ThreadLocal`或者`AtomicReference`来保证全局唯一。
   - 代码示例：
     ```java
     public class Singleton {
         private static Singleton instance;

private Singleton() {}

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

// 其他方法
     }
     ```

2. **工厂模式**（Factory）
   - 实现：使用`abstract class`创建抽象工厂，然后为每个产品类型创建一个具体工厂类。
   - 代码示例：
     ```java
     // 抽象工厂
     public abstract class Factory {
         public abstract Product createProduct();
     }

// 具体工厂
     public class ConcreteFactory1 extends Factory {
         @Override
         public Product createProduct() {
             return new Product1();
         }
     }

// 产品接口
     public interface Product {
         String getProductInfo();
     }

// 产品类型实现
     public class Product1 implements Product {
         @Override
         public String getProductInfo() {
             return "This is product 1";
         }
     }
     ```

3. **观察者模式**（Observer）
   - 实现：使用`abstract class`创建抽象主题类，然后为每个观察者类型创建一个具体观察者类。在主题类中定义通知方法。
   - 代码示例：
     ```java
     // 抽象主题
     public abstract 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 abstract void notifyObservers();
     }

// 抽象观察者
     public abstract class Observer {
         // 观察者方法，根据具体主题类实现
         public abstract void update(Subject subject, Object data));
     }

// 具体观察者1
     public class ConcreteObserver1 extends Observer {
         @Override
         public void update(Subject subject, Object data) {
             System.out.println("Observer 1 received: " + data);
         }
     }

// 具体主题类，例如新闻系统
     public class NewsSystem extends Subject {
         private String headline;

// 新闻标题设置方法
         public void setHeadline(String headline) {
             this.headline = headline;
             notifyObservers();
         }

// 通知观察者更新
         @Override
         public void notifyObservers() {
             for (Observer observer : observers) {
                 observer.update(this, headline);
             }
         }
     }

// 使用示例
     public class Main {
         public static void main(String[] args) {
             NewsSystem newsSystem = new NewsSystem();

// 添加观察者
             ConcreteObserver1 observer1 = new ConcreteObserver1();
             newsSystem.addObserver(observer1);

// 设置新闻标题
             newsSystem.setHeadline("Breaking News!");

// 通知所有观察者更新
             newsSystem.notifyObservers();
         }
     }
     ```

以上是几种常见的Java设计模式及其实现，但实际开发中可能还会用到其他设计模式。