Throwable类
----|Error ---------- extends Throwable
----|Exception ---------- extends Throwable
-----RuntimeException ---------- extends Exception
-----非RuntimeException ---------- extends Exception
Throwable类
----|Error ---------- extends Throwable
用于指示合理的应用程序不应该试图捕获的严重问题
----|Exception ---------- extends Throwable
类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
-----RuntimeException ---------- extends Exception
运行期问题，比如说0为除数
-----非RuntimeException ---------- extends Exception
编译期问题，必须处理，不然在eclipse中报错，红色线条
一： try…catch…finally的处理格式：
try {
//这里代码越少越好
有问题代码;
有问题代码;
有问题代码;
}catch(异常名1 变量) {
问题处理;
问题处理;
问题处理;
}catch(异常名2 变量) {
问题处理;
问题处理;
问题处理;
}catch(异常名3 变量) {
问题处理;
问题处理;
问题处理;
}finally {
释放资源;
释放资源;
释放资源;
}
注意点：
1异常范围
异常名1范围< 异常名2范围<异常名3范围
2：try–catch代码一旦出现问题，jvm会帮我们生成一个异常对象，然后把这个对象抛出，和catch里面的类进行匹配,匹配成功，执行catch里面的处理，然后结束了try…catch
，执行try…catch后面的语句。
3.catch里面的语句都会执行完.
4.异常的几个方法
- public String getMessage():异常的消息字符串
- public String toString():返回异常的简单信息描述
- printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。把信息输出在控制台
5.finally:被finally控制的语句体一定会执行,执行到finally之前jvm退出了
package cn;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
try {
System.out.println(a / b);//这边抛异常，执行对应catch，执行完结束try catch，继续下一行代码
System.out.println("11");
} catch (ArithmeticException ae) {
System.out.println("除数不能为0");
}
System.out.println("即使try catch有错，也会走下去");
try {
System.out.println(a / b);
System.out.println("12");
} catch (Exception e) {
System.out.println(e.getMessage());
/// by zero
System.out.println(e.toString());
//java.lang.ArithmeticException: / by zero
e.printStackTrace();
//java.lang.ArithmeticException: / by zero
//at cn.Test.main(Test.java:22)
System.out.println("跳出catch");
}
//即使try catch有错，也会走下去
System.out.println("即使try catch有错，也会走下去2");
}
}
输出：
除数不能为0
即使try catch有错，也会走下去
/ by zero
java.lang.ArithmeticException: / by zero
跳出catch
即使try catch有错，也会走下去2
java.lang.ArithmeticException: / by zero
at cn.Test.main(Test.java:22)
二、JDK7一个新的异常处理方案：
try{
}catch(异常名1 | 异常名2 | … 变量 ) {
…
}
注意：
- A:处理方式是一致的。
- B:多个异常间必须是平级关系。
int a = 10;
int b = 0;
int[] arr = { 1, 2, 3 };
try {
System.out.println(a / b);
System.out.println(arr[3]);
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println("出问题了:JDK7出现了一个新的异常处理方案：");
}
System.out.println("即使try catch有错，也会走下去");
输出：
出问题了:JDK7出现了一个新的异常处理方案：
即使try catch有错，也会走下去
三、异常抛出
1.格式：
方法（）throws 异常类名
public static void method() throws ParseException
注意点：
throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常
public static void main(String[] args) throws ArrayStoreException,
AclNotFoundException, RuntimeException {
method();
}
public static void method() throws AclNotFoundException,
ArrayStoreException, RuntimeException {
method1();
method2();
method3();
}
// RuntimeException
public static void method1() throws ArrayStoreException {
throw new ArithmeticException();
}
// RuntimeException
public static void method2() throws RuntimeException {
throw new ArrayIndexOutOfBoundsException();
}
// 非RuntimeException
public static void method3() throws AclNotFoundException {
throw new AclNotFoundException();
}
输出：
Exception in thread "main" java.lang.ArithmeticException
at cn.Test3.method1(Test3.java:34)
at cn.Test3.method(Test3.java:28)
at cn.Test3.main(Test3.java:24)
四finally的一个特殊案例
public static void main(String[] args) {
System.out.println(getInt());
}
public static int getInt() {
int a = 10;
try {
System.out.println(a / 0);
a = 20;
} catch (ArithmeticException e) {
System.out.println(1);
a = 30;
return a;
/*
* 1.return a在程序执行到这一步的时候，返回的是30,并结束getInt方法(发现finally，先不结束)
* 2发现还有finally,继续执行finally，结束后，执行1步骤
*/
} finally {
System.out.println(2);
a = 40;
}
System.out.println(3);
return a;
}
输出：
1
2
30五、自定义异常
package cn;
/*
自定义异常就必须继承自Exception或者RuntimeException
*/
public class MyException extends Exception{
public MyException() {
super();
}
public MyException(String message) {
super(message);
}
};
package cn;
/*
自定义异常就必须继承自Exception或者RuntimeException
*/
public class MyExceptionTest{
public static void main(String[] args) throws MyException {
int i=100;
if (i>0){
throw new MyException("拋出自定义异常");
}
}
};
输出：
Exception in thread "main" cn.MyException: 拋出自定义异常
at cn.MyExceptionTest.main(MyExceptionTest.java:14)
六、异常注意事项:
- A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(子类的异常要在父类异常的范围)
- B:如果父类抛出了多个异常,子类重写父类时,子类的方法必须抛出相同的异常或父类异常的子类,但是抛出异常的数量不限制，
- throws 后面跟的异常与异常范围无关，也就是大异常可以放在小异常的前面，也可以放在小异常的后面
- C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
一下代码在eclipse中没有报错
class Fu {
public void show() throws Exception {
}
}
class Zi extends Fu {
@Override
//throws 后面跟的异常与异常范围无关，也就是大异常可以放在小异常的前面，也可以放在小异常的后面
public void show() throws ArithmeticException,Exception ,ArithmeticException{
}
//throws 后面跟的异常与异常范围无关，也就是大异常可以放在小异常的前面，也可以放在小异常的后面
public void show(int a) throws Exception,ArithmeticException {
}
public void show(String a) throws Exception,RuntimeException,ArithmeticException {
}
}