Java语言程序设计-第2版-(郑莉)课后习题答案.doc

Java语言程序设计第2版(郑莉)
第二章习题答案
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();
April.setname(“zhangli”)
April.setSex(‘f’);;
April.setage(330;
April.setweigeht(154.72);
April.setalolergies(true);
System.out.println(“那么： ”+april.getname());
System.out.println(“sex: ”+april.getsex());
System.out.println(“age: ”+april.getage());
System.outprintln(“weught: ”+april.getweight());\
System.out.println(“allergies: ”+april.getallergies());
声明并测试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();
april.setname("ZhangLi");
april.setsex('f');
april.setage(33);
april.setweight(154.72f);
april.setallergies(true);
System.out.println("Name: "+april.getname());
System.out.println("sex: "+april.getsex());
System.out.println("age: "+april.getage());
System.out.println("weight: "+april.getweight());
System.out.println("allergies: "+april.getallergies());
}
}

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)
{
this.a=a;
this.b=b;
}
public void Add(Complex p)
{
this.a+=p.a;
this.b+=p.b;
}
public void Decrease(Complex p)
{
this.a-=p.a;
this.b-=p.b;
}
public void Multiply(Complex p)
{
this.a=this.a*p.a;
this.b=this.b*p.b;
}
}
public class ComplexTexter
{
public static void main(String args[])
{
Complex a=new Complex(2,4);
Complex b=new Complex(5,8);
a.Add(b);System.out.println(a.toString()+"\n");
a.Decrease(b);System.out.println(a.toString()+"\n");
a.Multiply(b);System.out.println(a.toString()+"\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)
System.out.println("0!=1\n");
else
{s=1;
for(i=1;i<=n;i++)
s=s*i;
System.out.println(n+"!="+s+"\n");
}
}
}
}

2.编写程序，接收用户从键键盘上输入的三个整数x,y,z..从中选出最大和最小者，并编程实现。
答：public class Math{
public static void main(String args[]){
int[] IntArg = new int[args.length];
for(int i=0;i<args.length;i++){
IntArg[i] = Integer.parseInt(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];
System.out.println("max="+max);
System.out.println("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++;
System.out.print(n+" ");
if(k%5==0)
System.out.print("\n");
}
}

}
}
4.使用java.lang.Math类，生成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)(Math.random()*100);
MinNum=array[0];
MaxNum=array[0];

System.out.println("数列为：");
System.out.print(array[0]+" ");
for(int i=0;i<100;i++)
{
array[i]=(int)(Math.random()*100);
if(array[i]>50)
n++;
if(array[i]>=MaxNum)
MaxNum=array[i];
if(array[i]<=MinNum)
MinNum=array[i];
System.out.print(array[i]+" ");
}
System.out.println();
System.out.println("MinNum="+MinNum);
System.out.println("MaxNum="+MaxNum);
System.out.println("大于50的整数个数有:"+n);
}
}

5.接收用户从键盘上输入的两个整数，求两个数的最大公约数和最小公倍数，并输出。
public class Test2
{
public static void main(String[] args)
{
int[] I = new int[args.length];
for(int i=0;i<args.length;i++){
I[i] = Integer.parseInt(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;
}
System.out.println("两个数的最大公约数为："+n);
System.out.println("两个数的最小公倍数为："+I[0]*I[1]/n);
}
}

6. 从键盘上输入一件物品的价格（范围在0.10~5.00元.），假设用户支付了一张5元纸币，请列出一种找零的方案，使得纸币及硬币的个数最少。如3.68元，应为两元一张、一元一张、五角一个、一角一个、五分一个、二分一个、一分一个。
// Price类
import java.io.*;
public class Price{
public static void main(String args[]){
System.out.println("enter a number(0.01----5.00):");
float a=Keyboard.getFloat();
int c=(int)(a*100);
int b=500-c;
System.out.println("找零如下：");
if(b/200!=0){System.out.println(b/200+"张2元");b-=(b/200)*200;}
if(b/100!=0){System.out.println(b/100+"张1元");b-=(b/100)*100;}

if(b/50!=0){System.out.println(b/50+"张5角");b-=(b/50)*50;}
if(b/20!=0){System.out.println(b/20+"张2角");b-=(b/20)*20;}
if(b/10!=0){System.out.println(b/10+"张1角");b-=(b/10)*10;}
if(b/5!=0){System.out.println(b/5+"个5分");b-=(b/5)*5;}
if(b/2!=0){System.out.println(b/2+"个2分");b-=(b/2)*2;}
if(b!=0)System.out.println(b+"个1分");
}
}
// Keyboard类
import java.io.*;
public class Keyboard{
static BufferedReader inputStream =new BufferedReader(new InputStreamReader(System.in));
public static int getInteger(){
try{
return(Integer.valueOf(inputStream.readLine().trim()).intValue());
}catch(Exception e){
e.printStackTrace();
return 0;
}
}
public static String getString(){
try{
return(inputStream.readLine());
}catch(IOException e){
return"0";
}
}
public static float getFloat(){
String s="";
try{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
s=in.readLine();
return(Float.parseFloat(s));
}
catch(IOException e)
{
System.out.println("输入非法!");
return(0.0f);
}
}
}
运行结果：

7.什么是异常？解释抛出、捕获的含义。
答：异常又称为例外，是特殊的运行错误对象，在程序中可以强制编译器来处理程序运行中的发生的并非由程序本身所造成的错误；
抛出异常：把生成异常对象并提交的过程称为抛出异常；
抛出异常是java中一个程序处理动作，检查异常时要么在方法中声明一个异常抛出，用try-catch语句捕获异常，并进行处理。

8.简述Java的异常处理机制。
答：java中声明了很多异常类，每个异常类都代表了一种运行错误，类中包含了该运行错误的信息和处理错误的方法等内容。每当java程序运行过程中发生一个可识别的运行错误时，即该错误有一个异常类与之相对应时，系统都会产生一个相应的该异常类的对象，即产生一个异常。一旦一个异常对象产生了，系统中就一定有相应的机制来处理它，确保不会产生死机、死循环或其他对操作系统的损害，从而保证了整个程序运行的安全性。

9.系统定义的异常与用户自定义的异常有何不同？如何使用这两类异常？
答：系统定义的特定情况出现的问题，而此时用来对可能遇到的问题进行处理。用户定义的是自己觉得可能会出现问题时，需要处理的。这样避免程序中断或是出现未知错误。
系统异常有两种一种是运行时异常，一种是普通异常，普通异常要求用户捕获或者抛出的，不补货或者抛出就会编译不通过。运行时异常编译可以通过，但是运行时才显露出来。
10.用户如何自定义异常？编程实现一个用户自定义异常。
（1）定义mytest
import java.io.*;
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{
System.out.println("输入第一个数字：");
number1=Integer.valueOf(Keyboard.getString()).intValue();
System.out.println("输入第二个数字：");
number2=Integer.valueOf(Keyboard.getString()).intValue();
result=quotient(number1,number2);
}
catch(NumberFormatException e){
System.out.println(e.toString());
System.exit(-1);
}
System.out.println(number1+"/"+number2+"="+result);
}
}
（2）定义DivideByZeroException
public class DivideByZeroException extends ArithmeticException{
public DivideByZeroException(){
super("除数不能为0!");
}
}
（3）定义Keyboard
import java.io.*;
public class Keyboard{
static BufferedReader inputStream=new BufferedReader(new InputStreamReader(System.in));
public static int getInteger(){
try{
return (Integer.valueOf(inputStream.readLine().trim()).intValue());
}catch(Exception e){
e.printStackTrace();
return 0;
}
}
public static String getString(){
try{
return(inputStream.readLine());
}catch(IOException e){return "0";}
}
}

第四章课后习题答案
1.子类将继承父类所有的属性和方法吗？为什么？
答：不,子类不能直接访问从父类中继承的私有属性及方法，但可以对公有及保护方法进行访问。
2.方法的覆盖与方法的重载有何不同？
答：覆盖是运用在子类中实现与父类相同的功能，但采用不同的算法或公式；在名字相同的方法中，要做比父类更多的事情；在子类中需要取消从父类继承的方法。
3.声明两个带有无参构造方法的两个类A和B，声明A的子类C，并且声明B为C的一个成员，不声明C 的构造方法。编写测试代码，生成类C的实例对象，并观察结果。
//A类
public class A {
public A () {
System.out.println ("输出A类");
}
}
//B类
public class B {
public B () {
System.out.println ("输出B类");
}
}
//C类
public class C extends A {
B b = new B ();
}
//测试类
public class test4_3 {
public static void main (String args[]) {
C c = new C();
}
}
运行结果：

4.声明一个基类A，它只有一种非默认构造方法；声明A的子类B，B具有默认方法及非默认方法，并在B的构造方法中调用基类A的构造方法。
//A类
public class A {
public A (String lin) {
System.out.println("A类的非默认构造方法 "+lin);
}
}//B类
public class B extends A{
public B () {
super ("Fuck your teacher");
System.out.println ("B默认类构造方法");
}
public B (String lin) {
super (lin);
System.out.println ("B类非构造方法");
}
}//测试类
public class test4_4 {
public static void main (String args[]) {
new B();
System.out.println ();
new B("Fuck my teacher");
}
}
运行结果：

5.声明一个类，它具有一种方法，此方法被重载三次，派生一个新类，并增加一种新的重载方法，编写测试类验证四种方法对于派生类验证四种方法对于派生类都有效。
//A类

public class A {
public void showTime () {
System.out.println ("空重载");
}

public void showTime (int l) {
System.out.println ("整形参数重载");
}

public void showTime (char l) {
System.out.println ("字符参数重载");
}
}
//B类
public class B extends A {
public void showTime (String l) {
System.out.println ("字符串参数重载");
}
}
//测试类
public class test4_5 {
public static void main (String args[]) {
B b = new B();
b.showTime();
b.showTime(5);
b.showTime('f');
b.showTime("林楚金");
}
}

6.声明一个具有final方法的类，声明一个派生类，并试图对这个方法进行重写，会有什么结果。
//A类
public class A {
public final void showTime() {
System.out.println ("类A中方法");
}
}
//B类
public class B extends A{
public void showTime() {
System.out.println ("类B中方法");
}
}
//测试类
public class test4_6 {
public static void main (String args[]) {
B b = new B();
b.showTime();
}
}
运行结果：

（说白了就是B中showTime()的无法覆盖A中showTime()，被覆盖为final，不能覆盖。）

7.声明一个final类，并试图声明其派生类，会有什么结果。
//A类
public final class A {

}
//B类
public class B extends A{

}
//测试类
public class test4_7 {
public static void main (String args[]) {
B b = new B();
}
}
运行结果：

（说白了就是无法从A中进行继承）

8.什么是抽象类？抽象类中是否一定要包括抽象方法？
答：抽象类是一个不完全的类，不能使用new方法进行实例化。
抽象类可以包含抽象方法，也可以不包含抽象方法，但有抽象方法的必须是抽象类。

9.this和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 Student(){
}
public Student(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer){
this.id=aid;
this.name=aname;
this.scoreOfenglish=ascoreOfenglish;
this.scoreOfmath=ascoreOfmath;
this.scoreOfcomputer=ascoreOfcomputer;
//this.scoreOfsum=ascoreOfenglish+ascoreOfmath+ascoreOfcomputer;
this.scoreOfsum=sum();
}
//sum方法
public float sum(){
return(this.scoreOfenglish+this.scoreOfmath+this.scoreOfcomputer);
}
//testScore测评成绩/平均分
public float testScore(){
return(this.scoreOfsum/3);
}
//6个get方法
public String getid(){
return(id);
}
public String getname(){
return(name);
}
public float getscoreOfenglish(){
return(scoreOfenglish);
}
public float getscoreOfmath(){
return(scoreOfmath);
}
public float getscoreOfcomputer(){
return(scoreOfcomputer);
}
public float getscoreOfsum(){
return(scoreOfsum);
}
//5个set方法
public void setid(String newid){
this.id=newid;
}
public void setname(String newname){
this.name=newname;
}
public void setscoreOfenglish(float newscoreOfenglish){
this.scoreOfenglish=newscoreOfenglish;
this.scoreOfsum=sum();
}
public void setscoreOfmath(float newscoreOfmath){
this.scoreOfmath=newscoreOfmath;
this.scoreOfsum=sum();
}
public void setscoreOfcomputer(float newscoreOfcomputer){
this.scoreOfcomputer=newscoreOfcomputer;
this.scoreOfsum=sum();
}
//toString方法
public String toString(){
return("学号："+this.id+"\n姓名："+name+"\n英语："+this.scoreOfenglish+"\n数学："+this.scoreOfmath+"\n计算机："+this.scoreOfcomputer+"\n总分："+this.scoreOfsum);
}
//compare方法/比较2学生总分
public void compare(Student x){
if(this.ge