min
二
a[i][j];
min_i=i;
)
if
(i==j II i+j==4) sum+=a[i][j];
1
System.6>wAprintln("最大值："+max+"位置：("+max_i+","+max_j+")");
System.6>wAprintln("最小值："+min+"位置：("+min_i+","+min_j+")”);
ntln("主副对角线和:"+sum);
1
【习题5】
一、 选择题
D C A B
二、 填空题
1、继承性多态性
2、 类的成员变量
3、 类的成员方法
4、 构造方法
三、简答题
1、 什么是类？什么是对象？
答：对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。类是相同 属性和行为的一组对象的集合。类是对象的模板，即类是对一组有相同数据和相同操作的对 象的定义，一个类所包含的方法和数据描述一组对象的共同属性和行为。
2、 简述声明类的语法格式。
答：声明类的语法格式如下：
［类修饰符］class类名［extends基类］［implements接口列表］{
［成员变量声明］
［构造方法定义］
［成员方法定义］
}
说明：
类修饰符［可选］:用于规定类的一些特殊性，比如访问控制、抽象类等。
类名：类的名字，类名一般首字母用大写，其余用小写，如果类名由多个单词组成，则 从每个单词的首字母大写。
extends基类：表示新类由父类派生，Java中只支持单继承。
implements接口列表：表示实现接口。因Java中支持单继承，但可以实现多个接口， 为多重继承软件开发提供方便。
类体：用花括号括起，类体中可有成员变量声明、构造方法定义和成员方法定义。
3、 简述Java类成员的访问控制。
答：
访问控制符
private
同一个类中
可以访问
可以访问
可以访问
同一个包中
X
不同包的子类
X
X
不同包的非子类
X
X
X
default（缺省） 可以访问
protected
public
可以访问
可以访问
可以访问
可以访问
可以访问 可以访问
4、包的作用是什么，如果创建包，导入包？
答：包是类、接口和其他包的集合，建包的目的是有效区分名字相同的类，不同Java源文 件中的两个类名字相同时，它们可以通过隶属不同的包来区分。
包的声明格式：
package
包名；
若类的访问权限是public,则其他包的类可以引用该类，但引用前需导入包，导包的语 句是：
import包名.类名；
四、编程题
1、定义一个复数类Complex,复数的实部real与虚部image定义为私有数据成员。定义getters
和setters方法访问私有数据成员，再定义构造方法对实部与虚部进行初始化，定义公有成 员方法show。显示复数值。
public class
Complex (
private int
real;
private int
image;
public int
getReal() (
return
real;
1
public
void setReal(int real) (
= real;
1
public int
getlmage() (
return
image;
1
public void setlmage(int image) (
= image;
1
public
Complex()(
1
public
Complex(int real,
int
image) (
= real;
= image;
1
public void
show() (
System.＜?wAprintln(real+"+"+image+"i");
1
}
public class
ComplexTest (
public static void
main(String [] args) (
Complex cl = new Complex(5,6);
();
}
}
2、编写一个Book类，用于描述个人藏书，包含作者Author＞书名Title、价格Price＞出版 社Publisher＞出版年份Published Year五个属性。然后编写一个测试类BookTest,对Book
类进行测试，输出正确的属性值。
public class
Book (
〃作者、书名、价格、出版社、出版年份
private
String author;
private
String title;
private float
price;
private
String publisher;
private int
publishedYear;
public
String getAuthor() (
return
author;
1
public void
setAuthor(String author) (
= author;
public
String getTitle() (
return
title;
1
public void
setTitle(String title) ( = title;
1
public float
getPrice() (
return
price;
1
public void
setPrice(float price) ( = price;
1
public
String getPublisher() (
return
publisher;
1
public void
setPublisher(String publisher) ( her = publisher;
1
public int
getPublishedYear() (
return
publishedYear;
}
public void
setPublishedYear(int
publishedYear) ( hedY ear = publishedYear;
}
)
public class
BookTest (
public static void
main(String [] args) (
Book book =
new
Book();
//孙浏毅、Java宝典、98.00、电子工业出版社、2009 book, set Author("孙浏毅”)；
le("Java
宝典")；
ce(98.00F);
lisher("电子工业出版社，
book. setPublishedY ear(2009);
System.。"，.printing
图书的信息是
Sy printin("作 者:"+book. getAuthor());
Sy . println("书名:"+book. getT itle());
Sy stem.。"，.printing
价格:"+ce());
System.。"，.printing
出版社:"+lisher());
System.。"，.printing
出版年份:"+lishedY ear());
3、编写一个UnitConversion类，封装一些常用的单位转换算法，其中两个单位转换是英寸 和厘米的转换，另一个是摄氏温度和华氏温度的转换(转换公式请自行查找资料)。要求该 类象Math类一样不可被继承，也不可被实例化。然后编写一个测试类UnitConversionTest,
测试UnitConversion类是否能够正常工作。
final public class
UnitConversion (
private
UnitConversion() (
1
final public static float f2C(float
f) (
return
(f-32)/1.8F;
1
final public static float c2F(float c) (
return
c * 1.8F + 32.0F;
1
final public static
float inch2Cm(float inch) (
return
inch * 2.54F;
1
final public static float cm2Inch(float cm) (
return
cm / 2.54F;
1
}
public class
UnitConversionTest (
public static void
main(String [] args) (
System.6>wAprintln("37
摄氏度="+
UnitConversion.c2F(37) +
”华氏度”);
ntln(" 100
华氏度="+
UnitConversion.^ C( 100) +
"摄氏度");
Sy stem.。"，.printing 10
厘米="+
UnitConversion. 10) +
”英寸，
Sy stem.。"，.printing 10
英寸="+
UnitConversion. znc/z2Cm( 10) +
"厘米”);
1
【习题6】
一、 选择题
B C C A AEF
二、 填空题
1、 编译时多态性（静态多态）运行时多态（动态多态）
2、 可扩充性接口性
3、 最终类
三、 简答题
1、简述继承的声明格式。
答：类的继承语法格式如下：
［类修饰符］class类名［extends基类］［implements接口列表］｛
［成员变量声明］
［构造方法定义］
［成员方法定义］
说明：
（1）
（2）
（3）
（4）
（5）
类修饰符同类的声明，如public, default（缺省）。
类名必须符合标识符命名规则。
extends是关键字。
基类，可以是自定义的类，也可以是系统类库中的类。如果省略基类，其默认的基
子类可以添加新的成员变量和成员方法，可以隐藏基类的成员变量或者覆盖基类的
类是
类。
成员方法。
（7）类之间的继承具有传递性。
2、 简述类的继承规则。
答：根据继承规则，子类可以继承父类的成员变量和成员方法，还可以增加自己的成员变量。 如果子类声明了与父类同名的成员变量，则在子类中父类的成员变量被隐藏。
子类可以继承父类的方法，还可以增加自己的成员方法。子类对象可以使用从父类继 承过来的方法。方法重写（或覆盖）是指子类重新定义从父类继承过来的方法，从而使子类 具有自己的行为，满足自己的需要。如果子类定义了与父类同名的成员方法，则在子类中父 类的成员方法被覆盖。子类不再继承父类的方法，即子类中不再存在父类的同名方法。
3、 分别解释关键字super与this的用法。
答：this代表了当前对象的一个引用，可将其理解为对象的另一个名字，通过这个名字可以 顺利地访问对象、修改对象的数据成员、调用对象的方法。this有以下三种使用场合：
（1）
访问当前对象的数据成员，使用形式如下：
this.数据成员
（2）
访问当前对象的成员方法，使用形式如下：
this.成员方法
（3）
当有重载的构造方法时，来引用同类的其他构造方法，使用形式如下：
this（参数）;
super表示当前对象直接父类的对象，是当前对象直接父类对象的引用。super有以下三种使 用场合：
（1）
用来访问直接父类中被隐藏的数据成员，使用形式如下：
s叩er.数据成员
（2）
用来调用直接父类中被重写的成员方法，使用形式如下：
super.成员方法
（3）
用来调用直接父类的构造方法，使用形式如下：
super
（参数）;
4、 简述抽象类的声明格式。
答：声明抽象类的格式与声明类的格式相同，要用abstract修饰符指明它是一个抽象类：
［public］ abstract class
类名［extends
基类［［implements
接口列表］｛
［成员变量声明］
［构造方法定义］
［成员方法定义］
）
说明：
public［可选］:抽象类默认不是public的，通常声明为public的。
抽象类必须要有abstract修饰符。
抽象类不能被实例化。
5、 简述类对象之间的类型转换规则。
答：类对象之间的类型转换是指父类对象与子类对象之间在一定条件下的相互转换。转换规 则如下：
（1）
子类对象可以隐式，也可以显式的转换为父类对象。
>
>
>
父类对象获得子类对象，不能操作子类新增的成员变量，不能使用子类新增的成 员方法。
父类对象获得子类对象，可以操作子类继承或重写的成员变量和成员方法。
如果子类重写了父类的某个方法，若父类对象获得子类对象会调用这个重写的方 法。
（3）
父类对象在一定的条件下可以转换成子类对象，但必须使用强制类型转换。
（2）
处于相同类层次的类的对象不能进行转换。
>
>
子类对象可以操作父类及子类的成员变量和成员方法。
子类对象访问父类重写方法时，访问的是子类中的方法。
子类对象接收父类对象，必须进行类型强制转换且必须保证父类对象引用的是该子类的对 象，如果引用父类或其他子类的对象，会抛出类型不匹配异常。
6、 简述抽象类和接口的区别。
答：
表抽象类与接口的区别
抽象类
不能省略abstract修饰符
抽象类的子类继承（extends）抽象类，单继承
单继承
除抽象方法外，有成员变量，也可以有普通方法
实现代码的复用
省略abstract修饰符
接口
abstract修饰符
子类和实现类
继承
变量和方法
复用
接口的实现类实现（implements）接口，多实现
多继承
只能有抽象方法，以及静态常量
不能实现代码的复用
四、编程题
1、假设银行Bank已经有按整年计算利息的一般方法，其中year只能取整数，比如按整年 计算方法为：year*0.035*savedMoney。
建设银行ConstructionBank和大连银行BankOfDalian是Bank的子类，隐藏继承的成员变量
year,并重写计算利息的方法，即声明一个double型的变量year。比如，当year取值为5.216
时，表示计算5年216天的利息。建设银行或大连银行把5.216的整数部分赋给隐藏的year,
并用super调用Bank的计算利息的方法，求出5年的利息，再按自己的方法计算216天的 利息。建设银行计算日利息的方法：day*0.0001 *savedMoney,大连银行计算日利息的方法:
day*0.00012*savedMoneyo
测试类，求8000元存5年236天两银行的利息差额。
Bank
类属性：savedMoney、year、interest> interestRate=0.035
Bank
类方法：computerinterest
public class
Bank （
int
savedMoney;
int
year;
double
interest;
double
interestRate = 0.035;
public double
computelnterest（） （
interest = year * interestRate* savedMoney;
return
interest;
public void setInterestRate(double interestRate) ( stRate = interestRate;
}
}
public class
ConstructionBank
extends
Bank (
double
year;
public double
computelnterest() (
= (int)year;
double
r = year - (int)year;
int day = (int)(r*1000);
double
yearinterest =
elnterest();
double
daylnterest = day*0.0001 *savedMoney;
interest = yearlnterest+daylnterest;
System.o〃，.println(savedMoney+"元存在建设银行"++"年零"+day+"天的利息:
"+interest+n
元”)；
return
interest;
}
}
public class
BankOfDalian
extends
Bank (
double
year;
public double
computelnterest() (
= (int)year;
double
r = year - (int)year;
int day = (int)(r*1000);
double
yearinterest =
elnterest();
double
daylnterest = day*0.00012*savedMoney;
interest = yearlnterest+daylnterest;
System.o〃，.println(savedMoney+"元存在大连银行"++n
年零"+day+"天的利息:
"+interest+n
元”)；
return
interest;
}
}
public class
SaveMoney (
public static void
main(String [] args) (
int
amount=8000;
ConstructionB ank bank_c =
new
ConstructionB ank();
bank_c. savedMoney = amount;
bank_ = 5.236;
bank_c. setInterestRate(0.035);
double
interest_c=bank_elnterest();
BankOfDalian bank_d =
new
BankOfDalian();
bank_d. savedMoney = amount;
bank_
二
5.236;
bank_d. setInterestRate(0.035);
double
interest_d=bank_elnterest();
System.。"，.printing
两个银行利息相差"+(interest_c-interest_d)+"元，
}
2、(1)定义动物类Animal,在类中定义属性和方法:
•
私有属性sex,表示性别，数据类型为boolean；
•
私有属性age,表示年龄，数据类型为int；
•
属性的getters和setters方法；
在类的构造方法中设置性别初始值为false；
公有方法IntroduceQ,用于介绍动物：
I)
若字段sex属性的值为true,方法返回一个字符串"This is a male Animal!"；
II)
若字段sex属性的值为false,则方法返回一个字符串"This is a female Animal!"
o
(2)
由基类Animal创建派生类Dog,在派生类中实现方法重写。
•
创建公有类Dog,它是从基类Animal中派生出的；
•
在类Dog的构造方法中，设置属性sex的初始值为true；
•
在类Dog中重写基类Animal的方法Introduce：
I)
若属性Sex的值为true,方法返回一个字符串"This is a male Dog!"；
II)
若属性Sex的值为false,则方法返回一个字符串”This is a female Dog!%
(3)
定义测试类AnimalTest,在程序主方法中实例化类的对象，调用方法输出介绍动物的 字符串：
•
实例化Animal的一个对象ani,调用类的方法Introduce(),并输出方法返回的字符串；
•
实例化Dog的一个对象dog,调用类的方法Introduce(),并输出方法返回的字符串。
•
•
public class
Animal (
private boolean
sex;
private int
age;
public boolean
getSex() (
return
sex;
}
public void setSex(boolean sex) (
this,
sex = sex;
1
public int
getAge() (
return
age;
}
public void
setAge(int age) (
= age;
1
public
Animal()(
sex
= false;
1
public void
Introduce()(
if
(sex ==
true)
System.(?M?.println("This is a male Animal!");
?.println("This is a female Animal!");
}
}
public class
Dog
extends
Animal (
public
Dog()(
setSex(true);
1
public void
Introduce() (
if
(getSex() ==
true)
?.println("This is a male Dog!");
else
System.^n("This is a female Dog!");
public class
Test Animal (
public static void
main(String [] args) (
Animal ani =
new
Animal();
uce();
Dog dog=new Dog();
uce();
1
}
3、要求设计abstract类，类名为Employee,类内有抽象方法earning(),功能是计算工资。
Employee
的子类有
YearWorker> Month Worker > WeekWorkero Year Worker
对象按年领取薪 水，每年年薪6万，Month Worker按月领取薪水，每月3000元，Week Worker按周领取薪 水，每周500元。有一个Company类，该类有两个属性，一个是用Employee数组作为属性， 存放所有的员工，一个是salaries属性，存放该公司每年该支付的总薪水，paySalaries方法 能计算一年需支付的薪水总额。测试类定义29名员工，员工编号0-28,能被3整除的员工 为Week Worker,除3余数为1的是Month Worker,除3余数为2的是YearWorker,测试类 输出该公司支付总金额。
public abstract class
Employee (
public abstract double
eaming();
)
public class
Year Worker
extends
Employee (
public double
eaming() (
return
60000;
}
)
public class
Month Worker
extends
Employee (
public double
eaming() (
return
12*3000;
}
)
public class
WeekWorker
extends
Employee (
public double
eaming() (
return
52*500;
}
)
public class
Company (
Employee[] e;
double
salaries = 0;
public
Company (Employ ee[] e) (
this.e = e;
}
public double
paySalaries()(
for (int
i=O;i<;i++)
salaries = salaries + e[i].eaming();
return
salaries;
1
}
public class
TestSalary (
public static void
main(String[] args) (
Employee[] e =
new
Employee[29];
int
i;
for
(i=O;i<;i++) (
if(i%3==0)
e[i] =
new
WeekWorker();
else if(i%3==l)
e[i] =
new
MonthW orker();
else
e[i] =
new
YearWorker();
)
Company company =
new
Company(e);
Sy stem, owA println(company .pay S alaries());
1
}
4、(1)编写
DogState
接口，接口中有
showState
方法。
(2)
(3)
编写若干个实现DogState接口的类，负责刻画小狗的各种状态。meetEnemyState(狂叫)、
编写Dog类，有DogState定义的属性state,有show方法，在该方法中回调showState
方meetFriendState(晃动尾巴)、meetAnotherDog(嬉戏)、SoftlyState(听主人命令)。
法。
(4)
编写测试类，测试小狗的各种状态。
public interface
DogState (
void
showState();
}
public class
meetEnemyState
implements
DogState(
public void
showState() (
Sy stem.。"，.printing
狂叫”)；
1
}
public class
meetFriendState
implements
DogState (
public void
showState() (
System.。"，.printing
晃动尾 巴”)；
1
}
public class
meetAnotherDog
implements
DogState (
public void
showState() (
System.。"，.printing
嬉戏”)；
public class
SoftlyState
implements
DogState(
public void
showState() (
Sy stem.。"，.printin("听主人命令”)；
1
}
public class
Dogl (
DogState state;
public void
show()( ate();
1
public void
setState(DogState state) (
this,
state = state;
1
}
public class
TestDog (
public static void
main(String [] args) (
Dogl yellowDog =
new
Dogl();
Sy stem.。"，.printing
狗遇到敌人:");
yellowDog. setState(new meetEnemyState()); yellowDog.
show();
Sy stem.。"，.printing
狗遇到同伴：");
yellowDog. setState(new meetAnotherDogO); yellowDog.
show();
Sy stem.。"，.printing
狗遇到朋友:");
yellowDog. setState(new meetFriendState()); yellowDog.
show();
ntln("狗在主人面前:");
te(new SoftlyState()); yellowDog. show();
1
【习题7】
一、 选择题
C B B A C
二、 填空题
1、 集(Set)列表(List)
2、 映射(Map)
3、
Iterator
4、
LinkedList ArrayList
5、
HastSet TreeSet
三、 简答题
1、 简述集合容器的分类。
答：集合容器类共分为两类，分别是：
•
集合(Collection):
一个集合就是存储一组对象的容器，Java集合框架支持集(Set)
和列表
(List)两种类型的集合。
■
■
•
Set(集)：集合中的对象(也称为元素element)没有次序之分，且没有重复对象。
List(列表)：集合中的对象按照索引位置排序，可以有重复对象，可以按索引 位置检索对象。
映射(Map):集合中的每个对象都由一个特殊的“键-值”对组成。键对象不能重 复，值对象可以重复。
2、 简述Iterator接口中主要方法。
答：Iterator接口中主要方法有：
•
•
•
boolean hasNextQ:判断是否存在另一个可以访问的元素
Object next():返回下一个可以访问的元素。通常与hasNext()方法结合使用，以免 产生异常。
void removeQ:删除上次访问返回的对象。
3、 简述Set接口和List接口的差异。
答：Set接口继承Collection接口，与List接口比较相似，但又有两个典型差异，分别是：
•
•
Set中不保存重复的元素(List中可以有重复元素)
Set中不能保证元素顺序信息(List中的元素顺序是确定的)
四、 编程题
1、创建一个book包，里面包含第5章编写的Book类，设计一个管理个人藏书的IMyBook
接口，包含添加藏书、根据书名查找藏书、根据作者查找藏书、计算藏书总数和计算藏书总 金额的抽象方法。分别用List、Set、Map3种接口编写MyBookList>MyBookSet和MyBookMap
类管理Book类，实现IMyBook中的抽象方法。编写BookTest类进行测试。
package
;
import
;
import
;
public interface
IMyBook (
public void
add(Book book);
public
Book findByTitle(String title);
public
List findByAuthor(String author);
public float
totalAmount();
public int
bookCount();
)
package
;
import
List;
import
;
import
;
public class
MyBookList
implements
IMyBook (
private
List bookList =
new
LinkedList();
public void
add(Book book) ( (book);
1
public
Book findByTitle(String title) (
for(Book b: bookList) (
if(le().equals(title)) (
return
b;
1
)
return null;
1
public
List findByAuthor(String author) ( List list =
new
LinkedList();
for(Book b: bookList) (
if(hor().equals(author))(
(b);
1
)
return
list;
1
public float
totalAmount() (
float
sum=0;
for(Book b: bookList) (
sum += ce();
}
return
sum;
}
public int
bookCount() (
return
bookList size();
1
)
package
;
import
p;
import
List;
import
;
import
;
import
;
public class
MyBookMap
implements
IMyBook (
private
Map bookMap =
new
HashMap();
public void
add(Book book) (
(le(),book);
public
Book findByTitle(String title) ( return((title));
1
public
List findByAuthor(String author) ( List list =
new
LinkedList();
for(Book b : ()) (
if(hor().equals(author))( (b);
1
)
return
list;
1
public float
totalAmount() (
float
sum=0;
for(Book b : ()) ( sum += ce();
)
return
sum;
1
public int
bookCount() (
return
();
}
}
package
;
import
t;
import
List;
import
;
import
;
import
;
public class MyBookSet
implements
IMyBook (
private
Set bookSet =
new
HashSet();
public void
add(Book book) (
bookSet. add(book);
1
public
Book findByTitle(String title) (
for(Book b:bookSet)(
if(le().equals(title)) (
return
b;
1
return null;
public
List findByAuthor(String author) ( List list =
new
LinkedList();
for(Book b:bookSet)(
if(hor().equals(author))( (b);
1
)
return
list;
1
public float
totalAmount() (
float
sum=0;
for(Book b:bookSet)(
sum += ce();
)
return
sum;
1
public int
bookCount() (
return
bookSet. size();
1
)
package
;
import
;
import
;
public class
BookTest (
public static void
main(String [] args) (
//孙浏毅、Java宝典、98.00、电子工业出版社、2009
IMyBook my Book =
new
MyBookMapO;
Book book =
new
Book();
book, set Author("孙浏毅，
le("Java
宝典")；
ce(98.00F);
lisher("电子工业出版社，
book. setPublished Y ear(2009);
(book);
book =
new
Book();
book, set Author("孙浏毅，
le("Java
宝典(第二版)，
ce(198.00F);
lisher("电子工业出版社”);
lishedY ear(2009);
my Book, add(book);
book = new Book();
hor("黄能耿”)；
le(”Java语言程序设计及实训，
book. setPrice(28. OOF);
lisher("机械工业出版社”)；
lishedY ear(2009);
myBook. add(book);
//以下进行测试
Sy stem.。"，.printing
图书总数:")；
System.(?n(unt());
ntln("n
图书总金额;
n(mount());
System.。以.println("n查找《Java语言程序设计》
p
汕必。oA(Title(" Java
语言程序设计"))；
System.。必println("n查找《Java语言程序设计及实训》
p
〃加R?oA(Title("Java
语言程序设计及实训"));
System.6)n("n
查找“孙浏毅”的书;
List list = Author("孙浏毅")；
for(Book b: list)(
printBookQS)
static void
printBook(Book book) (
/.println("n
图书的信息是:")；
if(book==null)(
System. owprintln("无结果.”)；
return;
}
System.。”/,
printing
作者:"+hor());
Sy stem.。必.printing
书名:"+le());
Sy stem.。"，.printing'价格:"+ce());
System.。”/,
printing
出版社:"+lisher());
System. o“£.println("出版年份:"+lishedY ear());
【习题8】
一、 选择题
D C A A C B C C
二、 填空题
1、 异常(Exception)
2、
Throwable
3、
Error Exception
4、
Java虚拟机
5、
Java编译器
6、 出现异常对象的类
7、
finally
8、 抛出异常
9、 自定义的异常
10、 运行
异常处理
三、 简答题
1、 异常处理的方式有哪两种？
答：(1)捕获异常：程序运行过程中，当一个异常被抛出时，识别这个被抛出的异常对象并 查找处理它的方法的过程。
(2)使用throws声明抛出异常：若在声明一个方法时，该方法可能会发生异常，但又 不想在当前方法中来处理这个异常，那么可以将该异常抛出，然后在调用该方法的代码中捕 获该异常并进行处理。
2、 简述创建用户自定义异常的步骤。
答：自定义异常类的使用分为三个步骤，分别是：
(1)
创建自定义异常类；
(2)
在出现异常处抛出异常，所在的方法需要声明抛出异常；
(3)
在处理异常处捕获并处理异常。
四、 编程题
1、对下述代码进行异常处理。
public class
ExceptionDemo (
public static void
main(String [] args) (
int
a=2,b=0;
ntln("This is an exception. " + a/b);
ntln("Finished");
答:
public class
ExceptionDemo (
public static void
main(String[] args) (
try{
int
a=2,b=0;
?.println("This is an exception. " + a/b);
} catch(Exception e)(
?.println(sage());
)
System. o〃，.println("Finished");
1
}
2、(1)创建
AgeException
异常类。
(2)
创建Example类，在Example类中创建一个readAge()方法，该方法用于从键盘处获取
年龄并检查年龄是否在18〜22岁之间，若超出该范围，则抛出AgeException异常。
(3)
在主程序中捕获自定义异常，并作相应处理。
public class
AgeException
extends
Exception}
public
AgeException(String msg) (
super(msg);
1
}
import
r;
public class
Example (
public static int
readAge()
throws
AgeException (
Scanner sc =
new
Scanner(System.m);
System.6>wAprint("请输入年龄：”)；
〃声明抛出自定义异常
int
i = t();
if(i< 18) (
throw new
AgeException("年龄不能小于18岁。，〃抛出自定义异常
)
if
(i>22) (
throw new
AgeException("年龄不能大于22岁。，〃抛出自定义异常
)
return
i;
1
)
public class
Test Age (
public static void
main(String [] args) (
int
i = -1;
try {
i = Example.*泌4ge();
Sy stem.。如.println(i);
} catch
(AgeException e) (
?.println(sage());
【习题9】
一、 选择题
C C A B C
二、 填空题
1、 流
2、 输入流 输出流
3、 字节流 字符流
4、
in out err
三、 简答题
1、什么是输入/输出流？字节流和字符流有什么区别？
答：根据数据流的方向，可以将流分为输入流和输出流。我们可以将数据流想象成水流，一 条管道连接了内存和外设（磁盘文件或打印机），数据就象管道中的水流。从其他设备读取 数据，此时流入内存的数据序列就是输入流；从内存写入数据到外部设备的数据序列出就是 输出流。
根据数据流中处理的数据，可以将流分为字节流和字符流，其中字节流用来处理没有进 行加工的原始数据（即二进制字节数据），字符流是经过编码的符合某种格式规定的数据（即 文本文件数据）。
2＞过滤流BufferedlnputStream类与字节流FilelnputStream类的关系是什么？
答：FilelnputStream类和FileOutputStream类读写数据是以字节为单位进行的，文件流的利 用率不高，而BufferedlnputStream类和BufferedOutputStream类在字节输入/输出流的基础上 实现了带缓冲的过滤流，采用一个内部缓冲区数组缓存数据，从而提高磁盘的读写速度。
3、对象串行化的作用是什么？对象串行化是如何实现的？
答：使用对象输入输出流实现对象序列化，可以直接存取对象，将对象存入一个数据流称为 对象的串行化（Serialization,也称序列化），而从一个数据流将对象读出来的过程被称为反串 行化。
串行化和反串行化的过程包括：
（1）
声明可串行化的类
通过实现包的Serializable接口，声明一个类的实例是可串行化的。Serializable
接口中没有定义任何方法，它的作用仅仅是一个标识，用于标识实现了该接口的类的实例是 可以被串行化的。
（2）
串行化对象
串行化一个对象，必须要与一定的输入/输出流相连，通过输出流对象，将对象的当前 在状态保存下来，然后可以通过输入流对象将对象的数据进行恢复。在包中，提供 了专门的保存和读取串行化对象的类，分别为ObjectlnputStream类和ObjectOutputStream类。 使用ObjectOutputStream类的writeObject。方法实现对象的串行化，即直接将对象信息保存 到输出流中，使用ObjectlnputStream类的ReadObject（）方法可以实现对象的反串行化。
四、 编程题
1、d:这个文件是一篇英文短文，编写一个程序，统计该文件中英文字母的个数， 并将其写入另一个文本文件中。
import
tFoundException;
import
ader;
import
ption;
public class
Ex9_l {
public static void
main(String [] args) (
FileReader fr =
null;
char
c;
int
ch = 0;
try {
fr = new
FileReader("d:/");
int
b;
while
((b=())!=-1) (
c=(char)b;
if
(c>=*a' && c<='z' || c>=*A' && c<='Z')(
ch++;
)
1
} catch
(FileNotFoundException e) (
System.。以
printing
文件不存在! ”)；
} catch
(lOException e) (
tln(”输入输出异常！")；
)finally (
try (
();
} catch
(lOException e) (
System.o“n(”输入输出异常!");
}
}
System.。"，.printing英文字母个数:"+ch);
}
}
2、定义学生类，包含学生的基本信息(包括学号、姓名和考试成绩)，键盘接收学生信息, 并将学生信息保存到文件中。
import
izable;
public class
Student
implements
Serializable (
private
String id;
private
String name;
private int
score;
public
String getld() (
return
id;
1
public void
setId(String id) (
= id;
public
String getName() (
return
name;
1
public void
setName(String name) ( = name;
1
public int
getScore() (
return
score;
1
public void
setScore(int score) ( = score;
1
public
Student(String id, String name,
int
score) ( = id;
= name;
= score;
1
)
import
edWriter;
import
putStream;
import
tputStream;
import
iter;
import
ption;
import
lnputStream;
import
OutputStream;
import
r;
public class
StudentScore (
public static void
main(String [] args) (
String id, name;
int
score;
Scanner sc =
new
Scanner(System.m);
System.。"，.printing请输入学号:");
id = ();
System.。"，.printing请输入姓名:");
name = ();
Sy stem.。"，.printin("请输入成绩:'*);
score = t();
Student s =
new
Student(id, name, score);
try {
FileOutputStream fw =
new
FileOutputStream("D:/");
ObjectOutputStream oos =
new
ObjectOutputStream(fw);
oos. writeObj ect(s);
();
FilelnputStream fr =
new
FilelnputStream("D:/");
ObjectlnputStream ois =
new
ObjectlnputStream(fr);
Student si = (Student) ject();
?.println(sl .getld() +
+ re());
();
+ e() +
} catch
(lOException e) (
n("输入输出异常！");
} catch
(ClassNotFoundException e) (
?.println("类不存在!");
【习题10】
一、选择题
C D AC ABC D
、填空题
1、
2AWT
顶层容器
中间容器
BorderLayout GridLayout
、
FlowLayout
3单行文本框
、
列表框JList
三、简答题
口令框 文本框
1、 简述GUI界面设计的步骤。
答：1、创建顶层容器窗体，作为放置其他组件的容器；
2、 创建要放置在窗体上的各个组件；
3、 将各个组件添加到容器上（可使用布局管理器来管理位置）；
4、 处理事件响应，本例处理的是窗体关闭事件；
5、 设置顶层容器组件大小；
6、 使顶层容器组件可见。
2、 什么是容器组件？ Java中容器有哪些？
答：容器的主要作用是包容其他组件，并按一定的方式组织排列它们。Java中的容器主要分 为顶层容器和中间容器。顶层容器是进行图形编程的基础，可以在其中放置若干中间容器或 组件。在Swing中，有以下4中顶层容器：JWindow、JFrame JDialog和J Applet □中间容 器专门专门放置其他组件，介于顶层容器和普通Swing组件中间的容器。常用的中间容器 有：JPanel、JOptionPane、JMenuBar、JToolBar、JTabbedPane
等。
3、 什么是布局管理？ Java提供了哪几种布局？各有什么作用？
答：布局管理器负责控制组件在容器中的布局。Java语言提供了多种布局管理器，主要有：
FlowLayout、BorderLayout> GridLayout
等。
FlowLayout称为流式布局管理器。在这种布局管理器中，组件一个接一个从左往右、 从上到下一排一排地依次放在容器中。FlowLayout默认为居中对齐。当容器尺寸发生变化 时，组件大小不会变，但组件在容器中的位置会发生相应的变化。
BorderLayout称为边界布局管理器。这种布局管理器将容器版面分为5个区域：北区、 南区、东区、西区和中区，遵循“上北下南、左西右东”的规律。5个区域可以用5个常量
NORTH, SOUTH, EAST、WEST和CENTER来表示。当容器的尺寸变化时，组件的相对 位置不会改变，NORTH和SOUTH组件高度不变，宽度改变，EAST和WEST组件宽度不 变、高度改变，中间组件尺寸变化。
GridLayout称为网格布局管理器。这种布局管理器通过设置行列将容器划分成大小相同 的规则网格。添加组件是按照“先行后列”的顺序依次添加。当容器尺寸发生变化时，组件 的相对位置不变，大小变化。
4
、 简述Java的事件处理机制。
图1事件处理模型
编写事件处理的过程是（见图1）:
① 创建一个组件，并设置其有关属性，如显示的大小和位置等。
② 为该组件编写某种事件的监听器类（实现监听器接口或继承适配器），可以用外部类、 内部类或匿名类的形式。
③ 通过组件的addXXXListener（）注册监听器类的实例。如果采用匿名类的形式，监听器
的声明、创建和注册同时完成。
程序运行时，AWT处理事件的流程是（见图1）：
⑴用户与界面交互，执行一个操作。
⑵组件响应操作，产生一个事件对象。
⑶组件将事件对象传递给监听器。
⑷监听器根据事件的具体内容执行相应的操作。
四、编程题
1、编写加法程序：在两个文本框中输入两个数，点击“计算”按钮，计算之和显示在第三 个文本框中。
请输入两个教：|333 | + [T |=|339 一
|手和]
import
yout;
import
j ava. . ActionEvent;
import
j ava. . ActionListener;
import
n;
import
;
import
;
import
;
import
ield;
public class
AddDemo(
private
JFrame frame;
private
JLabel label 1;
private
JLabel addsign;
private
JLabel equalsign;
private
JTextField numl;
private
JTextField num2;
private
JTextField result;
private
JButton button;
private
JPanel panel 1;
private
JPanel panel2;
public
AddDemo() (
frame = new JFrame("求和")；
label 1 =
new
JLabel(n请输入两个数：");
addsign =
new
JLabel("+n);
equalsign =
new
JLabel("=");
button =
new
JButton("求和")；
numl =
new
JTextField(5);
num2 =
new
JTextField(5);
result=
new
JTextField(8);
panel 1 =
new
JPanel();
panel2 =
new
JPanel();
panel 1. add(labell);
panel 1 .add(numl);
panel 1 .add(addsign);
panel 1 .add(num2);
panel 1 .add(equalsign);
panel 1 .add(result);
panel2. add(button);
frame. setLayout(new FlowLayout());
frame, add(panell);
frame. add(panel2);
frame. /TLOALCLOSE);
frame. setSize(400,150);
frame. setVisible(true);
ionListener(new ActionListener() (
public void
actionPerformed(ActionEvent argO) (
int
number 1 ,number2,res;
number 1 = Integer .par5e7nZ(num 1 .getText());
number2
二
/〃，(t());
res = number 1 +number2;
t(res+"");
1
})；
1
public static void
main(String[] args) (
new
AddDemo();
1
2、用标签显示一道简单的测试题，答案使用单选按钮列出，用户选择答案后，会在另一个 标签中显示结果或说明。
图单选题
将GU圈口削分为东、西、南、北、中五个部分的布局管理器是：
I O FlowLayout O GridLayout Q CardLayout ® {BorderLayout
答案：D
import
yout;
import
ent;
import
j ava. awt. event. ItemListener;
import
j avax. swing. B uttonGroup;
import
n;
import
j avax. s wing. JFrame;
import
;
import
;
import
j avax. swing. JRadioB utton;
public class
Exl0_2 (
private
JFrame frame;
private
JLabel label 1;
private
JLabel label2;
JRadioB utton jbA;
JRadioB utton jbB;
JRadioB utton jbC;
JRadioButton jbD;
B uttonGroup bg;
private
JB utton button;
private
JPanel panel 1;
private
JPanel panel2;
private
JPanel panel3;
public
Exl0_2()(
frame
二
new
JFrame(n单选题”)；
labell = newJLabel(”将GUI窗口划分为东、西、南、北、中五个部分的布局管理器是：，
jbA = new
JRadioButton("FlowLayout");
jbB =
new
JRadioButton("GridLayout");
jbC =
new
JRadioButton("CardLayout");
jbD =
new
JRadioButton("BorderLayout");
bg =
new
ButtonGroupO;
(jbA);
(jbB);
(jbC);
(jbD);
Iabel2 =
new
JLabel();
panel 1 =
new
JPanel();
panel2 =
new
JPanel();
panel3 =
new
JPanel();
panel (labell);
(jbA);
(jbB);
(jbC);
(jbD);
panel3. add(label2);
frame. setLayout(new FlowLayout());
frame. add(panell);
frame. add(panel2);
(panel3);
frame. setDefaultCloseOperation(JFrame.£'X/7^OA/_C£OSE);
frame. setS ize(400,200);
frame, set V isible(true);
mListener(new ItemStateChanged());
jbB .addItemListener(new ItemStateChanged());
jbC. addltemListener(new
ItemStateChanged());
mListener(new ItemStateChanged());
}
class
ItemStateChanged
implements
ItemListener(
public void
itemStateChanged(ItemEvent argO) ( t(H答案：D”);
}
}
public static void
main(String [] args) (
new
Exl0_2();
}
【习题11】
一、选择题
A D D A D
二、 填空题
1、
JDBC
admin 管理员组
发表评论