60、Java 中的图像、声音处理与动画编程

Java 中的图像、声音处理与动画编程

1. 图像的使用

在 Java 中，我们可以创建同时包含文本和图标的按钮，例如：

openButton = new JButton("Open", openIcon);

1.1 在 applet 中使用 ImageIcon

如果程序是一个 applet，需要使用 URL 而不是文件名来标识图像文件。获取与 applet 位于同一位置的文件的 URL 可以使用如下代码：

URL url = PictureApplet.class.getResource("HalfDome.jpg");

获取 URL 后，可以创建 ImageIcon 对象：

pic = new ImageIcon(url);

之后，就可以在标签或按钮组件中使用这个 ImageIcon 对象，也可以使用 getImage 方法获取底层的 Image 对象，以便直接将其绘制到屏幕上。

1.2 使用 Image 类

若要将图像直接绘制到图形上下文中（例如，在面板的 paintComponent 方法中），需要使用 Image 类来表示图像。要在面板构造函数中创建 Image 对象，在 paintComponent 方法中绘制它。因此，需要将引用图像的变量声明为实例变量，示例如下：

Image img;

下面是处理 Image 对象的类的重要构造函数和方法：
| 类 | 方法和字段 | 描述 |
| ---- | ---- | ---- |
| Image 类 | Image getScaledInstance(int x, int y, int hints) | 根据 x 和 y 参数缩放图像。如果 x 或 y 为负，则保留图像的宽高比。hint 参数可以是 DEFAULT、SPEED 或 SMOOTH。 |
| | int DEFAULT | 默认缩放方法。 |
| | int SPEED | 优先考虑速度而非平滑度的缩放方法。 |
| | int SMOOTH | 优先考虑平滑度而非速度的缩放方法。 |
| Toolkit 类 | static Toolkit getDefaultToolkit() | 获取一个 Toolkit 对象。 |
| | Image getImage(String filename) | 从指定的文件名加载 Image 对象。 |
| Graphics 类 | void drawImage(Image img, int x, int y, ImageObserver observer) | 在指定的 x 和 y 坐标处绘制指定的图像。observer 参数指定监听图像更新事件的对象。 |
| | void drawImage(Image img, int x, int y, int width, int height, ImageObserver observer) | 在指定的 x 和 y 坐标处，使用指定的宽度和高度绘制指定的图像。observer 参数指定监听图像更新事件的对象。 |

创建 Image 对象有两种简单的方法：
- 使用 ImageIcon 类 ：

ImageIcon picIcon = new ImageIcon("c:\\HalfDome.jpg");
Image picImage = picIcon.getImage();

这段代码应放在面板构造函数中，以确保只执行一次。
- 使用 Toolkit 类 ：

Toolkit kit = Toolkit.getDefaultToolkit();
img = kit.getImage("HalfDome.jpg");

同样，这段代码也应放在面板构造函数中，避免每次绘制图像时都重新加载。

如果只加载单个小图像，两种技术都适用。如果要加载大量图像或图像较大，使用 Toolkit 技术更好，原因有二：一是避免创建大量不必要的 ImageIcon 对象；二是不会在整个图像加载完成之前占用应用程序。

绘制 Image 对象可以在 paint 方法中添加代码：

g.drawImage(img, 0, 0, this);

drawImage 方法有四个参数，前三个分别是要绘制的图像以及图像要出现的 x 和 y 坐标，第四个参数是实现 ImageObserver 接口的对象。

还有另一种形式的 drawImage 方法可以设置图像的绘制大小：

g.drawImage(img, 0, 0, 200, 200, this);

不过，这可能会导致图像失真。更好的缩放图像的方法是调用图像的 getScaledInstance 方法：

img = img.getScaledInstance(200, -1, Image.SCALE_DEFAULT);

下面是一个完整的使用 Image 类在面板中显示图像的程序示例：

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

public class PictureFrame extends JFrame implements ActionListener {
    Image img;
    JButton getPictureButton;

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

    public PictureFrame() {
        this.setSize(300, 300);
        this.setTitle("Picture Frame Application");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel picPanel = new PicturePanel();
        this.add(picPanel, BorderLayout.CENTER);
        JPanel buttonPanel = new JPanel();
        getPictureButton = new JButton("Get Picture");
        getPictureButton.addActionListener(this);
        buttonPanel.add(getPictureButton);
        this.add(buttonPanel, BorderLayout.SOUTH);
        this.setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        String file = getImageFile();
        if (file != null) {
            Toolkit kit = Toolkit.getDefaultToolkit();
            img = kit.getImage(file);
            img = img.getScaledInstance(300, -1, Image.SCALE_SMOOTH);
            this.repaint();
        }
    }

    private String getImageFile() {
        JFileChooser fc = new JFileChooser();
        fc.setFileFilter(new ImageFilter());
        int result = fc.showOpenDialog(null);
        File file = null;
        if (result == JFileChooser.APPROVE_OPTION) {
            file = fc.getSelectedFile();
            return file.getPath();
        } else {
            return null;
        }
    }

    private class PicturePanel extends JPanel {
        public void paint(Graphics g) {
            g.drawImage(img, 0, 0, this);
        }
    }

    private class ImageFilter extends javax.swing.filechooser.FileFilter {
        public boolean accept(File f) {
            if (f.isDirectory()) {
                return true;
            }
            String name = f.getName();
            if (name.matches(".*((.jpg)|(.gif)|(.png))")) {
                return true;
            } else {
                return false;
            }
        }

        public String getDescription() {
            return "Image files (*.jpg, *.gif, *.png)";
        }
    }
}

这个程序的主要步骤如下：
1. 声明 img 变量，以便类可以访问它。
2. 在框架类构造函数中，创建一个 PicturePanel 类的新实例，并将其添加到框架的中心。
3. 创建一个面板来放置用户点击以打开图像文件的按钮，并将该面板添加到框架的南部。
4. 当用户点击 “Get Picture” 按钮时，调用 actionPerformed 方法。该方法调用 getImageFile 方法显示文件选择器，并返回用户选择的文件的文件名。若文件名不为空，则使用 Toolkit 类加载图像，缩放图像并重新绘制框架。
5. getImageFile 方法创建并显示一个只显示 .jpg、.gif 和 .png 文件的文件选择器对话框。如果用户选择了文件，则返回文件的完整路径；否则返回 null。
6. PicturePanel 类定义了显示图片的面板，其 paint 方法使用 drawImage 方法绘制图像。
7. ImageFilter 类用于限制文件选择器只显示 .jpg、.gif 和 .png 文件。

2. 声音的播放

Java 提供了对播放声音和音乐文件的内置支持，可以播放多种格式的声音和音乐文件，包括多种格式的波形文件（WAV、AU、RMF 和 AIFF）以及 MIDI 文件。波形文件通常用于为应用程序添加特定的音效，MIDI 文件可在应用程序运行时播放音乐。

音频文件由实现 AudioClip 接口的对象表示，该接口的方法如下：
| 方法 | 描述 |
| ---- | ---- |
| void play() | 播放一次音频剪辑。 |
| void loop() | 循环播放音频剪辑。 |
| void stop() | 停止播放音频剪辑。 |

创建 AudioClip 对象最简单的方法是使用 Applet 类的静态方法 newAudioClip 。该方法需要一个 URL，而不是简单的文件名，因此必须先获取要播放的声音文件的 URL。示例代码如下：

URL url = MyApp.class.getResource("hit.wav");
click = Applet.newAudioClip(url);
click.play();

下面是一个每次在程序框架中点击鼠标时播放 hit.wav 声音的程序：

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

public class MouseClicker extends JFrame {
    AudioClip click;

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

    public MouseClicker() {
        this.setSize(400, 400);
        this.setTitle("Mouse Clicker");
        this.addMouseListener(new Clicker());
        URL urlClick = MouseClicker.class.getResource("hit.wav");
        click = Applet.newAudioClip(urlClick);
        this.setVisible(true);
    }

    private class Clicker extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {
            click.play();
        }
    }
}

这个程序的主要步骤如下：
1. 声明 AudioClip 类型的 click 变量。
2. 在构造函数中设置框架的大小和标题，添加鼠标监听器，获取声音文件的 URL，创建 AudioClip 对象并显示框架。
3. 当鼠标点击时， mouseClicked 方法被调用，播放声音。

3. 动画编程

在 Java 中，由于其强大的绘图功能，非常适合创建游戏程序，尤其是作为 applet 创建的游戏，以便可以通过互联网播放。

3.1 精灵动画的基本原理

在动画和游戏编程中，在屏幕上移动的对象通常称为精灵。精灵可以通过多种方式绘制。如果精灵是简单的几何形状（如圆形），可以创建 Ellipse2D 对象并使用 draw 或 fill 方法进行渲染；更常见的是，精灵由小图像表示，使用 drawImage 方法进行渲染。

在某些情况下，精灵可能关联有一系列图像。例如，如果精灵是一个在游戏世界中行走的小人，可能有几个图像表示他向左或向右行走，或者处于不同的行走阶段。可以将这些图像放在数组中，并使用索引变量来跟踪要绘制的图像。

在 Java 中为精灵制作动画的基本技术是相同的：创建一个线程，定期重新绘制绘图组件，然后每次重新绘制组件时计算精灵的新位置，并在新位置绘制精灵。

假设要创建一个从组件左侧移动到右侧的球，需要完成以下步骤：
1. 创建绘制球的组件，通常该组件可以继承 JComponent。
2. 创建一个线程，其 run 方法包含一个循环。在循环内，调用 sleep 方法休眠一小段时间（通常为 10 或 20 毫秒），然后调用绘图组件的 repaint 方法。为了方便，可以让绘图组件不仅继承 JComponent，还实现 Runnable 接口，这样可以将 run 方法作为绘图组件类的成员。
3. 在 paint 方法中，重新计算每个要动画的形状的位置，然后绘制它。
4. 为了启动动画，创建绘图组件的实例并将其添加到框架或 applet 中。然后，将该实例传递给 Thread 类的构造函数以创建 Thread 对象。最后，调用 Thread 对象的 start 方法。

下面是一个动画移动球的 applet 程序示例：

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

public class BallRoom extends JApplet {
    private final int WIDTH = 350;
    private final int HEIGHT = 300;
    private PaintSurface canvas;

    public void init() {
        this.setSize(WIDTH, HEIGHT);
        canvas = new PaintSurface();
        this.add(canvas, BorderLayout.CENTER);
        Thread t = new AnimationThread(this);
        t.start();
    }
}

class AnimationThread extends Thread {
    JApplet c;

    public AnimationThread(JApplet c) {
        this.c = c;
    }

    public void run() {
        while (true) {
            c.repaint();
            try {
                Thread.sleep(20);
            } catch (InterruptedException ex) {
                // 忽略异常
            }
        }
    }
}

class PaintSurface extends JComponent {
    int x_pos = 0;     // 起始 X 位置
    int y_pos = 150;   // 起始 Y 位置
    int d = 20;        // 球的直径

    public void paint(Graphics g) {
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(
            RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
        x_pos += 1;    // 球向右移动一个像素
        Shape ball = new Ellipse2D.Float(
            x_pos, y_pos, d, d);
        g2.setColor(Color.RED);
        g2.fill(ball);
    }
}

这个程序的主要步骤如下：
1. BallRoom 类继承 JApplet ，定义了宽度和高度常量，以及一个 PaintSurface 类型的 canvas 变量，用于绘制动画球。
2. init 方法在 applet 启动时调用，设置 applet 的大小，创建 PaintSurface 类的实例并将其添加到 applet 中，创建一个 AnimationThread 线程并启动它。
3. AnimationThread 类定义了用于动画球的线程，其 run 方法包含一个无限循环，定期重新绘制 applet，并在每次循环中休眠 20 毫秒。
4. PaintSurface 类定义了绘制球的面板，其 paint 方法计算球的新位置并绘制球。

这个程序的流程可以用 mermaid 流程图表示：

graph TD;
    A[启动 applet] --> B[设置 applet 大小];
    B --> C[创建 PaintSurface 实例];
    C --> D[将 PaintSurface 添加到 applet];
    D --> E[创建 AnimationThread 线程];
    E --> F[启动线程];
    F --> G[线程循环];
    G --> H[重新绘制 applet];
    H --> I[线程休眠 20 毫秒];
    I --> G;
    C --> J[绘制球];
    J --> K[计算球的新位置];
    K --> J;

通过以上内容，我们了解了 Java 中图像、声音的处理以及动画编程的基本方法和技术。这些技术可以帮助我们创建更加丰富和生动的 Java 应用程序和游戏。

Java 中的图像、声音处理与动画编程

4. 动画编程进阶 - 多精灵动画

前面介绍了单个精灵（如球）的动画实现，接下来探讨如何创建多个精灵的动画，例如创建一个充满多个弹跳球的房间。

要实现多个弹跳球的动画，核心思路与单个球的动画类似，但需要管理多个球的状态。以下是实现的步骤：
1. 定义球的类 ：创建一个表示球的类，包含球的位置、速度、大小等属性，以及更新位置和绘制自身的方法。
2. 管理球的集合 ：在绘图组件中维护一个球的集合，用于存储所有的球。
3. 更新和绘制所有球 ：在 paint 方法中，遍历球的集合，更新每个球的位置并绘制它们。
4. 线程控制 ：使用线程定期重新绘制组件，实现动画效果。

以下是一个示例代码，展示了如何创建一个充满多个弹跳球的房间：

import java.applet.*;
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;
import java.util.ArrayList;

public class MultipleBallsRoom extends JApplet {
    private final int WIDTH = 350;
    private final int HEIGHT = 300;
    private PaintSurface canvas;

    public void init() {
        this.setSize(WIDTH, HEIGHT);
        canvas = new PaintSurface();
        this.add(canvas, BorderLayout.CENTER);
        Thread t = new AnimationThread(this);
        t.start();
    }
}

class AnimationThread extends Thread {
    JApplet c;

    public AnimationThread(JApplet c) {
        this.c = c;
    }

    public void run() {
        while (true) {
            c.repaint();
            try {
                Thread.sleep(20);
            } catch (InterruptedException ex) {
                // 忽略异常
            }
        }
    }
}

class Ball {
    int x;
    int y;
    int dx;
    int dy;
    int size;

    public Ball(int x, int y, int dx, int dy, int size) {
        this.x = x;
        this.y = y;
        this.dx = dx;
        this.dy = dy;
        this.size = size;
    }

    public void update() {
        x += dx;
        y += dy;

        if (x < 0 || x + size > 350) {
            dx = -dx;
        }
        if (y < 0 || y + size > 300) {
            dy = -dy;
        }
    }

    public void draw(Graphics2D g2) {
        g2.setColor(Color.RED);
        g2.fillOval(x, y, size, size);
    }
}

class PaintSurface extends JComponent {
    ArrayList<Ball> balls;

    public PaintSurface() {
        balls = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            int x = (int) (Math.random() * 300);
            int y = (int) (Math.random() * 250);
            int dx = (int) (Math.random() * 5) + 1;
            int dy = (int) (Math.random() * 5) + 1;
            int size = 20;
            balls.add(new Ball(x, y, dx, dy, size));
        }
    }

    public void paint(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        g2.setRenderingHint(
                RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);

        for (Ball ball : balls) {
            ball.update();
            ball.draw(g2);
        }
    }
}

这个程序的主要步骤如下：
1. Ball 类 ：定义了球的属性（位置 x 、 y ，速度 dx 、 dy ，大小 size ），以及更新位置和绘制自身的方法。
2. PaintSurface 类 ：维护一个 ArrayList<Ball> 用于存储所有的球。在构造函数中初始化 10 个随机位置和速度的球。在 paint 方法中，遍历球的集合，更新每个球的位置并绘制它们。
3. AnimationThread 类 ：与单个球的动画类似，使用线程定期重新绘制 applet。

这个程序的流程可以用 mermaid 流程图表示：

graph TD;
    A[启动 applet] --> B[设置 applet 大小];
    B --> C[创建 PaintSurface 实例];
    C --> D[初始化多个球];
    D --> E[将 PaintSurface 添加到 applet];
    E --> F[创建 AnimationThread 线程];
    F --> G[启动线程];
    G --> H[线程循环];
    H --> I[重新绘制 applet];
    I --> J[线程休眠 20 毫秒];
    J --> H;
    C --> K[遍历球集合];
    K --> L[更新球的位置];
    L --> M[绘制球];
    M --> K;

5. 简单游戏编程 - 类似 Pong 游戏

Pong 游戏是一款经典的街机游戏，玩家通过控制挡板击球，防止球出界。下面介绍如何使用 Java 实现一个简单的类似 Pong 游戏。

实现类似 Pong 游戏的主要步骤如下：
1. 定义球和挡板 ：创建表示球和挡板的类，包含它们的位置、速度等属性。
2. 处理碰撞检测 ：检测球与挡板、边界的碰撞，并相应地改变球的运动方向。
3. 用户交互 ：允许用户通过键盘控制挡板的移动。
4. 线程控制 ：使用线程定期更新游戏状态并重新绘制界面。

以下是实现类似 Pong 游戏的示例代码：

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

public class PongGame extends JFrame {
    private GamePanel gamePanel;

    public PongGame() {
        this.setSize(400, 300);
        this.setTitle("Pong Game");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        gamePanel = new GamePanel();
        this.add(gamePanel);

        this.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                gamePanel.keyPressed(e);
            }

            @Override
            public void keyReleased(KeyEvent e) {
                gamePanel.keyReleased(e);
            }
        });

        this.setVisible(true);

        Thread t = new Thread(gamePanel);
        t.start();
    }

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

class GamePanel extends JPanel implements Runnable {
    private int ballX = 200;
    private int ballY = 150;
    private int ballDx = 2;
    private int ballDy = 2;
    private int paddleY = 250;
    private int paddleX = 150;
    private boolean leftPressed = false;
    private boolean rightPressed = false;

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.setColor(Color.RED);
        g.fillOval(ballX, ballY, 20, 20);
        g.setColor(Color.BLUE);
        g.fillRect(paddleX, paddleY, 100, 10);
    }

    @Override
    public void run() {
        while (true) {
            update();
            repaint();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void update() {
        // 更新球的位置
        ballX += ballDx;
        ballY += ballDy;

        // 检测球与边界的碰撞
        if (ballX < 0 || ballX > 380) {
            ballDx = -ballDx;
        }
        if (ballY < 0) {
            ballDy = -ballDy;
        }

        // 检测球与挡板的碰撞
        if (ballY + 20 >= paddleY && ballX >= paddleX && ballX <= paddleX + 100) {
            ballDy = -ballDy;
        }

        // 检测球是否出界
        if (ballY > 300) {
            // 游戏结束逻辑
        }

        // 更新挡板的位置
        if (leftPressed && paddleX > 0) {
            paddleX -= 5;
        }
        if (rightPressed && paddleX < 300) {
            paddleX += 5;
        }
    }

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_LEFT) {
            leftPressed = true;
        }
        if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
            rightPressed = true;
        }
    }

    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_LEFT) {
            leftPressed = false;
        }
        if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
            rightPressed = false;
        }
    }
}

这个程序的主要步骤如下：
1. PongGame 类 ：创建一个 JFrame 作为游戏窗口，添加 GamePanel 作为游戏界面，并添加键盘监听器。
2. GamePanel 类 ：
- 定义球和挡板的属性，如位置、速度等。
- 在 paint 方法中绘制球和挡板。
- 在 run 方法中使用线程循环更新游戏状态并重新绘制界面。
- 在 update 方法中处理球的运动、碰撞检测和挡板的移动。
- 在 keyPressed 和 keyReleased 方法中处理用户的键盘输入。

这个程序的流程可以用 mermaid 流程图表示：

graph TD;
    A[启动游戏] --> B[创建 JFrame 窗口];
    B --> C[创建 GamePanel 实例];
    C --> D[添加键盘监听器];
    D --> E[显示窗口];
    E --> F[创建线程];
    F --> G[启动线程];
    G --> H[线程循环];
    H --> I[更新游戏状态];
    I --> J[重新绘制界面];
    J --> K[线程休眠 10 毫秒];
    K --> H;
    I --> L[检测球与边界碰撞];
    L --> M[改变球的运动方向];
    I --> N[检测球与挡板碰撞];
    N --> M;
    I --> O[处理用户键盘输入];
    O --> P[更新挡板位置];

通过以上内容，我们深入了解了 Java 中图像、声音处理以及动画和游戏编程的高级应用。这些技术可以帮助我们创建更加复杂和有趣的 Java 应用程序和游戏。希望大家通过学习和实践，能够在 Java 编程领域取得更好的成果。