基于JAVA的飞机大战游戏的设计与实现计算机毕业设计论文

基于Java的飞机大战游戏的设计与实现

摘 要

飞机大战是电脑游戏发展史中早期最为经典的游戏之一，经常能在掌上游戏机、手机以及电脑上见到这个游戏。不过，以往常见的飞机大战游戏是二维平面上的，并且大多以黑白的形式出现，当然在电脑上可以看到多种颜色的飞机大战。

Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

本游戏是一个基于java的飞机大战游戏，利用Eclipse平台实现经典的飞机大战游戏。游戏主要涉及了游戏状态控制功能、游戏难度的调整、游戏界面绘画功能、玩家游戏控制功能，最终展示了游戏开发的基本开发过程和设计思路。

关键词：飞机大战；游戏；java；Eclipse平台

Design and implementation of airplane wargame based on Java

Abstract

Lightning is the history of the development of computer games in the early one of the

most classic game, often on a handheld game consoles, mobile phone and computer to see

this game. However, the previous common lightning game is two-dimensional plane, and

mostly in black and white, in the course of the computer can see lightning in color.

Since Java is very popular after the launch, the rapid development of the C + + language

to form a strong impact. Java technology has excellent versatility, efficiency, platform

portability and security, widely used in personal PC, data center, game consoles, scientific

supercomputers, cell phones and the Internet, also has the world's largest developer of

professional community . In the world of cloud computing and mobile Internet industry

environment, Java and more have a significant advantage and broad prospects.

This game is a game based on the realization of Java lightning, lightning classic game

based on Eclipse platform. The game is mainly involved in the game state control function,

the difficulty of the game, the game interface to adjust the drawing function, game player

control function, finally shows the basic development process of game development and

design ideas.

Keywords: lightning; game; Java; Eclipse platform

目 录

摘 要 .............................................................. i

Abstract ............................................................ ii

1 引言 .............................................................. 1

1.1 项目背景 ..................................................... 1

1.2 国内外研究现状 ............................................... 1

1.3 项目主要工作 ................................................. 1

1.4 本文组织结构 ................................................. 2

2 开发平台与开发技术 ................................................ 3

2.1 Eclipse ...................................................... 3

2.2 Eclipse平台 .................................................. 3

2.3 Java ......................................................... 4

2.4 Java语言的特点与优势 ......................................... 5

2.5 java技术在游戏开发中的应用 ................................... 6

2.6 UML .......................................................... 8

3 飞机大战游戏模块设计 .............................................. 9

3.1 用户需求分析 ................................................. 9

3.2 可行性分析 ................................................... 9

3.3 总体设计原则 ................................................ 10

3.4 功能模块设计 ................................................ 11

3.4.1 游戏状态控制功能 ...................................... 11

3.4.2 游戏难度的调整 ........................................ 11

3.4.3 游戏界面绘画功能 ...................................... 11

3.4.4 玩家游戏控制功能 ...................................... 11

3.5 游戏难点分析 ................................................ 11

4 飞机大战功能实现 ................................................. 12

4.1 游戏首页的实现 .............................................. 12

4.1.1 界面实现 .............................................. 12

4.1.2 流程图 ................................................ 13

4.1.3 核心代码 .............................................. 14

4.2 游戏开始模块的实现 .......................................... 15

4.2.1 界面实现 .............................................. 15

4.2.2 流程图 ................................................ 16

4.2.3 核心代码 .............................................. 17

4.3 发射子弹模块的实现 .......................................... 18

4.3.1 界面实现 .............................................. 18

4.3.2 流程图 ................................................ 19

4.3.3 核心代码 .............................................. 20

4.4 积分模块的实现 .............................................. 22

4.4.1 界面的实现 ............................................ 22

4.4.2 核心代码 .............................................. 23

4.5 碰撞逻辑 .................................................. 26

4.5.1 碰撞画面的实现 ........................................ 26

4.5.2 核心代码 .............................................. 27

4.6 游戏玩家与BOSS的血条 ..................................... 28

4.6.1 玩家血条和BOSS血条的实现 ............................. 28

4.6.1 核心代码 .............................................. 29

4.7 游戏操作的实现 .............................................. 30

4.7.1 核心代码 .............................................. 30

5 系统测试 ......................................................... 31

5.1 测试的定义及其重要性 ........................................ 31

5.1.1 测试的定义 ............................................ 31

5.1.2 测试的重要性 .......................................... 31

5.2 测试实例的研究与选择 ........................................ 31

5.3 测试结果 .................................................... 32

总结和展望 .......................................................... 33

参考文献 ............................................................ 34

致 谢 ............................................................ 35

外文原文 ............................................................ 36

中文翻译 ............................................................ 42

1 引言

1.1 项目背景

90年代的我们，对小时候的一些经典街机游戏肯定是印象深刻，像 “飞机大战”、“超级玛丽”、“坦克大战”等，这些游戏伴随了我们童年，怀旧经典，重温这些经典的游戏，我选择“飞机大战”作为设计的项目。

而基于JAVA语言开发“飞机大战游戏”，也是对大学知识的一次运用，本次的项目不但可以重拾儿时的回忆，也同样是对大学知识的一次回顾与复习。

飞机大战游戏拥有所有游戏共通的独立成份。它有一个游戏循环（这个过程被反复执行直到游戏退出）。这个游戏循环读取玩家的输入，处理这个输入，然后更新游戏的元素（下落的Enemy airplane），并且检查是Hero airplane的输赢（本机是否空血）。

以后要做的所有的简单的游戏都要用到这些东西，所以学习这个过程并且实现它是非常重要的。当第一次完成它之后，以后再做游戏时就能看出那个游戏有多难以及要花多长时间。如果没有完整的完成过这些，哪怕一次，就永远不能完整地正确领会其中的每个元素。当做大的项目时，就更不能确定其复杂性及所要的时间。如果甚至不能正确地领会这整个过程（因为你没能完成它），可能是没能建立一个合适的时间表或估计合适的时间，更有可能的是不够努力。

1.2 国内外研究现状

Java作为一门成熟的编程语言，以其简单性、可移植性和平台无关性等优点，得到了广泛地应用，对于游戏开发来说，由于涉及到比较复杂的情况，开发过程很多时候是一个不断修改的过程，可以方便的修改游戏内容是十分关键的。由于其虚拟机特性，java本身就可以用来编写游戏脚本，目前也有例如beanshell、groovy等脚本语言可以无缝的和java语言进行交互，这些都极大的方便了java游戏编程。

由于Java语言的的可移植性和平台无关性等优点，如今，国内外对于Java在游戏设计开发的运用有两大方面：一个是手机游戏，另一个就是web上的游戏开发，可见Java语言在游戏开发方面有其优点和独特性。

如今正由于智能手机游戏市场发生重大的变化，ios不再独霸于市场，Android的市场正在不断的扩散。据国外媒体最新报道，Android智能机的市场份额为68%，远高于苹果的17%，用Java语言开发游戏也迎来了黄金期，特别是在手机游戏开发上。

Java语言称霸企业级应用这么多年，事实证明了它非常适合于开发大型软件。如今Java在游戏开发领域，也正开始展露头脚。

1.3 项目主要工作

本次的开发内容——基于JAVA的飞机大战游戏就是游戏与JAVA编程语言相结合的例子。

从游戏的基本玩法出发，主要就是Hero airplane和Enemy airplane的对决，首先应该有个界面来装载整个游戏，然后就是Hero airplane的移动方式（鼠标移动或键盘移动），接下来就是Hero airplane子弹的生成，然后是Enemy airplane的出现方式，

然后Enemy airplane的子弹生成，最后是Hero airplane与Enemy airplane的对战结果。

该游戏要满足以下功能性需求：

（1）游戏状态控制功能

游戏的状态控制包括运行、暂停、恢复及结束游戏，首先进入游戏的加载页面，在游戏进行时，你需要去做其他事情但又不想让游戏结束，你可以选择暂停游戏，当你忙完事情你可以选择恢复游戏，当游戏结束时会提示。

（2）游戏难度的调整

玩家越往后游戏的难度越高，敌机的数量越多、敌机的速度越快、敌机的子弹数量越多且越快。

（3）游戏界面绘画功能

在右上角显示游戏难度，当前游戏得分，与本机血条，游戏主屏主要用来输出用户对Hero airplane的控制与Enemy airplane的动作显示。

（4）玩家游戏控制功能

玩家可以通过控制鼠标或者键盘来控制友机的移动和友机子弹的发射。

1.4 本文组织结构

文本的具体内容和组织结构简述如下：

第一章介绍了本文的研究及应用背景。

第二章介绍了设备平台的基本特征和软件开发环境的功能特性。

第三章主要进行了用户的需求分析，并根据分析结果采用面向对象的设计方法，对记事本软件进行了模块设计。

第四章主要实现了飞机大战游戏的功能模块，对核心功能做了集中阐述，对核心代码做了解释和说明。

第五章对实现的程序进行了模块测试和系统测试，评价了软件的功能，提出了软件的优点和不足。

2 开发平台与开发技术

本章主要介绍软件开发平台如何选择，以及开发平台的合理配置。本软件涉及到的开发平台是Eclipse，开发技术是JAVA技术。下文详述了选择的理由和配置的方法。

2.1 Eclipse

eclipse-galileo

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

虽然大多数用户很乐于将 Eclipse 当作 Java 集成开发环境（IDE）来使用，但

Eclipse 的目标却不仅限于此。Eclipse 还包括插件开发环境（Plug-in Development

Environment，PDE），这个组件主要针对希望扩展 Eclipse 的软件开发人员，因为它允许他们构建与 Eclipse 环境无缝集成的工具。由于 Eclipse 中的每样东西都是插件，对于给 Eclipse 提供插件，以及给用户提供一致和统一的集成开发环境而言，所有工具开发人员都具有同等的发挥场所。

这种平等和一致性并不仅限于 Java 开发工具。尽管 Eclipse 是使用 Java 语言开发的，但它的用途并不限于 Java 语言；例如，支持诸如 C/C++ 、 COBOL、PHP 等编程语言的插件已经可用，或预计将会推出。Eclipse 框架还可用来作为与软件开发无关的其他应用程序类型的基础，比如内容管理系统。

基于 Eclipse 的应用程序的一个突出例子是 IBM Rational Software Architect，它构成了 IBM Java 开发工具系列的基础。

Eclipse是著名的跨平台的自由集成开发环境（IDE）。最初主要用来Java语言开发，通过安装不同的插件Eclipse可以支持不同的计算机语言，比如C++和Python等开发工具。Eclipse的本身只是一个框架平台，但是众多插件的支持使得Eclipse拥有其他功能相对固定的IDE软件很难具有的灵活性。许多软件开发商以Eclipse为框架开发自己的IDE。

Eclipse 最初由OTI和IBM两家公司的IDE产品开发组创建，起始于1999年4月。IBM提供了最初的Eclipse代码基础，包括Platform、JDT 和PDE。Eclipse项目IBM发起，围绕着Eclipse项目已经发展成为了一个庞大的Eclipse联盟，有150多家软件公司参与到Eclipse项目中，其中包括Borland、Rational Software、Red Hat及Sybase等。Eclipse是一个开放源码项目，它其实是Visual Age for Java的替代品，其界面跟先前的Visual Age for Java差不多，但由于其开放源码，任何人都可以免费得到，并可以在此基础上开发各自的插件，因此越来越受人们关注。随后还有包括Oracle在内的许多大公司也纷纷加入了该项目，Eclipse的目标是成为可进行任何语言开发的IDE集成者，使用者只需下载各种语言的插件即可。

2.2 Eclipse平台

Eclipse是著名的跨平台的自由集成开发环境（IDE）。最初主要用来Java语言开发，但是目前亦有人通过插件使其作为其他计算机语言比如C++和Python的开发工具。Eclipse的本身只是一个框架平台，但是众多插件的支持使得Eclipse拥有其他功能相

对固定的IDE软件很难具有的灵活性。许多软件开发商以Eclipse为框架开发自己的IDE。

Eclipse 最初由OTI和IBM两家公司的IDE产品开发组创建，起始于1999年4月。IBM提供了最初的Eclipse代码基础，包括Platform、JDT 和PDE。目前由IBM牵头，围绕着Eclipse项目已经发展成为了一个庞大的Eclipse联盟，有150多家软件公司参与到Eclipse项目中，其中包括Borland、Rational Software、Red Hat及Sybase等。Eclipse是一个开发源码项目，它其实是Visual Age for Java的替代品，其界面跟先前的Visual Age for Java差不多，但由于其开放源码，任何人都可以免费得到，并可以在此基础上开发各自的插件，因此越来越受人们关注。近期还有包括Oracle在内的许多大公司也纷纷加入了该项目，并宣称Eclipse将来能成为可进行任何语言开发的IDE集大成者，使用者只需下载各种语言的插件即可。

2.3 Java

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun

Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaSE,

JavaEE, JavaME）的总称。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。后来Sun公司被甲骨文公司并购，Java也随之成为甲骨文公司的产品。

Java是一种计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

Java 编程语言的风格十分接近C、C++语言。Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）、多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic

Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。

Java 不同于一般的编译执行计算机语言和解释执行计算机语言。它首先将源代码编译成二进制字节码（bytecode），然后依赖各种不同平台上的虚拟机来解释执行字节码。从而实现了“一次编译、到处执行”的跨平台特性。不过，每次的执行编译后的字

节码需要消耗一定的时间，这同时也在一定程度上降低了 Java 程序的运行效率。

平台无关性是指Java能运行于不同的平台。Java引进虚拟机 原理，并运行于虚拟机，实现不同平台的Java接口之间。使用Java编写的程序能在世界范围内共享。Java的数据类型与 机器无关，Java虚拟机（Java Virtual Machine）是建立在硬件和操作系统之上，实现Java二进制代码的解释执行功能， 提供于不同平台的接口的。

Java的编程类似C++，学习过C++的读者将很快掌握Java的精髓。Java舍弃了C++的指针对存储器地址的直接操作，程序运行时，内存由操作系统分配，这样可以避免病毒通过指针侵入系统。Java对程序提供了安全管理器，防止程序的非法访问。

Java吸取了C++面向对象的概念，将数据封装于类中，利用类的优点，实现了程序的简洁性和便于维护性。类的封装性、继承性等有关对象的特性，使程序代码只需一次编译，然后通过上述特性反复利用。程序员只需把主要精力用在类和接口的设计和应用上。Java提供了众多的一般对象的类，通过继承即可使用父类的方法。在Java中，类的继承关系是单一的非多重的，一个子类只有一个父类，子类的父类又有一个父类。Java提供的Object类及其子类的继承关系如同一棵倒立的树形，根类为Object类，Object类功能强大，经常会使用到它及其它派生的子类。

Java建立在扩展TCP/IP网络平台上。库函数提供了用HTTP和FTP协议传送和接受信息的方法。这使得程序员使用网络上的文件和使用本机文件一样容易。

Java致力于检查程序在编译和运行时的错误。类型检查帮助检查出许多开发早期出现的错误。Java自己操纵内存减少了内存出错的可能性。Java还实现了真数组，避免了覆盖数据的可能，这些功能特征大大提高了开发Java应用程序的周期。并且Java还提供了Null指针检测、数组边界检测、异常出口、Byte code校验等功能。

2.4 Java语言的特点与优势

（1）平台无关性

平台无关性是指Java能运行于不同的平台。Java引进虚拟机 原理，并运行于虚拟机，实现不同平台的Java接口之间。使用Java编写的程序能在世界范围内共享。Java的数据类型与 机器无关，Java虚拟机（Java Virtual Machine）是建立在硬件和操作系统之上，实现Java二进制代码的解释执行功能， 提供于不同平台的接口的。

（2）安全性

Java的编程类似C++，学习过C++的读者将很快掌握Java的精髓。Java舍弃了C++的指针对存储器地址的直接操作，程序运行时，内存由操作系统分配，这样可以避免病毒通过指针侵入系统。Java对程序提供了安全管理器，防止程序的非法访问。

（3）面向对象

Java吸取了C++面向对象的概念，将数据封装于类中，利用类的优点，实现了程序的简洁性和便于维护性。类的封装性、继承性等有关对象的特性，使程序代码只需一次编译，然后通过上述特性反复利用。程序员只需把主要精力用在类和接口的设计和应用上。Java提供了众多的一般对象的类，通过继承即可使用父类的方法。在Java中，类的继承关系是单一的非多重的，一个子类只有一个父类，子类的父类又有一个父类。Java提供的Object类及其子类的继承关系如同一棵倒立的树形，根类为Object类，Object类功能强大，经常会使用到它及其它派生的子类。

（4）分布式

Java建立在扩展TCP/IP网络平台上。库函数提供了用HTTP和FTP协议传送和接受信息的方法。这使得程序员使用网络上的文件和使用本机文件一样容易。

（5）健壮性

Java致力于检查程序在编译和运行时的错误。类型检查帮助检查出许多开发早期出现的错误。Java自己操纵内存减少了内存出错的可能性。Java还实现了真数组，避免了覆盖数据的可能，这些功能特征大大提高了开发Java应用程序的周期。并且Java还提供了Null指针检测、数组边界检测、异常出口、Byte code校验等功能。

2.5 java技术在游戏开发中的应用

（1）绘图技术

Applet程序中所采用的AWT的绘图机制主要涉及三个方法：paint()方法、update()方法和repaint()方法，update()方法和paint()方法都有一个Graphics类参数。Graphics是画图的关键，它可以支持两种绘图：一种是基本的绘图，如：画线、矩形、圆等；另一种是画图象，主要用于动画制作。

要进行绘图，首先要找到一个Graphics类的对象。update()方法和paint()方法所传递的参数都是Graphics类的对象，因此主要是通过重载它们来进行绘图，这是在动画程序中经常使用的方法。我们还可以通过getGraphics()方法得到一个Graphics类的对象，这个对象和update()方法和paint()方法中所传递的对象一样，都是该成员所对应的Graphics类的对象。得到了Graphics类的对象，就可使用各种绘图方法。Graphics中提供的图形绘制方法有：

paint( )：进行绘图的具体操作，必须有程序员重写；

update( )：用于更新图形，先清除背景、前景，再调用paint()；

repaint( )：用于重绘图形，在组件外形发生变化，即大小改变或位置移动repaint( )方法立即被系统自动调用，而实际上repaint()方法是自动调用update()方法。

（2）游戏开发中的交互

一个优秀的游戏必定是与玩家不断的沟通，给予玩家充分的操作时间，而游戏又必须快速地，正确的对玩家的动作作出反映，否则这样的游戏，不能称为一个好游戏。所以说，游戏开发中的交互与其他技术有着相同的地位，是一个游戏必备的核心。在Java游戏的开发中，往往使用事件处理器来进行设计。

事件：用户对程序的某一种功能性操作。Java中的事件主要有两种：组件类事件、动作类事件。

事件编程：用户编程定义每个特定事件发生时程序应做出何种响应，并且这些响应代码会在对应的事件发生时由系统自动调用。事件源是产出事件的组件。监听器是对组件所产生的事件作出具体响应的代吗，即事件产出与处理分别由两个不同类加以编程实现。事件处理机制是AWT组件自身不编程处理相应的事件，面是交由事件监听器处理。

事件适配器：由于事件监听器接口是Abstract类型，意谓着实现该接口的类应全部实现其各个成员函数，但实际应用中可能只需处理某些事件响应代码；此时再采用实现事件监听器接口可能会导致编程复杂。JDK中提供事件适配器方式来实现事件编程。

（3）基于AWT及SWING的游戏界面开发

抽象窗口工具包AWT (Abstract Window Toolkit) 是API为Java程序提供的建立图形用户界面GUI (Graphics User Interface)工具集，AWT可用于Java的applet和

applications中。它支持图形用户界面编程的功能包括： 用户界面组件；事件处理模型；图形和图像工具，包括形状、颜色和字体类；布局管理器，可以进行灵活的窗口布局而与特定窗口的尺寸和屏幕分辨率无关；数据传送类，可以通过本地平台的剪贴板来进行剪切和粘贴。

AWT是Swing的基础。Swing的产生主要原因就是AWT不能满足图形化用户界面发展的需要。AWT设计的初衷是支持开发小应用程序的简单用户界面。随着发展的需要，Swing出现了，Swing组件几乎都是轻量组件，与重量组件相比，没有本地的对等组件，不像重量组件要在它们自己的本地不透明窗体中绘制，轻量组件在它们的重量组件的窗口中绘制。Swing是由100%纯Java实现的，Swing组件是用Java实现的轻量级（ light-weight）组件，没有本地代码，不依赖操作系统的支持，这是它与AWT组件的最大区别。由于AWT组件通过与具体平台相关的对等类（Peer）实现，因此Swing比AWT组件具有更强的实用性。Swing在不同的平台上表现一致，并且有能力提供本地窗口系统不支持的其它特性。Swing采用了一种MVC的设计范式，即”模型-视图-控制”。

（4）多线程技术的应用

线程简介：进程就是程序的运行时的一个实例。线程可以看作单独地占有CPU时间来执行相应的代码的。对早期的计算机（如DOS）而言，线程既是进程，进程既是进程，因为它是单线程的。当然一个程序可以是多线程的，多线程的各个线程看上去像是并行地独自完成各自的工作，就像一台一台计算机上运行着多个处理机一样。在多处理机计算机上实现多线程时，它们确实可以并行工作，而且采用适当的分时策略可以大大提高程序运行的效率。但是二者还是有较大的不同的，线程是共享地址空间的，也就是说多线程可以同时读取相同的地址空间，并且利用这个空间进行交换数据。

Java实现多线程的过程：与其他语言不一样的是，线程的观念在Java是语言中是重要的，根深蒂固的，因为在Java语言中的线程系统是Java语言自建的， Java中有专门的支持多线程的API库。在使用Java创建线程的时候，你可以生成一个Thread类或者他的子类对象，并给这个对象发送start()消息（程序可以向任何一个派生自Runnable接口的类对象发送start() 消息的），这样一来程序会一直执行，直到run返回为止，此时该线程就死掉了。

（5）Java网络技术的应用

Java最初是作为一种网络编程语言出现的，它能够使用网络上的各种资源和数据，与服务器建立各种传输通道，将自己的数据传送到网络的各个地方。你可以用Java很轻松地完成这些，因为Java类库提供了很强大的网络功能。

Java中有关网络方面的功能都定义在程序包中。Java所提供的网络功能可大致分为三大类：

(1)URL和URLConnection这是三大类功能中最高级的一种。通过URL的网络资源表达方式，很容易确定网络上数据的位置。利用URL的表示和建立，Java程序可以直接读入网络上所放的数据，或把自己的数据传送到网络的另一端。

(2)Socket所谓Socket，可以想像成两个不同的程序通过网络的通道，而这是传统网络程序中最常用的方法。一般在TCP/IP网络协议下的客户服务器软件采用Socket作为交互的方式。

(3)Datagram是这些功能中最低级的一种。其他网络数据传送方式，都假想在程序执行时，建立一条安全稳定的通道。但是以Datagram的方式传送数据时，只是把数据

的目的地记录在数据包中，然后就直接放在网络上进行传输，系统不保证数据一定能够安全送到，也不能确定什么时候可以送到。也就是说，Datagram不能保证传送质量。

2.6 UML

面向对象软件开发方法已经成为现代软件工程的重要手段。应用面向对象方法设计的软件组件可以方便的实现软件重用。同时这种机制将传统的以数据为中心的软件开发方法，改变为同时关注数据的信息与功能，从而可以开发出适应信息与功能变化的系统。

UML语言是目前应用最为广泛的面向对象软件建模语言，其完整丰富的图形和符号为表达面向对象系统模型提供了有力的支持。但是UML本身只是一种描述工具，而不是一种开发方法，使用UML快速设计和表达系统模型，必须有有效的设计方法支。

3 飞机大战游戏模块设计

3.1 用户需求分析

飞机大战游戏拥有所有游戏共通的独立成份。它有一个游戏循环（这个过程被反复执行直到游戏退出）。这个游戏循环读取玩家的输入，处理这个输入，然后更新游戏的元素（下落的Enemy airplane），并且检查是Hero airplane的输赢（本机是否空血）。

从游戏的基本玩法出发，主要就是Hero airplane和Enemy airplane的对决，首先应该有个界面来装载整个游戏，然后就是Hero airplane的移动方式（鼠标移动或键盘移动），接下来就是Hero airplane子弹的生成，然后是Enemy airplane的出现方式，然后Enemy airplane的子弹生成，最后是Hero airplane与Enemy airplane的对战结果。

该游戏主要包括以下几个功能：

（1）游戏状态控制功能

（2）游戏难度的调整

（3）游戏界面绘画功能

（4）玩家游戏控制功能

游戏程序是一项精度要求很高的程序系统，因为其代码利用率很高。一个实时运行的最终作品，每秒都会运行成千上万行程序，绘图事件、键盘事件都会以极高的频率在后台等待响应，若有丝毫的差别都将很容易导致程序在运行不久后可能出现严重错误，甚至死循环。因此，其逻辑设计应当相当严谨，需将所有可能发生的事件及意外情况考虑在设计中。

这款游戏名字叫“飞机大战游戏”。在这款游戏中，玩家控制的飞机将出现在屏幕的下方，敌机则出现在屏幕的上方。双方以互相攻击的方式，以及上下左右移动躲避对方的攻击。玩家实际是控制自己，尽量多的打中敌机和避免敌机的子弹打中自己，玩家的初始生命值是100，每被敌人的子弹打中减少10，当玩家飞机生命为0时，则游戏结束。当攻击命中敌人时，就可以打死敌人，直到杀死关卡所有的敌人，玩家获得本关卡的胜利。游戏画面主要是一般的图片，本游戏主要是（上、下、左、右）控制玩家飞机的移动方向，Z键玩家发射子弹，空格键玩家发动全屏爆炸，是一款简单易懂容易上手的休闲单机游戏。

3.2 可行性分析

可行性分析也称为可行性研究，是在调查的基础上，针对新软件的开发是否具备必要性和可能性，对新软件的开发从技术、经济、社会等方面进行分析和研究，以避免投资失误，保证新软件的开发成功[2]。可行性研究的目的就是用最小的代价在尽可能短的时间内确定问题是否能够解决。

下面将分别从技术、经济、社会三个方面对基于java的飞机大战游戏的建设进行分析和研究。

（1）技术可行性

说技术上的可行性主要分析技术条件能否顺利完成开发工作，硬、软件能否满足开发者的需要等。该软件采用的开发工具是功能强大的Eclipse3.1，他具有是十分强的功能扩展能力，需要的只是下载安装相关的插件，开发平台J2ME更是当前最受欢迎的手机软件开发平台，而且它完全满足飞机大战游戏的开发实现的要求。因此，软件的软件开发平台已成熟可行。硬件方面，科技飞速发展的今天，硬件更新的速度越来越快，容量越来越大，可靠性越来越高，价格越来越低，其硬件平台完全能满足此软件的需要。

由以上分析可知，本软件的开发在技术上是可行的。

（2）经济可行性

本软件开发成本低，在经济上是可以接受的，并且本软件实施后可以显著提高工作效率，有助于飞机大战游戏的管理。而且软件维护简单，实用性强，一次性开发使用，即可长久使用，要做的只是把软件加载在移动通信设备上。当软件满足不了用户需求时，只需对信息加以更新，对具体功能模块加以改进完善。

由以上分析可知，本软件在经济上是可行的。

（3）社会可行性

本软件的社会可行性主要从法律因素、用户使用可行性两方面进行研究。

(1)法律因素

本软件是根据基于java的飞机大战游戏的实际工作情况开发研制的，是通过大量的调研得出的，软件的软件设计是在独立的环境下完成的，无可供抄袭的软件产品。

(2)用户使用可行性

本软件对用户的要求，不需要特别的技术能力。使用软件的管理员，在投入使用前，无需对使用人员进行培训。这样既减少投入成本又简化了操作环节。

由以上分析可知，本软件具有社会可行性。

3.3 总体设计原则

本软件为了设计、实现和后期维护的方便，以及软件用户使用的便利，所以必须采取一定的设计原则。其主要设计原则有：

简单性：在实现软件的功能的同时，尽量让软件操作简单易懂，这对于一个软件来说是非常重要的。

针对性：本软件设计是基于java的飞机大战游戏的需求定向开发设计，所以具有专业突出和很强的针对性。

实用性：要求本软件能够满足基于java的飞机大战游戏的需要，因此具有良好的实用性。

一致性：界面整体设计风格以及命名规则的一致性：整体界面布局和用图用色风格及变量、类名和其他元素的命名规则保持一致。功能一致性：完成同样的功能应该尽量使用同样的元素。元素风格一致性：界面元素的美观风格、摆放位置在同一个界面和不同界面之间都应该是一致的。变量命名规则的一致性：变量应该用统一的规则进行命名，做到任意变量均能从上下文推断其义。

3.4 功能模块设计

3.4.1 游戏状态控制功能

游戏的状态控制包括运行及结束游戏，首先进入游戏的加载页面，在游戏进行时，你需要去打死所有的敌机来完成当前关卡，你的生命降低为0的时候游戏就会结束，界面会出现提示。

3.4.2 游戏难度的调整

玩家越往后游戏的难度越高，敌机的数量越多、敌机的速度越快、敌机的子弹数量越多且越快。

3.4.3 游戏界面绘画功能

在右下角显示本机血条，左下角显示持有炸弹数和所得分数，游戏主屏主要用来输出用户对Hero airplane的控制与Enemy airplane的动作显示。

3.4.4 玩家游戏控制功能

玩家可以通过控制鼠标或者键盘来控制友机的移动和友机子弹的发射。

3.5 游戏难点分析

（1）绘图美化。游戏优美清新的界面会给用户带来愉悦的心情和美感。所以在本游戏中，主要采用借鉴原有的游戏的画面，友机和敌机的形象也应美观。

（2）多线程技术的实现。线程机制的应用是实现游戏控制的基石，游戏中的刷帧、后台资源的加载以及对各类角色（如敌机，友机）的自动控制都需要线程来实现，以此来实现对整个游戏的控制。

（3）碰撞问题的解决。比如敌机和友机，敌机子弹和友机等等。碰撞检测技术的实现要综合运用数学和物理知识，在不同的情况下，采用不同的碰撞检测方式。

（4）动画的实现。利用图片数组、切片的变换形成的动画。图片数组，不断改变画在画布上的图片数组下标，从而实现动画的形成，即一张图片是一帧。利用切片来实现动画，所有帧数都放在同一张图片中，以此来实现爆炸效果。

4 飞机大战功能实现

4.1 游戏首页的实现

4.1.1 界面实现

飞机大战的界面如图4-1所示。

图4-1 飞机大战游戏开始界面

4.1.2 流程图

游戏开始的流程图如图4-2所示。

图4-2 游戏初始化流程图

4.1.3 核心代码

游戏初始化代码如下：

public final void paint(Graphics g) {

or(r);

ct(x, y, width, height);

or(r);

ct(x, y, width, height);

oxContents(g);

}

private void paintBlock(int x, int y, int blockType, Graphics g) {

int blockX = + (ize * x);

IntblockY=+(ize*(_

VISIBLE_ROW));

if(_EMPTY != blockType) {

or(_BLACK);

ct(blockX + 1, blockY + 1, ize - 1, this.

blockSize - 1);

or(blockType, g);

ct(blockX, blockY, ize - 1, ize - 1);

} else {

or(_WHITE);

ct(blockX, blockY, ize, ize);

}

}

4.2 游戏开始模块的实现

4.2.1 界面实现

飞机大战的开始界面如图4-3所示。

图4-3 飞机大战开始界面

4.2.2 流程图

流程图如图4-4所示。

图4-4 游戏开始模块程序流程图

4.2.3 核心代码

下面是游戏开始模块的功能代码，如下：

private int clearCompletedRows(TetrisPiece piece) {

TetrisBoard board = rd();

for(int i = 0; i < _BLOCKS; i++) {

int rowY = ckY(i);

if(owCompleted(rowY)) {

wCompleted(rowY, true);

}

}

int numClearedRows = 0;

for(int y = - 1; y >= 0; y--) {

if(numClearedRows > 0) {

w(y, numClearedRows);

}

if(ompleted(y)) {

numClearedRows++;

wCompleted(y, false);

}

}

for(int i = 0; i < numClearedRows; i++) {

ow(i);

}

return numClearedRows;

}

4.3 发射子弹模块的实现

4.3.1 界面实现

发射子弹界面实现如图4-5所示。

图4-5 发射子弹界面

4.3.2 流程图

流程图如图4-6所示。

图4-6 发射子弹模块程序流程图

4.3.3 核心代码

发射子弹实现代码如下：

public void rotate(int pivotX, int pivotY, boolean rotateDirection) {

if(ON_TYPE_TOGGLE == onType) {

// 如果翻转类型为TOGGLE

rotateDirection = onToggle; //判断翻转方向

onToggle = !onToggle; // 如果与canRotate匹配，

中心点方块将被使用

}

// 重构四个小块，每个都转动

for(int i = 0; i < _BLOCKS; i++) {

int blockX = ckX(i);

int blockY = ckY(i);

// 左旋转：交换x和y坐标，x坐标取反

// 右旋转：交换x和以坐标，y坐标取反

int dx = blockY - pivotY;

int dy = blockX - pivotX;

if(rotateDirection) {

// 如向左旋转

dx *= -1;

} else {

// 如向右旋转

dy *= -1;

}

int rotateX = pivotX + dx;

int rotateY = pivotY + dy;

ckCoords(i, rotateX, rotateY);//得到翻转后的新坐标

}

}

选中敌机目标后，开始发射子弹。在中的checkRowCompleted()方法实现了此功能，其代码如下：

public boolean checkRowCompleted(int rowY) {

for(int x = 0; x < ; x++) {

if(_EMPTY == ckType(x, rowY)) {

// 选中目标，发射子弹

return false;

}

}

return true;

}

当击中敌机后，积分就会有所变化，计算并显示出用户当前的分数。同时等待玩家

键入数字，选择游戏难度开始新的游戏。其实现由init()方法控制，其代码如下：

private void init() {

= new TetrisBoard();

nvas = new TetrisCanvas(this);

Piece = new TetrisPiece();

tedRows = new boolean[]; //初始化数组

e = dReadHiScore();

eceType = IALIZED;

= new Random();

// 设置exit/pause/resume命令

ommands();

mand(mmand);

// 显示title屏

eState(_STATE);

}

4.4 积分模块的实现

4.4.1 界面的实现

飞机大战积分模块界面如图4-7所示。

图4-7 积分模块

4.4.2 核心代码

积分板实现代码如下：

public void drawCount(Graphics g){

or();

Font font = new Font("宋体", 1, 20);

t(font);

ring("积分:" + , 0, 470);

}

实现积分的增长：

if (burst != null)

(g_off);

for (int i = 0; i < (); i++) {

Role chara1 = (Role) (i);

if (()) {

if (chara1 instanceof Enemy)

{

rst(g_off);

++;

}

(i);

}

}

全屏爆炸时，计算炸死几个敌人增长分数：

if(ount>0){

for (int i = 0; i < (); i++) {

Role chara1 = (Role) (i);

if(!(chara1 instanceof Battle) && chara1.x>0 && chara1.y>0

&& !(chara1 instanceof BossA) && !(chara1 instanceof BossB)

&& !(chara1 instanceof BossC)){

(i);

if(chara1 instanceof Enemy){

++;

}

实现积分的输出：

private void gameOver() {

ount = 10;

if () {

gameMode = 12;

stage = 1;

} else {

g_or();

}

}

Font font = new Font("黑体", 1, 28);

g_t(font);

FontMetrics fontMetrics = getFontMetrics(font);

g_ring("Game Over", (450 - fontMetrics

.stringWidth("Game Over")) / 2, (500 + fontMetrics

.getHeight()) / 2 - 50);

String score = "Score: " + ;

g_ring(score, (450 - fontMetrics

.stringWidth(score)) / 2, (500 + fontMetrics

.getHeight()) / 2 - 20);

if (15 <= current % 50)

g_ring("请按 回车", (450 - fontMetrics

.stringWidth("请按 回车")) / 2,

(500 + ght()) / 2 + 100);

积分的输出如图4-8所示。

图4-8 积分的输出

4.5 碰撞逻辑

判断飞机是否中弹的逻辑非常简单就是在绘制飞机与子弹的时候判断两个图片是否存在重合的部分，如果存在则在该重合位置绘制一个爆炸图片，之后将中弹飞机从飞机队列中删除，子弹同样的处理。

4.5.1 碰撞画面的实现

绘制爆炸如图4-9所示。

图4-9 绘制爆炸图片

4.5.2 核心代码

碰撞逻辑核心代码如下：

public boolean checkHit(Role chara) {

if ((chara instanceof EnemyA) || (chara instanceof EnemyB)|| (chara

instanceof EnemyC) || (chara instanceof EnemyShot)) {

if ((x + WIDTH) - 14F > chara.x && x + 14F < chara.x +

&& (y + HEIGHT) - 12F > chara.y

&& y + 12F < chara.y + ) {

//如果碰到敌人,敌人死亡

();

//如果碰到子弹血量减少

if (chara instanceof EnemyBeam){

power--;

}

power -= 50;

if (power <= 0) {

dead();

//绘制爆炸图片

= new Burst(x, y);

}

return true;

}

4.6 游戏玩家与BOSS的血条

绘制玩家飞机血条和Boss血条的逻辑是相同的，在统计飞机中弹次数的情况下使用图。

4.6.1 玩家血条和BOSS血条的实现

BOSS的血条和玩家飞机的血条如图4-10所示。

图4-10 BOSS血条和玩家的血条

4.6.1 核心代码

玩家血条和BOSS血条核心代码如下：

for (int i = 0; i < (); i++) {

Role chara1 = (Role) (i);

for (int j = 0; j < (); j++) {

Role chara2 = (Role) (j);

it(chara2);

}

}

for (int i = 0; i < (); i++) {

Role chara1 = (Role) (i);

if (chara1 instanceof Boss) {

boss = (Boss) chara1;

if (!()) {

wer(g_off);

} else {

bossX = ();

bossY = ();

heroX = ();

zikiY = ();

gameMode = 14;

}

}

}

4.7 游戏操作的实现

本游戏操作采用键盘的上下左右键来实现玩家飞机的移动。

4.7.1 核心代码

游戏操作实现代码如下：

public void move() {

oldx = x;

oldy = y;

if () {

if ()

x -= (double) speed / 4D;

else

x -= speed;

if (x <= 0.0F)

x = 0.0F;

}

if () {

if ()

x += (double) speed / 4D;

else

x += speed;

if (x + WIDTH >= (float) th())

x = (float) th() - WIDTH;

}

if () {

if ()

y += (double) speed / 4D;

else

y += speed;

if (y + HEIGHT >= (float) ght())

y = (float) ght() - HEIGHT;

}

if () {

if ()

y -= (double) speed / 4D;

else

y -= speed;

if (y <= 0.0F)

y = 0.0F;

}

5 系统测试

测试是开发时期最后一个阶段，是保证软件质量的重要手段。软件测试就是在受控制的条件下对软件或应用程序进行操作并评价操作结果的过程，所谓控制条件应包括正常条件与非正常条件。软件测试过程中应该故意地去促使错误的发生，也就是事情在不该出现的时候出现或者在应该出现的时候没有出现。从本质上说，软件测试是"探测"，在"探测"中发现软件的毛病。

5.1 测试的定义及其重要性

5.1.1 测试的定义

软件测试是为了发现错误而执行程序的过程。它不仅是软件开发阶段的有机组成部分，而且在整个软件工程(即软件定义、设计和开发过程)中占据相当大的比重。软件测试是软件质量保证的关键环节，直接影响着软件的质量评估。软件测试不仅要讲究策略，更要讲究时效性。验收测试作为软件测试过程的最后一个环节，对软件质量、软件的可交付性和软件项目的实施周期起到"一锤定音"的作用。

5.1.2 测试的重要性

软件测试在软件生命周期中占据重要的地位，在传统的瀑布模型中，软件测试学仅处于运行维护阶段之前，是软件产品交付用户使用之前保证软件质量的重要手段。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。

事实上，对于软件来讲，不论采用什么技术和什么方法，软件中仍然会有错。采用新的语言、先进的开发方式、完善的开发过程，可以减少错误的引入，但是不可能完全杜绝软件中的错误，这些引入的错误需要测试来找出，软件中的错误密度也需要测试来进行估计。测试是所有工程学科的基本组成单元，是软件开发的重要部分。自有程序设计的那天起测试就一直伴随着。统计表明，在典型的软件开发项目中，软件测试工作量往往占软件开发总工作量的40％以上。而在软件开发的总成本中，用在测试上的开销要占30％到50％。如果把维护阶段也考虑在内，讨论整个软件生存期时，测试的成本比例也许会有所降低，但实际上维护工作相当于二次开发，乃至多次开发，其中必定还包含有许多测试工作。

5.2 测试实例的研究与选择

程序测试的主要方法分为两大类，白盒测试和黑盒测试。

白盒测试：一种是以程序的内部逻辑结构为依据而设计测试用例的方法，因而又称结构测试或玻璃盒测试，将软件看成一个透明的白盒子，按照程序的内部结构和处理逻辑来选定测试用例，对软件的逻辑路径及过程进行测试，检查它与设计是否相符。白盒测试就是要选取足够的测试用例，对源代码实行比较充分的覆盖，以便尽可能多地发现程序中的错误。主要有两种方法：一种称为逻辑覆盖法，另一种称为路径覆盖法。

黑盒测试：也称功能测试，数据驱动测试等，它将待测对象堪称是一个黑盒子，在完全不考虑程序的内部结构和特性的情况下，只依据规格说明书检查程序的功能是否能正常使用。

黑盒测试主要是根据输入条件和输出条件的确定测试数据，来检查程序是否能产生正确的输出。进行黑盒测试主要有下面几种方法：等价分类法、边界值分析法、猜错法、因果图法。

本系统的测试综合了白盒测试、黑盒测试两种方法，但主要使用的是黑盒测试方法。在测试当中遵循了“尽早地和不断进行测试”，“保证测试用例的完整性和有效性”原则。通过测试达到以下测试目的：

（1）功能检查。

检查功能是否争取，是否遗漏或实现不了应该实现的功能等。

（2）接口检查。

检查能否正确地接受信息或输出信息。

（3）数据检查。

检查数据结构或外部信息是否有（如数据文件）访问错误。

（4）性能检查。

检查性能需求能否得到满足。

（5）初始化、终止检查。

检查是否能进行正确地初始化或终止。

5.3 测试结果

软件评价是指软件在正式运行了一段时间之后，对它在功能上、技术上和经济上所进行的审核评价。针对本软件的评价如下：

（1）软件功能评价

根据本软件开发前所订的目标，在软件完成后经过测试运行，该软件达到了预定的开发目标，在实际使用中的功能可以满足用户需求。

（2）软件技术评价

本软件设计合理，功能达到了预期目标，且软件运行后稳定可靠，安全性高，具有实用性，大大提高了信访办公效率。

（3）软件经济评价

在规定时间内，该软件完成了软件分析时所确定的软件开发目标，达到了设计要求，投入使用后为用户节省了大量人力物力财力，提高了科学管理水平。

总结和展望

本次毕业设计做的是基于Java的飞机大战游戏的设计与实现，是本人第一次完整的使用Java开发软件，在软件开发设计过程中，让我对Java有了进一步的了解，极大提高了编程能力。通过这次毕业设计，让我深深的体会到要完整地开发一个软件，前期工作是十分重要的，即开工前一定要有软件工程学的概念，如软件的需求分析、总体设计、详细设计等，还包括软件的结构安排、代码编程的模块划分。并且在这基础上，逐步的开发软件，这样定能达到事半功倍的效果。

整个软件按照预期目标大致实现了飞机大战游戏的功能，当然由于个人技术有限以及时间的不足，软件可能还存在一些不足，有待于日后进一步的改进和完善。

参考文献

[1] 荣钦科技.Java2游戏设计[M]．北京．清华大学出版社．2004．

[2] 程成．软件工程[M]．北京．机械工业出版社．2003．

[3] 袁海燕，王文涛．Java实用程序设计100例[M]．北京．人民邮电出版社．2005．

[4] 王伯欣．J2ME无线Java应用开发[M]．北京．人民邮电出版社．2002．

[5] 曹莹，苗志刚，赵秀明．浅谈Java优势[J]．中国科技信息，2006．

[6] 邵敏敏，陈德平．解析Java的多线程机制[J]．电脑知识与技术．2006．

[7] 朱平．Java程序设计教学[J]．湖北教育学院学报．2006．

[8] 孟伟君．李龙海．付少锋．周利华．基于VC++和JAVA的多线程设计和实现[J]．2006．

[9] 秦琴．Java语言的异常处理设计[J]．中国科技信息．2006．

[10] 倪道义．手机游戏架构分析[J]．科技论坛，2011，(9)：90．

[11] Rick Rogers，John Lombardo，Meike Blake．Android Appliaction Development[D]．

Shroff Publishers & Distributors Pvt Ltd．2010．

[12] Stephen J. Chapman ．Introduction to Java [M]．Prentice Hall．1999．

[13] Bruce Eckel．Thinking in Java [M] ．Prentice Hall．2006．

致 谢

大学生活在这个时候即将划上一个句号。但是对于我的人生道路来说，这仅仅是一个逗号，我将面对的是又一次征程的开始。

回忆过去，许许多多的事情浮现在脑海：刚上大学时欢乐心情和兴奋的场景还历历在目。一切都是那么新鲜，那么富有吸引力。有快乐也有艰辛，有收获也有失落。衷心感谢软件学院所有支持帮助过我的老师，谢谢你们多年来的关心和爱护。同窗的友情同样难忘，你们与我共同走过了人生中不平凡的道路，给我留下了值得珍藏的美好记忆。

最后，我要特别感谢指导教师李老师和校内指导老师朱老师。本论文是在他们的悉心指导和热情帮助下完成的，老师认真负责的工作态度，严谨的治学精神和精深的理论水平都使我受益匪浅。他们无论在理论上还是在实践中，都给予我很大的帮助，使我专业技能的应用水平得到很大提高，这对于我以后的工作和学习都有益处。值此论文完成之际，特别向指导老师表示衷心的感谢和崇高的敬意，谢谢他们细心而又耐心地辅导，使得我得以顺利的完成毕业设计开发工作，同时也要感谢其他帮助过我的老师和同学，他们在我成长过程中给予了我很大的帮助，在此一并表示感谢。

由于本人水平有限，加上时间紧促，本文一定有不少缺点和不足，恳请各位老师给予帮助和指正。

外文原文

Introduction to Java Applications

Java programs consist of pieces called classes. You can program each piece you may

need to from a Java program. However, most Java programmers take advantage of rich

collections of existing classes in java libraries. Thus, there are really two pieces to learning

the java “world”, the first is learning the java language itself so that you can program your

own classes; the second is how to use the classes in the extensive java class libraries.

The Java language facilitates a disciplined approach to computer program design. We

now introduce Java programming and present examples that illustrate several important

features of Java. Each example is analyzed one line at a time. We present a detailed treatment

of program development and program control in Java.

Java uses notations that may appear strange to nonprogrammers. We begin by

considering a simple application that displayed a line of text. An application is a program that

executes using the java interpreter (discussed later in this section).

This program illustrates several important features of the Java language. We consider

each line of the program in detail. Each program we present in this book has line numbers

included for the reader’s convenience; line numbers are not part of actual Java programs.

Line 9 does the “real word”of the program, namely displaying the phrase Welcome to Java

Programming! But let us consider each line in order. Line 1,

Begins with//, indicating that the remainder of the line is a comment. Programmers

insert comments to document programs and improve program readability. Comments also

help other people read and understand a program. Comments do not cause the computer to

perform any action when the program is run. The Java compiler ignores comments. We begin

every program with a comment indicating the figure number and file name (line1).

//

// A first program in Java.

public class Welcome1{

// main method begins execution of Java application

public static void main (String args [ ])

{

n (“Welcome to Java Programming!”);

} // end method main

know all of the details of a feature in order for you to use that feature in Java. All

programmers initially learn how to program by mimicking what other programmers have

done before them. For each detail we ask you to mimic, we indicate where the full discussion

will be presented later in the text.

When you save your public class definition in a file, the file name must be the class

name followed by the “.java” file-name extension. For our application the file name is

Java class definitions are stored in files ending with the file-name

extension” java.”

It is an error for a public class if the file name is not identical to the class name (plus

the .java extension) in terms of both spelling and capitalization. Therefore, it is also an error

for a file to contain two or more public classes.

It is an error not to end a file name with the .java extension for a file containing an

application’s class definition. If the extension is missing, the Java compiler will not be able to

compile the class definition.

A left brace (at the end of line 4), {begin the body of every class definition. A

corresponding right brace (in line 13 in this program),}, must end each class definition.

Notice that lines 6-11 are indented. This indentation is one of the spacing conventions

mentioned earlier. We define each spacing convention as a good programming Practice.

Whenever you type an opening left brace, {, in your program, immediately type the

closing right brace,}, then reposition the cursor between the braces to begin typing the body.

This practice helps prevent errors due to missing braces.

Indent the entire body of each class definition one “level” of indentation between the left

brace, {, and the right brace,}, that define the body of the class. This format emphasizes the

structure of the class definition and helps make the class definition easier to read.

Set a convention for the indent size you prefer, and then uniformly apply that convention.

The Tab key may be used to create indents, but tab stops may vary between editors. We

recommend using three spaces to form a level of indent.

If braces do not occur in matching pairs, the compiler indicates an error.

Line 5 is a blank line, inserted for program readability. Line 6,

// main method begins execution of Java application

Line 7,

Public static void main (String args [ ])

Java applications begin executing at main. After main indicate that main is a program

building block called a method Java class definitions normally contain one or more methods.

For a Java application class, exactly one of those methods must be called main and must be

defined as shown on line 7; otherwise, the java interpreter will not execute the application.

Methods are able to perform tasks and return information when they complete their tasks.

The void keyword indicates that this method will perform a task (displaying a line of text, in

this program), but will not return any information when it completes its task. Later, we will

see that many methods return information when they complete their task. Methods are

explained in detail .For now, simply mimic main’s first line in your Java applications.

Indent the entire body of each method definition one “level” of indentation between the

left, {, and the right brace,}, that define the body of the method. This format makes the

structure of the method stand out and helps make the method definition easier to read.

Line 9,

n (“Welcome to Java Programming!”);

Instructs the computer to perform an action, namely to print the string of characters

contained between the double quotation marks. A string is sometimes called a character string,

a message or a string literal. We refer to characters between double quotation marks

generically as strings. White-space characters in strings are not ignored by the compiler.

is known as the standard output object. allows Java applications

to display strings and other types of information in the command window from which the

Java application executes. In Microsoft Windows 95/98/ME, the command window is the

MS-DOS prompt. In Microsoft Windows NT/2000, the command window is the

COMMAND PROMPT (). The command window is normally called a command

window, a command tool, a shell tool or a shell. On computers running an operating system

that does not have a command window (such as a Macintosh), the java interpreter normally

displays a window containing the information the program displays.

Method n displays (or prints) line of text in the command window.

When n completes its task, it automatically positions the output cursor (the

location where the next character will be displayed) to the beginning the of the next line in

the command window. (This move of the cursor is similar to you pressing the Enter key when

typing in a text editor—the cursor appears at the beginning of the next line in your file.)

The entire line, including n, its argument in the parentheses (the string)

and the semicolon (;), is a statement. Every statement must end with a semicolon (also known

as the statement terminator). It displays the message Welcome to Java Programming! in the

command window.

Omitting the semicolon at the end of a statement is a syntax error. Error occurs when the

compiler cannot recognize a statement. The compiler normally issues an error message to

help the programmer identify and fix the incorrect statement. Syntax is violations of the

language rules. Syntax errors are also called compile errors, compile-time error or

compilation errors, because the compiler detects them during the compilation phase. You will

be unable to execute your program until you correct all of the syntax errors in it.

When the compiler reports a syntax error, the error may not be on the line number

indicated by the error message. First, check the line for which the error was reported. If that

line does not contain syntax errors, check the preceding several lines in the program.

Some programmers find it difficult when reading and/or writing a program to match the

left and right braces ({and}) that delimit the body of a class definition or a method definition.

For this reason, some programmers prefer to include a single-line comment after a closing

right brace () 0that ends a method definition and after a closing right brace that ends a class

definition. For example, line 11,

} // end method main

Specifies the closing right brace (}) of method main, and line 13,

} //end class Welcome1

Specifies the closing right brace (}) of class comment indicates the

method or class that the right brace terminates. We use such comments to help beginning

programmers determine where each program component terminates. We use such comments

when pairs of braces contain many statements, which make the closing braces difficult to

identify.

Some programmers prefer to follow the closing right brace (}) of a method body or class

definition with a single-line comment indicating the method or class definition to which the

brace belongs. This comment improves program readability.

We are now ready to compile and execute our program. To compile the program, we

open a command window, change to the directory where the program is stored and type

Javac

If the program contains no syntax errors, the preceding command creates a new file

called containing the Java byte codes that represent our application. These

will be interpreted by the java interpreter when we tell it to execute the program, as shown in

the Microsoft Windows 2000 Command Prompt.

Java Welcome1

To launch the java interpreter and indicate that it should load the “.class” file for class

that the “.class” file-name extension is omitted from the preceding command;

otherwise the interpreter will not execute the program. The interpreter automatically calls

method main. Next, the statement on line 7 of main displays “Welcome to Java

Programming!”

The Java compiler generates syntax error messages when the syntax of a program is

incorrect. When you are learning how to program, sometimes it is helpful to “break” a

wording program so you can see the error messages produced by the compiler. Then, when

you encounter that error message again, you will have an idea of the error’s cause. Try

removing a semicolon or curly brace from the program, then recompile the program to see

the error messages generated by the omission.

//Displaying multiple strings

import ; //import Applet class

import cs; //import Graphics class

public class Welcome extends Applet {

public void paint（Graphics g）

｛

ring（“Welcome to”,25,25）;

ring（“Java Programming”,25,40）;

}

}

中文翻译

Java编程介绍

Java程序由类和方法构成，程序员可以自己编写Java程序的每一部分。但是，大部分Java程序员利用了Java类库中的类和方法。在Java世界中有两部分需要学习：第一个部分就是Java语言本身，可以用它来编写自己的类和方法；第二个部分是如何使用扩充的Java类库。

这个程序表述了Java语言的几种重要特性，我们将详细解释程序的每一行。为了阅读方便，程序中都加上了行号，但这些行号不是Java程序的原有部分。第８行执行了程序的“真正工作”，在屏幕上显示“”Welcome to Java Programming１这一短句。现在，让我们按顺序考虑程序的每一行。第一行：

／／A first program in Java

这一行以“／／”开始，表明本行是一个注释。程序员在程序中加入注释来使程序文档化以及增加程序的可读性。注释还可以帮助其他人阅读和理解你的程序。注释在程序执行时不会导致计算机执行任何动作。Java编译器将忽略注释，并且不会产生任何字节码。“A first program in Java”注释简单地描述了程序的目的。一个以“／／”开始的注释称为单行注释，因为该注释的作用范围在行尾结束。稍后的中间开始，它能够使这一行的剩余部分（如第２行和第３行）成为注释。

//A first program in Java

import ;//import Applet class

import cs;//import Graphics class

public class Welcome extends Applet{

public void paint （Graphics g）

{

ring(“Welcome to Java Programming !”,25,25);

}

}

每一个程序由一个表明本程序用途的注释开始。

Java包括许多预先定义的类，并且在磁盘上将相关的类放入一个目录中，我们称之为软件包。这些软件包称为Java类库或者java应用程序编程接口（API）。下面这两行：

import ;//import Applet class

import cs;//import Graphics class

是import语句，用来载入编译一个Java程序所需要的类。这些特定的行告诉编译器从软件包中载入Applet类，并且从软件包中载入Graphics累。当用户在Java中创建一个applet时，必须载入Applet类。载入Graphics类的目的是程序可以在屏幕上显示信息。

Java的最强大的功能是Java API的各个软件包中含有树木庞大的类，程序员可以重用它们而不必重新开发。我们运用了这些类的大量成员，并且将详细讨论类和软件包。

从类中继承一个Java API的子类之前，请仔细阅读它的说明文档以了叫了解这些

类的功能。

类用来在程序执行时在内存中实例化（或创建）一个对象是内存中的一个区域。其中存储程序使用的信息。类库主要由编译器的供应商提供，但是许多是由独立的软件供应商提供的。我们的Welcome类用来创建一个执行这个Java applet的对象，其中运行这个applet的浏览器创建了Welcome类的一个事例。关键字public使得浏览器能够创建并执行我们的applet在Java中，主要的Applet类（即从Applet中继承的）总是一个public（公有）类型的类。

当把applet存入文件时，这个applet的类名将作为文件名的一部分。在本例中，文件名为。

如果文件名在拼写或缩写上同类名都不吻合，则将产生语法错误。

如果一个文件包含一个applet的类定义，那么它的文件名后缀必须为.Java，否则将并在完成自己的工作时返回信息。关键字void表明这个方法将执行某一任务，但是当它结束时并不返回值。Paint之后的左括号定义了这个方法的参数表，方法从此参数表中接收完成任务所需要的信息。方法paint的参数表说明它需要一个Graphic的对象（名为g）来完成相应的任务。关键字public是必须的，这样浏览器可以自动调用定义的paint方法。到目前为止，所有的方法定义都是以关键字public开头的。

第７行的左括号表明这个方法定义的程序体的开始。一个相应的右花括号表明这个方法定义的程序体的结束（程序的第９行）。

下列语句：

ring（“Welcome to Java Programming!,25,25”）;

指示计算机执行一个动作，即采用Graphics对象g的drawString方法画出引号中的字符串。一个串有时称为一个字符串、一条信息或一行文字。这样的一整行，包括ring、括号中的参数以及分号（；），通常称为一条语句。每条语句必须以一个分

为了示范我们的applet，我们使用了Sun公司的Java开发工具箱中的appletviewer命令。Appletviewer是一个测试Java applet的程序。Appletviewer仅能识别HTML中的applet标记，所以有时也称之为“最小的浏览器”（忽略了所有其他HTML标记）。Appletviewer是按以下方式从机器的命令行激活Welcome Applet类：

Appletviewer

注意，appletviewer需要一个HTML文件来载入Java applet。

文件将Welcome Applet类载入一个浏览器中。

如果appletviewer命令之后所跟的文件名后缀不是.html，就不会执行appletviewer。

可以使用好几种方法来显示“Welcome to Java Programming!”。在paint方法中使用

两个drawString语句可以产生多行显示结果。

//Displaying multiple strings

import ; //import Applet class

import cs; //import Graphics class

public class Welcome extends Applet {

public void paint（Graphics g）

｛

ring（“Welcome to”,25,25）;

ring（“Java Programming”,25,40）;

}

}