java中的异常类都继承自java.lang.Throwable。java.lang无需导入。
异常是Exception。
Throwable常用方法:
String getMessage() //返回详细信息
void printStackTrace() //
void printStackTrace(PrintStream s) //输出到指定输出流
目录
非运行时Exception 与 runtimeException
throws关键字
定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常,而交给方法调用处进行处理。
throws关键字格式:public 返回值类型 方法名称(参数列表,,,)throws 异常类{};
假设定义一个除法,对于除法操作可能出现异常,可能不会。所以对于这种方法最好将它使用throws关键字声明,一旦出现异常,则应该交给调用处处理:
--------------------------------------------------
class Math{
public int div(int i,int j) throws Exception{ // 定义除法操作,如果有异常,则交给被调用处处理
int temp = i / j ; // 计算,但是此处有可能出现异常
return temp ;
}
}
public class ThrowsDemo01{
public static void main(String args[]){
Math m = new Math() ; // 实例化Math类对象
try{
System.out.println("除法操作:" + m.div(10,2)) ;
}catch(Exception e){ //因为div使用了throws关键字声明,所以调用此方法的时候,方法必须进行异常处理。通过try...catch;
e.printStackTrace() ; // 打印异常
}
}
}
--------------------------------------------------
如果在主方法的声明也使用了throws关键字,那么就意味着主方法也可以不处理异常,而交给JAVA中最大头JVM,所以如果在主方法使用了throws关键字,则表示一切异常交给JVM进行处理。默认处理方式也是JVM完成:
--------------------------------------------------
class Math{
public int div(int i,int j) throws Exception{ // 定义除法操作,如果有异常,则交给被调用处处理
int temp = i / j ; // 计算,但是此处有可能出现异常
return temp ;
}
};
public class ThrowsDemo02{
// 在主方法中的所有异常都可以不使用try...catch进行处理
public static void main(String args[]) throws Exception{
Math m = new Math() ; // 实例化Math类对象
System.out.println("除法操作:" + m.div(10,0)) ;
}
}
运行输出:
Exception in thread "main" java.lang.ArithmeticException: / by zero
at methoud.Math.div(ThisDemo06.java:4)
at methoud.ThisDemo06.main(ThisDemo06.java:12)
throw关键字
throw的作用是抛出一个异常,抛出的时候是抛出的是一个异常类的实例化对象,在异常处理中,try语句要捕获的是一个异常对象,那么此异常对象也可以自己抛出。
package methoud;
public class ThisDemo06{
public static void main(String args[]){
try{
throw new Exception("自己抛着玩的。") ; // 抛出异常的实例化对象
}catch(Exception e){
System.out.println(e) ;
}
}
}
联合使用
在一般开发中try,catch,finally,throw,throws联合使用的情况是最多的。
例如,现在要使用一个相除的方法,但是在操作之前必须打印“运算开始”的信息,结束之后必须打印“异常结束”。
如果有异常,需要把异常交给异常调用处处理。面对这样要求,必须全部使用以上关键字。
---------------------------------------
class Math{
public int div(int i,int j) throws Exception{ // 定义除法操作,如果有异常,则交给被调用处处理
System.out.println("***** 计算开始 *****") ;
int temp = i / j ; // 计算,但是此处有可能出现异常
System.out.println("***** 计算结束 *****") ;
return temp ;
}
};
public class ThrowDemo02{
public static void main(String args[]){
Math m = new Math() ;
try{
System.out.println("除法操作:" + m.div(10,0)) ;
}catch(Exception e){
System.out.println("异常产生:" + e) ;
}
}
};
输出:
***** 计算开始 *****
异常产生:java.lang.ArithmeticException: / by zero
---------------------------------------
以上没有 "计算结束" ,因为没有异常发生了,直接中断程序操作。所以做以下操作。
package methoud;
class Math{
public int div(int i,int j) throws Exception{ // 定义除法操作,如果有异常,则交给被调用处处理
System.out.println("***** 计算开始 *****") ;
int temp = 0 ; // 定义局部变量
try{
temp = i / j ; // 计算,但是此处有可能出现异常
}catch(Exception e){
}
System.out.println("***** 计算结束 *****") ;
return temp ;
}
};
public class ThisDemo06{
public static void main(String args[]){
Math m = new Math() ;
try{
System.out.println("除法操作:" + m.div(10,0)) ;
}catch(Exception e){
System.out.println("异常产生:" + e) ;
}
}
};
***** 计算开始 *****
***** 计算结束 *****
异常产生:java.lang.ArithmeticException: / by zero
--------------------------------------------
这里虽然貌似成功了,但是,这里的异常并没有抛出去,因为在方法中已经被自动处理了,没有抛出去。
所以要抛出异常对象,给方法调用处处理,使用throw关键字。
package methoud;
class Math{
public int div(int i,int j) throws Exception{ // 定义除法操作,如果有异常,则交给被调用处处理
System.out.println("***** 计算开始 *****") ;
int temp = 0 ; // 定义局部变量
try{
temp = i / j ; // 计算,但是此处有可能出现异常
}catch(Exception e){
throw e ; //抛出异常。
}finally{ // 不管是否有异常,都要执行统一出口
System.out.println("***** 计算结束 *****") ;
}
return temp ;
}
}
public class ThisDemo06{
public static void main(String args[]){
Math m = new Math() ;
try{
System.out.println("除法操作:" + m.div(10,0)) ;
}catch(Exception e){
System.out.println("异常产生:" + e) ;
}
}
}
非运行时Exception 与 runtimeException
是面试中经常出现的问题。
1. 处理非运行时异常有两种方式:
1)try ... catch 捕获异常
2)thows 抛出异常,让调用者处理
2. 处理运行时异常时,即使没有try...catch 或 throws,程序也能编译通过,一旦发生异常之后,将由JVM处理。
观察以下代码:
package methoud;
public class ThisDemo06{
public static void main(String args[]){
String str = "123" ; // 定义字符串,全部由数字组成
int temp = Integer.parseInt(str) ; // 将字符串变为int类型
System.out.println(temp * temp) ; // 计算乘方
}
}
但java中parseInt()的定义格式:public static int parseInt(String s) throws NumberFormatException
此方法明明使用了throws关键字抛出异常,但调用时没做处理。
为了保证程序的健康性,在有可能出现异常的时候还是老实使用try ..catch处理。
自定义异常类
只需要继承Exception类就可以自定义异常类。因为JAVA中提供的都是标准异常类(包括一些异常信息),如果需要自己想要
的异常信息就可以自定义异常类。
public class MyException extends Exception{ // 自定义异常类,继承Exception类
public MyException(){
super() ; // 调用Exception类中无参数的构造方法
}
public MyException(String msg){
super(msg) ; // 调用Exception类中有一个参数的构造方法,传递错误信息
}
}
public class Test{
public static void main(String args[]){
try{
System.out.println(div(4, -2));
} catch(MyException e) {
System.out.println(e.getMessage());
}
}
public static int div(int a, int b) thows MyException{
if(b < 0) {
throw new MyException("被除数是负数");
}
return a / b;
}
}
父类与子类的异常:
1. 子类重写父类方法时,子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)。父子一致,儿子的异常可以小一些。
2. 如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集。子类不能抛出父类没有的异常,且子类抛出异常的数量<=父类抛出异常的数量。不能瞎抛,不能多抛。
3. 如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常;如果子类方法内有异常发生,那么子类只能try,不能throws。父类没抛,子类坏了也不能抛。
快捷键:
选中要加try catch的内容 按Alt + shift + Z