设计模式在Java开发中的具体运用示例

原创拼搏现实的明天。 2024-10-05 20:03 53阅读 0赞

设计模式是软件设计中的一种常见解决方案。在Java开发中，我们可以通过遵循特定的设计模式来优化代码结构和复用性。以下是一些具体的设计模式及其在Java中的应用：

1. **单例模式**（Singleton）
   - 运用：线程安全的全局资源管理。
   - Java实现：
     ```java
     public class Singleton {
         private static Singleton instance = new Singleton();

private Singleton() {}

public static Singleton getInstance() {
             return instance;
         }
     }
     ```

2. **工厂模式**（Factory）
   - 运用：创建具有相同接口的对象，而不关心对象的创建过程。
   - Java实现：
     ```java
     // 创建一个抽象工厂类
     abstract class Factory {
         public Product createProduct(String type) {
             if ("type1".equals(type)) {
                 return new Type1();
             } else if ("type2".equals(type)) {
                 return new Type2();
             }
             throw new IllegalArgumentException("Invalid product type: " + type);
         }
     }

// 创建具体产品类
     class Type1 extends Product {
         @Override
         public void doSomething() {
             System.out.println("Doing something for Type1");
         }
     }

class Type2 extends Product {
         @Override
         public void doSomething() {
             System.out.println("Doing something for Type2");
         }
     }

// 创建抽象工厂类实例
     final Factory factory = new ConcreteFactory();

// 根据产品类型创建对象并执行操作
     Product type1Product = factory.createProduct("type1"));
     type1Product.doSomething();

Product type2Product = factory.createProduct("type2"));
     type2Product.doSomething();
     ```

3. **观察者模式**（Observer）
   - 运用：当一个对象的状态发生改变时，所有依赖于该对象的其他对象都会得到通知并自动更新。
   - Java实现：
     ```java
     // 定义抽象主题类
     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);
         }

// 发布主题相关事件并通知所有注册的观察者
         protected void notifyObservers(String eventType, Object eventData) {
             for (Observer observer : observers) {
                 observer.update(eventType, eventData));
             }
         }
     }

// 定义抽象观察者类
     abstract class Observer {
         public abstract void update(String eventType, Object eventData));
     }

// 实现具体主题和观察者类
     class ConcreteSubject extends Subject {
         private String status = "Ready";

// 主题状态变化处理
         public synchronized void changeStatus(String newStatus) {
             if (newStatus != null && !newStatus.isEmpty()) {
                 this.status = newStatus;
                 notifyObservers("statusChange", this.status));
             }
         }

@Override
         public String getStatus() {
             return status;
         }
     }

// 实现具体观察者类
     class ConcreteObserver1 extends Observer {
         private final Subject subject;

public ConcreteObserver1(Subject subject) {
             this.subject = subject;
             subject.addObserver(this);
         }

@Override
         public void update(String eventType, Object eventData) {
             System.out.println("ConcreteObserver1 received event: " + eventType + ", data: " + eventData);

// 根据事件类型处理数据
             if ("statusChange".equals(eventType))) {
                 String newStatus = (String) eventData;
                 subject.changeStatus(newStatus);
                 System.out.println("New status set to: " + newStatus);
             }
         }
     }

// 测试代码
     public class Main {
         public static void main(String[] args) {
             // 创建主题和观察者
             ConcreteSubject concreteSubject = new ConcreteSubject();
             ConcreteObserver1 concreteObserver1 = new ConcreteObserver1(concreteSubject);

// 观察者注册后，主题状态变化会通知所有注册的观察者
             concreteSubject.changeStatus("Processing...");

// 输出观察者收到的通知信息
             System.out.println("\nObservation received by ConcreteObserver1:");
             concreteObserver1.update(null, null); // 用于输出观察者收到的通知信息，此处为便利，实际不需要调用
         }
     }
     ```

以上示例展示了一个完整的观察者模式，包括主题（Subject）、观察者（Observer）和通知（Notification）机制。