public interface Vistor {
  void visitConcreteElementA(ConcreteElementA elementA);
  void visitConcreteElementB(ConcreteElementB elementB);
}

public class ConcreteVisitor implements Visitor {
    @Override
    public void visitConcreteElementA(ConcreteElementA elementA) {
        System.out.println("访问者处理元素 A：" + elementA.operation());
    }

    @Override
    public void visitConcreteElementB(ConcreteElementB elementB) {
        System.out.println("访问者处理元素 B：" + elementB.operation());
    }
}

public interface Element {
    void accept(Visitor visitor);
}

public class ConcreteElementA implements Element {
    public String operation() {
        return "元素 A 的内容";
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementA(this);
    }
}

public class ConcreteElementB implements Element {
    public String operation() {
        return "元素 B 的内容";
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementB(this);
    }
}

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

public class ObjectStructure {
    private List<Element> elements = new ArrayList<>();

    public void add(Element element) {
        elements.add(element);
    }

    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

public abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(String request);
}

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("ConcreteHandlerA 处理了请求：" + request);
        } else if (nextHandler != null) {
            System.out.println("ConcreteHandlerA 无法处理，转交给下一个...");
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("B".equals(request)) {
            System.out.println("ConcreteHandlerB 处理了请求：" + request);
        } else if (nextHandler != null) {
            System.out.println("ConcreteHandlerB 无法处理，转交给下一个...");
            nextHandler.handleRequest(request);
        }
    }
}

// 1. 定义策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 2. 实现具体策略
public class Alipay implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("支付宝支付: " + amount);
    }
}

public class WeChatPay implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("微信支付: " + amount);
    }
}

// 3. 上下文使用策略
public class ShoppingCart {
    private PaymentStrategy strategy;

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

    public void checkout(int amount) {
        strategy.pay(amount);
    }
}

// 4. 调用示例
ShoppingCart cart = new ShoppingCart();
cart.setPaymentStrategy(new Alipay());
cart.checkout(100); // 输出：支付宝支付: 100

public interface ProcessState {
  void schedule(ProcessContext context);
  void ioWait(ProcessContext context);
  void interrupt(ProcessContext context);
  void exit(ProcessContext context);
  void eventComplete(ProcessContext context);
  String getStatus();
}

public class NewState implements ProcessState {
    @Override
    public void schedule(ProcessContext context) {
        System.out.println("Admitting process to Ready state");
        context.setState(new ReadyState());
    }

    @Override
    public void exit(ProcessContext context) {
        System.out.println("Process terminated from New state");
        context.setState(new TerminatedState());
    }

    // 其他操作无意义
    @Override public void ioWait(ProcessContext context) {}
    @Override public void interrupt(ProcessContext context) {}
    @Override public void eventComplete(ProcessContext context) {}

    @Override
    public String getStatus() {
        return "New";
    }
}

public class ReadyState implements ProcessState {
    @Override
    public void schedule(ProcessContext context) {
        System.out.println("Process is now Running");
        context.setState(new RunningState());
    }

    // 其他操作暂不支持
    @Override public void ioWait(ProcessContext context) {}
    @Override public void interrupt(ProcessContext context) {}
    @Override public void exit(ProcessContext context) {}
    @Override public void eventComplete(ProcessContext context) {}

    @Override
    public String getStatus() {
        return "Ready";
    }
}

public class RunningState implements ProcessState {
    @Override
    public void ioWait(ProcessContext context) {
        System.out.println("Process is waiting for I/O");
        context.setState(new WaitingState());
    }

    @Override
    public void interrupt(ProcessContext context) {
        System.out.println("Process interrupted, back to Ready");
        context.setState(new ReadyState());
    }

    @Override
    public void exit(ProcessContext context) {
        System.out.println("Process exited normally");
        context.setState(new TerminatedState());
    }

    // 其他操作无意义
    @Override public void schedule(ProcessContext context) {}
    @Override public void eventComplete(ProcessContext context) {}

    @Override
    public String getStatus() {
        return "Running";
    }
}

public class WaitingState implements ProcessState {
    @Override
    public void eventComplete(ProcessContext context) {
        System.out.println("I/O complete, back to Ready");
        context.setState(new ReadyState());
    }

    // 其他操作无意义
    @Override public void schedule(ProcessContext context) {}
    @Override public void ioWait(ProcessContext context) {}
    @Override public void interrupt(ProcessContext context) {}
    @Override public void exit(ProcessContext context) {}

    @Override
    public String getStatus() {
        return "Waiting";
    }
}

public class TerminatedState implements ProcessState {
    @Override
    public String getStatus() {
        return "Terminated";
    }

    // 所有操作无效
    @Override public void schedule(ProcessContext context) {}
    @Override public void ioWait(ProcessContext context) {}
    @Override public void interrupt(ProcessContext context) {}
    @Override public void exit(ProcessContext context) {}
    @Override public void eventComplete(ProcessContext context) {}
}

public class ProcessContext {
    private ProcessState state;

    public ProcessContext() {
        this.state = new NewState();  // 初始状态为 New
    }

    public void setState(ProcessState state) {
        this.state = state;
        System.out.println("状态切换至：" + state.getStatus());
    }

    public void schedule() {
        state.schedule(this);
    }

    public void ioWait() {
        state.ioWait(this);
    }

    public void interrupt() {
        state.interrupt(this);
    }

    public void exit() {
        state.exit(this);
    }

    public void eventComplete() {
        state.eventComplete(this);
    }

    public String getStatus() {
        return state.getStatus();
    }
}

public interface Expression {
  boolean interpret(String context);
}

public class TerminalExpression implements Expression {
  private String data;
  public TerminalExpression(String data) {
    this.data = data;
  }
  @Override
  public boolean interpret(String context) {
    return context.contains(data);
  }
}

public class AndExpression implements Expression {
  private Expresion expr1;
  private Expression expr2;
  
  public AndExpression(Expression expr1, Expression expr2) {
    this.expr1 = expr1;
    this.expr2 = expr2;
  }
  
  @Override
  public boolean interpret(String context) {
    return expr1.interpret(context) && expr2.interpret(context);
  }
}

public class Memento {
  priate String state;
  public Mento(String state) {
    this.state = state;
  }
  public String getState() {
    return state;
  }
}

public class Originator {
  private String state;
  
  public void setState(String state) {
    this.state = state;
  }
  
  public String getState() {
    return state;
  }
  
  public Memento saveStateToMemento() {
    return new Memento(state);
  }
  
  public void restoreStateFromMemento(Remento memento) {
    this.state = memento.getState();
  }
}

public class Caretaker {
  private List<Memento> mementoList = new ArrayList<>();
  
  public void addMemento(Memento memento) {
    mementoList.add(memento);
  }
  
  public Memento getMemento(int index) {
    return mementoList.get(index);
  }
}

public interface Mediator {
  void send(String message, Colleague colleague);
}

pubic class ConcreteMediator implements Mediator {
  private Colleague colleagueA;
  private Colleague colleagueB;
  
  public void setColleagueA(Colleague colleagueA) {
    this.colleagueA = colleagueA;
  }
  
  public void setColleagueB(Colleague colleagueB) {
    this.colleagueB = colleagueB;
  }
  
  @Override
  public void send(String message, Colleague colleague) {
    if (colleague == colleagueA) {
      colleagueB.receive(message);
    } else {
      colleagueA.receive(message);
    }
  }
}

public abstract class Colleague {
  protected Mediator mediator;
  
  public Colleague(Mediator mediator) {
    this.mediator = mediator;
  }
  
  public abstract void send(String message);
  public abstract void receive(String message);
}

public class ConcreteColleagueA extends Colleague {
  public ConcreteColleagueA(Mediator mediator) {
    super(mediator);
  }
  
  @Override
  public void send(String message) {
    mediator.send(message, this);
  }
  
  @Override
  public void receive(String message);
}
public class ConcreteColleagueB extends Colleague {
  public ConcreteColleagueB(Mediator mediator) {
    super(mediator);
  }
  
  @Override
  public void send(String message) {
    mediator.send(message, this);
  }
  
  @Override
  public void receive(String message);
}

// 观察者接口
interface Observer {
    void update(String message);
}

// 被观察者
class Subject {
    private List<Observer> observers = new ArrayList<>();

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

    public void notifyAllObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    public void changeState() {
        // 模拟状态变化
        notifyAllObservers("StateChanged");
    }
}

// Iterator 接口
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

// ConcreteIterator 实现
public class ListIterator<T> implements Iterator<T> {
    private T[] items;
    private int position = 0;

    public ListIterator(T[] items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        return position < items.length;
    }

    @Override
    public T next() {
        return items[position++];
    }
}

// Aggregate 接口
public interface Aggregate<T> {
    Iterator<T> iterator();
}

// ConcreteAggregate 实现
public class ListAggregate<T> implements Aggregate<T> {
    private T[] items;

    public ListAggregate(T[] items) {
        this.items = items;
    }

    @Override
    public Iterator<T> iterator() {
        return new ListIterator<>(items);
    }
}

// Client 使用示例
public class Client {
    public static void main(String[] args) {
        String[] data = {"A", "B", "C"};
        Aggregate<String> aggregate = new ListAggregate<>(data);
        Iterator<String> iterator = aggregate.iterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

// Command 接口
public interface Command {
  void execute();
}
// Reciver 类
public class Light {
  public void on();
  public void off();
}
// ConcreteCommand 实现
public class LightOnCommand implements Command {
  private Light light;
  public LightOnCommand(Light light) {
    this.light = light;
  }
  
  @Override
  public void execute() {
    light.on();
  }
}
// Invoker 类
public class RemoteControl {
  private Command command;
  public void setCommand(Command command) {
    this.command = command;
  }
  public void pressButton() {
    command.execute();
  }
}
// Client 使用
Light light = new Light();  // Receiver
Command command = new LightOnCommand(light);  // ConcreteCommand

RemoteControl remoteControl = new RemoteControl(); // Invoke
remoteControl.setCommand(command);
remoteControl.pressButton();  // 执行命令

public abstract class AbstractClass {
  public final void templateMethod() {  // 
    operation1();
    operation2();
    if (hook()) {   // 
      operation3();
    }
  }
  protected abstract void operation1(); // 
  protected abstract void operation2():
  protected abstract void operation3():
  
  protected boolean hook() {    // 
    return true;
  }
  
}

interface Subject {
  void request();
}
class RealSubject implements Subject {
  void request();
}
class Proxy implements Subject {
  private Subject realSubject;
  
  @Override
  public void request() {
    realSubject.request();
  }
}

class Proxy implements InvocationHandler {
  @Override
  pubilc Object invoke(Method method, Object[] args, Object proxy) {
    return method.invoke(target, args);
  }
}

class Proxy implements MethodInterceptor {
  @Override
  public Object intercept(Object obj, Method method, MethodProxy proxy) {
    return proxy.invokeSuper(obj, args);
  }
}

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(RealSubject.class);
enhancer.setCallback(new Proxy());
RealSubject proxy = enhancer.create();
proxy.request();

public interface Piece {
  void render(int x, int y);
}
public class WhitePiece implements Piece {
  @Override
  public void render(int x, int y); // 绘制白色棋子
}
public class BlackPiece implements Piece {
  @Override
  public void render(int x, int y); // 绘制黑色棋子
}

public class PieceFactory {
  private static final Map<String, Piece> pieces = new HashMap<>();
  public static Piece getPiece(String type) {
    if (!pieces.containsKey(type)) {
      switch (type) {
        case "white":
          pieces.put(type, new WhitePiece());  // 
          break;
        case "black":
          pieces.put(type, new BlackPiece());
          break;
        default:
          throw new IllegalArgumentException("Invalid piece type: " + type);
      }
    }
    return pieces.get(type);
  }
}

void main() {
  for (int i = 0; i < 100; i++) {
    var black = PieceFactory.getPiece("black");
    black.render(i%10, i/10);
    var white = PieceFactory.getPiece("white");
    white.render(i%10, i/10);
  }
}

public class HomeTheaterFacade {
  ...
  public void watchMovie(String movie) {
    System.out.println("Get ready to watch a movie...");
    lights.dim(10);
    projector.on();
    projector.setInput(dvdPlayer);
    amplifier.on();
    amplifier.setVolume(75);
    amplifier.setInput(dvdPlayer);
    dvdPlayer.on();
    dvdPlayer.play(movie);
  }

  public void endMovie() {
    System.out.println("Shutting movie theater down...");
    dvdPlayer.stop();
    dvdPlayer.off();
    amplifier.off();
    projector.off();
    lights.off();
  }
}

public interface AttendanceComponent {

  void punchIn();

  void punchOut();

  // 当日工时
  long getAttendance();
}

public class EmployeeLeaf implements AttendanceComponent {

  private long attendance = 0L;

  private OffsetDateTime punchInTime;
  private OffsetDateTime punchOutTime;

  @Override
  public void punchIn() {
    punchInTime = OffsetDateTime.now();
  }

  @Override
  public void punchOut() {
    punchOutTime = OffsetDateTime.now();
  }

  @Override
  public long getAttendance() {
    if (attendance == 0 && (punchOutTime != null && punchInTime != null)) {
      attendance = Duration.between(punchInTime, punchOutTime).toMinutes();
    }
    return attendance;
  }
}

public class DepartmentComposite implements AttendanceComponent {

  private final Set<AttendanceComponent> components = new HashSet<>();

  @Override
  public void punchIn() {
    for (AttendanceComponent component : components) {
      component.punchIn();
    }
  }

  @Override
  public void punchOut() {
    for (AttendanceComponent component : components) {
      component.punchOut();
    }
  }

  @Override
  public long getAttendance() {
    return components.stream().mapToLong(AttendanceComponent::getAttendance).sum();
  }

  public void add(AttendanceComponent component) {
    components.add(component);
  }

  public void remove(AttendanceComponent component) {
    components.remove(component);
  }
}

Equip levelUpWeapon = new RedGem(new BlueGem(new YellowGem(new GreenGem(new WwaponEquip()))));
// 创建剑士并穿戴该氪金武器
Swordman swordman = new Swordman();
swordman.equip(levelUpWeapon);

System.out.println(swordman);

Swordman{
  attack=12, 
  defense=0, 
  speed=5, 
  hp=5, 
  mp=10, 
  equipment=已装备有：🗡
}

public interface Equip {
  EquipType getType();
  int attack();
  int speed();
  int defense();
  int hp();
  int mp();
  String description();
}

public class WeaponEquip implements Equip {
  @Override
  public EquipType getType() {
    return EquipType.WEAPON;
  }
  @Override
  public int attack() {
    return 0;
  }
  @Override
  public int speed() {
    return 0;
  }
  @Override
  public int defense() {
    return 0;
  }
  @Override
  public int hp() {
    return 0;
  }
  @Override
  public int mp() {
    return 0;
  }
  @Override
  public String description() {
    return "🗡";
  }
}

public abstract class EquipDecorator implements Equip {
  protected Equip equip;
  protected EquipDecorator(Equip equip) {
    this.equip = equip;
  }
  @Override
  public int attack() {
    return equip.attack();
  }
  @Override
  public int speed() {
    return equip.speed();
  }
  @Override
  public int defense() {
    return equip.defense();
  }
  @Override
  public int hp() {
    return equip.hp();
  }
  @Override
  public int mp() {
    return equip.mp();
  }
  @Override
  public String description() {
    return equip.description();
  }
}

public class BlueGemEquipDecorator extends EquipDecorator {
  public BlueGemEquipDecorator(Equip equip) {
    super(equip);
  }
  @Override
  public int mp() {
    return equip.mp() + 10;
  }
}

public interface Color {
  void fill();
}
public class Red implements Color {
  @Override
  public void fill() {
    System.out.println("fillin red");
  }
}
public class Blue implements Color {
  @Override
  public void fill() {
    System.out.println("fillin blue");
  }
}
public class Green implements Color {
  @Override
  public void fill() {
    System.out.println("fillin green");
  }
}

public abstract class Shape {
  protected Color color;
  
  protected Shape(Color color) {
    this.color = color;
  }
  
  public abstract void draw();  // 
}

public class Circle extends Shape {
  public Circle(Color color) {
    super(color);
  }
  @Override
  public void draw() {
    System.out.println("Circle ->");
    color.fill();
  }
}
public class Rectangle extends Shape {
  public Rectangle(Color color) {
    super(color);
  }
  @Override
  public void draw() {
    System.out.println("Rectangle ->");
    color.fill();
  }
}
public class Square extends Shape {
  public Square(Color color) {
    super(color);
  }
  @Override
  public void draw() {
    System.out.println("Square ->");
    color.fill();
  }
}

public class Client {
  public static void main(String[] args) {
    Shape redCircle = new Circle(new Red());
    Shape blueRectangle = new Rectangle(new Blue());
    Shape greenSquare = new Square(new Green());
  }
}