Java异常处理实验

（一）上机并运行下面程序，看看会出现什么问题？

package case1;

class Example1{
  static void method() {
   int a = 0;
 int b = 10 / a;
  }
  public static void main(String[] args) {
 method();
  }
 }

分析程序出错的原因？
Method函数方法中a的值为零，作为除数时发生异常
修改程序使之能够正常运行。

package case1;

class Example1 {
    static void method() {
        int a = 0;
        try {
            int b = 10 / a;
        } catch (ArithmeticException exc) {
            System.out.println("Can't divide by zero");
        }
    }

    public static void main(String[] args) {
        method();
    }
}

（二）填补下列程序。体会throw关键字的使用。

class Example2 {
  static int method(int x,int y) {
    if(x < y) 
      throw new ArithmeticException("x);
    return x - y;
  }
  public static void main(String[] args) {
                      
  }
}

补充程序，使之触发异常；

package case2;

public class Example2 {
    static int method(int x, int y) {
        if (x < y)
            throw new ArithmeticException("x);
        return x - y;
    }

    public static void main(String[] args) {
        method(1,0);
    }
}

（三）填补下列程序，完成div()方法，并且使用throws语句。

package case3;

class Math {
    // 代码补充处
    double div(double x, double y)throws Exception{
        double result = x / y;
        return result;
    }
}

public class ThrowsDemo01 {
    public static void main(String args[])  {
        Math m = new Math();
        try {
            System.out.prdoubleln("除法操作：" + m.div(10, 2));
        } catch (Exception e) {
            e.prdoubleStackTrace();
        }
    }
}

（四）分析下列程序，并打印输出结果。

package case4;

public class FinallyExample {
    static void method(int i) {
        try {
            if (i == 2) {
                System.out.println("第2种情况： 发生算术运算异常");
                throw new ArithmeticException();
            }
            if (i == 3) {
                System.out.println("第3种情况： 发生数字格式异常");
                throw new NumberFormatException();
            }
            if (i == 4) {
                System.out.println("第4种情况： 发生数组下标越界异常");
                throw new ArrayIndexOutOfBoundsException();
            }
            System.out.println("第1种情况： 没有发生异常");
        } catch (ArithmeticException e) {
            System.out.println("异常被捕捉处理″");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("异常被捕捉，但又被重新引发");
            throw e;
        } finally {
            System.out.println("这是finally子句");
        }
        System.out.println("这是try语句后的代码");
    }

    public static void main(String args[]) {
        for (int i = 1; i < 5; i++) {
            try {
                method(i);
            } catch (RuntimeException e) {
                System.out.println("由main方法捕捉到异常");
            }
        }
    }
}

第1种情况： 没有发生异常
这是finally子句 这是try语句后的代码
第2种情况： 发生算术运算异常
异常被捕捉处理″
这是finally子句
这是try语句后的代码
第3种情况： 发生数字格式异常
这是finally子句
由main方法捕捉到异常
第4种情况： 发生数组下标越界异常
异常被捕捉，但又被重新引发
这是finally子句
由main方法捕捉到异常

（五）分析下列程序,如果函数method正常运行并返回，会显示哪些信息？

package case5;

public class Test {
    try
    { 
　　　　　　method(); 
　　　　　　System.out.println("Hello World"); 
　　　　　}　　　catch(
    ArrayIndexOutOfBoundsException e)　　　{ 
　　　　System.out.println("Exception?"); 
　　　}　　　catch(
    Exception e)　　　{ 
　　　　System.out.println("Exception1"); 
　　　}　　　finally{
　　　　System.out.println("Thank you!"); 
　　　　}

}

Hello World
Thank you!

（六）如下代码输出结果是什么？为什么？

package case6;

public class test {
    public static void main(String args[]) {
        int i = 1, j = 1;
        try {
            i++;
            j--;
            if (i / j > 1)
                i++;
        } catch (ArithmeticException e) {
            System.out.println(0);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(1);
        } catch (Exception e) {
            System.out.println(2);
        } finally {
            System.out.println(3);
        }
        System.out.println(4);
    }
}

输出结果：
0
3
4

原因： 初始时i=1,j=1;分别经过自增和自减操作后，其值变为2和0.在运行 if（i/j>1）时发生算数异常，被随后的第一个catch语句所捕捉，打印输出0； 无论是否有异常拋出，都会执行 finally 语句块中的语句，所以随后打印输出3； 最后打印输出4。

（七）编写一个自定义异常MyException能够打印一个自定义消息msg，之后写一个测试类，在调用方法发生自定义异常时能够打印出自己的消息。

package case7;

/*
格式：
public class 异常类名 extends Exception{
    无参构造
    带参构造
}
*/
public class MyException extends Exception {

    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }

}

package case7;

public class Score {

    public void checkScore(int score) throws MyException {
        if (score < 0 || score > 100) {
            throw new MyException("所给分数有误，请确保分数在0-100之间");
        } else {
            System.out.println("成绩正常");
        }
    }
}

package case7;

import java.util.Scanner;

public class ScoreTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入分数：");

        int score = sc.nextInt();

        Score t = new Score();
        try {
            t.checkScore(score);
        } catch (MyException e) {
            e.printStackTrace();
        }
        sc.close();
    }
}

（七）Java中，关键字try、catch、finally、throw和throws，各有何作用？

① try:用于监听。将可能抛出异常的代码放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
②catch：用于捕获异常。
③finally：总是会被执行，主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
④throw:用于抛出异常。
⑤throws:用于方法签名中，声明该方法可能抛出的异常。

（八）在java中是如何处理异常的？

Java 通过面向对象的方法来处理异常。
在一个方法的运行过程中，如果发生了异常，则这个方法会产生代表该异常的一个对象，并把它交给运行时的系统，运行时系统寻找相应的代码来处理这一异常。

（九）当需要捕获多个可能发生的异常时，各个catch块的顺序有什么要求，为什么?

①需要捕获多个可能发生的异常时，一定要把异常范围小catch块放在前面，范围大的放在后面。
②对于try里面发生的异常，对于发生的异常会按照catch块从上往下匹配。当匹配某一个catch块的时候，就直接进入到该catch块里面去了，而对于后面的catch块的不做任何处理，直接跳过，全部忽略掉。

（十）Java中常见的异常类有哪些以及什么情况下会触发异常？

①按照Java异常需要处理的时机分为两种异常：
编译时异常:必须显示处理，否则程序就会发生错误，无法通过编译；
运行时异常:无需显示处理，也可以和编译时异常一样处理。
②触发异常的情况：
a. Java 内部错误发生异常，Java 虚拟机产生的异常;
b. 编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。这种异常称为未检査的异常，一般需要在某些类中集中处理这些异常;
c. 通过 throw 语句手动生成的异常，这种异常称为检査的异常，一般用来告知该方法的调用者一些必要的信息。

（十一）下列关于finally的说法正确的是（B）：

A. 如果程序在前面的catch语句中找到了匹配的异常类型，将不执行finally语句块
B. 无论程序是否找到匹配的异常类型看，都会执行finally语句块中的内容
C. 如果在前面的catch语句中找到了多个匹配的异常类型，将不执行finally语句块
D. 只要有catch语句块，任何时候都不会执行finally语句块