java第七章作业

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

Error（错误）：不是程序需要捕获和进行处理的，例如OutOfMemoryError，当Error发生时程序会停止。
Exception（异常）：需要程序进行捕获和处理。

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

• 声明抛出处理

  • 隐式声明抛出：异常类型是RuntimeException或者是其子类，程序方法可以对异常不作任何声明抛出或处理，直接交给调用该方法的地方处理，程序能编译通过，不会对可能产生异常的代码行给出提示。
  • 显式声明抛出：在方法声明后加throws Exception，显式声明抛出异常。
  • 见示例1、2。

• 捕获处理
  使用try-catch-finally语句块来捕获异常，try里面存放可能出现异常的代码，catch里面接受异常对象，并处理异常信息，finally的语句则在执行完try或catch后最后执行。
  捕获处理包括非嵌套与嵌套两种，具体用法见示例3、4。

1.隐式声明抛出

public class Test {
	public static void main(String[] args) {
        int a,b,c;
        a=67;
        b=0;
        c=a/b;
        System.out.println(a+"/"+b+"="+c);
    }
}

2.显式声明抛出

import java.io.*;
public class Test{
   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[2];
     while(i<2){
        c1 = keyin.readLine(); 
        e[i] = c1;
        i++; 
     }    
   }
}

3.异常捕获处理（非嵌套）

import java.io.*;
public class Test{
   public static void main(String[] args){
     BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
     String c1;
     int i=0;
     String[] e = new String[2];
     while(i<2){
       try{
           c1 = keyin.readLine(); 
           e[i] = c1;
           i++; 
       }
       catch (IOException e1) {
           System.out.println("系统有IO错误");
       }
     }    
   }
}

4.异常捕获处理（嵌套）

public class Test {
	public static void main(String[] args) {
        int a,b,c;
        a=67;
        b=0;
        try{
            try{
                c=a/b;
            }
            catch(ArithmeticException ae){
                b = 10;
                c = a/b;
                System.out.println(a+"/"+b+"="+c);
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
}

3、选取RuntimeException类的五个子类，编写抛出并捕获上述子类异常的程序。（例如算术异常，空指针异常，类转换异常，数组越界异常等）

算术异常

public class Test {
    public static void main(String[] args) {
        int a,b,c;
        a=67; b=0;
        c=a/b;
        System.out.println(a+"/"+b+"="+c);
    }
 }

空栈异常

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

空指针异常：

public class Test {
 private static int[] x;
 public  static void main(String[] args){
     System.out.println(x[0]);
 }
}

类转换异常：

class Father{
    String name = "Dad";
}

class Son extends Father{
    String cname = "Son";
}

public class Test {
    public static void main(String[] args){
        Father f = new Father();
        Son s = new Son();
        s = (Son)f;
        System.out.println("Success");
    }
}

数组越界异常

public class Test {
    public static void main( String[] args) {
       String ss = args[2]; 
       System.out.println(ss);
    }
   }

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

class MyException extends Exception {
    MyException(String msg){
        super(msg);    
    }
    static void check(String s) throws MyException{
        if(s.length() > 10){
            throw new MyException("字符串过长!");
        }
        else{
            String ss=s.toUpperCase();
            System.out.println(ss);
        }
    } 
    public static void main(String[] args){
        try{
            String sss="aaaaaaaaaaaaaaaaaaa";
            check(sss);
        }
        catch(MyException e)
        {e.printStackTrace();}
    }
}