异常处理动手动脑及课后练习

Posted 2020-10-14 程序猿养成中

1.

.

 

代码：

import javax.swing.*;

public class AboutException {
public static void main(String[] a)
{
int i=1, j=0, k;
k=i/j;

try
{

k = i/j; // Causes division-by-zero exception
//throw new Exception("Hello.Exception!");
}

catch ( ArithmeticException e)
{
System.out.println("被0除. "+ e.getMessage());
}

catch (Exception e)
{
if (e instanceof ArithmeticException)
System.out.println("被0除");
else
{
System.out.println(e.getMessage());

}
}

finally
{
JOptionPane.showConfirmDialog(null,"OK");
}

}
}

运行结果：

2.

 

 

解答：

 

反编译：

以下是PPT给出的参考：

 

 

 生成的字节码指令不一样。

3.

 

 

 

里面的try抛出异常一，对应的catch（紧跟着的catch）接收一并执行，外层的try抛出异常二，对应的catch接收二并执行，抛出异常和接收异常这执行可以看成是一个单一的动作操作，最后的catch就没有抛出这一动作执行，所以不运行（因为抛出异常一已被接住）。

 

 4.

代码：

public class EmbededFinally {

public static void main(String args[]) {

int result;

try {

System.out.println("in Level 1");

try {

System.out.println("in Level 2");
// result=100/0; //Level 2

try {

System.out.println("in Level 3");

result=100/0; //Level 3

}

catch (Exception e) {

System.out.println("Level 3:" + e.getClass().toString());

}


finally {

System.out.println("In Level 3 finally");

}


// result=100/0; //Level 2

}

catch (Exception e) {

System.out.println("Level 2:" + e.getClass().toString());

}
finally {

System.out.println("In Level 2 finally");

}

// result = 100 / 0; //level 1

}

catch (Exception e) {

System.out.println("Level 1:" + e.getClass().toString());

}

finally {

. System.out.println("In Level 1 finally");

}

}

}运行结果：

 

 

此例题和上面例题的区别就在于，里面的catch所接住的方向变了。
按着程序顺序分析下来，当里面的try抛出异常时，只有外面的catch能接住，那么开始执行外面的catch，顺序就从刚才执行的语句之下执行下去了，即便是外面的catch交换顺序，结果一样不变。当有多层嵌套的finally时，异常在不同的层次抛出，在不同的位置抛出，可能会导致不同的finally语句块执行顺序。
总结：try catch这一模式，是有顺序依据的，当执行try语句是，紧接着的就是所对应的catch来执行，然后接着catch继续执行下去。

5.

源代码：

public class SystemExitAndFinally {
public static void main(String[] args)
{
try{
System.out.println("in main");
throw new Exception("Exception is thrown in main");
//System.exit(0);
}
catch(Exception e)
{
System.out.println(e.getMessage());
System.exit(0);
}
finally
{
System.out.println("in finally");
}
}
}运行结果：

finally语句一定会执行吗？答案必然是否定的 ，上述运行已经给出了结果。why?

JVM是java虚拟机，finally是由JVM保证执行，而System.exit(0)是正常退出程序，结束JVM的运行，那么最后finally就不再执行。

finally语句不被执行的唯一情况是先执行了用于终止程序的System.exit()方法。

6.

 

源代码：

// UsingExceptions.java
// Demonstrating the getMessage and printStackTrace
// methods inherited into all exception classes.
public class PrintExceptionStack {
public static void main( String args[] )
{
try {
method1();
}
catch ( Exception e ) {
System.err.println( e.getMessage() + "\\n" );
e.printStackTrace();
}
}

public static void method1() throws Exception
{
method2();
}

public static void method2() throws Exception
{
method3();
}

public static void method3() throws Exception
{
throw new Exception( "Exception thrown in method3" );
}
}

 

 

 

 

 7.依据对本讲多个示例程序的分析，请自行归纳总结出Java多层嵌套异常处理的基本流程。

 答：

1）在java语言中，通常将可能出现异常的语句放入try{}语句中，将出现错误后需要执行的语句放入到catch{}语句中，将无论是否发生异常都要执行的语句放在finally{}语句中。

2）当程序执行出现异常的时候，系统会抛出一个异常，然后由try{}语句中中出现异常的地方转到catch{}语句中。不过不管有没有异常产生，finally{}中的语句都将执行。

3）如果系统出现系统错误或者运行Runtime异常，jvm会结束程序运行，不一定会执行finally{}中的语句。

4）如果try{}中产生的异常在catch中没有处理，系统将停止程序，也不会执行finally中的语句。

基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行。

 

 8.

 

代码：

import java.util.*;
public class PrintExceptionStack
{
public static void main(String[] args)
{
Scanner sc =new Scanner(System.in);
int score=0;
System.out.print("请输入成绩：");
try
{
score=sc.nextInt();
if(score>=0&&score<=59)
{
System.out.println("不及格");
}
else if(score>=60&&score<=69)
{
System.out.println("及格");
}
else if(score>=70&&score<=79)
{
System.out.println("中");
}
else if(score>=80&&score<=89)
{
System.out.println("良");
}
else if(score>=90&&score<=100)
{
System.out.println("优");
}
else
{
System.out.println("输入的数字过大或过小");
}
}
catch(Exception e)
{
System.out.println("输入错误，请输入正确数字！");
}
}
}

 运行结果：