java异常处理


  o(╯□╰)o

throwable:一切异常的超类

  • ERROR 错误
  • Exception 异常
    RuntimeException:运行时异常
    其他:编译时异常

try catch

1
2
3
4
5
6
7
8
9
10
11
12
13
package testDemo;

public class test1 {
public static void main(String[] args) {
int a=10;
int b=0;
try{
System.out.println(a/0);
}catch(ArithmeticException e){
e.printStackTrace();
}
}
}

try catch finally

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package testDemo;

public class test1 {
public static void main(String[] args) {
int a=10;
int b=0;
try{
System.out.println(a/0);
}catch(ArithmeticException e){
e.printStackTrace();
}finally {
System.out.println("有异常!");
}
}
}

throws

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package testDemo;

class test{
int a=10;
int b=0;
public void show() throws ArithmeticException{
System.out.println(a/b);
}
}

public class test1 {
public static void main(String[] args) {
try {
new test().show();
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
}

throw:要抛出异常的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package testDemo;

class test{
int a=10;
int b=0;
public void show() throws ArithmeticException{
if(b==0){
throw new ArithmeticException();
}else{
System.out.println(a/b);
}
}
}
public class test1 {
public static void main(String[] args) {
try {
new test().show();
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
}

throws 和 throw 的区别

  • throws
  • 用在方法声明后面,后面跟异常类名
  • 可以跟多个异常类名,用逗号隔开
  • 表示抛出异常,由该方法的调用者来处理
  • 只表示出现异常的可能性,并不一定会发生异常

  • throw

  • 用在方法体内,跟的是对象名
  • 只能抛出一个异常对象名
  • 表示抛出异常对象

finally

  • 一定会执行
  • 有特殊情况,finally之前有System.exit(0);
  • 用于释放资源,在IO流和数据库操作会见到。

final finally finalize()

  • final: 最终的意思,可以修饰类,成员变量,成员方法
    修饰类,类不能被继承
    修饰变量,变量是常量
    修饰方法,方法不能被重写
    
  • finally: 异常处理的一部分,用于释放资源
    一般来说,代码肯定会执行,特殊情况:执行finally之前jvm退出。
    
  • finalize:Object类的一个方法,用于垃圾回收

如果catch里面有return,finally是否还会执行

会,是在return之前。 但更准确的说是在中间。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package testDemo;

public class test1 {
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) {
a = 30;
return a;
} finally {
a = 40;
}
return a;
}
}

结果是输出30,运行调试便知。

如果try里面有return,finally是否还会执行

仍然会,与在catch中类似。(如果try中没有异常发生,就不会走catch)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package testDemo;

public class test1 {
public static void main(String[] args) {
System.out.println(getInt());
}
public static int getInt() {
int a = 10;
try {
a = 20;
return a;
} catch (ArithmeticException e) {
a = 30;
return a;
} finally {
a = 40;
}
}
}

结果输出20。

try catch 集中用法

1
2
3
4
5
A:try...catch...finally
B:try...catch
C:try...catch...catch...
D:try...catch...catch...finally
E:try...finally

自定义异常

  有时候java中的异常处理不能满足需求,需要自己自定义异常

1
2
3
4
5
6
7
8
public class MyException extends Exception {//必须继承Exception/RuntimeException
public MyException() {
}

public MyException(String message) {
super(message);//调用父类构造方法即可
}
}

其他注意事项

  • 子类重写父类方法时,必须抛出相同异常或更具体的异常
  • 父类没有异常,子类不可以抛出异常,只能用try catch 处理

欢迎与我分享你的看法。
转载请注明出处:http://taowusheng.cn/
微博:寒枫–0-0–
知乎:https://www.zhihu.com/people/tao-wu-sheng
豆瓣:YIFEI