制作一个简易的画图程序，要求有七种颜色，有矩形，直线，椭圆

好的，我可以为您提供一个简易的画图程序的伪代码：

1. 初始化画布，设置画布大小和背景色
2. 定义颜色数组，包含七种颜色
3. 定义绘制形状的函数：
    a. 矩形函数：需要输入起点坐标和终点坐标，绘制矩形
    b. 直线函数：需要输入起点坐标和终点坐标，绘制直线
    c. 椭圆函数：需要输入起点坐标和终点坐标，绘制椭圆
4. 定义选择颜色的函数：需要输入颜色的索引，将当前画笔的颜色设置为选择的颜色
5. 进入主循环：
    a. 等待用户输入
    b. 如果用户输入是绘制形状，则调用相应的绘制函数
    c. 如果用户输入是选择颜色，则调用选择颜色的函数
    d. 如果用户输入是退出，则退出循环

上述伪代码只是一个简单的框架，具体的实现可以根据您所使用的编程语言和图形库进行相应的调整。

相关问题

用Java制作一个简易的画图程序，要求有七种颜色，有矩形，直线，椭圆

好的，以下是一个简单的Java画图程序，包含七种颜色，可以绘制矩形、直线、椭圆。

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class SimplePaint extends JFrame implements ActionListener, MouseListener, MouseMotionListener {
    private int startX, startY, endX, endY;
    private int currentShape;
    private int currentColor;
    private JButton[] colorButtons;
    private JButton[] shapeButtons;
    private JPanel colorPanel;
    private JPanel shapePanel;
    private JPanel controlPanel;
    private DrawingArea drawingArea;

    public SimplePaint() {
        setTitle("Simple Paint");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(600, 400);

        // 初始化画布和颜色、形状按钮
        drawingArea = new DrawingArea();
        colorButtons = new JButton[7];
        colorButtons[0] = new JButton("Black");
        colorButtons[1] = new JButton("Red");
        colorButtons[2] = new JButton("Orange");
        colorButtons[3] = new JButton("Yellow");
        colorButtons[4] = new JButton("Green");
        colorButtons[5] = new JButton("Blue");
        colorButtons[6] = new JButton("Purple");
        for (int i = 0; i < colorButtons.length; i++) {
            colorButtons[i].addActionListener(this);
        }
        shapeButtons = new JButton[3];
        shapeButtons[0] = new JButton("Rectangle");
        shapeButtons[1] = new JButton("Line");
        shapeButtons[2] = new JButton("Oval");
        for (int i = 0; i < shapeButtons.length; i++) {
            shapeButtons[i].addActionListener(this);
        }

        // 设置颜色、形状按钮面板
        colorPanel = new JPanel();
        colorPanel.setLayout(new GridLayout(1, colorButtons.length));
        for (int i = 0; i < colorButtons.length; i++) {
            colorPanel.add(colorButtons[i]);
        }
        shapePanel = new JPanel();
        shapePanel.setLayout(new GridLayout(1, shapeButtons.length));
        for (int i = 0; i < shapeButtons.length; i++) {
            shapePanel.add(shapeButtons[i]);
        }

        // 设置控制面板
        controlPanel = new JPanel();
        controlPanel.setLayout(new BorderLayout());
        controlPanel.add(colorPanel, BorderLayout.NORTH);
        controlPanel.add(shapePanel, BorderLayout.SOUTH);

        // 添加组件
        add(drawingArea, BorderLayout.CENTER);
        add(controlPanel, BorderLayout.NORTH);

        // 添加鼠标事件监听器
        drawingArea.addMouseListener(this);
        drawingArea.addMouseMotionListener(this);
    }

    public void actionPerformed(ActionEvent e) {
        // 处理颜色按钮事件
        for (int i = 0; i < colorButtons.length; i++) {
            if (e.getSource() == colorButtons[i]) {
                currentColor = i;
                return;
            }
        }
        // 处理形状按钮事件
        for (int i = 0; i < shapeButtons.length; i++) {
            if (e.getSource() == shapeButtons[i]) {
                currentShape = i;
                return;
            }
        }
    }

    public void mouseClicked(MouseEvent e) {}
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void mousePressed(MouseEvent e) {
        startX = e.getX();
        startY = e.getY();
    }
    public void mouseReleased(MouseEvent e) {
        endX = e.getX();
        endY = e.getY();
        // 绘制形状
        Graphics g = drawingArea.getGraphics();
        g.setColor(getColor(currentColor));
        switch (currentShape) {
            case 0: // 矩形
                g.drawRect(Math.min(startX, endX), Math.min(startY, endY), Math.abs(endX - startX), Math.abs(endY - startY));
                break;
            case 1: // 直线
                g.drawLine(startX, startY, endX, endY);
                break;
            case 2: // 椭圆
                g.drawOval(Math.min(startX, endX), Math.min(startY, endY), Math.abs(endX - startX), Math.abs(endY - startY));
                break;
        }
        g.dispose();
    }
    public void mouseDragged(MouseEvent e) {}
    public void mouseMoved(MouseEvent e) {}

    private Color getColor(int index) {
        switch (index) {
            case 0: // 黑色
                return Color.BLACK;
            case 1: // 红色
                return Color.RED;
            case 2: // 橙色
                return Color.ORANGE;
            case 3: // 黄色
                return Color.YELLOW;
            case 4: // 绿色
                return Color.GREEN;
            case 5: // 蓝色
                return Color.BLUE;
            case 6: // 紫色
                return new Color(128, 0, 128);
            default:
                return Color.BLACK;
        }
    }

    public static void main(String[] args) {
        SimplePaint paint = new SimplePaint();
        paint.setVisible(true);
    }

    // 画布面板
    class DrawingArea extends JPanel {
        public DrawingArea() {
            setPreferredSize(new Dimension(400, 300));
            setBackground(Color.WHITE);
        }
    }
}

这个程序使用了Java的Swing图形库，创建了一个窗口，在窗口中添加了一个画布和颜色、形状按钮。通过鼠标事件监听器实现了绘制矩形、直线、椭圆的功能，通过颜色按钮实现了七种颜色的选择。您可以根据需要对程序进行修改和完善。

用Java制作一个简易的画图程序，要求有七种颜色，有矩形，直线，椭圆，画笔，清除画板橡皮擦等功能

以下是一个Java制作的简易画图程序，包含七种颜色，矩形，直线，椭圆，画笔，清除画板和橡皮擦等功能。

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class SimplePaintApp extends JFrame implements ActionListener, MouseListener, MouseMotionListener {
    private static final long serialVersionUID = 1L;
    private JButton clearBtn, eraserBtn;
    private JButton lineBtn, rectBtn, ovalBtn, penBtn;
    private JButton redBtn, greenBtn, blueBtn, cyanBtn, magentaBtn, yellowBtn, blackBtn;
    private JPanel btnPanel, drawPanel;
    private int startX, startY, endX, endY;
    private boolean isDrawing = false;
    private Color currentColor = Color.BLACK;
    private int penSize = 2;
    private Graphics2D g2;

    public SimplePaintApp() {
        setTitle("Simple Paint App");
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        // 初始化按钮
        clearBtn = new JButton("Clear");
        eraserBtn = new JButton("Eraser");
        lineBtn = new JButton("Line");
        rectBtn = new JButton("Rectangle");
        ovalBtn = new JButton("Oval");
        penBtn = new JButton("Pen");
        redBtn = new JButton();
        redBtn.setBackground(Color.RED);
        greenBtn = new JButton();
        greenBtn.setBackground(Color.GREEN);
        blueBtn = new JButton();
        blueBtn.setBackground(Color.BLUE);
        cyanBtn = new JButton();
        cyanBtn.setBackground(Color.CYAN);
        magentaBtn = new JButton();
        magentaBtn.setBackground(Color.MAGENTA);
        yellowBtn = new JButton();
        yellowBtn.setBackground(Color.YELLOW);
        blackBtn = new JButton();
        blackBtn.setBackground(Color.BLACK);

        // 添加按钮监听器
        clearBtn.addActionListener(this);
        eraserBtn.addActionListener(this);
        lineBtn.addActionListener(this);
        rectBtn.addActionListener(this);
        ovalBtn.addActionListener(this);
        penBtn.addActionListener(this);
        redBtn.addActionListener(this);
        greenBtn.addActionListener(this);
        blueBtn.addActionListener(this);
        cyanBtn.addActionListener(this);
        magentaBtn.addActionListener(this);
        yellowBtn.addActionListener(this);
        blackBtn.addActionListener(this);

        // 初始化按钮面板
        btnPanel = new JPanel();
        btnPanel.setLayout(new GridLayout(4, 4));
        btnPanel.add(clearBtn);
        btnPanel.add(eraserBtn);
        btnPanel.add(lineBtn);
        btnPanel.add(rectBtn);
        btnPanel.add(ovalBtn);
        btnPanel.add(penBtn);
        btnPanel.add(redBtn);
        btnPanel.add(greenBtn);
        btnPanel.add(blueBtn);
        btnPanel.add(cyanBtn);
        btnPanel.add(magentaBtn);
        btnPanel.add(yellowBtn);
        btnPanel.add(blackBtn);

        // 初始化画板
        drawPanel = new JPanel() {
            private static final long serialVersionUID = 1L;

            @Override
            public void paintComponent(Graphics g) {
                super.paintComponent(g);
                g2 = (Graphics2D) g;
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            }
        };
        drawPanel.setBackground(Color.WHITE);
        drawPanel.addMouseListener(this);
        drawPanel.addMouseMotionListener(this);

        // 添加面板
        getContentPane().add(btnPanel, BorderLayout.NORTH);
        getContentPane().add(drawPanel, BorderLayout.CENTER);

        setSize(600, 400);
        setVisible(true);
    }

    public static void main(String[] args) {
        new SimplePaintApp();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == clearBtn) {
            g2.setColor(Color.WHITE);
            g2.fillRect(0, 0, drawPanel.getWidth(), drawPanel.getHeight());
            g2.setColor(currentColor);
        } else if (e.getSource() == eraserBtn) {
            g2.setColor(Color.WHITE);
            penSize = 20;
            penBtn.setSelected(false);
            lineBtn.setSelected(false);
            rectBtn.setSelected(false);
            ovalBtn.setSelected(false);
        } else if (e.getSource() == lineBtn) {
            penSize = 2;
            penBtn.setSelected(false);
            lineBtn.setSelected(true);
            rectBtn.setSelected(false);
            ovalBtn.setSelected(false);
        } else if (e.getSource() == rectBtn) {
            penSize = 2;
            penBtn.setSelected(false);
            lineBtn.setSelected(false);
            rectBtn.setSelected(true);
            ovalBtn.setSelected(false);
        } else if (e.getSource() == ovalBtn) {
            penSize = 2;
            penBtn.setSelected(false);
            lineBtn.setSelected(false);
            rectBtn.setSelected(false);
            ovalBtn.setSelected(true);
        } else if (e.getSource() == penBtn) {
            penSize = 2;
            penBtn.setSelected(true);
            lineBtn.setSelected(false);
            rectBtn.setSelected(false);
            ovalBtn.setSelected(false);
        } else if (e.getSource() == redBtn) {
            currentColor = Color.RED;
            g2.setColor(currentColor);
        } else if (e.getSource() == greenBtn) {
            currentColor = Color.GREEN;
            g2.setColor(currentColor);
        } else if (e.getSource() == blueBtn) {
            currentColor = Color.BLUE;
            g2.setColor(currentColor);
        } else if (e.getSource() == cyanBtn) {
            currentColor = Color.CYAN;
            g2.setColor(currentColor);
        } else if (e.getSource() == magentaBtn) {
            currentColor = Color.MAGENTA;
            g2.setColor(currentColor);
        } else if (e.getSource() == yellowBtn) {
            currentColor = Color.YELLOW;
            g2.setColor(currentColor);
        } else if (e.getSource() == blackBtn) {
            currentColor = Color.BLACK;
            g2.setColor(currentColor);
        }
    }

    @Override
    public void mousePressed(MouseEvent e) {
        startX = e.getX();
        startY = e.getY();
        isDrawing = true;
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        if (isDrawing) {
            endX = e.getX();
            endY = e.getY();
            if (penBtn.isSelected()) {
                g2.setStroke(new BasicStroke(penSize, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2.drawLine(startX, startY, endX, endY);
            } else if (lineBtn.isSelected()) {
                g2.setStroke(new BasicStroke(penSize, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2.drawLine(startX, startY, endX, endY);
            } else if (rectBtn.isSelected()) {
                g2.setStroke(new BasicStroke(penSize, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2.drawRect(Math.min(startX, endX), Math.min(startY, endY), Math.abs(endX - startX), Math.abs(endY - startY));
            } else if (ovalBtn.isSelected()) {
                g2.setStroke(new BasicStroke(penSize, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2.drawOval(Math.min(startX, endX), Math.min(startY, endY), Math.abs(endX - startX), Math.abs(endY - startY));
            }
        }
        isDrawing = false;
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        if (isDrawing) {
            endX = e.getX();
            endY = e.getY();
            if (penBtn.isSelected()) {
                g2.setStroke(new BasicStroke(penSize, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2.drawLine(startX, startY, endX, endY);
                startX = endX;
                startY = endY;
            } else if (eraserBtn.isSelected()) {
                g2.setStroke(new BasicStroke(penSize, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2.setColor(Color.WHITE);
                g2.drawLine(startX, startY, endX, endY);
                g2.setColor(currentColor);
                startX = endX;
                startY = endY;
            }
        }
    }

    @Override
    public void mouseClicked(MouseEvent e) {
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }

    @Override
    public void mouseMoved(MouseEvent e) {
    }
}

该程序使用了 `JFrame` 和 `JPanel` 等 Swing 组件，通过按钮的监听器来实现不同功能的绘图，包括清除画板、橡皮擦、直线、矩形、椭圆和画笔，同时提供了七种颜色选择。程序中使用了 `Graphics2D` 对象来进行绘图，并通过鼠标事件监听器来捕获鼠标动作，实现画图功能。