// 不好的设计 - 一个类承担多个职责
class User {
    public void saveUser() { /* 保存用户 */ }
    public void sendEmail() { /* 发送邮件 */ }
    public void calculateSalary() { /* 计算薪资 */ }
}

// 好的设计 - 分离职责
class UserRepository {
    public void saveUser() { /* 保存用户 */ }
}
class EmailService {
    public void sendEmail() { /* 发送邮件 */ }
}
class SalaryCalculator {
    public void calculateSalary() { /* 计算薪资 */ }
}

// 不好的设计 - 添加新支付方式需要修改原有代码
class PaymentProcessor {
    public void processPayment(String type) {
        if (type.equals("ALIPAY")) {
            // 支付宝支付
        } else if (type.equals("WECHAT")) {
            // 微信支付
        }
        // 新增支付方式需要修改这里
    }
}

// 好的设计 - 对扩展开放
interface Payment {
    void pay();
}
class AliPay implements Payment {
    public void pay() { /* 支付宝 */ }
}
class WeChatPay implements Payment {
    public void pay() { /* 微信 */ }
}
class PaymentProcessor {
    public void processPayment(Payment payment) {
        payment.pay();
    }
}

// 不好的设计 - 正方形继承矩形，违反LSP
class Rectangle {
    protected int width, height;
    public void setWidth(int w) { width = w; }
    public void setHeight(int h) { height = h; }
    public int getArea() { return width * height; }
}
class Square extends Rectangle {
    @Override
    public void setWidth(int w) {
        super.setWidth(w);
        super.setHeight(w);
    }
    @Override
    public void setHeight(int h) {
        super.setWidth(h);
        super.setHeight(h);
    }
}

// 好的设计 - 提取共同基类
abstract class Shape {
    public abstract int getArea();
}
class Rectangle extends Shape {
    private int width, height;
    public void setWidth(int w) { width = w; }
    public void setHeight(int h) { height = h; }
    public int getArea() { return width * height; }
}
class Square extends Shape {
    private int side;
    public void setSide(int s) { side = s; }
    public int getArea() { return side * side; }
}

// 不好的设计 - 高层依赖低层
class OrderService {
    private MySQLOrderDao dao = new MySQLOrderDao();
    public void saveOrder() { dao.save(); }
}
class MySQLOrderDao {
    public void save() { /* MySQL保存 */ }
}

// 好的设计 - 依赖抽象
interface OrderDao {
    void save();
}
class MySQLOrderDao implements OrderDao {
    public void save() { /* MySQL保存 */ }
}
class OrderService {
    private OrderDao dao;
    public OrderService(OrderDao dao) { this.dao = dao; }
    public void saveOrder() { dao.save(); }
}

// 不好的设计 - 接口过于臃肿
interface Animal {
    void fly();
    void swim();
    void run();
}
class Dog implements Animal {
    public void fly() { /* 狗不会飞，空实现 */ }
    public void swim() { /* 狗会游泳 */ }
    public void run() { /* 狗会跑 */ }
}

// 好的设计 - 接口分离
interface Flyable { void fly(); }
interface Swimmable { void swim(); }
interface Runnable { void run(); }
class Dog implements Swimmable, Runnable {
    public void swim() { /* 游泳 */ }
    public void run() { /* 跑步 */ }
}

// 不好的设计 - 继承复用
class Car extends Engine { }

// 好的设计 - 组合复用
class Engine {
    public void start() { }
}
class Car {
    private Engine engine;
    public Car(Engine engine) { this.engine = engine; }
    public void start() { engine.start(); }
}

// 不好的设计
class Customer {
    public Wallet getWallet() { return wallet; }
}
class Wallet {
    public void reduceMoney(int amount) { /* 减少金额 */ }
}
class Store {
    public void charge(Customer customer, int amount) {
        customer.getWallet().reduceMoney(amount); // 直接操作钱包
    }
}

// 好的设计
class Customer {
    public void pay(int amount) { wallet.reduceMoney(amount); }
}
class Store {
    public void charge(Customer customer, int amount) {
        customer.pay(amount); // 只与Customer通信
    }
}

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public class Singleton {
    private static Singleton instance;

    private Singleton() { }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() { }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private Singleton() { }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // 业务方法
    }
}

// 使用
Singleton.INSTANCE.doSomething();

interface Product {
    void use();
}
class ProductA implements Product {
    public void use() { System.out.println("使用产品A"); }
}
class ProductB implements Product {
    public void use() { System.out.println("使用产品B"); }
}
class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A": return new ProductA();
            case "B": return new ProductB();
            default: return null;
        }
    }
}
// 使用
Product product = SimpleFactory.createProduct("A");
product.use();

interface Product {
    void use();
}
interface Factory {
    Product createProduct();
}
class ProductA implements Product {
    public void use() { System.out.println("使用产品A"); }
}
class FactoryA implements Factory {
    public Product createProduct() { return new ProductA(); }
}
class ProductB implements Product {
    public void use() { System.out.println("使用产品B"); }
}
class FactoryB implements Factory {
    public Product createProduct() { return new ProductB(); }
}
// 使用
Factory factory = new FactoryA();
Product product = factory.createProduct();
product.use();

// 产品族1
interface Button { void click(); }
interface TextField { void input(); }

class WindowsButton implements Button {
    public void click() { System.out.println("Windows按钮"); }
}
class WindowsTextField implements TextField {
    public void input() { System.out.println("Windows输入框"); }
}
class MacButton implements Button {
    public void click() { System.out.println("Mac按钮"); }
}
class MacTextField implements TextField {
    public void input() { System.out.println("Mac输入框"); }
}

// 抽象工厂
interface GUIFactory {
    Button createButton();
    TextField createTextField();
}
class WindowsFactory implements GUIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createTextField() { return new WindowsTextField(); }
}
class MacFactory implements GUIFactory {
    public Button createButton() { return new MacButton(); }
    public TextField createTextField() { return new MacTextField(); }
}

// 使用
GUIFactory factory = new WindowsFactory();
Button button = factory.createButton();
TextField textField = factory.createTextField();
button.click();
textField.input();

// 产品
class Computer {
    private String cpu;
    private String ram;
    private String storage;
    private String gpu;

    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
        this.gpu = builder.gpu;
    }

    public static class Builder {
        private String cpu;
        private String ram;
        private String storage;
        private String gpu;

        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }
        public Builder ram(String ram) {
            this.ram = ram;
            return this;
        }
        public Builder storage(String storage) {
            this.storage = storage;
            return this;
        }
        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }
        public Computer build() {
            return new Computer(this);
        }
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", storage='" + storage + '\'' +
                ", gpu='" + gpu + '\'' +
                '}';
    }
}

// 使用
Computer computer = new Computer.Builder()
        .cpu("i9")
        .ram("32GB")
        .storage("1TB SSD")
        .gpu("RTX4090")
        .build();
System.out.println(computer);

// 浅拷贝
class Prototype implements Cloneable {
    private String name;
    private List<String> list;

    public Prototype(String name, List<String> list) {
        this.name = name;
        this.list = list;
    }

    @Override
    public Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone();
    }

    // 深拷贝
    public Prototype deepClone() {
        Prototype copy = new Prototype(this.name, new ArrayList<>(this.list));
        return copy;
    }
}

// 目标接口
interface Target {
    void request();
}

// 被适配者
class Adaptee {
    public void specificRequest() {
        System.out.println("特殊请求");
    }
}

// 适配器
class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    public void request() {
        adaptee.specificRequest();
    }
}

// 使用
Target target = new Adapter(new Adaptee());
target.request();

// 抽象组件
interface Coffee {
    String getDescription();
    double getCost();
}

// 具体组件
class SimpleCoffee implements Coffee {
    public String getDescription() { return "简单咖啡"; }
    public double getCost() { return 10.0; }
}

// 装饰器抽象类
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    public CoffeeDecorator(Coffee coffee) { this.coffee = coffee; }
}

// 具体装饰器
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) { super(coffee); }
    public String getDescription() { return coffee.getDescription() + ", 加牛奶"; }
    public double getCost() { return coffee.getCost() + 2.0; }
}
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) { super(coffee); }
    public String getDescription() { return coffee.getDescription() + ", 加糖"; }
    public double getCost() { return coffee.getCost() + 1.0; }
}

// 使用
Coffee coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);
coffee = new SugarDecorator(coffee);
System.out.println(coffee.getDescription() + " = " + coffee.getCost());

// 主题接口
interface Image {
    void display();
}

// 真实主题
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("加载 " + fileName);
    }

    public void display() {
        System.out.println("显示 " + fileName);
    }
}

// 代理
class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

// 使用
Image image = new ProxyImage("test.jpg");
image.display();  // 第一次加载并显示
image.display();  // 直接显示

// 子系统
class CPU {
    public void start() { System.out.println("CPU启动"); }
}
class Memory {
    public void load() { System.out.println("内存加载"); }
}
class Disk {
    public void read() { System.out.println("磁盘读取"); }
}

// 外观类
class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private Disk disk;

    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.disk = new Disk();
    }

    public void start() {
        cpu.start();
        memory.load();
        disk.read();
        System.out.println("电脑启动完成");
    }
}

// 使用
ComputerFacade computer = new ComputerFacade();
computer.start();

// 实现部分接口
interface Color {
    String getColor();
}
class Red implements Color {
    public String getColor() { return "红色"; }
}
class Blue implements Color {
    public String getColor() { return "蓝色"; }
}

// 抽象部分
abstract class Shape {
    protected Color color;
    public Shape(Color color) { this.color = color; }
    public abstract void draw();
}
class Circle extends Shape {
    public Circle(Color color) { super(color); }
    public void draw() {
        System.out.println("画一个" + color.getColor() + "圆");
    }
}
class Square extends Shape {
    public Square(Color color) { super(color); }
    public void draw() {
        System.out.println("画一个" + color.getColor() + "正方形");
    }
}

// 使用
Color red = new Red();
Shape redCircle = new Circle(red);
redCircle.draw();

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

abstract class Component {
    protected String name;
    public Component(String name) { this.name = name; }
    public abstract void add(Component component);
    public abstract void remove(Component component);
    public abstract void display(int depth);
}

class Leaf extends Component {
    public Leaf(String name) { super(name); }
    public void add(Component component) {
        System.out.println("叶子节点不能添加");
    }
    public void remove(Component component) {
        System.out.println("叶子节点不能删除");
    }
    public void display(int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("-");
        }
        System.out.println(name);
    }
}

class Composite extends Component {
    private List<Component> children = new ArrayList<>();
    public Composite(String name) { super(name); }
    public void add(Component component) {
        children.add(component);
    }
    public void remove(Component component) {
        children.remove(component);
    }
    public void display(int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("-");
        }
        System.out.println(name);
        for (Component component : children) {
            component.display(depth + 2);
        }
    }
}

// 使用
Composite root = new Composite("根目录");
root.add(new Leaf("文件1.txt"));
Composite dir1 = new Composite("文件夹1");
dir1.add(new Leaf("文件2.txt"));
root.add(dir1);
root.display(0);

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

class AliPayStrategy implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount);
    }
}
class WeChatPayStrategy implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("微信支付: " + amount);
    }
}
class CreditCardStrategy implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("信用卡支付: " + amount);
    }
}

// 上下文
class PaymentContext {
    private PaymentStrategy strategy;
    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    public void executePayment(double amount) {
        strategy.pay(amount);
    }
}

// 使用
PaymentContext context = new PaymentContext(new AliPayStrategy());
context.executePayment(100.0);

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

// 主题
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

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

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

// 具体观察者
class ConcreteObserver implements Observer {
    private String name;
    public ConcreteObserver(String name) { this.name = name; }
    public void update(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

// 使用
Subject subject = new ConcreteSubject();
subject.attach(new ConcreteObserver("观察者1"));
subject.attach(new ConcreteObserver("观察者2"));
((ConcreteSubject) subject).setState("状态更新");

// 抽象类
abstract class BankTemplate {
    // 模板方法
    public final void processBusiness() {
        takeNumber();
        transact();
        evaluate();
    }

    // 具体方法 - 取号
    protected void takeNumber() {
        System.out.println("取号排队");
    }

    // 抽象方法 - 办理具体业务，子类实现
    protected abstract void transact();

    // 具体方法 - 评价
    protected void evaluate() {
        System.out.println("服务评价");
    }
}

// 具体子类
class DepositBusiness extends BankTemplate {
    protected void transact() {
        System.out.println("办理存款业务");
    }
}
class WithdrawBusiness extends BankTemplate {
    protected void transact() {
        System.out.println("办理取款业务");
    }
}

// 使用
BankTemplate business = new DepositBusiness();
business.processBusiness();

// 处理者
abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(int request);
}

class ConcreteHandlerA extends Handler {
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("HandlerA处理请求: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}
class ConcreteHandlerB extends Handler {
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("HandlerB处理请求: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 使用
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
handlerA.setNextHandler(handlerB);
handlerA.handleRequest(5);
handlerA.handleRequest(15);

// 命令接口
interface Command {
    void execute();
    void undo();
}

// 接收者
class Light {
    public void on() { System.out.println("灯打开了"); }
    public void off() { System.out.println("灯关上了"); }
}

// 具体命令
class LightOnCommand implements Command {
    private Light light;
    public LightOnCommand(Light light) { this.light = light; }
    public void execute() { light.on(); }
    public void undo() { light.off(); }
}
class LightOffCommand implements Command {
    private Light light;
    public LightOffCommand(Light light) { this.light = light; }
    public void execute() { light.off(); }
    public void undo() { light.on(); }
}

// 调用者
class RemoteControl {
    private Command command;
    public void setCommand(Command command) { this.command = command; }
    public void pressButton() { command.execute(); }
    public void pressUndo() { command.undo(); }
}

// 使用
Light light = new Light();
Command onCommand = new LightOnCommand(light);
RemoteControl remote = new RemoteControl();
remote.setCommand(onCommand);
remote.pressButton();
remote.pressUndo();

// 状态接口
interface State {
    void handle(Context context);
}

// 上下文
class Context {
    private State state;
    public void setState(State state) {
        this.state = state;
    }
    public void request() {
        state.handle(this);
    }
}

// 具体状态
class ConcreteStateA implements State {
    public void handle(Context context) {
        System.out.println("当前状态是A，切换到B");
        context.setState(new ConcreteStateB());
    }
}
class ConcreteStateB implements State {
    public void handle(Context context) {
        System.out.println("当前状态是B，切换到A");
        context.setState(new ConcreteStateA());
    }
}

// 使用
Context context = new Context();
context.setState(new ConcreteStateA());
context.request();
context.request();

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

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

// 聚合接口
interface Aggregate<T> {
    Iterator<T> createIterator();
}

// 具体聚合
class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();
    public void add(T item) { items.add(item); }
    public T get(int index) { return items.get(index); }
    public int size() { return items.size(); }
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(this);
    }
}

// 具体迭代器
class ConcreteIterator<T> implements Iterator<T> {
    private ConcreteAggregate<T> aggregate;
    private int index = 0;
    public ConcreteIterator(ConcreteAggregate<T> aggregate) {
        this.aggregate = aggregate;
    }
    public boolean hasNext() {
        return index < aggregate.size();
    }
    public T next() {
        return aggregate.get(index++);
    }
}

// 使用
ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
aggregate.add("A");
aggregate.add("B");
aggregate.add("C");
Iterator<String> iterator = aggregate.createIterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}