java applet编程_JavaApplet编程技巧

Java Applet 编 程 技 巧

陈 冲

———————————————————————-

———-

1. Java Applet 概 述

Java Applet 程 序 分 为 两 类：Java 小 程 序(Applet) 和Java

应 用 程 序(Application)， 这 两 类 程 序 是 有 区 别 的。Java Appl

et 嵌 入 在WWW 的 页 面， 作 为 页 面 的 组 成 部 分 被 下 载， 并 能

运 行 在 实 现Java 虚 机 器(JVM) 的Web 浏 览 器 中。Java 的 安 全 机

制 可 以 防 止 小 程 序 存 取 本 地 文 件 或 其 他 安 全 方 面 的 问

题。 而 一 个Java 应 用 程 序 运 行 于Web 浏 览 器 之 外， 没 有Applet

运 行 时 的 诸 多 限 制。 另 外， 两 者 程 序 设 计 上 的 最 大 区 别

在 于：Java Applet 没 有 主 程 序， 而Java 应 用 程 序 一 定 要 有 主

程 序。 在Java 中 每 个applet 都 是 由Applet 的 子 类 来 实 现。 开 发

人 员 自 定 义 的applet 通 过 重 载Applet 的 几 个 主 要 成 员 函 数

完 成 小 应 用 程 序 的 初 始 化、 绘 制 和 运 行。 这 些 函 数 是init

( )、paint( )、start( )、stop( ) 和destory( )。

一 个applet 的 生 命 周 期 与Web 页 面 有 关。 当 首 次 加 载

含applet 的 页 面 时， 浏 览 器 调 用init( ) 方 法， 完 成applet 的 初

始 化。 然 后 调 用paint( ) 或start( ) 方 法 绘 制 或 启 动 程 序。 当

用 户 离 开 页 面 时， 浏 览 器 调 用stop( ) 方 法 停 止 小 程 序 运

行。 若 用 户 关 闭 浏 览 器 将 使applet 停 止 运 行， 浏 览 器 调 用d

estory( ) 方 法 终 止， 使 小 应 用 程 序 有 机 会 释 放 其 存 在 期 间

锁 定 的 资 源。 只 要 用 户 不 关 闭 浏 览 器， 重 新 加 载 页 面，

浏 览 器 则 只 调 用start( ) 方 法 和paint( ) 方 法 重 新 绘 制 并 运

行 小 程 序。Applet 生 命 周 期 如 图1 所 示。

2. 扩 展 小 程 序 基 类 支 持 多 线 程

通 常 情 况 下， 设 计 小 程 序 是 为 了 给 主 页 增 加 交 互

性， 使 页 面 更 加 生 动 活 泼。 因 此， 那 些 真 正 有 用 小 程 序，

如 动 画、 实 时 更 新Internet 服 务 器 信 息 回 取、 一 般 娱 乐 等

通 常 都 是 持 续 运 行 的， 即 小 程 序 的 逻 辑 主 体 存 在 着 无 限

循 环。 这 个 逻 辑 主 体 不 宜 放 在 几 个 浏 览 器 调 用 方 法 中，

如init( )、paint( )、

start( ) 等。 这 是 因 为 隐 含 情 况 下， 小 程 序 所 有 主 逻 辑 都

采 用 单 一 线 程。 当 浏 览 器 调 用 方 法 中 出 现 死 循 环， 则 程

序 控 制 不 返 回。 如 果 用 户 换 到 另 一 个 页 面 之 后 小 程 序 还

在 运 行， 就 会 浪 费 处 理 器 资 源。 你 可 以 做 一 个 实 验， 使

用 小 程 序 查 阅 器 运 行 小 程 序， 你 会 发 现 查 阅 器 本 身 完 全

停 止 作 用， 因 为 它 要 等 到 调 用 函 数 返 回 后， 才 能 继 续 处

理 其 他 事 情( 如 响 应 菜 单)。 显 然， 这 个 逻 辑 主 体 必 须 放

在 其 他 地 方。 解 决 方 法 是 在 小 程 序 框 架 中 加 入 线 程， 把

逻 辑 主 体 放 在 线 程run( ) 方 法 中。 只 在 浏 览 器 调 用 方 法st

art( ) 中 生 成 线 程， 而 在

stop( ) 中 终 止 线 程 运 行， 这 样 当 用 户 不 查 阅 时 不 会 占 用

处 理 器 资 源。 图2 表 示 浏 览 器、 小 程 序 和 线 程 之 间 的 关 系

。

由 于 浏 览 器/ 小 程 序/ 线 程 是 所 有 浏 览 器 都 采 用 的

模 型， 而Java.applet.Applet 类 本 身 并 不 支 持 线 程。 在 实 际 使

用 中， 为 方 便 操 作， 我 们 可 以 派 生Applet 类 生 成 一 个 支 持

线 程 的 子 类， 今 后 再 编 写applet 时， 就 可 以 直 接 从 子 类 中

派 生， 程 序 逻 辑 主 体 放 在run( ) 方 法 中， 将 线 程 控 制 隐 藏

起 来。 这 个 子 类 如 下：

import Java.applet.*;

import Java.awt.*;

class MultiThreadApplet extends Applet implements Runnable {

Thread thisThread;

Public void start( ) {      if(thisThread==null) {

thisThread=new Thread(this);

thisThread.start( );{

}

public void stop( ) {

if (thisThread! =null) {

thisThread.stop( );

thisThread=null;}

}

public void run ( ) {}}

由 于run( ) 是 接 口Runnable 的 抽 象 方 法， 所 以 在MultiTh

readApplet 类 中 也 需 要 进 行 定 义， 只 不 过 内 容 为 空。 下 面 的

例 子 显 示 如 何 使 用 这 个 类。 程 序 包 含 一 个 无 限 循 环 累 加

操 作， 并 将 结 果 显 示 在 屏 幕 上：

import java.awt.*;

public class counter extends MultiThreadApplet{

int Counter;

public void run( ){

while(true){

counter++;

repaint( );}

}

public void paint(Graphics g) {

g.drawString(string.valueof(counter),10,10);{

}

很 显 然， 这 个 小 程 序 对 线 程 的 操 作 已 被 隐 藏 在Mul

ti ThreadApplet 中。

3. 解 决 动 画 中 的 一 些 问 题

动 画 的 本 质 就 是 运 动 的 图 形， 一 系 列 连 续 显 示 的

静 止 图 形 会 给 我 们 一 种 连 续 动 画 的 假 象。 只 要 动 画 速 度

足 够 快， 则 分 散 的 静 止 图 形 就 会 合 并 成 一 个 连 续 运 动 的

流 程。

绘 制 动 画 十 分 简 单， 只 需 遵 照 以 下 三 步 即 可；(1)

擦 去 整 个 小 程 序 绘 图 区；(2) 重 画 动 画 背 景；(3) 在 新 的

位 置 绘 制 图 形。 但 是， 当 动 画 连 续 帧 之 间 运 动 和 颜 色 不

连 续 时 就 会 发 生 闪 烁 现 象( 例 子 略)。 问 题 出 在 小 程 序

区 的 屏 幕 刷 新 上， 有 两 种 方 法 可 以 防 止 动 画 闪 烁。 第 一

种 方 法 是 只 做 局 部 刷 新， 即 每 次 只 擦 除 改 变 的 部 分。 例

如： 如 果 要 绘 制 一 幅” 飞 行 的 星 空” 动 画， 每 次 刷 新 操 作，

先 擦 去 前 一 位 置 的 星 星， 再 在 新 的 位 置 绘 制 一 个。 但 是

， 如 果 动 画 比 较 复 杂， 运 动 部 分 重 叠 较 多， 则 局 部 刷 新

操 作 很 繁 琐 也 影 响 程 序 运 行 速 度。 在 这 种 情 况 下， 可 以

用 另 外 一 种 方 法( 双 缓 存) 来 解 决 闪 烁 问 题。 它 的 核 心 思

想 是 在 屏 幕 外 完 成 一 帧 的 全 部 动 画， 然 后 把 最 后 绘 制 完

的 帧 显 示 在 小 程 序 屏 幕 上。 过 程 如 图3 所 示。

示 例 程 序 如 下：

import java.awt.*;

public class Ball extends MultiThreadApplet {

Image ball=null;

Image applet=null;

Graphics appletG,ballG;

Public void run( ){

If(ball= =null){

Applet=createlmage(bounds( ).width,bounds( ).

Height);

Ball=create Image(70,70);

AppletG=applet.getGraphics( );

BallG=ball.getGraphics( );

BallG.setColor(Color.gray);

BallG.drawOral(0,0,70,70); {

For(int x=0;x <400;x++) { Double angle=”((double)x)/20;” Int y=”(

int)(Math.abs(Math.sin(angle))*80);” AppletG.clearRect(0,0,bounds( ).w

idth.bounds( ), Helght); DrawBackground(appletG); AppletG.drawImage(ba

ll,x.80-y,this); This.getGraphics( ).drawImage(applet,0,0,this); Try {

Thread.sleep(25); } catch(Exception ignored) {}} } private void drawB

ackground(Graphics g) { for(int I=”0;I” < 1;I++){ g.drawLine(0.i*10,40

0,I*10); } } }

小 程 序 首 先 用createImage( ) 取 得 与 小 程 序 大 小 完 全

相 同 的 屏 外 图 形 缓 存， 赋 给 变 量applet， 然 后 得 到 缓 存 的

绘 图 对 象appletG。 以 后 对 帧 的 刷 新 操 作 过 程都 是 针 对apple

tG。 这 包 括 清 除 帧、 绘 制 背 景、 在 新 位 置 绘 制 图 形。最后再

用drawImage ( ) 方 法 把 缓 存 复 制 到 小 程 序 的 屏 幕 显 示 区。 运

行 这 个 小 程 序， 你 会 发 现 动 画 非 常 平 滑， 不 存 在 闪 烁 现

象。

除 了 闪 烁 之 外， 如 果 动 画 过 于 复 杂， 帧 速 率 就 可

能 降 低。 若 动 画 降 到 每 秒20， 帧 是 动 画 会 出 现 间 断 现 象 影

响 显 示 效 果。 因 此 有 必 要 优 化 动 画 速 度， 下 面 列 出 了 一

些 可 行 的 方 案；(1) 画 得 尽 可 能 少；(2) 用 较 快 的 绘 图 算

法；(3) 用 颜 色 循 环 等 技 巧 来 绘 画 某 一 部 分；(4) 用 图 案

来 表 示 细 节；(5) 用 定 点 整 数 进 行 三 维 计 算；(6) 用 查 询

的 预 先 计 算 结 果 来 处 理 复 杂 算 法。

4. 缩 短 小 程 序 装 入 时 间

真 正 功 能 性 的 小 程 序 本 身 并 不 小， 这 就 意 味 着 小

程 序 从Internet 上 下 载 需 要 花 很 多 时 间。 随 着 小 程 序 的 普

及， 越 来 越 多 的Internet 频 带 被 用 于 从 各 地 的 服 务 器 向 客

户 端Web 浏 览 器 传 送 这 些 小 程 序， 因 此 响 应 时 间 进 一 步 下

降。 为 了 缩 短 小 程 序 下 载 和 装 入 时 间， 可 以 采 取 以 下3 种

方 法。

使 执 行 文 件 尽 量 小 尽 管Internet(TCP 协 议) 可 以 接 受 任 意 长

度 的 数 据 流， 但 负 责 点 对 点 传 送 的 网 络 设 备( 例 如： 路

由 器) 对 一 次 传 送 分 组 包 的 上 限 有 严 格 的 限 制， 通 常 这

一 限 制 是256 的 整 数 倍。 因 此， 当 小 程 序 在 网 上 传 送 时， 按

照 上 限 它 被 分 成 若 干 包， 而 最 后 一 个 包 可 能 只 有 几 个 字

节。 这 些 包 是 单 独 传 送， 需 要 在 客 户 端 重 新 组 装 为 原 先

小 程 序 执 行 文 件 字 节 流。 当 最 后 一 个 包 延 迟 时， 可 能 要

用 好 几 秒 来 等 待 最 后 几 个 字 节 到 达。 唯 一 的 解 决 办 法 就

是 保 持 类 文 件 尽 量 小。 开 发 人 员 可 以 在 不 影 响 程 序 逻 辑

主 体 的 前 提 下 尝 试 下 列 方 案：(1) 删 除 查 错 代 码；(2) 缩

小String 直 接 量；(3) 选 择Java 编 译 器 优 化 编 译 选 项；(4)

删 除 用 不 到 的 方 法 等。

类 散 保 持 在 可 控 范 围 内 几 乎 没 有 一 个 小 程 序 是 由 一 个 类

组 成。 通 常， 开 发 人 员 为 了 实 现 一 个 功 能 较 强 的 小 程 序

需 要 从 标 准 的Java 基 类 中 派 生 出 若 干 子 类， 并 对 之 进 行

组 合。 因 此， 若 要 使 一 个 小 程 序 运 行，Java 虚 拟 机 就 要 分

别 下 载 并 装 入 这 些 类。 如 果 实 现 中 类 的 数 目 较 多， 下 载

的 时 间 也 就 相 应 较 长。 我 们 都 知 道， 下 载20 个 独 立 的 数 据

块 比 下 载 一 个 相 当 于20 个 数 据 块 之 和 的 大 数 据 块 要 花 费

更 多 的 时 间， 这 是 由 于 下 载 每 个 独 立 数 据 块 都 要 重 新 进

行 网 络 联 接， 而 进 行 每 次 联 接 都 要 花 费 时 间 的 缘 故。 因

此， 开 发 人 员 在 设 计 小 程 序 时， 类 的 数 目 要 选 择 适 中，

即 可 保 证 结 构 层 次 清 晰， 又 要 保 证 程 序 精 简， 不 增 加 冗

余。

缩 短 小 程 序 初 始 化 时 间 用 户 讨 厌 等 待， 因 此， 程 序 下 载

后 应 尽 量 缩 短 初 始 化 时 间。 如 果 预 处 理 工 作 较 多， 可 以

用 辅 助 线 程 先 同 用 户 进 行 交 互， 例 如： 问 候 用 户、 询 问 用

户 姓 名、 显 示 进 程 指 示 等。 总 之， 让 用 户” 忙 起 来”。 同 时

， 小 程 序 主 线 程 可 以 继 续 在 后 台 做 初 始 化 工 作。 有 句 话

请 记 住：” 高 兴 时 时 间 过 得 快”， 充 分 利 用 这 一 现 象 可 以

改 变 用 户 对 小 程 序 装 入 时 间 的 感 觉。

使 用Java 开 发WWW 客 户 端 应 用 程 序 十 分 方 便， 技 术 也

很 多， 本 文 只 简 单 介 绍 几 种 方 法 和 注 意 事 项 供 大 家 参 考

。

文 章 来 源： 微 电 脑 世 界.

—

朋友可以让时间变得短暂,让快乐加倍的膨胀,让悲伤悄悄的引退,让回忆不再平淡.我想我会喜欢这里.

※ 来源:．月光软件站 http://www.moon-soft.com．[FROM: 61.130.132.158]