58、Java 中的鼠标事件处理、定时器对象与音频播放

Java 中的鼠标事件处理、定时器对象与音频播放

1. 鼠标事件处理

在 Java 里，能够创建监听器类来处理鼠标生成的事件。鼠标会产生两种类型的事件，即鼠标事件和鼠标移动事件。

1.1 鼠标事件监听器

要处理鼠标事件，需创建鼠标监听器类。该类能响应以下事件：
- 鼠标按钮被按下。
- 鼠标按钮被释放。
- 鼠标按钮被点击（按下后不移动鼠标再释放）。
- 鼠标光标进入组件的屏幕空间。
- 鼠标光标离开组件的屏幕空间。

鼠标监听器类必须实现 MouseListener 接口，此接口位于 java.awt.event 包中。该类还需具备表 1 所列的方法：

方法	描述
public void mousePressed(MouseEvent e)	当鼠标光标位于组件上方且鼠标按钮被按下时，调用此方法。
public void mouseClicked(MouseEvent e)	鼠标点击定义为按下鼠标按钮并在不移动鼠标的情况下释放。当鼠标光标位于组件上方且鼠标被点击时，调用此方法。
public void mouseReleased(MouseEvent e)	鼠标按钮按下后释放时调用此方法， mousePressed 方法总是在此方法之前被调用。
public void mouseEntered(MouseEvent e)	鼠标光标进入组件所属的屏幕区域时调用此方法。
public void mouseExited(MouseEvent e)	鼠标光标离开组件所属的屏幕区域时调用此方法。

每个方法都接受一个 MouseEvent 对象作为参数，该对象包含有关鼠标事件的数据。可使用 MouseEvent 对象的 getX 和 getY 方法，它们会返回事件发生时鼠标光标的 X 和 Y 坐标。

创建鼠标监听器类后，可使用从 Component 类继承的 addMouseListener 方法将其注册到组件上。当相应的鼠标事件发生时，鼠标监听器类中的适当方法会自动被调用。

以下是一个简单的鼠标事件监听器示例：

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

public class MouseEvents extends JApplet {
    private JTextField[] mouseStates;
    private String[] text = {
            "Pressed", "Clicked", "Released",
            "Entered", "Exited", "Dragged",
            "X:", "Y:"
    };

    public void init() {
        setLayout(new FlowLayout());
        mouseStates = new JTextField[8];
        for (int i = 0; i < mouseStates.length; i++) {
            mouseStates[i] = new JTextField(text[i], 10);
            mouseStates[i].setEditable(false);
            add(mouseStates[i]);
        }
        addMouseListener(new MyMouseListener());
        addMouseMotionListener(new MyMouseMotionListener());
    }

    public void clearTextFields() {
        for (int i = 0; i < 6; i++) {
            mouseStates[i].setBackground(Color.lightGray);
        }
    }

    private class MyMouseListener implements MouseListener {
        public void mousePressed(MouseEvent e) {
            clearTextFields();
            mouseStates[0].setBackground(Color.yellow);
        }

        public void mouseClicked(MouseEvent e) {
            clearTextFields();
            mouseStates[1].setBackground(Color.yellow);
        }

        public void mouseReleased(MouseEvent e) {
            clearTextFields();
            mouseStates[2].setBackground(Color.yellow);
        }

        public void mouseEntered(MouseEvent e) {
            clearTextFields();
            mouseStates[3].setBackground(Color.yellow);
        }

        public void mouseExited(MouseEvent e) {
            clearTextFields();
            mouseStates[4].setBackground(Color.yellow);
        }
    }
}

1.2 鼠标移动事件监听器

鼠标移动事件监听器类能响应以下事件：
- 鼠标被拖动（按下按钮并在按住按钮的同时移动鼠标）。
- 鼠标被移动。

鼠标移动事件监听器类必须实现 MouseMotionListener 接口，此接口位于 java.awt.event 包中。该类还需具备表 2 所列的方法：

方法	描述
public void mouseDragged(MouseEvent e)	当鼠标按钮被按下并在按住按钮的同时移动鼠标时，鼠标被拖动。当在组件上开始拖动操作时，调用此方法， mousePressed 方法总是在此方法之前被调用。
public void mouseMoved(MouseEvent e)	当鼠标光标位于组件上方且被移动时，调用此方法。

创建鼠标移动事件监听器类后，可使用从 Component 类继承的 addMouseMotionListener 方法将其注册到组件上。当相应的鼠标事件发生时，鼠标移动事件监听器类中的适当方法会自动被调用。

在上述 MouseEvents 类中，添加鼠标移动事件监听器的代码如下：

private class MyMouseMotionListener implements MouseMotionListener {
    public void mouseDragged(MouseEvent e) {
        clearTextFields();
        mouseStates[5].setBackground(Color.yellow);
    }

    public void mouseMoved(MouseEvent e) {
        mouseStates[6].setText("X: " + e.getX());
        mouseStates[7].setText("Y: " + e.getY());
    }
}

1.3 使用适配器类

很多时候处理鼠标事件时，并非对鼠标生成的每个事件都感兴趣。例如 DrawBoxes 小程序，它只处理鼠标按下和鼠标拖动事件。

在实现监听器类时，如果实现 MouseListener 或 MouseMotionListener 接口，即使有些方法不需要使用，也必须提供空的方法定义，否则会导致编译错误。

Java API 提供了一种替代技术，可通过继承 MouseAdapter 或 MouseMotionAdapter 类来创建监听器类，从而避免为不感兴趣的事件定义空方法。这些类实现了 MouseListener 和 MouseMotionListener 接口，并为所有必需的方法提供了空定义。当从这些适配器类扩展一个类时，它会继承这些空方法，在扩展类中可重写所需的方法，而忽略其他方法。 MouseAdapter 和 MouseMotionAdapter 类都位于 java.awt.event 包中。

以下是 DrawBoxes2 类的示例代码：

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

public class DrawBoxes2 extends JApplet {
    private int currentX = 0;
    private int currentY = 0;
    private int width = 0;
    private int height = 0;

    public void init() {
        addMouseListener(new MyMouseListener());
        addMouseMotionListener(new MyMouseMotionListener());
    }

    public void paint(Graphics g) {
        super.paint(g);
        g.drawRect(currentX, currentY, width, height);
    }

    private class MyMouseListener extends MouseAdapter {
        public void mousePressed(MouseEvent e) {
            currentX = e.getX();
            currentY = e.getY();
        }
    }

    private class MyMouseMotionListener extends MouseMotionAdapter {
        public void mouseDragged(MouseEvent e) {
            width = e.getX() - currentX;
            height = e.getY() - currentY;
            repaint();
        }
    }
}

2. 定时器对象

定时器对象能按照程序员指定的时间间隔定期生成动作事件。这在希望程序在特定时间或经过一定时间后执行操作时非常有用。

定时器对象由 javax.swing 包中的 Timer 类创建。 Timer 类构造函数的一般格式如下：

Timer(int delay, ActionListener listener)

• delay 参数传入的是动作事件之间的时间间隔，以毫秒为单位。例如， delay 值为 1000 会使动作事件每秒生成一次。
• listener 参数传入的是要注册到 Timer 对象的动作监听器的引用。若想稍后添加动作监听器，可将此参数设为 null ，然后使用 Timer 对象的 addActionListener 方法注册动作监听器。

Timer 类的方法如下表 3 所示：

方法	描述
void addActionListener(ActionListener listener)	将 listener 引用的对象注册为动作监听器。
int getDelay()	返回当前的时间延迟（以毫秒为单位）。
Boolean isRunning()	如果 Timer 对象正在运行，则返回 true ，否则返回 false 。
void setDelay(int delay)	设置时间延迟，参数是延迟的毫秒数。
void start()	启动 Timer 对象，使其开始生成动作事件。
void stop()	停止 Timer 对象，使其停止生成动作事件。

以下是一个使用定时器对象实现小球弹跳动画的示例：

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

public class BouncingBall extends JApplet {
    private final int X = 109;
    private final int WIDTH = 40;
    private final int HEIGHT = 40;
    private final int TIME_DELAY = 30;
    private final int MOVE = 20;
    private final int MINIMUM_Y = 50;
    private final int MAXIMUM_Y = 400;
    private int y = 400;
    private boolean goingUp = true;
    private Timer timer;

    public void init() {
        timer = new Timer(TIME_DELAY, new TimerListener());
        timer.start();
    }

    public void paint(Graphics g) {
        super.paint(g);
        g.setColor(Color.red);
        g.fillOval(X, y, WIDTH, HEIGHT);
    }

    private class TimerListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (goingUp) {
                if (y > MINIMUM_Y) {
                    y -= MOVE;
                } else {
                    goingUp = false;
                }
            } else {
                if (y < MAXIMUM_Y) {
                    y += MOVE;
                } else {
                    goingUp = true;
                }
            }
            repaint();
        }
    }
}

3. 音频播放

Java 小程序可以播放存储在多种流行声音文件格式中的音频。直接支持的文件格式如下：
- .aif 或 .aiff （Macintosh 音频文件）
- .au （Sun 音频文件）
- .mid 或 .rmi （MIDI 文件）
- .wav （Windows 波形文件）

要播放音频文件，计算机必须配备声卡和扬声器。

3.1 使用 play 方法

一种播放音频文件的方法是使用 JApplet 类从 Applet 类继承的 play 方法，其格式如下：

void play(URL baseLocation, String fileName)

• baseLocation 参数传入的是指定文件位置的 URL 对象。
• fileName 参数传入的是文件的名称。文件中录制的声音将播放一次。

调用 play 方法时，通常使用 getDocumentBase 或 getCodeBase 方法（ JApplet 类从 Applet 类继承）来获取第一个参数的 URL 对象。例如：

play(getDocumentBase(), "mysound.wav");

此语句将加载并播放与调用小程序的 HTML 文件位于同一位置的 mysound.wav 声音文件。

3.2 使用 AudioClip 对象

Applet 类的 play 方法会加载声音文件，播放一次后将其释放以进行垃圾回收。若需要加载声音文件并多次播放，应使用 AudioClip 对象。

AudioClip 对象实现了 AudioClip 接口，该接口位于 java.applet 包中，它指定了以下三个方法：
- play() ：播放声音一次。
- loop() ：重复播放声音。
- stop() ：停止声音播放。

可使用 Applet 类的 getAudioClip 方法为给定的声音文件创建 AudioClip 对象，如下所示：

AudioClip getAudioClip(URL baseLocation, String fileName)

以下是一个使用 AudioClip 对象的示例代码：

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

public class AudioDemo2 extends JApplet {
    private JLabel credit;
    private JButton playButton;
    private JButton loopButton;
    private JButton stopButton;
    private AudioClip sound;

    public void init() {
        setLayout(new FlowLayout());
        credit = new JLabel("Audio source: NASA");
        add(credit);
        makeButtons();
        sound = getAudioClip(getDocumentBase(), "step.wav");
    }

    private void makeButtons() {
        playButton = new JButton("Play");
        loopButton = new JButton("Loop");
        stopButton = new JButton("Stop");
        playButton.addActionListener(new ButtonListener());
        loopButton.addActionListener(new ButtonListener());
        stopButton.addActionListener(new ButtonListener());
        add(playButton);
        add(loopButton);
        add(stopButton);
    }

    private class ButtonListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (e.getSource() == playButton) {
                sound.play();
            } else if (e.getSource() == loopButton) {
                sound.loop();
            } else if (e.getSource() == stopButton) {
                sound.stop();
            }
        }
    }
}

3.3 在应用程序中播放音频

在不扩展 JApplet 的类中，获取 AudioClip 对象引用的过程有所不同。以下是一个 Swing 应用程序的示例代码：

import java.io.File;
import java.applet.Applet;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;

// 假设在某个类中
File file = new File("step.wav");
URI uri = file.toURI();
try {
    URL url = uri.toURL();
    AudioClip sound = Applet.newAudioClip(url);
    // 可以使用 sound 进行播放操作
    sound.play();
} catch (MalformedURLException e) {
    e.printStackTrace();
}

此代码首先创建一个 File 对象表示音频文件，然后调用 File 类的 toURI 方法创建一个 URI 对象表示音频文件，接着调用 URI 类的 toURL 方法创建一个 URL 对象表示音频文件。最后，调用 Applet 类的静态 newAudioClip 方法，传入 URL 对象作为参数，返回一个 AudioClip 对象引用，可用于播放音频文件。

综上所述，Java 提供了丰富的功能来处理鼠标事件、使用定时器对象和播放音频，通过合理运用这些功能，可以开发出交互性强、功能丰富的应用程序。

Java 中的鼠标事件处理、定时器对象与音频播放

4. 技术要点总结与应用场景分析

4.1 鼠标事件处理的要点与应用

鼠标事件处理是 Java 图形用户界面编程中的重要部分，它能让程序与用户的鼠标操作进行交互。

• 要点总结

  • 鼠标事件分为普通鼠标事件（如按下、释放、点击、进入、离开）和鼠标移动事件（拖动、移动）。
  • 处理鼠标事件需实现 MouseListener 或 MouseMotionListener 接口，若只关注部分事件，可使用 MouseAdapter 或 MouseMotionAdapter 类简化代码。
  • 注册监听器使用 addMouseListener 和 addMouseMotionListener 方法。
  • MouseEvent 对象包含鼠标事件的相关信息，可通过 getX 和 getY 方法获取鼠标位置。

• 应用场景

  • 游戏开发 ：在游戏中，鼠标点击可触发角色的动作，鼠标拖动可实现视角的移动或物体的拖动。例如，在策略游戏中，玩家可以通过鼠标点击选择单位，拖动鼠标来移动地图视角。
  • 绘图软件 ：绘图软件中，鼠标按下和拖动可绘制图形，鼠标移动可实时显示绘制的预览效果。如常见的画图工具，用户可以使用鼠标绘制线条、矩形、圆形等图形。

4.2 定时器对象的要点与应用

定时器对象为 Java 程序提供了定时执行任务的功能。

• 要点总结

  • 定时器对象由 javax.swing 包中的 Timer 类创建，构造函数需传入延迟时间和动作监听器。
  • 可使用 addActionListener 方法注册动作监听器，使用 start 和 stop 方法控制定时器的启动和停止。
  • 定时器会按照指定的时间间隔生成动作事件，触发监听器的 actionPerformed 方法。

• 应用场景

  • 动画效果 ：通过定时器定期更新图形的位置或状态，实现动画效果。如前面提到的 BouncingBall 小程序，定时器不断更新小球的位置，使其呈现出弹跳的动画效果。
  • 定时任务 ：在一些应用中，需要定时执行某些任务，如定时保存数据、定时检查网络连接等。例如，一个文本编辑器可以使用定时器每隔一段时间自动保存用户的编辑内容。

4.3 音频播放的要点与应用

Java 提供了多种方式来播放音频文件，满足不同的需求。

• 要点总结

  • 支持多种常见的音频文件格式，如 .aif 、 .au 、 .mid 、 .wav 等。
  • 可使用 play 方法播放音频文件一次，使用 AudioClip 对象可多次播放音频。
  • 在应用程序中获取 AudioClip 对象的过程与在小程序中有所不同，需要通过 File 、 URI 和 URL 对象来实现。

• 应用场景

  • 游戏音效 ：在游戏中添加各种音效，如角色的攻击声、背景音乐等，增强游戏的沉浸感。例如，在射击游戏中，玩家开枪时会播放相应的枪声音效。
  • 多媒体应用 ：开发多媒体播放器、语音提示系统等应用。如一个语音导航系统，会根据用户的操作和位置播放相应的语音提示。

5. 操作流程梳理

5.1 鼠标事件处理操作流程

graph TD;
    A[创建鼠标监听器类] --> B{实现接口};
    B -- 普通鼠标事件 --> C[实现 MouseListener 接口];
    B -- 鼠标移动事件 --> D[实现 MouseMotionListener 接口];
    C --> E[重写接口方法];
    D --> E;
    E --> F[创建组件];
    F --> G[注册监听器];
    G -- 普通鼠标事件 --> H[使用 addMouseListener 方法];
    G -- 鼠标移动事件 --> I[使用 addMouseMotionListener 方法];
    H --> J[等待鼠标事件触发];
    I --> J;
    J --> K[执行相应方法];

具体步骤如下：
1. 创建鼠标监听器类，根据需求实现 MouseListener 或 MouseMotionListener 接口。
2. 重写接口中的方法，处理相应的鼠标事件。
3. 创建需要监听鼠标事件的组件，如 JApplet 或其他图形组件。
4. 使用 addMouseListener 或 addMouseMotionListener 方法将监听器注册到组件上。
5. 等待鼠标事件触发，当事件发生时，监听器中的相应方法会自动执行。

5.2 定时器对象操作流程

graph TD;
    A[创建 Timer 对象] --> B[设置延迟时间和动作监听器];
    B --> C[启动定时器];
    C --> D[定时器按间隔生成动作事件];
    D --> E[触发监听器的 actionPerformed 方法];
    E --> F[执行相应任务];
    F --> G{是否停止定时器};
    G -- 是 --> H[调用 stop 方法停止定时器];
    G -- 否 --> D;

具体步骤如下：
1. 创建 Timer 对象，传入延迟时间和动作监听器。
2. 调用 start 方法启动定时器。
3. 定时器会按照指定的时间间隔生成动作事件，触发监听器的 actionPerformed 方法。
4. 在 actionPerformed 方法中编写需要定时执行的任务。
5. 根据需要，调用 stop 方法停止定时器。

5.3 音频播放操作流程

使用 play 方法播放音频

graph TD;
    A[获取文件位置的 URL 对象] --> B{获取方式};
    B -- getDocumentBase --> C[获取 HTML 文件位置的 URL];
    B -- getCodeBase --> D[获取 applet 类文件位置的 URL];
    C --> E[调用 play 方法];
    D --> E;
    E --> F[传入文件名称];
    F --> G[播放音频文件];

具体步骤如下：
1. 使用 getDocumentBase 或 getCodeBase 方法获取文件位置的 URL 对象。
2. 调用 play 方法，传入 URL 对象和文件名称。
3. 文件中录制的声音将播放一次。

使用 AudioClip 对象播放音频

graph TD;
    A[获取文件位置的 URL 对象] --> B{获取方式};
    B -- getDocumentBase --> C[获取 HTML 文件位置的 URL];
    B -- getCodeBase --> D[获取 applet 类文件位置的 URL];
    C --> E[调用 getAudioClip 方法];
    D --> E;
    E --> F[传入文件名称];
    F --> G[获取 AudioClip 对象];
    G --> H{操作类型};
    H -- 播放一次 --> I[调用 play 方法];
    H -- 循环播放 --> J[调用 loop 方法];
    H -- 停止播放 --> K[调用 stop 方法];

具体步骤如下：
1. 使用 getDocumentBase 或 getCodeBase 方法获取文件位置的 URL 对象。
2. 调用 getAudioClip 方法，传入 URL 对象和文件名称，获取 AudioClip 对象。
3. 根据需要，调用 play 方法播放一次音频，调用 loop 方法循环播放音频，调用 stop 方法停止播放音频。

在应用程序中播放音频

graph TD;
    A[创建 File 对象] --> B[表示音频文件];
    B --> C[调用 toURI 方法];
    C --> D[创建 URI 对象];
    D --> E[调用 toURL 方法];
    E --> F{是否成功创建 URL 对象};
    F -- 是 --> G[调用 Applet.newAudioClip 方法];
    F -- 否 --> H[处理 MalformedURLException 异常];
    G --> I[获取 AudioClip 对象];
    I --> J{操作类型};
    J -- 播放一次 --> K[调用 play 方法];
    J -- 循环播放 --> L[调用 loop 方法];
    J -- 停止播放 --> M[调用 stop 方法];

具体步骤如下：
1. 创建 File 对象表示音频文件。
2. 调用 File 类的 toURI 方法创建 URI 对象。
3. 调用 URI 类的 toURL 方法创建 URL 对象，可能会抛出 MalformedURLException 异常，需要进行异常处理。
4. 调用 Applet 类的静态 newAudioClip 方法，传入 URL 对象，获取 AudioClip 对象。
5. 根据需要，调用 play 方法播放一次音频，调用 loop 方法循环播放音频，调用 stop 方法停止播放音频。

6. 常见问题与解决方案

6.1 鼠标事件处理中的问题

• 问题 ：实现 MouseListener 或 MouseMotionListener 接口时，忘记重写某些方法，导致编译错误。

• 解决方案 ：使用 MouseAdapter 或 MouseMotionAdapter 类，只重写需要的方法，避免编写空方法。

• 问题 ：监听器未正确注册，导致鼠标事件无法触发。

• 解决方案 ：检查 addMouseListener 和 addMouseMotionListener 方法是否正确调用，确保监听器对象已正确传递给这些方法。

6.2 定时器对象使用中的问题

• 问题 ：定时器未按预期时间间隔触发事件。

• 解决方案 ：检查 Timer 构造函数中传入的延迟时间是否正确，确保时间单位为毫秒。同时，检查定时器是否已调用 start 方法启动。

• 问题 ：定时器启动后无法停止。

• 解决方案 ：检查是否正确调用了 stop 方法，确保调用该方法的对象与启动定时器的对象是同一个。

6.3 音频播放中的问题

• 问题 ：音频文件无法播放。

• 解决方案 ：检查文件路径是否正确，文件格式是否支持，计算机是否配备声卡和扬声器。如果使用 play 或 getAudioClip 方法，确保传入的 URL 对象和文件名称正确。

• 问题 ：在应用程序中获取 AudioClip 对象时抛出 MalformedURLException 异常。

• 解决方案 ：检查 URI 对象转换为 URL 对象的过程中， URI 是否合法。在调用 toURL 方法时，进行异常处理，确保程序的健壮性。

通过对 Java 中鼠标事件处理、定时器对象和音频播放的学习和实践，我们可以开发出更加丰富、交互性强的应用程序。在实际开发中，要根据具体的需求选择合适的技术和方法，同时注意解决可能出现的问题，提高程序的稳定性和可靠性。