使用命令模式设计一个图形绘制系统，该系统可以绘制矩形、椭圆、三角形等图形，恢复和撤销功能。绘制类图并编程实现。java实现

以下是使用命令模式设计的图形绘制系统的类图：


在该类图中，有以下几个角色：

- `Command`：定义了一个执行操作的接口，其中包括`execute()`方法。
- `DrawCommand`：继承自`Command`，具体实现了绘制图形的操作。其中，包含了一个`receiver`对象，即`Graphics`对象，用于执行具体的绘制操作。
- `Invoker`：负责调用命令进行执行的对象。
- `Receiver`：接收并执行具体命令的对象。在本例中，即为绘制图形的对象`Graphics`。
- `Client`：客户端，用于创建具体的命令和接收操作请求。

以下是基于上述类图的Java代码实现：

// Receiver
public class Graphics {
    public void drawRectangle(int x, int y, int width, int height) {
        System.out.println("绘制矩形");
    }

    public void drawEllipse(int x, int y, int width, int height) {
        System.out.println("绘制椭圆");
    }

    public void drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3) {
        System.out.println("绘制三角形");
    }
}

// Command
public interface Command {
    void execute();
}

// DrawCommand
public class DrawCommand implements Command {
    private Graphics receiver;
    private String type;
    private int[] params;

    public DrawCommand(Graphics receiver, String type, int[] params) {
        this.receiver = receiver;
        this.type = type;
        this.params = params;
    }

    public void execute() {
        if (type.equals("rectangle")) {
            receiver.drawRectangle(params[0], params[1], params[2], params[3]);
        } else if (type.equals("ellipse")) {
            receiver.drawEllipse(params[0], params[1], params[2], params[3]);
        } else if (type.equals("triangle")) {
            receiver.drawTriangle(params[0], params[1], params[2], params[3], params[4], params[5]);
        }
    }
}

// Invoker
public class Invoker {
    private Stack<Command> undoStack;
    private Stack<Command> redoStack;

    public Invoker() {
        undoStack = new Stack<Command>();
        redoStack = new Stack<Command>();
    }

    public void executeCommand(Command command) {
        command.execute();
        undoStack.push(command);
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            Command command = undoStack.pop();
            command.execute();
            redoStack.push(command);
        }
    }

    public void redo() {
        if (!redoStack.isEmpty()) {
            Command command = redoStack.pop();
            command.execute();
            undoStack.push(command);
        }
    }
}

// Client
public class Client {
    public static void main(String[] args) {
        Graphics graphics = new Graphics();
        Invoker invoker = new Invoker();

        // 绘制矩形
        int[] params1 = {10, 10, 100, 50};
        Command command1 = new DrawCommand(graphics, "rectangle", params1);
        invoker.executeCommand(command1);

        // 绘制椭圆
        int[] params2 = {50, 100, 80, 40};
        Command command2 = new DrawCommand(graphics, "ellipse", params2);
        invoker.executeCommand(command2);

        // 绘制三角形
        int[] params3 = {100, 200, 150, 250, 200, 200};
        Command command3 = new DrawCommand(graphics, "triangle", params3);
        invoker.executeCommand(command3);

        // 撤销操作
        invoker.undo();

        // 重做操作
        invoker.redo();
    }
}

在上述代码中，我们定义了一个`Graphics`类作为接收者，并且实现了三个具体的绘制方法。同时，我们定义了一个`Command`接口，包括了一个`execute()`方法，以及一个`DrawCommand`类，实现了对应每个具体绘制操作的命令。`Invoker`类作为命令的调用者，可以执行、撤销和重做命令，其中使用了`Stack`来维护撤销和重做栈。最后，我们在客户端代码中创建了具体的命令并执行。