Java设计模式如何应用

设计模式是解决特定设计问题的通用、可重用的解决方案。在Java中应用设计模式可以帮助开发者创建更灵活、可维护和可扩展的代码。以下是几种常见设计模式的应用示例：

工厂方法模式

应用场景：当你需要创建对象，但对象的创建逻辑复杂或者需要根据不同条件创建不同对象时，可以使用工厂方法模式。

示例代码：

// 工厂接口
interface ShapeFactory {
    Shape createShape(String type);
}

// 具体工厂
class CircleFactory implements ShapeFactory {
    public Shape createShape(String type) {
        if ("circle".equalsIgnoreCase(type)) {
            return new Circle();
        }
        return null;
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        ShapeFactory factory = new CircleFactory();
        Shape shape = factory.createShape("circle");
        shape.draw();
    }
}

单例模式

应用场景：当系统需要保证全局只有一个实例时，如配置管理器。

示例代码：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

装饰者模式

应用场景：在不改变对象自身的基础上，动态地给对象添加新的职责和行为。

示例代码：

// 组件接口
interface Beverage {
    String getDescription();
    double cost();
}

// 具体组件
class Espresso implements Beverage {
    public String getDescription() {
        return "Espresso";
    }
    public double cost() {
        return 1.99;
    }
}

// 装饰者基类
abstract class CondimentDecorator implements Beverage {
    protected Beverage beverage;
    public CondimentDecorator(Beverage beverage) {
        this.beverage = beverage;
    }
}

// 具体装饰者
class MilkDecorator extends CondimentDecorator {
    public MilkDecorator(Beverage beverage) {
        super(beverage);
    }
    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }
    public double cost() {
        return beverage.cost() + 0.50;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Beverage espresso = new Espresso();
        System.out.println(espresso.getDescription() + " $" + espresso.cost());

        Beverage milkEspresso = new MilkDecorator(espresso);
        System.out.println(milkEspresso.getDescription() + " $" + milkEspresso.cost());
    }
}

观察者模式

应用场景：实现对象间的联动，如GUI事件处理。

示例代码：

// 观察者接口
interface Observer {
    void update(double temperature, double humidity, double pressure);
}

// 具体观察者
class CurrentConditionsDisplay implements Observer {
    private double temperature;
    private double humidity;
    private double pressure;

    public void update(double temperature, double humidity, double pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }

    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees, " + humidity + "% humidity, " + pressure + " pressure");
    }
}

// 主题接口
interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 具体主题
class WeatherStation implements Subject {
    private List<Observer> observers;
    private double temperature;
    private double humidity;
    private double pressure;

    public WeatherStation() {
        observers = new ArrayList<>();
    }

    public void registerObserver(Observer o) {
        observers.add(o);
    }

    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void setMeasurements(double temperature, double humidity, double pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        notifyObservers();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        WeatherStation weatherStation = new WeatherStation();
        CurrentConditionsDisplay display = new CurrentConditionsDisplay();
        weatherStation.registerObserver(display);

        weatherStation.setMeasurements(25, 60, 1013);
    }
}

设计模式的应用需要根据具体的项目需求和场景来选择合适的模式。同时，合理使用设计模式还需要遵循一些基本原则，如单一职责原则、开闭原则、依赖倒置原则等。