设计模式：抽象工厂、备忘录、组合模式

1.抽象工厂模式（Abstract Factory Pattern）

目的： 抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象家族的一个或多个系列的产品，而无需指定具体产品类。这样可以使客户端独立于具体产品的创建过程，同时使得易于更换整体产品族。

结构：

• AbstractFactory（抽象工厂）：声明创建一组相关或相互依赖对象的接口，让客户端可以使用这些对象而无需指定它们的具体类型。
• ConcreteFactory（具体工厂）：实现抽象工厂接口，生成一组具体产品对象。
• Product（抽象产品）：定义产品的接口，它是所有具体产品必须实现的接口。
• ConcreteProduct（具体产品）：实现了抽象产品接口，是实际生产出来的产品。

示例场景： 操作系统界面元素工厂，可以创建不同风格（如Windows、Mac OS、Linux）的按钮、窗口等界面组件。

// 抽象产品接口
interface Color {
    void fill();
}

interface Shape {
    void draw();
}

// 具体产品
class RedColor implements Color {
    @Override
    public void fill() {
        System.out.println("填充红色");
    }
}

class BlueColor implements Color {
    @Override
    public void fill() {
    System.out.println("填充蓝色");
    }

// 形状
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制正方形");
    }

// 抽象工厂
interface ColorFactory {
    Color getColor();
}

interface ShapeFactory {
    Shape getShape();
}

// 具体工厂
class RedColorFactory implements ColorFactory {
    @Override
    public Color getColor() {
        return new RedColor();
    }
}

class BlueColorFactory implements ColorFactory {
    @Override
    public Color getColor() {
        return new BlueColor();
    }

class CircleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Circle();
    }
}

class SquareFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Square();
    }

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ColorFactory redColorFactory = new RedColorFactory();
        ShapeFactory circleFactory = new CircleFactory();

        Color color = redColorFactory.getColor();
        Shape shape = circleFactory.getShape();

        color.fill();
        shape.draw();
    }
}

2.备忘录模式（Memento Pattern）

目的： 备忘录模式是一种行为设计模式，它提供了一种在不破坏封装性的前提下，捕获并外部化对象状态的方法，以便在稍后时刻恢复对象状态。

结构：

• Originator（发起人）：创建一个备忘录，可以利用备忘录恢复到先前的状态。通常包含一些重要的业务数据。
• Memento（备忘录）：存储发起人的内部状态。为了保护发起人的隐私，备忘录通常只提供有限的接口供发起人访问。
• Caretaker（管理者）：负责保存和恢复发起人的状态，但不能对备忘录的内容进行任何操作，只能将其传递给发起人。

示例场景： 文本编辑器的撤销功能，每次编辑操作后，编辑器都会创建一个包含当前文档内容的备忘录，之后可以使用备忘录恢复到之前的状态。

// 原始类（Originator）
class GameSnapshot {
    private int score;
    private int level;
    
    public GameSnapshot(int score, int level) {
        this.score = score;
        this.level = level;
    }

    public int getScore() {
        return score;
    }

    public int getLevel() {
        return level;
    }

    // 创建备忘录
    public Memento saveGame() {
        return new Memento(score, level);
    }

    // 恢复游戏状态
    public void restoreGame(Memento memento) {
        this.score = memento.getScore();
        this.level = memento.getLevel();
    }
}

// 备忘录（Memento）
class Memento {
    private final int score;
    private final int level;

    public Memento(int score, int level) {
        this.score = score;
        this.level = level;
    }

    public int getScore() {
        return score;
    }

    public int getLevel() {
        return level;
    }
}

// 管理者（Caretaker）
public class GameManager {
    private Memento savedMemento;

    public void saveGame(GameSnapshot game) {
        savedMemento = game.saveGame();
    }

    public void restoreGame(GameSnapshot game) {
        if (savedMemento != null) {
            game.restoreGame(savedMemento);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        GameSnapshot game = new GameSnapshot(100, 5);
        GameManager manager = new GameManager();

        // 保存游戏状态
        manager.saveGame(game);

        // 改变游戏状态
        game.setLevel(6);
        game.setScore(150);

        // 恢复到之前保存的状态
        manager.restoreGame(game);
    }
}

3.组合模式（Composite Pattern）

目的： 组合模式是一种结构型设计模式，它允许你将对象结构看作一棵树形结构，在这棵树中，个别对象和组合对象对客户来说具有相同的意义。这样，客户可以一致地处理单个对象和对象组合。

结构：

• Component（组件）：定义所有对象共有的接口，既可以代表叶子节点（即没有子节点的对象），也可以代表容器节点（即有子节点的对象）。
• Leaf（叶子节点）：实现 Component 接口，代表没有子节点的对象，它的操作通常很简单，不会涉及到递归或子对象。
• Composite（容器节点）：同样实现 Component 接口，但它还包含了额外的方法来管理它的子组件。它可以用来存储和遍历子组件，并调用它们的方法。

示例场景： 文件系统目录结构，目录（Composite）可以包含子目录和文件（Leaf），并且可以对它们进行统一的操作，如添加、删除、显示名称等。

// 抽象组件
abstract class GraphicComponent {
    protected String name;

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

    public abstract void add(GraphicComponent component);
    public abstract void remove(GraphicComponent component);
    public abstract void draw();

    public String getName() {
        return name;
    }
}

// 叶子组件
class Leaf extends GraphicComponent {
    public Leaf(String name) {
        super(name);
    }

    @Override
    public void add(GraphicComponent component) {
        throw new UnsupportedOperationException("Cannot add to a leaf node.");
    }

    @Override
    public void remove(GraphicComponent component) {
        throw new UnsupportedOperationException("Cannot remove from a leaf node.");
    }

    @Override
    public void draw() {
        System.out.println("Drawing " + name);
    }
}

// 容器组件
class Composite extends GraphicComponent {
    private List<GraphicComponent> children = new ArrayList<>();

    public Composite(String name) {
        super(name);
    }

    @Override
    public void add(GraphicComponent component) {
        children.add(component);
    }

    @Override
    public void remove(GraphicComponent component) {
        children.remove(component);
    }

    @Override
    public void draw() {
        System.out.println("Drawing " + name);
        for (GraphicComponent child : children) {
            child.draw();
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Composite graphics = new Composite("Graphics");
        graphics.add(new Leaf("Rectangle"));
        graphics.add(new Leaf("Circle"));

        Composite moreGraphics = new Composite("More Graphics");
        moreGraphics.add(new Leaf("Triangle"));
        moreGraphics.add(new Leaf("Line"));

        graphics.add(moreGraphics);

        graphics.draw();
    }
}