throws 和throw 的范围区别

public class TestExceptionSer {
    public void testExceptionOne() throws RuntimeException{
         throw new ExceptionTest("500","throw 子类，thorws 父类异常");

    }
    public void testExceptionTwo() throws ExceptionTest{
        throw new RuntimeException();
    }
    
    
    public void testExceptionThree() throws RuntimeException{
        throw new RuntimeException();

   }
   public void testExceptionFour() throws ExceptionTest{
       throw new ExceptionTest("500","throw 子类，thorws 父类异常");
   }
}

/**
 * 
 * 〈功能详细描述〉测试throws 与throw 范围
 *
 * @author 
 * @since v1.0.1
 */
public class ExceptionTest extends RuntimeException {

    /**
     */
    private static final long serialVersionUID = 1L;

    /**
     * 错误码
     */
    private String code;

    /**
     * 错误信息
     */
    private String message;

    public ExceptionTest(String code, String message) {
        this.code = code;
        this.message = message;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public static long getSerialversionuid() {
        return serialVersionUID;
    }

}

    TestExceptionSer test = new TestExceptionSer();
  //声明为父类异常，方法体抛出子类异常，catch 可以用父类捕获
    try {
        test.testExceptionOne();
        }
      catch (RuntimeException e) {
        System.out.println("方法体抛出子类异常");
    }
    //声明为父类异常，方法体抛出子类异常，catch 可以用子类捕获（catch 捕获的异常为方法体抛出的明确异常类，可以用异常类及其父类进行捕获）
  try {
      test.testExceptionOne();
    } catch (ExceptionTest e) {  
    System.out.println("ExceptionTest+++++++++++++"); 
    }
  //声明为父类异常，方法体抛出子类异常，catch 可以用子类捕获（catch 捕获的异常为方法体抛出的明确异常类，可以用异常类及其父类进行捕获，
  //如果同时添加异常类及其父类catch,则会走明确异常类处理）(多个catch时捕获异常有顺序，子类异常在前，父类异常在后)
  try {
      test.testExceptionOne();
  } catch(ExceptionTest e1){
      System.out.println("会走这个catch，子类异常处理在前");
  }catch (RuntimeException e) {
      System.out.println("这个不会走，父类异常catch在子类异常catch后,不然编译报错");
  }

 
  

运行结果：

方法体抛出子类异常

ExceptionTest+++++++++++++

会走这个catch，子类异常处理在前

  //声明的是子类异常，抛出的是父类异常，catch的异常范围大于等于方法体抛出的异常类时可以被捕获
  try {
      test.testExceptionTwo();
  } catch (RuntimeException e) {
      System.out.println("可以被捕获");
  }
  //声明的是子类异常，抛出的是父类异常，catch的异常范围小于方法体抛出的异常类时不可以被捕获
  try {
    test.testExceptionTwo();
   } catch (ExceptionTest e) {  
   System.out.println("异常不能被捕获"); 
   }

运行结果：

可以被捕获
Exception in thread "main" java.lang.RuntimeException
    at com.suning.slop.web.action.TestExceptionSer.testExceptionTwo(TestExceptionSer.java:9)
    at com.suning.slop.web.action.Test.main(Test.java:40)

   //声明异常与抛出异常一致，catch 可以用父类异常捕获
   try {
        test.testExceptionFour();
  } catch (RuntimeException e) {
    System.out.println("捕获子类异常");
  }
   //声明异常与抛出异常一致，catch 可以用父类异常捕获
  try {
       test.testExceptionFour();
 } catch (ExceptionTest e) {
   System.out.println("捕获子类异常");
 }
   //声明异常与抛出异常一致，catch用子类异常不能捕获
    try {
        test.testExceptionThree();
  } catch (ExceptionTest e) {
      System.out.println("用子类异常捕获父类异常");
  }

运行结果：

捕获子类异常
捕获子类异常
Exception in thread "main" java.lang.RuntimeException
    at com.suning.slop.web.action.TestExceptionSer.testExceptionThree(TestExceptionSer.java:14)
    at com.suning.slop.web.action.Test.main(Test.java:59)

总结：catch 在捕获异常时和方法体抛出的异常类有关，可以用方法体抛出的异常本身及其父类用来捕获，方法头声明的异常只是用来进行声明，抛出的异常可以声明异常的父类或子类，所以在try catch时要根据方法体抛出的异常来进行定义，不能盲目的以方法头部声明的异常为准(例如方法体抛的异常是父类，而方法头部声明的是子类异常，try catch用声明的子类异常进行捕获时是捕获不到的)