java语言程序设计作业答案

Java语言程序设计(郑莉)

第二章习题答案

1.什么是对象、类，它们之间的联系？

答：1）对象是包含现实世界物体特征的抽象实体，它反映系统为之保存信息和与它交互的能力。对象是一些属性及服务的封装体，在程序设计领域，可以用“对象=数据+作用于这些数据上的操作”来表示。现实生活中对象是指客观世界的实体；在程序中对象是指一组变量和相关方法的集合。

2）类是既有相同操作功能和相同的数据格式的对象的集合与抽象！

3）两者的关系：对象是类的具体实例.。

4．请解释类属性、实例属性及其区别。

答：实例属性，由一个个的实例用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。

5．请解释类方法、实例属性及其区别。

答：实例方法表示特定对象的行为，在声明时前面不加static修饰符，在使用时需要发送给一个类实例。

类方法也称为静态方法，在方法声明时前面需加static修饰符，类方法表示具体实例中类对象的共有行为。

区别：实例方法可以直接访问实例变量，调用实例方法，实例方法可以直接访问类变量，调用类方法；类方法可以直接调用类变量和类方法，类方法不能直接调用实例变量和实例方法；

6．类的访问控制符有哪几种？具体含义及其区别。

答：类的访问控制符只有public（公共类）及无修饰符（默认类）两种。

区别：当使用public修饰符时表示所有其他的类都可以使用此类；当没有修饰符时，则只有与此类处于同一包中的其他类可以使用类。

7类成员的访问控制符有哪几种?他们对类成员分别有哪些访问限制的作用?

答:

类成员的访问控制符有public,private,protecte及无修饰符.

public(公有的):用public修饰的成分表示公有的,也就是它可以被其他任何对象访问(前提是对累成员所在的类访问有访问权限).

P rivate(保护的)：类中限定为private的成员只能被这个类本身访问，在类外不可见。proteced（保护的）用该关键字修饰的成分是受保护的，只可以被同一类及其子类的实例对象访问。

无修饰符（默认的）：public，private，protected这个三个限定符不是必须写的。如果不写，则表明是“friendly”，相应的成分可以被所在保重的各类访问。

8简述构造方法的特点?

答：

构造方法主要有以下特点：

（1）构造方法的方法名与类名相同；

（2）构造方法没有返回类型（修饰符void也不能有）；

（3）构造方法通常被声明为公有的（public）；

（4）构造方法可以有任意多个参数；

（5）构造方法的主要作用是完成对象的初始化工作；

（6）构造方法不能在程序中显式的调用；

（7）在生成一个对象时，系统会自动调用该类的构造方法为新生成的对象初始化。

9如果在类声明中声明了构造方法,系统是否还提供默认的构造方法?

答：

用户在进行类声明时，如果没有声明任何构造方法，系统会赋给此类一个默认（无参）的构造方法。但是，只要用户声明了构造方法，即使没有声明无参的构造方法，系统也不会再赋默认的构造方法。

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. 常用的类与类之间的关系有哪几种。

答：有关联、依赖、流、泛化、实现、使用。

Java语言程序设计(郑莉)

第三章课后习题答案

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

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]

min=min

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

if(n%i==0)

{y=0;break;}

if(y==1){

k++;

System.out.print(n+" ");

if(k%5==0)

System.out.print("\n");

}

}

}

}

4.使用https://www.360docs.net/doc/435537421.html,ng.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);

}

}

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";}

}

}

Java语言程序设计

第四章课后习题答案

1.子类将继承父类所有的属性和方法吗？为什么？

答：不,子类不能直接访问从父类中继承的私有属性及方法，但可以对公有及保护方法进行访问。

2.方法的覆盖与方法的重载有何不同？

答：覆盖是运用在子类中实现与父类相同的功能，但采用不同的算法或公式；在名字相同的方法中，要做比父类更多的事情；在子类中需要取消从父类继承的方法。

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;

https://www.360docs.net/doc/435537421.html,=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){

https://www.360docs.net/doc/435537421.html,=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.getscoreOfsum()>x.getscoreOfsum())System.out.println(this.getname()+"总分大于"+x.getname());

if(this.getscoreOfsum()

else System.out.println(this.getname()+"总分等于"+x.getname());

}

//equals方法/比较2学生学号是否相等(还没完善)

/*

* public boolean equals(Object x){

if(this.getClass()!=x.getClass())return false;

Student b=(Student)x;

if(this.id==b.getid())return true;

}

*/

}

(2）声明StudentXW(学习委员)类为Student类的子类。

在StudentXW类中增加责任属性，并重写testScore方法（评测成绩=三门课平均分+3）

public class StudentXW extends Student{

String responsibility;

//构造方法

public StudentXW(){

super();

//responsibility=" ";

}

public StudentXW(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer,String aresponsibility){

super(aid,aname,ascoreOfenglish,ascoreOfmath,ascoreOfcomputer);

responsibility=aresponsibility;

}

//testScore测评成绩/平均分

public float testScore(){

return(this.scoreOfsum/3+3);

}

//toString方法

public String toString(){

return("学号："+this.id+"\n姓名："+name+"\n英语："+this.scoreOfenglish+"\n数学："+this.scoreOfmath+"\n计算机："+this.scoreOfcomputer+"\n总分："+this.scoreOfsum+"\n职位："+this.responsibility);

}

}

(3）声明StudentBZ类为Student类的子类

在StudentBZ类中增加责任属性，并重写testScore方法（评测成绩=三门课平均分+5）

public class StudentBZ extends Student{

String responsibility;

//构造方法

public StudentBZ(){

super();

//responsibility="";

}

public StudentBZ(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer,String aresponsibility){

super(aid,aname,ascoreOfenglish,ascoreOfmath,ascoreOfcomputer);

responsibility=aresponsibility;

}

//testScore测评成绩/平均分

public float testScore(){

return(this.scoreOfsum/3+5);

}

//toString方法

public String toString(){

return("学号："+this.id+"\n姓名："+name+"\n英语："+this.scoreOfenglish+"\n数学："+this.scoreOfmath+"\n计算机："+this.scoreOfcomputer+"\n总分："+this.scoreOfsum+"\n职位："+this.responsibility);

}

}

4）声明测试类，生成若干个Student类、StudentXW类及StudentBZ类对象，并分别计算它们的评测成绩(建议采用:写一个测试函数，该函数以父类student数组作为参数) 。

import java.te x t.*;

public class te st4_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,"班长");

System.out.print(li);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(li.testScore()));

System.out.println();

System.out.print(wang);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(wang.testScore()));

System.out.println();

System.out.print(ou);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(ou.testScore()));

System.out.println();

System.out.print(su);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(su.testScore()));

System.out.println();

System.out.print(du);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(du.testScore()));

System.out.println();

System.out.print(bai);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(bai.testScore()));

System.out.println();

System.out.print(liu);

System.out.println("\n评测成绩："+new DecimalFormat("0.00").format(liu.testScore()));

}

}

运行test4_10的结果如下：

（很好玩吧，李白，我让你挂科。）

11.包有什么作用？如何创建包和引用包中的类？

答：包是一种松散的类的组合，一般不要求处于同一包中的类型有明确的相互关系，但由于同一包中的类在默认情况下可以相互访问，所以为了方便编程和管理，通常把需要在一起工作的类放在一个包里。利用包来管理类，可实现类的共享与复用。

在操作系统中，目录用来组织文件，设置权限。只要在要用到包中类的时候，在该引用类的第一行加上：package (包的全路径)即可。

Java语言程序设计

第五章课后习题答案

1.什么是接口？接口起什么作用？接口与抽象类有何区别？

答：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。

作用：接口是面向对象的一个重要机制，使用接口可以实现多态继承；接口中的所有方法都是抽象的，这些抽象方法由实现这一接口的不同类型来具体；接口还可以用来实现不同类之间的常量共享。

与抽象类不同的是：接口允许在看起来不相干的类之间定义共同行为。

3.在什么情况下，可以对父类对象的引用进行强制类型转换，使其转化成子类对象的引用？答：一个对象被塑型为父类或接口后，可以再一次被塑型回到它原来所属的类，即转化成原类对象的引用。

4.声明一个接口，此接口至少具有一个方法；在一个方法中声明内部类实现此接口，并返回此接口的引用。

//A类接口

public interface A{

void fuck();

}

//B类

public class B{

public A fuck(){

return new A(){

public void fuck(){

System.out.println("B类声明实现A接口类并返回接口的应用——Fuck you!");

}

};/*注意这里有分号“；”*/

}

}

//test5_4

public class test5_4 {

public static void main(String[] args){

new B().fuck().fuck();

}

}

运行结果：

7.什么是多态？如何实现多态？

答：多态性是指不同类型的对象可以响应相同的消息。利用向上塑性技术，一个父类的应引用变量可以指向不同的子类对象；而利用动态绑定技术，可以再运行时根据父类引用变量所指对象的世纪类型执行相应的子类方法，从而实现多态性。

Java语言程序设计

第六章课后习题答案

3.创建一存储若干随机整数的文本文件，文件名、整数的个数及范围均由键盘输入。// memory存储类

import java.io.*;

import java.util.Random;

public class memory {

private String name;

private int count;

private int Max;

private int Min;

public memory(String n,int c,int min,int max){

https://www.360docs.net/doc/435537421.html,=n;

this.count=c;

this.Min=min;

this.Max=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+random.nextInt(limit);

System.out.print(number);

System.out.print(" ");

out.write(number+" ");

}

out.close();

}catch(IOException iox){

System.out.println("方法startmemory()有问题");

}

}

}

//test6_3

import java.io.*;

import java.util.Scanner;

public class test6_3 {

public static void main(String[] args) throws IOException{ //BufferedReader

String fileName;

int count,min,max;

Scanner in = new Scanner(System.in);

System.out.println("输入要存储的文件名");

fileName=in.next();

System.out.println("输入随机数个数");

count=in.nextInt();

System.out.println("输入随机数最小值");

min=in.nextInt();

System.out.println("输入随机数最大值");

max=in.nextInt();

memory M=new memory(fileName,count,min,max);

M.startmemory();

}

}

}

运行结果：

naruto文件存储二进制数：

6.用记事本程序创建一篇包含几十个英语单词的小文章，要求从屏幕输出每一个单词。//test6_6

import java.io.*;

public class test6_6 {

public static void main(String[] args)throws IOException { FileReader fr=new FileReader("naruto.txt");

int s;

while((s=fr.read())!=-1){

if(s>='a'&& s<='z'|| s>='A' && s<='Z')

System.out.print((char)s);

else

System.out.print("\n");

}

fr.close();

}

}

运行结果：

8.创建一个学生类（包括姓名、年龄、班级、密码），创建若干该类的对象并保存在文件中（密码不保存），从文件读取对象后显示在屏幕上。

//Student类

import java.io.Serializable;

class Student implements Serializable{

String name;

int age;

int grade;

transient String secret;

public Student(String name,int age,int grade,String secret){ https://www.360docs.net/doc/435537421.html,=name;

this.age=age;

this.grade=grade;

this.secret=secret;

}

}

//test6_8

import java.io.*;

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")};

//创建输出