自考Java语言程序设计(一)最新串讲笔记

《Java语言程序设计》串讲笔记

课程代码：4747

【提示】本课程考试内容覆盖到章。其中，重点章节为第三、五、六、八章，考核分数比例约为60％；次重点章节为第二、四、七章，考核分数比例约为30％；一般章节为第一、九、十章，考核分数比例约为10％。

第1章Java语言基础

Java语言的特点。[P3-4,§1.1]

Java语言主要有以下特点：

1)强类型：强制约束程序员必须遵守更多的编程规定，编译

器能检测程序中尽可能多的错误。

2)编译和解释：用Java编写的源程序在计算机上运行必须经

过编译和解释执行两个阶段。编译程序先江Java源程序翻

译成与机器无关的字节码（bytecode），不是通常的编译程

序将源程序翻译成特定计算机的机器代码。运行时，由Java

虚拟机（JVM）中的Java解释器负责将字节码文件解释成

为特定的机器码进行运行。

3)自动无用内存回收功能：垃圾收集器（garbage collector）

可以自动回收程序不再使用的内存，避免程序遗漏或重复

释放内存。

4)面向对象

5)与平台无关：与平台无关是对程序可移植性最直接最有效

的支持，“一次编程，到处运行”。可移植性源于两方面：

1. Java的编译和解释的特征（Java虚拟机）；

2. Java采用基

于国际标准的数据类型，在任何平台上，同一种数据类型

是一致的。

6)安全性：取消指针，避免因指针使用不当，访问不该访问

的内存空间；提供数组下标检测机制，禁止程序越界访问

内存；编译执行过程中进行比较严格的检查：在解释执行

前，对字节码文件作检查，防止被恶意改动的字节码文件

被解释执行而破坏系统；浏览器限制下载的小应用程序不

允许访问本地文件，避免其破坏本地文件。

7)分布式计算

8)多线程：Java的运行环境采用多线程实现。Java语言提供

语言级多线程支持，用Java语言能直接编写多线程程序。两种类型的Java程序。[P5, §1.2]

Java程序可分为应用程序（Application）和小应用程序（Applet）两类。这两种程序的主要区别：

1)小应用程序需要嵌入在HTML网页中，当网页被浏览时，在浏

览器中运行；且其运行受到严格的安全限制。

2)应用程序则独立运行，不嵌入网页，也没有那些限制。

3)另外，这两类程序在代码编写上也有差异：一个小应用程序必

须定义为java.applet.Applet类的子类，而不必定义main()方法；

应用程序一般不必为java.applet.Applet类的子类，而必须在一个类中定义main()方法。注释：

1)行注释//

2)块注释/* …. */

3)文档注释/** …*/

Java程序的开发过程[P6, §1.3]

通常在JDK目录下有bin、demo、lib、jre等子目录，其中bin目录保存了javac（编译器）、java（解释器）、jdb（调试器）、appletviewer （java Appelt解释器）等命令文件；

Java的字符集和标识符。[P7, §1.4]

Java语言使用Unicode字符集，字符采用双字节的表示方式，共有65535个字符，最前面的128个字符与标准的ASCII字符一致，包括：

1)数字字符10个（0~9）

2)英文大小写字母各26个（A~Z, a~z）

3)下划线（_）、美元符号（$）

4)文字字符（汉字，日文片假名、平假名，朝鲜文字等）

5)其他用于构成特殊符号的字符集

标识符可以用来标识文件名、变量名、类名、接口名和成员方法名等，其构造规则如下：

1)标识符由Java字母和Java数字组成；

2)首字符必须是Java字母；

3)除去关键字、false、true和null；

4)所有标识符是区分大小写的。

关键字是Java语言保留的一些英文单词，具有特殊的含义。例如：public、static和class，具有特殊用途，不能作为标识符使用。

基本数据类型。[P8-10, §1.5]

布尔型（boolean）1个字节（true或false)

字符型（char）16位

字节型（byte）8位

短整型（short）16位

整数型（int）32位

长整型（long）64位

单精度浮点型（float）32位

双精度浮点型（double）64位

Java直接量是直接显式地表示基本数据类型数据、字符串（String）值和空引用值（null）的表达式，而且在该表达式中不含运算。

布尔(boolean)直接量只有两个：true和false

字符(char)直接量：如‘a’，‘6’，‘猫’，‘\u0061’，‘\n’

整型(byte,short,int)直接量：如-27，+0123，0x56ab

长整型(long)直接量：如-27L，+0123L，0x56abL

浮点数(float,double)直接量：如1.5，45.6D，100d，76.4e8，-32.0 ，1.5F，45.6f，76.4E-8F，-32.0F

字符串(String)直接量：如“Hello World!”

引用数据类型的直接量：null

变量在计算机内部对应着一个存储单元，而且总是具有某种数据类型：基本数据类型或引用数据类型。

每个变量均具有：名字、类型、一定大小的存储单元以及值。

变量总是具有与其数据类型相对应的值。

基本数据类型：变量的存储单元中存放的是具体的布尔值或数值；

引用数据类型：变量的存储单元中存放的是引用值，引用值一般用来指向某个具体的对象。如果引用值是null,则该引用值不指向任何对象。

在使用变量前，必须先定义该变量，而且一般要求先初始化。例如:

int studentNumber; //定义单个变量

studentNumber=30; //给变量赋值

double velocity, distance; //定义多个变量

int studentNumber=30; //定义变量，并赋初值

第2章运算和语句

赋值运算。[P13, §2.1.1]

●简单赋值运算，格式如下：

变量=表达式

不是“相等”运算符（“==”）。

赋值语句中的数据类型转换只能是简单类型向复杂类型转换，不能从复杂的转换成简单的。转换规则如下：

byt e→short→int→long→float→bouble

●复合赋值运算，格式如下：

变量双目算术运算符= 表达式

包括：+=、-=、*=、/=、&=、|=、%=、<<=、>>=和>>>=。例如：a+=b等价于a=a+b，a/=b+c等价于a=a/(b+c)。

算术运算符。[P14, §2.1.2]

算术运算符包括：

+（取正）， -（取负）（单目运算）

+, -, *, /, % （双目运算）

注意事项：

1)当操作数是定点类型数据时，应当注意运算是否会溢出

int i=123456;

i=i*i; //溢出

2)整数除法：截去余数，7/5结果为1

3)考虑除数是否可能为0或很小的数

4)取模：返回余数，可以对定点或浮点数进行取模运算，7%5结果

为2；15.25%(-0.5)结果为0.25

自增自减运算。[P14, §2.1.3]

自增(++)和自减(--)：操作数必须是变量；有前置和后置两种运算int n=3;

int i=n++, j=n--; //i=3,j=4,n=3

int k=++n, m=--n; //k=4,m=3,n=3

前缀和后缀，对变量本身，效果相同；但表达式的值不相同。

运算对象只能是变量，不能是常量或表达式，如：7++；(i+j)--都是非法的。

关系运算符。[P15, §2.1.4]

关系运算符包括: <、 >、<=、>=、== 和 !=，关系运算生成一个布尔结果。例如:

1 > 2; //false

3.5 != 1; //true

51.5 >= 23.0; //true

540 <= 654; //true

24 == 3*8; //true

boolean test1=(10 < 10); //test1=false;

关系运算符的优先级：<、<=、>、>=优先于==、!=；<、<=、>、>=优先级相同，结合性是自左向右；==、!= 优先级相同，结合性是自左向右。

【注意】Java不允许将一个数字作为布尔值使用，这与c或c++不同。例如：当要表达“如果a不等于0”这个条件

不能写作 if(a)

而要写作 if(a!=0)

逻辑运算符。[P15, §2.1.5]

逻辑运算的操作数必须是布尔型，结果也是布尔型。可以有3种基本操作：与（&&）、或（||）、非（!）。

短路规则：一旦能够明确无误的确定整个表达式的值，就不再计算表达式余下的部分了。因此，整个逻辑表达式靠后的部分可能不会计算。比较:

(birthday == true) && (++age >= 65)

(birthday == true) || (++age >= 65)

! 优先于双目算术运算符优先于关系运算符优先于 && 优先于||

条件运算符。[P16, §2.1.6]

条件运算符是一个三目运算符，一般形式为：

逻辑表达式 ? 表达式1 : 表达式2

例如:

int i = 5;

int k = (i>=0) ? 1 : -1;

条件运算符的结合性为“自右至左”。

例如： x > y ? x : u > v ? u : v 等价于

x > y ? x : （u > v ? u : v）位运算和位移运算。[P17, §2.1.7]

位运算符包括：&、|、~、^、

移位运算符有： >>、>>>和<<

&、|、~、^ 按位求与、或、非、异或

>> 带符号右移：左端空出的位填原符号位

<< 左移：右端空出的位补0

>>>不带符号右移（逻辑右移）：左端空出的位填0（C或C++中无此运算符）

位运算操作是：先将整数写成二进制形式（补码），然后按位操作，最后产生一个新的数

注意: 只用于定点类型数据（整型）

基本语句。[P20, §2.2.1]

表达式语句：k=k+2;

空语句 ;

break语句：break; 用于循环或选择

continue语句：continue; 同上

return语句：return;, return 表达式;,该语句的执行将结束方法的执行，只能出现在方法体中。

复合语句。[P21, §2.2.2]

用花括号引起来的两条或两条以上语句，顺序执行但作为一个整体。在复合语句中可以定义自己专用的临时变量。

if语句。[P22, §2.2.3]

if语句的格式是:

if (布尔表达式)

语句

或

if (布尔表达式)

{

一条或多条语句

}

例如：

if(score >= 60)

System.out.println("Passed");

if-else语句。[P22, §2.2.3]

if-else语句的格式是:

if (布尔表达式)

语句1或语句块1

else

语句2或语句块2

例如：

if (score >= 60)

System.out.println("Passed!");

else

System.out.println("Failed!");

标准嵌套if-else控制结构可实现多路选择，用在想从多个候选项中选择且只选出一项时。

例如：

if (score>90)

System.out.println(“A”) ;

else if (score>=80)

System.out.println(“B”) ;

else if (score>=60)

System.out.println(“C”) ;

else

System.out.println(“F”) ;

switch语句。[P23, §2.2.4]

switch语句的格式是:

switch (表达式)

{

case 值1:

语句组1；

break;

case 值2:

语句组2；

break;

……

case 值n:

语句组n；

break;

default:

语句组(n+1)；

}

switch表达式的数据类型可以是基本类型char、byte、short、int；或是这四种基本类型相对应的包装类https://www.360docs.net/doc/9c1778879.html,ng.Character、https://www.360docs.net/doc/9c1778879.html,ng.Byte、https://www.360docs.net/doc/9c1778879.html,ng.Short、https://www.360docs.net/doc/9c1778879.html,ng.Integer或enum枚举类型。

跟在case后的必须是常量表达式，其值的类型应当与switch表达式的数据类型相匹配。

Switch语句的执行规则：

1)求出表达式的值；

2)找出给定值与表达式相符的case语句，执行此case标号

后的所有语句（除非遇到break语句），直到switch语句

结束；

3)若没有匹配的case语句，则转向defalult语句，执行

default标号后的所有语句，直到switch语句结束。

4)若没有匹配的case语句，也没有defalult语句，则switch

语句的这次执行立即结束。

try…catch语句。[P25, §2.2.5]

try {

语句块//执行该语句块，可能会发生异常

} catch (异常类型e) {

异常发生时要执行的语句块

} finally {

无论异常发生与否，都要执行的语句块

}

说明：

1)Catch和 finally 必须和一个try相关联

2)try至少要有一个catch, 可以有多个

3)finally语句块是可选的

while语句。[P26, §2.2.6]

while语句的格式：

while (布尔表达式)

语句或语句块

当条件(布尔表达式)为true ，则不断地执行语句或语句块。“while”循环的中止条件是布尔表达式变为false，如果布尔表达式一开始就为false，则不执行循环体。

有时循环条件很难写出，可以直接使用true, 格式如下：While (true) {

…

If( 条件表达式） break;

…

}

do-while语句。[P27, §2.2.7]

do-while语句的格式是：

do

{

语句或语句块

}

while (布尔表达式);

do-while和while结构唯一的区别就是do-while中的语句至少会执行一次，即便布尔表达式第一次就被计算为false。注意最后的分号，一定不能省略。

for语句。[P28, §2.2.8]

for语句的格式是:

for ([初始化表达式]; [条件表达式]; [更新表达式])

语句或语句块

例如：

int counter, sum;

for(counter=1,sum=0; counter<=100; counter++)

sum+=counter;

System.out.println(“counter=“ + counter + ”, sum=” + sum);

注意变量counter和sum的作用域，若将它们改在for语句内部定义，会有何不同。

在for语句的初始化和更新部分，可以使用多个由逗号分隔的表达式，这些表达式都会独立执行。

例如：

for(int 1=1, j=i+10; i< 5; i++, j=i*2) {

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

注意：通过逗号操作符，可以在初始化部分定义多个变量，但这些变量必须具有相同的类型。无论在初始化还是更新部分，表达式都是顺序执行的。

嵌套的循环结构。[P29, §2.2.9] for循环的嵌套

while循环的嵌套

do..while循环的嵌套

以上三个任意之间的嵌套

continue语句。[P30, §2.2.10]

格式：continue;

功能：跳过continue之后的语句，重新判断循环控制条件，决定是否继续循环。

说明：

(1)continue语句只能用在三种循环语句的循环体中。

(2)continue语句通常和if语句联合使用，从而构成其后的部

分循环体是否执行的单分支结构。

break语句。[P30, §2.2.10]

格式：

break;

功能：强制结束当前的循环，不再执行循环体中break后面的语句。说明：

(1)break语句只能在三种循环语句的循环体和switch语句中使

用。

(2)在循环语句中break通常和if语句联合使用，用于构成第二

个退出循环的机会。

Package语句。[P31, §2.2.11]

程序包相当于其它语言的函数库，系统提供大量的程序包，自己编写的类也可以组成程序包，但一定要用package语句声明。

格式： package 包名；

包名是一个目录名，可以有路径。

import 语句。[P32, §2.2.12]

用来引入所需要的类

格式：

import 包名.类名；

例如： import java.util.Date;//引入Date类

如果从一个包中引入多个类，可以用通配符“*”，如： import java.awt.*;

一个java源程序中可以有多个import语句，它们必须出现在package语句之后；类的定义之前。

Java程序的基本结构。[P32, §2.2.13]

[ package 包名;]

import 包名.类名；

… // 更多的import语句

[public] class 类名{

int val=… //变量定义语句

Public static void main( String args[ ])

// 方法定义

{

… // 变量定义和控制语句构成的方法体

}

}

第3章面向对象编程基础

抽象（见课本39页）

抽象是程序设计最经常使用的技术之一，是有效控制程序复杂性的重要手段。

在面向对象程序设计中：

把一系列复杂的属性与动作组织到单个模块中，然后把该模块当作一个整体（对象）来对待，就是一种抽象形式。

把一个问题分解成构成它的对象，也是一种抽象形式。

对象（object）

万物皆为对象，它存储数据，还可以要求它在自身上执行操作。

对象具有状态、行为和标识。这意味着每一个对象可以拥有内部数据（它们给出该对象的状态）和方法（它们产生行为），并且每一个对象都可以唯一地与其他对象区分开来（每一个对象在内存中都有唯一一个地址）。

消息（message）

在面向对象框架中，对象之间通过相互发送消息来进行交互。

在Java里，通过调用方法来传递消息。

类（class）

类定义了某种类型的所有对象所具有的属性与行为，是用来创建对象的蓝图或模板；对象是某个确切类的实例。

在创建一个类的实例（对象）之前必须定义这个类。

继承性（inheritance）

继承机制：属于一个子类（派生类）的对象从其父类（基类）中继承了全部属性和行为。所有可以发送给父类对象的消息也可以发送给子

类对象。

多态性（polymorphism）

对象的多态性是指在超类中定义的属性或行为被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在一般类及其各个子类中具有不同的语义。

联编（见课本41页）

联编是指将发送给对象的消息与包含执行该消息方法的对象连接起来。

静态联编：在编译和连接阶段实现的联编。

动态联编：在运行阶段实现的联编。

动态联编是实现适应性多态的基础。

类（见课本41-44页）

（1）类的声明

类的定义格式如下：

[类修饰词] class 类名[extends 父类名]

[implements 接口名称列表]

{

类体

// 通常先定义成员变量，再定义构造方法，最后编写成员方法

}

（2）成员变量

成员变量的定义格式如下：

[修饰词列表] 类型变量名或带初始化的变量名列表；

例如：private float height, weight;

private String name, sex, no;

（3）方法

类的成员方法：简称方法，用来实现类的各种功能。

方法的定义格式如下:

[方法修饰词列表] 返回类型方法名(方法的参数列表)

{

方法体

}

例如：public int mb_method() { …}

public static void main(String args[])

{ … }

例3.2（若某方法的参数名或局部变量名与类的成员变量名相同，则成员变量名在这个方法内部暂时被隐藏。）

例3.3（关键字this：对当前对象的引用）

例3.4（方法重载）

（4）构造方法

构造方法用来创建类的实例，并对对象初始化。构造方法的声明和一般方法声明非常相似，但是它必须和类同名，并且不能声明返回值类型。构造方法的一般形式：

public <类名> ( <参数列表> ) { <语句> }

例3.5

默认的构造方法：当一个类没有包含构造方法时，Java将自动提供一个默认的构造方法。

对象（见课本44-46页）

（1）声明对象

声明一个对象只是命名一个引用变量，这个引用变量和对象关联，可以用来引用该对象。

声明一个对象的格式如下：

类名变量名（对象名）；

例如，声明对象：

Point p1,p2;

不要把声明一个对象和创建一个对象混淆起来。声明对象并不会为这个对象分配内存。

（2）创建对象

创建对象：使用new操作符和构造方法。

构造方法是在对象实例化过程中使用的特殊方法；

操作符new为新的对象分配一片内存并将它存储在那里，然后返回对象的地址。

格式为：

new 构造方法名(构造方法的调用参数列表)

例如：

p1 = new Point(); p2 = new Point(30,40);

声明和创建对象也可以一起完成，例如：

Point p3 = new Point(), p4 = new Point(60,70);

（3）对象的内存模型在Java中有两种类型的变量：基本类型与引用类型。基本类型的变量总是存放一个该类型的值；引用变量实际上存放的是它所引用的对象的地址，而不是存放对象本身。在Java中，主要有数组和类类型是引用类型。

课本45页，图3.1、3.2

（4）使用对象

程序使用对象：

访问对象的成员变量，一般形式为：

对象名.成员变量名

调用对象的方法，一般形式为：

对象名.方法名([参数表])

例3.6

实例变量和类变量（见课本46页）

被关键字static修饰的变量为类变量（静态变量），未被关键字static 修饰的变量为实例变量。

例如：

class D {

float x; // 实例变量

static int y; //类变量

…

}

每个对象都有自己的实例变量，不同对象的实例变量也将被分配不同的内存空间。

类变量则被一个类的所有对象共享，在内存中也只有一处。可以通过类名或对象名引用类变量。

实例方法和类方法（见课本46-48页）

被关键字static修饰的方法为类变量（静态方法），未被关键字static 修饰的方法为实例方法。

例3.7

注意：类中的实例方法可以互相调用，并可调用类方法。类方法也能相互调用，但不能直接调用实例方法，而要通过在类方法中引入局部对象，通过对象名调用实例方法。

类中的实例方法中可以直接使用实例变量，也可直接使用类变量。但类方法能直接使用类变量，却必须通过在类方法中引入的局部对象，用对象名引用实例变量。

类方法可以通过类名或对象名调用。

例3.8

访问权限（见48-49页）

设置访问权限实现访问控制，为类的成员设置访问权限，保护类的成员不在非期望的情况下被引用。

在类的声明中，除了类的方法总能访问类的成员变量外，为其他类的方法访问本类的成员变量和方法，提供了四种访问权限:

public：无访问限制，其他类的方法都能访问

private：最强访问限制，其他类的方法都不能访问

protected：仅限子类或同一包中的类的方法访问

：只允许同一包中的类的方法访问

继承（见课本49-53页）

继承性- 软件重用的一种方法

继承使得一个类可通过扩展现有类来定义

扩展声明的新类称为子类，原有的类称为超类（父类）

子类继承超类的变量和方法；子类可以增加新的变量和方法；子类可以重写（第51页）从超类中继承的方法。

子类对父类的继承性，Java语言有以下规定：

子类自然地继承其父类中非private的成员变量作为自己的成员变量子类自然地继承其父类中非private的成员方法作为自己的成员方法例3.10

多态性（见课本51-52页）

静态的多态性：重载，在编译时就能够被识别针对的是同一个类内的同名方法（重载的方法）。

动态的多态性：重写，在程序运行时才被识别（动态联编）重写父类的方法（同样签名）。

例3.11

多层继承（见课本52页）

继承关系具有传递性。继承声明的新类，又可被其他类再继承，从而构成多层继承。

例3.12

多层继承中构造方法的调用顺序（见课本52-53页）

当前定义的类的构造方法必须调用其直接父类的构造方法，而且该调用语句必须是当前定义的类的构造方法的第一条语句，其调用格式是：

super(调用参数列表)；

super是关键字，此处表示其直接父类的构造方法，调用参数列表必

须与其直接父类的某个构造方法的参数列表相匹配。

例3.13

Java面向对象的其他机制（见课本53-58页）

（1）final类、final方法和final变量

关键字final的含义为“最终的”，“不能改变的”。用final修饰类，表明此类不能派生出子类，例如：final class C { …}

用final修饰方法，表明此方法不能被子类的方法重写（覆盖）例如：final int f( int x, int y ) { …}

用final修饰变量，表明此变量一旦赋值，则不能再被改变，相当于一个常量

例如：final int FINALVAR = 100；

（2）abstract类和abstract方法

关键自abstract的含义为“抽象”，用abstract修饰类，此类称为抽象类，抽象类不能被实例化；用abstract修饰方法，此方法称为抽象方法，抽象方法没有实现的代码（方法首部; ）包含抽象方法的类一定是抽象类，但抽象类可以没有抽象方法。

例3.14

（3）关键字super

关键字super的用途：在子类型的非静态成员方法中访问其父类型的成员变量

例3.15

（4）关键字this

关键字this的用途：在当前类的非静态成员方法中访问当前类的成员变量

例见课本57页

（5）类之间的is-a和has-a关系

例3.16：类A继承自类B，子类A与父类B之间有is-a关系

例3.17：类A的某个成员变量的类型是B，类A和类B之间是has-a 关系

（6）内部类（inner class）

定义在其它类内部的类称为内部类。

接口(interface)

Java小应用程序基础（课本61-64页，简单应用、识记）

Java Applet

主要功能：显示图形、动画、播放声音、响应用户事件等。

Java applet 的实现主要依靠java.applet 包中的Applet类。

java. applet. Applet类是所有Java applet的基类，所有的Java applet 都必须继承该类。

（1）小应用程序的建立和运行（见课本59页）

Java applet程序从建立到运行的步骤如下：

1)选用写字板或文本编辑器等工具建立Java applet源程序。（其中

必须有一个类继承java.applet.Applet类，这个类是小应用程序的主类，用关键字public修饰。）

2)把Java applet的源程序编译为字节码文件。

3)编制HTML文件，通过标记将字节码文件嵌入

HTML文件中。

4)在支持Java的浏览器上运行。

（2）Applet类的基本方法（见课本63页）

public void init( )

public void start( )

public void paint( )

public void stop( )

public void destroy( )

public void repaint( )

public void update( )

（4）小应用程序数据输入与输出（见课本64页）

小应用程序的数据输入有多种方式：

从图形用户界面的文本框、文本区域中输入；

采用系统标准输入；

由HTML文件中的参数导入。

第4章数组和字符串

1. 数组（课本69-73页，综合应用）

数组是连续存储区域的命名集合，这些存储区域彼此相邻，存放着相同类型的数据元素。

一维数组（见课本69-71页）

（1）声明一维数组

一维数组变量的声明格式有如下两种:

数组元素的数据类型[ ] 数组名;

数组元素的数据类型数组名[ ]; （2）创建一维数组

Java数组是引用类型，可以通过new 操作符来创建；在创建一个数组时必须指明数组的元素类型和它的长度。

先声明后创建

格式：数组名= new 数组元素类型[元素个数]

示例:

char[ ] c; // 声明数组

c = new char[5]; // 创建数组，并分配内存

在声明时创建

示例:

char[ ] c = new char[5];

对于较小的数组，可以使用直接赋值创建，即在声明数组时赋给它初值。数组初始化表达式写成一组用逗号分开的扩在花括号里的表达式。

例如：int arr[ ] = {2, -9, 15, -2, 0, 80, 7};

char c[ ] = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’};

（3）引用一维数组元素

数组的每个元素通过它在数组里的位置来引用：数组名[ 下标]，例如：arr[7]

数组下标必须是0到N-1之间的整数，或值在0到N-1之间的整数表达式，其中N是数组里元素的个数。例如：arr[7]、arr[i+j]（其中i=1, j=6）

使用一个不在0到N-1范围内的下标值系统将发生运行时异常，这是由于Java运行系统会对数组下标自动进行范围越界检查。例如：arr[-1]、arr[15]

多维数组（见课本71-73页）

（1）声明二维数组

声明二维数组的形式有以下三种：

数据元素类型数组名[ ][ ]

数据元素类型[ ][ ] 数组名

数据元素类型[ ] 数组名[ ]

（2）创建二维数组

创建二维数组的方法也有多种：

●直接分配（适用于平衡二维数组，即矩阵）

格式：类型数组名[ ][ ] = new 类型[长度1][长度2];

例如：double rainfall[ ][ ] = new double[12][31];

●从最高维开始，分别对每一维分配不等长空间（适用于非平衡

数组）

例如：int a[ ][ ] = new int[3][ ];

int a[0] = new int[4];

int a[1] = new int[5];

int a[2] = new int[2];

●直接赋值创建（适用于元素较少的数组）

例如：int[ ][ ] x = { {5,6,7},

{8,9,10,11},

{18,19,20,15},

{2,9}

};

（3）引用二维数组元素

书中示例的非平衡二维数组x中，x[2][3]值为15

（4）使用二维数组要注意的问题

二维数组名[下标1]是一维数组。

二维数组名.length是二维数组的子数组个数；二维数组名[下标

1].length是指定子数组的元素个数。

2. 字符串（课本73-80页，综合应用）

字符串常量（见课本73页）

双引号括起来的字符序列。示例：“student”、“你好”或“123.456”字符串声明和创建（见课本73-74页）

String name1 = new String( );

String name2 = new String(“Hello World”);

char a[ ] = {‘1’,‘2’,‘3’,‘4’,‘5’,‘6’,‘7’}；

String name3 = new String(a);

String name4 = new String(a,2,4);

字符串基本操作（见课本74-77页）

（1）字符串连接

String s1 = “sweet”;

String s2 = new String( “you ” + “are ” + s1);

（2）获取字符串长度

方法：public int length()

功能：返回此字符串的长度

（3）字符串前缀或后缀的比较

方法：public boolean startsWith(String prefix)

功能：测试此字符串是否以指定的前缀开始

方法：public boolean endsWith(String suffix)

功能：测试此字符串是否以指定的后缀结束

（4）比较两个字符串是否相同

方法：public boolean equals(Object obj)

功能：比较两个引用变量是否引用同一个对象，例如x.equals(y)，对于任何非空引用值x 和y，当且仅当x 和y 引用同一个对象时，此方法才返回true（x == y 具有值true）。

方法：public boolean equalsIgnoreCase(String anotherString)

功能：将此String 与另一个String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的。

方法：public int compareTo(String str)

功能：按字典顺序比较两个字符串的大小。该比较基于字符串中各个字符的Unicode 值。如果此String 对象小于参数字符串，则返回一个负整数。如果此String 对象大于参数字符串，则返回一个正整数。如果这两个字符串相等，则返回0。

方法：public int compareToIgnoreCase(String str)

功能：按字典顺序比较两个字符串，不考虑大小写。

（5）字符串检索

String的实例方法indexOf( ) 可以用于在字符串中查找一个字符或子串的索引位置。indexOf( )方法在一个String里从左到右查找一个字符或子串，它有几种版本：

public int indexOf( String string );

public int indexOf( String string, int startingIndex );

（6）取字符串的子串

方法substring( )可以用来从一个String里检索一个字符子串。

public String substring( int startIndex )

例如：

String str = “HelloWorld”;

str.substring( 5 ); // “World”

str.substring( 9 ); // ”d”

（7）替换字符串中的某字符得到一个新字符串

方法：public String replace(char oldChar, char newChar)

功能：返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。

（8）去掉前后空格得到一个新字符串

方法：public String trim()

功能：返回字符串的副本，去掉前后空白。

（9）基本类型值的字符串表示

String的类方法valueOf( )用于把某种基本类型的值转换成一个String 对象。

（10）字符串得到基本类型对象

每种基本类（包装类，除Character）都有类方法能将字符串转换成基本类的对象，形如：

public static Type valueOf(String s)

其中，Type代表任何基本类，包括Boolean、Integer、Double等。（11）字符串得到基本类型值

每种基本类（包装类，除Character）都有类方法能从字符串中解析出基本类型的值，形如：

public static type parseType(String s)

其中，type代表任何基本数据类型，包括boolean、int、double 等，Type代表相应的包装类。

StringTokenizer类（见课本77-78页）

java.util.StringTokenizer类用来把字符串分解为标记。

常用构造方法1：

public StringTokenizer(String str)

//为指定字符串构造一个string tokenizer。使用默认的分隔符集“ \t\n\r\f”，即：空格字符、制表符、换行符、回车符和换页符。

常用构造方法2：

public StringTokenizer(String str, String delim)

//为指定字符串构造一个string tokenizer。delim 参数中的字符都是分隔标记的分隔符。

常用方法：

public int countTokens()

// 返回使用当前分隔符集的字符串中剩余的标记数

public String nextToken()

//返回此string tokenizer 的下一个标记。

public boolean hasMoreElements()

//测试此string tokenizer 的字符串中是否还有更多的可用标记。如果此方法返回true，那么后续调用无参数的nextToken 方法将成功地返回一个标记。字符串与字节数组（见课本78-79页）

可以使用String构造方法，利用字节数组创建字符串：

public String(byte[ ] bytes)

//通过使用默认字节字符对应表，由字节数组构造一个新的String。新String 的长度是字符集的函数，因此可能不等于byte 数组的长度。

public String(byte[ ] bytes, int offset, int length)

//通过使用默认字节字符对应表，由字节数组起始位置offset开始取length个字节构造一个新的String。

String类也提供实例方法将字符串转化为字节数组：

public byte[] getBytes()

// 使用默认字节字符对应表将字符串转化为字节数组

对象的字符串表示（见课本79-80页）

根类Object中定义了实例方法

public String toString()

此方法的功能描述为：返回该对象的字符串表示。

第5章图形界面设计（一）

1. 图形界面设计基础（课本85-89页，领会）

AWT和Swing（见课本85-86页）

AWT：Abstract Windowing Toolkit,抽象窗口工具包

Swing：与AWT相比——功能更加强大、完善，平台相关性较小

组件和容器（见课本85-86页）

组件（Component ）

组件是Java图形用户界面的最基本组成部分，是一个可以以图形化的方式显示在屏幕上、并能与用户进行交互的对象，组件不能独立地显示出来，必须将组件放在一定的容器中才可以显示出来。

容器（Container ）

容器是可以容纳其他组件的组件，是图形界面的复合元素。Container类有add()方法，可以向容器添加组件。

类java.awt.container的成员方法：

public Component add( component comp )

// 将组件comp添加到当前容器中

Component、Container和Graphics类是AWT库中的关键类。

事件驱动程序设计基础（见课本85-86页）

（1）事件、监视器和监视器注册

在Java里，每当某件事发生在一个GUI组件（事件源或源对象）里，会生成一个事件对象（event）并传给为处理该事件而注册的事件监视器（event listener）。

（2）实现事件处理的途征

事件处理模型的三个基本要素：

事件源(An event source)

事件对象(An event object)

事件监视器(event listener(s))

事件源（源对象）

可供用户进行交互的GUI组件

事件对象

包装相应的事件

记录事件源以及处理该事件所需要的各种信息

事件对象对应的类一般位于包java.awt.event和包javax.swing.event 中

事件监视器（事件监听器）

在事件源中注册事件监视器，当有事件发生时，事件源接收事件对象，并交由相应的事件监听器处理

事件监听器对应的接口和适配器类一般位于包java.awt.event和包javax.swing.event中

（3）事件类型和监视器接口

常用的事件：动作事件（ActionEvent）、项事件（ItemEvent）、列表选择事件（ListSelectionEvent）、文档事件（DocumentEvent）

课本88页表5-1

课本88页表5-2

2. 框架窗口（课本89-91页，综合应用）

JFrame的创建

框架（类javax.swing.JFrame）的构造方法：

public JFrame( ) throws HeadlessException

// 构造一个初始时不可见的Frame

public JFrame( String title ) throws HeadlessException

//创建一个新的、初始不可见的、具有指定标题的Frame；参数title指定标题

JFrame的常用成员方法

框架（类javax.swing.JFrame）的一系列用于属性设置的成员方法：public void setBounds(int x, int y, int width, int height)

//移动Frame并调整其大小。由x 和y 指定左上角的新位置，由width 和height 指定新的宽度和高度。单位是像素。

public void setSize( int width, int height ) // 设置Frame的大小public void setBackground(Color c) //设置Frame的背景色public void setVisible( boolean b )

// 设置Frame是否可见，应当在Frame的属性设置完毕并添加完组件之后调用该方法，使初始不可见的框架变成可见的

public void setTitle(String title) //将Frame的标题设置为指定的字符串

public void setResizable(boolean resizable)

// 设置此窗体是否可由用户调整大小（默认为可调整大小）

框架（类javax.swing.JFrame）的其他常用成员方法：

public void pack() // 以紧凑方式显示Frame

public String getTitle() //获得窗体的标题

向容器中添加组件：在Swing图形用户界面程序设计中，给顶层容器添加组件的方法一般是先获取顶层容器的内容窗格，再向内容窗格添加组件。

类javax.swing.Frame的成员方法：

public Container getContentPane( ) // 返回当前Frame的内容窗格类java.awt.container的成员方法：

public Component add( component comp ) // 将组件comp添加到当前容器中

对于顶层容器，是向其内容窗格添加组件；对于其他容器，则可直接添加组件。

为顶层容器添加组件的另一种方法：建立JPanel对象作为中间容器，将组件添加到这个容器中，再用方法public void setContentPane(Container contentPane)把此中间容器设置为内容面板。

JPanel contentPane = new JPanel(); …// 添加组件到contentPane中

mw = setContentPane(contentPane); // mw为之前创建的某JFame对象

3. 标签、按钮和按钮事件（课本91-94页，综合应用）

标签（见课本91-92页）

标签（javax.swing.JLabel）是用于短文本字符串或图像或二者的显示区。标签不对输入事件作出反应。

标签（类javax.swing.JLabel）的构造方法：

public JLabel( )

public JLabel( String text )

public JLabel( String text, int align )

// 参数text指定标签的文字信息；参数align指定文字在水平方向上的对齐方式。常见对齐方式：javax.swing.JLabel.LEFT（左对齐）、javax.swing.JLabel.CENTER（中对齐）、javax.swing.JLabel.RIGHT（右对齐）

JLabel的常用成员方法：

public void setText( String text ) // 设置标签的文字信息

public void getText( ) //返回该标签所显示的文本字符串

public void setBackground(Color bg) // 设置标签的背景色，默认为容器的背景色

public void setForeground(Color fg)

// 设置标签的前景色，即标签上的文字的颜色，默认为黑色

按钮（见课本92-94页）：命令式按钮在界面设计中用于激发动作事件。

命令式按钮（类javax.swing.JButton）的构造方法：

public JButton ( )

public JButton ( String text)

JButton的成员方法详见课本92页。

public void addActionListener( ActionListener a )

// 为按钮注册由参数a指定的动作事件监视器

动作事件监视器一般是实现接口java.awt.event.ActionListener的类的实例对象。

接口java.awt.event.ActionListener的定义如下：

public interface ActionListener extends EventListener {

public void actionPerformed( ActionEvent e );

}

动作事件对象

动作事件对象的具体类型为java.awt.event.ActionEvent。

类java.awt.event.ActionEvent的常用成员方法包括：

public Object getSource( ) // 返回当前事件的事件源

public String getActionCommand( ) // 返回当前动作事件相关的字符串

类JButton中定义了成员方法：

public void setActionCommand(String actionCommand)

//设置此按钮的动作命令

按钮（动作事件）处理程序的基本内容包括：

定义一个类，实现接口ActionListener，即在此类中实现actionPerformed()方法

4. 面板（课本94-96页）

JPanel（见课本94-95页）面板是一种常用容器，常被用作中间容器。面板（类javax.swing.JPanel）的构造方法：

public JPanel ( )

public JPanel(LayoutManager layout) //创建具有指定布局管理器的JPanel

使用JPanel的两种途径：

(1) 直接创建JPanel的实例对象，在其中添加组件，再将其放入另一个容器中（如JFrame）

(2)定义JPanel类的子类，在其构造方法中向其中添加组件，再通过创建这个子类的实例对象，并将这个对象加入另一个容器中

JPanel的常用成员方法：

public void setPreferredSize( Dimension preferredSize )

// 将面板大小设置为参数preferredSize所指定的尺寸

类java.awt.Dimension的构造方法：

public Dimension( int width, int height) //参数width指定宽度，参数height指定高度

public void setBackground( Color bg ) //将面板背景颜色设置为参数bg 所指定的颜色

JScrollPane（见课本95-96页）：带有滚动条的面板，它也是java.awt.container类的子类，但规定只能向其中添加一个组件。当一个容器的显示区域不足，导致无法同时显示其中的所有组件时，如果让容器带有滚动条，则通过移动滚动条的滑块，就可以看到所有位置上的组件。为容器添加滚动条的工作，可以通过将容器添加到一个JScrollPane中实现。

滚动窗格（javax.swing.JScrollPane）的构造方法：

public JScrollPane( )

// 可以先创建JScrollPane对象，再用其成员方法setViewportView(Component view)设置需要加上滚动条功能的组件public JScrollPane( Component view)

// 参数view指定需要加上滚动条功能的组件，只要组件的内容超过视图大小就会显示水平和垂直滚动条

设置JScrollPane滚动条属性的成员方法：

public void setHorizontalScrollBarPolicy(int policy)

// 确定水平滚动条何时显示在滚动窗格上。选项有：ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED （水平滚动条需要时才显现）

ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER （水平滚动条总是不可见）

ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS （水平滚动条总是可见）

public void setVerticalScrollBarPolicy(int policy)

// 确定垂直滚动条何时显示在滚动窗格上。选项有：ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED（垂直滚动条需要时才显现）

ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER （垂直滚动条总是不可见）

ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS （垂直滚动条总是可见）

5. 布局设计（课本96-102页，综合应用）

FlowLayout布局（见课本97页）

流布局管理器（java.awt.FlowLayout）是java.awt.Applet、java.awt.Panel 和javax.swing.JPanel的默认布局方式。特点：在容器中，从左到右依次排列组件，当组件排满一行时，则从下一行开始继续排列组件。可以设置每行组件的对齐方式为: 左对齐、中间(默认对齐方式)和右对齐。

类java.awt.FlowLayout的构造方法：

public FlowLayout( )

public FlowLayout( int align )

public FlowLayout( int align, int hgap, int vgap)

// 参数hgap（vgap）指定同一行相邻两组件之间的水平（竖直）间隙，单位为像素，默认值均为5；参数align指定行对齐方式：java.awt.FlowLayout.LEFT（左对齐）、java.awt.FlowLayout.CENTER（中对齐）、java.awt.FlowLayout.RIGHT（右对齐）

BorderLayout布局（见课本97-98页）：边界布局管理器

（java.awt.BorderLayout）是java.awt.Frame、java.awt.Dialog 和javax.swing.Window、javax.swing.Frame、javax.swing.Dialog的默认布局方式。特点：将容器分成东、西、南、北、中五个区域，分别对应常量：

java.awt.BorderLayout.EAST 东(右侧)

java.awt.BorderLayout.WEST 西(左侧)

java.awt.BorderLayout.SOUTH 南(底部)

java.awt.BorderLayout.NORTH 北(顶部)

java.awt.BorderLayout.CENTER 中(中间)

每个区域最多只能容纳1个组件。

类java.awt.BorderLayout的构造方法：

public BorderLayout( )

public BorderLayout( int hgap, int vgap )

// 参数hgap指定同一行相邻两组件之间的水平间距，参数vgap 指定相邻两行组件之间的竖直间距，单位均为像素，默认值均为0 GridLayout布局（见课本98-99页）：特点，网格布局管理器（java.awt.GridLayout）将容器按行与列等分成相同大小的矩形区域（网格）；每个组件占用具有相同宽度和高度的网格；添加组件到网格的顺序: 从左到右，从上到下

类java.awt.GridLayout的构造方法：

public GridLayout( )

public GridLayout( int rows, int cols )

public GridLayout( int rows, int cols, int hgap, int vgap )

// 参数rows和col分别指定网格的行数和列数（注意实际行数和列数的计算），默认值均为1；参数hgap和vgap分别指定同一行相邻两组件之间的水平和竖直间距，单位均为像素，默认值均为0；CardLayout布局（见课本100-101页）：

特点：卡片布局管理器（java.awt.CardLayout）对组件的排列类似于码扑克牌，新加入的组件放在已加入的组件的上面，每次一般只能看到一个组件；可以从上到下依次取出下一个组件，而当前组件变为最后一个组件；可以直接翻到某个组件，而组件之间前后排列顺序保持一致。

类java.awt.cardLayout的构造方法：

public CardLayout( )

public CardLayout(int hgap, int vgap )

// 参数hgap和vgap分别指定组件与容器边界之间的水平和竖直间隙，单位均为像素，默认值均为0；

在CardLayout布局下向容器添加组件：使用类java.awt.container的成员方法：

public void add( component comp, Object contraints )

// 将组件comp添加到当前容器中，参数contraints的实际类型为String，指定组件comp的名称。新加入的组件放在已加入的组件的上面

类java.awt.CardLayout提供了成员方法：

public void show( Container parent, String name）

// 直接翻转到指定组件，但不改变组件间的前后排列顺序。参数parent指定要在其中布局的父容器；参数name指定要翻转到的组件的名称。

public void first( Container parent ) // 翻转到容器parent的第一个组件

public void last( Container parent ) // 翻转到容器parent的最后一个组件

public void next(Container parent)//翻转到容器parent中当前显示组件的后一个组件

public void previous(Container parent)

//翻转到容器parent中当前显示组件的前一个组件

Null布局与setBounds方法（见课本100-101页）

可以把一个容器的布局设置为null，即空布局。而采用组件的setBounds()方法设置其大小和在容器中的位置。

类https://www.360docs.net/doc/9c1778879.html,ponent的成员方法：

public void setBounds(int x, int y, int width, int height)

// 设置组件位置及大小。由x 和y 指定组件的左上角在容器中的位置坐标，由width 和height 指定组件的宽和高。

类https://www.360docs.net/doc/9c1778879.html,ponent还有成员方法：

public Dimension getSize( )

// 以Dimension 对象的形式返回组件的大小。Dimension 对象的height 字段包含此组件的高度，而Dimension 对象的width 字段则包含此组件的宽度。

布局管理器类（如FlowLayout、BorderLayout、GridLayout、CardLayout 等）有成员方法：

public void setHgap(int hgap) //将组件之间的水平间距设置为指定值public void setVgap(int vgap) //将组件之间的垂直间距设置为指定值

6. 文本框和文本区（课本102-107页，综合应用）

文本框（见课本102-103页）：文本框（javax.swing.JTextField）可用来编辑单行文本。文本框（类javax.swing.JTextField）的构造方法：public JTextField ( )

public JTextField ( String text )

public JTextField ( int columns)

public JTextField ( String text, int columns)

// 参数text指定在文本框中显示的初始文本信息；参数columns 为非负整数，指定文本框的宽度

类java.swing.JTextField

public String getText( ) // 获取文本框的文本信息

public void setText( String t ) // 设置文本框的文本信息

public void setEditable( boolean b )

// 设置文本框是否可编辑，b为true则可编辑，为false则不可编辑。

文本框（JTextField）可以触发动作事件，其类定义中含有成员方法public void addActionListener( ActionListener a )

// 为文本框注册由参数a指定的动作事件监视器

文本区（见课本103-104页）：可以编辑多行文本信息的文本区域；文本区域不能自动进行滚屏处理，可以将文本区域添加到滚动窗格（JScrollPane）中，从而实现文本区域自动添加滚动条的功能。

文本区（类javax.swing.JTextArea）的构造方法：

public JTextArea ( )

public JTextArea ( String text )

public JTextArea ( int rows, int columns )

public JTextArea ( String text, int rows, int columns )

// 参数text指定在文本区域中显示的初始文本信息；参数rows 指定显示的行数；参数columns指定显示的列数

类java.swing.JTextArea的成员方法：

public String getText( ) // 获取文本区的文本信息

public void setText( String t ) // 设置文本区的文本信息

public void setLineWrap( boolean wrap )

// 设置文本区的换行策略。如果设置为true，则当行的长度大于所分配的宽度时，将换行。如果设置为false，则始终不换行。

实现文本区域自动添加滚动条，只需使用滚动面板（javax.swing.JScrollPane）的构造方法：

public JScrollPane( Component view) // 参数view指定需要加上滚动条功能的组件

例如：

JTextArea ta = new JTextArea( );

JScrollPane jsp = new JScrollPane(ta);

数据输入和输出（见课本104-107页）

在GUI中，常用文本框和文本区实现数据的输入和输出。例5.9、例5.10

第6章图形界面设计（二）

1.选择框和单选按钮（课本111-114页，综合应用）

选择框（JCheckBox）和单选按钮（JRadioButton）均为触击式选择组件，单击这些组件时，都能触发特定的事件，使得复选框和单选按钮的选择状态发生变化。选择状态有两种，一种是选中（on），一种是未选中（off）。

当需要让用户在一组选择项目中做出选择时，可以使用选择框和单选钮。

选择框（见课本111页）：

选择框也称为复选框，选择框（类javax.swing.JCheckBox）的常用构造方法：

public JCheckBox ( )

public JCheckBox ( String text)

public JCheckBox ( String text, boolean selected)

// 参数text指定复选框的文本信息；参数selected指定复选框是否处于被选中状态

单选框（见课本111-112页）

可以用选择框（JCheckBox）实现单选框，方法是通过按钮组（ButtonGruop）：

通过类javax.swing.ButtonGroup的构造方法：

public ButtonGroup( ) //创建按钮组

通过类javax.swing.ButtonGroup的成员方法：

public void add( AbstractButton b )

// 将选择框b 添加到当前按钮组

添加到同一个按钮组中的多个选择框有联动的特点，即同一时刻组内只能有一个选择框处于选中状态。

单选按钮（见课本112页）

单选按钮（类javax.swing.JRadioButton）的构造方法：

public JRadioButton ( )

public JRadioButton ( String text)

public JRadioButton ( String text, boolean selected)

// 参数text指定复选框的文本信息；参数selected指定复选框是否处于被选中状态

单选按钮之间的联动是通过按钮组（ButtonGruop）实现的：

通过类javax.swing.ButtonGroup的构造方法：

public ButtonGroup( ) //创建按钮组

通过类javax.swing.ButtonGroup的成员方法：

public void add( AbstractButton b )

// 将按钮b 添加到当前按钮组

添加到同一个按钮组中的单选按钮具有联动的特点。

类java.swing.JCheckBox或类java.swing.JRadioButton的成员方法：public String setSelected( boolean b )

// 设置复选框或单选按钮的选中状态

public boolean isSelected( )

// 返回当前复选框或单选按钮的选中状态

选择项目事件处理（见课本112-114页）

复选框（JCheckBox）和单选按钮（JRadioButton）都可以触发项目事件（ItemEvent）

这两类组件均含有成员方法

public void addItemListener( ItemListener a )

// 为组件注册由参数a指定的项目事件监视器

项事件监听器

项事件监视器一般是实现接口java.awt.event.ItemListener的类的实例对象。

接口java.awt.event.ItemListener的定义如下：

public interface ItemListener extends EventListener {

public void ItemStateChanged( ItemEvent e );

}

项事件对象

项事件对象的具体类型为java.awt.event.ItemEvent。

类java.awt.event.ItemEvent的常用成员方法包括：

public Object getSource( )

// 返回当前事件的事件源

public ItemSelectable getItemSelectable( )

// 返回当前事件的事件源

程序实例（见课本112-113页）

2.列表和组合框（课本114-117页，简单应用）

列表（见课本114-116页）

JList构造方法：JList（），JList（String[ ] list）

其他常用方法：课本114-116页

组合框（见课本116-117页）

JComboBox---文本框和列表的组合

常用构造方法：JComboBox（），

JComboBox（JComboBoxModel aModel），

JComboBox（Object [ ] items)

其他常用方法：课本116页

3. 菜单（课本117-121页，综合应用）

菜单条、菜单和菜单项（见课本118-121页）

（1）菜单条：JMenubar

（2）菜单：JMenu（）、JMenu（String s）

（3）菜单项：JMenuItem（）、JMenuItem（String s）

（4）处理菜单事件

（5）嵌入子菜单

选择框菜单项（见课本121页）

JCheckBoxMenuItem

4.对话框（课本121-125页，简单应用）

JDialog类（见课本121-124页）

JOptionPane类（见课本124-125页）

5. 滚动条（课本125-127页，简单应用）

6. 鼠标事件（课本127-132页，识记）

MouseListener接口（见课本127-130页）

MouseMotionListener接口（见课本130-132页）7. 键盘事件（课本132-133页，简单应用）

第7章图形、图像与多媒体主要内容：绘图基础、绘图、图像处理基础、多媒体基础

7.1 绘图基础

Graphics类的基本功能：建立字体、设定显示颜色、显示图像和文本、绘制和填充各种几何图形。

getGraphics()

Paint() paintComponent()

字型和颜色

drawString(String str, int x,int y)

drawChars(char data[ ], int offset, int length, int x, int y)

drawBytes(byte data [ ], int offset, int length, int x, int y)

字型的三个要素：字体、风格、字号

类Font设置字型

构造方法有：

Font(String fontName, int style, int size)

常用方法如：getStyle() getName() 等

例题7.1

类Color设置颜色

构造方法有：

Color(int R, int G, int B)

常用方法如：setColor() setBackground() 等

getColor()

例题7.2

绘图模式：如何确定重叠部分，正常模式、异或模式setPaintMode()、setXORMode()

7.2 绘图

Graphics类的绘图方法

画线段drawLine()

画矩形drawRect()

画图

画带颜色的图形

画椭圆drawOval()

画弧drawArc()

画多边形drawPolygon()

擦除矩形块clearRect（）

复制图形copyArea（）

例7.3 7.4

Graphics2D类的绘图方法

7.3 图像处理基础

图像载入和输出

Image类：getImage(URL url)

图像缓冲技术

加载图像

?小应用程序通过URL得到网页上的图像

?类java.applet.Applet中的方法

–Image getImage(URL url)

–Image getImage(URL url, String name)

–返回图像对象

显示图像

?类java.awt.Graphics中的成员方法

–不带缩放的图像显示:

–boolean drawImage(Image img, int x, int y, Color

bgcolor, ImageObserver observer)

–boolean drawImage(Image img, int x, int y,

ImageObserver observer)

–带缩放的图像显示:

–boolean drawImage(Image img, int x, int y, int width,

int height, Color bgcolor, ImageObserver observer) –boolean drawImage(Image img, int x, int y, int width,

int height, ImageObserver observer)

图像缓冲技术

?BufferedImage类

7.4 多媒体基础

播放幻灯片和动画

例7.7

播放声音

例7.8

通过定时器控制动画速度

?javax.swing.Timer

–构造方法

public Timer(int delay, ActionListener listener)

–成员方法

public void setInitialDelay(int initialDelay)

public void setCoalesce(boolean flag)

public void start( )

public void stop( )

动画制作

?相关方法

public void actionPerformed(ActionEvent e)

repaint( );

public void paint(Graphics g)

提高动画质量

?帧缓存技术

加载与播放声音资源

?支持多种声音资源

–Sun Audio 文件(.au 后缀),

–Windows Wave 文件(.wav后缀),

–Macintosh AIFF文件(.aif 或.aiff后缀)

–Musical Instrument Digital Interface (MIDI)文件

(.mid或.rmi 后缀).

类java.applet.Applet中的相关方法

?AudioClip getAudioClip(URL) 和AudioClip getAudioClip(URL, String)

–返回声音资源

?void play(URL) 和

void play(URL, String)

–播放AudioClip

接口java.applet.AudioClip中相关方法

?void loop( )

–重复播放audio clip

?void play( )

–播放audio clip(不循环)

?void stop( )

–停止播放

第8章多线程

1. 线程的基本概念（课本159-160页）

?在Java程序中，多任务是通过多线程实现的。

?多任务是一种在单个程序里同时执行多项任务的技术。在Java 中，通过给每个任务一个独立的执行线程，从而形成了多线程的并行程序。

?一个CPU一次只能执行一条机器指令，通过在线程之间快速的切换，就可以并行的运行多个线程。

?通过调度技术将CPU时间在各个线程之间分享，就可以实现多线程的程序。在不同的操作系统中，处理线程调度有不同的解决方案。

?常用的一种调度技术为时间分片，在某种调度算法的控制下，每个线程得到一小片CPU时间。

–轮循调度：每个线程分到一个相等的时间片，并且遵循先来先服务的原则。

–优先级调度：更高优先级的线程可以在低优先级线程运行之前先运行。

（1）线程的生命周期（课本159-160页）

线程的生命周期

?新建-> 就绪-> 运行-> 阻塞-> 死亡

?Thread类

?Start()

?Run()

?Sleep wait

?Resume notify notifyAll

（2）线程调度与优先级（课本160页）

?每个Java程序都有一个默认的主线程，就是通过JVM启动的第一个线程。

–对于应用程序，主线程执行main()方法。

–对于Applet，主线程是指浏览器加载并执行小应用程序的那一个线程。

?守护线程（Daemon）是一种监视其他线程工作的服务线程，具有最低的优先级。

2. Thread类和Runnable接口（课本161-165页）

?在程序中创建线程的方法通常有两种：

(1) 创建Thread的一个子类，并重写run()方法，创建此子类

的对象作为线程对象。

(2) 定义实现Runable接口的类（即在类中实现run()方法），创建此类的对象并将其作为实参传给Thread类的构造方法Thread(Runnable target)，从而创建线程对象。

（1）Thread类（课本161-163页）

?常用成员方法：

–public final String getName()// 返回该线程的名称。

–public final void setName(String name)// 设置线程名称为name。

–public final int getPriority()// 返回线程的优先级。

–public final void setPriority(int newPriority)

// 设置线程的优先级为newPriority，常用取值为常量：

–MAX_PRIORITY(10): 线程可以具有的最高优先级。

–MIN_PRIORITY(1): 线程可以具有的最低优先级。

–NORM_PRIORITY(5): 分配给线程的默认优先级。

?常用成员方法：

–public static Thread currentThread()

// 返回对当前正在执行的线程对象的引用。

–public final boolean isAlive()

// 测试线程是否处于活动状态。如果该线程处于活动状态，则返回true；否则返回false。如果线程已经启动且尚未终止，则为活动状态。

?用于线程控制的成员方法：

–public void start()

// 使该线程开始执行，先完成所有和系统相关的初始化任务，再由JVM调用该线程的run()方法；

–public void run()

// 封装了线程的基本算法，通常不会被直接调用，而是由线程的start()方法调用它。

–public static void sleep(long millis) throws InterruptedException

// 在指定的毫秒数millis内让当前正在执行的线程休眠（暂停执行），当休眠时间结束，重新回到就绪队列中排队。

–public static void yield()

// 暂停当前正在执行的线程对象，并执行其他线程,暂停的线程重新等待被调度；

程序实例（见课本162页）

（2）Runnable（课本163-165页）

在小应用程序中使用Runnable接口实现多线程的步骤：

(1) 声明实现Runnable接口的类，并在类中实现run()方法；

(2) 在类中声明新线程，在init()方法或start()方法中使用Thread 类的构造方法Thread(Runnable target)创建线程对象，并在start()方法中启动新线程。

补充：产生随机数

?Math.random( )方法用于产生一个[0，1)区间内的随机double 值，并且在上述范围内大致均匀分布。

0.0 <= Math.random( ) < 1.0

?要随机产生一个在[M, M+N-1]范围内的整数值，一般形式如下：

M + ( int ) ( Math.random( ) * N )

例如：int die = 1 + ( int ) ( Math.random( ) * 6 )

程序实例（见课本163页）

?例8.2

?例8.3

3. 线程互斥和同步（课本161-165页）

线程的行为是异步的，无法预测一个线程什么时候可能被中断或让出CPU给其他线程。

当涉及协调多个线程协作的应用程序中，很重要的一点是，设计应当具有防范因异步而导致问题的能力。

（1）线程互斥（课本166-168页）

一些同时运行的线程需要共享某些数据，为保证数据操作的完整性，线程之间需要互斥。

程序实例（见课本166页）例8.4

?临界段：指一个线程执行中不应该被中断的部分。加锁机制。

?在多线程累加求和的例子中，取得当前结果并将其与50求和的新结果存回的过程是不该被中断的临界段。

?Synchronized限定符也可以用于指定一个方法为关键段，这样就使得这个方法的执行不能被其他的合作线程抢占。

程序实例（见课本167-168页）

?设置临界段实现线程互斥后的例8.4

（2）线程同步（课本168-171页）

当线程A使用到某个对象，而此对象又需要线程B修改后才能符合本线程的需要，这时线程A要等待线程B完成修改工作。线程相互等待称为线程的同步。

?线程同步地实现使通过类https://www.360docs.net/doc/9c1778879.html,ng.Object中定义的成员方法：

–public final void wait() throws InterruptedException

// 导致当前线程等待，直到其他线程调用此对象的notify()或notifyAll()方法。

–public final void wait(long timeout) throws InterruptedException // 导致当前线程等待，直到其他线程调用此对象的notify()或notifyAll()方法，或超过指定时间量。

–public final void notify()

// 唤醒在此对象监视器上等待的单个线程，使其回到就绪队列；

–public final void notifyAll()

// 唤醒在此对象监视器上等待的所有线程，使其回到就绪队列。

程序实例（见课本168页）例8.5

第9章输入和输出流

File对象

常用构造方法：

(1)File(String s)

(2)File(String directory, String s)

流对象：InputStream和OutputStream、FileInputStream和FileOutputStream、FileReader和FileWriter类

建立流对象：

FileInputStream (String name)

FileInputSteam (File filename)

创建输入流的一般代码如下：

try{

FileInputStream ins = new FileInputStream(“myfile.dat”);

} catch(FileNotFoundException e) {

System.out.println(“文件找不到：” + e);

}

输入流的常用方法

输出流的常用方法