设计模式：在Java中实现常见模式的实战示例

原创短命女 2024-10-16 05:27 47阅读 0赞

设计模式是面向对象编程经验的总结，它提供了一种通用的解决方案。以下是在Java中实现几种常见设计模式的实战示例：

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

// 隐藏构造器，防止外部直接创建实例
    private Singleton() {}

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

// 使用示例
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance(); // 这两个引用指向同一个对象

```

2. **工厂模式（Factory Method）**：
```java
// 定义抽象产品接口
public abstract class Product {
    public abstract void operation();
}

// 实现具体产品的子类
class ConcreteProductA extends Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operates.");
    }
}

class ConcreteProductB extends Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operates.");
    }
}

// 工厂方法实现类，不包含具体产品子类
public class FactoryMethodExample {

// 创建工厂方法
    public static Product getProduct(String productType) {
        if (productType.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (productType.equalsIgnoreCase("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type: " + productType);
        }
    }

public static void main(String[] args) {
        // 创建并使用产品
        Product concreteProduct = getProduct("A");
        concreteProduct.operation(); // 输出: ConcreteProductA operates.

// 更改产品类型再次创建
        concreteProduct = getProduct("B");
        concreteProduct.operation(); // 输出: ConcreteProductB operates.
    }
}
```

3. **观察者模式（Observer Pattern）**：
```java
// 定义抽象观察者接口
public interface Observer {
    void update(String content);
}

// 定义具体观察者实现类
class ConcreteObserverA implements Observer {
    @Override
    public void update(String content) {
        System.out.println("ConcreteObserverA received: " + content);
    }
}

// 定义抽象被观察者接口
public interface Observable {
    // 添加观察者到列表
    void attach(Observer observer);

// 移除观察者列表
    void detach(Observer observer);

// 触发所有已附加的观察者的更新方法
    void update(String content);
}

// 定义具体被观察者实现类
class ConcreteObservableExample implements Observable {
    private List<Observer> observers;

public ConcreteObservableExample() {
        this.observers = new ArrayList<>();
    }

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

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

@Override
    public void update(String content) {
        for (Observer observer : observers) {
            observer.update(content);
        }
    }
}

// 使用示例
class MainClass {
    public static void main(String[] args) {
        // 创建观察者和被观察者
        ConcreteObserverA observerA = new ConcreteObserverA();
        ConcreteObservableExample observableExample = new ConcreteObservableExample();

// 附加观察者到被观察者列表
        observableExample.attach(observerA));

// 触发被观察者的更新方法，发布内容
        observableExample.update("This is a notification from the Observable example.");

// 移除观察者
        observableExample.detach(observerA));
    }
}
```

以上就是几种常见设计模式的Java实现示例。