Java语言程序设计(郑莉)
第二章习题答案
1.什么是对象、类，它们之间的联系？
答：1）对象是包含现实世界物体特征的抽象实体，它反映系统为之保存信息和与它交互的能力。
对象是一些属性及服务的封装体，在程序设计领域，可以用“对象=数据+作用于这些数据上的操作”来表示。
现实生活中对象是指客观世界的实体；在程序中对象是指一组变量和相关方法的集合。
2）类是既有相同操作功能和相同的数据格式的对象的集合与抽象！3）两者的关系：对象是类的具体实例.。
2.什么是面向对象的程序设计方法？它有那些基本特征？
答：面向对象程序设计从所处理的数据入手，以数据为中心而不是以服务为中心来描述系统。
它把编程问题视为一个数据集合，数据相对于功能而言，具有更强的稳定性。
它的特征：抽象，封装，继承，多态。
3（无用）
4．请解释类属性、实例属性及其区别。
答：实例属性，由一个个的实例用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。
5．请解释类方法、实例属性及其区别。
答：实例方法表示特定对象的行为，在声明时前面不加static修饰符，在使用时需要发送给一个类实例。
类方法也称为静态方法，在方法声明时前面需加static修饰符，类方法表示具体实例中类对象的共有行为。
区别：实例方法可以直接访问实例变量，调用实例方法，实例方法可以直接访问类变量，调用类方法；类方法可以直接调用类变量和类方法，类方法不能直接调用实例变量和实例方法；
6．类的访问控制符有哪几种？具体含义及其区别。
答：类的访问控制符只有public（公共类）及无修饰符（默认类）两种。
区别：当使用public修饰符时表示所有其他的类都可以使用此类；当没有修饰符时，则只有与此类处于同一包中的其他类可以使用类。
7类成员的访问控制符有哪几种?他们对类成员分别有哪些访问限制的作用?
答:类成员的访问控制符有 public,private,protecte及无修饰符.
public(公有的):用public修饰的成分表示公有的,也就是它可以被其他任何对象访问(前提是对累成员所在的类访问有访问权限).
Private(保护的)：类中限定为private的成员只能被这个类本身
访问，在类外不可见。
proteced（保护的）用该关键字修饰的成分是受保护的，只可以被同一类及其子类的实例对象访问。
无修饰符（默认的）：public，private，protected这个三个限定符不是必须写的。
如果不写，则表明是“friendly”，相应的成分可以被所在保重的各类访问。
8简述构造方法的特点?答：构造方法主要有以下特点：
（1）构造方法的方法名与类名相同；
（2）构造方法没有返回类型（修饰符void也不能有）；（3）构造方法通常被声明为公有的（public）；
（4）构造方法可以有任意多个参数；
（5）构造方法的主要作用是完成对象的初始化工作；
（6）构造方法不能在程序中显式的调用；
（7）在生成一个对象时，系统会自动调用该类的构造方法为新生成的对象初始化。
9如果在类声明中声明了构造方法,系统是否还提供默认的构造方法?
答：
用户在进行类声明时，如果没有声明任何构造方法，系统会赋给此类一个默认（无参）的构造方法。
但是，只要用户声明了构造方法，即使没有声明无参的构造方法，系统也不会再赋默认的构造方法。
10：声明Patient类表示在门诊室中的病人。
此类对象应包括ｎａｍｅ（ａｓｔｒｉｎｇ）＼ｓｅｘ（ａｃｈａｒ）、age(an integer)、weight(a float0、allergies(a boolean).
声明存取及修改方法。
在一个单独的累中，声明测试方法，并生成两个patient的例子：
Atient april=new Patient();
(“zhangli”)
(‘f’);;
(330;
;
(true);
那么：”+());
”+());
”+());
(“weught: ”+());\
”+());
声明并测试toString（）方法显示一个病人的aga、sex、name及allergies属性。
答：
public class Patient
{
private String name;
private char sex;
private int age;
private float weight;
private boolean allergies;
public void setname(String a)
{
name=a;
}
public void setsex(char b)
{
sex=b;
}
public void setage(int c)
{
age=c;
}
public void setweight(float d)
{
weight=d;
}
public void setallergies(boolean e)
{
allergies=e;
}
public String getname(){return name;}
public char getsex(){return sex;}
public int getage(){return age;}
public float getweight(){return weight;}
public boolean getallergies(){return allergies;}
}
public class Text
{
public static void main(String args[])
{
Patient april=new Patient();
("ZhangLi");
('f');
(33);
(154.72f);
(true);
"Name: "+());
"sex: "+());
"age: "+());
"weight: "+());
"allergies: "+());
}
}
11:声明并测试一个复数类，其方法包括toString（）及复数的加、减、乘运算。
答：public class Complex
{
private float a;
private float b;
public String toString()
{if(a!=0)
return(a+"i"+"+"+b);
else return(""+b);
}
public Complex(float a,float b)
{
=a;=b;
}
public void Add(Complex p)
{
+=;
+=;
}
public void Decrease(Complex p)
{
=;
=;
}
public void Multiply(Complex p)
{
=*;
=*;
}
}
public class ComplexTexter
{
public static void main(String args[])
{
Complex a=new Complex(2,4);
Complex b=new Complex(5,8);
(b);"\n");
(b);"\n");
(b);"\n");
}
}
12：什么是UML？它由哪几部分组成？
答：
UML是图形化（）即可视化的建模语言，成为面向对象建模的标准语言。
它由四部分组成：（1）视图（2）图（3）模型元素（4）通用机制
13. 常用的类与类之间的关系有哪几种。
答：有关联、依赖、流、泛化、实现、使用。
14. 考虑学院、系及教员应该具有哪些属性，并画出它们之间关系的类图。
第三章课后习题答案
1.设N为自然数：
n!=1*2*3*….*n
称为n的阶乘，并且规定0！=1.试编程计算2!,4!,6!he 10!.并将结果输出到屏幕上。
答：
public class Mul
{
public static void main(String args[])
{
int i,n;
float s;
for(n=0;n<=10;n=n+2)
{
if(n==0)
"0!=1\n");
else
{s=1;
for(i=1;i<=n;i++)
s=s*i;
"!="+s+"\n");
}
}
}
}
2.编写程序，接收用户从键键盘上输入的三个整数x,y,z..从中选出最大和最小者，并编程实现。
答：public class Math{
public static void main(String args[]){
int[] IntArg = new int[];
for(int i=0;i<;i++){
IntArg[i] = (args[i]);
}
int max,min;
max=IntArg[0]>IntArg[1]?IntArg[0]:IntArg[1];
max=max>IntArg[2]?max:IntArg[2];
min=IntArg[0]<IntArg[1]?IntArg[0]:IntArg[1];
min=min<IntArg[2]?min:IntArg[2];
"max="+max);
"min="+min);
}
}
3.求出100一枚的宿舍，并将这些数在屏幕上5个乙杭地显示出来。
答：
public class Su{
public static void main(String args[]){
int n,i,k=0,y;for(n=2;n<=100;n++){
y=1;
for(i=2;i<n;i++)
if(n%i==0)
{y=0;break;}
if(y==1){
k++;
" ");
if(k%5==0)
"\n");
}
}
}
}
4.使用类，生成100个0---99之间的随机整数，找出他们之中的最大值和最小值，并统计大于50的整数个数。
public class Random{
public static void main(String[] args)
{
int MinNum,MaxNum,n=0;
int[] array=new int[100];
array[0]=(int)()*100);
MinNum=array[0];
MaxNum=array[0];
"数列为：");
" ");
for(int i=0;i<100;i++)
{
array[i]=(int)()*100);
if(array[i]>50)
n++;
if(array[i]>=MaxNum)
MaxNum=array[i];
if(array[i]<=MinNum)
MinNum=array[i];
" ");
}
"MinNum="+MinNum);
"MaxNum="+MaxNum);
"大于50的整数个数有:"+n);
}
}
5.接收用户从键盘上输入的两个整数，求两个数的最大公约数和最小公倍数，并输出。
public class Test2
{
public static void main(String[] args)
{
int[] I = new int[];
for(int i=0;i<;i++){
I[i] = (args[i]);
}
int m,n,temp,t;
if(I[0]<I[1])
{
temp=I[0];
I[0]=I[1];
I[1]=temp;
}
m=I[0];
n=I[1];
t=m%n;
while(t!=0)
{
m=t;
n=m;
t=m%n;
}
"两个数的最大公约数为："+n);
"两个数的最小公倍数为："+I[0]*I[1]/n);
}
}
6. 从键盘上输入一件物品的价格（范围在~元.），假设用户支付了一张5元纸币，请列出一种找零的方案，使得纸币及硬币的个数最少。
如元，应为两元一张、一元一张、五角一个、一角一个、五分一个、二分一个、一分一个。
;
public class Price{
public static void main(String args[]){
"enter a number");
float a=();
int c=(int)(a*100);
int b=500-c;
"找零如下：");
if(b/200!=0){"张2元");b-=(b/200)*200;}
if(b/100!=0){"张1元");b-=(b/100)*100;}
if(b/50!=0){"张5角");b-=(b/50)*50;}
if(b/20!=0){"张2角");b-=(b/20)*20;}
if(b/10!=0){"张1角");b-=(b/10)*10;}
if(b/5!=0){"个5分");b-=(b/5)*5;}
if(b/2!=0){"个2分");b-=(b/2)*2;}
if(b!=0)"个1分");
}
}
;public class Keyboard{
static BufferedReader inputStream =new BufferedReader(new InputStreamReader);
public static int getInteger(){
try{
return().trim()).intValue());
}catch(Exception e){
();
return 0;
}
}
public static String getString(){
try{
return());
}catch(IOException e){
return"0";
}
}
public static float getFloat(){
String s="";
try{
BufferedReader in = new BufferedReader(new InputStreamReader);
s=();
return(s));
}
catch(IOException e)
{
"输入非法!");
return(0.0f);
}
}
}
运行结果：
7.什么是异常？解释抛出、捕获的含义。
答：异常又称为例外，是特殊的运行错误对象，在程序中可以强制编译器来处理程序运行中的发生的并非由程序本身所造成的错误；抛出异常：把生成异常对象并提交的过程称为抛出异常；
抛出异常是java中一个程序处理动作，检查异常时要么在方法中声明一个异常抛出，用try-catch语句捕获异常，并进行处理。
8.简述Java的异常处理机制。
答：java中声明了很多异常类，每个异常类都代表了一种运行错误，类中包含了该运行错误的信息和处理错误的方法等内容。
每当java程序运行过程中发生一个可识别的运行错误时，即该错误有一个异常类与之相对应时，系统都会产生一个相应的该异常类的对象，即产生一个异常。
一旦一个异常对象产生了，系统中就一定有相应的机制来处理它，确保不会产生死机、死循环或其他对操作系
统的损害，从而保证了整个程序运行的安全性。
9.系统定义的异常与用户自定义的异常有何不同？如何使用这两类异常？
答：系统定义的特定情况出现的问题，而此时用来对可能遇到的问题进行处理。
用户定义的是自己觉得可能会出现问题时，需要处理的。
这样避免程序中断或是出现未知错误。
系统异常有两种一种是运行时异常，一种是普通异常，普通异常要求用户捕获或者抛出的，不补货或者抛出就会编译不通过。
运行时异常编译可以通过，但是运行时才显露出来。
10.用户如何自定义异常？编程实现一个用户自定义异常。
（1）定义mytest
import .*;
public class mytest{
private static int quotient(int number,int denominator)throws
DivideByZeroException{
if(denominator==0)
throw new DivideByZeroException();
return(number/denominator);
}
public static void main(String args[]){
int number1=0,number2=0, result=0;
try{
"输入第一个数字：");
number1=()).intValue();
"输入第二个数字：");
number2=()).intValue();
result=quotient(number1,number2);
}
catch(NumberFormatException e){
(-1);
}
"/"+number2+"="+result);
}
}
（2）定义DivideByZeroException
public class DivideByZeroException extends ArithmeticException{
public DivideByZeroException(){
super("除数不能为0!");
}
}
（3）定义Keyboard
import .*;
public class Keyboard{
static BufferedReader inputStream=new BufferedReader(new InputStreamReader);
public static int getInteger(){
try{
return ().trim()).intValue());
}catch(Exception e){
();
return 0;
}
}
public static String getString(){
try{
return());
}catch(IOException e){return "0";}
}
}
第四章课后习题答案
1.子类将继承父类所有的属性和方法吗？为什么？
答：不,子类不能直接访问从父类中继承的私有属性及方法，但可以对公有及保护方法进行访问。
2.方法的覆盖与方法的重载有何不同？
答：覆盖是运用在子类中实现与父类相同的功能，但采用不同的算法或公式；在名字相同的方法中，要做比父类更多的事情；在子类中需要取消从父类继承的方法。
3.声明两个带有无参构造方法的两个类A和B，声明A的子类C，并且声明B为C的一个成员，不声明C 的构造方法。
编写测试代码，生成类C的实例对象，并观察结果。
明一个基类A，它只有一种非默认构造方法；声明A的子类B，B 具有默认方法及非默认方法，并在B的构造方法中调用基类A的构造方法。
明一个类，它具有一种方法，此方法被重载三次，派生一个新类，并增加一种新的重载方法，编写测试类验证四种方法对于派生类验证四种方法对于派生类都有效。
明一个具有final方法的类，声明一个派生类，并试图对这个方法进行重写，会有什么结果。
明一个final类，并试图声明其派生类，会有什么结果。
么是抽象类？抽象类中是否一定要包括抽象方法？
答：抽象类是一个不完全的类，不能使用new方法进行实例化。
抽象类可以包含抽象方法，也可以不包含抽象方法，但有抽象方法的必须是抽象类。
和super分别有哪些特殊含义？都有哪些种用法？
答：this 表示当前类；super 表示调用父类。
在定义类的时候用到，this是当前对象的引用，super是当前对象的父类对象的引用，一般的都是把super用在构造函数中。
10.完成下面父类及子类的声明：
(1) 声明Student类属性包括学号、姓名、英语成绩、数学成绩、计算机成绩和总成绩。
方法包括构造方法、get方法、 set方法、toString方法、equals方法、compare方法（比较两个学生的总成绩，结果分为大于、小于、等于），sum方法（计算总成绩）和testScore方法（计算评测成绩）。
注：评测成绩可以取三门课成绩的平均分，另外任何一门课的成绩的改变都需要对总成绩进行重新计算，因此，在每一个set方法中应调用sum方法计算总成绩。
public class Student{
String id;
String name;
float scoreOfenglish;float scoreOfmath;
float scoreOfcomputer;
float scoreOfsum;
;
public class test4_10{
public static void main(String args[]){
Student su=new Student("001","苏轼",56.00f,87.00f,95.00f);
Student du=new Student("002","杜甫",86.00f,75.00f,80.00f);
Student bai=new Student("003","白居易",42.00f,77.00f,65.00f);
Student liu=new Student("004","柳宗元",67.00f,67.00f,67.00f);
StudentXW ou=new StudentXW("005","欧阳修",89.00f,98.00f,90.00f,"数学代表");
StudentXW wang=new StudentXW("006","王安石",98.00f,87.00f,36.00f,"英语代表");
StudentBZ li=new StudentBZ("007","李白",89.00f,87.00f,87.00f,"班长");
"\n评测成绩："+new DecimalFormat("").format()));
"\n评测成绩："+new DecimalFormat("").format()));
"\n评测成绩："+new DecimalFormat("").format()));
"\n评测成绩："+new DecimalFormat("").format()));
"\n评测成绩："+new DecimalFormat("").format()));
"\n评测成绩："+new DecimalFormat("").format()));
"\n评测成绩："+new DecimalFormat("").format()));
}
}
运行test4_10的结果如下：
（很好玩吧，李白，我让你挂科。
）
11.包有什么作用？如何创建包和引用包中的类？
答：包是一种松散的类的组合，一般不要求处于同一包中的类型有明确的相互关系，但由于同一包中的类在默认情况下可以相互访问，所以为了方便编程和管理，通常把需要在一起工作的类放在一个包里。
利用包来管理类，可实现类的共享与复用。
在操作系统中，目录用来组织文件，设置权限。
只要在要用到包中类的时候，在该引用类的第一行加上：package (包的全路径)即可。
第五章课后习题答案
1.什么是接口？接口起什么作用？接口与抽象类有何区别？
答：Java中的接口是一系列方法的声明，是一些方法特征的集合，
一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。
作用：接口是面向对象的一个重要机制，使用接口可以实现多态继承；接口中的所有方法都是抽象的，这些抽象方法由实现这一接口的不同类型来具体；接口还可以用来实现不同类之间的常量共享。
与抽象类不同的是：接口允许在看起来不相干的类之间定义共同行为。
2.试编程证明接口中的属性都隐含为static及final，所有的方法都为public。
什么情况下，可以对父类对象的引用进行强制类型转换，使其转化成子类对象的引用？
答：一个对象被塑型为父类或接口后，可以再一次被塑型回到它原来所属的类，即转化成原类对象的引用。
4.声明一个接口，此接口至少具有一个方法；在一个方法中声明内部类实现此接口，并返回此接口的引用。
uck().fuck();
}
}
运行结果：
5.声明一个具有内部类的类，此内部类只有一个非默认的构造方法；声明另外一个具有内部类的类，此内部类继承第一个内部类。
明一个具有两个方法的类，在第一个方法中调用第二个方法。
声明此类的一个子类，并在子类中重写第二个方法。
生成一个子类的对象，并将其塑型为基类，调用第一个方法，解释会发生什么？
第4章习题10的基础上，声明测试类完成对多态性的测试。
（1）在主方法中声明Student类的数组（含五个元素）
（2）生成五个对象存入数组：其中三个Student类的对象、一个StudentXW类的对象、一个StudentBZ类的对象。
（3）将方法testScore（）发送给数组的每一个元素，输出结果，并分析具体执行的是哪一个类中的方法。
;
public class test5_8{
public static void main(String args[]){
Student student[]={
new Student("001","苏轼
",56.00f,87.00f,95.00f),
new Student("002","杜甫
",86.00f,75.00f,80.00f),
new Student("003","白居易
",42.00f,77.00f,65.00f),
new StudentXW("006","王安石
",98.00f,87.00f,36.00f,"英语代表"),
new StudentBZ("007","李白
",89.00f,87.00f,87.00f,"班长")
};
for(int i=0;i<5;i++)
{
"学生名字："+student[i].getname()+"\t评测成绩："+new DecimalFormat("").format(student[i].testScore()));
}
}
}
运行结果：
在主函数定义student数组的五个对象
Student student[5]={
new Student(),
new Student(),
new Student(),
new StudentXW(),
new StudentBZ()
}中，输出时，第1、2、3个调用的是Student中的方法，第4个调用的是StudentXW的方法，第5个调用的是StudentBZ的方法。
第六章课后习题答案
1.将本章例6-1至6-18中出现的文件的构造方法均改为使用File 类对象作为参数实现。
个人理解：File类只能对整文件性质进行处理，而没法通过自己直接使用()或者是()类似方法对文件内容进行写或者读取。
注意：是直接;下面只提供一个例2变化，其他的你自己做，10几道啊，出这题的人真他妈有病。
import .*;
public class test6_2{
public static void main(String[] args) throws IOException {
String fileName = "D:\\";
File writer=new File(fileName);
();
BufferedWriter input = new BufferedWriter(new FileWriter(writer));
("Hello !\n");
("this is my first text file,\n");
("你还好吗？\n");
();
}
}
运行结果：（电脑系统问题，没法换行，所以一般使用BuffereWriter 中newLine()实现换行）
2.模仿文本文件复制的例题，编写对二进制文件进行复制的程序. ;
class CopyMaker {
String sourceName, destName;
BufferedInputStream source;
BufferedOutputStream dest;
int line;
opy(s1, s2))
"复制成功");
else
"复制失败");
}
}
运行前的两个文本：和（为空）
运行后：
3.创建一存储若干随机整数的文本文件，文件名、整数的个数及范围均由键盘输入。
;
import class memory {
private String name;
private int count;
private int Max;
private int Min;
public memory(String n,int c,int min,int max){
=n;
=c;
=min;
=max;
}
public void startmemory(){
try{
FileWriter out=new FileWriter(name);
int limit=Max-Min;
Random random = new Random();
for (int i=1;i<=count;i++){
int number=Min+(limit); " ");
(number+" ");
}
();
}catch(IOException iox){
"方法startmemory()有问题");
}
}
}
;
import class test6_3 {
public static void main(String[] args) throws IOException{
别使用FileWriter和BufferedWriter往文件中写入10万个随机数，比较用时的多少。
;
public class fileWriter {
public static void main(String[] args) throws IOException{
long time = ();;
}
}
运行结果：
;
public class bufferedWriter {
public static void main(String[] args) throws IOException{
long time = ();;
}
}
运行结果：
有用时可知： BufferedWriter比FileWriter写入的速度快, 当需要写入大量内容,前者效率高。
5.生成一html文件，使其能显示2的幂次（0~9）的表格如下：
;
public class test6_5{
public static void main(String[] args) throws IOException{
BufferedWriter fuck =new BufferedWriter( new FileWriter(""));
("<table border=1 align=center width=200
height=250>");
();
("<tr><td align=center>Power of 2<td
align=center>Value</tr>");
for (int i=0;i<=9;i++){
("<tr><td align=center>"+i+"<td align=center>"+(i, 2)+"</tr>");
}
("</table>");
();
();
}
}
运行结果：
6.用记事本程序创建一篇包含几十个英语单词的小文章，要求从屏幕输出每一个单词。
;
public class test6_6 {
public static void main(String[] args)throws IOException {
FileReader fr=new FileReader("");
int s;
while((s=())!=-1){
if(s>='a'&& s<='z'|| s>='A' && s<='Z')
else
"\n");
}
();
}
}
运行结果：
7.从键盘敲入一系列字母，将其存储到文件中，对其进行升序排序后，存储到另一个文件，并显示在屏幕上。
;
import class test6_7 {
建一个学生类（包括姓名、年龄、班级、密码），创建若干该类的对象并保存在文件中（密码不保存），从文件读取对象后显示在屏幕上。
;
public class tset6_8 {
public static void main(String[] args) throws IOException,ClassNotFoundException{
Student student[]={
new Student("苍井空
",19,101,"changjingkong"),
new Student("吉沢明
",19,103,"jizeming"),
new Student("武藤兰
",20,104,"wutenglan"),
new Student("我爱女优
",21,105,"woainvyou")};
ame);
"我的年龄："+student[i].age);
"我的班级："+student[i].grade);
"我的密码："+student[i].secret);
}
else{
"第"+(i+1)+"个女学生名字：
"+student[i].name);
"第"+(i+1)+"个女学生年龄："+student[i].age);
"第"+(i+1)+"个女学生班级：
"+student[i].grade);
"第"+(i+1)+"个女学生密码：
"+student[i].secret);
}
}
}
}
9.对例6—14中的压缩程序段进行修改，是压缩流经过缓冲类。
比较两种方法在对大的文件进行压缩时的效率。
;
import class test6_9f{
public static void main(String[] args) throws IOException {
long time = ();
FileInputStream in = new FileInputStream("");
GZIPOutputStream out = new GZIPOutputStream(
new
FileOutputStream(""));
"Writing compressing file from to ");
int c;
while((c = ()) != -1) (c); Reading;
}
}
运行结果：
;
import class test6_9b{
public static void main(String[] args) throws IOException {
BufferedInputStream in = new BufferedInputStream(new FileInputStream(""));
GZIPOutputStream out = new GZIPOutputStream(
new BufferedOutputStream(
new FileOutputStream("")));
"Writing compressing file from to ");
int c;
long time = ();
Reading;
}
}
运行结果：
以上2个类的运行用时比较，可见对大文件进行压缩，经过缓冲流的效率要高得多。
10.一家杂货店的店主，需要查询、输入、修改任何一件商品的品名、价格、库存量信息。
请用随机存取文件满足其要求，可以更新、查询信息。
每件商品的标志为其记录号。
ength>8)
(),0, , 0,8);ength);ength>8)
(),0, , 0,8);
else
(),0,,0,().length);
}
public double getPrice() {
return Price;
}
public void setPrice(double price) {
= price;
}
public int getNumber() {
return Number;
}
public void setNumber(int number) {
= number;
}
public int getCount() {
return Count;
}
public void setCount(int count) {
= count;
}
}
;
public class Work{
String FileName;
public Work(String FileName){
=FileName;
}
ength>8)
(),0,borrow,0,8);
else
(),0,borrow,0,().length);
for(int i=0;i<8;i++)
(borrow[i]);
();
}
组的声明与数组元素的创建有什么关系？
答：声明数组仅仅是代表试图创建数组，不分配任何存储空间，声明是为创建做“铺垫”。
类的对象与数组有什么关系？什么时候适合使用数组，什么时候适合使用Vector？
答：vector是一个能够存放任意对象类型的动态数组，容量能自动扩充，而数组存储固定且类型相同的对象；对于存储固定类型相同的对象使用数组，对于存储不同类型或者动态调整数组大小的情况使用Vector。
3.与顺序查找相比，二分查找有什么优势？使用二分查找的条件？答：对于大数据量中进行查找时二分查找比顺序查找效率高得多；条件是已排序的数组。
4.试举出三种常见的排序算法，并简单说明其排序思路。
答：①选择排序：基本思想是站在未排序列中选一个最小元素，作为已排序子序列，然后再重复地从未排序子序列中选取一个最小元素，把它加到已经排序的序列中，作为已排序子序列的最后一个元素，直到把未排序列中的元素处理完为止。
②插入排序：是将待排序的数据按一定的规则逐一插入到已排序序列中的合适位置处，直到将全部数据都插入为止。
③二分查找：将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
5.声明一个类People，成员变量有姓名、出生日期、性别、身高、体重等；生成10个People类对象，并放在一个以为数组中，编写方法按身高进行排序。
1989年8月13日1958年8月29日1963年2月17日1769年8月15日1983
年11月11日etHeight()<people[j].getHeight()){
temp=people[j];
people[j]=people[i];
people[i]=temp;
}
}
"按身高从小到大排序后的结果如下：");
for(int i=0;i<;i++)
"\n");
}
}
运行结果：
6.声明一个类，此类使用私有的ArrayList来存储对象。
使用一个Class类的引用得到第一个对象的类型之后，只允许用户插入这种类型的对象。
;
}
else{
"只允许插入"+getClassType()+"类的对象.");
}
}
public ArrayList getMan() {
return man;
}
public Class getClassType() {
return classType;
}
public Fuck(){}
}
出一个二维数组的鞍点，即该位置上的元素在所在行上最大，在所在列上最小。
（也可能没有鞍点）
ength; j++)
{ Array[i][j] = ();
if(j==series-1) {
max = Array[i][0];
for (int z = 1; z < series; z++)
if (Array[i][z] > max)
{
max = Array[i][z];
R[i] = z;
}
}
}
for (int j = 0; j < Array[0].length; j++)
{
max = Array[0][j];
for (int z = 1; z < row ; z++)
if (Array[z][j] < max)
{
max = Array[z][j];
S[j] = z;
}
}
for(int i=0;i<;i++)
{
if(S[R[i]]==i)
{
"鞍点:"+"Array["+i+"]["+R[i]+
"]:"+Array[i][R[i]]+"\n");
T=true;
}
}
if(T==false)
"没有鞍点");
}
}
运行结果：
8. 声明一个矩阵类Matrix，其成员变量是一个二维数组，数组元素类型为int，设计下面的方法，并声明测试类对这些方法进行测试。
(1)构造方法。
Matrix() ength; j++)
+ " ");
}
}
public void transpose() {ength; i++) {
for (int j = 0; j < ; j++)
+ " ");
}
}
public boolean isTriangular() {ength; j++) {
if ((i > j) && (array[i][j] != 0)) {
flag = false;
}
}
}
return flag;
}
public boolean isSymmetry() { ength; j++) {
if (array[i][j] == array[j][i]) {
Symmetry = false;
}
}
}
return Symmetry;
}
public void add(Matrix b) { ength; j++) {
[i][j] = array[i][j] + [i][j];
}
}
}
}
程和线程有何区别，Java是如何实现多线程的。
答：区别：一个程序至少有一个进程,一个进程至少有一个线程；线程的划分尺度小于进程；进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
Java程序一般是继承Thread 类或者实现 Runnable接口，从而实现多线程。
2.简述线程的生命周期，重点注意线程阻塞的几种情况，以及如何重回就绪状态。
答：线程的声明周期：新建-就绪-（阻塞）-运行--死亡
线程阻塞的情况：休眠、进入对象wait池等待、进入对象lock池等待；
休眠时间到回到就绪状态；在wait池中获得notify（）进入lock 池，然后获得锁棋标进入就绪状态。
3.随便选择两个城市作为预选旅游目标。
实现两个独立的线程分别显示10次城市名，每次显示后休眠一段随机时间（1000毫秒以内），哪个先显示完毕，就决定去哪个城市。
分别用Runnable接口和Thread类实现。
（注：两个类，相同一个测试类）
写一个多线程程序实现如下功能：线程A和线程B分别在屏幕上显示信息“…start”后，调用wait等待；线程C开始后调用sleep 休眠一段时间，然后调用notifyall，使线程A和线程B继续运行。
线程A和线程B恢复运行后输出信息“…end”后结束，线程C在判断线程B和线程A结束后自己结束运行。
start");
try {
wait();
} catch (InterruptedException e) {
();
}
+ "..end");
}
public synchronized void notifyall() {
notifyAll();
}
public static void main(String args[]) {
test8_4 test = new test8_4();
现一个数据单元，包括学号和姓名两部分。
编写两个线程，一个线程往数据单元中写，另一个线程往外读。
要求没写一次就往外读一次。
tart();
new Write(data).start();
}
}
运行结果：
6.创建两个不同优先级的线程，都从1数到10000，看看哪个数得快。
(注：线程的优先级别越高低与执行速度没有绝对关系！)
写一个Java程序，以说明较高优先级的线程通过调用sleep方法，使较低优先级的线程获得运行的机会。
（这里可以借鉴课本例8—13）
etPriority(2);
runners[1].setPriority(5);
for(int i=0;i<2;i++){
runners[i].start();
}
}
}
运行结果：
8.主线程控制新线程的生命，当主线程运行一段时间后，控制新线程死亡，主线程继续运行一段时间后结束。
(注：main函数就是主线程，程序里其他的Thread都属于子线程。
可以参考课本的例8—1)
;
/* while(i>0){
result=result*i;
i--;
}*/
"the new thread of "+num+"is "+result);
"new thread ends");
}
}
;
SonThread newThread = new SonThread(10);
();
两个线程模拟存、取货物。
一个线程往一对象里放货物（包括品名、价格），另外一个线程取货物。
分别模拟“放一个、取一个”和“放若干个、取若干个”两种情况。
两个线程模拟对话，任何一个线程都可以随时收发信息。
(这道题本人搞不清楚，暂且用网上的给大家参考下。
听说要用到：
()获取输入流用于“接收”
()获取输出流用于“发送”
)
;
import .*;
import .*;
public class test8_10 {
public static void main(String[] args) {
try {
;
quals("BYE"))
done = true;
}
} finally {
();
}
} catch (IOException e) {
();
}
}
}
第九章课后习题答案
1.编写一个程序，该程序绘制一个5×9的网络，使用drawLine方法。
写一个程序，该程序以不同的颜色随机产生三角形，每个三角形用不同的颜色进行填充。
写一个Applet，该程序请求用户输入圆的半径，然后显示该圆的直径、周长和面积。
;
import .*;
import class test9_3 extends JApplet {
loatValue();写一个Applet，向其输入五个数，然后以条形。
