JAVA程序设计基础课件

第2章Java基本语法2.1

Java语言的基本组成2.2变量和直接量2.3数据类型2.4运算符与表达式2.5

Java语句及其控制结构2.6

数

组2.1

Java语言的基本组成2.1.1标识符2.1.2关键字2.2变量和直接量变量是一块取了名字的用来存储Java程序信息的内存区域，它是一些有意义的数据。在程序中，定义的每块被命名的内存区域只能存储一种特定类型的数据。在程序中直接给出的数值被称作直接量，直接量可以是一个具体的数值或字符串，每个直接量也属于一个特定的类型。2.3数据类型2.3.1

integer数据类型（1）字节（byte）型（2）短整（short）型（3）整（int）型（4）长整（long）型2.3.2浮点数据类型（1）单精度浮点型（float）（2）双精度浮点型（double）2.3.3变量类型的转换2.4运算符与表达式•2.4.1赋值运算符•2.4.2算术运算符•2.4.3关系运算符•2.4.4条件运算符•2.4.5逻辑运算符2.5

Java语句及其控制结构2.5.1

Java语句

Java语句是Java标识符的集合，由关键字、常量、变量和表达式构成，是成员方法的主要成分，必须包含在类的方法体之中。Java语句

有表达式语句、复合语句、选择语句和循环语句等。语句以分号“；”作为结束标志，单独的一个分号被看作一个空语句，空语句不做任何事情。在表达式后边加上分号“；”就是一个表达式语句。经常使用的表达式语句有赋值语句

和方法调用语句。表达式语句是最简单的语句，它们被顺序执行，完成相应的操作。

复合语句也称为块（block）语句，是包含在一对大括号“{}”中的任意语句序列。与其他语句用分号作结束符不同，复合语句右括号

“}”后面不需要分号。尽管复合语句含有任意多个语句，但从语法上讲，一个复合语句被看作一个简单语句。例2-2：public

class

Block{public

static

void

main(String

args[]){int

k,i=3,j=4;k=i

+

j;System.out.println("k="+k);{float

f;f=j+4.5F;i++;System.out.println("f="+f);}System.out.println("i="+i);}}运行结果见图2-2。图2-2程序说明：在main方法中有两个复合语句嵌套在一起，复合语句内包含的是表达式语句。第1个复合语句中说明了3个整型变量k、i、j，它们不仅在第1个复合语句中起作用，还在被嵌套的第2个复合语句中起作用。而在第2个复合

语句中说明的变量f仅在第2个复合语句中起作

用。在这个例子中，人为地加入了一个复合语句，在实际编程中并不多见。复合语句更广泛的应用是在结构式语句中，如选择语句和循环语句。当结构式语句中包含的表达式语句超过一条时，就要用大括号把它们括起来。2.5.2选择语句

在复合语句中必须逐行执行每条命令。能

否改变程序执行的顺序呢？利用if...else结构就可以根据条件控制程序流程。1．if语句if语句的语法结构如下：if（条件表达式）s1语句;这是最简单的单分支结构。条件表达式的值为true，就执行s1语句，否则就忽略s1语句。

s1语句可以是复合语句。2．if...else语句

if选择结构仅当条件为真时才执行某一动作，否则忽略这一动作。而if...else选择结构允许程序员指定在条件为真或者条件为假时的不同动作。if语句通常都与else语句配套使用，形成二分支结构。它的语法结构如下：if（条件表达式）s1语句;elses2语句;当条件表达式的值为true，就执行s1语句，忽略else和s2语句；否则，条件表达式的值为

false，程序忽略s1语句，执行else后面的s2语句。

s1和s2都可以是复合语句。3．if...else复合结构对于复杂的情况，我们可以嵌套使用

if...else语句。它的语法结构如下：if（条件表达式1）s1语句;else

if（条件表达式2）s2语句;elses3语句;

在这里依次计算条件表达式，如果某个条件表达式的值为true，就执行它后面的语句，其余部分被忽略。所有表达式的值都为false，就执行最后一个else后的s3语句。s1、s2和s3都可以是复合语句。4．switch开关语句

虽然嵌套的条件语句可实现多个分支处理，但嵌套太多时容易出错和混乱，这时可以使用

开关语句switch处理。实际上开关语句switch也是一种if...else结构，不过它使你在编程时很容易写出判断条件，特别是有很多条件选项的时

候。开关语句switch的语法结构如下：switch(表达式){

case常量1;语句1;break;case常量2;语句2;break;……default:•语句n;

}其中switch、case、default是关键字，

default子句可以省略。开关语句先计算表达式，然后将表达式值与各个常量比较，如果表达式值与某个常量相

等，就执行该常量后面的语句。如果都不相等，就执行default下面的语句，如果无default子句，就什么都不执行，直接跳出开关语句。使用开关语句时，注意以下问题。（1）case后面的常量必须是整数或字符型，而且不能有相同的值。（2）通常在每一个case中都应使用break语句提供一个出口，使流程跳出开关语句。否则，在第一个满足条件case后面的所有语句都会被执行，这种情况叫做落空。（3）有些case标号列在一起（如“case1:case2:”，中间没有语句），这表示对所列情况将进行同样的操作。2.5.3循环语句1．for循环语句for循环的语法结构为：for（表达式1；表达式2；表达式3）循环体2．while循环语句while循环的语法结构为如下形式：while

（条件表达式）循环体•••3．do...while循环

如不用大括号，循环体中只含一条语句的

do...while结构如下：do语句while（条件）；只有一条语句的do...while结构也常常写成如下形式：do{语句}while（条件）；4．循环语句的嵌套5．循环语句小结一个循环一般应包括以下4部分内容。（1）初始化部分用来设置循环的一些初始条件，计数器清零等。（2）循环体部分这是反复被执行的一段代码，可以是单语句，也可以是复合语句。（3）迭代部分这是在当前循环结束，下一次循环开始时执行的语句，常用来使计数器加1或减1。（4）终止部分通常是一个布尔表达式，每一次循环要对该表达式求值，以验证是否满足循环终止条件。2.5.4跳转语句1．break和continue语句2．带标号的break和continue语句2.6数组2.6.1数组的声明和建立数组按如下格式定义：type

arrayname[

]；

type是数组类型，它指出数组中各元素的类型，arrayname为数组名。2.6.2多维数组以二维数组为例，其格式为：•type

arrayname[

][

];第3章面向对象的程序设计3.1简介3.2类3.3对象3.4实例研究（无）3.5类的继承和类的多态性3.6接口与包3.1

简

介Java是面向对象的程序设计语言，从面向对象这个角度看，体现了如下3个特点。1．封装性2．继承性3．通信相关性3.2类1．类的说明（1）指出特性（2）指出父类（extends部分）（3）指出接口（implements部分）2．类体3.2.1类的成员变量1．变量的访问权限（1）公用（public）变量（2）专用（private）变量（3）保护型（protected）变量

（4）专用保护型（private

protected）变量（5）默认型变量2．是否为静态变量3．是否为常量3.2.2类的方法其格式如下所示：methodDeclaration{methodBody}3.2.3

this和super

this和super是Java的两个关键字，它们用在方法体中作为两个特殊的变量前缀和方法前缀。

this用来指明当前对象的成员变量或方法，以区分于同名的局部变量和其它同名的方法，而

super则用于指出父类的变量和方法。1．this的使用场合一个对象中的方法一般可以直接访问同一对象的成员变量。但是，有时候方法体内部定义的变量和成员变量名字相同，还有时方法的入口参数和对象的成员变量名字相同，那么就需要将三者区别清楚。因此，专门用this来指明当前对象的成员变量或当前对象的方法。2．super的使用场合在Java中，由父类派生子类，这样，子类的成员变量可能和父类的成员变量名字相同，

子类的方法也可能和父类的方法一样。当需要

调用父类的同名方法或使用父类的同名变量时，在子类中可用关键字super作前缀来指明父类的成员变量和方法。3.2.4构造函数3.2.5

main方法3.3对象3.3.1对象的创建•

一个对象往往经历创建、运行和释放3个阶段，这称为对象的典型生命周期。创建对象包括定义对象、建立对象和初始化对象3步。3.3.2对象的使用

对象使用就是指通过某种手段使一个对象产生它的效能。有两种途径来使用对象：一种是通过对象变量的引用来使用对象，另一种是通过调用对象的方法来使用对象。下面我们结合具体例子来说明。1．通过对象变量的引用来使用对象实际上，对象变量的引用就是用语句访问对象的变量，通过这种引用可以检测和修改变量。引用对象变量须按如下格式：ObjectReference.variable

;其中，ObjectReference是对象名，variable是所引用的变量。比如，已经由Rectangle建立了名为

myRectangle的对象，它有4个可以访问的变量x，y，width和height，那么：myRectangle.x=2;myRectangle.y=4;这两个语句将矩形myRectangle的原点定位于X轴方向为2，Y轴方向为4的位置上，而语句：rnyRectangle.width

=20;myRectangle.height=40;则将矩形的宽定为20，长定为40。对象变量的引用不仅能够检测和修改变量，也可以通过表达式来对几个变量进行合成，得到新的复合型变量。比如，用如下表达式引用对象变量：areaMyRectangle=myRectangle.width

*myRectangle.height

;就获得了矩形的面积，它用变量

areaMyRectangle表示。要提到的是，对象变量的引用有时会使某个变量改得不符合要求，从而使一个对象处于不规范状态。因为这一点，在类的设计中，有些变量被设置为禁止被操作状态，从而使这些变量不允许其他对象访问。这时，对象变量引用就不可行了。2．通过调用对象的方法来使用对象

每个对象在创建的时候，一方面用变量确定了它的状态，由创建过程为它分配内存空间，另一方面也创建了与它有关的方法，每个方法

都是和行为有关的。所以通过调用对象的某个

方法来使用对象，从而产生某种行为，这是最

符合逻辑思维习惯的。实际上，这也是更为安全可靠地使用对象的一种手段，因为这避免了

对变量的直接操作。

调用一个对象中的某个方法要遵照如下格式：ObjectReference.methodName(paramlist);或者：ObjectReference.methodName();比如，从Rectangle类中创建的对象

myRectangle含有一个方法叫move()，下面的语句就是用方法move()将对象myRectangle移动到一个新的位置：myRectangle.move

(5,

10);这个语句产生的效果等同于下面两个语句：myRectangle.x=5;myRectangle.y=10;3.3.3对象的释放

所谓释放对象，实质上就是释放掉分配给此对象的内存空间。Java中，对象的释放是自

动完成的，不需要程序员在编程时关注这一点。

Java运行系统具有所谓的“垃圾收集”机制，这种机制会周期性地检测对象是否还在使用，

如发现有长期不用的对象，则给予释放，回收

分配给这些对象的内存，这就是垃圾收集。

具体运行中，垃圾收集是由一个称为Java垃圾收集器的程序实现的。当一个对象在使用时，Java运行系统会将其对应的内存空间设置标记；而当一个对象结束使用时，会自动清除标记。有了这种标记设置和清除的规则，Java垃圾收集器就可以通过周期性地扫描所有Java对象有关的内存区域标记，将没有标记的内存区列入可供分配的范畴，从而起到垃圾收集作用。3.5类的继承和类的多态性3.5.1类的继承

类的继承是面向对象的程序设计语言所具有的重要技术。有了继承技术，程序设计时，就可以先定义一个包含公用变量和公用方法的类作为父类，再在此基础上创建具有专用变量和专用方法的子类。子类一方面可以增加父类中没有的变量和方法，另一方面还可以在继承基础上再定义父类中已有的变量和方法。

Java系统要求应用程序中每个类都有父类，如果一个类的定义中没有用关键字extends明确指出父类名，则Java系统默认这个类的父类为

系统软件包java.1ang中的Object类。父类中凡是公用型的、保护型的或者专用保护型的变量

和方法均可由子类直接调用，只有父类的专用

型变量和专用型方法不能被子类调用。例3-3：//

Point.javapublic

class

Point{protected

int

x,

y;public

Point()

{

setPoint(

0,

0

);

}public

Point(

int

a,

int

b

)

{

setPoint(

a,

b

);

}public

void

setPoint(

int

a,

int

b

)x

=

a;y

=

b;{••}public

int

getX()

{

return

x;

}public

int

getY()

{

return

y;

}

public

String

toString()

{

return

"["

+

x

+

",

"

+y

+

"]";

}}//Circle.javapublic

class

Circle

extends

Point{protected

double

radius;public

Circle()

{

setRadius(

0

);}public

Circle(

double

r,

int

a,

int

b

){super(

a,b

);setRadius(

r

);}

public

void

setRadius(

double

r

)

{

radius

=

(

r

>=0.0

?

r

:

0.0

);

}public

double

getRadius()

{

return

radius;

}

public

double

area()

{

return

Math.PI

*

radius

*radius;

}public

String

toString(){return

"Center

=

"

+

super.toString()

+

";

Radius=

"

+

radius;}}//

Cylinder.javapublic

class

Cylinder

extends

Circle{protected

double

height;public

Cylinder()

{

setHeight(

0

);

}public

Cylinder(

double

h,

double

r,

int

a,

int

b

){super(

r,

a,

b

);setHeight(

h

);}public

void

setHeight(

double

h

){

height

=

(

h

>=

0

?

h

:

0

);

}public

double

getHeight()

{

return

height;

}public

double

area(){

return

2

*

super.area()

+

2

*

Math.PI

*radius

*

height;}

public

double

volume()

{

return

super.area()

*height;

}public

String

toString(){

return

super.toString()

+

";

Height

=

"

+height;}}//Test.javaimport

javax.swing.JOptionPane;import

java.text.DecimalFormat;public

class

Test

{public

static

void

main(

String

args[]

){Cylinder

c

=

new

Cylinder(

5.7,

2.5,

12,

23

);

DecimalFormat

precision2

=

newDecimalFormat(

"0.00"

);String

output;output

=

"X

coordinate

is

"

+

c.getX()

+"\nY

coordinate

is

"

+

c.getY()

+"\nRadius

is

"

+

c.getRadius()

+"\nHeight

is

"

+

c.getHeight();c.setHeight(

10

);c.setRadius(

4.25

);c.setPoint(

2,2

);output

+="\n\nThe

new

location,

radius

"

+"and

height

of

c

are\n"

+

c

+

"\nArea

is

"

+

precision2.format(

c.area()

)

+"\nVolume

is

"

+

precision2.format(

c.volume()

);

JOptionPane.showMessageDialog(

null,output,"Demonstrating

Class

Cylinder",•JOptionPane.INFORMATION_MESSAGE

);System.exit(

0

);}}运行结果见图3-3。图3-3

程序分析：Circle类继承了Point类。这意味着Circle的public接口除了包括Circle类的

setRadius、getRadius、area、toString方法和

Circle的构造函数外，还包括Point的方法。应用程序Test用来测试Cylinder类。

注意Cylinder类继承了Circle类，即Cylinder的public接口除了包括Cylinder构造函数，

Cylinder的方法setHeight、getHeight、area（覆盖Circle的area方法）、volume和toSting外，还包括Circle的方法。Test应用程序的main方法

首先实例化了Cylinder类的一个对象，然后用“获取”方法获取关于Cylinder对象的信息。同样，这里的main方法也不能直接引用Cylinder类的protected数据。3.5.2类的多态性••

如果你想要使用多态性，则所需的条件概括如下。对派生类对象方法的调用必须通过基类的变量。被调用的方法必须也是基类的一个成员。（3）在基类与派生类中这个方法的方法名必须相同。（4）在基类与派生类中这个方法的返回类型必须相同。（5）在派生类中这个方法的访问修饰符限制不能超过基类中的限制。3.6接口与包3.6.1接口•

接口是和类很相似而又有区别的一种结构，接口的设计和调用也是Java程序设计的重要技

术。从结构上，接口有如下特点。（1）接口用关键字interface来定义，而不是用class。（2）接口中定义的变量全是最终的静态变量。（3）接口中没有自身的构造方法，而且定义的其他方法全是抽象方法，即只提供方法的定义，而没有提供方法的实现语句。（4）接口采用多重继承机制，而不是采用类的单一继承机制。3.6.2包1．声明自己的程序包2．程序包的引用3．Java的系统程序包第4章异常处理和常用系统类4.1异常处理机制4.2

String类和StringBuffer类4.3

AWT4.4

Java

applet4.1异常处理机制4.1.1什么是异常

用任何一种计算机语言设计的程序在运行

时都可能出现各种错误，常见的错误如除数为0、文件不存在、文件不能打开、数组下标超过界

限、内存不够用等。对于这种在运行中出现的

错误，计算机系统中通常有两种处理办法。

（1）由计算机系统本身直接检测程序错误，遇到错误时使程序终止运行。这种处理方法的优点是使程序设计比较简单。但是，对程序错

误一概地采用终止运行办法，显然过于简单化。因为有些情况下，完全可以通过其他途径保持

程序继续运行。比如，由于文件名不符合要求

而无法打开文件，那么，可以提示用户输入一

个新的文件名，从而使程序继续往下运行。

（2）由程序员在程序设计中兼顾错误检测、错误信息显示和出错处理。这种处理方法的优点是减少了中途终止程序运行的可能性。但是，要求程序员在程序设计中不仅将精力用于正常

处理过程，还要精心考虑错误检测和处理，这

会使程序变得复杂。并且，这类错误检测往往

是多数程序中重复甚至在一个程序中多次重复。而另一方面，如果程序中某处忽略了应有的检

测，又将引起程序总体结果的错误。

Java采用异常处理机制来处理程序运行中的错误。按照这种机制，将程序运行中的所有错误都看成一种异常，通过对语句块的检测，一个程序中所有的异常被收集起来放在程序的某一段中去处理。在Java系统中，专门设置了一个调用栈，此栈中装有指向异常处理方法的指针。

在程序运行时，系统会把收集到的异常和异常处理指针所指的处理类型逐个比较，如果

找到相符的类型，那么就转向相应的方法处理，如没有在调用栈中找到相应的类型指针，则终

止程序运行，并显示解释信息。在Java程序中，异常一般由以下两种原因引起。（1）程序中存在非法操作，最简单的例子就是除数为0的除法操作。这种原因常常是程序员出于无意或大意造成的，所以称为隐式异常。常见的隐式异常可以通过java.lang包中的

Throwable类的子类Error处理。

（2）程序员在程序中使用了throw语句引

起的异常。这种异常是程序员出于某种考虑有

意安排的，所以称为显式异常。在throw语句中，都会指出处理显式异常的对象，这些对象都是

由java.lang包的类Throwable的子类Exception再派生的子类生成的，每个对象完成对某种异常

的处理功能，这些对象综合起来实现各种异常

处理。比如Array-IndexOutOfBoundsException子类处理数组越界异常，IOException子类处理输入输出异常，而ArithmeticException子类处理除数为0导致的算术异常等。•4.1.2异常的层次结构•4.1.3异常的处理•4.1.4创建自己的异常4.2

String类和StringBuffer类4.2.1

String类1．String类的主要构造方法

String类有多个构造方法，主要的有下列5个：String();String(char

chars[

]);String(char

chars[

],

int

startIndex,

int

numChars);String(byte

ascii[

],

int

hiByte);

String(byte

ascii[

],

int

hiByte,

int

startIndex,

intnumChars);第1个构造方法生成一个空串。第2个构造方法生成一个字符数组。第3个构造方法生成一个字符串，这个字符串是从字符数组chars[]中提取的，具体讲，即从chars[]数组的startIndex位置开始提取字符，共提取numChars个字符组成一个字符串。第4个构造方法是以字节数组的形式生成一个字符串，数组中存放字符串各字符对应的

ASCII码。第5个构造方法也是从字节数组生成一个字符串。具体讲，就是以字节数组ascii[]的

startIndex处开始，共提取numChars个字符构成字符串，如为ASCII字符，则hiByte的值为0。例4-5：import

javax.swing.*;public

class

StringConstructors

{public

static

void

main(

String

args[]

){

char

charArray[]

=

{

"b",

"i",

"r",

"t",

"h",

"

",

"d","a",

"y"

};

byte

byteArray[]

=

{(byte)

"n",

(byte)

"e",

(byte)"w",(byte)

"

",

(byte)

"y",

(byte)

"e",(byte)

"a",

(byte)

"r"

};StringBuffer

buffer;String

s,

s1,

s2,

s3,

s4,

s5,

s6,

s7,

output;s

=

new

String(

"hello"

);

buffer

=new

StringBuffer(

"Welcome

to

JavaProgramming!"

);s1

=

new

String();s2

=

new

String(

s

);s3

=

new

String(

charArray

);s4

=

new

String(

charArray,

6,

3

);s5

=

new

String(

byteArray,

4,

4

);s6

=

new

String(

byteArray

);s7

=

new

String(

buffer

);output

=

"s1

=

"

+

s1

+"\ns2

=

"

+

s2

+•"\ns3

=

"

+

s3

+"\ns4

=

"

+

s4

+"\ns5

=

"

+

s5

+"\ns6

=

"

+

s6

+"\ns7

=

"

+

s7;

JOptionPane.showMessageDialog(

null,output，"Demonstrating

String

ClassConstructors"，•JOptionPane.INFORMATION_MESSAGE

);System.exit(

0

);}}运行结果见图4-5。图4-5程序分析：String类提供了9个构造函数，以便使用各种方法初始化String对象。例题共演示了7种。程序“s1=new

String()”实例化一个新的

String对象，并使用String类的缺省构造函数将它赋给引用s1。新的String对象没有字符（即空串），长度为0。“s2=new

String（s）；”例化一个新的

String对象，并使用String类的拷贝构造函数，将它赋给引用s2。s被当作参数传送给构造函数，新的String对象包含了String对象s中的字符的拷贝。在大多数情况下，没有必要拷贝已有的

String对象。String对象是不变的，一旦创建后就不能改变它们的内容（字符串）。而且，如果有一个或多个引用指向某个

String对象，垃圾收集器就不能回收该对象。也就是说，String引用既不能用于修改String对象，也不能删除String对象。这一点与C语言或C＋＋语言是不同的。“s3=new

String（charArray）；”实例化一个新的String对象，并使用以字符数组为参数的String类构造函数，将它赋给引用s3。新的

String对象包含了数组中字符的拷贝。“s4=new

String（charArray，6，3）；”实例化一个String对象，使用以一个字符数组和两个整数为参数的String类构造函数，将它赋给引用s4。第2个参数指定了在数组中拷贝字符的起始位置（offset）。第3个参数指定了数组中拷贝字符的数目（count），新的String对象包含了数组中指定字符的拷贝。如果offset或count参数指定的所取元素超过了字符数组的界限，就会产生

StringIndexOutOfBoundsException的例外处理。“s5=new

String（byteArray，4，4）；”实例化一个新的String对象，使用以一个byte数组和两个整数为参数的String类构造函数，将它赋给引用s5。第2和第3个参数分别指定了offset和count。新的String对象包含了数组中指定

byte的拷贝。如果offset或count参数指定的所取元素超过了byte数组的界限，就会产生一个

StringIndexOutOfBoundsException的例外处理。“s6=new

String（byteArray）；”实例化一个新的String对象，使用以一个byte数组为参数的String类构造函数，将它赋给引用s6。新的String对象包含了数组中byte的拷贝。“s7=new

String（buffer）；”实例化一

个新的String对象，使用以StringBuffer为参数的

String类构造函数，将它赋给引用s7。StringBuffer是一个可动态改变大小和内容的字符串。新的String对象包含了StringBuffer中字符的拷贝。2．String类的length、charAt和getChars方法

下面的例子演示了String类的length、charAt和getChars方法，它们分别用于确定

String类的长度、取String某一指定位置的字符以及取String某一子串。3．String类的字符串比较例4-7：import

javax.swing.JOptionPane;public

class

StringCompare

{public

static

void

main(

String

args[]

){String

s1,

s2,

s3,

s4,

output;s1

=

new

String(

"hello"

);s2

=

new

String(

"good

bye"

);s3

=

new

String(

"Happy

Birthday"

);s4

=

new

String(

"happy

birthday"

);output

=

"s1

=

"

+

s1

+

"\ns2

=

"

+

s2

+"\ns3

=

"

+

s3

+

"\ns4

=

"

+

s4

+

"\n\n";if

(

s1.equals(

"hello"

)

)••••output

+=

"s1

equals

\"hello\"\n";elseoutput

+=

"s1

does

not

equal\"hello\"\n";if

(

s1

==

"hello"

)output

+=

"s1

equals

\"hello\"\n";elseoutput

+=

"s1

does

not

equal\"hello\"\n";if

(

s3.equalsIgnoreCase(

s4

)

)output

+=

"s3

equals

s4\n";elseoutput

+=

"s3

does

not

equal

s4\n";output

+=

"\pareTo(

s2

)

is

"

+pareTo(

s2

)

+

"\pareTo(

s1

)

is

"

+pareTo(

s1

)

+•••

"\pareTo(

s1

)

is

"

+pareTo(

s1

)

+"\pareTo(

s4

)

is

"

+pareTo(

s4

)

+"\pareTo(

s3

)

is

"

+pareTo(

s3

)

+"\n\n";if

(

s3.regionMatches(

0,

s4,

0,

5

)

)••••

output

+=

"First

5

characters

of

s3

and

s4match\n";elseoutput

+="First

5

characters

of

s3

and

s4do

not

match\n";if

(

s3.regionMatches(

true,

0,

s4,

0,

5

)

)output

+=

"First

5

characters

of

s3

and

s4match";else•output

+="First

5

characters

of

s3

and•s4

do

not

match";

JOptionPane.showMessageDialog(

null,output,"Demonstrating

String

ClassConstructors",•JOptionPane.INFORMATION_MESSAGE

);System.exit(

0

);}}4．在字符串中定位字符和子串5．从字符串中抽取子串6．字符串连接public

String

concat（String

st）可返回一个字符串，它将把参数str添加在原字符串的后

面形成一个新的字符串。但在Java中，更多的是使用“＋”来连接字符串。这里读者可能会产生一个小小的迷惑，因为前面我们讲过String对象是不能改变的。实际上，字符串的连接是由编译器利用StringBuffer的方法append来实现的。这在下面的章节中讲

解。例4-10：import

javax.swing.*;public

class

StringConcat

{public

static

void

main(

String

args[]

){String

s1

=

new

String(

"Happy

"

),s2

=

new

String(

"Birthday"

),output;••output

=

"s1

=

"

+

s1

+"\ns2

=

"

+

s2;

output

+=

"\n\nResult

of

s1.concat(

s2

)

="

+s1.concat(

s2

);output

+=

"\ns1

after

concatenation

=

"

+s1;JOptionPane.showMessageDialog(

null,output,"Demonstrating

String

Method

concat",JOptionPane.INFORMATION_MESSAGE

);System.exit(

0

);}}运行结果见图4-10。7．转化为字符串图4-104.2.2

StringBuffer类

String类提供了很多处理字符串的功能。但是，一旦创建了字符串对象，它的内容就永远不会变。下面将讨论StringBuffer类的特点。这个类可以创建和操纵动态字符串，即可修改的字符串。每个StringBuffer都能够存储由它的容量所指定的一些字符。如果超过了

StringBuffer的容量，容量就会自动地扩大以容纳多出来的字符。我们将看到，StringBuffer类还可用来实现用于字符串连接的运算符"＋"。

String对象是常量字符串，StringBuffer对象是可修改的字符串。Java区分字符串和可修改的字符串是为了优化的目的。特别地，Java可以实现有关String对象的某些优化，例如多

个引用共享一个String对象，因为它知道这些

对象不会改变。

注意：在选择是用String对象还是用

StringBuffer对象来表示一个字符串时，如果该对象确实不会改变，则总是使用String对象，这样做可以改善性能。对String对象调用非String类的StringBuffer方法是一种语法错误。

StringBuffer提供的方法有一些与String相同，有一些不同。最主要的方法有两组，一组是

append，另一组是insert。4.3

AWT•4.3.1AWT概述•4.3.2AWT的特点•4.3.3AWT应用4.4

Java

applet4.4.1

Java

applet的特点

Java

applet与Java应用程序不同。它们的不同之处有以下几个方面。

（1）Java应用程序中，必须有一个main()方法。Main()方法是程序的入口，当程序开始运行时，解释器首先查找main()方法并执行。而Java

applet中则不需要main()方法，它必须嵌入HTML文件中，由支持Java

applet的浏览器运行。（2）Java应用程序可以独立运行。而Javaapplet不能独立运行，需要依赖于网络浏览器。（3）Java应用程序所实现的功能是完全的，不需依赖于其他程序。而Java

applet实现的功能是不完全的，它必须借助于浏览器中预先设计好的功能和已有的图形界面。Javaapplet只需接收浏览器发送给它的消息，并及时做出响应。

（4）Java应用程序中的所有方法的使用是通过调用实现的。可以人为控制。而Javaapplet中有一部分方法是固定的，只能由浏览器在特定时刻和场合调用，不能人为控制，但可以重载。4.4.2

Java

applet的程序结构Java

applet的一般程序结构如下：import

java.applet.*;import

java.awt.*;public

class子类名extends

Applet//定义Applet类的子类{

public

void

init(){方法体}

//初始化方法public

void

start(){方法体}

//开始执行方法public

void

stop(){方法体}

//停止执行方法public

void

destroy(){方法体}

//退出方法public

void

paint(Graphics

g)•{方法体}

//绘画方法}……从Java

applet程序结构看出，Java

applet由若干类组成，无需main()方法，但必须有且仅有一个主类，该类是Applet类的子类，且被声

明为public。程序被保存时，程序名必须命名为主类名，即程序名与主类名完全相同，后缀为.

java。主类中定义了init()、start()、stop()、destroy()和paint()方法，这些方法是从Applet中继承的，有固定的含义，由浏览器在时机成熟时自动执行。4.4.3

Applet的主要方法

在浏览器中运行Applet程序，从运行开始到运行结束，Applet程序需经历4个状态，分别是初始状态、运行状态、停止态和消亡状态。这4种状态分别对应Applet的4个主要方法：init()、start()、stop()和destroy()。

对于支持Java的浏览器，如果在运行一个

HTML文件时发现该文件包含Applet程序，浏览器就会生成该Applet的一个实例，并调用init()方法，进入初始化状态，在该状态下完成

Applet的一些初始化操作。初始化完成后，浏览器接着调用start()方法，进入运行状态，真正开始执行Applet，在该状态下Applet通常会启动一些线程执行各种任务。

当退出当前主页时，浏览器调用stop()方法终止在运行状态下启动的线程，进入停止状态。当用户退出浏览器时，浏览器首先调用Applet的stop()方法，停止Applet的执行，然后调用

destroy()方法释放Applet占用的系统资源，进入消亡状态。下面具体介绍init()、start()、stop()和

destroy()4种方法。1．Init()方法在Applet执行过程中，init()方法只执行一次。当浏览器第一次浏览含有Applet的Web页载入Applet时，就会执行init()方法。由于在Applet执行过程中，该方法只被执行一次，所以可以在init()方法中进行一些只需执行一次的初始化操作，如变量的初始化、设置Applet初始状态、载入图形或字体、获取

HTML中Applet标记单元中<PARAM>设定的参数等。2．start()方法调用完init()方法，浏览器将调用start()方法启动Applet。和init()方法不同，在Applet的执行过程中，start()方法可被浏览器调用多次。在下列情况下，浏览器会调用start()方法。（1）浏览器从图标状态恢复为窗口状态或缩放浏览器窗口时。（2）Applet第一次载入时。（3）离开该Web页后又再返回时。（4）reload该页面时。在start()方法中可启动相关线程来控制

Applet，给引入类对象发送消息，或以某种方式通知Applet开始运行。该方法是Applet的主体。3．stop()方法该方法与start()方法是相对应的，在

Applet执行过程中，也会被浏览器调用多次。在下列情况下，浏览器会调用stop()方法。（1）浏览器从图标状态恢复为窗口状态或缩放浏览器窗口时。（2）离开Applet所在Web页时。（3）reload该页面时。（4）关闭该Web页时。（5）从该Web页退出浏览器运行时。stop()方法可在适当时机挂起Applet，停止一些占用系统资源的工作，释放系统处理资源，以提高系统的运行速度。4．destroy()方法在彻底结束对该Web页的访问或退出浏览

器时调用destroy()方法，卸载Applet，释放载入

Applet时分配的系统资源。在Applet的执行过程中，destroy()方法只执行一次。destroy()方法是Applet类的类方法，只能用于Applet。可在该方法中执行释放系统资源

的代码。但一般不需重写destroy()方法，因为

Java运行系统本身会自动进行“垃圾”处理和

内存管理，除非用了特殊的资源如创建的线程。注意：destroy()方法与stop()方法不同。除了上述4个方法外，Applet还提供一个非常重要的方法：paint（Graphics

g）方法。该方法用于进行绘图的具体操作，但没有实现任何操作，用户可重写该方法，实现个性化的绘图操作。在Applet执行过程中，paint()方法可以被浏览器自动调用执行绘图操作，可调用多次。

当调整浏览窗口大小、缩放浏览窗口、移动窗

口或reload等需要重绘窗口时都会调用paint()方法。与其他4个方法不同的是，paint()中需传递一个参数，该参数是Graphics类的对象，由这个对象来完成具体的绘图操作。Graphics对象由浏览器自动创建并将其传送给paint()方法。注意：应在Applet中引入Graphics类的包或该类：import

java.awt.Graphics;例4-16：import

java.applet.*;import

java.awt.*;public

class

example4_16

extends

Applet{private

int

InitCount;private

int

StartCount;private

int

StopCount;private

int

DestroyCount;private

int

PaintCount;public

example4_16(){InitCount=0;StartCount=0;StopCount=0;DestroyCount=0;PaintCount=0;}public

void

init()InitCount++;{•}public

void

destroy(){DestroyCount++;}public

void

start()StartCount++;{•}public

void

stop(){StopCount++;}public

void

paint(Graphics

g){••PaintCount++;g.drawString("Paint()方法执行了:"+PaintCount+"次。",20,20);

g.drawString("Init()方法执行了:

"+InitCount+"次。",20,70);

g.drawString("Start()方法执行了:

"+StartCount+"次。",20,120);•

g.drawString("Stop()方法执行了:

"+StopCount+"次。",20,170);g.drawString("Destroy()方法执行了:

"+DestroyCount+"次。",20,220);}}4.4.4

Java

applet的运行•

Java

applet程序不能独立运行，必须由浏览器来运行，因此我们需编写一个HTML文件，通过<applet>标记将applet程序编译生成的字节码文件嵌入HTML文件，通知浏览器来运行

Java

applet。如要运行例4-16，可编写如下的HTML文件：<html><head><title>example4_16</title></head><body><applet

code=example4_16.classwidth=300

height=250></applet></body></html>第5章图形用户界面5.1文本框和文本区5.2

标

签5.3

按

钮5.4选择框5.5

画

布5.6面板与布局设计5.7

窗

口5.8

菜

单5.9对话框5.1文本框和文本区5.1.1文本框及处理事件1．文本框的创建2．文本框处理事件

例5-2：两个空白文本框，当在第一个文本框内输入字符时，在文本框内显示“*”号，输入完毕按回车键后，在第二个文本框内显示：The

end。import

java.awt.*;import

java.applet.Applet;import

java.awt.event.*;public

class

Ex6_2

extends

Applet{TextField

tf1=new

TextField(20);TextField

tf2=new

TextField(20);public

void

init(){add(tf1);tf1.setEchoChar("*");add(tf2);tf1Listener

al

=

new

tf1Listener();tf1.addActionListener(a1);}class

tf1Listener

implements

ActionListener{public

void

actionPerformed(ActionEvent

e)

{tf2.setText("The

end");}}}运行结果见图5-2。图5-15.1.2文本区及处理事件

例5-4：在Applet中添加一个文本框和一个文本区，每当在文本框中输入一个字符时，在文本区内就附加一行文本：The

text

is

changed。import

java.awt.*;import

java.applet.Applet;import

java.awt.event.*;public

class

Ex6_4

extends

Applet{TextField

tf1=new

TextField(20);TextArea

ta1=new

TextArea

(null,6,40);public

void

init(){add(tf1);add(ta1);tf1.addTextListener(new

TextL());}class

TextL

implements

TextListener{public

void

textValueChanged(TextEvent

e)

{ta1.append("\nThe

text

is

changed");•}}}运行结果见图5-4。图5-45.2

标

签

标签（Label）是AWT构件中最简单的一种构件，所谓标签实质上就是一段文字，但它与文字不同的是它是一个对象，所以在每次

repaint时，不用重新添加。标签在GUI界面中通常作为提示信息使用。标签构件的构造方法如下。（1）Label()构造一个空的标签。（2）Label（String

str）构造一个以

String

str为内容的标签。（3）Label（String

str,int

align）定义一个以String

str为内容的标签。5.3

按

钮5.3.1按钮••

按钮（Button）是GUI用户界面中常用的元素，它是用户输入命令的一个重要工具。当用鼠标单击某个按钮该按钮获得焦点时，在键盘上按回车键都会导致一个命令的执行。Button类有两种构

造方法。Button()构造一个没有标签的按钮。Button（String

str）构造一个以String

str为标签的按钮。5.3.2按钮处理事件•与按钮有关的事件有两类。1．ActionEvent当用鼠标单击按钮，或当按钮获得焦点时在键盘上按回车键都导致该事件的发生,此时任何实现了被注册为监听者的ActionListener接口的类，它的actionPerformed()方法将被调用。下面的程序范例在Applet上添加两个命令按钮，其标签分别为“显示”和“清除”，当单击“显示”按钮时，在文本区中显示：“你按下了显示按钮”，当按“清除”按钮时则清除文本区中显示的字符。例5-6：文本区事件处理。import

java.awt.*;import

java.applet.Applet;import

java.awt.event.*;public

class

Ex6_6

extends

Applet{Button

b1=new

Button("显示");Button

b2=new

Button("清除");TextArea

ta1=new

TextArea

(null,6,40);public

void

init(){add(b1);add(b2);add(ta1);b1.addActionListener(new

ButtenL());b2.addActionListener(new

ButtenL());}class

ButtenL

implements

ActionListener{public

void

actionPerformed(ActionEvent

e){••if

(e.getSource()==b1)ta1.append

("\n你按下了"显示"按钮");else•ta1.append

("\n你按下了"清除"按钮");}}}运行结果见图5-6。图5-62．FocusEvent

FocusEvent称作焦点事件，它的发生是指键盘光标移动到构件上并且可以接受键盘的输入。如果光标移动到一个按钮上，称作该按钮获得焦点，反之称作失去焦点。当一个按钮获得焦点时单击回车键即相当于用鼠标单击该按钮。如果一个文本框获得焦点就可以在该文本框中输入字符。例5-7：按钮和文本框检测焦点事件的例子。程序如下：import

java.awt.*;import

java.applet.Applet;import

java.awt.event.*;public

class

Ex6_7

extends

Applet{TextField

txt1

=

new

TextField("txt1",50);TextField

txt2

=

new

TextField("txt2",50);Button

button1=new

Button("button1");Button

button2=new

Button("button2");class

Keytry

implements

FocusListener{public

void

focusGained(FocusEvent

e)

{•txt1.setText("txt1:paramString()="+e.paramString());if

(e.getSource()==txt1)txt2.setText("txt2:focus

is

on

txt1

");elsetxt2.setText("txt2:focus

is

on

button1");••••}public

void

focusLost(FocusEvent

e)

{•txt1.setText("txt1:paramString()="+e.paramString());•txt2.setText("txt2:focus

lost

outsidebutton1

or

txt1");}}Keytry

al

=

new

Keytry();public

void

init(){setLayout(new

FlowLayout());txt1.addFocusListener(al);button1.addFocusListener(al);add(button1);add(button2);add(txt1);add(txt2);}}运行结果见图5-7。图5-7在上面的例子中，只有button1和txt1注册了焦点事件的事件监听者，它们共享同一个事

件处理程序。如果焦点在button1或txt1上面，文本框txt2显示焦点在哪个构件上（focusGaned），反之则指出无焦点（focusLost）。文本框txt1内显示事件的参数字符串，它也能指出是否有焦点。另外，程序中的

setLayout（new

FlowLayout()）语句是控制构件的布局用的，关于这个问题将在后面的章节中

进行讨论。5.4选择框5.4.1选择框1．下拉列表框（Choice）2．列表框（List）3．复选框（Checkbox）4．单选框（Checkbox

group-Radio

Button）5.4.2选择框处理事件例5-12：选择框检测ItemEvent事件的例子。import

java.awt.*;import

java.applet.Applet;import

java.awt.event.*;

public

class

Ex6_12

extends

Applet

implementsItemListener{TextArea

ta1=new

TextArea

(null,6,40);

String

subject[]={"语文","数学","政治","外语","物理","化学"};Checkbox

cb[]=new

Checkbox[6];public

void

init(){add(new

Label("请选择："));for(int

I=0;I<6;I++){cb[I]=

new

Checkbox(subject[I]);add(cb[I]);cb[I].addItemListener(this);•••}add(ta1);}•public

void

itemStateChanged(ItemEvent

e)

{

ta1.append("\n你在复选框中的选择是：

"+e.getItem());}}运行结果见图5-12。图5-125.5画布例5-13：创建一个画布。import

java.awt.*;import

java.applet.Applet;import

java.util.*;public

class

mycanvas

extends

Applet

{public

void

init()

{MyCanvas1

mc

=

new

MyCanvas1();mc.setBackground(Color.green);mc.setSize(150,150);add(mc);}}class

MyCanvas1

extends

Canvas{public

void

paint(Graphics

g){g.fillOval(40,20,80,80);}}运行结果见图5-13