┌────────────────────┐
          │      Strategy      │
          │ + execute():void   │
          └─────────┬──────────┘
                    │
 ┌──────────────────┼────────────────────┐
 │                  │                    │
 ▼                  ▼                    ▼
ConcreteStrategyA  ConcreteStrategyB   ConcreteStrategyC
│ + execute()      │ + execute()       │ + execute()
└──────────────────┘ └─────────────────┘ └──────────────┘

          ┌────────────────────┐
          │      Context       │
          │ - strategy:Strategy│
          │ + setStrategy()    │
          │ + execute()        │
          └────────────────────┘

if (type.equals("ali")) { payByAli(); }
else if (type.equals("wechat")) { payByWechat(); }
else if (type.equals("bank")) { payByBank(); }

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

public class AliPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付 " + amount + " 元");
    }
}

public class WeChatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付 " + amount + " 元");
    }
}

public class BankPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用银行卡支付 " + amount + " 元");
    }
}

public class PaymentContext {
    private PaymentStrategy strategy;

    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void executePayment(double amount) {
        if (strategy == null) {
            throw new IllegalStateException("未设置支付策略");
        }
        strategy.pay(amount);
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext();

        context.setStrategy(new AliPayStrategy());
        context.executePayment(100);

        context.setStrategy(new WeChatPayStrategy());
        context.executePayment(200);

        context.setStrategy(new BankPayStrategy());
        context.executePayment(300);
    }
}

使用支付宝支付 100 元
使用微信支付 200 元
使用银行卡支付 300 元

 ```java

 import org.springframework.web.bind.annotation.*;
 
 @RestController
 @RequestMapping("/promotion")
 public class PromotionController {
 
     private final PromotionStrategyContext context;
 
     public PromotionController(PromotionStrategyContext context) {
         this.context = context;
     }
 
     @GetMapping("/execute")
     public String execute(@RequestParam String type) {
         context.executeStrategy(type);
         return "执行成功";
     }
 }
 ```

 ```url
 GET /promotion/execute?type=discount
 GET /promotion/execute?type=cashback
 GET /promotion/execute?type=fullReduction
 ```

 **输出**：

 ```
 执行【打折】优惠策略
 执行【返现】优惠策略
 执行【满减】优惠策略
 ```

public abstract class Beverage {

    // 模板方法 — 定义制作流程
    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    // 固定的公共步骤
    private void boilWater() {
        System.out.println("Boiling water");
    }

    private void pourInCup() {
        System.out.println("Pouring into cup");
    }

    // 抽象方法（交给子类实现）
    protected abstract void brew();
    protected abstract void addCondiments();
}

public class Tea extends Beverage {
    @Override
    protected void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding lemon");
    }
}
public class Coffee extends Beverage {
    @Override
    protected void brew() {
        System.out.println("Dripping coffee through filter");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding sugar and milk");
    }
}

public class Main {
    public static void main(String[] args) {
        Beverage tea = new Tea();
        tea.prepareRecipe();

        System.out.println("-----");

        Beverage coffee = new Coffee();
        coffee.prepareRecipe();
    }
}

Boiling water
Steeping the tea
Pouring into cup
Adding lemon
-----
Boiling water
Dripping coffee through filter
Pouring into cup
Adding sugar and milk

// 抽象模板类
public abstract class DatabaseTemplate {

    // 模板方法：固定执行流程
    public final void execute() {
        connect();
        executeSQL();
        close();
    }

    private void connect() {
        System.out.println("Connecting to database...");
    }

    private void close() {
        System.out.println("Closing connection...");
    }

    // 子类实现不同SQL逻辑
    protected abstract void executeSQL();
}

public class UserQuery extends DatabaseTemplate {
    @Override
    protected void executeSQL() {
        System.out.println("Executing: SELECT * FROM users;");
    }
}

public class OrderInsert extends DatabaseTemplate {
    @Override
    protected void executeSQL() {
        System.out.println("Executing: INSERT INTO orders VALUES(...);");
    }
}

public class Main {
    public static void main(String[] args) {
        DatabaseTemplate query = new UserQuery();
        query.execute();

        System.out.println("----");

        DatabaseTemplate insert = new OrderInsert();
        insert.execute();
    }
}

Connecting to database...
Executing: SELECT * FROM users;
Closing connection...
----
Connecting to database...
Executing: INSERT INTO orders VALUES(...);
Closing connection...

public abstract class ReportExporter {
    // 导出流程
    public final void export() {
        fetchData();
        generateContent();
        saveToFile();
    }
	//获取数据
    protected abstract void fetchData();
    //生成内容
    protected abstract void generateContent();
	//保存文件
    private void saveToFile() {
        System.out.println("Saving file to disk...");
    }
}

// pdf导出
public class PdfExporter extends ReportExporter {
    @Override
    protected void fetchData() {
        System.out.println("Fetching data from database...");
    }

    @Override
    protected void generateContent() {
        System.out.println("Generating PDF content...");
    }
}
// excel导出
public class ExcelExporter extends ReportExporter {
    @Override
    protected void fetchData() {
        System.out.println("Fetching data from API...");
    }

    @Override
    protected void generateContent() {
        System.out.println("Generating Excel content...");
    }
}

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

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

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

public class WeatherStation implements Subject {
    //存储所有需要通知的观察者
    private List<Observer> observers = new ArrayList<>();
    private String weather;

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
	//核心逻辑：通知观察者
    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(weather);
        }
    }

    // 当天气变化时自动通知所有观察者
    public void setWeather(String weather) {
        this.weather = weather;
        System.out.println("Weather changed to: " + weather);
        notifyObservers();
    }
}

public class PhoneDisplay implements Observer {
    private String name;

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

    @Override
    public void update(String weather) {
        System.out.println(name + " received weather update: " + weather);
    }
}

public class Main {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();

        Observer phone1 = new PhoneDisplay("Alice's Phone");
        Observer phone2 = new PhoneDisplay("Bob's Phone");

        station.registerObserver(phone1);
        station.registerObserver(phone2);

        station.setWeather("Sunny");
        System.out.println("-----");
        station.setWeather("Rainy");
    }
}

Weather changed to: Sunny
Alice's Phone received weather update: Sunny
Bob's Phone received weather update: Sunny
-----
Weather changed to: Rainy
Alice's Phone received weather update: Rainy
Bob's Phone received weather update: Rainy

button.addActionListener(e -> System.out.println("按钮被点击"));

import org.springframework.context.ApplicationEvent;

public class OrderCreatedEvent extends ApplicationEvent {
    private final String orderId;

    public OrderCreatedEvent(Object source, String orderId) {
        super(source);
        this.orderId = orderId;
    }

    public String getOrderId() {
        return orderId;
    }
}

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class NotifyUserListener {
	//这里的 @EventListener`就是告诉 Spring： “当某个事件发生时，调用这个方法。”
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        System.out.println("发送通知：订单创建成功 -> " + event.getOrderId());
    }
}

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final ApplicationEventPublisher publisher;

    public OrderService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void createOrder(String orderId) {
        System.out.println("创建订单：" + orderId);

        // 发布事件 -> 自动触发所有监听这个事件的观察者
        publisher.publishEvent(new OrderCreatedEvent(this, orderId));
    }
}

orderService.createOrder("ORD123");

创建订单：ORD123
发送通知：订单创建成功 -> ORD123

员工提交请假 → 主管 → 经理 → 总经理

Client
  |
  v
Handler1 --> Handler2 --> Handler3

public abstract class Handler {

    // 下一个处理者
    protected Handler next;

    // 设置下一个处理者
    public void setNext(Handler next) {
        this.next = next;
    }

    // 处理请求（抽象方法）
    public abstract void handleRequest(int leaveDays);
}

// 主管审批
public class LeaderHandler extends Handler {
    @Override
    public void handleRequest(int leaveDays) {
        if (leaveDays <= 1) {
            System.out.println("主管批准请假 " + leaveDays + " 天");
        } else if (next != null) {
            next.handleRequest(leaveDays);
        }
    }
}

// 经理审批
public class ManagerHandler extends Handler {
    @Override
    public void handleRequest(int leaveDays) {
        if (leaveDays <= 3) {
            System.out.println("经理批准请假 " + leaveDays + " 天");
        } else if (next != null) {
            next.handleRequest(leaveDays);
        }
    }
}

// 总经理审批
public class BossHandler extends Handler {
    @Override
    public void handleRequest(int leaveDays) {
        if (leaveDays <= 7) {
            System.out.println("总经理批准请假 " + leaveDays + " 天");
        } else {
            System.out.println("请假天数太多，不批准！");
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Handler leader = new LeaderHandler();
        Handler manager = new ManagerHandler();
        Handler boss = new BossHandler();

        // 组装责任链
        leader.setNext(manager);
        manager.setNext(boss);

        // 发起请求
        System.out.println("请假 1 天：");
        leader.handleRequest(1);

        System.out.println("\n请假 3 天：");
        leader.handleRequest(3);

        System.out.println("\n请假 5 天：");
        leader.handleRequest(5);

        System.out.println("\n请假 10 天：");
        leader.handleRequest(10);
    }
}

请假 1 天：
主管批准请假 1 天

请假 3 天：
经理批准请假 3 天

请假 5 天：
总经理批准请假 5 天

请假 10 天：
请假天数太多，不批准

request → Filter1 → Filter2 → Filter3 → Controller → Response

public class LogFilter implements Filter {
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        System.out.println("进入日志过滤器");
        chain.doFilter(req, res); // 放行
        System.out.println("离开日志过滤器");
    }
}

request → Interceptor1 → Interceptor2 → Controller

public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        if (request.getHeader("token") == null) {
            response.setStatus(401);
            return false; // 终止链
        }
        return true; // 放行
    }
}

@Transactional → @Around("log") → @Around("auth") → Controller

Object proceed() throws Throwable;  // 类似 chain.doFilter()

SecurityContextPersistenceFilter
→ LogoutFilter
→ UsernamePasswordAuthenticationFilter
→ FilterSecurityInterceptor
→ ...

GlobalFilter1 → GlobalFilter2 → RouteFilter → ...

@FunctionalInterface
interface Handler {
    boolean handle(int days); // 返回 true 表示已处理，false 交给下一个
}

public class LambdaChain {
    public static void main(String[] args) {
        Handler leader = (days) -> {
            if (days <= 1) {
                System.out.println("主管批准 " + days + " 天");
                return true;
            }
            return false;
        };

        Handler manager = (days) -> {
            if (days <= 3) {
                System.out.println("经理批准 " + days + " 天");
                return true;
            }
            return false;
        };

        Handler boss = (days) -> {
            if (days <= 7) {
                System.out.println("总经理批准 " + days + " 天");
                return true;
            }
            System.out.println("请假太多，不批准");
            return true;
        };

        // 组装链条（这里用函数式方式动态连接）
        Handler chain = combine(leader, manager, boss);

        // 执行
        chain.handle(1);
        chain.handle(4);
        chain.handle(10);
    }

    static Handler combine(Handler... handlers) {
        return (days) -> {
            for (Handler handler : handlers) {
                if (handler.handle(days)) return true; // 有人处理就中断
            }
            return false;
        };
    }
}

// 灯的类
class Light {
    public void on() {
        System.out.println("灯打开了");
    }
    
    public void off() {
        System.out.println("灯关闭了");
    }
}

// 遥控器类
class SimpleRemoteControl {
    Light light;
    
    public void setLight(Light light) {
        this.light = light;
    }
    
    public void onButtonPressed() {
        light.on();
    }
    
    public void offButtonPressed() {
        light.off();
    }
}

public class RemoteControlTest {
    public static void main(String[] args) {
        // 1. 创建接收者（设备）
        Light livingRoomLight = new Light("客厅");
        Light bedroomLight = new Light("卧室");
        AirConditioner ac = new AirConditioner();
        
        // 2. 创建命令
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
        
        LightOnCommand bedroomLightOn = new LightOnCommand(bedroomLight);
        LightOffCommand bedroomLightOff = new LightOffCommand(bedroomLight);
        
        AirConditionerOnCommand acOn = new AirConditionerOnCommand(ac);
        AirConditionerSetTempCommand acSetTemp = new AirConditionerSetTempCommand(ac, 24);
        
        // 3. 创建调用者（遥控器）
        SmartRemoteControl remote = new SmartRemoteControl();
        
        // 4. 设置命令到遥控器插槽
        remote.setCommand(0, livingRoomLightOn, livingRoomLightOff);
        remote.setCommand(1, bedroomLightOn, bedroomLightOff);
        remote.setCommand(2, acOn, null); // 空调只有开，没有专门关的命令
        
        // 5. 测试
        System.out.println("=== 测试遥控器 ===");
        remote.onButtonPressed(0);  // 开客厅灯
        remote.offButtonPressed(0); // 关客厅灯
        remote.undoButtonPressed(); // 撤销：开客厅灯
        
        remote.onButtonPressed(1);  // 开卧室灯
        remote.onButtonPressed(2);  // 开空调
        
        // 6. 测试宏命令
        System.out.println("\n=== 测试宏命令（一键离家模式）===");
        Command[] leaveHomeCommands = {
            new LightOffCommand(livingRoomLight),
            new LightOffCommand(bedroomLight),
            new AirConditionerOnCommand(ac) // 为了简化，这里用关空调的命令更好
        };
        MacroCommand leaveHomeMacro = new MacroCommand(leaveHomeCommands);
        
        remote.setCommand(5, leaveHomeMacro, null);
        remote.onButtonPressed(5); // 一键执行离家模式
        remote.undoButtonPressed(); // 撤销离家模式
    }
}

命令模式 = 调用者 → 【中间商（命令对象）】 → 执行者
                 ↑_________________|
                 中间商赚的差价：
                 1. 存储历史记录
                 2. 支持回退
                 3. 延迟执行
                 4. 排队执行

@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepo;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private CouponService couponService;
    @Autowired
    private NotificationService notificationService;
    
    // 定时任务：每分钟执行一次，查找超时未支付订单
    @Scheduled(cron = "0 */1 * * * ?")
    public void autoCancelTimeoutOrders() {
        List<Order> timeoutOrders = orderRepo.findTimeoutUnpaidOrders(30);
        
        for (Order order : timeoutOrders) {
            // 1. 修改订单状态
            order.setStatus(OrderStatus.CANCELLED);
            order.setCancelReason("超时未支付");
            orderRepo.save(order);
            
            // 2. 恢复库存
            for (OrderItem item : order.getItems()) {
                inventoryService.increaseStock(item.getSkuId(), item.getQuantity());
            }
            
            // 3. 返还优惠券
            if (order.getCouponId() != null) {
                couponService.restoreCoupon(order.getCouponId());
            }
            
            // 4. 发送通知
            notificationService.send(order.getUserId(), 
                "您的订单" + order.getOrderNo() + "已超时取消");
        }
    }
    
    // 用户手动取消
    public void manualCancel(Long orderId, Long userId) {
        Order order = orderRepo.findById(orderId);
        // 权限校验...
        
        // 复制粘贴了和上面几乎一样的代码！！！
        order.setStatus(OrderStatus.CANCELLED);
        order.setCancelReason("用户手动取消");
        orderRepo.save(order);
        
        for (OrderItem item : order.getItems()) {
            inventoryService.increaseStock(item.getSkuId(), item.getQuantity());
        }
        
        if (order.getCouponId() != null) {
            couponService.restoreCoupon(order.getCouponId());
        }
        
        notificationService.send(order.getUserId(), 
            "您已成功取消订单" + order.getOrderNo());
    }
    
    // 管理员批量取消
    public void batchCancel(List<Long> orderIds) {
        // 又复制一遍...代码开始失控
    }
}

public class Fan {
    public static final int OFF = 0;
    public static final int LOW = 1;
    public static final int MEDIUM = 2;
    public static final int HIGH = 3;
    
    private int state = OFF;
    
    public void pull() {
        if (state == OFF) {
            state = LOW;
            System.out.println("低速档");
        } else if (state == LOW) {
            state = MEDIUM;
            System.out.println("中速档");
        } else if (state == MEDIUM) {
            state = HIGH;
            System.out.println("高速档");
        } else if (state == HIGH) {
            state = OFF;
            System.out.println("关闭");
        }
    }
}

┌─────────────────┐      ┌─────────────────┐
│     Context     │      │     State       │
│  (上下文/环境)   │──────│    (抽象状态)    │
├─────────────────┤      ├─────────────────┤
│ -state: State   │      │ +handle()       │
│ +request()      │      └─────────────────┘
└─────────────────┘              ▲
                                 │
                ┌────────────────┼────────────────┐
                │                │                │
        ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
        │ ConcreteStateA│ │ ConcreteStateB│ │ ConcreteStateC│
        │  (具体状态A)  │ │  (具体状态B)  │ │  (具体状态C)  │
        ├──────────────┤ ├──────────────┤ ├──────────────┤
        │ +handle()    │ │ +handle()    │ │ +handle()    │
        └──────────────┘ └──────────────┘ └──────────────┘

// 状态接口
public interface FanState {
    void pull(FanContext context);  // 拉一下开关
}

// 关闭状态
public class OffState implements FanState {
    @Override
    public void pull(FanContext fan) {
        System.out.println("从关闭状态切换到低速档");
        fan.setState(new LowState());  // 切换到低速状态
    }
}

// 低速状态
public class LowState implements FanState {
    @Override
    public void pull(FanContext fan) {
        System.out.println("从低速档切换到中速档");
        fan.setState(new MediumState());
    }
}

// 中速状态
public class MediumState implements FanState {
    @Override
    public void pull(FanContext fan) {
        System.out.println("从中速档切换到高速档");
        fan.setState(new HighState());
    }
}

// 高速状态
public class HighState implements FanState {
    @Override
    public void pull(FanContext fan) {
        System.out.println("从高速档切换到关闭状态");
        fan.setState(new OffState());
    }
}

public class FanContext {

    private FanState currentState;

    public FanContext() {
        // 初始状态：关闭
        currentState = new OffState();
    }

    public void setState(FanState state) {
        this.currentState = state;
    }

    public void pull() {
        // 委托给当前状态对象处理
        currentState.pull(this);
    }
}

public class Test {
    public static void main(String[] args) {
        FanContext fan = new FanContext();

        fan.pull();  // 关闭 → 低速
        fan.pull();  // 低速 → 中速
        fan.pull();  // 中速 → 高速
        fan.pull();  // 高速 → 关闭
        fan.pull();  // 关闭 → 低速
    }
}

// 订单状态接口
public interface OrderState {
    void pay(Order order);           // 支付
    void ship(Order order);          // 发货
    void confirm(Order order);       // 确认收货
    void cancel(Order order);        // 取消
}

// 待支付状态
public class PendingState implements OrderState {
    @Override
    public void pay(Order order) {
        System.out.println("支付成功，订单状态变为【已支付】");
        order.setState(new PaidState());
    }
    
    @Override
    public void ship(Order order) {
        System.out.println("请先完成支付才能发货");
    }
    
    @Override
    public void confirm(Order order) {
        System.out.println("请先支付再确认收货");
    }
    
    @Override
    public void cancel(Order order) {
        System.out.println("订单已取消");
        order.setState(new CancelledState());
    }
}

// 已支付状态
public class PaidState implements OrderState {
    @Override
    public void pay(Order order) {
        System.out.println("订单已支付，请勿重复支付");
    }
    
    @Override
    public void ship(Order order) {
        System.out.println("发货成功，订单状态变为【已发货】");
        order.setState(new ShippedState());
    }
    
    @Override
    public void confirm(Order order) {
        System.out.println("请等待发货后再确认收货");
    }
    
    @Override
    public void cancel(Order order) {
        System.out.println("退款申请中，订单已取消");
        order.setState(new CancelledState());
    }
}

// 订单类
public class Order {
    private OrderState state;
    
    public Order() {
        this.state = new PendingState();  // 初始状态：待支付
    }
    
    public void setState(OrderState state) {
        this.state = state;
    }
    
    public void pay() {
        state.pay(this);
    }
    
    public void ship() {
        state.ship(this);
    }
    
    public void confirm() {
        state.confirm(this);
    }
    
    public void cancel() {
        state.cancel(this);
    }
}

// 不封装的做法
public class BookShelf {
    private Book[] books;
    private int last = 0;
    
    public Book getBookAt(int index) {
        return books[index];
    }
    
    public int getLength() {
        return last;
    }
}

// 客户端遍历
BookShelf bookShelf = new BookShelf();
for (int i = 0; i < bookShelf.getLength(); i++) {
    Book book = bookShelf.getBookAt(i);
    System.out.println(book.getName());
}

┌─────────────────┐         ┌─────────────────┐
│   <<interface>> │         │   <<interface>> │
│    Aggregate    │         │    Iterator     │
├─────────────────┤         ├─────────────────┤
│ +iterator()     │────────▶│ +hasNext():bool │
└─────────────────┘         │ +next():Object  │
         ▲                  └─────────────────┘
         │                            ▲
         │                            │
┌─────────────────┐         ┌─────────────────┐
│ ConcreteAggregate│        │ ConcreteIterator│
├─────────────────┤         ├─────────────────┤
│ +iterator()     │────────▶│ -aggregate      │
└─────────────────┘         │ -index          │
                            │ +hasNext()      │
                            │ +next()         │
                            └─────────────────┘

public class Book {
    private String name;
    
    public Book(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

public interface Iterator {
    boolean hasNext();
    Object next();
}

public interface Aggregate {
    Iterator iterator();
}

public class BookShelf implements Aggregate {
    private Book[] books;
    private int last = 0;
    
    public BookShelf(int maxSize) {
        this.books = new Book[maxSize];
    }
    
    public Book getBookAt(int index) {
        return books[index];
    }
    
    public void appendBook(Book book) {
        this.books[last] = book;
        last++;
    }
    
    public int getLength() {
        return last;
    }
    
    @Override
    public Iterator iterator() {
        return new BookShelfIterator(this);
    }
}

public class BookShelfIterator implements Iterator {
    private BookShelf bookShelf;
    private int index;
    
    public BookShelfIterator(BookShelf bookShelf) {
        this.bookShelf = bookShelf;
        this.index = 0;
    }
    
    @Override
    public boolean hasNext() {
        return index < bookShelf.getLength();
    }
    
    @Override
    public Object next() {
        Book book = bookShelf.getBookAt(index);
        index++;
        return book;
    }
}

public class Main {
    public static void main(String[] args) {
        BookShelf bookShelf = new BookShelf(4);
        bookShelf.appendBook(new Book("设计模式"));
        bookShelf.appendBook(new Book("Java编程思想"));
        bookShelf.appendBook(new Book("Effective Java"));
        bookShelf.appendBook(new Book("重构"));
        
        Iterator it = bookShelf.iterator();
        while (it.hasNext()) {
            Book book = (Book) it.next();
            System.out.println(book.getName());
        }
    }
}

设计模式
Java编程思想
Effective Java
重构

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// 或者使用 for-each（语法糖，底层也是迭代器）
for (String s : list) {
    System.out.println(s);
}

// Java 8 内部迭代器
list.forEach(System.out::println);

// 没有中介者的糟糕设计
public class Aircraft {
    private List<Aircraft> otherAircrafts;
    
    public void changeAltitude(int newAltitude) {
        this.altitude = newAltitude;
        for (Aircraft other : otherAircrafts) {
            other.receiveAlert(this, newAltitude);
        }
    }
}

┌─────────────────────────────────────────────────────────────┐
│                         Mediator                             │
│                       (中介者接口)                            │
├─────────────────────────────────────────────────────────────┤
│ +notify(sender: Colleague, event: String)                   │
└─────────────────────────────────────────────────────────────┘
                              ▲
                              │
                ┌─────────────┼─────────────┐
                │             │             │
    ┌───────────────────┐ ┌───────────────────┐
    │ ConcreteMediator  │ │   Colleague        │
    │   (具体中介者)      │ │   (同事类接口)      │
    ├───────────────────┤ ├───────────────────┤
    │ -colleagues       │ │ +setMediator()     │
    │ +notify()         │ │ +action()          │
    └───────────────────┘ └───────────────────┘
                                    ▲
                                    │
                    ┌───────────────┼───────────────┐
                    │               │               │
        ┌───────────────────┐ ┌───────────────────┐
        │ ConcreteColleague1│ │ ConcreteColleague2│
        │   (具体同事类1)     │ │   (具体同事类2)     │
        ├───────────────────┤ ├───────────────────┤
        │ +action1()        │ │ +action2()        │
        │ +send()           │ │ +send()           │
        └───────────────────┘ └───────────────────┘

// 中介者接口
public interface SmartHomeMediator {
    void notify(String event, Device sender);
}

// 抽象同事类
public abstract class Device {
    protected SmartHomeMediator mediator;
    protected String name;
    
    public Device(String name, SmartHomeMediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }
    
    // 发送事件到中介者
    public void sendEvent(String event) {
        mediator.notify(event, this);
    }
    
    // 接收来自中介者的指令
    public abstract void receive(String instruction);
    
    public String getName() {
        return name;
    }
}

// 灯光设备
public class Light extends Device {
    private boolean isOn = false;
    
    public Light(String name, SmartHomeMediator mediator) {
        super(name, mediator);
    }
    
    public void turnOn() {
        if (isOn) {
            System.out.println(name + " 已经是打开状态，无需重复操作");
            return;
        }
        isOn = true;
        System.out.println(name + " 已打开");
        sendEvent("light_on");
    }
    
    public void turnOff() {
        if (!isOn) {
            System.out.println(name + " 已经是关闭状态");
            return;
        }
        isOn = false;
        System.out.println(name + " 已关闭");
        sendEvent("light_off");
    }
    
    public boolean isOn() {
        return isOn;
    }
    
    @Override
    public void receive(String instruction) {
        if ("auto_adjust".equals(instruction)) {
            System.out.println(name + " 接收到自动调节指令");
        }
    }
}

// 窗帘设备
public class Curtain extends Device {
    private boolean isOpen = true;
    
    public Curtain(String name, SmartHomeMediator mediator) {
        super(name, mediator);
    }
    
    public void open() {
        if (isOpen) {
            System.out.println(name + " 已经是打开状态");
            return;
        }
        isOpen = true;
        System.out.println(name + " 已打开");
        sendEvent("curtain_opened");
    }
    
    public void close() {
        if (!isOpen) {
            System.out.println(name + " 已经是关闭状态");
            return;
        }
        isOpen = false;
        System.out.println(name + " 已关闭");
        sendEvent("curtain_closed");
    }
    
    public boolean isOpen() {
        return isOpen;
    }
    
    @Override
    public void receive(String instruction) {
        if ("close".equals(instruction)) {
            close();
        } else if ("open".equals(instruction)) {
            open();
        }
    }
}

// 空调设备
public class AirConditioner extends Device {
    private int temperature = 25;

    public AirConditioner(String name, SmartHomeMediator mediator) {
        super(name, mediator);
    }

    public void setTemperature(int temp) {
        this.temperature = temp;
        System.out.println(name + " 温度设为 " + temp + "度");
        sendEvent("ac_temperature_changed");
    }

    @Override
    public void receive(String instruction) {
        if ("close_window".equals(instruction)) {
            System.out.println(name + " 接收指令：请关闭窗户以保持温度");
        }
    }
}

// 具体中介者：协调各个设备
public class SmartHomeMediatorImpl implements SmartHomeMediator {
    private Light light;
    private AirConditioner ac;
    private Curtain curtain;
    // 还可以有其他设备...
    
    public void setLight(Light light) { this.light = light; }
    public void setAirConditioner(AirConditioner ac) { this.ac = ac; }
    public void setCurtain(Curtain curtain) { this.curtain = curtain; }
    
    @Override
    public void notify(String event, Device sender) {
        System.out.println("中介者收到事件 [" + event + "] 来自 " + sender.getName());
        
        // 根据事件协调其他设备
        if ("light_on".equals(event)) {
            // 如果灯开了，且是白天，则关闭窗帘
            if (isDayTime()) {
                curtain.receive("close");
            }
        } else if ("light_off".equals(event)) {
            // 如果灯关了，可以考虑打开窗帘
            curtain.receive("open");
        } else if ("ac_temperature_changed".equals(event)) {
            // 空调温度改变，提醒关闭窗户
            // 假设有窗户设备...
            System.out.println("中介者提醒：请关闭窗户以节能");
        } else if ("curtain_closed".equals(event)) {
            // 窗帘关闭后，如果灯没开，可以考虑自动开灯
            if (!lightIsOn()) {
                light.turnOn();
            }
        }
    }
    
    private boolean isDayTime() {
        // 模拟判断白天黑夜
        return true;
    }
    
    private boolean lightIsOn() {
        // 这里可以维护状态，或者直接询问 light
        return false; // 简化
    }
}

public class HomeAutomationApp {
    public static void main(String[] args) {
        // 创建中介者
        SmartHomeMediatorImpl mediator = new SmartHomeMediatorImpl();
        
        // 创建设备，并注入中介者
        Light light = new Light("客厅灯", mediator);
        AirConditioner ac = new AirConditioner("客厅空调", mediator);
        Curtain curtain = new Curtain("客厅窗帘", mediator);
        
        // 设置中介者中的设备引用（中介者需要知道所有设备）
        mediator.setLight(light);
        mediator.setAirConditioner(ac);
        mediator.setCurtain(curtain);
        
        // 用户操作：打开灯
        light.turnOn();
        // 输出: 
        // 客厅灯 已打开
        // 中介者收到事件 [light_on] 来自 客厅灯
        // 客厅窗帘 已关闭   (因为白天，中介者自动关了窗帘)
        
        // 用户操作：调节空调温度
        ac.setTemperature(22);
        // 输出:
        // 客厅空调 温度设为 22度
        // 中介者收到事件 [ac_temperature_changed] 来自 客厅空调
        // 中介者提醒：请关闭窗户以节能
    }
}

┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│ Originator  │      │   Memento   │      │  Caretaker  │
│ (原发器)     │──────│ (备忘录)    │──────│ (负责人)    │
├─────────────┤      ├─────────────┤      ├─────────────┤
│ -state      │      │ -state      │      │ -memento    │
│ +saveToMemento()│   │ +getState()│      │ +addMemento()│
│ +restoreFromMemento()│ └─────────────┘      │ +getMemento()│
└─────────────┘                               └─────────────┘

// 备忘录：保存角色状态
public class RoleStateMemento {
    private int hp;
    private int mp;
    private int x;
    private int y;

    public RoleStateMemento(int hp, int mp, int x, int y) {
        this.hp = hp;
        this.mp = mp;
        this.x = x;
        this.y = y;
    }

    // 只提供getter，不提供setter，保证只有原发器可以设置
    public int getHp() { return hp; }
    public int getMp() { return mp; }
    public int getX() { return x; }
    public int getY() { return y; }
}

// 原发器：游戏角色
public class GameRole {
    private int hp;
    private int mp;
    private int x;
    private int y;

    public GameRole(int hp, int mp, int x, int y) {
        this.hp = hp;
        this.mp = mp;
        this.x = x;
        this.y = y;
    }

    // 战斗等方法会改变状态
    public void fight() {
        hp -= 20;
        mp -= 10;
        System.out.println("战斗后：hp=" + hp + ", mp=" + mp);
    }

    public void move(int dx, int dy) {
        x += dx;
        y += dy;
        System.out.println("移动到 (" + x + "," + y + ")");
    }

    // 保存当前状态到备忘录
    public RoleStateMemento saveState() {
        return new RoleStateMemento(hp, mp, x, y);
    }

    // 从备忘录恢复状态
    public void restoreState(RoleStateMemento memento) {
        this.hp = memento.getHp();
        this.mp = memento.getMp();
        this.x = memento.getX();
        this.y = memento.getY();
        System.out.println("恢复状态：hp=" + hp + ", mp=" + mp + ", 位置=(" + x + "," + y + ")");
    }

    public void display() {
        System.out.println("当前状态：hp=" + hp + ", mp=" + mp + ", 位置=(" + x + "," + y + ")");
    }
}

// 负责人：负责保存备忘录，但不能修改备忘录内容
public class Caretaker {
    // 可以保存多个存档，用栈实现撤销功能
    private Stack<RoleStateMemento> mementoStack = new Stack<>();

    // 存档：压入栈
    public void saveMemento(RoleStateMemento memento) {
        mementoStack.push(memento);
        System.out.println("存档成功，当前存档数量：" + mementoStack.size());
    }

    // 读档：弹出最近一次存档
    public RoleStateMemento loadMemento() {
        if (mementoStack.isEmpty()) {
            System.out.println("没有存档！");
            return null;
        }
        return mementoStack.pop();
    }
}

public class GameClient {
    public static void main(String[] args) {
        // 创建角色
        GameRole role = new GameRole(100, 50, 0, 0);
        Caretaker caretaker = new Caretaker();

        // 初始状态
        role.display();

        // 第一次存档
        caretaker.saveMemento(role.saveState());

        // 进行一些操作
        role.fight();
        role.move(5, 3);

        // 第二次存档
        caretaker.saveMemento(role.saveState());

        // 继续操作
        role.fight();
        role.move(-2, 1);

        // 想回到第二次存档之后的状态（即撤销一次）
        System.out.println("\n准备读档...");
        RoleStateMemento memento = caretaker.loadMemento();
        if (memento != null) {
            role.restoreState(memento);
        }

        role.display();
    }
}

当前状态：hp=100, mp=50, 位置=(0,0)
存档成功，当前存档数量：1
战斗后：hp=80, mp=40
移动到 (5,3)
存档成功，当前存档数量：2
战斗后：hp=60, mp=30
移动到 (3,4)

准备读档...
恢复状态：hp=80, mp=40, 位置=(5,3)
当前状态：hp=80, mp=40, 位置=(5,3)

public class GameRole {
    // ... 属性

    // 备忘录作为内部类，私有
    private class Memento {
        private int hp;
        private int mp;
        private int x;
        private int y;

        private Memento(int hp, int mp, int x, int y) {
            this.hp = hp;
            this.mp = mp;
            this.x = x;
            this.y = y;
        }

        private int getHp() { return hp; }
        // ... 其他getter
    }

    // 对外提供的备忘录接口（窄接口）
    public interface IRoleMemento { }  // 空接口，只作为类型标记

    public IRoleMemento saveState() {
        return new Memento(hp, mp, x, y);
    }

    public void restoreState(IRoleMemento memento) {
        Memento m = (Memento) memento;  // 强制转换，只有原发器能访问内部类
        this.hp = m.getHp();
        this.mp = m.getMp();
        this.x = m.getX();
        this.y = m.getY();
    }
}

SELECT * FROM user 
<if test="name != null"> 
    WHERE name = #{name}
</if>

public class MiniMyBatisDemo {
    public static void main(String[] args) {
        // 1. 准备参数（类似于 MyBatis 的参数对象）
        Map<String, Object> params = new HashMap<>();
        params.put("name", "张三");
        
        // 2. 创建动态 SQL（实际 MyBatis 是在启动时解析 XML 构建的，这里我们手动构建语法树）
        // 静态文本节点
        SqlNode selectNode = new StaticTextSqlNode("SELECT * FROM user");
        
        // IF 节点：判断 name != null
        SqlNode ifNode = new IfSqlNode(
            new StaticTextSqlNode(" WHERE name = #{name}"),  // 子节点
            "name != null"                                    // 测试表达式
        );
        
        // 混合节点（按顺序组合多个 SqlNode）
        MixedSqlNode mixedNode = new MixedSqlNode(Arrays.asList(selectNode, ifNode));
        
        // 3. 创建上下文，传入参数
        DynamicContext context = new DynamicContext(params);
        
        // 4. 执行解释
        mixedNode.apply(context);
        
        // 5. 获取最终解析出的 SQL
        System.out.println("解析后的 SQL: " + context.getSql());
    }
}

解析后的 SQL: SELECT * FROM user WHERE name = #{name}

解析后的 SQL: SELECT * FROM user

 ```java

 // 5. 客户端使用
 public class HospitalDemo {
     public static void main(String[] args) {
         // 数据结构：人的各个器官
         List<BodyPart> body = Arrays.asList(
             new Heart(), 
             new Liver(), 
             new Lung()
         );
         
         // 不同的访问者（医生）
         Doctor cardiologist = new Cardiologist();
         Doctor hepatologist = new Hepatologist();
         
         System.out.println("=== 心脏科医生查房 ===");
         for (BodyPart part : body) {
             part.accept(cardiologist);  // 每个器官接待心脏科医生
         }
         
         System.out.println("\n=== 肝病科医生查房 ===");
         for (BodyPart part : body) {
             part.accept(hepatologist);  // 每个器官接待肝病科医生
         }
     }
 }
 ```

 ```txt
 === 心脏科医生查房 ===
 心脏科医生检查心脏：72次/分钟
 心脏科医生：肝脏我不专业，跳过
 心脏科医生：肺部我不专业，跳过
 
 === 肝病科医生查房 ===
 肝病科医生：心脏我不看
 肝病科医生检查肝脏：正常范围
 肝病科医生：肺部我不看
 ```

// 文件系统的元素
public interface FileElement {
    void accept(FileVisitor visitor);
}

public class TextFile implements FileElement {
    public void accept(FileVisitor visitor) { visitor.visit(this); }
    public void read() { System.out.println("读取文本文件"); }
}

public class ImageFile implements FileElement {
    public void accept(FileVisitor visitor) { visitor.visit(this); }
    public void display() { System.out.println("显示图片"); }
}

// 文件操作访问者
public interface FileVisitor {
    void visit(TextFile file);
    void visit(ImageFile file);
}

public class CompressVisitor implements FileVisitor {  // 压缩操作
    public void visit(TextFile file) { 
        System.out.println("压缩文本文件");
        file.read();  // 先读再压缩
    }
    public void visit(ImageFile file) { 
        System.out.println("压缩图片文件");
        file.display();  // 先显示再压缩？
    }
}

public class VirusScanVisitor implements FileVisitor {  // 病毒扫描
    public void visit(TextFile file) { System.out.println("扫描文本文件病毒"); }
    public void visit(ImageFile file) { System.out.println("扫描图片文件病毒"); }
}

// 第一次分派：根据元素的实际类型
part.accept(doctor);  // part 是 Heart → Heart.accept()
                     // part 是 Liver → Liver.accept()

// 第二次分派：在 accept 内部，根据访问者的实际类型
// 在 Heart.accept() 中：
void accept(Doctor doctor) {
    // 这里的 this 明确是 Heart 类型
    doctor.visit(this);  // → 调用 visit(Heart heart)
}