第一章 Jave语言基础
1.1 Java语言的特点
领会Java语言的特点、关键字
1010-11.Java语言采用多种机制来保证可移植性，其中最主要的是______。虚拟机
1110-11．Java语言是一种 ____强类型语言___ 语言，它约束程序员必须遵守规定编写程序，能让编译器检测出程序中尽可能多的错误。
1.2 Java应用程序和小应用程序
识记 Java应用程序与小应用程序的特点和区别
11．一个应用程序必须在某个类中定义的方法是______。main()
1201-11.能在浏览器上执行的Java程序被称为小应用程序。
1.3 Java程序的开发过程
11.Java程序的字节码文件的扩展名是_________。 Class
1001-11．Java的编译程序先将Java源程序翻译成与机器无关的__________。字节码
1101-11.Java源文件的扩展名是_____.java____。
1210-11. 如果Java源文件中有多个类，那么只能有一个__public____类。
1404-11．类Testll经Java编译程序编译后，产生的文件是 ______。Test11.class
1.4 标识符和关键字
简单应用:Java程序的标识符命名规则、注释、基本数据类型
标识符可以用来标识文件名、变量名、类名、接口名和成员方法名等，其构造规则如下：
1) 标识符由Java字母和Java数字组成；
2) 首字符必须是Java字母；
3) 除去关键字、false、true和null；
4) 所有标识符是区分大小写的。
注释：
1) 行注释 //
2) 块注释 /* …. */
3) 文档注释 /** … */
1404-1．以下标识符中，不是Java语言关键字的是
A．wait B．new C．long D．switch
1．下述字符组合不能作为Java程序标识符的是（ ）
A．Aa12 B．大x C．y小 D．5x
1．下面供选字符序列中，不属于Java语言关键字的是（ ）
A．goto B．null C．false D．native
1．在下述字符串中，不属于Java语言关键字的是 ( C )
A．float B．new C．java D．return
1110-1．下面供选字符序列中，不属于Java语言关键字的是 ( )
A. throw B. synchronizedC. protect D. try
1010-1.以下是关于Java语言关键字的叙述，其中正确的是( )
A.关键字可以用来描述类的成员类型，但是不能描述普通变量
B.关键字由字母(包括英文字母、下划线字符、美元字符、文字字符)和数字组成
C.关键字不可以用作变量、方法、类或标号的标识符
D.break和main都是Java语言的关键字
|
1.5 基本数据类型
1.下列字符组合不能作为Java整型常量的是( )
A.078 B.0x3ACB C.5000 D.0x3ABC
1．在Java语言中，用于标记回车符的转义字符是
A．\b B．/b C．\n D．/n
1001-12．表达式¨23 & 18’’的值是__________。 2318
1101-1.在Java语言中，int类型数据的长度是( )
A.1个字节 B.2个字节 C.4个字节 D.8个字节
11．在Java语言中，双精度型变量在内存中占____8______个字节。
1101-l4.布尔类型数组元素的默认初值是____false_____。
第2章 运算和语句
选择 填空 简答 程序填空
2.1 数据运算
识记: 常用运算符的定义、包声明语句(package)和导入语句(import)
领会: 条件运算和其他运算
2．Java语言中数值数据的类型能自动转换，按照从左到右的转换次序为 ( B )
A． byte→int→short→long→float→double
B． byte→short→int→long→float→double
C． byte→short→int→float→long→double
D． short→byte→int→long→float→double
1404-2．以下数据类型转换中，必须进行强制类型转换的是
A.int→char B． short→long C.float→double D． byte→int
2．以下程序代码的输出的结果是（ ）
int x=53; System. out. println(1.0+x/2);
A．27.0 B．27.5 C．1.026 D．1.026.5
1404-12．表达式“45&20”的十进制值是 ______。 4 à101100&010100
2．设有定义int i=6；，则执行语句“i+=i-1;’’后，i的值为
A．10 B．11 C．12 D．13
1210-12. 运算符‘‘<”、 “*”和“&&”按优先级从高到低的顺序排列为__* < &&____。
21.请写出表示条件“x=2与y=3有且只有一个成立”的Java表达式”。（x=2）!=(y=3)或(x=2＆＆y!=3)||(x!=2＆＆y!=3)
12.构造一个Java表达式：y／x>5，并且x!=0。这个表达式是_________。y/x>5 && x!=0
1101-12.表达式-4>>l的十进制值是______-2___。(解法：-4/（2的一次幂）)
21.请写出表示year年是闰年的Java表达式。闰年的条件是：每4年一个闰年，但每100年少一个闰年，每400年又增加一个闰年。(year%4= =0) && (year%4!=0)||(year%400= =0) 简答
12.用条件运算符构造一个表达式：goal等于10时，表达式的值为“对了！”，否则，表达式的值为“错了！”。这个表达式是_________。
1010-2.执行以下代码，输出结果是( )
int x=5，y=7，u=9，v=6；
System.out.println(x>y ? x+2：u>v ? u-3：v+2)；
A.8 B.6 C.7 D.true
2．以下程序代码的输出结果是（ ）
int x=73；System.out.println（x>>1）；
A．36 B．36.5 c. 37 D．true
1110-2．以下程序代码的输出的结果是 ( )
double x = 25.6;
System.out.println((int)x << 1);
A. 48 B. 50 C. 51 D. 52
1201-2.表达式“-1>>>1”的十进制值是( )
A.－2 B.231－1 C.－(231－1) D.232－1
12．在Java语言中，逻辑右移运算符为____>>>______。
2.2 语句
简单应用: 阅读简单程序的功能和输出结果，编写简单的程序
综合应用: Java语言语句的书写形式和语句的语义，算术运算符、自增自减运算符、关系运算符和逻辑运算符
1210-2. 以下关于Java语句的说法正确的是
A. continue语句必须出现在多路按值选择结构或循环结构中
B. return语句可以出现在方法体的外面
C. 编译系统会把单独的分号看成是空语句
D. break语句的作用是提早结束当前轮次循环
1001-21．请写出一段if语句，判断一个整数n是否为偶数。如果是偶数，输出“Yes.”；否则,输出“No．”。
If(n%2==0){System.out.println(“Yes”);}else{System.out.println(“No”);}
1110-12．在Java语言中， package_____ 语句用于表示出现在该文件中的所有类都属于这个程序包。
1010-21.请使用for循环语句计算S=1+的值。
double s=0.0
for (int i=1;s<=10;i++) s+=1.0/I;
1404-21．已知变量n，请写出使用for语句计算的代码。
1101-21.请写一个if语句，判断整数n是否同时满足“被3除余2，被7除余1”的条件，满足时输出“OK”，否则输出“NO”。
1110-21．请使用for循环语句实现计算的值。
2.以下程序代码的输出结果是( )
int x = 10;
while (x > 7)
{ System.out.print("*"); x--；}
A.** B.*** C.* D.****
1101-2.在switch语句中，switch后面括号内的表达式的类型不能是( )
A.byte B.long C.char D.int
1010-12.程序包声明的格式是______。
12．import语句的格式是______。12、import包名.类名；
1201-21.请写出以下程序段的执行结果。
int c=0，d，n=3758；
while(n>0){ if((d=n％l0)>c) c=d；n/=10；}
System.out.println("结果="+c)；
执行结果：结果=8
21．请写出下面程序段的执行结果。
int n=90；
int k=2；
System.out.print(n+″=〞)；
while(k<=n){
if(k==n){System.out.println(n)； break;}
else if(n%k==0){System.out.print(k+″*″)；n=n／k;)
else k++；
} 90=2*3*3*5
27.方法int maxDigit(int n)的功能是找出十进制整数n各位中最大的一位数字。例如，n=23765，该方法的返回值是7。
static int maxDigit(int n){
int c=0,d;
|
while(n＞0){
d=_______;
if(d＞c) c=d;
n/=10;
}
________; }
27.方法int sigmaDigit(int n)的功能是求出十进制整数n的各位数字之和。例如，n=1234，该方法的返回值是10。
static int sigmaDigit( int n )
{ int sum = 0, d;
while( n > 0 ){
d=n% 10;
_________； sum+=d
n/= 10;
}
_________； return sum
1010-27.方法boolean isPrime(int n)的功能是判断正整数n(n>1)是否为质数。
static boolean isPrime(int n) {
int i;
if(n==2)return true;
if（n%2==0）return false;
for(i=3;i*i<=n;i+=2)
if(_________) break;
if(_________) return true;
return false;
}
1101-27.方法int numberOfDigits(int n)的功能是计算十进制正整数n的位数。
int numberOfDigits(int n){
int c=0：
do{ n／=10；_________；
}while(_________)；
return c；
}
第3章 面向对象编程基础
选择 填空 简答 分析程序运行结果
识记：类的内存模型，final、abstract、super、this的用法，Applet程序结构和执行过程。
领会：抽象、对象、消息、类、继承、封装、接口、多态等面向对象的基本概念。
简单应用：访问权限的设置，Applet类的init()、strart()、stop()、destroy()、paint()、repaint()等方法。
综合应用：类的声明、成员变量（实例变量、类变量）和方法（实例方法、类方法）、构造方法、方法重载，对象的声明、创建和使用，接口的声明和使用。
3.1 面向对象的基本概念
13．在面向对象语言中，对象之间的交互通过______实现。相互发送消息
1110-13．在Java程序系统中，对象之间的交互通过相互发送 _____消息__ 实现
13.类是对一组相同对象的描述，类概括了同类对象的共有性质：_________。(P40)数据（属性）和方法（函数）
1404-3．以下供选择的概念中，属于面向对象语言重要概念和机制之一的是
A．函数调用 B．模块C．继承 D．结构化
1010-13.当联编推迟至运行时间实现时，该联编过程称为______。动态联编
3．在以下供选择的概念中，不属于面向对象语言概念的是 ( B )
A．消息 B．模块 C．继承 D．多态性
1101-22.请写出在面向对象系统中，类和对象的关系。
1110-3．在以下供选择的概念中，不属于面向对象语言概念的是 ( )
A．类 B.函数 C．动态联编 D.抽象
1 3．在Java语言中，通过扩展原有的类，声明新类的机制被称为___继承_____。
3.2 Java的类和对象
22.请写出在类的方法的定义之前，加上修饰字public、private的区别。
Public修饰的方法为公用方法，任何类的方法都可以访问他
Private修饰的方法，本类内部可以访问
1010-3.Java语言中，只限子类或者同一包中的类的方法能访问的访问权限是( )
A.public B.private C.protected D.<无修饰>
1201-22.什么是方法重载，如何正确区分重载?
方法重载是指在一个类中定义多个有相同名字的方法。区分方法：根据这些方法或参数不同或者按顺序参数的类型不同来区分。
1101-13.在定义成员变量时，用关键字___static______修饰的是类变量。
3．参照以下Java代码，以下四个叙述中最确切的是（ ）
class A{ int x; static int y;
void fac(String s){Syatem. out. println(＂字符串:＂+s);}
}
A．x、y和s都是成员变量 B．x是实例变量、y是类变量、s是局部变量
C．x和y是实例变量、s是参数 D．x、y和s都是实例变量
1201-3.Java语言中，在类定义时用final关键字修饰，是指这个类( )
A.子类必须实现父类未实现的方法 B.没有具体实现代码
C.必须要有实例 D.不能被继承
1210-3. 不能被再继承的类是
A. final类 B. abstract类 C. public类 D. 用户自定义类
1404-13．如果类A继承和扩展类B，则子类A和超类B之间的关系是 __is a____。
1201-12.如果子类A隐藏了超类B的成员变量x，而类A的某个方法f()要引用类B的x，则引用类B的x的引用代码可以写成 super.x 。
1201-14.设u和v是类A的两个对象，则逻辑表达式“u==v”的意义是引用相同的对象。
0901-32.阅读下列程序，请写出该程序的输出结果。
class A {
int x, y;
|
A(int a, int b) {
x= a; y= b;
}
}
public class sample {
public static void main(String args[]) {
A pl, p2;
p2 = new A(12, 15);
p1 = p2; p2.x++;
System.out.println("p1.x=" + p1 .x);
}
} p1.x=13
3.设类U声明，及对象u和v的定义如下：
class U{
int x, int y;
|
U(int a, int b){x= a; y = b;}
void copy(U a){ x = a.x; y = a.y;}
}
U u = new U(1, 2), v = new U(2, 3);
在以下供选择的代码中，可能引起系统回收内存的是( )
A.u.x=v.y;u.y=v.x; B.u=v; C.u.copy(v); D.v.copy(u);
1010-32.阅读下列程序，请写出该程序的输出结果。考点：实例变量和类变量
public class A {
int m = 5; static int n = 3;
public static void main(String[] args) {
A obj 1 = new A(); A obj2 = new A();
objl.m *= 2; objl.n *= 4; obj2.m += 1; obj2.n += 6;
System.out.println("obj 1.m=‘‘ + obj 1.m);
System.out.println("obj 1.n=" + obj 1.n);
System.out.println("obj2.m=" + obj2.m);
System.out.println("obj2.n=" + obj2.n);
}
}
22.如果类Student是类Person的子类，类Undergraduate是类Student的子类，请指出以下代码行中哪些是不合法的。继承――父子类间的赋值兼容
Person p1=new Student();
Person p2=new Undergraduate();
Student s1=new Person();
Student s2=new Undergraduate();
Undergraduate ug1=new Person();
Undergraduate ug2=new Student();
Object ob=new Student();
参考答案：(P57)Student s1=new Person();
Undergraduate ug1=new Person();
Undergraduate ug2=new Student();
［解析］本题考核知识点是类之间的is-a关系。在两个相关的类之间，可能会有is-a和has-a关系。若类A是继承扩展类B，则子类A和超类B之间是is-a关系，即类A是一个类B。这种情况下，A类对象一定可以是B类类型，因为B类的所有成员A类也有。也就是子类对象可以是超类类型。语句B
b=new A()是正确的，A a=new B()是错误的。
1001-32．阅读下列程序，请写出该程序的输出结果。
class Parent{
private void method1() { System.out.println("Parent′s method 1()");}
public void method2() { System.out.println("Parent′s method 2()");method1();}
}
class Child extends Parent {
public void method1(){ System.out.println("Child′s method 1 ()");}
public static void main(String args[]){ Parent p = new Child();p.method2();}
|
}
Parent′s method 2()
Parent′s method 1()
32．阅读下列程序，请写出该程序的输出结果。考点：多重继承子类对象的构造
class Tree {
private String name;public boolean flower;
public int birthYear;
Tree（String n, boolean f, int y）{ name = n; flower = f; birthYear = y; }
public void setName（String n）{name = n;}
public String getName（）{return name; }
public void printTree（String str）{
System.out.println（str）; System.out.println（"Name:"+name）;
System.out.println（"Birth Year:"+birthYear）;
System.out.println（"Flower:"+flower）;
}
}
class PineTree extends Tree {
public boolean coniferous = true;
PineTree（String n, boolean f, int y, boolean c）{super（n, f, y）;coniferous = c; }
public void printTree（String str）{
super, printTree（str）;
System.out.println（"Coniferous:" + coniferous）;
}
}
class Test32 {
public static void main（String []args）{
Tree fOb = new Tree（"May Flower", true, 1980）;
PineTree sOb = new PineTree（"Pine", false, 2000, true）;
fOb.printTree（" fOb:"）; sOb.printTree（"sOb:"）;
|
}
}
3．以下关于抽象类及抽象方法的说法中，不正确的是
A．抽象方法只能出现在抽象类中 B．抽象类必须有抽象方法
C．有抽象方法的类一定是抽象类 D．抽象方法没有实现的代码
13.在类声明之前用_________修饰，声明类是不能被再继承的类，即它不能再有子类。 Final
3．Java语言中，在类定义时用final关键字修饰，是指这个类（ ）
A．不能被继承 B．在子类的方法中不能被调用
C．能被别的程序自由调用 D．不能被子类的方法覆盖
1001-13．如果类A某个成员变量的类型是类B，则类A和类B之间是__________关系。(P57)Has-a
3.3 接口
1001-22．请写出接口定义的一般形式。(P59)
1404-22．请写出接口体中可能包含的内容。
1101-3.以下关于接口的叙述中，正确的是( )
A.所有的接口都是公共接口，可被所有的类和接口使用
B.一个类通过使用关键字interface声明自己使用一个或多个接口
C.接口中所有的变量都默认为public abstract属性
D.接口体中不提供方法的实现
1201-13.接口有与类相似的基本形式，它有常量定义和方法定义，但没有方法的实现代码 。
3.4 基本类
3.5 Java小应用程序基础
标识:小应用程序与Applet类的关系, 小应用程序结构和执行过程
简单应用： Applet类的init()、strart()、stop()、destroy()、paint()、repaint()等方法。
11.一个小应用程序必须定义成一个_________。Applet(JApplet)类的子类
1010-22.请写出Applet类中init()方法的功能 创建所需要的对象,设置初始状态,装载图像,设计对数等
22．为了系统安全，对JavaApplet小应用程序有什么限制?
30.某小应用程序实现幻灯片放映。小应用程序的init()方法将幻灯片读入数组中存储和注册鼠标监视器。程序运行时，单击鼠标，就顺序变换放映幻灯片的序号。这里给出的是其中的paint()方法和mousePressed()方法。
|
final int number=30;//假定幻灯片有30张
int count=0;
Image[]pic=new Image[number];
public void paint(______gc){
if((pic[count])!=null)
gc.drawImage(pic[count],10,10,pic[count].getWidth(this),
pic[count].getHeight(this),this);
}
public void mousePressed(MouseEvent e){
count=(count+1)% number;//循环逐张显示
__________;
}
32.阅读下列程序，请写出该程序的输出结果。
import java.applet.*;import java.awt.*;
class Point{
int x,y;
Point(int xx,int yy){ x=xx;y=yy;}
Point(Point p){x=p.x;y=p.y; }
void m(int dx,int dy){x+=dx;y+=dy;}
}
class Circle extends Point{
int r;
Circle(Point p, int rr){ super(p); r=rr; }
float c(){ return 3.14f*2.0f*r; }
float a(){ return 3.14f*r*r;}
}
public class sample extends Applet{
Circle yuan; Point d;
|
public void init() {d=new Point(2,5);yuan=new Circle(d,10);}
public void paint(Graphics g){
g.drawString(＂yuan Circle＂+(int)(yuan.c()*100.0)/100.0,5,20);
g.drawString(＂yuan Area＂+(int)(yuan.a()*100.0)/100.0,5,40);
}
}
第4章 数组和字符串
简单应用：非平衡的多维数组的创建，StringTokenizer类的用法，字符串与字节数组之间的转换，对象的字符串表示
综合应用：一维数组、二维数组、字符串的声明和创建，字符串的常用处理方法，字符串与基本数据类型之间的转换
4.1 数组
1210-14. 数组名如同对象名一样，是一种__________。
23．请写出声明int类型的二维数组intArr的三种形式。
Int intArr[][] Int [][]intArr Int []intArr []
1110-14．数组每个元素按存储顺序对应一个下标，下标从 ___0____ 开始顺序编号
4．在下述Java语言语句中,错误的创建数组的方法是 ( D )
A．int intArray [ ]； intArray=new int[5]；
B．int intArray [ ]=new int[5]；
C．int [ ] intArray ={1，2，3，4，5}；
D．int intArray [5]={1，2，3，4．5};
1404-4．以下Java程序代码中，能正确创建数组的是
A.int myArray［］; myArray［］=new int［5］;
B．int myArray［］=new my(5);
C.int［］myArray={1,2,3,4,5};
D．int myArray［5］={1,2,3,4,5};
1201-23.请写出定义一个包含2个子数组的二维整型数组对象aArr的代码，其中第一个子数组有5个元素，第二个子数组有3个元素。
int aArr[][]=new int[2][];
aArr[0]=new int[5];
aArr[1]=new int[3];
14.设有数组a和b的定义如下：
int[]a={1,2,3};int[]b={4,5,6}
……
执行以下代码“a=b；”,除了完成赋值操作之外，引起系统额外要做的工作是_________。(P45)回收内存(引用类型)
0901-33.阅读下列程序，请写出调用pascal(4)的输出结果。
static void pascal(int n) {
int pas[];
pas = new int[n];
pas[0] = 1;
System.out.println(pas[0]);
for (int i = 2; i <= n; i++) {
/* 由存储在pas中的原来内容生成新内容*/
pas[i - l] =1;
|
for (int j = i- 2;j > 0; j--)
pas[j] = pas[j] + pas[j - 1 ];
for (int j = 0; j < i; j++)
System.out.print(pas[j] +" ");
System.out.println();
}
}
0910- 33．阅读下列程序，请写出该程序的输出结果。引用参数传递
class Test33 {
static void s （int b[ ], int k） {
int i, j, t;
for（i = 1;i< k; i++） {
for（t = b[i], j = i-1; j >= 0 && t < b[j]; j--）
b[j+l] = b[j];
b[j+ 1 ] = t;
}
}
public static void main（String []args）{
int i, a[] = {6, 12, 7, 11, 5 };
s（a, 5）;
for（i = 0;i< a.length; i++） System.out.print（a[i]+" "）;
System. out. Println（）;
}
} 5 6 7 11 12
1010-33.阅读下列程序，请写出该程序的输出结果。
class Test33 {
static int merger(int [] a, int []b, int []c){
int i = 0, j = 0, k = 0;
while(i < a.length && j < b.length) {
if(a[i] < b[j])c[k++] = a[i++]; else c[k++] = b[j++];
}
while(i < a.length) c[k++] = a[i++];
|
while(j < b.length) c[k++] = b[j++];
return k;
}
public static void main(String[] args) {
int a[] = {3, 6, 9}; int b[] = { 1, 2, 5};
int []c = new int[100]; int p = merger(a, b, c);
for(int k = 0; k < p; k++)
System.out.print(c[k]+ (k < p-1 ? " ":"\n"));
}
}
0910-27．方法int sigmaEvenNum（int[]a）的功能是求已知数组中偶数的个数。
static int sigmaEvenNum（int []a）{
int s =0;
for （ int i=0;______;i++ ） {
if（______） s++;
}
return s;
}
1001-27．方法void moveOddForword(int a[ ])的功能是将数组中的所有奇数移到所有偶数之前。
void moveOddForword(int a[]){
for(int i=0， odd=0;___ i<a.length _____；i++)
if(___a[i]%2= =0_____){
int t=a[i]；a[i]=a[odd]；a[odd]=t；odd++；
}
}
1010-4.设有数组定义int[][] x={{1，2}，{3，4，5}，{6}，{}}；，则x.length的值为( )
A.3 B.4 C.6 D.7
0901-37.编写数组复制方法。该方法从已知平衡的两维数组的左下角复制出一个非平衡的三角二维数组。设复制数组方法的模型为：
public static double[][] leftDownConer(double[][]anArray)
public static double[][] leftDownConer(double[][]anArray){
int l1= anArray.length;
int l2=anArray[0].length;
double temp[][];
if(l1<=l2){
temp=new double[l1][];
for(int i=0;i<l1;i++){
temp[i]=new double[i+1];
for(int j=0;j<i+1;j++)
temp[i][j]=anArray[i][j];
}
return temp;
}else{
temp=new double[l2][];
for(int i=0;i<l2;i++){
temp[i]=new double[i+1];
for(int j=0;j<i+1;j++)
temp[i][j]=anArray[l1-l2+i][j];
}
return temp;
}
}
0910-37．编写方法int searchMaxNumIndex（int[]a），寻找已知数组中最大数的下标并返回。
int searchMaxNumIndex(int［］a){
int i,maxIndex;(1分)
for(i=maxIndex=0;i<a.length;i++){(2分)
if(a［i］>a［maxIndex］)(1分)
maxIndex=i;(1分)
}
return maxIndex;(1分)
}
37．编写一个方法halfArray()，要求该方法有一个元素类型为int的数组参数，方法返回一个新数组，新数组的长度与参数数组的长度相同，而新数组元素的值是参数数组各元素的一半。(6分)
|
1:参考答案：
float ［］ halfArray(int ［］ a){（1分）
float ［］ b=new int［a.length］;(2分)
for(int k=0;k＜a.length;k++){（2分）
b［k］=float(a［k］/2.0);
}
return b;（1分）
}
4.2 字符串
1001-14．Java语言提供了两个用于处理字符串的类，它们是__________。String\StringBuffer
14．设有两个字符串对象str1和str2，则表达式“strl==str2”的意义是判别字符串strl和str2______。是否引用同一个对象
1404-14．Java语言提供的用于处理不可改变的字符串类是 ______。String
4.设有以下代码：
String s l="123"；
String s2="123"；
String s3=new String("123")；
则表达式s1==s2和s1==s3的值分别是( )
A.true，true B.false，false C.true，false D.false，true
14．已知字节数组b，取由b[i]开始至b[j](其中j≥i≥0)结束的字节字符构造一个字符串s，其语句为：String s=new String(__b,I,j ________)；。
14.设有字符串定义：
String s="ABCDABCD"；
则表达式s.indexOf("B")的值是_________。 1
1101-4.以下代码段的输出结果是( )
String s="JavaWorld"； System.out.print(s.indexOf("a"，4))；
A.-1 B.O C.1 D.4
1210-4. 已知String s="ABCDEFGHIJABC"，以下说法错误的是
A. s.indexOf("C")等于2 B. s.indexOf("EFG",2)等于4
C. s.indexOf("A"，7)等于10 D. s.indexOf("D"，4)等于3
4．执行下列程序语句后，b的值是
String a=〃Hello〃；
String b=a.substring(1,3)；
A．el B．He C．ell D．Hel
1110-4．在Java语言中，能够实现字符串连接的方法是 ( )
A. String substring(int startpoint) B. String concat(String s)
C. String replace(char old,char new) D. String trim()
1201-4.表达式 "java程序设计".1ength() 的值是( )
A. 0 B.12 C. 8 D.13
1201-15.要获得对象的字符串表示，调用的方法是 String toString（） 。
1010-37.请编写方法int countNum(String str)，该方法的功能是统计已知字符串str中数字的个数。例如，countNum("A42B83C2D")的返回值是5。
33．阅读下列程序，请写出该程序的功能。
|
import java. util.*;
public class Class1{
public static void main(Srting args[]){
Date date1=new Date();
System. out. println (datel);
String t=datel.toString();
int endPos=t.indexOf(｀C＇);
t=t.substring(11,endPos);
System. out println(t);
}
}
4．以下是关于字符串运算的代码，执行该代码段的输出结果是（ ）
String s=″0123456789″，sl，s2；
sl=s.substring（2）；s2=s.substring（2，5）；System.out.println（s1+s2）；
A．0122345 B．234567892345
C．012234 D．23456789234
java.util.StringTokenizer类用来把字符串分解为标记。
4．需要分析字符串，并将字符串分解成可被独立使用的单词，可使用java. util包中的类是
（ ）
A．String B．StringBuffer C．StringTokenizer D．stringTokenizer
1001-33．阅读下列程序，请写出该程序的功能。
import java.util.*；import javax.swing.*；
public class Test33{
public static void main(String args[]){
String str=(String)JOptionPane．showInputDialog(null，″请输入信息″，
″输入对话框″,JOptionPane．PLAIN_MESSAGE，null，null，null)；
StringTokenizer pas=new StringTokenizer(str, ″，″)；
int n=pas.countTokens()；
System.out.println(″输入的信息有单词:″+n+″个，全部单词如下：″)；
while(pas．hasMoreTokens()){
String s=pas.nextToken()；
System.out.println(s)；
}
}
)
答：
在输入对话框中输入文字，并以多好作为分割符输出单词个数，及各个单词
1010-14.使用默认字节字符对应表，将字符串转化为字节数组的方法是______。getBytes()
1001-37.请编写方法void strReverse(String str)，该方法的功能是输出一个新字符串，新字符串字符排列顺序与原字符串str的字符排列顺序相反。例如，strReverse(″ABCD″) 所输出的结果是″DCBA″。请使用字符串与字节数组的相互转换方法进行设计。
答：public static void strReverse(String str){
byte[] s=str.getBytes();
String t="";
for(int i=s.length-1;i>=0;i--){
t+=(char)s[i];
}
System.out.println(t); }
第五章图形界面设计(一)
创建框架窗口的方法，设计标签、按钮和按钮事件的处理方法
面板，布局设计，文本框和文本区数据输入和输出的方法
5.1 图形界面设计基础
领会:AWT和Swing的基础知识,组件和容器,事件驱动的概念
5．能够直接添加组件的Swing容器是
A．JFrame B．JDialog C．JWindow D JPanel
1404-5．某Java程序的类A要利用Swing创建框架窗口，则A需要继承的类是
A．JWindow B．JFrame C.JDialog D．JApplet
5.以下关于AWT与Swing之间关系的叙述，正确的是( )
A.Swing是AWT的提高和扩展
B.在写GUI程序时，AWT和Swing不能同时使用
C.AWT和Swing在不同的平台上都有相同的表示
D.AWT中的类是从Swing继承的
15．一个基于Swing的应用程序可能在任何平台上都会有相同的______。外观与风格
1010-5.在以下Swing的类中，属于容器的是( )
A.Japplet B.Jbutton C.JTextArea D.JMenu
1101-5.以下不属于AWT库中定义的类是( )
A.ComponentB.ContainerC.Images D.Graphics
1101-23.请写出JFrame、Frame以及Window这三个类的继承关系(按照从父类到子类顺序排列)。Window>frame>jframe
1110-5．在以下供选择的容器类中，属于顶层容器的是 ( )
A．JDialog B.JPanel C．JScrollPane D.JToolBar
1210-5. 以下Swing提供的GUI组件类和容器类中，不属于顶层容器的是
A. JFrame B. JApplet C. JDialog D. JMenu
2 框架窗口
综合应用:声明JFrame的子类和创建JFrame窗口
5．要为程序的子窗口设定一个由字符串s指定的名字，可以采用的代码是（ ）
A．JFrame(s) B．window(s) C．new JFrame(s) D．super(s)
5．在Swing中，它的子类能用来创建框架窗口的类是 ( B )
A．JWindow B．JFrame C．JDialog D．JApplet
1110-15．用Swing编写GUI程序时，通常用 __Jframe__ 类派生的子类创建窗口对象。
24．请写出在JFrame框架窗口对象中添加组件的步骤。
5.3 标签、按钮和按钮事件
简单应用: 声明和创建按钮标签
综合应用: 声明和创建按钮和按钮事件的处理
1210-15. 为了让监视器与事件对象关联起来，需要对事件对象做__监视器注册____，告诉系统事件对象的监视器。
1404-23．请写出对事件对象作监视器注册的作用。
1110-22．请写出Java语言中编写事件处理程序的两种方案。
1110-23.请写出代码段,用来创建一个标签对象lbl，显示文字为“Java”，背景色设为绿色。
15.在实现接口ActionListener的方法actionPerformed()中，常用的有两个获得事件源的方法，它们是getActionCommand()和_________。getSource()
1404-15．要使得已注册的按钮对象暂时不响应事件，需使用的方法是______。setEnabled()
1001-15．某程序用代码“JTextField text=new JTextField（）；”创建了一个文本框，并对这个文本框注册了监视器，则在监视器处理方法actionPerformed(ActionEvent e)中，判定是在这个文本框上发生事件的条件表达式是__________。e.getSource()==text
1001-23．请写出Java语言编写事件处理程序的两种主要方案。(P87)
28.某程序的界面包含一个文本区text1、一个文本框text2和一个按钮button。实现在文本区中输入整数序列后，点击按钮，程序响应按钮事件，累计文本区输入的整数序列，并将总和输出在文本框中。这里给出的是其中相应按钮事件的方法。
public void actionPerformed(ActionEvent e){
int sum;
if(e.getSource()==button){
String s=text1.________;//获取text1中的信息
StringTokenizer fenxi=new StringTokenizer(s,＂,,,\n＂);
int n=fenxi.countTokens();
double a[]=new double[n];
|
for(int i=0;i＜n;i++){
String temp=fenxi.nextToken();
a[i]=Double.valueOf(temp).doubleValue();
}
sum=0;
for(int i=0;i＜n;i++){
__________;
}
text2.setText(＂＂+sum);//刷新显示。}
0910-28．某小应用程序窗口包含有文本区dispArea，以及一个带文字“追加”的按钮。当点击这个按钮时，程序弹出一个输入信息的对话框，并将对话框中输入的内容追加到文本区中。以下是其中相应“追加”按钮事件的方法。
public void actionPerformed（ActionEvent e）{
if（e.______.equals（"追加"））{
String result=（String）JOptionPane.showInputDialog（null,"请输入信息"，
"输入对话框",JOptionPane.PLAIN_MESSAGE, null, null,null）；
dispArea.______（result + " "）;
|
}
}
1010-28.某小应用程序窗口中有一个文本框，一个8行10列的文本区以及一个按钮，点击这个按钮时，在文本框中输入的内容会追加到文本区中。
import java.applet.*; import javax.swing.*; import java,awt.event.*;
public class TextAPP extends Applet implements ActionListener {
JTextField input; JTextArea display; JButton append;
public void init() {
input = new JTextField(10);
display = new ;
append = new JButton("追加");
add(input); add(display); add(append);
input.requestFocus(); display.setLineWrap(true);
append.addActionListener(this);
}
public void actionPerformed(ActionEvent e),{
display. (input.getText() +" ");
}
}
5.4 面板
综合应用:声明JPanel类的子类,创建JPanel对象
简单应用:声明JScrollPane类的子类,创建JScrollPane对象
1010-15.在Swing中，带有滚动条的面板的类名是______。JScrollPane
1101-15.在Swing中，面板有两种，一种是JPanel，另一种是__JScrollPane____。
5.5 布局设计
综合应用:FlowLayout,BorderLayout,Cardlayout,GridLayout布局设计策略设计界面
识记:null布局与setBounds方法
1201-24.请写出创建一个JPanel对象p，并为对象p设定GridLayout布局的代码。
JPanel p=new JPanel();
p.setLayout(new GridLayout());
15．将容器区域分成东、南、西、北、中五个区域的布局类是_ BorderLayout _____。
5．以下是关于FlowLayout布局组件排列顺序的叙述，正确的是（ ）
A．从上到下排列 B．从左到右排列
C．从下到上排列 D．从右到左排列
1201-5.以下关于BorderLayout布局的叙述中，不正确的是( )
A.把容器内的空间划分成5个区域 B.加入组件应该指明要放入的区域
C.是框架窗口的默认布局 D.一个位置可直接放多个组件
34.阅读下列程序，请用示意图画出程序运行时呈现的界面。
import java.applet.*;
import java.awt *;
import javax.swing.*;
class MyPanel extends JPanel {
JButton button; JLabel label;
MyPanel(String s1, String s2) {
this.setLayout(new GridLayout(2, 2));
button = new JButton(s1);
label = new JLabel(s2, JLabel.CENTER);
add(button); add(label); add(new JLabel());
}
}
public class Class1 {
public static void main(String args[]) {
JFrame mw = new JFrame("一个示意窗口");
mw.setSize(400, 250);
Container con = mw.getContentPane();
con.setLayout(new BorderLayout());
MyPanel panel1, panel2;
panel1 = new MyPanel("按钮1" ,"标签1");
panel2 = new MyPanel("按钮2", "标签2");
JButton button = new JButton("开始按钮");
con.add(panel1, "North");con.add(panel2, "South");
con.add(button, "Center");
mw.setVisible(true);
} }
1001-34．阅读下列程序，请用示意图画出程序运行时呈现的界面。
import java.applet.*；import java.awt.*；import javax.swing.*；
class MyPanel extends JPanel{
JTextField textl，text2；
MyPanel(String sl，String s2) {
textl=new JTextFieId(s1)； text2=new JTextField(s2)；
add(text 1)； add(text2)；
}
}
class MySubPanel extends MyPanel {
JTextField text；
MySubPanel(String sl，String s2，String s3) {
super(s1，s2)；text = new JTextField(s3)；add(text)；
}
}
public class Test34 {
public static void main(String args[]) {
JFrame mw=new JFrame(″一个示意窗口″)；
mw.setSize(350，150)；
Container con = mw.getContentPane()；
con.setLayout(new BorderLayout())；
MyPanel pl=new MyPanel(″文本框l″，″文本框2″)；
MySubPanel p2=new MySubPanel(″文本框3″，″文本框4″，″文本框5″)；
JTextArea text=new JTextArea(″这里是一个文本区″)；
con.add(pl，″North″)； con.add(p2，″South″)；
con.add(text，″Center″)；mw．setVisible(true)；
}
}
6 文本框和文本区
综合应用:声明和创建文本框,处理文本框事件和在文本框中输入输出数据
声明和创建文本区域,将文本区域放置于滚动面板,在文本框中输入输出数据
23.请写出程序处理文本框输入结束事件（回车）添加监视器的方法，以及监视器类必须实现的接口方法。
参考答案：(P102)为对象添加监视器的方法是addActionListener;类必须实现的方法是
public void
actionPerformed(ActionEvent e)。
34.阅读下列程序，请写出该程序的功能。
import java.applet.*;import javax.swing.*;import java.awt.event.*;
public class Classl extends Applet implements ActionListener{
JTextField text1,text2;
public void init(){
text1=new JTextField(10); text2=new JTextField(10);
setSize(200,100); add(text1); add(text2);
text1.addActionListener(this);
}
public void actionPerformed(Action Event e){
|
long n;
if(e.getSource()==text1){
n=Long.parseLong(text1.getText());
text2.setText(String.valueOf(n*n));
}
}
}
1010-34.阅读下列程序，请写出该程序的功能。
import java.awt.*; import javax.swing.*;
import java.applet.*; import java.awt.event.*;
public class Classl extends Applet implements ActionListener{
JTextField Text I =new JTextField(5);
JTextField Text2=new JTextField(5);
JTextField Text3=new JTextField(5);
JLabel Label 1 =new JLabel("Please input three numbers:");
JLabel Label2=new JLabel(" ");
JButton but=new JButton("Start!");
public void init() {
setLayout(new GridLayout(6,1)); add (Label 1);
add (Textl); add (Text2); add (Text3);
add (but); add (Label2);
Label2.setFont(new Font ("Courier", 1, 20));
but.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
int a,b,c;
a=Integer.parseInt(Text 1.getText());
b=Integer.parselnt(Text2.getText());
c=Integer.parselnt(Text3.getText());
if (a + b < c || b + c < a || c + a < b) {
Label2 .setForeground (Color. red );
Label2.setFont(new Font ("Courier ", 1, 24));
Label2.setText("No.");
} else {
Label2.setForeground(Color.blue);
Label2.setFont(new Font ("Courier ", 2, 24));
Label2.setText(" Yes.");
}
}
}
38．一个Java小应用程序，界面有三个文本框和两个按钮，前两个文本框用于输入整数，第三个文本框用于输出结果。两个按钮分别表示加和减运算。当前两个文本框输入整数后，点击相应按钮，程序就将计算结果输出在第三个文本框中。以下是程序的大部分，其中监视按钮事件的方法未给出，试编写处理按钮事件的方法。
注：这里是给定部分的程序，你要编写的是actionPerformed(ActionEvent e)方法。
import java.applet.*;import javax.swing.*;
import java.awt.*; import java.awt.event.*;
class Panel1 extends JPanel{
JTextField text1, text2, text3;JButton addButton,subButton;
Panel1(){
text1=new JTextField(10);text2=new JTextField(10);
text3=new JTextField(10);setLayout(new GridLayout(5,1));
addButton=new JButton(＂加＂)；subButton=new JButton(＂减＂)；
add(text1); add(text2);
add(text3); add(addButton); add(subButton);
}
}
public class Classl extends Applet implements ActionListener{
Pane1 panel;//持有需访问对象的引用
public void init(){
setSize(100,200); panel=new Panel1();add(panel);
(panel.addButton).addActionListener(this);
(panel.subButton). addActionListener(this);
}
public void actionPerformed(ActionEvent e){//这里是你要编写的代码
2:参考答案：long n1,n2;（1分）
if(e.getSource()=(panel.addButton)){（3分）
n1=Long.parseLong(panel.text1.getText());
n2=Long.parseLong(Panel.text2.getText());
panel.text3.setText(String.valueOf(n1+n2));
}
else if(e.getSource()=(panel.subButton)){（2分）
n1=Long.parseLong(panel.text1.getText());
n2=Long.parseLong(panel.text2.getText());
panel.text3.setText(String.valueOf(n1-n2));
}
注：将panel.text1写成text1,panel.text2写成text2整体扣1分。
［解析］本题考核知识点是图形界面设计、JPanel、JTextField、JButton及其事件的处理。
在方法体中的代码类似于34小题。容器的嵌套不要忽略了。
0901-38.设计实现以下形式布局的Java小应用程序。
注1：其中空白格是文本框，用于输入对应的内容。
注2：这里给出的是程序的一部分，你要编写的是方法MyWindow(String s)。
import java.applet.*； import javax.swing.*； import java.awt.*；
class MyWindow extends JFrame{
JTextField textl，text2，text3，text4；
public MyWindow(String s){//这个方法是你要编写的
super(s);
Container con=getContentPane();
con.setLayout(new GridLayout(2,4));
JLabel label1=new JLabel("学 号");
JLabel label2=new JLabel("姓 名");
JLabel label3=new JLabel("考试成绩");
JLabel label4=new JLabel("平时成绩");
text1=new JTextField();
text2=new JTextField();
text3=new JTextField();
text4=new JTextField();
con.add(label1);
con.add(text1);
con.add(label2);
con.add(text2);
con.add(label3);
con.add(text3);
con.add(label4);
con.add(text4);
this.setVisible(true);
}
}
public class Class1 extends Applet{
MyWindow myWindow；
public void init(){ myWindow=new MyWindow("一个小应用程序")； }
}
38．以下程序的界面有一个按钮button、一个文本区textA和一个文本框textF。程序运行时，在文本区中输入数字序列，单击按钮，则在文本框中显示数字序列的和。以下是要求你编写的actionPerformed（ActionEvent e）方法的部分代码。
提示:本题来源于例5.9,但考试内容主要小涉及4.2字符串
public void actionPerformed（ActionEvent e） {
if （e.getSource（） == button） {
String s = textA.getText（）; double sum =0;
StringTokenizer fenxi = new StringTokenizer（s, " ,\n"）;
//请在以下位置编写代码
int n=fenxi.countTokens();(1分)
int i=0；(1分)
while(fenxi.hasMoreTokens()){(1分)
String s1=fenxi.nextToken();(1分)
sum=sum+Double.valueOf(s1).doubleValue（）;(1分)
}
textF.setText(""+sum);(1分)
1010-38.一个小应用程序，界面如下图所示，其功能为实现摄氏温度和华氏温度的相互转换。以下是程序的大部分，请编写其中的监视器方法。
注：华氏温度(F)=摄氏温度(C)×9／5+32
import java.applet.*; import javax.swing.*;
import java.awt.event.*;
public class test38 extends Applet implements
ActionListener {
JTextField textl, text2;
JButton c2f, f2c;
public void init() {
text l = new JTextField(5); text2 = new JTextField(5);
c2f=new JButton("摄氏转换为华氏")；
f2c=new JButton("华氏转换为摄氏")；
add(text 1)；add(text2)； add(c2f)；add(f2c)；
text1.requestFocus()；
c2f.addActionListener(this)；f2c.addActionListener((this)；
}
public void actionPerformed(ActionEvent e) {
//请在以下位置编写代码
}
}
第六章图形界面设计(二)
6.1 选择框和单选按钮
综合应用：声明和创建选择框、单选按钮，选择框和单选按钮分组，处理选择项目事件
16.使用单选按钮的方法是将一些单选按钮用_________对象分组，使同一组内的单选按钮只允许一个被选中。 ButtonGroup
29.这是一个处理选择项目事件的子窗口类。窗口中有2个选择框，当选中某个选择框时，文本框将显示选择框对应的信息。
class MyWindow extends JFrame implements ItemListener {
JTextField text;
JCheckBox boxl, box2;
MyWindow(String s) {
_________； super(s)
Container con = this.getContentPane();
this.setLocation(100, 100); this.setSize(400, 200);
text = new JTextField(10);
box1 = new JCheckBox("A计算机", false);
box2 = new JCheckBox("B计算机", false);
con.setLayout(new GridLayout(3, 2));
con.add( new JLabel("计算机产品介绍", JLabel.CENTER));
add(new JLabel("计算机2选1", JLabel.CENTER));
con.add(box1); con.add(box2); con.add(text);
box1 .addItemListener(this);
box2.addItemListener(this);
this.setVisible(true); this.pack();
}
public void itemStateChanged( _________e){ ItemEvent
if(e.getItemSelectable() == box1) {
text. setText("A公司生产");
} else if(e.getItemSelectable() == box2) {
text. setText("B公司生产");
}
}
}
29．以下程序段是选择项目事件处理程序的样例，一个由3个单选按钮组成的选择组被定义为一个面板子类Panel，当某个按钮被选中时，按钮监视程序在类MyWindow的一个文本框中输出某个按钮被选中的字样。以下是类Panel的定义。
class Panel extends JPanel implements {
static JRadioButton box[];
ButtonGroup g;
Panel（String radioNameList[]） {
box=new JRadioButton[radioNameList.length];
setLayout（new GridLayout（1, radioNameList.length））;
g=new ButtonGroup（）;
for（int i=0;i<radioNameList.length; i++）{
box[i] = new JRadioButton（______,false）;
g.add（box[i]）;add（box[i]）;box[i].addItemListener（this）;
|
}
}
public void itemStateChanged（ItemEvent e）{
for（int i = 0; i < box.length; i++）{
if（box[i]._______） {
MyWindow.text.setText（box[i].getLabel（）+"被选中！"）;
}
}
}
}
1010-29.某小应用程序有一个由3个单选按钮组成的颜色选择组，当选中某种颜色时，窗口的背景颜色将作相应的变化。这里给出的是窗口子类My Window的定义的框架以及其构造函数的定义。
class MyWindow extends JFrame implements {
…
MyWindow(String s) {
super(s);
Container con = this.getContentPane();
con.setLayout(new GridLayout(3,2));
this.setLocation(100, 100); this.setSize(400, 400);
panel 1 = new Panel l ();
label l = new JLabel("改变前景颜色",JLabel.CENTER);
con.add(label 1 ); con. ;//add(panel1)
panel 1 .box 1 .addltemListener(this);
panel 1 .box 2.addItemListener(this);
panel 1 .box 3.addItemListener(this);
this. setVisible (true); this.pack();
}
…
}
6.2 列表和组合框
简单应用：声明和创建列表、组合框
1210-16. 列表在界面中表现为列表框，是___JList___类或它的子类的对象。
1010-16.组合框(JComboBox)是______的组合。文本框和列表
1101-6.鼠标单击列表中某个选项事件的相关接口是( )
A.ListActionListener B.ListSelectionListener
C.ActionListener D.SelectionListener
1110-24．请写出JComboBox对象上可能发生的两种事件类型的名字。
6.3 菜单
综合应用：设置菜单和菜单项、处理菜单和菜单项事件
6．以下关于菜单的叙述中，正确的是（ ）
A．菜单分三级定义，最高一级的是菜单条，菜单条中放菜单，菜单中放菜单项
B．菜单分三级定义，最高一级的是菜单，菜单中放菜单条，菜单条中放菜单项
C．菜单分两级定义，最高一级的是菜单，菜单中放菜单项
D．菜单分两级定义，最高一级的是菜单条，菜单条中放菜单项
29.以下是生成菜单项对象，以及菜单项选择事件处理方法的部分代码。要求当菜单项singingItem被选中时，在文本框text中输出“唱歌菜单项被选中！”的字样。
……
singingItem=new________(＂唱歌＂)；//生成菜单项对象
……
public void actionPerformed(ActionEvent e){
if(e.getSource()==singingItem)
text.setText(e.________()+ ＂菜单项被选中!＂)；
|
}
1001-29．以下是子窗口中设置一个菜单条类的定义。类的构造方法根据指定的窗口名称和菜单表设置菜单条，菜单和菜单项，当选中某个菜单项时，在文本框中显示相应菜单项被选中的信息。
class MenuWindow extends JFrame implements ActionListener {
public static JTextField text；
public MenuWindow(String s，String menuList[][]) {
setTitle(s)；
Container con=this.getContentPane()；
con.setLayout(new BorderLayout())；
this.setLocation(100，100)； this.setSize(300，100)；
JMenuBar menubar=new JMenuBar()；
for(int i=0; i<menuList.length；i++) {
JMenu menu=new JMenu(menuList[i][0])；
for(int j=1；j<menuList[i]．1ength；j++){
JMenultem anltem=new JMenultem(menuList[i][j])；
anltem．setActionCommand(menuList[i][j])；
anltem．___ ActionListener(this)_____；menu.add(anltem)；
}
menubar．__ add(menu)________；
}
text=new JTextField()；setJMenuBar(menubar)；
con.add(text，BorderLayout．SOUTH)；
}
public void actionPerformed(ActionEvent e){
text．setText(e．getActionCommand()+″菜单项被选中! ″)；
}
}
public class Test29 extends Applet {
MenuWindow window；
String menuList[][]={{″体育″，″跑步″，″打蓝球″，″打乒乓″}，
{″娱乐″，″唱歌″，″跳舞″}}；
public void init() {
window=new MenuWindow(″体育娱乐之窗″，menuList)；
window.setVisible(true);
}
}
35．阅读下列程序，请回答以下问题：
（1）该程序的菜单条中共有几个菜单项?
（2）单击哪个菜单项，可以打开一个对话框?
（3）该对话框是强制型还是非强制型?
（4）该对话框中显示的是什么内容?
Import javax.swing.*;import java.awt.*;
import java.awt.event.*; import java.util.*;
class MyDialog extends JDialog {
MyDialog（JFrame F, String s） {
super（F, s, false）; Date date = new Date（）;
String t = date.toString（）; JLabel text = new JLabel（t）;
add（text）; setSize（200,100）; setVisible（true）;
}
}
public class MenuDemo extends JFrame implements ActionListener {
JMenuBar menubar; JMenu action;
JMenuItem show, set, quit;
public MenuDemo（） {
menubar = new JMenuBar（）; setJMenuBar（menubar）;
action = new JMenu（‘‘操作‘‘）； menubar.add（action）;
show= new JMenuItem（‘‘显示‘‘）, action.add（show）;
set = new JMenuItem（"设置"）; action.add（set）;
action.addSeparator（）; quit = new JMenuItem（"退出"）;
action.add（quit）; show.addActionListener（this）;
set.addActionListener（this）; quit.addActionListener（this）;
setSize（300,300）; setVisible（true）;
}
public void actionPerformed（ActionEvent e） {
if（e.getSource（） == show） {MyDialog diag = new MyDialog（this, "信息"）;}
else if（e.getSource（）== set） { this.setTitle（"菜单演示"）;}
else if（e.getSource（） == quit）{ System.exit（0）; }
}
public static void main（String[] args） {new MenuDemo（）;}
}
|
6.4 对话框
简单应用：声明和创建对话框
1010-24.在Swing中，对话框有几种?并请写出它们的主要区别。P121
1101-16.对话框的默认布局是____BorderLayOut_____。
1110-16．强制型对话框强制对话过程 ____不能中断___ ，直至对话过程结束，才让程序响应对话框以外的事件。
1210-6. 以下不是JDialog类构造方法的是
A. JDialog( ) B. JDialog(boolean b)
C. JDialog(JFrame f, String s) D. JDialog(JFrame f, String s, boolean b)
16．在构造非强制对话框时，所使用的构造方法是JDialog(f,s, ___false__)，其中f为对话框所依赖的窗口，s为对话框的标题。
1001-38.请设计实现如下用于输入学号和姓名的对话框界面，其中空白格是文本框，用于输入相应的内容。
这里给出的是程序的一部分，你要编写的是类InputNoNameDialog的构造方法InputNoNameDialog(JFrame f，String s，JTextField t)。其中参数f是对话框的依赖窗口，s是对话框标题，t是依赖窗口中显示对话框输入内容的文本框。
以下是类InputNoNameDialog的程序框架。
class InputNoNameDialog extends JDialog implements ActionListener{
JLabel title；JTextField textl，text2，mainText；JButton done；
InputNoNameDialog(JFrame f ，String s，JTextField t) {
super(f,s，true)； mainText = t；Container con = getContentPane()；
title=new JLabel(s)； textl=new JTextField(10)；
text2=new JTextField(10)； con.setLayout(new GridLayout(3,2))；
con.setSize(200，100)； setModal(false)；
//请在以下位置续写其余代码
答： done=new JButton("确定");
done.addActionListener(this);
con.add(title);con.add(done);
con.add(new JLabel("学号"));con.add(textl);
con.add(new JLabel("姓名"));con.add(text2);
setVisible(true); }
public void actionPerformed(ActionEvent e) {
//输入结束按确定按钮后，将对话框中输入的学号和姓名在它依赖窗口的文本框中显示。
mainText.setText(″学号：″+textl.getText()+″ 姓名：″+text2.getText())；
setVisible(false)；dispose()；
}
}
6.5 滚动条
简单应用：声明和创建滚动条
1404-1 6．一个水平滚动条对象的初始值是1 50，滑块的宽是8个像素，表示的范围是［0,300］。 创建这样的滚动条对象时，提供的最后2个参数依次是______。0,300
35.阅读以下程序，请写出该程序的功能。
import javax.swing.*; import java.awt.*;import java.awt.event.*;
class MyScrollBar extends JscrollBar{
public MyScrollBar(int init, int len, int low, int high){
super(JScrollBar. HORIZONTAL, init,len,low,high);
}
}
class MyWindow extends JFrame implements AdjustmentListener{
private JTextField text;
|
MyWindow(String s){
super(s);
MyScrollBar myBar=new MyScrollBar(10,10,0,255);
Container con=this. getContentPane();
con. setLayout(new GridLayout(2,1));
this. setSize(200,100);
this. setLocation(100,100);
myBar.addAdjustmentListener(this);
text=new JTextField(＂＂,20);
con. add(text);con.add(myBar);
this.setVisible(true);
}
public void adjustmentValueChanged(AdjustmentEvent e){
MyScrollBar myBar=(MyScrollBar)e.getAdjustable();
text.setText(＂＂+myBar.getValue());
}
}
public class Class1{
public static void main(String[]args){
MyWindow myWindow=new MyWindow(＂text5_4＂);
}
}
1010-35.阅读下列程序，请写出该程序的功能。
import javax.swing.*; import java.awt.*; import java.awt.event.*;
class MyScrollBar extends JScrollBar {
public MyScrollBar(int init, int len, int low, int high){
super(JScrollBar.HORIZONTAL, init, len, low, high);
}
public Dimension getPreferredSize(){
return new Dimension(125, 20);
}
}
class MyWindow extends JFrame implements AdjustmentListener{
private JTextField text;
MyWindow(String s){
super(s);
MyScrollBar tempBar = new MyScrollBar(l0, 10, 0, 255);
Container con = this.getContentPane();
con.setLayout(new GridLayout(2,1));
this.setSize(250, 100); this.setLocation(100, 100);
tempBar.addA djustmentListener(this);
text= new JTextField("移动滚动条的滑块",20);
con.add(text); con.add(tempBar); this.setVisible(true); this.pack();
}
public void adjustmentValueChanged(AdjustmentEvent e){
MyScrollBar myBar=(MyScrO11Bar)e.getAdjustable()；
text.setText("选择的值是："+myBar.getValue())；
}
}
public class Test35 {
public static void main(String[] args) { new MyWindow("滚动条示意程序"); }
}
1001-16．一个水平滚动条对象的初始值是50，滑块的宽是10个像素，表示的范围是[0，250]。 创建这样的滚动条对象时，提供的5个参数依次是__________。(P125)JScrollBar.HORIZONTAL,50,10,0,250
23.请写出将文本区text放置于滚动面板jsp，并将滚动面板jsp添加到JFrame窗口myFrame的Java语句。
TextArea text=new TextArea();
JScrollPane jsp=new JScrollPane(text);
myFrame.getContentPane().add(jsp);
6.6 鼠标事件
识记：鼠标事件类型、处理接口、处理方法
1404-6．MouseMotionListener接口能处理的鼠标事件是
A．按下鼠标键 B．鼠标点击C．鼠标进入 D．鼠标移动
6．用于判定鼠标右键操作的常量是
A．BUTTON1_MASKB．BUTTON2_MASKC．BUTTON3_MASK D．BUTTON4_MASK
1201-16.注册鼠标点击事件监视器的方法是 addMouseListener(监视器)。
16.Java语言为处理鼠标事件提供两个接口：_________接口和MouseMotionListener接口。
MouseListener
6．MouseListener接口不能处理的鼠标事件是 ( D )
A．按下鼠标左键 B．点击鼠标右键
C．鼠标进入 D．鼠标移动
1010-6.在以下供选择的方法中，属于接口MouseMotionListener的方法是( )
A.mouseReleased() B.mouseEntered()
C.mouseExited() D.mouseMoved()
1110-6．在以下选项中，属于MouseListener接口的方法是 ( )
A．mouseDoubleClicked(MouseEvent) B.mouseDragged(MouseEvent)
C．mouseMoved(MouseEvent) D.mousePressed(MouseEvent)
28.以下小应用程序能响应鼠标按动的事件，当鼠标在正文区的某个位置被点击时，就在该位置显示一个记号“×”，程序限制最多保留最新20个位置。
import java.applet.*; import java.awt.*;
import javax.swing.*; import java.awt.event.*;
class MyPanel extends JPanel {
public void print(Graphics g, int x, int y)(
g.setColor(Color.red);
g.drawLine(x-5, y-5, x+5, y+5);
g.drawLine(x+5, y-5, x-5, y+5);
}
}
class MyWindow extends JFrame implements MouseListener{
final int MaxMarks = 20;
int currentMarks = 0, markCount = 0;
Point marks[] = new Point[MaxMarks];
MyPanel panel;
MyWindow(){
this.setLocation(100, 100);
this.setSize(300, 300);
Container con = this.getContentPane();
panel = new MyPanel(); con.add(panel);
_________(this); addMouseListener
this.setVisible(true);
}
public void paint(Graphics g){
int i;
g.clearRect(0,0, this.getWidth(), this.getHeight());
for(i =0;i < markCount; i++) {
_________(g, marks[i].x, marks[i].y); panel .print //注意上下文
}
}
public void mousePressed(MouseEvent e){ }
public void mouseReleased(MouseEvent e){ }
public void mouseEntered(MouseEvent e){ }
public void mouseExited(MouseEvent e){ }
public void mouseClicked(MouseEvent e){
marks[currentMarks] = new Point(e.getX(), e.getY());
if(markCount < MaxMarks)markCount++;
currentMarks = (currentMarks+ 1)%MaxMarks;
repaint();
}
}
public class Class1 extends Applet {
public void init(){
MyWindow myWndow = new MyWindow();
}
}
1001-28．以下程序创建了一个窗口，然后在窗口内显示″Hello，World! ″。
import javax.swing.*； import java．awt*；
public class HelloWorld {
public static void main(String[ ]ares) {
TextFrame frame=new TextFrame()；
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)；
frame. ____ setVisable(true)____；
}
}
class TextFrame extends JFrame {
public TextFrame() { ．
setTitle(″HelloWorld″)；
setSize(WIDTH，HEIGHT)；
TextPanel panel=new TextPanel()；
Container contentPane=getContentPane()；
contentPane．add(panel)；
}
public static final int WIDTH=300；
public static final int HEIGHT= 200；
}
class TextPanel extends JPanel {
public void paintComponent(Graphics g) {
super. ___ paintComponent(g)_____；
g.drawString(″Hello，World! ″，x，y)；
}
public int x=100； public int y=100；
}
6.7 键盘事件
简单应用:键盘事件处理方法
1001-35．阅读下列程序，请写出该程序的功能。
import java.applet.*：import java.awt.event.*；import javax.swing.*
public class Class 1 extends Applet implements KeyListener{
JButton button=new JButton(″开始″)；
JTextArea text=new JTextArea(5，20)；
public void init() {
button.addKeyListener(this)； add(button);add(text)；
}
public void keyPressed(KeyEvent e){
int t=e.getKeyCode()；
if(t>=KeyEvent.VK_A&& t<=KeyEvent.VK_Z) {
text.append(″ ″+(char)t)；
}
}
public void keyTyped(KeyEvent e){}
public void keyReleased(KeyEvent e){}
}
答：程序功能：从键盘输入字符如果是大写字母A-Z，则显示在文本区中
16．处理键盘事件的Java程序，要实现的接口是______。KeyListener
第七章图形,图像与多媒体
7.1 绘图基础
识记：Graphics类的基本功能，坐标系统
领会：利用Graphics2D类设置绘图状态属性
简单应用：着色和设置字体
7.一般的绘图程序要定义一个JPanel子类。在JPanel子类中还要重定义一个方法，在这个方法中调用绘图方法，绘制各种图形。要重定义的方法是( )
A.paint() B.paintComponent() C.repaint() D.update()
1101-7.Java语言规定，程序绘图区域的坐标原点位于整个区域的( )
A.左上角B.右上角C.左下角 D.右下角
1001-17．要在JComponent 子类的组件中绘图，应重写__________方法。paintComponet()
1404-17．某应用程序定义的类C17是JPanel的子类，在类C17的对象中需要绘图，则在类 C17中应重写的方法是 ______。paintComponet()
1010-17.在某个组件中绘图，一般应该为这个组件所属的子类重写______方法。paint()
7．以下所述内容全部是字型要素的是（ ）
A．字体、字形和大小 B．字体、风格和字号 C．字形、风格和字号 D．字形、颜色和字号
7．以下不属于文字字型要素的是 ( A )
A．颜色 B．字体C．风格 D．字号
1404-7．以下术语中，属于文字字型风格属性的是
A．颜色 B．宋体C．斜体 D．字号
17.在Java语言中，用类Font对象设置字型。如果要设置的字型是：细明体、正常风格(Font.PLAIN)，12磅字号，构造这样要求的Font对象fnA的代码是_________。Font fnA=new Font(“细明体”,Font.PLAIN.12)
17.某个绘图方法设置成“异或模式”绘图，并用黄色作为异或模式设定的绘图颜色。如果当时背景色为红色，并用红色绘制线段，则线段的实际颜色是_________。(P140)黄色
1101-17. Java语言的绘图模式有两种，它们是正常模式和_________
7．设置异或绘图模式的方法是
A．setXORMode() B．setPaintMode() C．XORMode() D．PaintMode()
7.2 绘图
简单应用：利用Graphics2D类对象绘制几何图形、绘制二次、三次曲线
综合应用：显示文字，绘制基本几何图形
24.请写出一条语句，能够绘制一条从点（20，30）开始，长为100像素的水平线段。设调用的对象是类型为Graphics的g。
(P140)g.drawLine(20,30,120,30);或g.drawLine(120,30,20,30);
25．请写出使用Graphics2D类声明并创建一个左上角为(20，30)、边长为50的正方形对象square的语句。
1404-24．已知Graphics对象g，获得Graphics2D对象g2d，然后，用圆角长方形类创建对象 circle，该对象的左上角坐标是(30,40)，半径是50。请写出实现以上要求的Java代 码。
100-24．设已经有Graphics2D对象g2d, 请用Java语句绘制一个矩形rect，其左上角坐标是(20，30)，宽是120，高是30。
Rectangle2D rect=new Rectangle2D.Double(20,30,120,30)
G2d.draw(rect);
1201-7.设已经有Graphics2D对象g2d，RoundRectangle2D对象rRect，绘制对象rRect的代码是( )
A.g2d.draw(rRect) B.g2d.drawRoundRect(rRect)
C.rRect.draw() D.rRect.drawRoundRect()
1201-17.在异或模式下绘图时，实际绘制的颜色是由当前正要绘制的颜色、原先绘制的颜色，以及 异或模式设定的颜色 作特定的运算确定的。
24.要用Graphics2D类的方法画一个图形，首先要把参数对象g强制转换成Graphics2D对象；然后，用图形类提供的静态方法Double()创建一个图形对象；最后，以图形对象为参数调用Graphics2D对象的draw()方法绘制这个图形。请写出用这样的方法绘制一条线段的程序段，线段的两个端点分别是(10.0，10.0)和(30.0，30.0)。
Graphics2D g2d=( Graphics2D) g;
Line2D line=new Line2D.Double(10,20,30,40);
G2d.draw(line)
7．设已经有Graphics2D对象g2d，Rectangle2D对象r，绘制对象r的代码是（ ）
A．g2d.draw（r）B．g2d.drawRect（r）C．r.draw（） D．r.drawRect（）
1110-7．设已经有Graphics2D对象g2d，Line2D对象line，绘制对象line的代码是( )
A．g2d．draw(1ine) B.g2d．drawLine(1ine) C．1ine．draw()D.1ine．drawLine()
1110-17．在Graphics类中，用于在指定的位置显示字符串的方法是 _____darwString()__ 。
7.3 图像处理基础
简单应用：显示图像和图像缓冲
1210-17. Java语言的图像处理功能被封装在___ Image _______类中。
30.这是一个播放幻灯片的小应用程序中的paint()方法。设幻灯片已由小应用程序的init()方法装入内存，并存放于myImage数组中，幻灯片的张数放于变量num中，paint()方法要播放的幻灯片号是int currentImage = 0;
final int num = 30;
Image [ ] myImage = new _________ [num]; Image
……
public void paint(Graphics g) {
if ((mylmage[currentImage]) != null)
g. _________ (myImage[currentImage], 10, 10, drawImage
myImage [currentImage].getWidth(this),
myImage [currentImage].getHeight(this), this);
}
1001-30．以下是一个用鼠标自由作画的小应用程序。最简单的方法是根据鼠标所在位置画点，跟随鼠标的移动，不断画圆点，就能实现用鼠标作画。
import java．awt.*；
import java．awt.event.*；
public class Test30 extends java．applet．Applet implements MouseMotionListener {
Color color；int lineSize=2：
int x=-1,y=-l；
public void init(){
setLocation(30，20)； setSize(300，300)；
setBackground(Color.green)；addMouseMotionListener(this)；
}
public void paint(Graphics g){
if(x!=-1&&y!=-1) {
g.setColor(color)；g.fillOval(x，y，1ineSize，lineSize)；
}
}
public void mouseMoved(MouseEvent e){}
public void mouseDragged(MouseEvent e){
x=e.getX()；y=e．getY()；___ repaint()______；
}
public void ______ update()__ (Graphics g){ paint(g)；} ;
}
1010-30.某小应用程序的界面有两个按钮，点击“画圆”按钮，程序在窗口画一个圆，点击“画矩形”按钮，程序在窗口画一个矩形。
import java.applet.*; import java.awt.*;
import java.awt.event.*;import javax.swing.*;
public class Classl extends Applet implements ActionListener {
boolean c = false; int r = 50,a = 50, b = 50;
JButton bl, b2;
public void init(){
setSize(200, 200); setBackground(Color.blue);
b1 = new JButton("画 圆"); b2 = new JButton("画矩形");
b1.addActionListener(this); b2.addActionListener(this);
add(b1); add(b2); setVisible(true);
}
public void (Graphics g){
g.clearRect(70, 100, 130, 200);
g.setColor(Color. red);
if(c) g.drawRoundRect(70, 100, r, r, r, r);
else g.drawRect(70, 100, a, b);
}
public void update(Graphics g){ paint(g); }
public void actionPerformed(ActionEvent e){
if(e.getSource()==b1) { c = true; }
else if(e.getSource()==b2){ c = false; }
；
}
}
34．阅读下列程序，请写出该程序的功能。
import java.applet.*; import javax.swing.*;
import java.awt.*; import java.awt.event.*;
public class Test34 extends Applet implements ActionListener {
JTextField text;int r; JPanel panel;
public void paint（Graphics g）{
Graphics gc = panel.getGraphics（）;
gc.clearRect（0,0, panel.getWidth（）, panel.getHeight（））;
gc.setColor（Color.red）; gc.fillOval（10, 10, r, r）;
}
public void init（） {
text = new JTextField（10）; panel = new JPanel（）;
setSize（200, 100）; setLayout（new GridLayout（2,1））;
add（text）; add（panel）; text.addActionListener（this）;
|
}
public void actionPerformed（ActionEvent e） {
if （e.getSource（） == text） {
r = Integer.parseInt（text.getText（））;
repaint（）;
}
}
}
1001-36.阅读下列程序，请写出该程序的功能。
import java.applet.*； import java.awt.*；
public class Test36 extends java.applet.Applet implements Runnable{
Thread myThread = null；
double seta=0.0;
public void start() {
setSize(500，400)；
if(myThread=null){ myThread=new Thread(this)； myThread.start()；}
}
public void run() {
while(myThread!=null) {
try {myThread.sleep(40)；
} catch(InterruptedException e){}
seta+=3.0； if(seta>=360)seta=0； repaint()；
}
}
public void paint(Graphics g) {
final double pi=3.14159； final double r = 100.0；
int x0=250+(int)(r*Math.cos(3.1415926/180.0*seta))；
int y0=200+(int)(r*Math.sin(3.1415926/180.0*seta))；
g.setColor(Color.red)； g.drawOval(x0，y0，10，10)；
}
}
答：红色、顺时针画圆
7.4 多媒体基础
简单应用：播放幻灯片、动画、音乐的方法
1010-7.小程序要播放音频文件，可使用类( )
A.Audio B.Jaudio C.AudioClip D.JaudioClip
17．在Java语言中，要播放音频文件可以使用__________类。
1101-24.请写出java.applet.AudioClip控制声音播放的三个方法。
Loop（）；stop（）；play（）
第八章多线程
8.1 线程的基本概念
识记:线程与进程的区别，线程的各种状态、优先级，线程间的互斥与同步
1210-8. 阻塞状态的线程在消除引起阻塞的原因后，会转入
A. 死亡状态 B. 开始状态C. 就绪状态 D. 运行状态
18.线程从阻塞状态恢复到就绪状态，有三种途径：自动恢复、用resume()方法恢复和用_________方法恢复。notify()或notifyAll()
18．当线程调用resume()方法后，就进入__________状态。
1201-18.多线程程序设计中，让执行临界段程序时等待的线程结束等待，通常使用的方法有resume()、notify()或者 notifyAll（） 。
1001-18．当线程使用完临界段后，为了使等待的线程恢复工作，需要调用的方法是__________。Notify()
1110-18．在Java中，线程的调度策略采用___抢占式____，优先级高的线程比优先级低的优先执行。
8．在以下四个供选的整数中，能作为线程最高优先级的整数是 ( C )
A．0 B．1 C．10 D．11
1404-8．以下能作为表示线程优先级的数值，并且级别最低的是
A．0 B．1 C．1 5 D．1 6
1010-8.以下是关于线程的叙述，正确的是( )
A.多线程的使用可以提高设备的平行工作能力，但是使系统管理变得复杂
B.同一个进程下的线程都有自己的状态、专用数据段和独立的内存资源
C.线程是能独立运行的程序
D.进程的执行效率比线程的执行效率高
1101-8.以下关于线程互斥和同步的叙述中，正确的是( )
A.多线程互斥使用各自资源的程序段，在操作系统中称为临界段
B.临界段的作用是使某线程能够使用其它线程的资源
C.可以使用notify()方法通知等待线程结束等待
D.线程的互斥和同步可以很好地解决死锁问题
1101-18.当线程处于新建状态后，调用了start()方法，该线程就处于___就绪__状态。
1110-8．设Thread对象thd的优先级为7，thd又创建了另一个Thread对象chd，如果未对chd 的优先级进行修改，则chd的优先级为 ( )
A．1 B. 5 C．7 D. 10
8.2 Thread类和Runnable接口
综合应用:用Thread子类实现多线程，用Runnable接口实现多线程
8．用Thread子类实现多线程的步骤顺序是（ ）
A．声明Thread类的子类，创建Thread子类的实例，让线程调用start()方法
B．声明Thread类的子类，在子类中重新定义run()方法，创建Thread子类的实例
C．创建Thread子类的实例，让线程调用start()方法
D．声明Thread类的子类，在子类中重新定义run()方法，创建Thread子类的实例，让线程调用start()方法
18.程序员用Java语言编写多线程应用程序，程序员能控制的关键性工作有两个方面：一是编写线程的_________方法；二是建立线程实例。run()
8.用Runnable接口实现多线程的主要工作是( )
A.声明实现Runnable接口的类，在类内实现run()方法，让线程调用start()方法。
B.声明实现Runnable接口的类，在类内实现run()方法，在类内声明线程对象，在init()方法中创建新线程，启动新线程。
C.声明实现Runnable接口的类，在类内实现run()方法，在类内声明线程对象，在Init()方法或start()方法中创建新线程，在start()方法中启动新线程。
D.声明实现Runnable接口的类，在类内实现run()方法，在init()方法中创建新线程，在start()方法中启动新线程。
8．在以下供选择的方法中，能让线程从阻塞状态恢复到就绪状态的方法是（ ）
A．start（） B．init（）
C．resume（） D．run（）
1010-25.请写出用Runnable接口实现多线程的主要工作。
1110-25．请写出线程从阻塞状态恢复到就绪状态的三种途径。
8.3 线程互斥和同步
识记: 线程间的互斥与同步
简单应用: 线程互斥和同步的实现方法
1010-18.多线程互斥使用______的程序段，在操作系统中称为临界段。共享资源
8．用来定义临界段，能对共享对象的操作上锁的关键字是
A．static B．share C．serialize D．synchronized
1201-8.以下关于线程互斥和同步的叙述中，正确的是( )
A.临界段是线程互斥使用资源的程序段 B.临界段能使线程使用其它线程的资源
C.互斥和同步能很好地解决死锁问题 D.可用notify()方法让等待线程结束等待
1210-18. 线程之间的相互等待被称为线程的____同步______。
1404-18．当线程进入临界段后，发现需要与别的线程进行同步，则要调用的方法 是 ______。
Wait()
31.以下定义的类shareDataManager用于管理多个线程共享数据data。一些线程要减少data，另一些线程要增加data。由于data不可以是负值，修改data的方法对这些线程来说不仅要互斥，还要同步。类提供一个方法modiData()供修改data的线程调用，该方法在data修改结束后，应通知其它等待进入这个方法的线程。
class ShareDataManager{
|
int data=0;
________void modiData(int delta){
if(delta＞=0){
data+=delta;
}else {
while(data ＜delta){
try{System.out.println(＂发生等待！＂)；
wait();
}catch(InterruptedException e){ }
}
data-=delta;
}
_________;
}
ShareDataManager(int ititData){data=initData;}
}
36.小应用程序创建一个线程。例子使用容器类方法getGraphics()获得Graphics对象，给线程作为画笔使用。请写出该程序中这个线程的工作内容。
import java.applet.*;import java.awt.*;
public class Class1 extends java.applet.Applet implements Runnable{
Thread redBall;Graphics redPen;
int rx=0,ry=0;
public void init(){
setSize(250,200);
redBall =new Thread(this);
redPen=getGraphics();
redPen. setColor(Color.red);
setBackground(Color.gray);
}
public void start(){ redBall.start(); }
public void run(){
while(true){
if(Thread.currentThread()==redBall){
|
rx=(int)(80*Math.random());
ry=(int)(80*Math.random());
red Pen.setColor(Color.red);
red Pen.fillOval(100+rx,100+ry,10,10);
try{redBall.sleep(500);}
catch(InterruptedException e){}
redPen.setColor(Color.gray);
|
redPen.fillOval(100+rx,100+ry,10,10);
}
}
}
}
31.以下定义的类ShareData用于管理多个线程共享数据val。为了保证对共享数据val修改的完整性，线程对val的操作需要互斥，类ShareData中定义的方法modiData()就是供共享val的线程修改val的方法。程序共有20个线程共享val，有些减少val，有些增加val。
public class Class1 {
public static void main(String args[]){
ShareData mrc = new ShareData(50);
Thread[] aThreadArray = new Thread[20];
System.out.println("\t刚开始的值是:"+mrc.getVal());
System.out.println("\t多个线程正在工作,请稍等!");
for(int i = 0; i < 20; i++) {
int d = i % 2 == 0 ? 50 : -30;
aThreadArray[i] = new Thread(new MyMultiThreadClass(mrc, d));
aThreadArray[i].start();
}
WhileLoop ://等待所有线程结束
while(true){
for(int i = 0; i < 20; i++)
if(aThreadArray[i]. isAlive() ___)continue WhileLoop;
break;
}
System.out.println("\t最后的结果是: "+mrc.getVal());
}
}
class MyMultiThreadClass implements Runnable {
ShareData UseInteger; int delta;
MyMultiThreadClass(ShareData mrc, int d) {
UseInteger = mrc; delta = d;
}
public void run() {
for(int i = 0; i < 1000; i++) {
UseInteger.modiData(delta);
try {Thread.sleep(10) ;//做一些其他的处理
}catch(InterruptedException e){ }
}
}
}
class ShareData {
int val;
ShareData(int initValue){val = initValue; }
int getVal(){return val;}
private void putVal(int v){val = v;}
_________ void modiData(int d){ synchronized
putVal(getVal() + d);
}
}
1001-31．以下定义的类ShareData用于管理多个线程共享数据data。一个线程生成data，另一个线程使用data。约定，新生成的data只有被另一个线程使用后，才能生成下一个data。反之，一个data被使用后，也不能再继续使用。所以，生成和使用data的线程之间需要互斥和同步。以下是管理上述使用方式的类，类内有要管理的共享数据，以及对共享数据的存操作putData()和取操作getData()。
class ShareData{
int data；∥共享数据
boolean newData=false；∥有最近新生成data的标志
synchronized int getData(){
while(!newData){
try{ _____ wait()____；
} catch(InterruptedExceptipn e){
System.out.println(″因错误，而中断!″)；
}
}
newData=false； notify()；return data；
}
synchronized void putData(int n){
while(newData){
try{wait()；
}catch(InterruptedException e){
System.out.println(″因错误，而中断! ″)；
}
}
data=n； ______ newData=true ____；
notify()； return；
}
}
0901-36..阅读下列程序，请写出该程序的功能。
import java.applet.*; import java.awt.*;
public class Class1 extends java.applet.Applet implements Runnable {
Thread myThread = null;
public void start() {
setSize(500, 400);
if (myThread == null) {
myThread = new Thread(this); myThread.start();
}
}
public void run() {
while (myThread != null) {
try { myThread.sleep(500);
} catch (InterruptedException e) { }
repaint();
}
}
public void paint(Graphics g) {
int x = (int)(400*Math.random());
int y = (int)(300*Math.random());
g.setColor(Color.red); g.fillOval(x,y, 10, 10);
}
}
随机绘制外切矩形为10红色的圆
0910-36．阅读以下程序，请写出该程序的输出结果。
class CurrentThreadDemo {
public static void main（String args[]） {
Thread t = new Thread（）; System.out.println（"Current thread"）;
t.setName（"My Thread"）; System.out.println（"After name change"）;
try {for（int n = 3; n > 0; n--） {
System.out.println（n）; Thread.sleep（1000）;
}
} catch （InterruptedException e） {
System.out.println（"Main thread interrupted"）;
|
}
}
}
1010-36.阅读下列程序，请写出该程序的功能。
import java util.*;
class MyThread extends Thread {
int pauseTime; String name;
public MyThread (int x, String n) { pauseTime = x; name = n; }
public void run() {
for(int i = 1;i <= 4; i++) {
try {
System.out.println(name +":" +new Date(System.currentTimeMillis()));
Thread.sleep(pauseTime);
}catch(Exception e){ }
}
}
}
public class Test36{
static public void main(String[] args) {
MyThread thread1 = new MyThread (1000,"Fast Thread"); thread 1 .start();
MyThread thread2 = new MyThread (3000,"Slow Thread"); thread2.start();
}
}
第九章输入和输出流
25.某Java程序要使用文件输入输出流，请写出该程序所需要的import语句。
Import java.io.*;
19．要使用输入/输出操作的程序，必须要导入___java.io_______包。
1010-9.在Java的类库中，包含实现输入/输出操作的包是( )
A.java.util B.java.io C.java.applet D.java.awt
1110-9．在以下供选择的操作中， File对象能够提供的操作是 ( )
A．删除文件 B.读写文件
C．打开文件 D.查询文件属性
9.1 字节流和字符流
综合应用:File、FileInputStream、FileOutputStream、FileReader、FileWriter对象创建
1010-31.某按钮的监视器方法actionPerformed()实现将文本区中的内容写入到文本文件myText.txt中。
public void actionPerformed(ActionEvent e) {
try {
int n = txtFld.getText().length();
byte buffer[]=new byte[n];
buffer=txtFid.getText().getBytes();
FileOutputStream wf=new ("myText.txt");
wf. write(buffer, 0,n);
;
}catch (IOException ioe){ txtFld.setText(ioe.toString()); }
}
}
9．为16位Unicode字符流提供读和写操作支持的类分别是（ ）
A．FileInputStream类和FileOutputStream类 B．InputStream类和OutputStream类
C．FileReader类和FileWriter类 D．File_Reader类和File_Writer类
1110-19．字符流数据中使用的Unicode字符有____16___位二进制位。
1210-9. 字符流数据是
A. 8位的ASCII字符 B. 16位的Unicode字符
C. 任意字符数据 D. 任意二进制数据
9.2 缓冲式输入输出
简单应用: 缓冲式输入输出方法
9．如果一次从文件中读出一行数据，可使用的方法是
A．FileReader的readLine()方法 B．BufferedReader的readLine()方法
C．FileReader的read()方法 D．BufferedReader的read()方法
19.BufferedWriter类是提供缓冲式输出的类。程序需要先创建_________对象，再利用这个对象创建BufferedWriter对象。
FileWriter(流的连接)
1201-25.由于创建输出流对象时，可能会出现IOException异常，所以创建输出流对象的代码必须出现在try-catch语句结构中。请写出为当前目录下的myFile.dat文件创建缓冲输出流对象outs的代码。
try{
FileWriter writefile=new FileWriter(myFile.dat);
BufferedWriter outs=new BufferedWriter(writefile);
}catch(IOException e){}
9.程序如果要按行输入输出文件的字符流，最合理的方法是采用( )
A.BufferedReader类和BufferedWriter类B.InputStream类和OutputStream类
C.FileReader类和FileWriter类D.File_Reader类和File_Writer类
1101-19.如果要按行输入输出文件，需采用___缓冲式____输入输出方式
1210-19. 希望由FileReader对象rf，创建对文件实行缓冲式输入的对象in，能实现这个要求的代码是__________。in=new BufferReader(rf);
9.3 随机访问
识记:文件随机访问方法
9．在以下供选择的方法中，不能用于文件随机访问的方法是（ ）
A．readChar（）B．readLong（）C．readInteger（） D．writeChars（）
1001-19．某程序想为一个long型整数文件构造随机读写对象，支持这个要求的类是__________。RandomAccessFile
1010-19.在Java语言中，文件随机访问可以利用______类实现。RandomAccessFile
1404-19．某程序想要随机读写字符文件，能支持这个要求的类是______。
9.4 文件对话框
领会: JFileChooser设置筛选条件
简单应用:缓冲式输入输出方法，使用文件对话框打开和保存文件，类JFileChooser的使用
6．程序执行方法showOpenDialog（），能打开“打开文件对话框”，如果该方法的返回值是JFileChooser.APPROVE_OPTION，则用户执行的动作是（ ）
A．对话框非正常关闭 B．按下“打开／保存”按钮
C．按下“撤销”按钮 D．重新输入了一个文件名
9．Java语言可以用javax.swing包中的类JFileChooser来实现打开和保存文件对话框。用户通过文件对话框不可能获得的信息是 ( C )
A．文件名称 B．文件路径C．文件内容 D．文件对象
1404-9某Java程序用javax.swing包中的类JFileChooser来实现打开和保存文件对话框。该程序 通过文件对话框首先获得的信息是
A．文件长度 B．文件路径C．文件内容 D．文件对象
1101-9.当用户关闭文件对话框时，有可能返回的整数常量是( )
A.JFileChooser.CLOSE_OPTION B.JFileChooser.APPROVE_OPTION
C.JFileChooser.SAVE_OPTION D.JFileChooser.OPEN_OPTION
1001-25．打开文件对话框时，还可以设置筛选条件，即指定文件的类型。请写出FileFilter类预设的两个方法。accept() getDescription()
1201-6.利用文件对话框打开或保存文件，在打开文件对话框之前，可用FileFilter类设置筛选条件，其所用的两个方法是( )
A.accept()和getSelectedFile() B.accept()和getDescription()
C.accept()和setDescription() D.setDescription()和getDescription()
1101-25.请写出在使用FileFilter类设置筛选条件时，方法accept()以及getDescription()的作用。
实现FileFilter这个抽象类.此抽象类里面定义了两个空的方法,分别是 accept(File f)与getDescripton().当目录里的文件与设置的文件类型相符时,accept()方法就会返回true,并将此文件显示在文件 对话框中.而getDescription()方法则是对此文件类型的描述,可由程序设计者自定义,如"*.java"等等.要
1404-25．某程序希望用FileFilter类的子类为打开文件对话框设置文件筛选条件。请写出设置 此筛选条件要使用的类及相应的方法。
第十章网络与数据库编程基础
10.1 Java网络编程基础
领会:IP地址和InetAddress类;标识:统一资源定位符URL, socket通信C/S建立连接通信方式
1110-20．Java.net包中有 __InetAddress_____ 类，它的对象用于存储IP地址和域名。
1010-26.请写出用InetAddress类，获取网址为“www.edu.cn”的IP地址的Java语句
InetAddress addr= InetAddress.getBYName(“www.edu.cn”).
1404-20．某应用程序已经声明了InetAddress对象addr，现要用域名www.baidu.com创建addr 对象，能实现这样要求的代码是addr =InetAddress．______；getBYName(“www.baidu.com”)
1101-10.获取InetAddress对象的域名所用到的方法是( )
A.getByName()B.getHostAddress()C.getLocalHost() D.getHostName()
1201-10.获取InetAddress对象的域名所用到的方法是( )
A.getHostName()B.getLocalName()C.getHostAddress() D.getLocalHost()
10．获取InetAddress对象的IP地址所用到的方法是
A．getHostlPAddress() B．getHostlP()C．getHostAddress() D．getHost()
10．能利用对象提供的方法获得流对象和实现网络连接的是（ ）
A．URLConnection对象 B．URL对象 C．InetAddress对象 D．TCP/IP对象
26.请写出URLConnection类在编写Java网络应用程序中的作用。
URLConnection类完成流对象和实现网络连接
1001-26．请写出URLConnection类提供的三个常用方法。
getOutputStream()
getInputStream()
connect()
1110-26．请写出URIConnection类提供的获得输入输出流对象的方法和实现网络连接的方法。
10．某程序利用网址参数创建URL对象url，接着希望利用对象url获得URLConnection对象，则这个url对象要调用的方法是（ ）
A．connection（） B．URLConnection（）
C．getConnection（） D．openConnection（）
0901-35.阅读下列程序，请回答以下问题：
(1)程序要求在文本框text中输入的内容是什么? 需要读取的文件URL地址
(2)辅助文本区showArea组件的作用是什么? 显示读取的文件内容
(3)如何使程序开始下载网络文本文件? 点击下载按钮
(4)程序采用什么输入方式下载网络文件? 使用字节流完成下载
import java.net.*； import java.awt.*；
import java.awt.event.*； import,java.io.*； import javax.swing.*；
public class Class1{
public static void main(String args[]) .
{ new ConnectNet("读取网络文本文件示意程序")；}
}
class ConnectNet extends JFrame implements ActionListener{
JTextField text=new JTextField(30)；
JTextArea showArea=new JTextArea()；
JButton b=new JButton("下载")；JPanel p=new JPanel()；
ConnectNet(String s){
super(s)；Container con=this.getContentPane()；
p.add(text)；p.add(b)；
JScrollPane jsp=new JScrollPane(showArea)；
b.addActionListener(this)；
con.add(p，"North")； con.add(jsp，"Center")；
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)；
setSize(500，400)；setVisible(true)； }
public void actionPerformed(ActionEvent e){
String urlName=text.getText()；
try{ URL url=new URL(urlName)；//由网址创建URL对象
URLConnection tc=url.openConnection()；//获得URLConnection对象
tc.connect()；//设置网络连接
InputStreamReader in=new InputStreamReader(tc.getInputStream())；
BufferedReader dis=new BufferedReader(in)； String inLine；
while((inLine=dis.readLine())!=null){showArea.append(inLine+"＼n")；}
dis.close()；
}catch(MalformedURLException e2){e2.printStackTrace()；}
catch(IOException e3){ e3.printStackTrace()；}
} }
20.在Java语言中，客户端使用的套接字类是_________。ｓｏｃｋｅｔ
1001-20．设已知服务器的IP地址和端口号，要创建一个套接字对象，支持这个要求的类是__________。Socket
10.2 Java数据库编程基础
识记: 数据库的连接方法，数据源设置方法，DriverManager、Connection、Statement、ResultSet类使用方法
简单应用:SQL语句执行，数据库查询、更新
1010-20.Java程序可以用纯Java的______驱动程序，实现与数据库连接。ＪＤＢＣ
1101-20.Java程序与数据库连接的API被称为__Jdbc_______。
1010-10.在编写访问数据库的Java程序时，ResultSet对象的作用是( )
A.建立新数据库连接 B.用来表示与数据库的连接
C.在指定的连接中处理SQL语句 D.存储查询结果
20．在进行数据库访问时，查询结果存放在一个用__________类声明的对象中。
1110-10．在编写访问数据库的Java程序时，Statement对象的作用是 ( )
A．建立新数据库连接 B.设置查询命令C．创建SQL语句对象 D.存储查询结果
1201-9.在编写访问数据库的Java程序时，Connection对象的作用是( )
A.存储查询结果 B.在指定的连接中处理SQL语句
C.用来表示与数据库的连接 D.用来创建数据库的连接
26.JDBC是Java程序与数据库连接的API，请写出JDBC能做的三件事情。
与某个数据库建立连接、向数据库发送ＳＱＬ语句和处理数据库返回的结果。
26．请写出使用纯Java JDBC驱动程序连接数据库的步骤。
10.在编写访问数据库的Java程序中，要用到DriverManager类。该类的作用是( )
A.存储查询结果 B.处理与数据库的连接 C.在指定的连接中处理SQL语句
D.处理驱动程序的加载和建立数据库连接
20.Connection类是java.sql包中用于处理与数据库连接的类。Connection对象是用来表示_________的对象，Java程序对数据库的操作都在这种对象上进行。数据库连接
10．在编写访问数据库的Java程序时，Connection对象的作用是 ( A )
A．用来表示与数据库的连接 B．存储查询结果
C．在指定的连接中处理SQL语句 D．建立新数据库连接
1210-10. 以下方法中，可以执行SQL查询语句的是
A. executeQuery( ) B. executeUpdate( )
C. executeSQL( ) D. executeFind( )
1101-26.请写出Java程序实现数据库更新可以使用的三种对象。
Statement,PreparedStatement,CreateStatement
1201-26.请写出已知数据库url、用户名uName和密码pWord，通过驱动程序管理器(DriverManager)的方法getConnection()建立连接con的代码，可能产生的异常是SQLException。
try{
Connection con=DriverManager.getConnection(url,uName,pWord);
}catch(SQLException e){
e.printStackTrace(); return null;
}
04747 java语言程序设计(一)
第一章 JAVA语言基础
出题点：
1.JAVA语言的特点：强类型、编译和解释、自动无用内存回收功能、面向对象、与平台无关、安全性、分布式计算、多线程。（P3）
2.小应用程序与应用程序的区别（P5）
(1)小应用程序只能在与JAVA兼容的容器中运行，可以嵌入在html网页内，在网络上发布，当网页被浏览时，在浏览器中运行。小应用程序的运行还受到严格的安全限制。而JAVA应用程序没有这些限制，也不支持网页嵌入和下载运行。
(2)两者在代码编写上也有很大差异。一个小应用程序必须定义成一个Applet类的子类，应用程序可以是Applet类的子类，也可以不是。
(3)应用程序必须在一个类中定义一个main()方法，该方法代表应用程序的入口。而小应用程序不必定义main()方法。它的执行由Applet类中定义的多个方法控制。
3.JAVA应用程序的开过过程（P6）
(1)JAVA应用程序,先编写JAVA源程序，源程序经JAVA编译器编译后产生字节码文件(*.class)，最后由JAVA解释器解释执行字节码文件。
(2)小应用程序，先编写源程序，然后经JAVA编译器编译后产生字节码文件，最后由WEB浏览器解释执行字节码文件。
4.标识符：由字母和数字符组成，限定标识符第一个字符不能是数字符。（P8）
5.关键字：均由小写字母组成，关键字不可以用做变量、方法、类或标号的标识符。（P8）
6.基本数据类型：整数类型(判断合法常量,注意区分三种进制允许出现的字符)、浮点数类型(科学计数法表示123.45e1,e两边必须有数字)、字符类型(常用转义字符)、逻辑类型。非基本数据类型：数组、字符串、类、接口（P8）
7.整数类型依次分为：byte（8位）、short(16位)、int(32位)、long(64位)。（P9）
8.浮点数类型分为：float(单精度型32位)、double（双精度型64位）。（P10）
第二章 运算和语句
一、出题点：
1.在进行连续的逻辑运算时，不分逻辑与和或的优先级，而是顺序进行逻辑与和或的计算，一旦逻辑表子达式或逻辑表达式能确定结果，就不再继续计算（即条件1&&条件2，若条件1不成立，则条件2也无须再计算。） %:求余数,符号同被除数,/:两端为整数,则结果为整数,++,--只能对变量进行。（P16）
2.break语句：必须出现在多路按值选择结构或循环结构中，其执行强制结束它所在的控制结构，让程序从这个控制结构的后继语句继续执行。（P20）
3.continue语句：只能出现在循环结构中，其执行将忽略它所在的循环体中在它之后的语句，使控制转入对循环条件表达式的计算和测试。若出现在for循环体中，则转入表达式3的求值。（P21）
4.return语句：只能出现在方法体中，其执行将结束方法的执行，将控制返回到方法调用处。（P21）
5.在JAVA语言中，用try...catch语句指定可能会发生异常的代码块和错误处理代码块。（P25）
6.循环体中的continue语句的作用是结束当前循环，直接进入下一次循环。break语句的作用是从循环体内跳出至循环的后继语句，即强行中断当前循环。（P31）
二、语法点：
1.if语句(P22)
if(条件表达式)
{语句1}
else
{语句2}
2.switch语句(P23)
switch(表达式)//该表达式的类型只限于char,int,short,byte类型
{
case 常量表达式1：语句序列1；break；//也可以没有break
case 常量表达式2：语句序列2；break；//也可以没有break
......
case 常量表达式n：语句序列n；break；//也可以没有break
default ：语句序列n+1；break；//也可以没有break
3.try...catch语句（P25）
try
{
语句块//执行该语句块，可能会发生异常
}
catch(异常类型 e)
{
异常发生时要执行的语句块
}
finally
{
无论异常发生与否，都要执行的语句块
}
4.while语句//先计算条件表达式，再执行循环体（P26）
while(条件表达式)
{
循环体
}
5.do...while语句//先执行循环体，再计算条件表达式
do
{
循环体
}
while(条件表达式)
6.for语句）（P28）
for(表达式1；表达式2；表达式3)//表达式1为循环变量置初值，表达式2为执行循环条件判断，表达式3为更新循环变量值
{
语句块
}
7.package语句（P31）
package 包名；//package语句必须出现在源程序文件的起始行，表示出现在该文件中的所有类都属于这个程序包。
8.import语句（P32）
import 包名.类名；//该语名用来引来所需要的类。若要从一个包中引入多个类，可用“*”
9.java应用程序的基本结构（P32）
[package 包名；]
import 包名.类名；
[public] class 类名
{
int val=...//变量定义语句
public static void main(String args[])//方法定义
{
...//变量定义和控制语句构成的方法体
}
}
第三章 面向对象编程基础
一、出题点：
1.面向对象程序设计引入了许多概念和机制，包括：（P39）
抽象：是有效控制程序复杂性的重要手段，类是目前支持抽象的最好工具。
对象：对象的名称用于程序引用对象，对象的成员变量用于存储对象的状态信息，对象的方法用于描述对象的行为。
消息：在程序系统中，对象之间的交互通过相互发送消息实现。
类：声明对象共有属性和行为的机制称为类。
继承：就是在已有类的基础上，扩充属性或扩充与改写其某些方法，生成新的类。（即通过扩展原有的类，声明新类来实现的。P49）
多态性：是指类型适应性多态性，这来自继承，不同继承层次的对象对同样的方法有不同的实现。
2.类：是一种类型，类封装对象的属性和方法，是同一类对象的模板。
3.方法重载：是指在一个类中定义多个有相同名字的方法，但这些方法或者参数个数不同或按顺序参数的类型不同。（P43）在编译时就能确定被调用的方法，这种多态性不需要动态联编技术的支持。（P51）
4.构造方法：是一种特殊的方法，这种方法的名与它的类名相同，并且不返回结果，也不写上void关键字。构造方法的作用是创建类的对象，并给对象初始化。构造方法是公共方法，但程序不能显式调用，而是当程序运行时，当有对象要创建时，由系统自动调用构造方法。（P44）
5.实例变量和类变量的区别（P46）
（1）用关键字static修饰的是类变量，未用关键字static修饰的是实例变量。
（2）不同对象的实例变量将被分配不同的内存空间，改变类的某一个对象的实例变量值不会影响其他对象的实例变量。
（3）类变量的内存只有一处，让类的所有对象共享。从类的任一对象改变类变量，类的其他对象都能发现这个改变。
5.5实例方法和类方法的区别（P47）
（1）冠以修饰字static的方法称为类方法，没有冠以修饰字static的方法称为实例方法。
（2）实例方法可以互相调用，并可调用类方法。类方法可以互相调用，但不能直接调用实例方法。
（3）实例方法可引用实例变量及类变量，类方法能直接引用类变量，但不能引用实例变量。
6.访问权限(P48)
private:设置最强的访问，其他类的方法都不能访问。
protected:只限子类或者同一个包中的类的方法能访问。
public:设置没有限制的访问权限，其他类的方法都能访问。
友好的<default>:只允许同一个包中的类的方法访问。
7.final类：是不能被再继承的类，即它不能再有子类；final方法：声明该方法不能被子类的方法覆盖；final变量：声明该变量的值不能被改变。（P54）
8.关键字super：利用super，子类方法可以引用超类的成员变量和被覆盖的方法。使用super的3种情况：（1）调用超类的构造方法；（2）调用超类被子类覆盖的方法；（3）访问超类被子类隐藏的成员变量。（P55）
9.关键this:用来指对象自己。（P55）
10.is-a关系：类A是继承扩展类B，则子类A和超类B之间是is-a关系。
11.has-a关系：类A的某个成员变量的类型是B，则类A和类B之间是has-a关系。
12.接口有常量定义和方法定义，但没有方法的实现代码，可以将接口想象为一个“纯”抽象类。
13.基本类（P61）：即将基本类型的关键字的第一字母改为大写，其中只有int的基本类为Integer。值与对应对象的转换 ,1构造方法,2对象.xxxValue();
14.如果小应用程序已用import java.applet.Applet导入系统的Applet类，小应用程序的主类必须按以下形式声明：public class 主类名 extends Applet。如果没用import语句导入系统Applet类，则主类的声明应写成：public class 类名 extends java.applet.Applet。（P61）
15.Applet类的基本方法(63)
（1）init()方法:创建所需要的对象、设置初始状态、装载图像、设置参数等。
（2）start()方法:初始化方法后，紧接着调用start（）方法，启动小应用程序主线程。
（3）stop()方法:当浏览器离开小应用程序所在页面转到其他页面时，调用stop()方法，挂起小应用程序的执行。
（4）destroy()方法:关闭浏览器时，系统调用destroy()方法，结束小应用程序的生命，关闭线程释放对象资源。
（5）paint(Graphics g)方法:用于在屏幕窗口上显示某些信息。
（6）repaint()方法：先清除paint()方法以前所画的内容，然后再调用paint()方法。
（7）update()方法：调用repaint()方法时，系统会自动调用update()方法。也是清除paint()方法以前所画的内容，然后再调用paint()方法。
16.小应用程序的生命周期（P64）
（1）下载并实例化小应用程序，系统调用init()方法；
（2）启动，系统调用start()方法；
（3）小应用程序调用stop()方法暂停或执行paint()方法完成；
（4）重新启动；
（5）终止，或退出浏览器，或执行destroy()方法消亡方法。
二、语法点：
1.类的声明（P41）
class 类名
{
类体//给出类的成员变量和方法定义，类体中不能有独立的执行代码，所有执行代码只能出现在方法中。
}
2.成员变量（P42）
[修饰字] 类型 变量名；//修饰字可为：private、protected、public、友好的；成员变量对类内定义的方法都有效。类的方法也可以定义变量，称为局部变量。局部变量只在定义它的方法中有效。局部变量会隐藏同名的成员变量,访问 this.成员名
3.方法（P42）
返回值类型 方法名（类型 参数名，....，类型 参数名）
{
方法体
}
//返回值类型声明方法返回值的数据类型。如方法无返回值，就用void关键定。
4.对象（P44）
声明对象：
类名 对象名；//Point p1,p2;
创建对象：
new 构造方法（[参数表]）//p1=new Point();p2=new Point(30,40)
p45 对象的内存模型,引用类型
5.继承（P49）
class 子类名 extends 超类名
{
类体
}
(1)父子类间构造方法调用
(2)注意成员变量的隐藏和实例方法的覆盖
6.接口
定义接口 ：[public] interface 接口名 [extends 超接口表]
{
接口体 所有变量默认final static,方法:public abstract
}
实现接口：class 子类名 extends 超类名 implements 接口列表
｛ //必须实现接口中声明的所有方法｝
7.小应用程序主类的程序结构：
public class AppletName extends java.applet.Applet
{
public void init(){......}
public void start(){......}
public void stop(){......}
public void destroy(){......}
public void paint(Graphics g){......}
}
第四章 数据和字符串
一、出题点
1.String类用于处理不可改变的字符串， StringBuffer类用于处理可改变的字符串。(P73)
2.Object类有方法String toString()，一个对象通过调用该方法可以获得对象的字符串表示。（P79）
如：Date d1=new Date()；//声明并创建一个Date对象
String s=d1.toString()；//将Date对象d1处理转变为String类型，存放在s中。
二、语法点
1.数组(以二维数组为例)(P69-71)
（1）数组先声明
类型 数组名 [][](其它形式的声明：类型 [][] 数组名、类型 [] 数组名[])
（2）数组创建
类型 数组名[][]=new 类型[长度1][长度2]；
非平衡数组,int a[][] 区分a.length与a[0].length
赋初值:int x[]={1,2,3,4} int x[][]={{1,2},{3,4,5}}
2.字符串声明和创建（P73）
（1）字符串先声明
String s；
（2）字符串创建
s=new String()；//创建一个空字符串对象
s=new String(String str)；//创建一个str字符串对象,如s=new String("i am")
s=new String(char a[])；//如char c[4]={‘g‘,‘o‘,‘o‘,‘d‘}；String s=new String(c)；
s=new String(char a[]，int startIndex,int charNum)；//如char c[4]={‘g‘,‘o‘,‘o‘,‘d‘}；String s=new String(c,2,4),即从下标为2的字母开始，后面共4个字母赋值给s对象；
3.字体串基本操作（P74）
（1）字符串连接，concat(s)方法：s1=s1.concat(s2)；//将s2连接在s1之后，得到一个新的字符串。
（2）获取字符串的长度：s.length()；
（3）字符串前缀比较：boolean startsWith(s)判断一个字符串的前缀是否为s。
字符串后缀比较：boolean endsWith(s)判断一个字符串的后缀是否为s。
（4）比较两个字符串是否相同：boolean equals(s)方法。//s1.equals(s2)比较s1与s2字符串相同否，同为true。与”==”的区别,
（5）字符串检索：int indexOf(s)，即从字符串头开始检索s,返回s首次出现的位置；或int indexOf(String s，int startpoint)，即从指定的startpoint位置开始检索s,返回s首次出现的位置。(从0开始编号)
（6）取字符串的子串：String substring(int startpoint)或String substring(int startpoint，int end),其中startpoint是字符串的开始下标，end是截止下标。(到end-1为止)
(7)基本类型值的字符串表示: String.valueOf();
字符串得到基本类型对象:dobj=Double.valueof(“123.45”);
值: d=Double.pauseDouble(“123.45”);
4.StringTokenizer类操作（P77）
（1）使用StringTokenizer类构造对象作为字符串分析器
如：StringTokenizer st=new StringTokenizer("I am tom，I am man.")；
或 StringTokenizer st=new StringTokenizer("I am tom"，",")；//以“,”为分隔符
（2）利用取一个单词的方法nextToken()
如：st.nextToken()
（3）利用hasMoreTokens()方法控制循环，只要字符串中还有语言符号，返回 true。
（4）调用countTokens()方法能得到字符串分析器中一共有多少个单词。
如：st.countTokens()
第五章 图形界面设计（一）
一、出题点
1.AWT与Swing在区别（P85）
（1）AWT依赖于主平台绘制用户界面组件，而Swing有自己的机制，在主平台提供的窗口中绘制和管理界面组件。
（2）AWT在不同平台上运行相同的程序，界面的外观和风格可能会有一些差异，而一个基于Swing的应用程序可能在任何平台上都会有相同的外观和风格。
2.使用Swing设计图形界面，主要引入两个包：javax.swing包含Swing的基本类；java.awt.event包含与处理事件相关的接口和类。（P85）
3.组件（Component）是图形界面的基本元素，容器（Container）是图形界面的复合元素，容器可以包含组件。为了统一管理组件和容器，为所有组件类定义超类Component类，把组件的共有操作都定义在Component类中；为所有容器类定义超类Container类，把容器共有的操作都定义在Container类中。（P86）
4.Swing类的层次结构（P86）
顶层容器：JFrame,JApplet,JDialog,JWindow。
中间容器：JPanel,JScrollPane,JSplitPane,JToolBar等。JPanel 可直接加组件,其它不能
基本组件：JButton,JComboBox,JList,JMenu,JTextField。
可编辑组件：JColorChooser,JFileChooser,JTextArea。
5.图形界面设计的大致步骤：（1）创建容器（2）创建组件（3）往容器里添加组件（4）根据操作注册监视器，并用响应事件的方法完成处理。（自行整理）
6.事件：是指在某个组件上发生用户操作；对事件作监视的对象称为监视器；为了让监视器与事件对象关联起来，需要对事件对象作监视器注册，告诉系统事件对象的监视器。（P87）
7.以程序响应按钮事件为例：（1）程序要创建按钮对象，把它添加到界面中；（2）要为按钮作监视器注册，程序要有响应按钮事件的方法；（3）当“单击按钮”事件发生时，系统就调用已为这个按钮注册的事件处理方法，完成处理按钮事件的工作。
8.JAVA编写事件处理程序的两种方案：（1）程序重设方法handleEvent(Event evt)；（2）程序实现一些系统设定的接口。
9.java.awt.event包中用来检测并对事件做出反应的模型包包括以下三个组成元素：（P87）
（1）源对象：事件“发生”在这个组件上，它与一组“侦听”该事件的对象保持联系。
（2）监视器对象：是一个实现预定义的接口的类的一个对象，该对象的类要提供对发生的事件作处理的方法。
（3）事件对象：包含描述当事件发生时从源传递给监视器的特定事件的信息。
10.窗口是GUI编程的基础，小应用程序或图形界面的应用程序的可视组件都放在窗口中。在GUI中，有三种窗口：
（1）Applet窗口；（2）框架窗口（JFrame）；（3）一种无边框窗口（JWindow）。（P89）
11.Swing里的容器都可以添加组件，除了JPanel及其子类之外，其他的Swing窗口不允许把组件直接加入。而要采用以下两种方法添加：（P89）
（1）用getContentPane()方法获得该容器的内容面板，再将组件加入。如，mw.getContentPane().add(button)。或Container cP=getContentPane()；
cP.add(button)；
（2）建立一个JPanel对象的中间容器，把组件添加到这个容器中，再用setContentPane()把容器置为内容面板。如，JPanel cP= new JPanel()；
cP.add(button)；
......
mw.setContentPane(cP)；
2.用Swing编写GUI程序时，通常不直接用JFrame创建窗口对象，而用JFrame派生的子类创建窗口对象，在子类中可以加入窗口的特定要求和特别的内容等。（P90 例5.2）
13.标签（JLabel）是最简单的Swing组件。标签对象的作用是对位于其后的界面组件作说明。（P91）
14.按钮（JButton）在界面设计中用于激发动作事件。（P92）
15.面板（JPanel）是一种通用容器，其作用是实现界面的层次结构。默认布局为FlowLayout。
16.JScrollPane是带有滚动条的面板，是Container类的子类，也是一种容器，但是只能添加一个组件。其用法是先将一些组件添加到一个JPanel中，然后再把这个JPanel添加到JScrollPane中。（P95）
17.FlowLayout布局：是将其中的组件按照加入的先后顺序从左到右排列，一行排满之后就另起一行继续从左到右，每行中的组件都居中排列。FlowLayout是小应用程序的默认布局。可用超类Container的方法setLayout()加容器设定布局。如，setLayout(new FlowLayout())。（P97）
18.BorderLayout布局：是把容器内的空间简单的划分为东“East”、西“West”、南“South”、北“North”、中“Center”五个区域。BorderLayout是JWindow、JFrame、JDialog的默认布局（P97）
19.GridLayout布局：是把容器划分成若干行和列的网格状，行数和列数由程序控制，组件放在网格的小格子中。其布局特点是组件定位比较精确。（P98）
20.CardLayout布局：其容器可容纳多个组件，但是多个组件拥有同一个显示空间，某一时刻只能显示一个组件。（P100）
21.null空布局是把一个容器的布局设置为null布局。空布局采用 setBounds()方法设置组件本身的大小和在容器中的位置。（P101）
二、语法点
1.P90 例5.2 创建JFrame窗口
2.按钮处理程序的基本内容为（P92） P93 例5.3 处理按钮事件实例
3.面板处理程序的基本内容为（P94） P95 例5.4
4.BorderLayout布局 P97 例5.5
5.GridLayout布局 P98 例5.6
6.文本框（JTextField） P103 例5.8
7.文本区（JTextArea）P105 例5.9、5.10
第六章 图形界面设计（二）
一、出题点
1.Java为处理鼠标事件提供两个接口：MouseListener和MouseMotionListener接口。（P127）
2.MouseListener接口能处理5种鼠标事件：按下、释放、点击鼠标、鼠标进入、退出。（P127）
3.MouseMotionListener接口能处理2种鼠标事件：拖动鼠标、鼠标移动（P130）
4.键盘事件的接口是KeyListener，注册键盘事件监视器的方法是addKeyListener。实现KeyListener接口的方法有3个:keyPressed(KeyEvent e),键盘上某个键被按下；keyReleased(KeyEvent e),键盘上某个键被按下,又释放；keyTyped(KeyEvent e),keyPressed和keyReleased两种方法的组合；
二、语法点
1.选择框（JCheckbox）及单选框 P112 例6.2
复选框（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 ItemSelectable getItemSelectable( ) // 返回当前事件的事件源
2.单选按钮（JRadioButton）
需使用ButtonGroup 分组
3.列表（JList） P115 例6.3
列表(JList)在界面中表现为列表框，是JList类或它的子类的对象。程序可以在列表框中加入多个文本选择项条目。列
表事件的事件源有两种：一是鼠标双击某个选项，二是鼠标单击某个选项。
双击选项是动作事件，与该事件相关的接口是ActionListener，注册监视器的方法是addActionListener()，接口方法是
actionPerformed(ActionEvent e)。
单击选项是选项事件，与选项事件相关的接口是ListSelectionListener,注册监视器的方法是
addListSelectionListener,接口方法是valueChanged(ListSelectionEvent e)。
4.组合框（JComboBox） P117 例6.4
在JComboBox对象上发生事件分为两类。
一是用户选定项目，事件响应程序获取用户所选的项目。二是用户输入项目后按回车键，事件响应程序读取用户的输入。 第一类事件的接口是ItemListener;第二类事件是输入事件，接口是ActionListener。
5.菜单条（JMenuBar）、菜单（JMenu）、菜单项（JMenuItem） P119 例6.5
在窗口中增设菜单条，必须使用JFrame类中的setJMenuBar()方法。例如，代码：
setJMenuBar(menubar);
处理菜单事件
菜单的事件源是用鼠标点击某个菜单项。处理该事件的接口是ActionListener,要实现的接口方法是actionPerformed(ActionEvent e),获得事件源的方法getSource().
6.对话框（JDialog）P122 例6.6
强制型也称有模式对话框，非强制对话框也称非模式对话框
7.滚动条（JScrollBar） P126 例6.7
JScrollBar类对象的事件类型是AdjustmentEvent；类要实现的接口是AdjustmentListener,接口方法是
adjustmentValueChanged();注册监视器的方法是addAdjustmentListener();获取事件源对象的方法是getAdjustable().
8.鼠标事件 P128 例6.8 例6.9
要实现的MouseListener接口的方法有：
(1) mousePressed(MouseEvent e);
(2) mouseReleased(MouseEvent e);
(3) mouseEntered(MouseEvent e);
(4) mouseExited(MouseEvent e);
(5) mouseClicked(MouseEvent e);
MouseMotionListener接口处理拖动鼠标和鼠标移动两种事件。
注册监视器的方法是：
addMouseMotionListener(监视器)
要实现的的接口方法有两个：
(1) mouseDragged(MouseEvent e)
(2) mouseMoved(MouseEvent e)
9.键盘事件 P133 例6.10
键盘事件的接口是KeyListener， 注册键盘事件监视器的方法是addKeyListener(监视器)。 实现KeyListener接口有3个：
(1) keyPressed(KeyEvent e),键盘上某个键被按下。
(2) keyReleased(KeyEvent e),键盘上某个键被按下，又释放。
(3) keyTyped(KeyEvent e),keyPressed和keyReleased两个方法的组合。
管理键盘事件的类是KeyEvent，该类提供方法：
public int getKeyCode(),获得按动的键码，键码表在KeyEvent类中定义，参见附录E。
第七章 图形、图像与多媒体
一、出题点
1.在java.awt包中，类Graphics提供的功能有：建立字体、设定显示颜色、显示图像和文本，绘制和填充几何图形。（P137）
2.在某个组件中绘图，一般应该为这个组件所属的子类重写paint()方法，在该重写的方法中进行绘图。（P137）
3.绘图模式分为：正常模式，其方法为setPaintMode()和异或模式，其方法为setXORMode(Color e)。（P139）
4.Graphics类的绘图方法（P140）：
（1）画线段：drawLine(int x1,int y1,int x2,int y2) //在x1,y1的坐标点至x2,y2的坐标点之间画一条线。
（2）画矩形：drawRect(int x,int y,int width,int height)//在x,y该点上画一个宽width，高height的矩形。
（3）画三维矩形：draw3DRect(int x,int y,int width,int height，boolean raised)//在x,y该点上画一个宽width，高height的矩形。参数raised是突出与否。
（4）画椭圆形：drawOval(int x,int y,int width,int height)//在x,y该点上画一个横轴width，纵轴height的椭圆。或用fillOval(int x,int y,int width,int height)进行颜色填充。
（5）画圆弧（6）画多边形（7）擦除矩形块（8）限定图显示区域（9）复制图形
补． Graphics2D类的绘图方法
要用 Graphics2D 类的新方法画一个图形。先在重画方法 paintComponent()或 paint()中，(1)把参数对象 g 强制
换成 Graphics2D 对象；然后，(2)用上述图形类提供的静态方法 Double()创建该图形的对象；最后，(3)以图形对象为参数调用Graphics2D对象的draw()方法绘制这个图形。 例如以下代码用Graphics2D的新方法绘制线段：
Graphics2D g2d = (Graphics2D)g;//将对象g类型从Graphics转换成Graphics2D
Line2D line = new Line2D.Double(30.0,30.0,340.0,30.0);
g2d.draw(line);
5.在java程序中，图像也是对象，所以载入图像时，先要声明Image对象，然后利用getImage（）方法把Image对象与图像文件联系起来。方法有两个：（1）Image getImage(URL url)；（2）Image getImage(URL url,String name)。（P148）
6.程序要创建缓冲区图像，需要引入java.awt.image包中的BufferedImage类。要创建一个缓冲区图像，可以调用creatImage()方法，该方法返回一个Image对象，然后再将它转换成一个BufferedImage对象。（P152）
二、语法点
本章所有例点
第八章 多线程
一、出题点
1.进程与线程的异同（P159）
（1）进行是程序的一次执行过程，从代码加载、执行，直至完成的一个完整过程。线程是一个控制流，也是一个执行过程，但执行单位比进程小。
（2）两者的不同点是进程是一个实体，有自己的状态、专用数据段；而创建线程时不必建立新的数据段。其不是能够独立运行的程序，而只是某个进程内的一个执行流。
2.线程的生命周期：新建、就绪、运行、阻塞和死亡五种状态。（P159）
3.Java提供一个线程调度器来监视和控制就绪状态的线程，线程的调度策略采用抢占式，优先级高比低的先执行。在优先级相同的情况下按“先到先服务”的原则。线程优先级为1到10，数值越大优先级越高。（P160）
4.Java程序实现多线程应用有两种途径：（1）继承Thread类声明Thread子类，用Thread子类创建线程对象（2）在类中实现Runnable接口，在类中提供Runnable接口的run()方法。（P161）
5.在Java语言中，使用关键字synchronized定义临界段，能对共享对象的操作上锁。（P167）
6.为了实现同步，Java语言提供wait()、notify()、notifyAll()三个方法供线程在临界段中使用。用wait()方法使执行该方法的线程等待，并允许其他线程使用这个临界段。用notify()方法通知由于想使用这个临界段而处于等待的线程结束等待。若要使用其他早先等待的线程都可结束等待，重新竞争CPU，则使用notifyAll()方法。（P168）
二、语法点
本章所有例题
第九章 输入和输出流
一、出题点
1.Java语言采用流（stream）的机制实现输入和输出。实现输入/输出操作的类库在java.io包中（P175）
2.建立输入/输出流对象之前可以先建立一个File对象，File对象对应一个目录或文件，对象的属性包括文件路径、名字、文件长度、可否读写等。File对象只用来命名文件、查询文件属性和处理目录，不提供读写文件操作。（P175）
3.文件读写的主要操作包括：建立流对象、读数据、写数据和关闭流。
4.根据输入输出的类型是字节还是字符，java.io提供两种基本抽象类：一种用于读写字节，一种用于读写字符。
5.字节流用于读写二进制数据，比如图像和声音文件等。由InputStream类和OutputStream类为字节流提供API和部分实现。字节流读和写操作由FileInputStream类和FileOutputStream类提供支持。
6.字符流处理Unicode字符集中的任何字符，由Reader类和Writer类为字符流提供API和部分实现。读和写操作由FileReader类和FileWriter类提供支持。（P175）
7.程序要采用缓冲式输入，只要先创建FileReader对象，再利用FileReader对象创建BufferedReader对象。（P178）如：
file=new FileReader("abc.txt")；
in=new BufferedReader(file)；
8.BufferedWriter类是提供缓冲式输出的类，只要先创建FileWriter对象，再利用FileWriter对象创建BufferedWriter对象。（P179）
9.文件随机访问可利用RandomAccessFile类实现，该类创建的流既可以随机输出，也可以随机输入。（P180）
10.JFileChooser实现打开和保存文件对话框。（P182）
二、语法点
本章所有例题
第十章 网络与数据库编程基础
一、出题点
1.InetAddress类的对象用于存储IP地址和域名。（P190）
2.要接收和发送信息还需用URLConnection类，程序获得一个URLConnection对象，相当于完成对指定URL的一个HTTP连接。
3.JAVA语言在实现C/S模式中，套接字分为两类：在Server端，ServerSocket类支持底层的网络通信；在 Client端，Socket类支持网络的底层通信。（P193）
4.双方实现通信有流式socket和数据报式socket两种可选方式。
5.流式socket是有连接的通信，即TCP；数据报式socket是无连接的通信，即UDP。
6.JAVA程序与数据库连接方法有两种：（1）使用JDBC-ODBC桥接器与数据库连接（2）用纯JAVA的JDBC驱动程序实现与数据库连接。（P198）
7.编写访问数据库的JAVA程序还需要几个重要的类和接口（P201）：
（1）DriverManager类：处理驱动程序的加载和建立新数据库连接。
（2）Connection类：处理与特定数据库连接的类。
（3）Statement类：用于在指定的连接中处理SQL语句的类。数据库编程的要点是在程序中嵌入SQL命令。
（4）ResultSet类：执行SQL语句查询，并将查询结果存放在一个用ResultSet类声明的对象中。
8.数据库更新，利用Statement对象的executeUpdate()方法，执行SQL的update语句，实现数据表的修改；执行insert语句，实现记录的添加。
二、语法点
本章所有例题