利用java设计模式的思维优化代码

在Java开发中，设计模式提供了一套解决常见软件设计问题的成熟方案。通过合理应用设计模式，可以提高代码的可维护性、可读性和扩展性。以下是几个常用设计模式的示例，说明如何利用设计模式思维来优化代码。

1. 工厂模式（Factory Pattern）

场景：
假设你在开发一个系统，需要创建不同类型的日志记录器，如文件日志记录器、控制台日志记录器等。如果你在代码中直接使用new关键字创建这些对象，当需要添加新的日志类型时，可能需要修改多处代码，违反了“开放-封闭原则”。
优化前代码：

public class LoggerService {
    public Logger createLogger(String type) {
        if ("file".equals(type)) {
            return new FileLogger();
        } else if ("console".equals(type)) {
            return new ConsoleLogger();
        }
        return null;
    }
}

优化后代码：
使用工厂模式，将对象创建的细节封装起来。

// Logger接口
public interface Logger {
    void log(String message);
}

// 文件日志记录器
public class FileLogger implements Logger {
    public void log(String message) {
        System.out.println("Logging to a file: " + message);
    }
}

// 控制台日志记录器
public class ConsoleLogger implements Logger {
    public void log(String message) {
        System.out.println("Logging to console: " + message);
    }
}

// Logger工厂
public class LoggerFactory {
    public static Logger createLogger(String type) {
        if ("file".equals(type)) {
            return new FileLogger();
        } else if ("console".equals(type)) {
            return new ConsoleLogger();
        }
        throw new IllegalArgumentException("Unknown logger type");
    }
}

优点：

• 遵循开放-封闭原则：新增日志记录器时，只需扩展新的类，而不需要修改现有代码。
• 代码更易维护和扩展。

2. 策略模式（Strategy Pattern）

场景：
假设你在开发一个电子商务系统，系统需要根据不同的支付方式（如信用卡、PayPal、支付宝）进行支付处理。最初你可能会在一个类中通过if-else来处理不同的支付方式，但随着支付方式的增加，代码会变得臃肿且难以维护。

优化前代码：

public class PaymentService {
    public void pay(String type, double amount) {
        if ("creditCard".equals(type)) {
            // 信用卡支付逻辑
        } else if ("PayPal".equals(type)) {
            // PayPal支付逻辑
        } else if ("AliPay".equals(type)) {
            // 支付宝支付逻辑
        }
    }
}

优化后代码：
使用策略模式，将不同的支付逻辑封装在独立的类中，并通过接口规范它们的行为。

// 支付策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 信用卡支付实现
public class CreditCardPayment implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

// PayPal支付实现
public class PayPalPayment implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

// 支付宝支付实现
public class AliPayPayment implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using AliPay.");
    }
}

// 支付服务类
public class PaymentService {
    private PaymentStrategy paymentStrategy;

    public PaymentService(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void pay(double amount) {
        paymentStrategy.pay(amount);
    }
}

优点：

• 支持算法的灵活切换和扩展：新增支付方式时，只需添加新的策略类。
• 避免代码臃肿，提高代码的可读性和可维护性。

3. 观察者模式（Observer Pattern）

场景：
假设你在开发一个股票交易系统，多个客户端需要实时获取股票价格的变化。你可以使用观察者模式，当股票价格发生变化时，系统会自动通知所有订阅该股票的客户端。

优化前代码：

public class Stock {
    private double price;

    public void setPrice(double price) {
        this.price = price;
        // 通知客户端（假设直接调用）
    }
}

优化后代码：
使用观察者模式，将客户端注册为观察者，当股票价格变化时，通知所有观察者。

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

// 观察者接口
public interface Observer {
    void update(double price);
}

// 股票类
public class Stock {
    private double price;
    private List<Observer> observers = new ArrayList<>();

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

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

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

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

// 客户端实现
public class StockClient implements Observer {
    private String clientName;

    public StockClient(String clientName) {
        this.clientName = clientName;
    }

    @Override
    public void update(double price) {
        System.out.println("Client " + clientName + " received price update: " + price);
    }
}

优点：

• 使得发布者与订阅者解耦：发布者不需要知道观察者的细节，只需通知它们。
• 易于扩展：新增观察者时，不需要修改现有代码。

通过合理地应用设计模式，可以使得代码结构更加清晰、可扩展性更强，减少代码的耦合性，从而更容易进行后期的维护和扩展。