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用声明的子类异常进行捕获时是捕获不到的)