java设计模式介绍

好的，让我们针对每种设计模式分别给出详细的业务场景和相应的 Java 代码：

单例模式（Singleton Pattern）

业务场景：假设我们有一个日志管理器，我们希望在整个应用程序中只有一个日志管理器实例。

public class Logger {
    private static Logger instance;
    
    private Logger() {
        // 私有构造函数，防止外部实例化
    }
    
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
    
    public void log(String message) {
        System.out.println("Log: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Logger logger1 = Logger.getInstance();
        Logger logger2 = Logger.getInstance();
        
        logger1.log("Message 1");
        logger2.log("Message 2");
        
        // 输出：
        // Log: Message 1
        // Log: Message 2
    }
}

工厂模式（Factory Pattern）

业务场景：假设我们有一个数据库连接工厂，根据不同的数据库类型创建不同的数据库连接对象。

public interface Database {
    void connect();
}

public class MySqlConnection implements Database {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL database");
    }
}

public class OracleConnection implements Database {
    @Override
    public void connect() {
        System.out.println("Connecting to Oracle database");
    }
}

public class DatabaseFactory {
    public Database createDatabase(String type) {
        if (type.equals("MySQL")) {
            return new MySqlConnection();
        } else if (type.equals("Oracle")) {
            return new OracleConnection();
        } else {
            throw new IllegalArgumentException("Invalid database type");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        DatabaseFactory factory = new DatabaseFactory();
        
        Database mysql = factory.createDatabase("MySQL");
        mysql.connect();
        
        Database oracle = factory.createDatabase("Oracle");
        oracle.connect();
        
        // 输出：
        // Connecting to MySQL database
        // Connecting to Oracle database
    }
}

观察者模式（Observer Pattern）

业务场景：假设我们有一个新闻发布者，用户可以订阅新闻并在新闻发布时收到通知。

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

public interface Observer {
    void update(String news);
}

public class NewsPublisher {
    private List<Observer> observers = new ArrayList<>();
    
    public void subscribe(Observer observer) {
        observers.add(observer);
    }
    
    public void publishNews(String news) {
        for (Observer observer : observers) {
            observer.update(news);
        }
    }
}

public class User implements Observer {
    private String name;
    
    public User(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String news) {
        System.out.println(name + " received news: " + news);
    }
}

public class Main {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();
        
        User user1 = new User("Alice");
        User user2 = new User("Bob");
        
        publisher.subscribe(user1);
        publisher.subscribe(user2);
        
        publisher.publishNews("Breaking news: Java is awesome!");
        
        // 输出：
        // Alice received news: Breaking news: Java is awesome!
        // Bob received news: Breaking news: Java is awesome!
    }
}

策略模式（Strategy Pattern）

业务场景：假设我们有一个支付系统，用户可以选择不同的支付方式。

public interface PaymentStrategy {
    void pay(double amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " using credit card");
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " using PayPal");
    }
}

public class PaymentProcessor {
    private PaymentStrategy paymentStrategy;
    
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    
    public void processPayment(double amount) {
        paymentStrategy.pay(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        PaymentProcessor processor = new PaymentProcessor();
        
        processor.setPaymentStrategy(new CreditCardPayment());
        processor.processPayment(100.0);
        
        processor.setPaymentStrategy(new PayPalPayment());
        processor.processPayment(50.0);
        
        // 输出：
        // Paying 100.0 using credit card
        // Paying 50.0 using PayPal
    }
}

装饰器模式（Decorator Pattern）

业务场景：假设我们有一个咖啡店，顾客可以选择不同的咖啡并添加不同的配料。

public interface Coffee {
    double cost();
}

public class SimpleCoffee implements Coffee {
    @Override
    public double cost() {
        return 2.0;
    }
}

public abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;
    
    public CoffeeDecorator(Coffee decoratedCoffee) {
        this.decoratedCoffee = decoratedCoffee;
    }
    
    @Override
    public double cost() {
        return decoratedCoffee.cost();
    }
}

public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }
    
    @Override
    public double cost() {
        return super.cost() + 1.0;
    }
}

public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }
    
    @Override
    public double cost() {
        return super.cost() + 0.5;
    }
}

public class Main {
    public static void main(String[] args) {
        Coffee simpleCoffee = new SimpleCoffee();
        System.out.println("Cost of simple coffee: " + simpleCoffee.cost());
        
        Coffee milkCoffee = new MilkDecorator(simpleCoffee);
        System.out.println("Cost of coffee with milk: " + milkCoffee.cost());
        
        Coffee sugarMilkCoffee = new SugarDecorator(milkCoffee);
        System.out.println("Cost of coffee with milk and sugar: " + sugarMilkCoffee.cost());
        
        // 输出：
        // Cost of simple coffee: 2.0
        // Cost of coffee with milk: 3.0
        // Cost of coffee with milk and sugar: 3.5
    }
}

适配器模式（Adapter Pattern）

业务场景：假设我们有一个系统需要接收不同格式的数据，我们需要一个适配器将不同格式的数据转换为统一格式。

public interface DataFormat {
    void processData(String data);
}

public class XMLData implements DataFormat {
    @Override
    public void processData(String data) {
        System.out.println("Processing XML data: " + data);
    }
}

public class JSONData {
    public void handleData(String data) {
        System.out.println("Handling JSON data: " + data);
    }
}

public class JSONDataAdapter implements DataFormat {
    private JSONData jsonData;
    
    public JSONDataAdapter(JSONData jsonData) {
        this.jsonData = jsonData;
    }
    
    @Override
    public void processData(String data) {
        jsonData.handleData(data);
    }
}

public class Main {
    public static void main(String[] args) {
        DataFormat xmlData = new XMLData();
        xmlData.processData("XML Data");
        
        JSONData jsonData = new JSONData();
        DataFormat jsonAdapter = new JSONDataAdapter(jsonData);
        jsonAdapter.processData("JSON Data");
        
        // 输出：
        // Processing XML data: XML Data
        // Handling JSON data: JSON Data
    }
}

以上是针对每种设计模式的详细业务场景和相应的 Java 代码示例。希望这些示例能帮助您更好地理解这些设计模式的应用和实现。如果您有任何问题或需要进一步解释，请随时告诉我。