Java设计模式与实战案例解析

在软件开发领域，设计模式是解决常见问题的经典解决方案。Java作为一门广泛应用的语言，其设计模式在实际项目中扮演着至关重要的角色。本文将深入探讨几种常见的Java设计模式，并通过实战案例展示它们的应用。

单例模式：确保唯一性

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在配置管理、数据库连接等场景中非常有用。

实战案例：数据库连接池

public class DatabaseConnectionPool {
    private static DatabaseConnectionPool instance;
    private Connection connection;

    private DatabaseConnectionPool() {
        // 初始化数据库连接
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
    }

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

    public Connection getConnection() {
        return connection;
    }
}

在这个案例中，DatabaseConnectionPool类通过私有构造函数和getInstance方法确保全局只有一个数据库连接实例，避免了资源浪费。

工厂模式：简化对象创建

工厂模式通过一个工厂类来创建对象，避免了直接使用构造函数，使得对象的创建过程更加灵活。

实战案例：支付方式选择

interface Payment {
    void pay(double amount);
}

class CreditCardPayment implements Payment {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using Credit Card");
    }
}

class PayPalPayment implements Payment {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using PayPal");
    }
}

class PaymentFactory {
    public static Payment getPaymentMethod(String method) {
        if ("creditcard".equalsIgnoreCase(method)) {
            return new CreditCardPayment();
        } else if ("paypal".equalsIgnoreCase(method)) {
            return new PayPalPayment();
        }
        throw new IllegalArgumentException("Unknown payment method");
    }
}

在这个案例中，PaymentFactory根据传入的支付方式字符串返回相应的支付对象，使得支付方式的扩展和切换更加方便。

观察者模式：实现事件监听

观察者模式允许对象在状态变化时通知其他对象，常用于事件监听和消息订阅。

实战案例：股票价格更新

import java.util.ArrayList;
import java.util.List;

interface StockObserver {
    void update(double price);
}

class Stock {
    private double price;
    private List<StockObserver> observers = new ArrayList<>();

    public void addObserver(StockObserver observer) {
        observers.add(observer);
    }

    public void setPrice(double price) {
        this.price = price;
        notifyObservers();
    }

    private void notifyObservers() {
        for (StockObserver observer : observers) {
            observer.update(price);
        }
    }
}

class Investor implements StockObserver {
    private String name;

    public Investor(String name) {
        this.name = name;
    }

    public void update(double price) {
        System.out.println(name + " received update: Stock price is now " + price);
    }
}

在这个案例中，Stock类在价格变化时通知所有注册的Investor对象，实现了实时价格更新的功能。

装饰器模式：动态扩展功能

装饰器模式在不改变原有对象结构的情况下，动态地添加新功能。

实战案例：咖啡调味

interface Coffee {
    double cost();
    String description();
}

class SimpleCoffee implements Coffee {
    public double cost() {
        return 1.0;
    }

    public String description() {
        return "Simple Coffee";
    }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee decoratedCoffee) {
        this.decoratedCoffee = decoratedCoffee;
    }

    public double cost() {
        return decoratedCoffee.cost();
    }

    public String description() {
        return decoratedCoffee.description();
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }

    public double cost() {
        return super.cost() + 0.5;
    }

    public String description() {
        return super.description() + ", Milk";
    }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }

    public double cost() {
        return super.cost() + 0.2;
    }

    public String description() {
        return super.description() + ", Sugar";
    }
}

在这个案例中，通过MilkDecorator和SugarDecorator，可以动态地为SimpleCoffee添加牛奶和糖，而不改变其原有结构。

Java设计模式在实际开发中具有极高的实用价值，通过合理运用这些