工厂方法模式：

• 描述：通过工厂生产不同种类的产品，如汽车工厂生产轿车和卡车。
• 例子：一个披萨连锁店可以使用工厂方法模式生产不同口味的披萨。

javaCopy code
import lombok.*;

interface Pizza {
    String getDescription();
}

class CheesePizza implements Pizza {
    @Override
    public String getDescription() {
        return "Cheese Pizza";
    }
}

class PepperoniPizza implements Pizza {
    @Override
    public String getDescription() {
        return "Pepperoni Pizza";
    }
}

interface PizzaFactory {
    Pizza createPizza();
}

class CheesePizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new CheesePizza();
    }
}

class PepperoniPizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new PepperoniPizza();
    }
}

抽象工厂模式：

• 说明：提供一个接口用于创建一系列相关或依赖对象的家族，如工厂生产不同种类的食品。
• 例子：一个食品加工厂生产不同种类的薯片和饮料。

javaCopy code
import lombok.*;

interface Snack {
    String getDescription();
}

class PotatoChips implements Snack {
    @Override
    public String getDescription() {
        return "Potato Chips";
    }
}

class Beverage implements Snack {
    @Override
    public String getDescription() {
        return "Beverage";
    }
}

interface SnackFactory {
    Snack createSnack();
}

class PotatoChipsFactory implements SnackFactory {
    @Override
    public Snack createSnack() {
        return new PotatoChips();
    }
}

class BeverageFactory implements SnackFactory {
    @Override
    public Snack createSnack() {
        return new Beverage();
    }
}

单例模式：

• 说明：确保类只有一个实例。
• 例如：家庭中的电视机。

javaCopy code
import lombok.*;

@Singleton
public class Television {
    private static final Television instance = new Television();

    private Television() {}

    public static Television getInstance() {
        return instance;
    }
}

建造者模式：

• 说明：将一个复杂对象的构建与其表示分离。
• 例如：建造房屋时的建筑计划。

javaCopy code
import lombok.*;

@Getter
@Setter
@Builder
public class House {
    private String foundation;
    private String structure;
    private String roof;
    private String interior;
}

// 使用示例
House house = House.builder()
.foundation("Concrete")
.structure("Brick")
.roof("Tiles")
.interior("Wood")
.build();

原型模式：

• 说明：通过复制现有对象来创建新对象。
• 例如：复制一份文件。

javaCopy code
import lombok.*;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class File implements Cloneable {
    private String name;
    private String type;
    private long size;

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

// 使用示例
File originalFile = new File("document", "txt", 1024);
File copiedFile = originalFile.clone();

适配器模式：

• 说明：将一个类的接口转换成客户希望的另一个接口。
• 例如：电源插头转换器。

javaCopy code
import lombok.*;

interface MediaPlayer {
    void play(String mediaType, String fileName);
}

class AudioPlayer implements MediaPlayer {
    @Override
    public void play(String mediaType, String fileName) {
        if (mediaType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        } else if (mediaType.equalsIgnoreCase("vlc") || mediaType.equalsIgnoreCase("mp4")) {
            MediaAdapter mediaAdapter = new MediaAdapter(mediaType);
            mediaAdapter.play(mediaType, fileName);
        } else {
            System.out.println("Invalid media type: " + mediaType);
        }
    }
}

class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMediaPlayer;

    MediaAdapter(String mediaType) {
        if (mediaType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer = new VlcPlayer();
        } else if (mediaType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String mediaType, String fileName) {
        if (mediaType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer.playVlc(fileName);
        } else if (mediaType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer.playMp4(fileName);
        }
    }
}

interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}

class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // Do nothing
    }
}

class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        // Do nothing
    }

    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file: " + fileName);
    }
}

桥接模式：

• 说明：将抽象部分与实现部分分离。
• 例如：不同品牌的手机与不同操作系统的软件。

javaCopy code
import lombok.*;

interface Software {
    void run();
}

abstract class Phone {
    protected Software software;

    public Phone(Software software) {
        this.software = software;
    }

    abstract void runSoftware();
}

class IPhone extends Phone {
    public IPhone(Software software) {
        super(software);
    }

    @Override
    void runSoftware() {
        System.out.print("IPhone running ");
        software.run();
    }
}

class AndroidPhone extends Phone {
    public AndroidPhone(Software software) {
        super(software);
    }

    @Override
    void runSoftware() {
        System.out.print("Android Phone running ");
        software.run();
    }
}

class Game implements Software {
    @Override
    public void run() {
        System.out.println("game.");
    }
}

class MusicPlayer implements Software {
    @Override
    public void run() {
        System.out.println("music player.");
    }
}

// 使用示例
Phone iPhone = new IPhone(new Game());
iPhone.runSoftware();

Phone androidPhone = new AndroidPhone(new MusicPlayer());
androidPhone.runSoftware();

组合模式：

• 说明：将对象组合成树形结构以表示“部分-整体”的层次结构。
• 例如：文件系统中的目录和文件。

javaCopy code
import lombok.*;

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

interface FileSystemComponent {
    void display();
}

class FileLeaf implements FileSystemComponent {
    private String name;

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

    @Override
    public void display() {
        System.out.println("File: " + name);
    }
}

class DirectoryComposite implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> components;

    public DirectoryComposite(String name) {
        this.name = name;
        components = new ArrayList<>();
    }

    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    @Override
    public void display() {
        System.out.println("Directory: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }
}

// 使用示例
FileLeaf file1 = new FileLeaf("file1.txt");
FileLeaf file2 = new FileLeaf("file2.txt");
DirectoryComposite directory1 = new DirectoryComposite("Directory 1");
directory1.addComponent(file1);
directory1.addComponent(file2);

FileLeaf file3 = new FileLeaf("file3.txt");
DirectoryComposite directory2 = new DirectoryComposite("Directory 2");
directory2.addComponent(file3);

DirectoryComposite rootDirectory = new DirectoryComposite("Root Directory");
rootDirectory.addComponent(directory1);
rootDirectory.addComponent(directory2);

rootDirectory.display();

装饰器模式：

• 说明：动态地给对象添加额外的职责。
• 例如：在咖啡中添加奶泡或糖浆。

javaCopy code
import lombok.*;

interface Coffee {
    String getDescription();
    double getCost();
}

class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }

    @Override
    public double getCost() {
        return 1.0;
    }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription();
    }

    @Override
    public double getCost() {
        return coffee.getCost();
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 0.5;
    }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Sugar";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 0.3;
    }
}

// 使用示例
Coffee coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);
coffee = new SugarDecorator(coffee);
System.out.println("Description: " + coffee.getDescription());
System.out.println("Cost: $" + coffee.getCost());

外观模式：

• 说明：为复杂系统提供简化接口。
• 例如：电脑开机按钮。

javaCopy code
import lombok.*;

class CPU {
    public void start() {
        System.out.println("CPU is starting...");
    }

    public void shutdown() {
        System.out.println("CPU is shutting down...");
    }
}

class Memory {
    public void start() {
        System.out.println("Memory is starting...");
    }

    public void shutdown() {
        System.out.println("Memory is shutting down...");
    }
}

class Disk {
    public void start() {
        System.out.println("Disk is starting...");
    }

    public void shutdown() {
        System.out.println("Disk is shutting down...");
    }
}

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.start();
        disk.start();
    }

    public void shutdown() {
        disk.shutdown();
        memory.shutdown();
        cpu.shutdown();
    }
}

// 使用示例
ComputerFacade computer = new ComputerFacade();
computer.start();
System.out.println("-------- Computer is running --------");
computer.shutdown();

代理模式：

• 说明：为其他对象提供一种代理以控制对这个对象的访问。
• 例如：网络代理服务器。

javaCopy code
import lombok.*;

interface Internet {
    void connectTo(String serverHost);
}

class RealInternet implements Internet {
    @Override
    public void connectTo(String serverHost) {
        System.out.println("Connecting to " + serverHost);
    }
}

class ProxyInternet implements Internet {
    private RealInternet realInternet;

    public ProxyInternet() {
        this.realInternet = new RealInternet();
    }

    @Override
    public void connectTo(String serverHost) {
        if (serverHost.contains("restricted")) {
            System.out.println("Access Denied. Cannot connect to restricted sites.");
        } else {
            realInternet.connectTo(serverHost);
        }
    }
}

// 使用示例
Internet internet = new ProxyInternet();
internet.connectTo("example.com");
internet.connectTo("restricted-site.com");

责任链模式：

• 说明：为解除发送者和接收者之间的耦合，而不是发送请求的对象直接对接收请求的对象进行调用。
• 例如：工作流中的审批链。

javaCopy code
import lombok.*;

abstract class Approver {
    protected Approver successor;

    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }

    public abstract void processRequest(PurchaseRequest request);
}

class PurchaseRequest {
    private double amount;

    public PurchaseRequest(double amount) {
        this.amount = amount;
    }

    public double getAmount() {
        return amount;
    }
}

class Manager extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 1000) {
            System.out.println("Manager approved the request.");
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

class Director extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 5000) {
            System.out.println("Director approved the request.");
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

class CEO extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 10000) {
            System.out.println("CEO approved the request.");
        } else {
            System.out.println("Request needs board meeting discussion.");
        }
    }
}

// 使用示例
Approver manager = new Manager();
Approver director = new Director();
Approver ceo = new CEO();

manager.setSuccessor(director);
director.setSuccessor(ceo);

PurchaseRequest request1 = new PurchaseRequest(800);
manager.processRequest(request1);

PurchaseRequest request2 = new PurchaseRequest(5000);
manager.processRequest(request2);

PurchaseRequest request3 = new PurchaseRequest(15000);
manager.processRequest(request3);

命令模式：

• 说明：将请求封装成对象，使得可以用不同的请求对客户进行参数化。
• 例如：遥控器控制电器。

javaCopy code
import lombok.*;

interface Command {
    void execute();
}

class Light {
    public void turnOn() {
        System.out.println("Light is on.");
    }

    public void turnOff() {
        System.out.println("Light is off.");
    }
}

class TurnOnCommand implements Command {
    private Light light;

    public TurnOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

class TurnOffCommand implements Command {
    private Light light;

    public TurnOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}

class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

// 使用示例
Light light = new Light();
Command turnOnCommand = new TurnOnCommand(light);
Command turnOffCommand = new TurnOffCommand(light);

RemoteControl remoteControl = new RemoteControl();

remoteControl.setCommand(turnOnCommand);
remoteControl.pressButton();

remoteControl.setCommand(turnOffCommand);
remoteControl.pressButton();

解释器模式：

• 说明：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
• 例如：正则表达式解析器。

javaCopy code
import lombok.*;

interface Expression {
    boolean interpret(String context);
}

class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        return context.contains(data);
    }
}

class OrExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public OrExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public boolean interpret(String context) {
        return expression1.interpret(context) || expression2.interpret(context);
    }
}

class AndExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public AndExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public boolean interpret(String context) {
        return expression1.interpret(context) && expression2.interpret(context);
    }
}

// 使用示例
Expression person1 = new TerminalExpression("Alice");
Expression person2 = new TerminalExpression("Bob");

Expression isSingle = new OrExpression(person1, person2);
Expression isMarried = new AndExpression(person1, person2);

System.out.println("Is Alice single? " + isSingle.interpret("Alice"));
System.out.println("Is Alice married to Bob? " + isMarried.interpret("Alice Bob"));

迭代器模式：

• 说明：提供一种方法顺序访问一个聚合对象中各个元素，而不暴露其内部的表示。
• 例如：遍历一个列表。

javaCopy code
import lombok.*;

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

interface Container {
    Iterator getIterator();
}

class NameRepository implements Container {
    private String[] names = {"Alice", "Bob", "Charlie"};

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {
        private int index;

        @Override
        public boolean hasNext() {
            return index < names.length;
        }

        @Override
        public Object next() {
            if (this.hasNext()) {
                return names[index++];
            }
            return null;
        }
    }
}

// 使用示例
NameRepository nameRepository = new NameRepository();
Iterator iterator = nameRepository.getIterator();

while (iterator.hasNext()) {
    System.out.println