56、Java Applets与HTML基础入门

Java Applets与HTML基础入门

1. Java Applets简介

1.1 Applets的概念与工作原理

Applets是与网页关联的Java程序，会在网页浏览器中作为网页的一部分执行。Java程序主要分为两种类型：应用程序和Applets。应用程序是独立运行在计算机上的程序，而Applets通常是网站的一部分。当用户使用支持Java的浏览器打开网站时，Applets会在浏览器窗口内执行，给用户的感觉就像是网站的一部分。

Applets存储在Web服务器上，与网站的网页一起。当用户通过浏览器访问服务器上的网页时，与该网页关联的任何Applets都会通过互联网从服务器传输到用户的系统，然后由用户的系统执行。

1.2 Applets的示例

以一个展示华氏温度和摄氏温度转换的网页为例，网页中包含文本框和按钮的区域是由Applet生成的。用户可以在顶部文本框中输入华氏温度，点击“Convert”按钮，摄氏温度将显示在只读文本框中。

值得注意的是，Applet不一定要在Web服务器上才能执行。可以在Web浏览器中打开 TempConverter.html 文件来尝试运行这个Applet。

1.3 Applets的运行限制

大多数Web浏览器都有一个特殊版本的JVM来运行Applets。出于安全考虑，这个版本的JVM对Applet的操作进行了严格限制：
- 不能删除、读取或创建用户系统上的文件。
- 不能运行用户系统上的其他程序。
- 不能执行用户系统上的操作系统程序。
- 不能检索用户系统或用户身份的信息。
- 只能与传输Applet的服务器建立网络连接。
- 如果Applet显示一个窗口，窗口中会自动显示“Warning: Applet Window”等消息，让用户知道该窗口不是由系统上的应用程序显示的。

如果Applet试图违反这些限制，将会抛出异常。

2. HTML基础介绍

2.1 HTML的基本概念

HTML（超文本标记语言）是用于编写网页的语言。虽然无法详细介绍HTML的所有内容，但了解一些基础知识对于运行Java Applets是必要的。

2.1.1 超文本（Hypertext）

网页可以包含普通文本和超文本，超文本可以包含指向另一个网页或同一网页中其他位置的链接。当用户点击超文本时，会加载超文本所链接的网页或位置。

2.1.2 标记语言（Markup Language）

HTML不是像Java那样的编程语言，而是一种标记语言。它允许通过插入特殊指令来“标记”文本文件，这些指令告诉浏览器如何格式化文本和创建超文本链接。

2.2 HTML标签

2.2.1 标签的一般格式

大多数HTML标签成对出现，第一个是开始标签，第二个是结束标签。简单标签的一般格式如下：

<tag_name>
Text
</tag_name>

其中， tag_name 是标签的名称，开始标签是 <tag_name> ，结束标签是 </tag_name> ，两者都用尖括号 < > 括起来。结束标签中的标签名前面有一个斜杠 / ，开始标签和结束标签之间的文本会被标签格式化或修改。

2.2.2 文档结构标签

• <html></html> ：标记HTML文档的开始和结束，标签之间的所有内容，包括其他标签，都是网页的内容。
• <head></head> ：标记文档头部，包含关于文档的信息，如搜索引擎用于识别文档的关键字。通常使用 <title></title> 标签在浏览器的标题栏中显示页面标题。
• <body></body> ：标记文档主体，包含所有在浏览器窗口中产生输出的标签和文本。

以下是一个简单的HTML文档示例，只显示标题：

<html>
<head>
    <title>My First Web Page</title>
</head>
</html>

2.3 文本格式化标签

2.3.1 标题标签

HTML提供了六种不同的标题标签，用于将文本格式化为不同级别的标题。 <h1></h1> 创建一级标题，显示为粗体，比普通文本大； <h2></h2> 创建二级标题，也是粗体，但比一级标题小，以此类推，标题标签的级别数字越高，格式化的文本越小。

示例：

<h1>This is an h1 Header</h1>
<h2>This is an h2 Header</h2>
<h3>This is an h3 Header</h3>
<h4>This is an h4 Header</h4>
<h5>This is an h5 Header</h5>
<h6>This is an h6 Header</h6>
This is regular unformatted text.

2.3.2 居中标签

使用 <center></center> 标签可以将一行文本在浏览器窗口中居中显示。例如：

<center><h1>Java</h1></center>

2.3.3 粗体和斜体标签

使用 <b></b> 标签可以将文本显示为粗体，使用 <i></i> 标签可以将文本显示为斜体。也可以组合使用这两个标签，将文本显示为粗斜体。

示例：

<b>Hello World</b>
<i>Hello World</i>
<b><i>Hello World</i></b>

2.4 创建文本分隔

有三个HTML标签用于在文档文本中创建分隔，它们与之前学习的标签不同，不需要成对出现，只需要插入开始标签。
- <br /> ：在插入的文本位置处产生换行。由于浏览器通常会忽略按Enter键创建的换行符，因此在HTML文档中经常需要插入 <br /> 标签。
示例：

First line<br />Second line<br />Third line

• <p /> ：在插入的文本位置处产生段落分隔，通常会比换行插入更多的空间。
  示例：

First paragraph<p />Second paragraph<p />Third paragraph

• <hr /> ：在插入的文本位置处显示一条水平线。
  示例：

This is the first line of text.
<hr />
This is the second line of text.
<hr />
This is the third line of text.

2.5 插入链接

链接是网页中可以被用户点击的元素。当用户点击链接时，会显示另一个网页或启动某种操作。插入简单链接的标签格式如下：

<a href="Address">Text</a>

其中， Text 是将显示在网页中的文本，当用户点击该文本时，浏览器将，这是一个使用链接的HTML文档示例：

<html>
<head>
    <title>Link Demonstration</title>
</head>
<body>
    This demonstrates a link.
    <br />
    <a href="http://www.aw.com/gaddis">Click here to go to the textbook's web site.</a>
</body>
</html>

在这个示例中，当用户点击“Click here to go to the textbook’s web site.”时，浏览器将显示 http://www.aw.com/gaddis 的网页。

2.6 HTML标签总结

标签类型	标签名称	作用
文档结构标签	<html></html>	标记HTML文档的开始和结束
	<head></head>	标记文档头部，包含文档信息
	<title></title>	在浏览器标题栏显示页面标题
	<body></body>	标记文档主体，包含产生输出的内容
文本格式化标签	<h1></h1> - <h6></h6>	创建不同级别的标题
	<center></center>	使文本居中显示
	<b></b>	使文本显示为粗体
	<i></i>	使文本显示为斜体
文本分隔标签	<br />	产生换行
	<p />	产生段落分隔
	<hr />	显示水平线
链接标签	<a href="Address">Text</a>	插入链接

2.7 HTML文档结构流程图

graph LR
    A[HTML文档] --> B[<html>]
    B --> C[<head>]
    C --> D[<title>页面标题</title>]
    B --> E[<body>]
    E --> F[文本内容]
    E --> G[标签元素]
    E --> H[<a href="链接地址">链接文本</a>]
    B --> I[</html>]

3. 使用Swing创建Applets

3.1 Applet与GUI应用程序的区别

Applet与GUI应用程序非常相似，可以将Applet看作是在Web浏览器控制下运行的GUI应用程序。它不像GUI应用程序那样显示自己的窗口，而是出现在浏览器窗口中。GUI应用程序代码和Applet代码的区别如下：
- 继承类不同 ：GUI应用程序类继承自 JFrame ，而Applet类继承自 JApplet ， JApplet 类属于 javax.swing 包。
- 初始化方式不同 ：GUI应用程序类有一个构造函数来创建其他组件并设置GUI，而Applet类通常没有构造函数，而是有一个名为 init 的方法，该方法执行与构造函数相同的操作，接受无参数，返回类型为 void 。
- 不适用的方法 ：在GUI应用程序的构造函数中常用的一些方法，如 setTitle 、 setSize 、 setDefaultCloseOperation 、 pack 和 setVisible ，在Applet中通常不使用，因为Applet没有自己的窗口。
- 无需 main 方法 ：创建Applet类的实例不需要静态 main 方法，浏览器会自动创建类的实例。

3.2 简单Applet示例

以下是一个显示标签的简单Applet示例：

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

/**
 * This is a simple applet.
 */
public class SimpleApplet extends JApplet {
    /**
     * The init method sets up the applet, much like a constructor.
     */
    public void init() {
        // Create a label.
        JLabel label = new JLabel("This is my very first applet.");

        // Set the layout manager.
        setLayout(new FlowLayout());

        // Add the label to the content pane.
        add(label);
    }
}

这个代码与普通的GUI应用程序非常相似，虽然类继承自 JApplet 而不是 JFrame ，但仍然可以以相同的方式向内容面板添加组件和使用布局管理器。

3.3 运行Applet

运行Applet的过程与运行应用程序不同。要运行Applet，需要创建一个包含 applet 标签的HTML文档，其一般格式如下：

<applet code="Filename.class" width=Wide height=High></applet>

其中， Filename.class 是Applet的 .class 文件的名称，包含编译后的字节码。注意，这里指定的是 .class 文件，而不是包含Java源代码的 .java 文件。可以选择指定文件路径，如果只指定文件名，则假设文件与HTML文档在同一目录中。 Wide 是Applet的宽度（以像素为单位）， High 是Applet的高度（以像素为单位）。当浏览器处理 applet 标签时，会加载指定的字节码并在指定大小的区域内执行。

以下是一个使用 applet 标签加载上述 SimpleApplet 的HTML文档示例：

<html>
<head>
    <title>A Simple Applet</title>
</head>
<body>
    <applet code="SimpleApplet.class" width="200" height="50">
    </applet>
</body>
</html>

3.4 使用appletviewer运行Applet

Sun JDK附带了一个Applet查看器程序，可以在不使用Web浏览器的情况下加载和执行Applet。可以在命令提示符下使用 appletviewer 命令运行该程序，并指定一个HTML文档的名称作为命令行参数。例如：

appletviewer SimpleApplet.html

这个命令将执行 SimpleApplet.html 文件中 applet 标签引用的任何Applet。

需要注意的是，当在浏览器中加载使用Applet的网页时，很可能会收到安全警告。例如，在Internet Explorer中，需要点击警告消息，然后从弹出菜单中选择“Allow Blocked Content…”来运行Applet。

3.5 Applet中的事件处理

在Applet中，事件处理与GUI应用程序一样，使用事件监听器。以 TempConverter 类为例，它是一个将华氏温度转换为摄氏温度的Applet。用户可以在文本字段中输入华氏温度，点击“Convert”按钮，转换后的摄氏温度将显示在只读文本字段中。温度转换是在一个处理按钮动作事件的动作监听器类中执行的。

以下是 TempConverter 类的代码：

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

/**
 * The TempConverter class is an applet that converts Fahrenheit temperatures to Celsius.
 */
public class TempConverter extends JApplet {
    private JPanel fPanel;         // To hold a text field
    private JPanel cPanel;         // To hold a text field
    private JPanel buttonPanel;    // To hold a button
    private JTextField fahrenheit; // Fahrenheit temperature
    private JTextField celsius;    // Celsius temperature

    /**
     * init method
     */
    public void init() {
        // Build the panels.
        buildFpanel();
        buildCpanel();
        buildButtonPanel();

        // Create a layout manager.
        setLayout(new GridLayout(3, 1));

        // Add the panels to the content pane.
        add(fPanel);
        add(cPanel);
        add(buttonPanel);
    }

    /**
     * The buildFpanel method creates a panel with a text field in which the user can enter a Fahrenheit temperature.
     */
    private void buildFpanel() {
        // Create the panel.
        fPanel = new JPanel();

        // Create a label to display a message.
        JLabel message1 = new JLabel("Fahrenheit Temperature:");

        // Create a text field for the Fahrenheit temp.
        fahrenheit = new JTextField(10);

        // Create a layout manager for the panel.
        fPanel.setLayout(new FlowLayout(FlowLayout.RIGHT));

        // Add the label and text field to the panel.
        fPanel.add(message1);
        fPanel.add(fahrenheit);
    }

    /**
     * The buildCpanel method creates a panel that displays the Celsius temperature in a read-only text field.
     */
    private void buildCpanel() {
        // Create the panel.
        cPanel = new JPanel();

        // Create a label to display a message.
        JLabel message2 = new JLabel("Celsius Temperature:");

        // Create a text field for the celsius temp.
        celsius = new JTextField(10);

        // Make the text field read-only.
        celsius.setEditable(false);

        // Create a layout manager for the panel.
        cPanel.setLayout(new FlowLayout(FlowLayout.RIGHT));

        // Add the label and text field to the panel.
        cPanel.add(message2);
        cPanel.add(celsius);
    }

    /**
     * The buildButtonPanel method creates a panel with a button that converts the Fahrenheit temperature to Celsius.
     */
    private void buildButtonPanel() {
        // Create the panel.
        buttonPanel = new JPanel();

        // Create a button with the text "Convert".
        JButton convButton = new JButton("Convert");

        // Add an action listener to the button.
        convButton.addActionListener(new ButtonListener());

        // Add the button to the panel.
        buttonPanel.add(convButton);
    }

    /**
     * Private inner class that handles the action event that is generated when the user clicks the convert button.
     */
    private class ButtonListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            double ftemp, ctemp;  // To hold the temperatures

            // Get the Fahrenheit temperature and convert it to a double.
            ftemp = Double.parseDouble(fahrenheit.getText());

            // Calculate the Celsius temperature.
            ctemp = (5.0 / 9.0) * (ftemp - 32);

            // Display the Celsius temperature.
            celsius.setText(String.format("%.1f", ctemp));
        }
    }
}

以下是使用这个Applet的HTML文档示例：

<html>
<head>
    <title>Fahrenheit and Celsius Temperatures</title>
</head>
<body>
    <center>
        <h1>Fahrenheit and Celsius Temperatures</h1>
    </center>
    Fahrenheit and Celsius are two temperature scales in use today.
    The <b>Fahrenheit</b> scale was developed by the German physicist Daniel Gabriel Fahrenheit (1686 - 1736). In the Fahrenheit scale, water freezes at 32 degrees and boils at 212 degrees. The <b>Celsius</b> scale was developed by Swedish astronomer Andres Celsius (1701 - 1744). In the Celsius scale, water freezes at 0 degrees and boils at 100 degrees. The Celsius to Fahrenheit conversion formula is:
    <p />
    <i>C</i> = (5/9) * (<i>F</i> - 32)
    <p />
    where <i>F</i> is the Fahrenheit temperature. You can also use this Web page to convert Fahrenheit temperatures to Celsius. Just enter a Fahrenheit temperature in the text box below, then click on the Convert button.
    <p />
    <applet code="TempConverter.class" width="300" height="150">
    </applet>
    <hr />
</body>
</html>

3.6 Applet运行流程总结

1. 编写Java Applet代码，继承自 JApplet 类，并实现 init 方法进行初始化。
2. 编译Java代码生成 .class 文件。
3. 创建包含 applet 标签的HTML文档，引用 .class 文件，并指定Applet的宽度和高度。
4. 在浏览器中打开HTML文档，或者使用 appletviewer 命令运行Applet。

3.7 Applet运行流程图

graph LR
    A[编写Java Applet代码] --> B[编译Java代码]
    B --> C[生成.class文件]
    C --> D[创建HTML文档]
    D --> E[添加applet标签引用.class文件]
    E --> F[在浏览器中打开HTML文档]
    E --> G[使用appletviewer命令运行]

通过以上内容，我们了解了Java Applets的基本概念、HTML的基础知识以及如何使用Swing创建和运行Applets。这些知识为进一步开发交互式网页应用程序奠定了基础。

4. 使用AWT实现可移植性

4.1 AWT简介

AWT（Abstract Window Toolkit）是Java的一个早期图形用户界面（GUI）工具包，它提供了创建和管理GUI组件的基本功能。在创建Applets时，使用AWT可以实现更好的可移植性，因为AWT组件是基于本地操作系统的图形库实现的，能够在不同的操作系统上保持一致的外观和行为。

4.2 AWT与Swing的比较

比较项	AWT	Swing
组件实现	基于本地操作系统的图形库	纯Java实现
可移植性	较好，依赖本地系统	好，跨平台一致性高
外观	与本地系统一致	可自定义外观
功能丰富度	基础功能	功能更丰富

4.3 使用AWT创建Applet示例

以下是一个使用AWT创建的简单Applet示例，该Applet显示一个按钮：

import java.applet.Applet;
import java.awt.Button;
import java.awt.FlowLayout;

/**
 * 一个使用AWT的简单Applet示例
 */
public class AWTSimpleApplet extends Applet {
    public void init() {
        // 设置布局管理器
        setLayout(new FlowLayout());

        // 创建按钮
        Button button = new Button("Click me");

        // 将按钮添加到Applet中
        add(button);
    }
}

对应的HTML文档如下：

<html>
<head>
    <title>AWT Simple Applet</title>
</head>
<body>
    <applet code="AWTSimpleApplet.class" width="200" height="100">
    </applet>
</body>
</html>

4.4 AWT Applet创建流程

1. 导入必要的AWT包，如 java.applet.Applet 、 java.awt 相关类。
2. 创建一个继承自 Applet 的类。
3. 在 init 方法中进行组件的初始化和布局设置。
4. 编译Java代码生成 .class 文件。
5. 创建包含 applet 标签的HTML文档，引用 .class 文件，并指定Applet的宽度和高度。
6. 在浏览器中打开HTML文档或使用 appletviewer 命令运行Applet。

4.5 AWT Applet创建流程图

graph LR
    A[导入AWT包] --> B[创建继承Applet的类]
    B --> C[实现init方法]
    C --> D[编译Java代码]
    D --> E[生成.class文件]
    E --> F[创建HTML文档]
    F --> G[添加applet标签引用.class文件]
    G --> H[在浏览器中打开HTML文档]
    G --> I[使用appletviewer命令运行]

5. 在Applet中绘制图形

5.1 绘制图形的方法

在Applet中，可以使用 Graphics 类的方法来绘制各种图形，如直线、矩形、椭圆等。 Graphics 类提供了一系列的绘图方法，通过重写 Applet 的 paint 方法，可以在Applet中绘制图形。

5.2 绘制图形示例

以下是一个在Applet中绘制直线、矩形和椭圆的示例：

import java.applet.Applet;
import java.awt.Graphics;

/**
 * 一个在Applet中绘制图形的示例
 */
public class DrawingShapesApplet extends Applet {
    public void paint(Graphics g) {
        // 绘制直线
        g.drawLine(50, 50, 200, 50);

        // 绘制矩形
        g.drawRect(50, 100, 150, 100);

        // 绘制椭圆
        g.drawOval(50, 250, 150, 100);
    }
}

对应的HTML文档如下：

<html>
<head>
    <title>Drawing Shapes Applet</title>
</head>
<body>
    <applet code="DrawingShapesApplet.class" width="300" height="400">
    </applet>
</body>
</html>

5.3 绘制图形步骤总结

1. 创建一个继承自 Applet 的类。
2. 重写 paint 方法，在该方法中使用 Graphics 对象的绘图方法绘制图形。
3. 编译Java代码生成 .class 文件。
4. 创建包含 applet 标签的HTML文档，引用 .class 文件，并指定Applet的宽度和高度。
5. 在浏览器中打开HTML文档或使用 appletviewer 命令运行Applet。

5.4 绘制图形流程图

graph LR
    A[创建继承Applet的类] --> B[重写paint方法]
    B --> C[编译Java代码]
    C --> D[生成.class文件]
    D --> E[创建HTML文档]
    E --> F[添加applet标签引用.class文件]
    F --> G[在浏览器中打开HTML文档]
    F --> H[使用appletviewer命令运行]

6. 处理Applet中的鼠标事件

6.1 鼠标事件的类型

在Applet中，常见的鼠标事件包括鼠标点击、鼠标移动、鼠标进入和鼠标离开等。可以通过实现鼠标事件监听器接口来处理这些事件。

6.2 处理鼠标事件示例

以下是一个处理鼠标点击事件的Applet示例：

import java.applet.Applet;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

/**
 * 一个处理鼠标点击事件的Applet示例
 */
public class MouseEventsApplet extends Applet {
    private int clickX, clickY;

    public void init() {
        // 添加鼠标监听器
        addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                clickX = e.getX();
                clickY = e.getY();
                repaint();
            }
        });
    }

    public void paint(Graphics g) {
        if (clickX != 0 && clickY != 0) {
            g.drawString("Clicked at: (" + clickX + ", " + clickY + ")", clickX, clickY);
        }
    }
}

对应的HTML文档如下：

<html>
<head>
    <title>Mouse Events Applet</title>
</head>
<body>
    <applet code="MouseEventsApplet.class" width="300" height="300">
    </applet>
</body>
</html>

6.3 处理鼠标事件步骤总结

1. 创建一个继承自 Applet 的类。
2. 在 init 方法中添加鼠标事件监听器，可以使用 MouseAdapter 类来简化实现。
3. 重写监听器的相应方法，如 mouseClicked ，处理鼠标事件。
4. 在 paint 方法中根据事件处理结果进行绘制。
5. 编译Java代码生成 .class 文件。
6. 创建包含 applet 标签的HTML文档，引用 .class 文件，并指定Applet的宽度和高度。
7. 在浏览器中打开HTML文档或使用 appletviewer 命令运行Applet。

6.4 处理鼠标事件流程图

graph LR
    A[创建继承Applet的类] --> B[在init方法中添加鼠标监听器]
    B --> C[重写监听器方法处理事件]
    C --> D[在paint方法中绘制结果]
    D --> E[编译Java代码]
    E --> F[生成.class文件]
    F --> G[创建HTML文档]
    G --> H[添加applet标签引用.class文件]
    H --> I[在浏览器中打开HTML文档]
    H --> J[使用appletviewer命令运行]

7. 使用Timer对象

7.1 Timer对象的作用

Timer 对象可以在指定的时间间隔内触发事件，常用于实现定时任务，如动画效果、定时更新数据等。在Applet中使用 Timer 对象可以实现动态效果。

7.2 使用Timer对象示例

以下是一个使用 Timer 对象实现简单动画的Applet示例：

import java.applet.Applet;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Timer;

/**
 * 一个使用Timer对象实现动画的Applet示例
 */
public class TimerApplet extends Applet {
    private int x = 0;
    private Timer timer;

    public void init() {
        // 创建Timer对象，每100毫秒触发一次事件
        timer = new Timer(100, new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                x += 5;
                if (x > getWidth()) {
                    x = 0;
                }
                repaint();
            }
        });
        timer.start();
    }

    public void paint(Graphics g) {
        g.drawOval(x, 50, 20, 20);
    }

    public void destroy() {
        // 停止Timer对象
        timer.stop();
    }
}

对应的HTML文档如下：

<html>
<head>
    <title>Timer Applet</title>
</head>
<body>
    <applet code="TimerApplet.class" width="300" height="200">
    </applet>
</body>
</html>

7.3 使用Timer对象步骤总结

1. 创建一个继承自 Applet 的类。
2. 在 init 方法中创建 Timer 对象，并指定时间间隔和事件监听器。
3. 在事件监听器的 actionPerformed 方法中处理定时任务，如更新数据、重绘界面等。
4. 调用 start 方法启动 Timer 对象。
5. 在 paint 方法中根据定时任务的结果进行绘制。
6. 在 destroy 方法中停止 Timer 对象，避免资源泄漏。
7. 编译Java代码生成 .class 文件。
8. 创建包含 applet 标签的HTML文档，引用 .class 文件，并指定Applet的宽度和高度。
9. 在浏览器中打开HTML文档或使用 appletviewer 命令运行Applet。

7.4 使用Timer对象流程图

graph LR
    A[创建继承Applet的类] --> B[在init方法中创建Timer对象]
    B --> C[设置时间间隔和事件监听器]
    C --> D[启动Timer对象]
    D --> E[在actionPerformed方法中处理定时任务]
    E --> F[在paint方法中绘制结果]
    F --> G[在destroy方法中停止Timer对象]
    G --> H[编译Java代码]
    H --> I[生成.class文件]
    I --> J[创建HTML文档]
    J --> K[添加applet标签引用.class文件]
    K --> L[在浏览器中打开HTML文档]
    K --> M[使用appletviewer命令运行]

8. 在Applet中播放音频

8.1 播放音频的方法

在Applet中可以使用 AudioClip 接口来播放音频文件。 AudioClip 提供了播放、暂停、停止等基本的音频操作方法。

8.2 播放音频示例

以下是一个在Applet中播放音频文件的示例：

import java.applet.Applet;
import java.applet.AudioClip;
import java.net.URL;

/**
 * 一个在Applet中播放音频的示例
 */
public class AudioApplet extends Applet {
    private AudioClip audioClip;

    public void init() {
        try {
            // 获取音频文件的URL
            URL audioUrl = new URL(getCodeBase(), "audio.wav");
            // 获取音频剪辑对象
            audioClip = getAudioClip(audioUrl);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void start() {
        // 播放音频
        if (audioClip != null) {
            audioClip.play();
        }
    }

    public void stop() {
        // 停止音频
        if (audioClip != null) {
            audioClip.stop();
        }
    }
}

对应的HTML文档如下：

<html>
<head>
    <title>Audio Applet</title>
</head>
<body>
    <applet code="AudioApplet.class" width="200" height="100">
    </applet>
</body>
</html>

8.3 播放音频步骤总结

1. 创建一个继承自 Applet 的类。
2. 在 init 方法中获取音频文件的URL，并使用 getAudioClip 方法获取 AudioClip 对象。
3. 在 start 方法中调用 play 方法播放音频。
4. 在 stop 方法中调用 stop 方法停止音频。
5. 编译Java代码生成 .class 文件。
6. 创建包含 applet 标签的HTML文档，引用 .class 文件，并指定Applet的宽度和高度。
7. 在浏览器中打开HTML文档或使用 appletviewer 命令运行Applet。

8.4 播放音频流程图

graph LR
    A[创建继承Applet的类] --> B[在init方法中获取音频URL和AudioClip对象]
    B --> C[在start方法中播放音频]
    C --> D[在stop方法中停止音频]
    D --> E[编译Java代码]
    E --> F[生成.class文件]
    F --> G[创建HTML文档]
    G --> H[添加applet标签引用.class文件]
    H --> I[在浏览器中打开HTML文档]
    H --> J[使用appletviewer命令运行]

9. 避免常见错误

9.1 安全限制相关错误

由于Applets运行在受限环境中，需要注意避免违反安全限制，如尝试删除文件、读取文件内容、创建文件、运行其他程序等。如果违反这些限制，会抛出异常。在编写Applet代码时，要确保不进行这些受限操作。

9.2 代码编写相关错误

• 继承类错误 ：Applet类应继承自 JApplet 或 Applet ，而不是 JFrame 。
• 初始化方法错误 ：Applet类通常使用 init 方法进行初始化，而不是构造函数。
• 缺少必要方法 ：Applet不需要静态 main 方法，浏览器会自动创建类的实例。

9.3 运行相关错误

• 安全警告 ：在浏览器中加载使用Applet的网页时，可能会收到安全警告。需要按照提示进行操作，如点击警告消息，选择“Allow Blocked Content…”来运行Applet。
• 文件引用错误 ：在HTML文档中引用Applet的 .class 文件时，要确保文件名和路径正确。

9.4 常见错误总结

错误类型	错误描述	解决方法
安全限制错误	尝试进行受限操作，如文件读写、运行程序等	避免进行受限操作
代码编写错误	继承类错误、初始化方法错误、缺少必要方法等	确保继承自正确的类，使用 init 方法初始化，不使用静态 main 方法
运行错误	安全警告、文件引用错误等	按照提示处理安全警告，确保 .class 文件引用正确

通过以上内容，我们全面了解了Java Applets的各个方面，包括使用AWT实现可移植性、绘制图形、处理鼠标事件、使用Timer对象、播放音频以及避免常见错误等。这些知识将帮助我们开发出功能丰富、稳定可靠的交互式网页应用程序。