第一章 J ava概览

Java是一种理想的面向对象的网络编程语言。它的诞生为IT 产业带来了一次变革，也是软件的一次革命。Java程序设计是一个巨大而迅速发展的领域，有人把Java称作是网络上的“世界语”。

本章将简要介绍Java语言的发展历史、特点、Java程序的基本结构以及开发Java程序的环境和基本方法。

1.1 Java语言发展历史

1.1.1 Java 语言产生的背景

1991年，SUN MicroSystem公司的Jame Gosling、Bill Joe等人的研究小组针对消费电子产品开发应用程序，由于消费电子产品种类繁多，各类产品乃至同一类产品所采用的处理芯片和操作系统也不相同，就出现了编程语言的选择和跨平台的问题。当时最流行的编程语言是C和C++语言，但对于消费电子产品而言并不适用，安全性也存在问题。于是该研究小组就着手设计和开发出一种称之为Oak(即一种橡树的名字)语言。由于Oak在商业上并未获得成功，当时也就没有引起人们的注意。

直到1994年下半年，随着Internet的迅猛发展，环球信息网WWW的快速增长，Sun Microsystems公司发现Oak语言所具有的跨平台、面向对象、高安全性等特点非常适合于互联网的需要，于是就改进了该语言的设计且命名为“Java”，并于1995年正式向IT业界推出。Java一出现，立即引起人们的关注，使得它逐渐成为Internet上受欢迎的开发与编程语言。当年就被美国的著名杂志PC Magazine评为年度十大优秀科技产品之一(计算机类就此一项入选)。

1.1.2 互联网成就了Java

互联网的出现使得计算模式由单机时代进入了网络时代，网络计算模式的一个特点是计算机系统的异构性，即在互联网中连接的计算机硬件体系结构和各计算机所使用的操作系统不全是一样的，例如硬件可能是SPARC、INTEL或其他体系的，操作系统可能是UNIX、Linux、windows或其他的操作系统。这就要求网络编程语言是与计算机的软硬件环境无关的，即跨平台的，用它编写的程序能够在网络中的各种计算机上正常运行。Java正是这样迎合了互联网时代的发展要求，才使它获得了巨大的成功。

随着Java2一系列新技术（如JAVA2D、JAVA3D、SWING、JAVA SOUND、EJB、SERVLET、JSP、 CORBA、XML、JNDI等等）的引入，使得它在电子商务、金融、证券、邮电、电信、娱乐等行业有着广泛的应用，使用Java技术实现网络应用系统也正在成为系统开发者的首要选择。

事实上，Java是一种新计算模式的使能技术，Java的潜力远远超过作为编程语言带来的好处。它不但对未来软件的开发产生影响，而且应用前景广阔，其主要体现在以下几个方面：

1）软件的开发方法，所有面向对象的应用开发以及软件工程中需求分析、系统设计、开发实现和维护等。

2）基于网络的应用管理系统，如完全基于Java和WEB技术的Intranet（企业内部网）上应用开发。

3）图形、图像、动画以及多媒体系统设计与开发实现。

4）基于Internet的应用管理功能模块的设计，如网站信息管理、交互操作设计及动态Web页面的设计等。

5）其它应用。

1.2 Java的特点

Java是一种纯面向对象的网络编程语言，它具有如下特点：

1） 简单、安全可靠

Java是一种强类型的语言，由于它最初设计的目的是应用于电子类消费产品，因此就要求既要简单又要可靠。

Java的结构类似于C和C++，它汲取了C和C++优秀的部分，弃除了许多C和C++中比较繁杂和不太可靠的部分，它略去了运算符重载、多重继承等较为复杂的部分；它不支持指针，杜绝了内存的非法访问。它所具有的自动内存管理机制也大大简化了程序的设计与开发。

Java主要用于网络应用程序的开发，网络安全必须保证，Java通过自身的安全机制防止了病毒程序的产生和下载程序对本地系统的威胁破坏。

2）面向对象

Java是一种完全面向对象的语言，它提供了简单的类机制以及动态的接口模型，支持封装、多态性和继承（只支持单一继承）。面向对象的程序设计是一种以数据（对象）及其接口为中心的程序设计技术。也可以说是一种定义程序模块如何“即插即用”的机制。

面向对象的概念其实来自于现实世界，在现实世界中，任一实体都可以看作是一个对象，而任一实体又归属于某类事物，因此任何一个对象都是某一类事物的一个实例。

在Java中，对象封装了它的状态变量和方法（函数），实现了模块化和信息隐藏；而类则提供了一类对象的原型，通过继承和重载机制，子类可以使用或者重新定义父类或者超类所提供的方法，从而实现了代码的复用。

3）分布式计算

Java为程序开发者提供了有关网络应用处理功能的类库包，程序开发者可以使用它非常方便地实现基于TCP/IP的网络分布式应用系统。

4）平台的无关性

Java是一种跨平台的网络编程语言，是一种解释执行的语言。Java源程序被Java编译器编译成字节码（Byte-code）文件，Java字节码是一种“结构中立性”（architecture neutral）的目标文件格式，Java虚拟机（JVM）和任何Java-使能的Internet浏览器都可执行这些字节码文件。在任何不同的计算机上，只要具有Java虚拟机或Java使能的Internet浏览器即可运行Java的字节码文件，不需重新编译（当然，其版本向上兼容）。实现了程序员梦寐以求的“一次编程、到处运行”（write once,run every where!）的梦想。

5) 多线程

Java的多线程（multithreading）机制使程序可以并行运行。线程是操作系统的一种新概念，它又被称作轻量进程，是比传统进程更小的可并发执行的单位。Java的同步机制保证了对共享数据的正确操作。多线程使程序设计者可以在一个程序中用不同的线程分别实现各种不同的行为，从而带来更高的效率和更好的实时控制性能。

6) 动态的

一个Java程序中可以包含其他人写的多个模块，这些模块可能会遇到一些变化，由于Java在运行时才把它们连接起来，这就避免了因模块代码变化而引发的错误。

7) 可扩充的

Java发布的J2EE标准是一个技术规范框架，它规划了一个利用现有和未来各种Java技术整合解决企业应用的远景蓝图。

正如SUN MicroSystems所述：Java是简单的、面向对象的、分布式的、解释的、有活力的、安全的、结构中立的、可移动的、高性能的、多线程和动态的语言。

1.3 Java的工作原理

1.3.1 Java虚拟机

Java虚拟机其实是软件模拟的计算机，它可以在任何处理器上（无论是在计算机中还是在其它电子设备中）解释并执行字Java的字节码文件。Java的字节码被称为Java虚拟机的机器码，它被保存在扩展名为.class的文件中。

一个Java程序的编译和执行过程如图1-1所示。首先Java源程序需要通过Java编译器编译成扩展名为.class的字节码文件，然后由Java虚拟机中的Java解释器负责将字节码文件解释成为特定的机器码并执行。

1.3.2 内存自动回收机制

在程序的执行过程中，系统会给创建的对象分配内存，当这些对象不再被引用时，它们所占用的内存就处于废弃状态，如果不及时对这些废弃的内存进行回收，就会带来程序运行效率下降等问题。

在Java运行环境中，始终存在着一个系统级的线程，专门跟踪对象的使用情况，定期检测出不再使用的对象，自动回收它们占用的内存空间，并重新分配这些内存空间让它们为程序所用。Java的这种废弃内存自动回收机制，极大地方便了程序设计人员，使他们在编写程序时不需要考虑对象的内存分配问题。

1.3.3 代码安全性检查机制

Java是网络编程语言，在网络上运行的程序必须保证其安全性。如何保证从网络上下载的Java程序不携带病毒而安全地执行呢？Java提供了代码安全性检查机制。

Java 在将一个扩展名为 .class的字节码文件装载到虚拟机执行之前，先要检验该字节码文件是否符合字节码文件规范，代码中是否存在着某些非法操作。检验工作由字节码检验器（bytecode verifier）或安全管理器（SecurityManager）进行。检验通过之后，将字节码文件加载到Java虚拟机中，由Java解释器解释为机器码并执行。java虚拟机把程序的代码和数据都限制在一定内存空间里执行，不允许程序访问超出该范围，保证了程序的安全运行。

1.4 Java的运行环境JDK

1.4.1 Java平台

Java不仅仅是一种网络编程语言，还是一个不断扩展的开发平台。Sun公司针对不同的市场目标和设备进行定位，把Java划分为如下三个平台：

1）J2SE（Java2 Standard Edition）是Java2 的标准版，主要用于桌面应用软件的编程。它包含了构成Java语言基础和核心的类。我们在学习Java的过程中，主要是在该平台上进行的。

2）J2EE（Java2 Enterprise Edition）是Java2的企业版，主要是为企业应用提供一个服务器的运行和开发平台。J2EE 不仅包含J2SE 中的类，还包含了诸如EJB、servlet、JSP、XML等许多用于开发企业级应用的类包。J2EE本身是一个开放的标准，任何软件厂商都可以推出自己符合J2EE标准的产品，J2EE将逐步发展成为强大的网络计算平台。

3）J2ME（Java2 Micro Edition）是Java2的微缩版，主要为消费电子产品提供一个Java的运行平台，使得能够在手机、机顶盒、PDA等消费电子产品上运行Java程序。

1.4.2建立Java开发环境

要使用Java开发程序就必须先建立Java的开发环境。当前有许多优秀的Java程序开发环境，诸如JBuilder、Visual Age、Visual J++等等，这些工具功能强大，很适合有经验者使用。对于学习Java者来说，应该使用Sun公司的Java开发工具箱JDK(Java Development Kit)，它拥有最新的Java程序库，功能逐渐增加且版本在不断更新，尽管它不是最容易使用的产品，但它是免费的，可到Java.sun.com站点上免费下载。

下边我们在Microsoft Windows操作系统平台上安装JDK，建立Java 的开发环境。

1）下载并安装JDK文件

当前Jdk版本已经更新到1.6.0版本，我们就Jdk1.6.0 版本为例，从Java.sun.com站上下载安装文件jdk-6-windows-i586。

双击安装文件jdk-6-windows-i586，按照安装文件的提示一步步执行即可安装。

如果将JDK安装到C:\ Jdk1.6.0目录下，安装成功后，将有图1.2所示的目录结构。

2）下载并安装Java帮助文档

Java帮助文档对程序设计人员来说是很重要的，由于JDK的安装文件中不包括帮助文档，因此也需要从网站上下载而后安装。帮助文档下载与安装的过程和步骤与JDK类似，不再重述。

帮助文档一般被安装在docs的目录下，使用浏览器打开该目录下的index.html文件即可查阅所有的帮助文档。

3）设置运行路径

在运行Java程序或进行一些相关处理时，用到了工具箱中的工具和资源，这就需要设置两个环境变量PATH和CLASSPATH，以获取运行工具和资源的路径。

在不同的操作系统下设置环境变量的方式有所不同，下边我们以Windows XP系统为例说明设置环境变量的操作方法和步骤：

(1) 右击“我的电脑”图标；

(2) 在出现的快捷菜单中单击“属性”选项；

(3) 在出现的“系统属性”对话框窗口上单击“高级”选项；

(4) 单击对话框上的“环境变量”按钮；

(5) 在出现的“环境变量”对话框上，单击用户变量框内的“新建”按钮；

(6) 出现如图1.3的“新建用户变量”对话框窗口。在“变量名”文本框中输入：CLASSPATH；在“变量值”文本框中输入：.;c:\jdk1.6.0\lib\dt.jar;c:\jdk1.6.0\lib\tools.jar

图1.3 新建用户变量

然后，单击“确定”按钮。这就设置了环境变量CLASSPATH。

重复(5)~(6) 再设置PATH，输入变量值为：.;c:\jdk1.6.0\bin

完成之后，要使环境变量生效，最好重新启动计算机。

1.4.3开发工具简介

下边简要介绍在命令提示符方式下几个开发工具的使用。

1）Java编译器Javac.exe

Javac用于将扩展名为.java的源程序代码文件编译成扩展名为.class字节码文件。

使用格式： javac FileName.java

例：编译java源程序myProg.java

Javac myProg.java

执行该命令将在当前目录下生成字节码文件myProg.class。

注意：在编译文件时，源文件的扩展名.java必须带上，否则会出现编译错误，不能生成字节码文件。

2）解释器Java.exe

解释执行编译后的字节码文件程序。

使用格式： java classFileName

例：解释执行字节码文件myProg.class

Java myProg

注意: 运行的类文件名不需要带.class扩展名。

3）Applet浏览器Appletviewer.exe

Applet是用java语言编写的小应用程序。Applet不能够直接用Java解释器解释执行，只能被嵌入到HTML文档中，由浏览器装入执行。

使用格式： appletviewer htmlFileName.html

有关执行Applet的例子，我们将在后边介绍。

此外，工具箱中还提供了其它大量相关的工具，诸如：Java档案文件管理器jar.exe、Java文档生成器javadoc.exe等等，它们都被存放在c:\Jdk1.6.0\bin目录下。要了解它们的具体使用方法，请参阅相关的文档。

1.5 创建Java程序

Java是一种纯面向对象的程序设计语言，面向对象的程序程序设计有如下的特点：

1）程序中所有东西都是对象，可将对象看成是一种新型变量；它保存着数据，且能对自身进行操作。

2）程序是一些对象的组合，通过消息传递进行相关的处理，各对象知道自己该做些什么。

3）每个对象都有自己的存储空间并可容纳其他对象。也就是说通过封装现有的对象，可以创建出新的对象。对象的概念看似简单，其实却可达到任意高的复杂程度。

4）如前所述，每个对象都属于某一类型，因此每个对象都是某个类的一个实例。类的最重要的特征就是能将什么消息发给它，同一类所有对象都能接收相同的消息。

一般说来，Java程序有两类：应用程序(Application)和小应用程序(Applet)。下边我们分别创建两个简单的程序，看一下两类应用程序的基本结构。

1.5.1 第一个应用程序(application)

我们可以用文本编辑器编辑如下的程序代码：

/**

* 这是一个简单而经典的例子程序，在初级的Java编程书籍中，几乎都使用它。

* 它的功能是在屏幕上输出：Hello World!

* 程序的名字为：HelloWorld.Java

*/

import java.lang.*;

public class HelloWorld

{

public static void main(String []argc)

{

System.out.println("Hello World!");

}

}

下边我们简要分析一下该程序的结构：

类似于C和C++，以字符 /* 开始并以字符 */ 结束的行为注解行。注解行不是程序的代码部分，只是为了程序的易读性。

在程序开头是类包引入语句: import java.lang.*; 它将类包java.lang引入到本程序，以便在本程序中使用该包中已定义好的类。Java带有很多类包，每个包中都有很多已定义好的类，并编译成了字节代码，用户可直接引用，这实现了代码的重用。

public class HelloWorld;

该语句用来声明一个HelloWorld类，面向对象的程序是以类为基础的。在语句中：

class 为关键字，定义一个类。

public 是访问控制修饰符，表示该类是一个公有类，其它所有的类也可以访问这个类的对象。

每个类的定义都以符号“{”开始， “ }”结束，类中可以定义数据成员（变量）和方法成员。在本类中，没有定义数据成员，只定义了方法main()：

public static void main(String args[])

在该方法说明语句中：

public 是访问控制修饰符。

static 是修饰符。在类中，若方法被定义为static（静态的），那就是说，无需创建类对象即可调用静态方法。因此也被称为类方法。

void 表示方法无返回值。

main 为方法名。

Strring args[] 是参数说明，表示执行该程序时，可以带一组字符串参数。

方法也是以“{” 开始，以“}”结束。在该main()方法中只有一个语句：

System.out.println(“Hello World!”);

它的作用是在屏幕上输出信息：Hello World!

在语句中：

System 是java.lang类包中的一个类。它是java最重要、最基础的类之一，它提供了系统标准设备资源（显示器、键盘）的接口。

out 是System类定义的一个标准输出流的成员。

println 是System类中定义的一个静态的（static）方法，其功能是向标准输出设备（屏幕）输出信息。

要运行上述程序，需要以下步骤：

1）使用Java编译器编译Java源程序：

javac HelloWorld.java

生成字节码文件HelloWorld.class。

2）使用Java解释器解释执行字节码文件HelloWorld.class：

java HelloWorld

注意：Java应用程序中可以有多个类，每个类中也可以有多个方法，但只能有一个类和程序同名且只有该类中具有main()方法，程序最先执行的是main()方法。

1.5.2 第一个小应用程序(applet)

先将上面介绍的Application程序改写为Applet（小应用程序），然后分析Java Applet程序的结构。

/**

*该小应用程序的名字是：HelloWorldApplet.java

*它的功能是在屏幕指定的位置上显示: Hello world!

*它不能直接执行，只能被嵌入到HTML文档中，由浏览器装入执行

**/

import java.applet.*;

import java.awt.*;

public class HelloWorldApplet extends Applet

{

public void paint(Graphics g)

{

g.drawString(“Hello world!”,10,50);

}

}

本程序引入使用两个类包java.awt和jva.Applet中的类Graphics和Applet。

小应用程序在类的声明上和应用程序不同，它必须含有extends Applet项，表示HelloWorldApplet类是由Applet类派生而来的，HelloWorldApplet是派生类又称子类，而Applet是超类又称父类，子类可以继承父类的所有功能（特征、行为）。比如HelloWorldApplet类中含有一个方法paint()就是从超类继承过来的，不过在这里根据需要进行了重写。

paint()方法中只有一个语句： g.drawString(“Hello World!”,10,50);

在语句当中：

g 是一个Graphics类的对象，该对象由方法的参数传递所得。

drawSrting() 是Graphics类的方法，其功能是在指定位置（以Applet左上角为坐标原点，以像素为单位）显示指定的信息。本语句的功能是在Applet屏幕上的（10，50）坐标处开始显示：Hello World！

由于Applet程序的运行方式与Application程序不同，它是被嵌入在HTML文档中由浏览器装入运行的。下边简要介绍一下HTML语言，有关详细的内容请查阅相关的书籍资料。

超文本标记语言（HyperText Mark-up Language）是用来定义WEB页面的语言，简称HTML。用HTML定义的页面也称文档，它被存储在扩展名为.html或.htm的文件中。

HTML文档包含一组元素，每个元素都用标签（tag）来标识。因此又称HTML为标记语言。文档将以<HTML>开始，最后以</HTML>结束。在这里分界符<HTML>和</HTML>都是标签，文档中的所有元素都会位于类似这样的一对尖括号内。所有元素的标签是不区分大小写的，但习惯上使用大写，以便与文本内容区分。

下边我们使用文本编辑器创建如下嵌入HelloWorldApplet程序的HTML文档：

<HTML>

<TITLE>第一个Java Applet 应用!!!</TITLE>

<BODY>

<APPLET CODE=”HelloWorldApplet.class” WIDTH=200 HEIGHT=300 >

</APPLET>

</BODY>

</HTML>

并将它以FirstApplet.html 名字存储。

在创建HelloWorldApplet.java和FirstApplet.html文件之后，要运行HelloWorldApple程序需要以下步骤：

1）使用Java编译器编译HelloWorldApplet.java源程序：

javac HelloWorldApplet.java

生成字节码文件HelloWorldApplet.class。

2) 使用Applet浏览器浏览页面并装入HelloWorldApplet.class执行：

appletviewer FirstApplet.html

上边简要介绍了Java的应用程序和小应用程序，对Java程序有了基本的认识。我们应该注意以下几点：

(1) Java程序总是由一些类组成。在每个Java程序中可以包含有多个类，但至少必须有一个类；

(2) 可以把每个类的程序代码放入一个单独的程序文件中，一般情况下程序文件名和其中定义的类名取名相一致；

(3) 源程序文件必须使用扩展名.java。

1.6 RAD快速开发工具

在学习Java的过程中，需要大量的编辑、编译和调式运行Java 程序的操作，单纯使用前边介绍的JDK工具不太方便，因为它们是命令提示符方式的，每次都需要在键盘上输入相关的命令。下边我们介绍两个常用的、使用方便的快速开发工具，它们都是可视化界面，功能强大，一旦掌握可以起到事半功倍的效果。

1.6.1 JCreator

JCreator是一个非常方便实用的开发工具，它比较小，下载的文件只有几兆，它本身不带JDK，所以在安装JCreator之前，必须保证计算机上已经安装了JDK，其实它就是一个利用JDK工具的外壳程序。本书很多例子均是在该环境下调试完成的。

1）安装Jcreator

我们可以到http://www.jcreator.com网站上下载英文版JCreator，也可到国内的一些学习网站上下载汉化版本的Jcteator。下载之后安装到本地计算机上。

图1.4 Jcreator窗口

在完成安装后的第一次启动时，JCreator会弹出文件关联、JDK路径和JDK的文档路径配置对话框，初学者可直接点击“下一步（Next）”按钮跳过这一步，这是因为JCreator和JDK是无缝连接，只要正确的安装了JDK，JCreator就可以自动找到JDK的安装目录并正确配置。

图1.4是汉化版本JCreatorLE_3.50.013第一次启动后的窗口。下面我们简单介绍一下它的使用方法。

2）应用程序的开发

我们还以上边的HelloWorld.java程序为例简要介绍一下在Jcreator环境下开发一个Java程序的过程和步骤。

（1）编辑源程序文件

若Java源程序文件已经使用其他的开发工具建立，则使用“文件(F)”菜单中的“打开（O）”或工具栏上的打开文件图标按钮，浏览选中文件并打开装入即可。

若Java源程序文件不存在，则使用“文件(F)”菜单中的“新建（N）”子菜单下的“文件(F)…”选项，弹出如图1.5所示的“文件向导”对话框，单击“文件类型”选项卡，指定创建的文件类型为“Java File”，然后在“名称”和“路径”文本框中分别输入文件名（如HelloWorld）和路径（如D:\javaexam\），单击“完成（F）”按钮进入程序编辑屏幕。

图1.5 文件向导对话框

在编辑区域输入源程序，如图1.6所示。

在输入程序的过程中，左边自动显示程序的行号。在编译时如果出现错误，可以根据出错行很快找到错误的地方。

在输入程序行之后，系统会根据程序行的内容，自动在前边显示程序的结构标识。

此外，在输入程序语句的过程中，若输入定界符“{”时，系统自动在下一行加了一个“}”，若输入”(“时，系统会自动在后边再加上一个”)”，以提醒用户定界符是成对出现的，需要定义的部分应该放在定界符之内。

从图1.6的编辑程序窗口中，我们可以看到这样一个结构清晰的程序清单，注解部分、类、方法等前边加上了明显的标识，根据不同的内容，在关键的地方以不同颜色的字体显示，易读易懂，不易出错，这是一种良好的程序书写风格的具体体现。

在图1.6的JCreator窗口上，有四个子窗口：文件视图、包视图、生成输出和程序视图窗口。一般情况下可关闭文件视图和包视图窗口，当需要时再打开。只留下程序窗口和生成输出窗口，程序窗口用于编辑、显示程序；生成输出窗口用于显示、查看编译时的相关信息。

在程序编辑完成之后，就可以编译、调试执行了。

（2）编译源程序生成字节码文件

图1.6 Jcreator窗口

可以使用“生成(B)”菜单中的“编译文件(F)”命令或工具栏上的”编译文件”按钮对当前的源程序进行编译（见图1.7），以生成对应的字节码类文件。

图1.7 编译文件

编译将检查包括语法错误在内所有静态的错误，如果检查出错误，将在生成输出窗口给出出错行和出错信息并显示编译不成功的信息。这时就需要根据出错行和出错信息返回编辑屏幕修改程序中的错误，之后再进行编译，直至编译成功生成字节码类文件为止。

（3）解释执行字节码类文件

编译成功后，可以使用“生成(B)”菜单中的“执行文件(L)”命令或工具栏上的”执行”按钮运行Java程序，本例的执行结果如下图1.8所示。最后一行不是程序的输出信息，是系统的操作提示：按任意键返回到编辑窗口。

图 1.8 执行结果屏幕

3）小应用程序开发

同样以HelloWorldApplet.java程序为例简要介绍一下在JCreator环境下开发一个Java小应用程序的过程和步骤。

（1）编辑和编译源程序文件

编辑和编译HelloWorldApplet.java，生成字节码类文件，和前边所述的一样，不再重述。

（2）编辑FirstAppletHTML.html文件

建立和编辑HTML文档文件的过程和Java文件类似，所不同的是所选择的文件类型不同，编辑文档窗口每一行的文档前没有行号，也没有文档结构标识。编辑好的文档如图1.9所示。

图1.9 编辑HTML文件

（3）浏览执行Applet

使用“生成(B)”菜单中的“执行文件(L)”命令或工具栏上的”执行”按钮运行浏览执行Applet程序，本例的执行结果如下图1.10所示。

图1.10 Applet执行窗口结果

1.6.2 TextPad

这也是初学者最容易使用的开发工具之一。和JCreator类似，在此环境下可编辑JAVA程序和HTML文件，直接编译和运行Java程序，包括小应用程序查看器。图1.11是TextPad 4.73汉化版启动后的主窗口界面：

图1.11 TextPad主窗口

其中的文档名显示窗口和ANSI字符窗口可以关闭，需要时再打开。在文档窗口编辑Java程序或HTML文档。

完成程序的编辑和保存之后，就可以进行编译和执行了。如图1.12所示。

图1.12

编辑、运行应用程序和小应用程序的方法和JCreator类似，不再重述。

我们可到http://www.textpad.com网站下载英文版的TextPad，也可在国内的一些学习网站上下载汉化版的TextPad。

本章小结

本章简要介绍了Java的发展过程、Java语言的特点以及Java程序的基本组成。为了便于初学者上机实践，着重介绍了Java程序的运行环境和环境变量的设置方法以及常用开发工具Jcreator、TextPad的安装使用。

本章重点：面向对象的程序设计思路、Java语言的特点、Java语言的两类应用程序Application和程序的结构以及执行方式；HTML文档及在文档中嵌入Java类文件的方法。应该掌握使用JDK的开发工具及设置Java开发环境的路径PATH和CLASSPATH；熟悉JCreator环境的安装，熟练使用JCreator编辑、编译、运行Java程序及运行HTML文件。

习题

一、选择题

1．以下对Java 语言不正确的描述是：

A． Java语言是一个完全面向对象的语言。

B． Java是结构中立与平台无关的语言。

C． Java是一种编译性语言。

D． Java是一种解释性语言。

2．以下说法正确的是：

A．Java程序文件名必须和程序文件中定义的类名一致。

B．Java程序文件名可以和程序文件中定义的类名不一致。

C．Java源程序文件的扩展名必须是.java。

D．以上A、C说法正确，B说法不正确。

3．以下描述错误的是：

A．Java的源程序代码被存储在扩展名为 .java的文件中。

B．Java编译器在编译Java的源程序代码后，自动生成扩展名为 .class的字节代码类文件。

C．Java编译器在编译Java的源程序代码后，自动生成的字节代码文件名和类名相同，扩展名为 .class。

D．Java编译器在编译Java的源程序代码后，自动生成扩展名为 .class的字节代码文件，其名字可以和类名不同。

4．以下有关运行Java 应用程序（application）正确的说法是：

A．Java 应用程序由Java编译器解释执行。

B．Java 应用程序经编译后生成的字节代码可有Java虚拟机解释执行。

C．Java 应用程序经编译后可直接在操作系统下运行。

D．Java 应用程序经编译后可直接在浏览器中运行。

5．以下有关运行Java 小应用程序（applet）正确的说法是：

A．Java 小应用程序由Java编译器编译后解释执行。

B．Java 小应用程序经编译后生成的字节代码可有Java虚拟机解释执行。

C．Java 小应用程序经编译后可直接在操作系统下运行。

D．Java 应用程序经编译后生成的字节代码，可嵌入网页文件中由Java使能的浏览器解释执行。

二、问答题

1．Java语言有哪些特点？

2．如何建立和运行Java程序？

3．Java的运行平台是什么？

4．何为字节代码？其优点是什么？

5．Java程序有哪些几种类型？

三、实训题

1．模仿本章Java应用程序的例子，使用开发工具编辑、编译、运行Java应用程序。

2．模仿本章Java小应用程序的例子，使用开发工具编辑、编译、运行Java小应用程序。

第2章 Java的基本数据类型、运算符及表达式

本章将简要介绍Java的标识符、保留字、变量、常量、数据类型、运算符和表达式等等。读者如果已经对其他的程序设计语言等有所了解，只要注意比较一下它们的相同和不同之处，学习起来就会感到比较轻松。

2.1 用户标识符与保留字

2.1.1 用户标识符

用户标识符是程序员对程序中的各个元素加以命名时使用的命名记号。

在Java语言中，标识符是以字母、下划线（”_”）或美元符（”$”）开始，后面可以跟字母、下划线、美元符和数字的一个字符序列。

例如：

userName，User_Name，_sys_val，Name，name，$change 等为合法的标识符。而：

3mail，room#，#class 为非法的标识符。

注意：标识符中的字符是区分大小写的。例如，Name和name被认为是两个不同的标识符。

2.1.2 保留字

保留字是特殊的标识符，具有专门的意义和用途，不能当作用户的标识符使用。Java语言中的保留字均用小写字母表示。下表2.1列出了Java语言中的所有保留字。

表2.1 保留字

abstract

break

byte

boolean

catch

case

class

char

continue

default

double

do

else

extends

false

final

float

For

finally

if

import

implements

int

interface

instanceof

long

1ength

native

new

null

package

private

protected

public

return

switch

short

static

super

try

true

this

throw

throws

void

threadsafe

transient

while

synchronized

2.2 数据类型

Java语言的数据类型可划分为基本数据类型和引用数据类型(如图2-1所示)。本章我们主要介绍基本数据类型，引用型数据类型将在后边的章节中介绍，数组和字符串本身属于类，由于它们比较特殊且常用，因此也在图2-1中列出。

基本数据类型如表2.2所示。下边我们将简要介绍这些数据类型。

表2.2 Java的基本数据类型

数据类型

所占二进制位

所占字节

取值

byte

8

1

-27～27-1

short

16

2

-215～215-1

int

32

4

-231～231-1

long

64

8

-263～263-1

char

16

2

任意字符

boolean

8

1

true , false

float

32

4

-3.4E38(3.4×1038)～3.4E38(3.4×1038)

double

64

8

-1.7E308(1.7×10308)～1.7E308(1.7×10308)

2.2.1 常量和变量

常量和变量是程序的重要元素。

1．常量

所谓常量就是在程序运行过程中保持不变的量即不能被程序改变的量，也把它称为最终量。常量可分为标识常量和直接常量（字面常量）：

1） 标识常量

标识常量使用一个标识符来替代一个常数值，其定义的一般格式为：

final 数据类型 常量名=value[,常量名=value …];

其中

final 是保留字，说明后边定义的是常量即最终量；

数据类型 是常量的数据类型，它可以是基本数据类型之一；

常量名 是标识符，它表示常数值value，在程序中凡是用到value值的地方均可用常量名标识符替代。

例如： final double PI=3.1415926; //定义了标识常量PI，其值为3.1415926

注意：在程序中，为了区分常量标识符和变量标识符，常量标识符一般全部使用大写书写。

2）直接常量（字面常量）

直接常量就是直接出现在程序语句中的常量值，例如上边的3.1415926。直接常量也有数据类型，系统根据字面量识别，例如：

21，45，789，1254，-254 表示整型量；

12L，123l， -145321L 尾部加大写字母L或小写字母l表示该量是长整型量；

456.12，-2546，987.235 表示双精度浮点型量；

4567.2145F，54678.2f 尾部加大写字母F或小写字母f表示单精度浮点型量。

2．变量

变量是程序中的基本存储单元，在程序的运行过程中可以随时改变其存储单元的值。

1） 变量的定义

变量的一般定义如下：

数据类型 变量名[=value] [, 变量名[=value] …];

其中：

数据类型 表示后边定义变量的数据类型；

变量名 变量名，是一个标识符，应遵循标识符的命名规则。

可以在说明变量的同时为变量赋初值。例如：

int n1=456,n2=687;

float f1=3654.4f,f2=1.325f

double d1=2145.2;

2）变量的作用域

变量的作用域是指变量自定义的地方起，可以使用的有效范围。在程序中不同的地方定义的变量具有不同的作用域。一般情况下，在本程序块（即以大括号“{}”括起的程序段）内定义的变量在本程序块内有效。

例2.1 说明变量作用域的示例程序。

/** 这是说明变量作用域的示例程序

* 程序的名字为Var_Area_Example.java

*/

public class Var_Area_Example

{

static intn_var1=10; //类变量,对整个类都有效

public void display()

{

int n_var2=200; //方法变量，只在该方法内有效

n_var1=n_var1+n_var2;

System.out.println("n_var1="+n_var1);

System.out.println("n_var2="+n_var2);

}

public static void main(String args[])

{

int n_var3; //方法变量，只在该方法内有效

n_var3=n_var1*2;

System.out.println("n_var1="+n_var1);

System.out.println("n_var3="+n_var3);

}

}

2.2.2 基本数据类型

1. 整型

Java提供了四种整型数据，如上表2-2所示。

1）整型常量的表示方法

整型常量可以十进制、八进制和十六进制表示。

一般情况下使用十进制表示，如：123，－456，0 ，23456。

在特定情况下，根据需要可以使用八进制或十六进制形式表示整常量。以八进制表示时，以0开头，如：0123表示十进制数83，-011表示十进制数-9。

以十六进制表示整常量时，以0x或0X开头，如：0x123表示十进制数291，-0X12表示十进制数-18。

此外长整型常量的表示方法是在数值的尾部加一个拖尾的字符L或l，如：456l，0123L，0x25l。

2） 整型变量的定义

例如：int x=123; //指定变量x为int型，且赋初值为123

byte b=8; //指定变量b为byte型，且赋初值为8

short s=10; //指定变量s为short型，且赋初值为10

long y=123L,z=123l; //指定变量y,z为long型，且分别赋初值为123

2. 字符型(char)

字符型(char)数据占据两个字节16个二进制位。

字符常量是用单引号括起来的一个字符，如‘a’，‘A’等。

字符型变量的定义，如：

char c=’a’; //指定变量c为char型，且赋初值为a

3. 布尔型（boolean）

布尔型数据的值只有两个：true和false。因此布尔的常量值也只能取这两个值。

布尔型变量的定义，如：

boolean b1=true, b2=false; //定义布尔变量b1,b2并分别赋予真值和假值。

4. 浮点型（实型）

Java提供了两种浮点型数据，单精度和双精度，如表2-2所示。

1）实型常量的表示方法

一般情况下实型常量以如下形式表示：

0.123, 1.23, 123.0 等等表示双精度数；

123.4f, 145.67F, 0.65431f 等等表示单精度数。

当表示的数字比较大或比较小时，采用科学计数法的形式表示，如：

1.23e13 或123E11 均表示123×1011；

0.1e-8 或1E-9 均表示 10-9 。

我们把e或E之前的常数称之为尾数部分，e或E后面的常数称之为指数部分。

注意： 使用科学计数法表示常数时，指数和尾数部分均不能省略，且指数部分必须为整数。

2) 实型变量的定义

在定义变量时，都可以赋予它一个初值，例如：

float x=123.5f, y=1.23e8f; //定义单精度变量x,y并分别赋予123.5、1.23×108的值

double d1=456.78, d2=1.8e50 ; //定义双精度变量d1,d2 并分别赋予456.78、1.8×1050的值。

2.2.3 基本数据类型的封装

以上介绍的Java的基本数据类型不属于类，在实际应用中，除了需要进行运算之外，有时还需要将数值转换为数字字符串或者将数字字符串转换为数值等等。在面向对象的程序设计语言中，类似这样的处理是由类、对象的方法完成的。在Java中，对每种基本的数据类型都提供了其对应的封装类（称为封装器类wrapper class）。如下表2.3所示。

表2.3 基本数据类型和对应的封装类

数据类型

对应的类

数据类型

对应的类

boolean

Boolean

int

Integer

byte

Byte

long

Long

char

Character

float

Float

short

Short

double

Double

应该注意的是，尽管由基本类型声明的变量或由其对应类建立的类对象，它们都可以保存同一个值，但在使用上不能互换，因为它们是两个完全不同的概念，一个是基本变量，一个是类的对象实例。我们将在后边的章节中讨论它们。

2.3 Java运算符和表达式

运算符和表达式是构成程序语句的要素，必须切实掌握灵活运用。Java提供了多种运算符，分别用于不同运算处理。表达式是由操作数（变量或常量）和运算符按一定的语法形式组成的符号序列。一个常量或一个变量名是最简单的表达式。表达式是可以计算值的运算式，一个表达式有确定类型的值。

2.3.1 算术运算符和算术表达式

算术运算符用于数值量的算术运算，它们是： +（加），-（减），*（乘），/（除），%（求余数），++（自加1），--（自减1）。

按照Java语法，我们把由算术运算符连接数值型操作数的运算式称之为算术表达式。例如： x+y*z/2 、 i++ 、 (a+b)%10 等等。

加、减、乘、除四则运算大家已经很熟悉了，下边看一下其他运算符的运算：

% 求两数相除后的余数，如： 5/3 余数为2；5.5/3 余数为2.5。

++、-- 是一元运算符，参与运算的是单变量，其功能是自身加1或减1。它分为前置运算和后置运算，如：++i，i++，--i，i--等等。

下边举一个例子说明算术运算符及表达式的使用。

例2.2 使用算术运算符及表达式的示例程序。

class Arithmetic

{

public static void main(String [] arg)

{

int a=0,b=1;

float x=5f,y=10f;

float s0,s1;

s0=x*a++; //5*0=0

s1=++b*y; //2*10=20

System.out.println("a="+a+" b="+b+" s0="+s0+" s1="+s1);

s0=a+b; //1+2=3

s1++; //20+1=21

System.out.println("x%s0="+x%s0+" s1%y="+s1%y);

}

}

程序运行结果如下：

2.3.2关系运算符和关系表达式

关系运算符用于两个量的比较运算，它们是： >（大于），<（小于），>=（大于等于），<=（小于等于），==（等于），!=（不等于）。

关系运算符组成的关系表达式（或称比较表达式）产生一个布尔值。若关系表达式成立产生一个true值，否则产生一个false值。

例如：当x=90, y=78时，

x>y 产生true值；

x==y 产生false值。

2.3.3 布尔逻辑运算符和布尔表达式

布尔逻辑运算符用于布尔量的运算，有3个布尔逻辑运算符：

1. !（逻辑非）

！是一元运算符，用于单个逻辑或关系表达式的运算。

！运算的一般形式是： ! A

其中：A 是布尔逻辑或关系表达式。若A的值为true，则!A的值false，否则为true。

例如：若x=90，y=80，则表达式：

! (x>y) 的值为false（由于x>y产生true值）。

!(x==y) 的值为true（由于x==y产生false值）。

2. &&（逻辑与）

&& 用于两个布尔逻辑或关系表达式的与运算。

&&运算的一般形式是： A&&B

其中：A、B 是布尔逻辑或关系表达式。若A和B的值均为true，则A&&B的值为true，否则为false。

例如：若x=50，y=60，z=70，则表达式：

(x>y) && (y>z) 的值为false（由于两个表达式x>y、y>z的关系均不成立）。

（y>x）&&（z>y）的值为true（由于两个表达式y>x、z>y的关系均成立）。

（y>x）&&（y>z）的值为false（由于表达式y>z的关系不成立）。

3. ||（逻辑或）

|| 用于两个布尔逻辑或关系表达式的运算。

|| 运算的一般形式是： A || B

其中：A、B 是布尔逻辑或关系表达式。若A和B的值只要有一个为true，则A||B的值为true；若A和B的值均为false时，A||B的值为false。

例如：若x=50，y=60，z=70，则表达式：

（x>y）|| y>z）的值为false（由于两个表达式x>y、y>z的关系均不成立）。

（y>x）||（z>y）的值为true（由于两个表达式y>x、z>y的关系均成立）。

（y>x）||（y>z）的值为true（由于表达式y>x的关系成立）。

下边举一个例子看一下布尔逻辑运算符及表达式的使用。

例2.3 布尔逻辑运算符及表达式的示例。

class LogicExam2_3

{

public static void main(String [] arg)

{

int a=0,b=1;

float x=5f,y=10f;

boolean l1,l2,l3,l4,l5;

l1=(a==b)||(x>y); //l1=false

l2=(x<y)&&(b!=a); //l2=true

l3=l1&&l2; //l3=false

l4=l1||l2||l3; //l4=true

l5=!l4; //l5=false

System.out.println("l1="+l1+" l2="+l2+" l3="+l3+" l4="+l4+" l5="+l5);

}

}

程序的执行结果如下：

2.3.4 位运算符及表达式

位运算符主要用于整数的二进制位运算。可以把它们分为移位运算和按位运算。

1. 移位运算

1) 位右移运算（>>）

>> 用于整数的二进制位右移运算，在移位操作的过程中，符号位不变，其他位右移。

例如，将整数a进行右移2位的操作： a>>2

2) 位左移运算（<<）

<< 用于整数的二进制位左移运算，在移位操作的过程中，左边的位移出（舍弃），右边位补0。

例如，将整数a进行左移3位的操作： a<<3

3) 不带符号右移运算（>>>）

>>> 用于整数的二进制位右移运算，在移位操作的过程中，右边位移出，左边位补0。

例如，将整数a进行不带符号右移2位的操作： a>>>2

2. 按位运算

1）&（按位与）

& 运算符用于两个整数的二进制按位与运算，在按位与操作过程中，如果对应两位的值均为1，则该位的运算结果为1，否则为0。

例如，将整数a和b进行按位与操作： a&b

2) |（按位或）

| 运算符用于两个整数的二进制按位或运算，在按位或操作过程中，如果对应两位的值只要有一个为1，则该位的运算结果为1，否则为0。

例如，将整数a和b进行按位或操作： a|b

3) ^（按位异或）

^ 运算符用于两个整数的二进制按位异或运算，在按位异或操作过程中，如果对应两位的值相异（即一个为1，另一个为0），则该位的运算结果为1，否则为0。

例如，将整数a和b进行按位异或操作： a^b

4) ~（按位取反）

~ 是一元运算符，用于单个整数的二进制按位取反操作（即将二进制位的1变为0，0变为1）。

例如，将整数a进行按位取反操作： ~a

下边举一个例子简要说明位运算的使用。

例2.4 整数二进制位运算的示例。为了以二进制形式显示，程序中使用Integer类的方法toBinaryString()将整数值转换为二进制形式的字符串，程序代码如下：

class BitExam2_4

{

public static void main(String [] arg)

{

int i1=-128,i2=127;

System.out.println(" i1="+Integer.toBinaryString(i1));

System.out.println("i1>>2 ="+Integer.toBinaryString(i1>>2));

System.out.println("i1>>>2="+Integer.toBinaryString(i1>>>2));

System.out.println(" i2="+Integer.toBinaryString(i2));

System.out.println("i2>>>2="+Integer.toBinaryString(i2>>>2));

System.out.println(" i1&i2="+Integer.toBinaryString(i1&i2));

System.out.println(" i1^i2="+Integer.toBinaryString(i1^i2));

System.out.println(" i1|i2="+Integer.toBinaryString(i1|i2));

System.out.println(" ~i1="+Integer.toBinaryString(~i1));

}

}

程序运行结果如图2-4所示。结果是以二进制形式显示的，如果是负值，32位二进制位数全显示；如果是正值，前导0忽略，只显示有效位。

2.3.5 赋值运算符（=）和赋值表达式

赋值运算符是最常用的运算符，用于把一个表达式的值赋给一个变量（或对象）。在前边的示例中，我们已经看到了赋值运算符的应用。

与c、c++类似，Java也提供了复合的或称扩展的赋值运算符：

对算术运算有： +=，- =，*=，/=，%= 。

对位运算有： &=，^=，|=，<<=，>>=，>>>=。

例如：

x*=x+y ; 相当于x=x*(x+y) ;

x+=y; 相当于 x=x+y ;

y&=z ; 相当于 y=y&z ;

y>>=2; 相当于 y=y>>2 ;

2.3.6 条件运算符（ ? ：）及表达式

条件运算符是三元运算符，有条件运算符组成的条件表达式的一般使用格式是：

逻辑(关系)表达式 ？ 表达式1 ： 表达式2

其功能是：若逻辑（关系）表达式的值为true，取表达式1的值，否则取表达式2的值。

条件运算符及条件表达式常用于简单分支的取值处理。

例如，若已定义a,b为整型变量且以赋值，求a,b两个数中的最大者，并赋给另一个量max，可以用如下式子处理：

max=(a>b) ? a : b;

2.3.7 对象运算符

对象运算符如下：

1. 构造对象（new）

new 运算符主要用于构建类的对象，我们将在后边的章节作详细介绍。

2. 分量运算符（.）

. 运算符主要用于获取类、对象的属性和方法。例如上边程序中使用System类对象的输出方法在屏幕上输出信息： System.out.println(“my first Java program”);

3. 对象测试（instanceof ）

instanceof 运算符主要用于对象的测试。将在后边应用时介绍它。

2.3.8 其它运算符

还有如下一些运算符：

1. 数组下标运算符（[ ]）

主要用于数组。

2. 强制类型转换运算符（(类型)）

在高类型的数据向低类型的数据转换时，一般需要强制转换。

3. ( ) 运算符

( ) 运算符用在运算表达式中，它改变运算的优先次序；用于对象方法调用时作为方法的调用运算符。

4. 字符串连接符（+）

在表达式中，如果+号运算符前边的操作数是一个字符串，此时该+号运算符的作用是字符串连接符，例如：

”i1*i2=”+i1*i2

在程序中的System.out.print()输出方法的参数中，我们常常使用这种形式的表达式。

2.3.9 表达式的运算规则

最简单的表达式是一个常量或一个变量，当表达式中含有两个或两以上的运算符时，就称为复杂表达式。在组成一个复杂的表达式时，要注意以下两点：

1. Java运算符的优先级

表达式中运算的先后顺序由运算符的优先级确定，掌握运算的优先次序是非常重要的，它确定了表达式的表达是否符合题意，表达式的值是否正确。表2.4列出了Java中所有运算符的优先级顺序。

表2.4 Java运算符的优先次序

1

. , [] , ()

9

&

2

一元运算：+，-，++ , -- , ! , ~

10

^

3

new， (类型)

11

|

4

* , / , %

12

&&

5

+ , -

13

||

6

>> , >>> , <<

14

? :

7

> , < , >= , <=, instanceof

15

= , += , -= , *= , /= , %= , ^=

8

== , !=

16

&= , |= , <<= , >>= , >>>=

当然，我们不必刻意去死记硬背这些优先次序，使用多了，自然也就熟悉了。在书写表达式时，如果不太熟悉某些优先次序，可使用（）运算符改变优先次序。

2. 类型转换

整型、实型、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算，一般情况下，系统自动将两个运算数中低级的运算数转换为和另一个较高级运算数的类型相一致的数，然后再进行运算。

类型从低级到高级顺序示意如下：

低

------------------------------------------------------------------------>高

byte—> short, char—> int —> long—> float —> double

应该注意的是，如果将高类型数据转换成低类型数据，则需要强制类型转换，这样做有可能会导致数据溢出或精度下降。

如： long num1 = 8;

int num2 = (int)num1;

long num3 = 547892L;

short num4=(short)num3; //将导致数据溢出

本章小结

本章简要介绍了Java程序中的基本量：标识符、数据类型、运算符及表达式，它们是程序设计的基础，应该掌握它们并能熟练地应用。

数据类型可分为基本数据类型和引用型数据类型两种，本章介绍了基本数据类型，引用型数据类型将在后边的章节中介绍。

本章的重点：标识符的命名规则、变量和常量的定义及使用、运算符及表达式、不同数据类型值之间的相互转换规则、运算式子中的运算规则（按运算符的优先顺序从高向低进行，同级的运算符则按从左到右的方向进行）。

本章难点： 整数二进制的位运算操作。

习题2

一、选择题

1．以下有关标识符说法正确的是：

A．任何字符的组合都可形成一个标识符。

B．Java的保留字也可作为标识符使用。

C．标识符是以字母、下划线或$开头，后跟字母、数字、下划线或$ 的字符组合。

D．标识符是不区分大小写的。

2．以下哪一组标识符是正确的：

A．c_name, if, _name

B．c*name, $name, mode

C．Result1, somm1, while

D．$ast, _mmc, c$_fe

3. 下列哪个选项是合法的标识符:

A. 123 B. _name C. class D. 1first

4．有关整数类型说法错误的是：

A．byte,short,int,long都属于整数类型,分别占1,2,4,8个字节。

B．占据字节少的整数类型能处理较小的整数，占据的字节越多，处理的数据范围就越大。

C．所有整数都是一样的，可任意互换使用。

D．两个整数的算术运算结果，还是一个整数。

5．对于整型的字面量以下说法正确的是：

A．小于128的字面量，系统默认为是字节类型(byte)。

B．小于32768之间的字面量，系统默认为是短整数类型(short)。

C．大于32767之间的字面量，系统默认为是整数类型(int)。

D．所有整数字面量只要没有拖尾的类型标记(L或l)，系统均默认为是整数类型(int)。

6．以下说法正确的是：

A．基本字符数据类型有字符和字符串两种。

B．字符类型占两个字节，可保存两个字符。

C．字符类型占两个字节，可保存一个字符。

D．以上说法都是错误的。

7．有关浮点数类型说法正确的是：

A．浮点类型有单精度(float)和双精度(double)两种。

B．单精度(float)占4个字节，数据的表示范围是：-3.4E38~3.4E38。

C．双精度(double) 占8个字节数据的表示范围是：-1.7E308~1.7E308。

D．以上说法都正确。

8．关浮点型字面量说法正确的是：

A．数字字面量带有拖尾的标记f或F时，系统认为单精度(float)字面量。

B．带有拖尾的标记d或D时，系统认为双精度(double)字面量。

C．当字面量中无拖尾标记，但含有小数点或含有E指数表示时，系统默认为是双精度字面量(double)。

D．以上都正确。

9．关于类型转换说法错误的是：

A．低精度类型数据向高精度类型转换时，不会丢失数据精度。

B．系统会自动进行（整型或浮点型）低精度类型数据向高精度类型数据的转换。

C．高精度类型数据向低精度类型数据的转换、整型和浮点型数据之间的转换，必须强制进行，有可能会引起数据丢失。

D．高精度类型数据向低精度类型转换时，也不会丢失数据精度，因为转换是系统进行的。

10．对变量赋值说法错误的是：

A．变量只有在赋值后才能使用。

B．boolean类型的变量值只能取true或false。

C．只有同类型同精度的值才能赋给同类型同精度的变量，不同类型不同精度需要转换后才能赋值。

D．不同类型和精度之间也能赋值，系统会自动转换。

11．以下正确的赋值表达式是：

A．a = = 5

B．a+5 = a

C．a++

D．a++=b

12．数学式：x2+y2-xy正确的算术表达式是：

A．x^2+y^2+xy

B．x*x+y*y+xy

C．x(x+y)+y*y

D．x*x+y*y+x*y

13．以下正确的关系表达式是：

A．x≥y

B．x+y<>z

C．>=x

D．x+y!=z

14．以下正确的逻辑表达式是：

A．(x+y>7)&&(x-y<1)

B．! (x+y)

C．(x+y>7) || (z=a)

D．(x+y+z)&&(z>=0)

15．有关移位运算的说法是：

A．移位运算是一元运算。

B．移位运算是二元运算。是整数类型的二进制按位移动运算。

C．移位运算是二元运算。可以进行浮点数类型的二进制按位移动运算。

D．移位运算是二元运算。可以进行数据的按位移动运算。

16．有关位运算符说法正确的是：

A．~求反运算符是一元运算符。&, ^, | 是二元运算符。

B．a&b&c 是先进行a&c的二进制按位与操作，生成的结果再与c进行&操作。

C．位运算只对整型数据不能对浮点数进行位运算。

D．以上3种说法都正确。

17．有关条件运算符(?:)说法正确的是：

A．条件运算符是一个三元运算符，其格式是：表达式1 ? 表达式2 : 表达式3

B．格式中的表达式1是关系或逻辑表达式，其值是boolean 值。

C．若表达式1成立，该条件表达式取表达式2的值，否则取表达式3的值。

D．以上说法都正确。

18．下边正确的赋值语句是：

A．a=b=c=d+100;

B．a+7=m;

C．a+=b+7=c;

D．a*=c+7=d;

19．有关注释说法正确的是：

A．注释行可以出现在程序的任何地方。

B．注释不是程序的部分，因为编译系统忽略它们。

C．注释是程序的组成部分。

D．以上A）、B）说法正确，C）说法错误。

20. 下列的哪个选项可以正确用以表示八进制值8:

A. 0x8 B. 0x10 C. 08 D. 010

21. 下列的哪个赋值语句是不正确的:

A. float f = 11.1; B. double d = 5.3E12;

C. float d = 3.14f ; D. double f=11.1E10f;

22. 下列的哪个赋值语句是正确的:

A. char a=12; B. int a=12.0;

C. int a=12.0f; D. int a=（int）12.0;

二、填空题

1． 3.14156F 表示的是 【 】。

2． 阅读程序：

public class Test1

{

public static void main(String args[])

{

System.out.println( 15/2);

}

}

其执行结果是 【 】。

3．设 a = 16，则表达式 a >>> 2 的值是 【 】。

4．阅读程序：

public class Test2

{

public static void main(String args[])

{

int i=10,j=5,k=5;

System.out.println(“i+j+k=”+ i+j+k);

}

}

其执行结果是 【 】。

三、编程题

1．编写一个应用程序，定义两个整型变量n1,n2。当n1=22，n2=64时计算输出n1+n2，n1-n2，n1*n2，n1/n2，n1%n2的值。

2．编写一个应用程序，定义两个整型变量n1,n2并赋给任意值。计算输出n1>n2，n1<n2，n1-n2>=0，n1-n2<=0，n1%n2= =0的值。

3．编写一个应用程序，定义两个float 变量C、F。计算公式C=5/9（F-32），计算当F=60、F=90时，输出C 的值。

4．编写一个应用程序计算圆的周长和面积，设圆的半径为1.5，输出圆的周长和面积值。

第3章 程序设计基础

本章将介绍Java 程序的注释方式、简单的输入/输出语句以及控制程序流程的分支结构和循环结构语句。

3.1 Java程序的注释方式

一般程序设计语言都提供了程序注释的方式，要想让别人读懂自己编写的程序，没有注释是比较困难的。

Java提供了两种注释方式：程序注释和程序文档注释。

3.1.1 程序注释

如前所述，程序注释主要是为了程序的易读性。阅读一个没有注释的程序是比较痛苦的事情，因为对同一个问题，不同的人可能有不同的处理方式，要从一行行的程序语句中来理解他人的处理思想是比较困难的，特别对初学者来说。因此对一个程序语句，一个程序段，一个程序它的作用是什么，必要时都应该用注释简要说明。

程序中的注释不是程序的语句部分，它可以放在程序的任何地方，系统在编译时忽略它们。

注释可以在一行上，也可在多行上。有如下两种方式的注释：

1. 以双斜杠（//）开始

以“//”开始后跟注释文字。这种注释方式可单独占一行，也可放在程序语句的后边。

例如，在下边的程序片段中使用注释：

//下面定义程序中所使用的量

int id ; //定义一整型变量id ，表示识别号码。

String name; //定义一字符串变量name，表示名字。

2. 以“/﹡”开始，以“﹡/”结束

当需要多行注释时，一般使用“/﹡……﹡/”格式作注释，中间为注释内容。

例如，在下边的程序片段中使用注释：

/﹡

* 本程序是一个示例程序，在程序中定义了如下两个方法：

* setName(String ) ---设置名字方法

* getName () --- 获取名字方法。

﹡/

public void setName(String name)

{

……….

}

public String getName()

{

return name;

}

………

3.1.2 程序文档注释

程序文档注释是Java特有的注释方式，它规定了一些专门的标记，其目的是用于自动生成独立的程序文档。

程序文档注释通常用于注释类、接口、变量和方法。下面看一个注释类的例子：

/**

* 该类包含了一些操作数据库常用的基本方法，诸如：在库中建立新的数据表、

* 在数据表中插入新记录、删除无用的记录、修改已存在的记录中的数据、查询

* 相关的数据信息等功能。

* @author unascribed

* @version 1.50, 02/02/06

* @since JDK2.0

*/

在上边的程序文档注释中，除了说明文字之外，还有一些@字符开始的专门的标记，说明如下：

@author 用于说明本程序代码的作者；

@version 用于说明程序代码的版本及推出时间；

@since 用于说明开发程序代码的软件环境。

还有一些其他的标记没有列出，需要时可参阅相关的手册及帮助文档。此外文档注释中还可以包含HTML标注。

JDK提供的文档生成工具javadoc.exe能识别注释中这些特殊的标记和标注，并根据这些注解生成超文本Web页面形式的文档。

3.2 Java程序的输入输出

在开始编写Java应用程序之前，先介绍一下Java程序的输入输出。在任何程序中，输入数据和输出结果都是必不可少的。由于输入和输出的途径不同，输入输出的方法也就不一样。Java没有提供专用的输入输出命令或语句，它的输入输出是靠系统提供的输入输出类的方法实现的。

下边我们就以字符界面和图形界面两种形式简要介绍一下标准设备(键盘、显示器)的输入输出方法。

3.2.1字符界面下的输入输出方法

字符界面下的输入输出是由Java的基类System提供的，在前边的示例中，我们已经使用了System.out.println()方法在屏幕上输出信息。下边看一下输入输出方法的一般格式。

1. 输入方法

格式： System.in.read();

功能：该方法的功能是从键盘上接受一个字符，按照byte类型的数据处理。若将它转换为字符型，它就是字符本身；若转换为整型，它是扩展字符的ASCII码值（0~255）。

2. 输出方法

格式1： System.out.print(表达式);

格式2： System.out.println(表达式);

功能：在屏幕上输出表达式的值。

这两个方法都是最常用的方法，两个方法之间的差别是，格式1输出表达式的值后不换行，格式2在输出表达式的值后换行。

3. 应用示例

例3.1 从键盘上输入一个字符，并在屏幕上以数值和字符两种方式显示其值。示例程序代码如下：

/* 示例3.1 程序名：IoExam3_1.java

* 这是一个字符界面输入输出的简单示例。

* 它主要演示从键盘上输入一个字符，然

* 后以字节方式、字符方式在屏幕上输出。

*/

class IoExam3_1

{

public static void main(String [] args)

{

int num1=0;

try

{

System.out.print("请输入一个字符：");

num1=System.in.read(); //从键盘上输入一个字符并把它赋给num1

}

catch(Exception e1) { }

System.out.println("以数值方式显示，是输入字符的ASCII值= "+num1);

System.out.println("以字符方式显示，显示的是字符本身 = "+(char)num1);

}

}

在上边的程序中，我们使用了异常处理try~catch()语句，这是System.in.read()所要求的。在Java中引入了异常处理机制，对于一些设备的I/O处理、文件的读写处理等等，都必须进行异常处理。我们将在后边的章节介绍异常处理，在这里只是简单认识一下它的基本结构。程序的运行屏幕如下：

3.2.2 图形界面下的输入输出方法

有关图形界面的程序设计将在后边的章节详细介绍，本节将以对话框的形式介绍图形界面下的输入输出。

在javax.swing类库中的JoptionPane类提供了相应的输入输出方法。

1. 输入方法

格式1： JOptionPane.showInputDialog(输入提示信息);

格式2： JOptionPane.showInputDialog(输入提示信息,初值);

功能：系统显示一个对话框，可以在输入提示信息后边的文本框中输入值。格式2带有初值，在输入的文本框中显示该值，若要改变其值，直接输入新的值即可。

2. 输出方法

格式1： JOptionPane.showMessageDialog(框架,表达式);

格式2： JOptionPane.showMessageDialog(框架,表达式,标题,信息类型);

功能：在对话框中显示相关的信息。

其中：

1）框架是显示该对话框所使用的框架（框架其实是一个屏幕容器组件，将在后边的章节介绍它）。如果使用系统默认的框架，选择null。

2）表达式是将在对话框中显示的信息。

3）标题是将在对话框标题栏显示的信息。

4）信息类型是一个常量，表明显示什么信息，部分常量说明如下：

JOptionPane.ERROR_MESSAGE或0 错误信息显示；

JOptionPane.INFORMATION_MESSAGE或1 通知信息显示；

JOptionPane.WARNING_MESSAGE或2 警告信息显示；

JOptionPane.QUESTION_MESSAGE或3 询问信息显示；

JOptionPane. PLAIN_MESSAGE或-1 完全信息显示。

3. 示例

例3.2 输入a,b两个数，输出a,b之中的最大者并输出a与b的差值。

/**

*这是一个求a,b之中最大值及差值的程序, 程序的名字：OptionExam3_2.java

*主要演示图示界面的输入输出方法的使用。

*/

import javax.swing.*;

class OptionExam3_2

{

public static void main(String[] args)

{

String str1 =

JOptionPane.showInputDialog("输入a的值：");

String str2 =

JOptionPane.showInputDialog("输入b的值：");

int a = Integer.parseInt(str1); //将输入的数值字符串转换为数值赋给a

int b = Integer.parseInt(str2); //将输入的数值字符串转换为数值赋给b

int max = a>b ? a : b; //求a,b之中的最大者赋给max

JOptionPane.showMessageDialog(null,"最大值="+max+" 差值="+(a-b),"示例",-1);

System.exit(0); //结束程序运行，返回到开发环境

}

}

图3-2显示了程序运行时的操作步骤及最后结果, 在程序运行后先弹出如图3-2a的对话框，输入a的值后，单击“确定”按钮，弹出第二个输入对话框，输入b的值，单击“确定”按钮后，弹出如图3-2c的第三个对话框显示结果。

在实际应用中，用户操作界面一般是图形界面，我们将在后边的章节详细介绍图形用户界面的部署，在这里只是简单认识一下图形界面的操作及应用。

3.3 分支控制语句

Java程序通过一些控制结构的语句来执行程序流，完成一定的任务。程序流是由若干个语句组成的，语句可以是单一的一条语句，如c=a+b; 也可以是用大括号“{}”括起来的一个复合语句即语句块。

Java语句包含一系列的流程控制语句，这些控制语句表达了一定的逻辑关系，所以可选择性的或者是可重复性的执行某些代码行，这些语句与其他编程语言中使用的流程控制语句大体相近，Java的流程控制语句基本上是仿照C／C++中的语句。每一个流程控制语句实际上是个代码块，块的开始和结束都是用大括号来进行表示的，其中“{”表示开始，“}”表示结束。在本节先介绍分支控制语句。

3.3.1 if条件分支语句

一般情况下，程序是按照语句的先后顺序依次执行的，但在实际应用中，往往会出现这些情况，例如计算一个数的绝对值，若该数是一个正数(>=0)，其绝对值就是本身；否则取该数的负值（负负得正）。这就需要根据条件来确定执行所需要的操作。类似这样情况的处理，要使用if条件分支语句来实现。由三种不同形式if条件分支语句，其格式如下：

1. 格式1

if (布尔表达式) 语句;

功能：若布尔表达式（关系表达式或逻辑表达式）产生true (真)值，则执行语句，否则跳过该语句。执行流程如图3-3所示。

其中，语句可以是单个语句或语句块（用大括号“{}”括起的多个语句）。

例如，求实型变量x 的绝对值的程序段：

float x = -45.2145f;

if(x<0) x = -x;

System.out.println(“x=” + x);

2. 格式2

if (布尔表达式) 语句1;

else 语句2;

该格式分支语句的功能流程如图3-4所示，如果布尔表达式的值为true执行语句1；否则执行语句2。

例如，下边的程序段测试一门功课的成绩是否通过：

int score = 40;

boolean b = Score>=60； //布尔型变量b是false

if (b) System．out．println (“你通过了测试”)；

else System．out．println (“你没有通过测试”)；

这是一个简单的例子，我们定义了一个布尔变量，主要是说明一下它的应用。当然我们可以将上述功能程序段，写为如下方式：

int score = 40;

if (score>=60) System.out.println(“你通过了测试”)；

else System.out.println(“你没有通过测试”)；

3. 格式3

if (布尔表达式1) 语句1;

else if (布尔表达式2) 语句2;

……

else if (布尔表达式n-1) 语句n-1;

else 语句n;

这是一种多者择一的多分支结构，其功能是：如果布尔表达式i (i=1~n-1)的值为true，则执行语句i；否则（布尔表达式i (i=1~n-1)的值均为false）执行语句n。功能流程见图3-5。

例3.3 为考试成绩划定五个级别，当成绩大于或等于90分时，划定为优；当成绩大于或等于80且小于90时，划定为良；当成绩大于或等于70且小于80时，划定为中；当成绩大于或等于60且小于70时，划定为及格；当成绩小于60时，划定为差。可以写出下边的程序代码：

/* 这是一个划定成绩级别的简单程序

* 程序的名字是ScoreExam3_3.java

* 它主要演示多者择一分支语句的应用。

*/

public class ScoreExam3_3

{

public static void main(String [] args)

{

int score = 75;

if(score>=90) System.out.println("成绩为优="+score);

else if(score>=80) System.out.println("成绩为良="+score);

else if(score>=70) System.out.println("成绩为中="+score);

else if(score>=60) System.out.println("成绩为及格="+score);

else System.out.println("成绩为差="+score);

}

}

3.3.2 switch条件语句

如上所述，if~ else if ~ else是实现多分支的语句。但是当分支较多时，使用这种形式会显得比较麻烦，程序的可读性差且容易出错。Java提供了switch语句实现“多者择一”的功能。switch语句的一般格式如下：

switch(表达式)

{

case 常量1： 语句组1; [break;]

case 常量2： 语句组2;[break;]

……………………………

case 常量n-1： 语句组n-1;[break;]

case 常量n： 语句组n;[break;]

default： 语句组n+1;

}

其中：

1）表达式是可以生成整数或字符值的整型表达式或字符型表达式。

2）常量i (i=1~n)是对应于表达式类型的常量值。各常量值必须是唯一的。

3）语句组i (i=1~n+1) 可以是空语句，也可是一个或多个语句。

4）break关键字的作用是结束本switch结构语句的执行，跳到该结构外的下一个语句执行。

switch语句的执行流程如图2-5所示。先计算表达式的值，根据计值查找与之匹配的常量i，若找到，则执行语句组i，遇到break语句后跳出switch结构，否则继续执行下边的语句组。如果没有查找到与计值相匹配的常量i，则执行default关键字后的语句n+1。

例3.4 使用switch结构重写例3.3， 程序参考代码如下：

/* 这是一个划定成绩级别的简单程序

* 程序的名字是SwitchExam3_4.java

* 它主要演示多者择一分支语句的应用。

*/

public class SwitchExam3_4

{

public static void main(String [] args)

{

int score = 75;

int n=score/10;

switch(n)

{

case 10:

case 9: System.out.println("成绩为优="+score);

break;

case 8: System.out.println("成绩为良="+score);

break;

case 7: System.out.println("成绩为中="+score);

break;

case 6: System.out.println("成绩为及格="+score);

break;

default: System.out.println("成绩为差="+score);

}

}

}

比较一下，我们可以看出，用switch语句处理多分支问题，结构比较清晰，程序易读易懂。使用switch语句的关键在于计值表达式的处理，在上边程序中n=score/10，当score=100时，n=10; 当score大于等于90小于100时，n=9，因此常量10和9共用一个语句组。此外score在60分以下，n=5,4,3,2,1,0统归为default，共用一个语句组。

例3.5 给出年份、月份，计算输出该月的天数。

/* 这是一个计算某年某月天数的程序

* 程序的名字是：DayofMonthExam3_5.java

* 程序的目的是演示Switch结构的应用。

*/

public class DayofMonthExam3_5

{

public static void main(String [] args)

{

int year = 1980;

int month = 2;

int day=0;

switch(month)

{

case 2: day=28; //非闰年28天，下边判断是否闰年，闰年29天

if((year%4==0)&&((year%400==0)||(year%100!=0))) day++;

break;

case 4:

case 6:

case 9:

case 11: day=30;

break;

default: day=31;

}

System.out.println(year+"年"+month+"月有"+day+"天");

}

}

当然你也可以使用if~else if~else语句结构来编写该应用的代码，这一任务作为作业留给大家。比较一下，看一下哪种方式更好一些，更容易被接受。

3.4 循环控制语句

在程序中，重复地执行某段程序代码是最常见的，Java也和其他的程序设计语言一样，提供了循环执行代码语句的功能。

3.4.1 for循环语句

for循环语句是最常见的循环语句之一。for循环语句的一般格式如下：

for ( 表达式1; 表达式2; 表达式3)

{

语句组； //循环体

}

其中：

1）表达式1一般用于设置循环控制变量的初始值，例如：int i=1；

2）表达式2一般是关系表达式或逻辑表达式，用于确定是否继续进行循环体语句的执行。例如：i<100;

3）表达式3一般用于循环控制变量的增减值操作。例如：i++; 或i--;

4）语句组是要被重复执行的语句称之为循环体。语句组可以是空语句（什么也不做）、单个语句或多个语句。

for循环语句的执行流程如图3-7所示。先计算表达式1的值；再计算表达式2的值，若其值为true，则执行一遍循环体语句；然后再计算表达式3。之后又一次计算表达式2的值，若值为true，则再执行一遍循环体语句；又一次计算表达式3；再一次计算表达式2的值，……；如此重复，直到表达式2的值为false，结束循环，执行循环体下边的程序语句。

例3.6 计算sum=1+2+3+4+5+…+100的值。

/* 这是一个求和的程序

* 程序的名字是：SumExam3_6.java

* 主要是演示for 循环结构的应用。

*/

public class SumExam3_6

{

public static void main(String [] args)

{

int sum=0;

for(int i=1; i<=100; i++)

{

sum+=i;

}

System.out.println("sum="+sum) ;

}

}

该例子中我们使用的是for标准格式的书写形式，在实际应用中，可能会使用一些非标准但符合语法和应用要求书写形式。不管何种形式，我们只要掌握for循环的控制流程即可。下边我们看一个例子。

例3.7 这是一个古典数学问题：一对兔子从它出生后第3个月起，每个月都生一对小兔子，小兔子3个月后又生一对小兔子，假设兔子都不死，求每个月的兔子对数。该数列为：

1 1 2 3 5 8 13 21… 即从第3项开始，其该项是前两项之和。求100以内的波那契数列。程序参考代码如下：

/**一一一一一一一一一一一一一一一一一一一一

*功能概述： 生成100以内的斐波那契数列

*Fibonacci.java文件

* 一一一一一一一一一一一一一一一一一一一一

*/

public class FibonacciExam3_7

{

public static void main(String args[])

{

System.out.println("斐波那契数列:");

/**采用for循环，声明3个变量：

i--- 当月的兔子数(输出)；

j--- 上月的兔子数；

m--- 中间变量，用来记录本月的兔子数

*/

for(int i=1, j=0, m=0; i<100; )

{

m=i; //记录本月的兔子数

System.out.print(" "+i); //输出本月的兔子数

i=i+j; //计算下月的兔子数

j=m; //记录本月的兔子数

}

System.out.println("");

}

}

编译运行程序，结果如图3-8所示。

在该程序中我们使用了非标准形式的for循环格式，缺少表达式3。在实际应用中，根据程序设计人员的喜好，三个表达式中，那一个都有可能被省去。但无论哪种形式，即便三个表达式语句都省去，两个表达式语句的分隔符“；”也必须存在，缺一不可。

图3-8 例3.7运行结果

3.4.2 While和do-While循环语句

一般情况下，for循环用于处理确定次数的循环；while和do-while循环用于处理不确定次数的循环。

1. while循环

while循环的一般格 式是：

while(布尔表达式)

{

语句组； //循环体

}

其中：

1) 布尔表达式可以是关系表达式或逻辑表达式，它产生一个布尔值。

2) 语句组是循环体，要重复执行的语句序列。

while循环的执行流程如图3-9所示。当布尔表达式产生的布尔型值是true时，重复执行循环体（语句组）操作，当布尔表达式产生值是false时，结束循环操作，执行while循环体下边的程序语句。

例3.8 计算n!, 当n=9时。并分别输出1！~9！各阶乘的值。

/* 程序的功能是计算1~9的各阶乘值

* 程序的名字是：FactorialExam3_8.java

* 目的在于演示while()循环结构

*/

public class FactorialExam3_8

{

public static void main(String [] args)

{

int i=1;

int product=1;

while(i<=9)

{

product*=i;

System.out.println(i+"!="+product);

i++;

}

}

}

编译、运行程序，结果入图3-9所示。

例3.9 修改例3.7使用while循环显示100以内的斐波那契数列。请注意和for循环程序之间的差别。

/**一一一一一一一一一一一一一一一一一一一一一一一一一

*功能概述：使用while 循环计算100以内的斐波那契数列

*Fibo_whileExam3_9.java文件

* 一一一一一一一一一一一一一一一一一一一一一一一一一

*/

public class Fibo_whileExam3_9

{

public static void main(String args[])

{

int i=1;

int j=0;

int m=0;

System.out.println("斐波那契数列:");

while(i<100)

{

m=i;

System.out.print(" "+i);

i=i+j;

j=m;

}

System.out.println("");

}

}

2. do-While循环

do-while循环的一般格式是：

do

{

语句组； //循环体

}

while(布尔表达式)；

我们注意一下do-while和while循环在格式上的差别，然后再留意一下它们在处理流程上的差别。图3-10描述了do-while的循环流程。

从两种循环的格式和处理流程我们可以看出它们之间的差别在于：while循环先判断布尔表达式的值，如果表达式的值为true则执行循环体，否则跳过循环体的执行。因此如果一开始布尔表达式的值就为false，那么循环体一次也不被执行。do~while循环是先执行一遍循环体，然后再判断布尔表达式的值，若为true则再次执行循环体，否则执行后边的程序语句。无论布尔表达式的值如何，do~while循环都至少会执行一遍循环体语句。下边我们看一个测试的例子。

例3.10 while和do~while循环比较测试示例。

/**

Test_while_do_whileExam3_10.java文件

* 功能概述：进行while和do-while循环的测试

*/

public class Test_while_do_whileExam3_10

{

public static void main(String args[])

{

int i=0; //声明一个变量

System.out.println("准备进行while操作");

while (i<0)

{

i++;

System.out.println("进行第"+i+"次while循环操作");

}

System.out.println("准备进行do-while循环");

i=0;

do

{ i++;

System.out.println("进行第"+i+"次do-while循环操作");

}

while(i<0);

}

}

编译、运行程序，结果如图3-11所示。大家可以分析一下结果，比较两种循环之间的差别。

3.5 其他控制语句

3.5.1 break语句

在前边介绍的switch语句结构中，我们已经使用过break语句，它用来结束switch语句的执行。使程序跳到switch语句结构后的第一个语句去执行。

break语句也可用于循环语句的结构中。同样它也用来结束循环，使程序跳到循环结构后边的语句去执行。

break语句有如下两种格式：

1） break;

2） break 标号；

第一种格式比较常见，它的功能和用途如前所述。

第二种格式带标号的break语句并不常见，它的功能是结束其所在结构体（switch或循环）的执行，跳到该结构体外由标号指定的语句去执行。该格式一般适用于多层嵌套的循环结构和switch结构中，当你需要从一组嵌套较深的循环结构或switch结构中跳出时，该语句是十分有效的，它大大简化了操作。

在Java程序中，每个语句前边都可以加上一个标号，标号是由标识符加上一个“：”号字符组成。

下边我们举例说明break语句的应用。

例3.11输出50~100以内的所有素数。所谓素数即是只能被1和其自身除尽的正整数。

/**

* 这是一个求50~100之间所有素数的程序，程序名为：Prime50_100Exam3_11.java

* 目的是演示一下break语句的使用。

*/

class Prime50_100Exam3_11

{

public static void main(String[] args)

{

int n,m,i;

for( n=50; n<100; n++)

{

for( i=2; i<=n/2; i++)

{

if(n%i==0) break; //被i除尽，不是素数，跳出本循环

}

if(i>n/2) //若i>n/2,说明在上边的循环中没有遇到被除尽的数

{

System.out.print(n+" "); //输出素数

}

}

}

}

例3.12 修改例3.11，使用带标号的break语句，输出50~100以内的所有素数。

/**

* 这是一个求50~100之间所有素数的程序，程序名为：Prime50_100Exam3_12.java

* 目的是演示一下带标号的break语句的使用。

*/

class Prime50_100Exam3_12

{

public static void main(String[] args)

{

int n,m,i;

for( n=50; n<100; n++)

lb1:{

for( i=2; i<=n/2; i++)

{

if(n%i==0) break lb1; //被i除尽，不是素数

}

System.out.print(n+" "); //输出素数

}

}

}

我们可以相对比较一下，使用哪种格式使程序更简洁更容易理解一些。

3.5.2 continue语句

continue语句只能用于循环结构中，它和break语句类似，也有两种格式：

1) continue；

2)continue 标号;

第一种格式比较常见，它用来结束本轮次循环（即跳过循环体中下面尚未执行的语句），直接进入下一轮次的循环。

第二种格式并不常见，它的功能是结束本循环的执行，跳到该循环体外由标号指定的语句去执行。它一般用于多重（即嵌套）循环中，当需要从内层循环体跳到外层循环体执行时，使用该格式十分有效，它大大简化了程序的操作。

下边举例说明continue语句的用法。

例3.13 输出10~1000之间既能被3整除也能被7整除的数。

/* 本程序计算10~1000之间既能被3整除也能被7整除的数

* 程序的名字是： Mul_3and7Exam3_13.java

* 目的是演示continue语句的用法。

*/

public class Mul_3and7Exam3_13

{

public static void main(String args[])

{

int k=1;

System.out.println("在10～1000可被3与7整除的为");

for(int n=10; n<=1000; n++)

{

if(n%3!=0 || n%7!=0)continue;

System.out.print(n+" ");

if(k++%10==0)System.out.println("");//k用来控制1行打印10个

}

System.out.println(" ");

}

}

编译、运行程序，结果如图2-12所示。

例3.14修改例3.11，使用带标号的continue语句。输出50~100以内的所有素数。

/* 这是一个求50~100之间所有素数的程序

*程序名为：Prime50_100Exam3_14.java

* 目的是演示一下带标号的continue语句的使用。

*/

class Prime50_100Exam3_14

{

public static void main(String[] args)

{

int n,m,i;

lb1: for( n=50; n<100; n++)

{

for( i=2; i<=n/2; i++)

{

if(n%i==0) continue lb1; //被i除尽，不是素数

}

System.out.print(n+" "); //输出素数

}

}

}

3.5.3 返回语句return

return语句用于方法中，该语句的功能是结束该方法的执行，返回到该方法的调用者或将方法中的计算值返回给方法的调用者。return语句有以下两种格式：

1) return;

2) return 表达式;

第一种格式用于无返回值的方法；第二种格式用于需要返回值的方法。

下边举一个例子简要说明return语句的应用。

例3.15 判断一个正整数是否是素数，若是计算其阶乘。判断素数和阶乘作为方法定义，并在主方法中调用它们。程序参考代码如下：

/**该程序包含以下两个方法

* prime() 方法判断一个整数是否为素数

* factorial()方法用于求一个整数的阶乘

* 目的主要是演示return语句的应用

*/

public class Math_mothodExam3_15

{

public static boolean prime(int n) //判断n是否素数方法

{

for(int i=2; i<n/2; i++)

{

if(n%i==0) return false; //n不是素数

}

return true; //n是素数

} //prime()方法结束

public static int factorial(int n) //求阶乘方法

{

if(n<=1) return 1;

int m=1;

for(int i=1; i<=n; i++) m*=i;

return m;

} //factorial()方法结束

public static void main(String args[]) //主方法

{

int n=13;

System.out.println(n+"是素数吗？"+prime(n));

if(prime(n)) System.out.println(n+"!="+factorial(n));

} //main()方法结束

}

编译、运行程序，结果如图2-13所示。

本章小结

本章讨论了程序的注释、简单的输入输出方法、条件分支结构的控制语句和循环结构的控制语句以及break、continue、return等控制语句，它们是程序设计的基础，应该认真理解熟练掌握并应用。

本章重点： 三种格式的if分支结构和switch多分支结构、for循环结构、while循环结构、do…while循环结构、break语句、continue语句和return语句的使用。要注意不同格式分支结构的功能，不同循环结构之间使用上的差别，只有这样，我们才能在实际应用中正确使用它们。

习题