设计模式在Java中的实践案例

原创我不是女神ヾ 2024-12-11 12:15 11阅读 0赞

设计模式是面向对象编程经验的总结，它提供了一种解决常见问题的标准化方式。在Java中，我们可以通过创建具体的类来实现这些设计模式。

以下是一些设计模式在Java中的实践案例：

1. **单例模式**：
```java
// 静态内部类实现单例
public class Singleton {
    private static Singleton instance;

private Singleton() {}

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

2. **工厂模式**：
```java
// 简单工厂
public abstract class SimpleFactory {
    public abstract Product createProduct();
}

// 工厂方法实现
public class ConcreteSimpleFactory implements SimpleFactory {
    @Override
    public Product createProduct() {
        return new Product1();
    }
}

// 产品类
public class Product {
    // ... 其他业务逻辑 ...
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new ConcreteSimpleFactory();
        Product product = factory.createProduct();
        // ... 其他业务逻辑 ...
    }
}
```

3. **观察者模式**：
```java
// 观察者接口
public interface Observer {
    void update(String data);
}

// 被观察者接口
public interface Observable {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyAllObservers();
}

// 实现类
class ConcreteObservable implements Observable {
    private List<Observer> observers = new ArrayList<>();

@Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

@Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

@Override
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update("New data");
        }
    }
}

// 观察者类
class ConcreteObserver implements Observer {
    private String data;

@Override
    public void update(String data) {
        this.data = data;
        System.out.println("Observer received: " + data);
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        // 创建被观察者对象
        ConcreteObservable observable = new ConcreteObservable();

// 创建观察者对象
        ConcreteObserver observer = new ConcreteObserver();

// 附加观察者
        observable.attach(observer);

// 发布通知
        observable.notifyAllObservers();

// 清除观察者
        observable.detach(observer);
    }
}
```

以上案例展示了如何在Java中实现单例模式、工厂模式和观察者模式。