JAVA程序设计第七章作业

1 补充题

1.简述Java Error类与Exception类的区别。

Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。

Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

2.简述异常处理的两种方式，并举例说明区别。

异常处理包括声明抛出处理和程序捕获处理两种方式。

声明抛出处理：包括隐式声明抛出和显式声明抛出。
①隐式声明抛出：异常类型是RuntimeException或是其子类，程序方法可以对异常不作任何声明抛出或处理，直接交给调用该方法的地方处理，程序能编译通过，不会对可能产生异常的代码给出提示。
例如：

import java.util.*;
public class TestEmptyStack {
     
    public static void main(String[] args) {
     
        Stack st=new Stack();
        Object ob=st.pop();
    }
}

结果：

Exception in thread "main" java.util.EmptyStackException
	at java.util.Stack.peek(Stack.java:102)
	at java.util.Stack.pop(Stack.java:84)
	at TestEmptyStack.main(TestEmptyStack.java:5)

②显示声明抛出：异常类型不是RuntimeException类或其子类时可以用显示声明抛出。
例如：

import java.io.*;
class TestScreenIn{
     
    public static void main(String[] args) throws IOException{
     
        BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
        String c1;
        int i = 0;
        String[] e = new String[10];
        while(i<10){
     
            c1 = keyin.readLine();
            e[i] = c1;
            i++;
        }
    }
}

程序捕获处理：包括非嵌套捕获和嵌套捕获。是由try －catch组成的一个异常处理块结构，最为完整的方式是try-catch-finally语句。
try{
　 statements
}
catch (ExceptionType1 ExceptionObject){
　 Exception Handling
}
catch(ExceptionType2 ExceptionObject) {
　 Exception Handling
}……
finally{
　 Finally Handling
}

①非嵌套捕获

import java.io.*;
class TestScreenIn{
     
   public static void main(String[] args) throws IOException {
     
     BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
     String c1;
     int i=0;
     String[] e = new String[10];
     while(i<10){
     
       try{
     
           c1 = keyin.readLine();//可能发生IO异常
           e[i] = c1;
           i++; 
       }
       catch (IOException e1) {
     
          e1.printStackTrace(); return;
       }
     }    
   }
}

②嵌套捕获

public class NestingException{
     
 public static void main(String[] args){
     
    int a,b,c;
    a=67; b=0; 
    try{
     
       try{
     
          c=a/b;
       }
       catch(ArithmeticException ae){
     
          b = 10;
       }
      System.out.println(a+"/"+b+"="+ a/b);
      //此外还可能有别的代码产生异常，由外层try/catch语句来捕获处理
       ……
    }
    catch(Exception e){
     
      e.printStackTrace();
    }
  }
} 

4.仿照例7.9，自定义一个异常类，并在某场景下抛出异常对象。

public class MyException extends Exception {
     
    MyException(String msg) {
     
        super(msg);
    }

    static void thorwone() throws MyException {
     
        int exit = 999;
        if (exit == 999) {
     
            throw new MyException("exit = 999");
        }
    }
    public static void main(String args[]){
     
        try{
     
            thorwone();
        }
        catch(MyException e){
     
            e.printStackTrace();
        }
    }
}