Java异常处理习题

一、选择题

1、java中用来抛出异常的关键字是（ ）

A.try      B.catch    C.throw          D.finally

2、关于异常，下列说法正确的是（ ）

A. 异常是一种对象        B.一旦程序运行，异常将被创建

C．为了保证程序运行速度，要尽量避免异常控制     D.以上说法都不对

3、（）类是所有异常类的父类。

A.Throwable     B.Error      C.Exception    D. AWTError

4、java语言中，下列哪一子句是异常处理的出口（ ）

A.try{ …}子句   B.catch{…}子句  C.finally{…}子句 D.以上说法都不对

5.下列程序的执行，说法错误的是（ ）

class MultiCatch

 {

   public static voidmain(String args[])

     {

       try

          {

            inta=args.length;

            int b=42/a;

            intc[]={1};

            c[42]=99;

           System.out.println(“b=”+b);

          }

      catch(ArithmeticException e)

          {

            System.out.println(“除0异常：”+e);

           }

      catch(ArrayIndexOutOfBoundsException e)

          {

            System.out.println(“数组超越边界异常：”+e);

            }

           }

    }

A.程序将输出第15行的异常信息

B.程序第10行出错

C.程序将输出“b=42”

D.程序将输出第19行的异常信息

6、下列程序的执行，说法正确的是（ ）

class ExMulti

{

  static voidprocedure()

  {

    try

     {

      int c[]={1};

      c[42]=99;

     }

   catch(ArrayIndexOutOfBoundsException e)

     {

      System.out.println(“数组超越界限异常：”+e);

     }

   }

    public static voidmain(String args[])

    {

      try

        {

          procedure();

          inta=args.length;

          int b=42/a;

         System.out.println(“b=”+b);

         }

      catch(ArithmeticException e)

         {

          System.out.println(“除0异常：”+e);

         }

       }

   }

A.程序只输出第12行的异常信息

B.程序只输出第26行的异常信息

C.程序将不输出异常信息

D.程序将输出第12行和第26行的异常信息

7、下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。

class TrowsDemo

{

  static voidprocedure() throws IllegalAccessExcepton

  {

    System.out.println(“inside procedure”);

   throw_______IllegalAccessException(“demo”);

  }

 public static voidmain(String args[])

   {

     try

      {

        procedure();

      }

      ___________

      {

       System.out.println(“捕获：”+e);

      }

    }

finally语句块中的代码（     ）

A．总是被执行   

B．当try语句块后面没有catch时，finally中的代码才会执行

C．异常发生时才执行                         

D．异常没有发生时才被执行

8、抛出异常应该使用的关键字是（     ）

A．throw         B．catch      C．finally           D．throws

9、自定义异常类时，可以继承的类是（     ）

A．Error           B．Applet          C．Exception及其子类  D．AssertionError

10、在异常处理中，将可能抛出异常的方法放在（     ）语句块中

A．throws               B．catch             C．try          D．finally

11、对于try{……}catch子句的排列方式，下列正确的一项是（     ）

A．子类异常在前，父类异常在后   B．父类异常在前，子类异常在后

C．只能有子类异常                              D.父类异常与子类异常不能同时出现

12、使用catch(Exception e)的好处是（     ）

A．只会捕获个别类型的异常

B．捕获try语句块中产生的所有类型的异常

C．忽略一些异常

D．执行一些程序

13．请问所有的异常类皆继承哪一个类？（    ）

A．java.lang.Throwable　　              B．java.lang.Exception

C．java.lang.Error　                    D．java.io.Exception

14．对于已经被定义过可能抛出异常的语句，在编程时（      ）。

A．必须使用try／catch语句处理异常，或用throw将其抛出。

B．如果程序错误，必须使用 try／catch语句处理异常。

C．可以置之不理。

D．只能使用try／catch语句处理。

15．下面程序段的执行结果是什么？（      ）

　　public class Foo{

　　　public static voidmain(String[] args){

　　　　try{

　　　　　　return;}

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

　　　　　}

　　　}

　　}

A．编译能通过，但运行时会出现一个例外。  B．程序正常运行，并输出 “Finally”。

C．程序正常运行，但不输出任何结果。　D．因为没有catch语句块，所以不能通过编译。

16．下面是一些异常类的层次关系：

       java.lang.Exception

          java.lang.RuntimeException

              java.lang.IndexOutOfBoundsException

                  java.lang.ArrayIndexOutOfBoundsException

java.lang.StringIndexOutOfBoundsException

假设有一个方法X，能够抛出两个异常，Array Index和String Index异常，假定方法X中没有try-catch语句处理这些异常，下面哪个答案是正确的？（   ）

A．方法X 应该声明抛弃ArrayIndexOutOfBoundsException和StringIndexOutOfBounds-Exception。

B．如果调用X的方法捕获IndexOutOfBoundsException，则ArrayIndexOutOfBounds- Exception和StringIndexOutOfBoundsException都可以被捕获。

C．如果方法X声明抛弃IndexOutOfBoundsException，则调用X的方法必须用try-catch语句捕获。

D．方法X不能声明抛弃异常。

17．下面的方法是一个不完整的方法，其中的方法unsafe()会抛出一个IOException，那么在方法的①处应加入哪条语句，才能使这个不完整的方法成为一个完整的方法？（    ）

①  ____________________________

②  { if(unsafe())   {//do something…}

③    else if(safe())  {//do the other…}

④  }

A．public IOExceptionmethodName()   B．public void methodName()throw IOException

C．public void methodName() 　　　    D．public voidmethodName() throws IOException

18．如果下列的方法能够正常运行，在控制台上将不显示什么？（     ）

　　public void example( ){

　　　try{

　　　　　 unsafe();

　　　　　System.out.println(“Test1”);

　　　　　}

　　　catch(SafeException e)

　　　　　{System.out.println(“Test2”);}

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

　　　System.out.println(“Test4”);

　　}

A．Test 1          B． Test 2          C．Test 3            D． Test 4

二、填空题

1、catch子句都带一个参数，该参数是某个异常的类及其变量名，catch用该参数去与____抛出异常 ___对象的类进行匹配。

2、java虚拟机能自动处理____  运行 ___异常。

3、变量属性是描述变量的作用域，按作用域分类，变量有局部变量、类变量、方法参数和___全局参数 ____

4、同一段程序可能产生不止一种异常。可以放置多个____ catch ____子句，其中每一种异常类型都将被检查，第一个与之匹配的就会被执行。

5、捕获异常要求在程序的方法中预先声明，在调用方法时用try-catch-___  finally___语句捕获并处理。

6、java语言认为那些可预料和不可预料的出错称为_____异常____

7、按异常处理不同可以分为运行异常、捕获异常、声明异常和___抛出异常___几种。

8、抛出异常的程序代码可以是___自定义异常类或者是JDK中的某个类，还可以是JVN.

9、抛出异常、生成异常对象都可以通过____throw_____语句实现。

10、捕获异常的统一出口通过___finally______语句实现。

11、java语言的类库中提供了一个_____ Throwable_____类，所有的异常都必须是它的实例或它子类的实例。

12、Throwable类有两个子类：____ Error______类和Exception类。

13、对程序语言而言，一般有编译错误和______运行______错误两类。

14、一个try语句块后必须跟___catch_______语句块，____finally______语句块可以没有

15、自定义异常类必须继承_____Exception_____类及其子类

16、异常处理机制允许根据具体的情况选择在何处处理异常，可以在_____catch_____捕获并处理，也可以用throws子句把他交给____调用栈中上层的方法 ______处理

三．简答题

1．什么是异常？简述Java的异常处理机制。

答：异常是指在运行代码序列中产生的异常情况，换句话说异常是一个运行时的错误。

程序在运行时出现异常没有相应的处理措施时，Java会自动捕获并在异常发生处结束执行

2．系统定义的异常与用户自定义的异常有何不同？如何使用这两类异常？

系统定义的异常时特定情况出现的问题，而此时用来对可能遇到的问题进行处理。用户定义的是自己觉得可能会出现问题时，需要处理的异常，这样做可避免程序中断或是出现未知错误。

3．在Java的异常处理机制中，try程序块、catch程序块和finally程序块各起到什么作用？try-catch-finally语句如何使用？

4．说明throws与throw的作用。

throw语句用在方法体内,表示抛出异常,由方法体内的语句处理  

throws语句用在方法声明后面,表示再抛出异常,由调用这个方法的上一级方法中的语句来处理

5.Throw/throws有什么联系和区别？

1）throws出现在方法函数头；而throw出现在函数体；  

 2）throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常；  

 3）两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

6.如何自定义异常类？

     答：class  异常名称 extends Exception{}

7.谈谈final、finally的区别和作用         

final是全局变量声明的时候使用，意思是这个变量不可被修改，不可被override，一般用于声明常量，或者系统设置的值。

finally是在try-catch-finally块中配套使用，作用是，不管代码执行了try还是catch，最后一定会执行finally里面的代码

8.如果try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行？

finally是一定会执行的

只有代码中有system.exit()这一种情况才不会执行finally

因为终止了虚拟机进程

finally会在return之前执行

如果在finally里面有return情况会更复杂

9.Error和Exception有什么区别？

Error类和Exception类都继承自Throwable类。

Error的继承关系：

java.lang.Object >java.lang.Throwable > java.lang.Error

Exception的继承关系：

java.lang.Object >java.lang.Throwable >java.lang.Exception

Exception：

1．可以是可被控制(checked) 或不可控制的(unchecked)

2．表示一个由程序员导致的错误

3．应该在应用程序级被处理

Error：

1．总是不可控制的(unchecked)

2．经常用来用于表示系统错误或低层资源的错误

3．如何可能的话，应该在系统级被捕捉

10.什么是RuntimeException？列举至少4个RuntimeException的子类

RuntimeException是java中所有运行时异常的父类，实际运行时出现的都是它的子类，看看RuntimeException的Java doc就可以随便列出几个：

1，

Object x = new Integer(0);

     System.out.println((String)x);

当试图将对象强制转换为不是实例的子类时，抛出该异常（ClassCastException)

2．

int a=5/0;

一个整数“除以零”时，抛出ArithmeticException异常。

3,

String s=null;

int size=s.size();

当应用程序试图在需要对象的地方使用 null 时，抛出NullPointerException异常

4,

“hello”.indexOf(-1);

指示索引或者为负，或者超出字符串的大小，抛出StringIndexOutOfBoundsException异常

5，

String[] ss=new String[-1];

如果应用程序试图创建大小为负的数组，则抛出NegativeArraySizeException异常。

2.3.1 try语句　
try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
2.3.2 catch语句　
catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。　
2.3.3 finally语句　
try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

3．try-catch-finally程序块的执行流程以及执行结果比较复杂。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1．如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：
–>如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
–>如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
–>如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：
–>如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：
–>如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
–>如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
–>如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：
–>如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
–>如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。
如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。
这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。）
–>如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：
–>如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。
–>如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。
3．如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：
–>如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
–>如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。