Java开发中常见且有趣的10种设计模式

在Java的世界里，设计模式就像一道美味的菜肴，虽然看似简单，但制作起来却需要精心调配各种“香料”。今天就让我们一起探索那些在Java开发中被广泛使用的、既实用又有趣的10种设计模式吧！

单例模式：程序界的“独孤求败”

单例模式堪称Java开发中的“独孤求败”，它确保一个类只有一个实例，并提供一个全局访问点。想象一下，如果你正在经营一家咖啡店，而咖啡机只允许存在一台，这样不仅能节省空间，还能防止混乱。在Java中，我们可以通过懒汉式和饿汉式两种方式来实现单例模式。懒汉式如同一个谨慎的老板，只有当需要的时候才启动咖啡机；而饿汉式则像一位早起的店员，在咖啡店开业之前就已经准备好了咖啡机。

// 懒汉式单例模式
public class CoffeeMachine {
    private static CoffeeMachine instance;
    
    private CoffeeMachine() {}
    
    public static CoffeeMachine getInstance() {
        if (instance == null) {
            instance = new CoffeeMachine();
        }
        return instance;
    }
}

工厂模式：生产线上高效的“工头”

工厂模式就像是一个生产线上的“工头”，负责管理和分配工作。在Java中，当你需要创建对象时，如果直接new会导致代码过于冗长且难以维护，那么工厂模式就是你的救星。例如，当你需要生产不同类型的咖啡时，可以定义一个抽象的咖啡工厂类，然后让具体的工厂子类去实现具体的产品创建逻辑。

// 工厂模式示例
public abstract class CoffeeFactory {
    public abstract Coffee createCoffee();
}

public class LatteFactory extends CoffeeFactory {
    @Override
    public Coffee createCoffee() {
        return new Latte();
    }
}

观察者模式：消息传递中的“社交达人”

观察者模式仿佛是一个消息灵通的“社交达人”，当某个对象的状态发生变化时，所有依赖它的观察者都会收到通知。在Java中，我们可以使用观察者模式来构建事件驱动的应用程序。比如，当用户点击按钮时，所有的监听器都应该得到通知并做出相应的反应。

// 观察者模式示例
public interface Observer {
    void update(String message);
}

public class Button implements Subject {
    private List<Observer> observers = new ArrayList<>();
    
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

命令模式：操作指令集里的“指挥官”

命令模式就像是一名操作指令集里的“指挥官”，将请求封装成对象，从而让你能够参数化各个命令，支持撤销操作以及日志记录等功能。在Java中，我们可以通过命令模式来实现宏录制和回放功能。例如，当你想要录制一系列的操作步骤并在之后重放时，命令模式就能派上用场了。

// 命令模式示例
public interface Command {
    void execute();
}

public class MacroCommand implements Command {
    private Command[] commands;
    
    public MacroCommand(Command[] commands) {
        this.commands = commands;
    }
    
    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }
}

装饰者模式：为对象披上新衣的“裁缝”

装饰者模式好比是一个技艺高超的“裁缝”，可以在不改变原有对象的情况下动态地为其添加新的功能。在Java中，当我们需要扩展对象的行为而不修改其原始代码时，装饰者模式就显得尤为重要。例如，如果你想给一杯普通的拿铁咖啡添加奶油或糖浆，就可以使用装饰者模式来实现。

// 装饰者模式示例
public abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;
    
    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }
    
    @Override
    public String getIngredients() {
        return decoratedCoffee.getIngredients();
    }
    
    @Override
    public double getCost() {
        return decoratedCoffee.getCost();
    }
}

模板方法模式：框架里的“规矩制定者”

模板方法模式宛如一位在框架内制定规则的“规矩制定者”，定义了一个算法的骨架，将某些步骤延迟到子类中实现。在Java中，当我们需要一套固定的操作流程，但其中某些具体步骤需要根据不同情况有所变化时，模板方法模式就非常适用。例如，当你在编写一个处理订单的系统时，可以使用模板方法模式来定义订单处理的基本流程。

// 模板方法模式示例
public abstract class OrderProcessor {
    public final void processOrder() {
        validateOrder();
        calculateTotal();
        placeOrder();
    }
    
    protected abstract void validateOrder();
    protected abstract void calculateTotal();
    protected abstract void placeOrder();
}

策略模式：决策背后的“智囊团”

策略模式好似决策背后的“智囊团”，允许程序在运行时选择不同的算法或行为策略。在Java中，当我们需要根据不同的场景选择不同的算法时，策略模式就成为了一种理想的选择。例如，当你需要根据用户的偏好来决定播放哪种类型的音乐时，策略模式就能很好地满足这一需求。

// 策略模式示例
public interface MusicStrategy {
    void playMusic();
}

public class ClassicalMusicStrategy implements MusicStrategy {
    @Override
    public void playMusic() {
        System.out.println("Playing classical music...");
    }
}

public class RockMusicStrategy implements MusicStrategy {
    @Override
    public void playMusic() {
        System.out.println("Playing rock music...");
    }
}

访问者模式：数据结构中的“游客”

访问者模式像是数据结构中的“游客”，能够在不改变元素类的前提下访问其内部结构。在Java中，当我们需要对一个复杂的数据结构进行多种不同的操作时，访问者模式就能提供一种优雅的解决方案。例如，当你需要对一个员工列表进行统计分析时，可以使用访问者模式来实现不同类型的操作。

// 访问者模式示例
public interface EmployeeVisitor {
    void visit(SalariedEmployee employee);
    void visit(HourlyEmployee employee);
}

public class SalaryCalculator implements EmployeeVisitor {
    private double totalSalary = 0.0;
    
    @Override
    public void visit(SalariedEmployee employee) {
        totalSalary += employee.getSalary();
    }
    
    @Override
    public void visit(HourlyEmployee employee) {
        totalSalary += employee.getHoursWorked() * employee.getHourlyRate();
    }
}

适配器模式：接口转换中的“翻译家”

适配器模式犹如接口转换中的“翻译家”，能够让两个不兼容的接口一起工作。在Java中，当我们需要让两个原本无法协同工作的类能够合作时，适配器模式就能发挥作用。例如，当你需要在一个旧系统中使用新的API时，适配器模式就能帮助你实现无缝对接。

// 适配器模式示例
public interface NewApi {
    void performOperation();
}

public class OldSystem {
    public void oldOperation() {
        System.out.println("Performing old operation...");
    }
}

public class Adapter implements NewApi {
    private OldSystem oldSystem;
    
    public Adapter(OldSystem oldSystem) {
        this.oldSystem = oldSystem;
    }
    
    @Override
    public void performOperation() {
        oldSystem.oldOperation();
    }
}

状态模式：行为随状态变化的“变色龙”

状态模式恰似行为随状态变化的“变色龙”，允许对象在其内部状态改变时改变其行为。在Java中，当我们需要根据对象的状态来执行不同的操作时，状态模式就能提供一种灵活的解决方案。例如，当你需要实现一个自动售货机时，可以根据当前库存状态来决定是否可以继续出售商品。

// 状态模式示例
public interface VendingMachineState {
    void insertCoin();
    void selectProduct();
    void dispenseProduct();
}

public class SoldOutState implements VendingMachineState {
    private VendingMachine vendingMachine;
    
    public SoldOutState(VendingMachine vendingMachine) {
        this.vendingMachine = vendingMachine;
    }
    
    @Override
    public void insertCoin() {
        System.out.println("Machine is sold out.");
    }
    
    @Override
    public void selectProduct() {
        System.out.println("Machine is sold out.");
    }
    
    @Override
    public void dispenseProduct() {
        System.out.println("Machine is sold out.");
    }
}

以上就是Java开发中常见的10种设计模式啦！希望这些生动的例子能帮助你更好地理解和运用它们。记住，每种模式都有其独特的应用场景，只有在合适的场景下使用，才能发挥出它们最大的价值哦！