交互式画板 v3.0

交互式画板 v3.0

---

用Java实现一个功能丰富的交互式画图板
在v2.0的基础上，添加了更多高级功能，包括画笔粗细调节、RGB颜色调节等，并优化了界面布局。

---

各个类的功能介绍

1. DrawPadv3类：负责创建和初始化画板的图形界面，包括各种控制面板的布局和组件设置
2. DrawListener类：实现MouseListener、ActionListener和ChangeListener接口，用于处理鼠标事件、按钮点击事件和滑块值改变事件

---

具体实现

1. 界面布局设计

public void showUI() {
    // 创建主窗口
    JFrame jf = new JFrame();
    jf.setTitle("画板v3.0");
    jf.setSize(1000,800);
    jf.setLocationRelativeTo(null);
    jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    // 创建各个面板
    JPanel topCtrlJP = new JPanel();       // 顶部控制面板
    JPanel shapeBtnJP = new JPanel();      // 图形按钮面板
    JPanel otherCtrlJP = new JPanel();     // 其他控制面板
    JPanel drawJP = new JPanel();          // 绘图面板
    JPanel penCtrlJP  = new JPanel();      // 画笔控制面板
    JPanel strokeWidthJslJP = new JPanel();// 画笔粗细滑块面板
    JPanel colorBtnJP = new JPanel();      // 颜色按钮面板
    JPanel colorJslJP = new JPanel();      // 颜色滑块面板

通过创建多个面板，实现了更清晰的界面布局：

• 顶部控制面板：用于放置基本控制按钮
• 左侧图形按钮面板：用于选择绘图工具
• 中央绘图面板：主要的绘图区域
• 底部控制面板：包含画笔粗细调节和颜色选择功能

2. 画笔控制功能

public void initStrokeWidthJp(JPanel fontSizeJp) {
    JSlider sliderSize = new JSlider(JSlider.HORIZONTAL, 0, 20, 1);
    sliderSize.setMajorTickSpacing(4);
    sliderSize.setPaintLabels(true);
    sliderSize.addChangeListener(dl);
    JLabel labelSize = new JLabel("画笔尺寸:" + 1);

    fontSizeJp.add(labelSize);
    fontSizeJp.add(sliderSize);

    dl.setStrokeWidthComponent(sliderSize, labelSize);
}

实现了画笔粗细的实时调节功能：

• 使用JSlider组件创建粗细调节滑块
• 范围从0到20，步长为1
• 添加刻度标记和数值标签
• 通过ChangeListener实时更新画笔粗细

3. RGB颜色调节

public void initColorJslJp(JPanel colorJslJp) {
    // 创建RGB颜色滑块
    JSlider sliderR = new JSlider(JSlider.HORIZONTAL, 0, 255, 1);
    JSlider sliderG = new JSlider(JSlider.HORIZONTAL, 0, 255, 1);
    JSlider sliderB = new JSlider(JSlider.HORIZONTAL, 0, 255, 1);
    
    // 设置滑块刻度
    sliderR.setMajorTickSpacing(50);
    sliderG.setMajorTickSpacing(50);
    sliderB.setMajorTickSpacing(50);
    sliderR.setPaintLabels(true);
    sliderG.setPaintLabels(true);
    sliderB.setPaintLabels(true);
}

添加了RGB颜色调节功能：

• 为红、绿、蓝三个通道分别创建滑块
• 范围从0到255，步长为1
• 添加刻度标记和数值标签
• 实时预览颜色效果

4. 事件处理

public void stateChanged(ChangeEvent e) {
    JSlider slider = (JSlider) e.getSource();
    int value = slider.getValue();

    int sliHashCode = slider.hashCode();

    // 处理画笔粗细滑块
    if (sliHashCode == jslFontSize.hashCode()) {
        fontSize = value;
        Graphics2D g2d = (Graphics2D) g;
        BasicStroke stroke = new BasicStroke(fontSize);
        g2d.setStroke(stroke);
        labelFontSize.setText("画笔尺寸：" + fontSize);
    } 
    // 处理颜色滑块
    else {
        if (sliHashCode == sliderR.hashCode()) {
            red = value;
            labelR.setText("红:" + red);
        } else if (sliHashCode == sliderG.hashCode()) {
            green = value;
            labelG.setText("绿:" + green);
        } else if (sliHashCode == sliderB.hashCode()) {
            blue = value;
            labelB.setText("蓝:" + blue);
        }
        Color color = new Color(red, green, blue);
        g.setColor(color);
        jslColorBtn.setBackground(color);
    }
}

实现了完整的事件处理机制：

• 处理滑块值改变事件，更新画笔粗细和颜色
• 处理按钮点击事件，切换绘图工具和颜色
• 处理鼠标事件，实现图形绘制

5. 绘图功能

@Override
public void mouseReleased(MouseEvent e) {
    x2 = e.getX();
    y2 = e.getY();

    // 根据不同的绘图类型执行相应的绘制操作
    if (type.equals("直线")) {
        g.drawLine(x1, y1, x2, y2);
    } else if (type.equals("矩形")) {
        g.drawRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
    } else if (type.equals("圆形")) {
        g.drawOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
    }
    // ... 其他图形绘制代码
}

支持多种图形的绘制：

• 直线、矩形、圆形等基本图形
• 实心图形和空心图形
• 等腰三角形及其变体
• 橡皮擦功能

6. 橡皮擦功能

橡皮擦功能的实现原理很简单，但非常实用：

• 当用户选择橡皮擦工具时，程序会将画笔颜色设置为白色（Color.white）
• 由于画板的背景色也是白色，所以当用户使用橡皮擦工具绘制时，实际上是用白色覆盖了原有的图形
• 这种实现方式的优点是：
  1. 不需要额外的内存来存储绘图历史
  2. 可以精确擦除特定区域
  3. 擦除效果与画笔粗细设置保持一致

7. 清空功能

清空功能提供了一键清除整个画板的能力：

• 实现原理：使用白色填充整个画板区域
• 具体步骤：
  1. 保存当前画笔颜色（Color currentColor = g.getColor()）
  2. 将画笔颜色设置为白色（g.setColor(Color.WHITE)）
  3. 使用fillRect方法填充整个画板区域（g.fillRect(0, 0, 1000, 800)）
  4. 恢复原来的画笔颜色（g.setColor(currentColor)）
• 这种实现方式的优点：
  1. 操作简单，一键完成
  2. 不会影响当前的画笔设置（颜色、粗细等）
  3. 可以快速开始新的绘制

---

主要改进

1. 界面布局优化：使用多个面板实现更清晰的界面结构
2. 画笔控制增强：添加画笔粗细调节功能
3. 颜色系统升级：支持RGB颜色调节和预设颜色选择
4. 事件处理完善：添加滑块值改变事件的处理
5. 代码结构优化：更清晰的类设计和功能划分

使用说明

1. 选择绘图工具：点击左侧面板中的工具按钮
2. 调节画笔粗细：使用底部的粗细滑块
3. 选择颜色：
   • 使用预设颜色按钮
   • 使用RGB滑块调节自定义颜色
4. 绘制图形：在中央绘图区域按住鼠标拖动
5. 使用橡皮擦：选择橡皮擦工具后，在需要擦除的区域拖动
6. 清空画板：点击左侧面板中的"清空"按钮，可以一键清除所有绘制内容

---

最终效果

---

最终代码

DrawPadv3.java

package basic.hj0510;

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

/**
 * 画板程序的主类
 * 负责创建和初始化画板的图形界面
 * 实现了以下主要功能：
 * 1. 创建主窗口和各个功能面板
 * 2. 设置面板布局和尺寸
 * 3. 初始化各种控制组件（按钮、滑块等）
 * 4. 组装界面组件
 * 5. 添加事件监听器
 */
public class DrawPadv3 {
    // 创建绘图监听器实例，用于处理所有用户交互事件
    DrawListener dl = new DrawListener();

    /**
     * 显示画板界面
     * 初始化所有UI组件并设置布局
     * 主要步骤：
     * 1. 创建主窗口并设置基本属性
     * 2. 创建并配置各个功能面板
     * 3. 设置面板布局和尺寸
     * 4. 初始化控制组件
     * 5. 组装界面
     * 6. 添加事件监听
     */
    public void showUI() {
        // 创建主窗口并设置基本属性
        JFrame jf = new JFrame();
        jf.setTitle("画板v3.0");
        jf.setSize(1000,800);  // 设置窗口大小为1000x800像素
        jf.setLocationRelativeTo(null);  // 使窗口在屏幕中居中显示
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  // 设置关闭窗口时退出程序

        // 创建各个功能面板
        JPanel topCtrlJP = new JPanel();       // 顶部控制面板：用于放置基本控制按钮
        JPanel shapeBtnJP = new JPanel();      // 图形按钮面板：用于选择绘图工具
        JPanel otherCtrlJP = new JPanel();     // 其他控制面板：包含绘图区域和其他控制组件
        JPanel drawJP = new JPanel();          // 绘图面板：主要的绘图区域
        JPanel penCtrlJP  = new JPanel();      // 画笔控制面板：包含画笔粗细和颜色控制
        JPanel strokeWidthJslJP = new JPanel();// 画笔粗细滑块面板：用于调节画笔粗细
        JPanel colorBtnJP = new JPanel();      // 颜色按钮面板：用于选择预设颜色
        JPanel colorJslJP = new JPanel();      // 颜色滑块面板：用于RGB颜色调节

        // 设置各个面板的尺寸
        Dimension dim_topCtrlJP = new Dimension(1100, 30);      // 顶部控制面板尺寸
        Dimension dim_shapeBtnJP = new Dimension(120, 570);     // 图形按钮面板尺寸
        Dimension dim_otherCtrlJP = new Dimension(900, 570);    // 其他控制面板尺寸
        Dimension dim_penCtrlJP = new Dimension(900, 150);      // 画笔控制面板尺寸
        Dimension dim_strokeWidthJslJP = new Dimension(260, 150);// 画笔粗细滑块面板尺寸
        Dimension dim_colorBtnJP = new Dimension(360, 150);     // 颜色按钮面板尺寸
        Dimension dim_colorJslJP = new Dimension(280, 150);     // 颜色滑块面板尺寸

        // 应用尺寸设置到各个面板
        topCtrlJP.setPreferredSize(dim_topCtrlJP);
        shapeBtnJP.setPreferredSize(dim_shapeBtnJP);
        otherCtrlJP.setPreferredSize(dim_otherCtrlJP);
        penCtrlJP.setPreferredSize(dim_penCtrlJP);
        strokeWidthJslJP.setPreferredSize(dim_strokeWidthJslJP);
        colorBtnJP.setPreferredSize(dim_colorBtnJP);
        colorJslJP.setPreferredSize(dim_colorJslJP);

        // 设置面板的布局管理器
        topCtrlJP.setLayout(new BorderLayout());    // 使用边界布局
        otherCtrlJP.setLayout(new BorderLayout());  // 使用边界布局
        penCtrlJP.setLayout(new BorderLayout());    // 使用边界布局

        // 设置各个面板的背景颜色
        topCtrlJP.setBackground(Color.LIGHT_GRAY);      // 浅灰色背景
        shapeBtnJP.setBackground(Color.DARK_GRAY);      // 深灰色背景
        drawJP.setBackground(Color.WHITE);              // 白色背景
        strokeWidthJslJP.setBackground(Color.LIGHT_GRAY);// 浅灰色背景
        colorBtnJP.setBackground(Color.LIGHT_GRAY);     // 浅灰色背景

        // 组装面板，构建界面层次结构
        penCtrlJP.add(strokeWidthJslJP, BorderLayout.WEST);    // 左侧放置画笔粗细控制
        penCtrlJP.add(colorBtnJP, BorderLayout.EAST);          // 右侧放置颜色按钮
        penCtrlJP.add(colorJslJP, BorderLayout.CENTER);        // 中间放置颜色滑块

        otherCtrlJP.add(penCtrlJP, BorderLayout.SOUTH);        // 底部放置画笔控制面板
        otherCtrlJP.add(drawJP, BorderLayout.CENTER);          // 中间放置绘图区域

        jf.add(topCtrlJP, BorderLayout.NORTH);                 // 顶部放置控制面板
        jf.add(shapeBtnJP, BorderLayout.WEST);                 // 左侧放置图形按钮
        jf.add(otherCtrlJP, BorderLayout.CENTER);              // 中间放置其他控制面板

        // 初始化各个功能面板的组件
        initColorBtnJp(colorBtnJP);         // 初始化颜色按钮
        initColorJslJp(colorJslJP);         // 初始化颜色滑块
        initStrokeWidthJp(strokeWidthJslJP);// 初始化画笔粗细控制
        initShapeBtnJp(shapeBtnJP);         // 初始化图形按钮

        jf.setVisible(true);  // 显示窗口

        // 为绘图面板添加鼠标监听器，用于处理绘图操作
        drawJP.addMouseListener(dl);

        // 获取绘图面板的Graphics对象并传递给监听器
        Graphics g = drawJP.getGraphics();
        dl.g = g;
    }

    /**
     * 初始化图形按钮面板
     * 创建各种绘图工具的按钮
     * 包括：直线、圆形、矩形等基本图形工具
     * 以及实心图形和橡皮擦等特殊工具
     */
    public void initShapeBtnJp(JPanel shapeBtnJp) {
        // 定义所有可用的绘图工具
        String[] btnType = {"直线", "圆形", "矩形", "实心圆形", "实心矩形", "等腰三角形",
                "实心等腰三角形", "橡皮擦", "清空"};
        // 循环创建按钮并添加到面板
        for (int i = 0; i < btnType.length; i++) {
            JButton btn = new JButton(btnType[i]);
            shapeBtnJp.add(btn);
            btn.addActionListener(dl);  // 添加动作监听器
        }
    }

    /**
     * 初始化颜色按钮面板
     * 创建预设颜色的按钮
     * 包括：黑色、红色、绿色等13种基本颜色
     */
    public void initColorBtnJp(JPanel colorBtnJp) {
        // 定义预设颜色数组，包含13种常用颜色
        Color[] btnColors = {Color.BLACK, Color.RED, Color.GREEN,
                Color.BLUE, Color.YELLOW, Color.CYAN, Color.MAGENTA,
                Color.GRAY, Color.LIGHT_GRAY, Color.DARK_GRAY,
                Color.PINK, Color.ORANGE, Color.WHITE};

        // 创建颜色按钮
        Dimension cDim = new Dimension(20, 20);  // 设置按钮大小为20x20像素
        for(int i = 0 ; i < btnColors.length ; i++) {
            JButton btn = new JButton();
            btn.setActionCommand("ColorBtn");    // 设置按钮命令
            btn.setBackground(btnColors[i]);     // 设置按钮背景色
            colorBtnJp.add(btn);
            btn.setPreferredSize(cDim);          // 设置按钮尺寸
            btn.addActionListener(dl);           // 添加动作监听器
        }
    }

    /**
     * 初始化画笔粗细控制面板
     * 创建画笔粗细滑块和标签
     * 实现画笔粗细的实时调节功能
     */
    public void initStrokeWidthJp(JPanel fontSizeJp) {
        // 创建画笔粗细滑块，范围0-20，步长1
        JSlider sliderSize = new JSlider(JSlider.HORIZONTAL, 0, 20, 1);
        sliderSize.setMajorTickSpacing(4);       // 设置主刻度间隔
        sliderSize.setPaintLabels(true);         // 显示刻度标签
        sliderSize.addChangeListener(dl);        // 添加值改变监听器
        
        // 创建显示当前画笔粗细的标签
        JLabel labelSize = new JLabel("画笔尺寸:" + 1);

        // 添加组件到面板
        fontSizeJp.add(labelSize);
        fontSizeJp.add(sliderSize);

        // 将组件传递给监听器
        dl.setStrokeWidthComponent(sliderSize, labelSize);
    }

    /**
     * 初始化颜色滑块面板
     * 创建RGB颜色调节滑块和颜色预览按钮
     * 实现颜色的精确调节功能
     */
    public void initColorJslJp(JPanel colorJslJp) {
        // 创建RGB三个颜色通道的滑块
        JSlider sliderR = new JSlider(JSlider.HORIZONTAL, 0, 255, 1);  // 红色通道
        JSlider sliderG = new JSlider(JSlider.HORIZONTAL, 0, 255, 1);  // 绿色通道
        JSlider sliderB = new JSlider(JSlider.HORIZONTAL, 0, 255, 1);  // 蓝色通道
        
        // 设置滑块刻度
        sliderR.setMajorTickSpacing(50);  // 设置主刻度间隔为50
        sliderG.setMajorTickSpacing(50);
        sliderB.setMajorTickSpacing(50);
        sliderR.setPaintLabels(true);     // 显示刻度标签
        sliderG.setPaintLabels(true);
        sliderB.setPaintLabels(true);
        
        // 添加值改变监听器
        sliderR.addChangeListener(dl);
        sliderG.addChangeListener(dl);
        sliderB.addChangeListener(dl);

        // 创建显示当前RGB值的标签
        JLabel labelR = new JLabel("R:" + 1);
        JLabel labelG = new JLabel("G:" + 1);
        JLabel labelB = new JLabel("B:" + 1);

        // 添加组件到面板
        colorJslJp.add(labelR);
        colorJslJp.add(sliderR);
        colorJslJp.add(labelG);
        colorJslJp.add(sliderG);
        colorJslJp.add(labelB);
        colorJslJp.add(sliderB);

        // 创建颜色预览按钮
        JButton jslColorBtn = new JButton();
        jslColorBtn.setActionCommand("ColorBtn");
        jslColorBtn.setBackground(Color.BLACK);  // 初始颜色设为黑色
        jslColorBtn.setPreferredSize(new Dimension(200, 30));  // 设置按钮大小
        colorJslJp.add(jslColorBtn);
        jslColorBtn.addActionListener(dl);
        dl.jslColorBtn = jslColorBtn;  // 将按钮引用传递给监听器

        // 将颜色相关组件传递给监听器
        dl.setJslComponent(sliderR, sliderG, sliderB, labelR, labelG, labelB);
    }

    /**
     * 程序入口点
     * 创建画板实例并显示界面
     */
    public static void main(String[] args) {
        DrawPadv3 dp = new DrawPadv3();
        dp.showUI();
    }
}

DrawListener.java

package basic.hj0510;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

/**
 * 绘图监听器类
 * 实现了鼠标监听器、动作监听器和状态改变监听器
 * 用于处理画板的所有交互事件，包括：
 * 1. 鼠标事件：处理绘图操作
 * 2. 按钮事件：处理工具选择和颜色选择
 * 3. 滑块事件：处理画笔粗细和颜色调节
 */
public class DrawListener implements MouseListener, ActionListener, ChangeListener {
    // 绘图对象，用于执行实际的绘图操作
    public Graphics g;
    
    // 记录鼠标按下和释放的坐标，用于确定图形的位置和大小
    int x1, y1, x2, y2;
    
    // 当前选择的绘图类型，默认为直线
    String type = "直线";
    
    // 颜色相关的组件和变量
    int red = 1, green = 1, blue = 1;   // RGB颜色值，初始值设为1
    JSlider sliderR, sliderG, sliderB;  // RGB颜色滑块
    JLabel labelR, labelG, labelB;      // RGB颜色值显示标签
    JButton jslColorBtn;                // 颜色预览按钮

    /**
     * 设置颜色相关的组件
     * 将RGB滑块和标签的引用保存到监听器中
     */
    public void setJslComponent(JSlider sliderR, JSlider sliderG, JSlider sliderB,
                              JLabel labelR, JLabel labelG, JLabel labelB) {
        this.sliderR = sliderR;
        this.sliderG = sliderG;
        this.sliderB = sliderB;
        this.labelR = labelR;
        this.labelG = labelG;
        this.labelB = labelB;
    }

    // 画笔粗细相关组件
    int fontSize = 1;                 // 画笔粗细值，初始值为1
    JSlider jslFontSize;              // 画笔粗细滑块
    JLabel labelFontSize;             // 画笔粗细显示标签

    /**
     * 设置画笔粗细相关的组件
     * 将滑块和标签的引用保存到监听器中
     */
    public void setStrokeWidthComponent(JSlider sliderSize, JLabel labelSize) {
        this.jslFontSize = sliderSize;
        this.labelFontSize = labelSize;
    }

    /**
     * 处理滑块值改变事件
     * 用于更新颜色和画笔粗细
     * 根据滑块的类型执行不同的更新操作
     */
    public void stateChanged(ChangeEvent e) {
        JSlider slider = (JSlider) e.getSource();
        int value = slider.getValue();

        int sliHashCode = slider.hashCode();

        // 处理画笔粗细滑块
        if (sliHashCode == jslFontSize.hashCode()) {
            fontSize = value;
            Graphics2D g2d = (Graphics2D) g;
            BasicStroke stroke = new BasicStroke(fontSize);
            g2d.setStroke(stroke);
            labelFontSize.setText("画笔尺寸：" + fontSize);
        } 
        // 处理颜色滑块
        else {
            if (sliHashCode == sliderR.hashCode()) {
                red = value;
                labelR.setText("红:" + red);
            } else if (sliHashCode == sliderG.hashCode()) {
                green = value;
                labelG.setText("绿:" + green);
            } else if (sliHashCode == sliderB.hashCode()) {
                blue = value;
                labelB.setText("蓝:" + blue);
            }
            // 更新当前颜色
            Color color = new Color(red, green, blue);
            g.setColor(color);
            jslColorBtn.setBackground(color);
        }
    }

    /**
     * 处理按钮点击事件
     * 用于切换绘图工具和颜色
     * 根据按钮的类型执行不同的操作
     */
    @Override
    public void actionPerformed(ActionEvent e) {
        String ac = e.getActionCommand();
        
        // 处理颜色按钮点击
        if(ac.equals("ColorBtn")) {
            JButton btn = (JButton) e.getSource();
            Color color = btn.getBackground();
            // 更新RGB值
            red = color.getRed();
            green = color.getGreen();
            blue = color.getBlue();
            g.setColor(color);
        }
        // 处理橡皮擦工具
        else if(ac.equals("橡皮擦")) {
            g.setColor(Color.white);  // 设置颜色为白色，实现擦除效果
        }
        // 处理清空画板
        else if(ac.equals("清空")) {
            // 保存当前颜色
            Color currentColor = g.getColor();
            // 清除整个面板
            g.setColor(Color.WHITE);
            g.fillRect(0, 0, 1000, 800);  // 使用固定尺寸，确保覆盖整个绘图区域
            // 恢复原来的颜色
            g.setColor(currentColor);
        }
        // 处理其他绘图工具
        else {
            type = ac;  // 更新绘图类型
            g.setColor(new Color(red, green, blue));  // 设置当前颜色
        }
    }

    /**
     * 处理鼠标点击事件
     * 目前仅用于调试输出
     */
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("鼠标在窗体按钮上点击了");
    }

    /**
     * 记录鼠标按下的起始位置
     * 用于确定图形的起始点
     */
    @Override
    public void mousePressed(MouseEvent e) {
        x1 = e.getX();
        y1 = e.getY();
    }

    /**
     * 处理鼠标释放事件
     * 根据选择的工具类型绘制相应的图形
     * 支持多种图形的绘制，包括：
     * 1. 直线
     * 2. 矩形（空心和实心）
     * 3. 圆形（空心和实心）
     * 4. 等腰三角形（空心和实心）
     */
    @Override
    public void mouseReleased(MouseEvent e) {
        x2 = e.getX();
        y2 = e.getY();

        // 根据不同的绘图类型执行相应的绘制操作
        if (type.equals("直线")) {
            g.drawLine(x1, y1, x2, y2);
        } else if (type.equals("矩形")) {
            g.drawRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
        } else if (type.equals("圆形")) {
            g.drawOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
        } else if (type.equals("实心矩形")) {
            g.fillRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
        } else if (type.equals("实心圆形")) {
            g.fillOval(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
        } else if (type.equals("实心等腰三角形")) {
            // 绘制实心等腰三角形
            int mx = (x1 + x2) / 2;   // 计算顶点x坐标
            int my = y1;              // 顶点y坐标
            int h = Math.abs(y2 - y1);// 计算高度
            int w = Math.abs(x2 - x1);// 计算宽度
            double dx = w / 2.0 / h;  // 计算每行宽度变化量
            // 逐行绘制三角形
            for (int i = 0; i < h; i++) {
                if (y1 < y2) {
                    g.drawLine((int) (mx - dx * i), my + i, (int) (mx + dx * i), my + i);
                } else {
                    g.drawLine((int) (mx - dx * i), my - i, (int) (mx + dx * i), my - i);
                }
            }
        } else if (type.equals("等腰三角形")) {
            // 绘制等腰三角形轮廓
            int mx = (x1 + x2) / 2;  // 计算顶点x坐标
            int my = y1;             // 顶点y坐标
            // 绘制三条边
            g.drawLine(x1, y2, mx, my);  // 左边
            g.drawLine(mx, my, x2, y2);  // 右边
            g.drawLine(x1, y2, x2, y2);  // 底边
        }
    }

    /**
     * 处理鼠标进入事件
     * 目前未实现具体功能
     */
    @Override
    public void mouseEntered(MouseEvent e) {
    }

    /**
     * 处理鼠标离开事件
     * 目前未实现具体功能
     */
    @Override
    public void mouseExited(MouseEvent e) {
    }
}