简介：在Java中，"paintDemo2_java_点与多边形_"展示了一个图形用户界面(GUI)编程示例，它演示了如何通过鼠标事件处理和图形绘制来追踪并绘制多边形，并判断点是否在多边形内部。通过实现监听鼠标事件的 DrawListener.java 类和包含绘图功能的 DramFrame.java 主窗口类，以及采用几何算法来判断点的位置，这个项目为学习Java图形界面编程和图形算法提供了基础。 
1. Java GUI编程基础
1.1 Java GUI的简介
Java GUI（Graphical User Interface，图形用户界面）编程为开发者提供了一种创建图形界面应用程序的方法。利用Java的AWT（Abstract Window Toolkit）和Swing库，用户能够设计出具有现代外观的应用程序。它不仅丰富了用户体验，也为处理用户输入提供了直观的界面。
1.2 Java GUI编程的核心组件
在Java中，GUI编程通常涉及几个核心组件：窗口（JFrame），面板（JPanel），按钮（JButton），文本框（JTextField），等等。每个组件都有其特定用途，通过合理的布局和事件处理，可以构建出功能丰富且用户友好的界面。
1.3 开始编写第一个Java GUI程序
一个基本的Java GUI程序需要导入Swing库，创建一个JFrame窗口，并设置其一些基本属性如大小和默认关闭操作。然后通过 add() 方法将组件添加到窗口中，并通过 pack() 方法调整窗口大小以适应组件内容。最后，调用 setVisible(true) 使窗口可见。以下是一段简单的示例代码：
import javax.swing.JFrame;
import javax.swing.JButton;
public class FirstGUIApp {
public static void main(String[] args) {
JFrame frame = new JFrame("第一个GUI程序");
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton button = new JButton("点击我");
frame.add(button);
frame.pack();
frame.setVisible(true);
}
}
本章为读者介绍了Java GUI编程的基本概念、核心组件以及如何编写一个简单的应用程序，为后续章节的内容打下基础。
2. 鼠标事件处理
2.1 鼠标事件的种类
2.1.1 鼠标点击事件
鼠标点击事件是用户与GUI交互中最常见的方式之一，它涉及到多种动作，包括单击（鼠标左键按下和释放）、双击以及右键点击等。Java中的鼠标事件处理是通过实现AWT和Swing库中的事件监听接口完成的。在Java GUI编程中，涉及到鼠标的事件处理，需要使用 MouseListener 接口。
下面是 MouseListener 接口中定义的鼠标事件回调方法：
public interface MouseListener {
// 鼠标被点击时触发
void mouseClicked(MouseEvent e);
// 鼠标进入组件时触发
void mouseEntered(MouseEvent e);
// 鼠标离开组件时触发
void mouseExited(MouseEvent e);
// 鼠标按下触发
void mousePressed(MouseEvent e);
// 鼠标释放触发
void mouseReleased(MouseEvent e);
}
2.1.2 鼠标移动事件
鼠标移动事件是当鼠标指针移动到组件内部或者从组件上移动开时触发的事件。在 MouseMotionListener 接口中定义了两个方法： mouseMoved 和 mouseDragged 。 mouseMoved 方法在鼠标指针移动到组件上时触发，而 mouseDragged 则是在鼠标指针在组件上按下并移动时触发。
public interface MouseMotionListener {
// 鼠标指针移动到组件上时触发
void mouseMoved(MouseEvent e);
// 鼠标被按下并移动时触发
void mouseDragged(MouseEvent e);
}
2.2 事件处理机制
2.2.1 事件监听与响应
在Java中，事件处理是基于事件监听模型的。事件监听模型由事件源、事件监听器和事件对象组成。当事件源发生了某种事件，比如鼠标点击，它会创建一个事件对象并通知所有注册的事件监听器。
为了响应事件，你需要实现相应的事件监听接口，并注册到相应的组件上。这可以通过组件的 addMouseListener 和 addMouseMotionListener 方法实现。
2.2.2 事件委托模型
事件委托模型是处理GUI事件的一种模式，它建议将事件监听器附加到一个公共的父组件上，而不是直接附加到产生事件的组件上。这样可以减少内存消耗，并简化事件处理逻辑。Java中的Swing组件是单线程模型，事件处理逻辑是放在事件分发线程（Event Dispatch Thread, EDT）中的。
在事件委托模型中，当一个事件发生时，它会沿着组件层次结构向上委托，直到找到合适的监听器处理它。这种模型减少了事件监听器的数量，提高了程序的性能和可维护性。
// 示例：注册鼠标监听器
button.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
// 处理鼠标点击事件
}
});
上述代码展示了如何给一个按钮添加一个鼠标点击事件的监听器。在这里，我们使用了 MouseAdapter 抽象类，这是 MouseListener 的一个便利实现，它默认实现了接口中所有方法的空操作，我们只需要重写需要处理的方法。
在下一章节中，我们将继续深入了解图形绘制技术，探讨Java中的基本图形绘制方法，如线条、矩形、圆形和文本的绘制，以及如何实现抗锯齿图形和图像的绘制和处理。我们将通过代码和图形的结合，逐步展示Java GUI编程的视觉效果实现过程。
3. 图形绘制技术
3.1 Java中的基本图形绘制
在Java中， Graphics 类提供了一系列用于绘制基本图形的方法，包括线条、矩形、圆形等，以及字符和文本的绘制。本节将详细介绍如何利用这些方法来完成基础图形的绘制。
3.1.1 线条、矩形和圆形的绘制
在Java图形用户界面(GUI)编程中， Graphics 类是最常用的类之一，它提供了多种用于绘制图形的方法，如 drawLine 、 drawRect 、 drawOval 等。
public void paintComponent(Graphics g) {
super.paintComponent(g);
// 绘制线条
g.drawLine(10, 10, 200, 10);
// 绘制矩形
g.drawRect(50, 20, 100, 50);
// 绘制圆形
g.drawOval(160, 20, 100, 100);
}
在上述代码中， drawLine 方法需要四个参数：起点的x和y坐标以及终点的x和y坐标。 drawRect 方法需要四个参数，分别表示矩形左上角的x和y坐标以及矩形的宽度和高度。 drawOval 方法则需要四个参数来确定椭圆或圆形的位置和大小。
3.1.2 字符和文本的绘制
绘制字符和文本是GUI应用中非常常见的一项需求。 Graphics 类提供了 drawString 方法用于绘制字符串。
public void paintComponent(Graphics g) {
super.paintComponent(g);
// 绘制字符串
g.drawString("Hello, World!", 50, 100);
}
drawString 方法有两个整型参数和一个字符串参数，分别表示字符串绘制的起始x坐标、y坐标和字符串内容。文本的位置基于组件的左上角。
3.2 高级图形绘制技术
随着应用需求的不断增长，基础图形绘制往往满足不了复杂的应用场景，此时就需要运用一些高级的图形绘制技术。
3.2.1 抗锯齿图形绘制
抗锯齿技术是一种平滑图形边缘的技术，能有效减少图形边缘的锯齿现象。Java的 Graphics 类提供了抗锯齿的功能，但默认是关闭的。要开启抗锯齿功能，可以通过以下代码：
Graphics2D g2d = (Graphics2D) g;
RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setRenderingHints(rh);
在这段代码中， RenderingHints 类用于设置图形绘制时的提示信息， KEY_ANTIALIASING 与 VALUE_ANTIALIAS_ON 共同作用来开启抗锯齿功能。
3.2.2 图像的绘制和处理
在Java中，可以使用 Graphics 类的 drawImage 方法来绘制图像。 Image 类代表了一个图像对象，可以通过读取图片文件来创建。
Image image = Toolkit.getDefaultToolkit().getImage("path/to/image.png");
g.drawImage(image, 100, 100, this);
在这段代码中， getImage 方法读取图片文件并返回一个 Image 对象， drawImage 方法则用于将图像绘制到指定位置。
此外，Java还提供了丰富的图像处理功能，如图像缩放、旋转等。例如，通过 BufferedImage 类可以创建一个可写的图像缓冲区，在此可以对图像进行各种处理。
BufferedImage img = new BufferedImage(200, 200, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = img.createGraphics();
// 在此处可以使用g2d来对图像进行处理
g2d.dispose();
以上是基础图形绘制技术的概览。为了提升图形界面的吸引力和功能性，掌握这些高级技术是非常有必要的。在本章节中，我们将深入探讨更多实用的图形绘制技术和实践，使读者能够创建更加丰富多彩的图形用户界面。
4. 多边形绘制与顶点管理
在本章节中，我们将深入探讨如何在Java中进行多边形的绘制以及顶点的管理。多边形是图形用户界面（GUI）编程中常用的图形对象，特别是在需要表现复杂形状或者进行空间分析的应用场景中。我们不仅会介绍如何在Java中构建和绘制多边形，还会深入分析顶点管理的技术细节，包括顶点的数据结构、存储以及增删改查操作。
4.1 多边形的构建与绘制
多边形是通过一系列顶点顺序连接而成的闭合图形。在Java中，绘制多边形通常涉及到创建一个自定义的图形类，然后使用Java的图形绘制API来实现。
4.1.1 创建多边形类
创建一个多边形类，首先需要定义顶点的数据结构。一个典型的做法是使用一个顶点数组来存储多边形的所有顶点坐标。在这个类中，我们还需要实现一个多边形的绘制方法，该方法将使用Java的 Graphics 类提供的绘制方法来绘制多边形。
public class Polygon {
private int[] xPoints; // 存储多边形各顶点x坐标
private int[] yPoints; // 存储多边形各顶点y坐标
private int nPoints; // 顶点数量
public Polygon(int[] xPoints, int[] yPoints, int nPoints) {
if (nPoints > 1) {
this.nPoints = nPoints;
this.xPoints = xPoints;
this.yPoints = yPoints;
} else {
throw new IllegalArgumentException("多边形必须至少有三个顶点");
}
}
public void draw(Graphics g) {
g.drawPolygon(xPoints, yPoints, nPoints);
}
}
在上述代码中，我们定义了一个名为 Polygon 的类，它有两个数组成员变量 xPoints 和 yPoints 来存储顶点的x和y坐标，以及一个整型变量 nPoints 来记录顶点的数量。构造函数用于初始化这些变量，并检查顶点数量以确保多边形至少有三个顶点。 draw 方法使用 Graphics 对象的 drawPolygon 方法来绘制多边形。
4.1.2 使用顶点数组绘制多边形
在实际应用中，要绘制一个多边形，首先需要创建 Polygon 对象，并传入顶点坐标数组。以下是一个简单的示例，演示如何在一个 JPanel 上绘制一个自定义的多边形。
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Polygon;
public class PolygonExample extends JPanel {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// 定义多边形的顶点坐标
int[] xPoints = {100, 200, 300, 400, 300};
int[] yPoints = {100, 150, 250, 200, 100};
int nPoints = 5; // 顶点数量
// 创建并绘制多边形
Polygon polygon = new Polygon(xPoints, yPoints, nPoints);
g.drawPolygon(polygon);
}
public static void main(String[] args) {
JFrame frame = new JFrame("Polygon Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new PolygonExample());
frame.setSize(500, 500);
frame.setVisible(true);
}
}
在上述代码中，我们创建了一个 PolygonExample 类，它继承自 JPanel 。在 paintComponent 方法中，我们定义了多边形的顶点坐标，并创建了一个 Polygon 对象来绘制它。 main 方法中创建了一个 JFrame 窗口，并将 PolygonExample 面板添加到窗口中。
4.2 多边形顶点的数据结构与管理
管理多边形顶点的数据结构至关重要，因为它是实现多边形操作的基础。在本节中，我们将探讨如何高效地存储顶点数据，以及如何实现对顶点的增删改查操作。
4.2.1 顶点的坐标表示与存储
在多边形类中，顶点的坐标是多边形定义的基础。通常情况下，顶点存储为一个二维数组，数组中的每个元素代表一个顶点的x和y坐标。这种数据结构可以方便地通过索引来访问每个顶点，也便于数组的遍历。
4.2.2 顶点的增删改查操作
在Java中，顶点的增删改查可以通过数组操作或者使用集合框架中的数据结构来实现。为了提供更加灵活的操作，我们可以为 Polygon 类添加一系列方法来实现这些操作。
public void addVertex(int x, int y) {
int[] newXPoints = new int[nPoints + 1];
int[] newYPoints = new int[nPoints + 1];
for (int i = 0; i < nPoints; i++) {
newXPoints[i] = xPoints[i];
newYPoints[i] = yPoints[i];
}
newXPoints[nPoints] = x;
newYPoints[nPoints] = y;
xPoints = newXPoints;
yPoints = newYPoints;
nPoints++;
}
public void removeVertex(int index) {
if (index < 0 || index >= nPoints) {
throw new IndexOutOfBoundsException("顶点索引越界");
}
int[] newXPoints = new int[nPoints - 1];
int[] newYPoints = new int[nPoints - 1];
int j = 0;
for (int i = 0; i < nPoints; i++) {
if (i != index) {
newXPoints[j] = xPoints[i];
newYPoints[j] = yPoints[i];
j++;
}
}
xPoints = newXPoints;
yPoints = newYPoints;
nPoints--;
}
public void updateVertex(int index, int newX, int newY) {
if (index < 0 || index >= nPoints) {
throw new IndexOutOfBoundsException("顶点索引越界");
}
xPoints[index] = newX;
yPoints[index] = newY;
}
在上述代码中，我们实现了 Polygon 类的 addVertex 方法用于增加顶点、 removeVertex 方法用于删除顶点，以及 updateVertex 方法用于更新顶点坐标。这些方法通过数组操作实现，保证了顶点数据结构的一致性。
. . . 顶点的查找
查找顶点通常涉及到通过索引访问数组中的元素。例如，查找第 i 个顶点的坐标可以简单地通过以下代码实现：
public Point getVertex(int index) {
if (index < 0 || index >= nPoints) {
throw new IndexOutOfBoundsException("顶点索引越界");
}
return new Point(xPoints[index], yPoints[index]);
}
. . . 顶点的更新
更新顶点涉及到修改数组中对应索引的坐标值。例如，更新第 i 个顶点的坐标可以通过以下代码实现：
public void updateVertex(int index, Point newVertex) {
if (index < 0 || index >= nPoints) {
throw new IndexOutOfBoundsException("顶点索引越界");
}
xPoints[index] = newVertex.x;
yPoints[index] = newVertex.y;
}
. . . 顶点的删除
删除顶点是一个复杂的过程，因为需要保持数组的连续性。可以使用 removeVertex 方法如上所示来实现这一操作。
. . . 顶点的添加
添加顶点需要创建一个新的数组，然后将新顶点插入到指定位置。可以使用 addVertex 方法如上所示来实现这一操作。
表格展示
为了更直观地了解顶点操作的复杂性，我们可以创建一个表格来展示不同顶点操作的比较：
| 操作类型 | 时间复杂度 | 空间复杂度 | 描述 | |----------|------------|------------|------| | 查找 | O(1) | O(1) | 通过索引直接访问顶点坐标 | | 更新 | O(1) | O(1) | 修改指定顶点的坐标值 | | 删除 | O(n) | O(1) | 删除指定顶点并重新排列剩余顶点 | | 添加 | O(n) | O(n) | 创建新数组并插入新顶点 |
顶点操作的代码块逻辑分析
public void addVertex(int x, int y) {
// 创建新的数组，长度比原数组多1
int[] newXPoints = new int[nPoints + 1];
int[] newYPoints = new int[nPoints + 1];
// 复制原数组到新数组，并将新顶点坐标加入数组末尾
for (int i = 0; i < nPoints; i++) {
newXPoints[i] = xPoints[i];
newYPoints[i] = yPoints[i];
}
newXPoints[nPoints] = x;
newYPoints[nPoints] = y;
// 更新原数组变量指向新数组
xPoints = newXPoints;
yPoints = newYPoints;
// 增加顶点数量
nPoints++;
}
上述代码展示了如何向 Polygon 类中添加一个新的顶点。通过增加数组长度并复制元素到新数组，然后更新类变量，我们完成了添加顶点的操作。这个过程保证了顶点数据的连续性，并且维护了顶点的顺序。
结语
多边形的构建与绘制是图形界面编程中的重要组成部分。通过使用Java中提供的 Polygon 类和自定义的顶点管理方法，我们可以灵活地对多边形进行操作。在本章节中，我们学习了多边形的基本概念，掌握如何构建自定义多边形类并进行绘制，同时分析了顶点数据结构的存储方式以及增删改查的具体实现步骤。这些知识为我们在Java中创建复杂的图形界面打下了坚实的基础。
5. 点在多边形内判断方法
在图形界面编程和计算机图形学中，判断一个点是否在多边形内部是一个基础且重要的问题。这对于各种游戏设计、图形渲染、地理信息系统等领域至关重要。本章将详细介绍两种常用算法：光栅扫描算法和射线交叉法，它们在不同场景下的应用及优缺点。
5.1 光栅扫描算法
5.1.1 基本原理
光栅扫描算法的核心思想是将多边形的边界线段进行排序，并使用“扫描线”来逐行判断点是否在多边形内部。扫描线是一种虚拟的线，它从多边形的上边界向下移动，每次移动一行像素。算法将多边形的边界线段按从左到右的顺序排序，然后对每条扫描线上的交点进行计数。如果点在多边形内部，那么每条扫描线上的交点个数将是奇数；如果点在多边形外部，则交点个数为偶数。
5.1.2 实现步骤与代码示例
以Java为例，以下是使用光栅扫描算法实现点在多边形内判断的基本步骤：
- 获取多边形所有边界的顶点，并按X坐标排序。
- 为每条边找到与扫描线的交点。
- 对所有扫描线的交点进行计数。
- 根据交点总数的奇偶性来判断点是否在多边形内。
public class PointInPolygon {
static class Edge {
int x1, y1, x2, y2; // 边的两个顶点坐标
Edge(int x1, int y1, int x2, int y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
}
static boolean pointInPolygon(int x, int y, List<Edge> edges) {
int crossings = 0;
int n = edges.size();
for (int i = 0; i < n; i++) {
Edge e = edges.get(i);
int x1 = e.x1, y1 = e.y1;
int x2 = e.x2, y2 = e.y2;
// 只考虑左侧的边
if (y1 > y2) {
int temp = y1;
y1 = y2;
y2 = temp;
temp = x1;
x1 = x2;
x2 = temp;
}
// 点在边上或者多边形顶点上不算在内
if (y == y1 || y == y2 || x == x1 || x == x2) continue;
// 如果点在边的延长线上，则认为在多边形外
if ((y1 < y && y < y2) || (y2 < y && y < y1)) {
if (x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) continue;
}
// 当扫描线穿过边时，增加交叉点计数
if (y1 <= y && y < y2) {
crossings++;
}
}
// 如果交叉点数为奇数，则点在多边形内部
return (crossings % 2 != 0);
}
public static void main(String[] args) {
List<Edge> polygonEdges = Arrays.asList(
new Edge(0, 0, 5, 0),
new Edge(5, 0, 5, 5),
new Edge(5, 5, 0, 5),
new Edge(0, 5, 0, 0)
);
boolean result = pointInPolygon(3, 3, polygonEdges);
System.out.println("Point is inside polygon: " + result);
}
}
在上述代码中，我们创建了一个 Edge 类来表示多边形的每条边，然后编写了 pointInPolygon 函数来计算多边形内点的判断逻辑。在主函数 main 中，我们定义了一个简单矩形多边形并测试了一个点是否在多边形内部。
5.2 射线交叉法
5.2.1 基本原理
射线交叉法是一种更为直观的方法，核心思想是从待判断的点出发，向任意方向（通常是水平向右）发出一条射线，然后计算射线与多边形各边的交叉点个数。根据交叉点的奇偶性来判断点是否在多边形内部。如果交叉点个数为奇数，则点在多边形内；如果为偶数，则点在多边形外。
5.2.2 实现步骤与代码示例
以下是使用射线交叉法判断点在多边形内的基本步骤：
- 从待判断的点向右方发出一条射线。
- 遍历多边形的所有边，判断射线与每条边是否相交。
- 计算交叉点的总数。
- 根据交叉点的奇偶性判断点是否在多边形内。
public class PointInPolygonRayCrossing {
static class Point {
double x, y;
Point(double x, double y) {
this.x = x;
this.y = y;
}
}
static class Edge {
Point start, end;
Edge(Point start, Point end) {
this.start = start;
this.end = end;
}
}
static boolean pointInPolygon(Point point, List<Edge> edges) {
int crossings = 0;
double x = point.x;
double y = point.y;
for (Edge edge : edges) {
// 仅当射线与边的x坐标范围相交时才进行计算
if (edge.start.y == edge.end.y) continue;
double x1 = edge.start.x, x2 = edge.end.x, y1 = edge.start.y, y2 = edge.end.y;
// 计算射线是否与边相交
// 交点的x坐标计算公式
double crossX = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
if (x <= crossX) {
crossings++;
}
}
// 如果交叉点数为奇数，则点在多边形内部
return (crossings % 2 != 0);
}
public static void main(String[] args) {
List<Edge> polygonEdges = Arrays.asList(
new Edge(new Point(0, 0), new Point(5, 0)),
new Edge(new Point(5, 0), new Point(5, 5)),
new Edge(new Point(5, 5), new Point(0, 5)),
new Edge(new Point(0, 5), new Point(0, 0))
);
Point testPoint = new Point(3, 3);
boolean result = pointInPolygon(testPoint, polygonEdges);
System.out.println("Point is inside polygon: " + result);
}
}
在上述代码中，我们定义了 Point 类和 Edge 类来表示点和边，然后编写了 pointInPolygon 函数来计算射线交叉法的逻辑。在主函数 main 中，我们同样定义了一个矩形多边形并测试了一个点是否在多边形内部。
这两种方法各有优劣，光栅扫描算法在多边形边数较多时效率更高，而射线交叉法则适用于边数较少、顶点坐标较为简单的情况。在实际应用中，可以根据具体需求和多边形的特性选择合适的算法。
6. MouseListener 和 MouseMotionListener 接口应用
6.1 接口的介绍与使用场景
6.1.1 MouseListener 接口方法说明
MouseListener 接口提供了对鼠标点击事件的处理，它包含五个主要的方法来响应不同的鼠标事件：
void mouseClicked(MouseEvent e);
void mousePressed(MouseEvent e);
void mouseReleased(MouseEvent e);
void mouseEntered(MouseEvent e);
void mouseExited(MouseEvent e);
-
mouseClicked方法：当鼠标按钮被点击时触发，可以获取点击次数。 -
mousePressed方法：当鼠标按钮被按下时触发。 -
mouseReleased方法：当鼠标按钮被释放时触发。 -
mouseEntered方法：当鼠标指针进入到组件的边界时触发。 -
mouseExited方法：当鼠标指针离开组件的边界时触发。
6.1.2 MouseMotionListener 接口方法说明
MouseMotionListener 接口提供了对鼠标移动事件的处理，它包含两个方法：
void mouseDragged(MouseEvent e);
void mouseMoved(MouseEvent e);
-
mouseDragged方法：当鼠标被拖动时触发，通常与鼠标按下事件一起使用。 -
mouseMoved方法：当鼠标指针在组件上移动时触发。
这两个接口的实现对于构建具有交互性的GUI程序至关重要，它们允许开发者针对用户的鼠标行为做出响应，从而实现图形界面的动态交互。
6.2 实际应用案例分析
6.2.1 鼠标监听事件的应用
要使用这些接口，我们需要创建一个类，实现这些接口，并覆盖其方法。例如，一个简单的鼠标监听器可以用于绘制图形或者响应用户的点击：
import java.awt.event.*;
import javax.swing.*;
public class MouseExample extends JFrame implements MouseListener, MouseMotionListener {
public MouseExample() {
this.addMouseListener(this);
this.addMouseMotionListener(this);
this.setSize(400, 400);
}
@Override
public void mouseClicked(MouseEvent e) {
// 在点击处打印坐标
System.out.println("Clicked: " + e.getX() + ", " + e.getY());
}
// 实现其他MouseListener和MouseMotionListener的方法...
public static void main(String[] args) {
MouseExample frame = new MouseExample();
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
在上面的例子中，当用户点击窗口时，程序会在控制台打印出鼠标的坐标位置。这是通过 MouseListener 接口的 mouseClicked 方法实现的。
6.2.2 鼠标移动事件的应用
MouseMotionListener 接口可以用来检测鼠标在组件内的移动。这对于创建具有动态视觉反馈的GUI很有用。例如，我们可以在鼠标移动时改变鼠标指针下的颜色，或者绘制出鼠标移动的轨迹。
@Override
public void mouseMoved(MouseEvent e) {
// 设置鼠标移动到的组件内位置的颜色
repaint(e.getX(), e.getY(), 1, 1);
}
@Override
public void mouseDragged(MouseEvent e) {
// 绘制鼠标拖动的轨迹
repaint(e.getX(), e.getY(), 1, 1);
}
在上述代码中， mouseMoved 和 mouseDragged 方法都调用了 repaint 方法，后者将触发 paintComponent 方法的调用。因此，我们可以在 paintComponent 方法中实现具体的绘制逻辑。
@Override
protected void paintComponent(Graphics g) {
// 绘制背景
g.clearRect(0, 0, getWidth(), getHeight());
// 绘制鼠标当前位置的颜色
g.setColor(Color.BLUE);
g.fillOval(e.getX(), e.getY(), 10, 10);
}
这个简单的例子展示了如何使用鼠标监听接口来创建一个在鼠标移动时在窗口中绘制小圆点的程序。这种类型的应用程序可以扩展到各种交互式应用程序，例如绘画程序或图形编辑器。
7. paintComponent(Graphics g) 方法重写
在Java中， paintComponent 是一个关键方法，用于绘制组件。对于继承自 JPanel 的类来说，这个方法尤为重要，因为它是绘图的主要入口。通过重写这个方法，开发者能够自定义组件的显示效果，实现丰富的图形界面。
7.1 方法重写的必要性与原理
7.1.1 paintComponent 的作用与重要性
paintComponent 方法在 Swing 组件中提供了一个可以被开发者自定义的画布（Canvas）。当需要绘制组件时，Swing 框架会调用这个方法。这个方法提供了一个 Graphics 对象作为参数，它是一个接口，允许我们与渲染上下文进行交互，执行绘制任务。
7.1.2 方法重写的基本要求
为了确保组件的正确绘制，我们需要遵守几个重写 paintComponent 的基本原则： - 调用父类的 paintComponent 方法，通常这个方法内部会调用 super.paintComponent(g) ，以确保组件的背景和其他基础设置被正确绘制。 - 不要直接调用 paintComponent 方法。应该让它由Swing框架根据需要调用。 - 在 Graphics 对象上进行操作时，应该考虑到性能问题，例如，避免在重绘时重新创建资源。
7.2 综合实践：绘制交互式图形界面
7.2.1 实现交互式图形绘制
下面是一个简单的例子，通过重写 paintComponent 方法，在一个 JPanel 中绘制一个蓝色的矩形，这个矩形会响应窗口大小的变化：
import javax.swing.*;
import java.awt.*;
public class CustomPanel extends JPanel {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.BLUE);
g.fillRect(10, 10, getWidth() - 20, getHeight() - 20);
}
}
将这个自定义的 JPanel 添加到一个 JFrame 中，并且设置合适的大小和默认关闭操作：
public class InteractiveGraphicsDemo extends JFrame {
public InteractiveGraphicsDemo() {
CustomPanel customPanel = new CustomPanel();
this.add(customPanel);
this.setSize(400, 300);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(InteractiveGraphicsDemo::new);
}
}
这段代码将创建一个窗口，窗口中会显示一个蓝色的矩形，并且这个矩形会随着窗口的大小调整而自动调整大小。
7.2.2 结合监听器增强界面功能
为了使图形界面更加交互式，可以结合使用监听器，例如 MouseListener ，来响应用户的点击事件，并根据用户的操作改变绘制内容。下面的代码展示了如何为上面创建的面板添加鼠标监听器，以便在用户点击面板时在面板上绘制一个红色的点：
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
// ...（前面的代码保持不变）
public class CustomPanel extends JPanel {
private Point lastClickedPoint = null;
public CustomPanel() {
this.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
lastClickedPoint = e.getPoint();
repaint(); // 请求重绘组件
}
});
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.BLUE);
g.fillRect(10, 10, getWidth() - 20, getHeight() - 20);
if (lastClickedPoint != null) {
g.setColor(Color.RED);
g.fillOval(lastClickedPoint.x, lastClickedPoint.y, 10, 10);
}
}
}
这段代码中， MouseListener 监听器会捕捉到鼠标点击事件，并在面板上记录点击的位置。然后， paintComponent 方法会在绘制蓝色矩形的同时，也在记录的点上绘制一个红色的圆形。通过这种方式，可以不断地在面板上增加新的点，实现一个简单的交互式绘图应用程序。
简介：在Java中，"paintDemo2_java_点与多边形_"展示了一个图形用户界面(GUI)编程示例，它演示了如何通过鼠标事件处理和图形绘制来追踪并绘制多边形，并判断点是否在多边形内部。通过实现监听鼠标事件的 DrawListener.java 类和包含绘图功能的 DramFrame.java 主窗口类，以及采用几何算法来判断点的位置，这个项目为学习Java图形界面编程和图形算法提供了基础。
扫一扫
1107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
