第4章-Java语言与面向对象作业习题与答案

第4章 Java语言与面向对象作业习题与答案

一、简答题

1．什么是对象？什么是类？

对象是一种抽象数据类型。它包含了事物的静态特征（属性）和动态特征（行为）两大特征。

类是一组同种对象的集合与抽象。即是具有相同属性和方法的一组对象集合。

2．Java语言的单继承是指什么？

一个类可以派生出多个子类，但子类只允许有一个父类，而不允许存在多个父类。

3．在一个共有类中的数据成员及方法成员的访问控制符为缺省，则这个类可供什么样的包引用？

当一个类的访问控制符为public共有时，表明这个类作为整体对其它类是可见和可引用的；但其数据成员和方法成员访问控制符为缺省时，它们只能被包中类（含当前类）引用。 4．抽象类的用途

（1）设计在更高的层次上进行，不考虑具体对象，从而大大简化了处理问题的复杂性；

（2）设计出的类也具有更加良好的可扩展性。

5．什么是非静态的成员变量？

非静态成员即为实例成员变量（没有加static修饰的变量）。

6．异常Exception和错误Error有什么不同？Java如何处理它们？

答：错误通常是指程序本身存在非法情形，常常是因为代码存在问题而引起的，如造成系统崩溃、虚拟机粗错、动态失败等，这一类错误无法恢复或不可能捕获，并将导致应用程序中断。

异常表示另外一种“非同寻常”的错误。这种错误通常是不可预测，但可以被捕获且可以恢复。常见的异常情况包括存不足、找不到所需文件等。

对于错误，编程人员可以通过对程序进行更仔细的检查，以避免这种错误。

对于异常，可以使用捕获机制进行捕获，再编写出相应的处理程序。

7．简单述Java的异常处理机制。

答：Java采取“抛出—捕获”的方式，一旦一个异常想象产生，Runnable环境和应用程序会抛出各种标准类型和自己定义的异常，系统就可以捕获这些异常，并一定有相应的机制来处理它，确保不会产生司机、死循环或其它对操作系统的损害，从而保证了整个程序运行的安全性。

8．简单述throw语句和throws关键字之间的差别。

答：throw语句是在一个方法中用来直接抛出异常对象，其格式是：

throw 异常对象；

throws关键字是用一个方法声明首部，用来指出这个方法中可能产生若干种异常，其格式：[方法修饰符] 返回类型方法名（参数表）throws 异常类型表

{ /*方法体*/ }

二、填空题

1．所有Java应用程序都必须包含的一个类方法是 main() 。

2．面向对象程序设计语言的三种重要特性是封装性、继承性和多态性。

3．方法重载与方法覆盖的不同有：方法重载是指允许在同一个类中定义多个同名方法，它们通过形参的个数或形参参数的类型来区别；方法覆盖是指在子类中重新定义了与父类中的方法同名的方法。

4．面向对象程序设计语言的多态的事项方法主要有三种：方法重载、方法覆盖和接口。

5．对象之间的信息通过消息传递机制来完成。

6．成员变量的修饰符有（写出6种）public, friendly, protected, private, final, static。7．整个类共同拥有的方法是用static修饰的方法或叫类成员方法；它具有统计一个类的实例个数等用途。

8．引用父类中的成员用super；引用当前的类或对象用this。

9．在面向对象中，继承有两种含义，分别指在类的层次结构中，子类自动继承父类的特性和同一类的所有实例对象都具有所属类的特征。

10．在Java语言中，所有类都是Object类的子类。

11．多继承问题指的是一个类有多个父类问题；在Java语言过接口方法解决多继承问题。 12．接口是一种特殊的类，它只能定义一些抽象方法和常量。

13．在Java语言中，一组类和接口的集合通常被称为类库或API包或应用程序接口。

14．给出引用包的两种方法是：使用包名、类名做前缀；使用import语句。

15．Java语言异常处理三种方式是：捕获异常、声明异常和自定义异常

16．程序设计过程中可能会出现的两种错误是编译错误和运行错误。

17．程序设计过程后的运行错误大致有三类。它们是逻辑错误、用户输入不合法和硬件设备出错。

18．在Java语言中，用try-catch-final结构来捕获并处理异常。

19．用户程序使用throw new 异常类名；抛出自己的异常。

20．自定义异常类必须继承Exception类。

三、选择题

1．下述声明中哪一种可以防止该类产生子类？

A．static class DEF{} B．private calss DEF{}

C．abstract class DEF{} D．final public class DEF{}

E．final abstract class DEF{}

答案：D。

Final防止有子类继承，因此可选择D、E。但final不可以和abstract连用，因此E也错。

2．如果要求子类可以在任何包中访问父类的成员，下面哪一个修饰符可以达到这个目标的最为严格的修饰符？

A．public B．private C．protected D．无修饰符答案：C。

A和C都可以做到这点，但A更为宽松，不仅仅是任何包中的子类，而且任何包中和包外的类都可以访问它。D只能被同一个包的类访问，所以D不符合要求。而B比D更为严格。3．程序的封装性是如何实现的？

A．由应用程序的设计者实现B．由应用程序的使用者实现

C．由应用程序的设计和使用者实现D．由操作系统实现

答案：A。

4．下列哪个选项是错误的？

A．子类对象可以转化成父类对象

B．父类对象一般不转化成子类对象

C．子类对象与父类对象之间不能转化

D．子类对象转化为父类对象后，对于子类与父类共有的方法，仍然调用子类的方法。

答案：C。

5．下列哪个选项能体现Java语言的多态性？

A．匿名类B．布类C．方法重载D．方法覆盖

答案：C。

6．下列哪个选项正确？

A．Error类是一个RuntimeException异常

B．任何抛出一个RuntimeException异常的语句必须包含在try块。

C．任何抛出一个Error对象的语句必须包含在try块。

D．任何抛出一个Exception异常的语句必须包含在try块。

答案：D

Error代表程序中不可捕获的问题，与Exception类同在一个层次，而RuntimeException 是Exception的子类，所以Error类不可能是一个RuntimeException类型的异常；抛出一个RuntimeException异常不一定要在try块，它是由JVM正常抛出，不需要throw和throws语句，因而也不一定要有catch语句去捕获，所以可以不出现在try块中；Error类型的问题是不可恢复的，多以没有规定要去捕获Error，因而也可以不出现在try块中；对于抛出一个Exception对象的语句，如果没有包含在try块之，有可能编译不能通过，因此选项D是必须的。

7．有如下程序，给出程序运行结果？

import java.io.*;

public class ExceptionTest

{ public static void main(String args[])

{ try

{ methodA(); }

catch(IOException e){ System.out.println(“Caught Exception”);

}

public void methcdA()

{ throw new IOException(); }

}

}

A．代码不能编译B．输出：Caught Exception

C．输出：CaughtIO Exception D．程序正常运行后无任何信息输

出

答案：A

首先，methcdA是非静态方法，不能出现在main中；其次，就算methcdA是静态方法，IOException是可检测异常，必须被catch捕获或是被throws声明，但程序中没有声明throws，所以try语句块不可能抛出IOException这个异常，而catch也就谈不到捕获它了，所以两个条件都没有满足，编译同样错误。

在methcdA方法定义语句的前面加static，后面加上throws IOException，程序就可以调试通过了。

8．有如下程序，在程序的point x处增加如下哪个选项程序才能通过编译？

public class ExceptionTest

{ calss TestException extends Exception{}

public void runTest() throws TestException{}

public void test() //point x

{ runTest(); }

}

A．throws Exception B．catch(Exception)

C．throws RuntimeException D．catch(TestException)

答案：A

没有try就不能有catch，所以B，D错；而C里边的RuntimeException是Exception 的子类，不能用捕“小鱼”的工具去捕“大鱼”，所以错误；由于runTest()抛出的是TestExcption，而TestExcption又是Excption的子类，因此用到runTest方法就必须抛出Excption异常。

9．有如下程序，该程序的运行结果是？

public class Exc_4

{ public static void main(String args[])

{ try{ return; }

finally{ System.out.println(“Finally”); }

}

}

A．程序无输出B．程序输出“Finally”

C．代码可以通过编译但执行时产生异常D．因为缺少catch块所以编译出错答案：B

程序中有catch则必须有try，但反之不成立，所以D不对；关于try-catch-finally 的问题，程序中如果遇到return，则finally块先被执行，然后再执行return，而finally 块后面的语句将不被执行。如果遇到System.exit(1)，则退出JVM，整个程序退出，当然finally块其后的语句都不执行。

10．有如下程序，如果methodA()抛出IOException异常，该程序的运行结果是？

class Exc_5

{ public static void main(String args[])

{ try{ methodA(); }

catch(IOException e){ System.out.println(“caught IOException”); }

catch(Exception e){ System.out.println(“caught Exception”);} } }

}

答案：caught IOException

如果methodA()抛出IOException异常，被语句5捕获，输出“caught IOException”

四、编程题

1．试编写出要创建一个员工类Employee。这个类中的一个成员变量应该包括员工号empNum、Name；其操作方法一个是用来设置set员工的工号，另一个操作方法是用来取得get员工工号。（建议按两步完成设计：一步是写出类的头结构；另外一步是完成成员声明。）

class Employee

{ public empNum;

public Name;

public int setNum(int _empNum)

{

int empNum=_empNum;

return empNum;

}

int void getNum()

{

Employee A;

int empNum=A.setNum(2001);

System.out.println("员工工号为：" + empNum);

}

}

2．创建一个名为List的显示类，它可以存储任何类型的对象，并可以在任何时候增加或删除对象。

class List

{ private int maxItems=100;

private int numItems=0;

private Object[] list=null;

public List()

{ list=new Object[maxItems]; }

public List(int _maxItems)

{

maxItems=_maxItems;

list=new Object[maxItems];

}

public void add(Object obj)

{

list[numItems]=obj;

numItems++;

}

public void delete(int pos)

{

for(int i=pos+1; i

{ list[i-1]=list[i]; }

numItems--;

}

public Object get(int pos)

{ return list[pos]; }

public int getSize()

{ return numItems; }

public boolean isFull()

{ return (numItems>=maxItems); }

public String toString()

{ String s=new String();

for(int i=0; i

{ s+="\n"+list[i].toString(); }

return s+"\n";

}

}

public class ListTest

{ public static void main(String[] args)

{

List list=new List();

list.add(new Double(10.0));

list.add(new String("Java by Definition"));

list.add(new Integer(-10));

System.out.println(list);

System.out.println("Position 0:"+list.get(1));

list.delete(2);

list.delete(0);