Java编程中常见设计模式的应用示例

原创柔光的暖阳◎ 2024-10-15 00:00 33阅读 0赞

设计模式是软件设计中的经验和总结，它们提供了一种通用的、可重用的解决方案。以下是几个常见设计模式及其应用示例：

1. ** Singleton（单例）**：保证类只有一个实例，并提供全局访问点。

```java
// 静态内部类实现单例
public class Singleton {
    private static Singleton instance = new Singleton();

// 获取唯一实例
    public static Singleton getInstance() {
        return instance;
    }

// 私有构造函数，防止外部创建实例
    private Singleton() {}
}
```

2. ** Factory Method（工厂方法）**：用于创建对象，但不提供具体创建对象的类。

```java
// 创建抽象产品
public abstract class Product {
    public abstract void operation();
}

// 创建具体产品的工厂
public class FactoryProduct {
    public static Product create(String type) {
        if ("type1".equals(type)) {
            return new ConcreteProduct1();
        } else if ("type2".equals(type)) {
            return new ConcreteProduct2();
        }
        return null; // 如果类型不存在，返回null
    }
}

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

public class ConcreteProduct2 extends Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProduct2 - Operation");
    }
}
```

3. ** Observer Pattern（观察者模式）**：定义对象之间一对多依赖关系，当一对象状态发生改变时，所有依赖它的对象都会得到通知并自动更新。

```java
// 定义抽象被观察的类
public abstract class Observable {
    // 添加和移除观察者的集合
    private List<Observer> observers = new ArrayList<>();

// 观察者方法接口
    public interface Observer {
        void update(Observable observable, Object data));
    }

// 添加观察者的方法
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

// 移除观察者的方法
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

// 把状态改变通知给所有观察者
    protected void notifyObservers(Observable observable, Object data) {
        for (Observer observer : observers) {
            observer.update(observable, data);
        }
    }
}

// 定义具体的被观察的类
public class ConcreteObservable extends Observable {

private String state;

// 初始化状态为"initial"
    public ConcreteObservable() {
        state = "initial";
    }

// 设置状态
    public void setState(String newState) {
        state = newState;
        notifyObservers(this, new StateChange(state, newState))));
    }

// 获取当前状态
    public String getState() {
        return state;
    }
}

// 定义具体的观察者类
public class ConcreteObserver implements Observer {

private String observation;

// 初始化观察为"initial"
    public ConcreteObserver() {
        observation = "initial";
    }

// 设置观察结果
    public void setObservation(String newObservation) {
        observation = newObservation;
        notifyObservers(ConcreteObservable.class, new ObservationChange(observation, newObservation)))));
    }

// 获取当前观察结果
    public String getObservation() {
        return observation;
    }
}

// 实现状态变化和观察变化的接口
public class StateChange implements Observer {

private String currentState;
    private String newState;

// 初始化状态为"initial"
    public StateChange(String initialState, String newState) {
        currentState = initialState;
        newState = newState;
    }

// 设置当前状态
    public void setCurrentState(String currentState) {
        this.currentState = currentState;
        notifyObservers(ConcreteObservable.class, new CurrentStateChange(currentState, currentState)))));
    }

// 获取当前状态
    public String getCurrentState() {
        return currentState;
    }
}

// 实现观察变化的接口
public class ObservationChange implements Observer {

private String observation;
    private String newObservation;

// 初始化观察为"initial"
    public ObservationChange(String initialObservation, String newObservation) {
        observation = initialObservation;
        newObservation = newObservation;
    }

// 设置当前观察结果
    public void setObservation(String newObservation) {
        this.newObservation = newObservation;
        notifyObservers(ConcreteObservable.class, new ObservationChange(newObservation, newObservation)))));
    }

// 获取当前观察结果
    public String getObservation() {
        return observation;
    }
}
```

以上示例展示了如何在Java中使用工厂方法（Factory Method）模式来创建对象。