一.异常与错误的区别
再讲异常之前我们就应该要知道异常和错误的区别
Error类和Exception类的父类都是throwable类，他们的区别是：
Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，
仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
二.异常的体现分类：
1.checked 异常检查期异常 java.lang.Excetion 在编译期需要人工处理否则编译失败：Exception的子类除了运行期异常都是检查期异常
2.非Checked异常运行时异常 java.lang.RuntimeException 不需要处理的直接能编译通过：所有的RuntimeException以及其子类都是运行异常
举例：运行期异常
结果：运行期异常，当你敲好代码时不会报错，而当你运行时才会报除数不能为0的错误
举例：检查期异常：
结果：检查期异常，当你编译的时候就会报错，一定要抛出异常编译才能通过
三.异常的处理机制
Java语言主要依赖于 try catch finally 和throws throw 五个关键字来描述异常
1） 在发生异常的地方直接处理
使用try catch finally 直接处理异常
a) try-catch-finally结构中try块是必须有的，catch和finally块为可选，但两者至少必须出现其中之一。
b) catch 可以同时出现多个，但一个异常最多捕获一个catch，而且catch的顺序是从上往下
c) finally 无论是否捕获异常都会执行的一行代码
演示1：try异常
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public class TestException { public static void main(String[] args) { int c = 0; try { int a = 3; int b = 0; // 这块代码出现了异常 c = a / b; // 那么异常之后的代码都不会被执行 System.out.println("Hello World"); } catch (ArithmeticException e) { System.out.println("除数不能为零"); } finally { //不管有没有发生异常，finally语句块都会被执行 System.out.println("Welcome"); } System.out.println(c); // 当b为0时，有异常，输出为c的初始值0 } } //输出结果：除数不能为零 Welcome 0try异常 |
演示2：带有return的异常
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import java.io.FileInputStream;import java.io.FileNotFoundException;public class DemoException { public static void main(String[] args) { int a=test3(); System.out.println(a); } @SuppressWarnings("finally") public static int test3(){ try { System.out.println(9 / 0); return 1; } catch (Exception e) { System.out.println("捕获到了异常...."); return 2; }finally{ System.out.println("无论如何都会执行的代码..."); return 3; } }}//输出结果 "呵呵""哈哈" 3带有return异常 |
得出结论：作用范围 return 终止整个方法体，但在finally出现之前 return是老大 finally 作用范围> return
2）将异常抛给调用者让调用者处理
|
1
2
3
4
5
|
//throws在方法体头部通过声明 抛出异常...public void dealFile() throws FileNotFoundException{ FileInputStream fis =new FileInputStream("C:/name.txt");}//那么那么上面调用这个方法可以选择是继续抛出，还是捕获异常 |
案例一：通过throws抛出异常，调用者直接捕获抛出的异常
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class TestException { public static void main(String[] args) { try { Test3(); //这里选择直接捕获异常，而不是在抛出异常 } catch (NumberFormatException e) { System.err.println("非数据类型不能转换。"); } //System.err.println();这种输出方式可以输出错误的消息，在控制台呈现红色。 } public static void Test3() throws NumberFormatException{ String s = "abc"; System.out.println(Double.parseDouble(s)); } }throws异常 |
运行结果：
非数据类型不能转换。
注意：使用Throws是的限制
两小原则
使用throws 声明抛出异常一个限制
子类继承父类重写父类的方法
子类抛出的异常必须比父类少
子类抛出的异常必须比父类小
两小原则是针对检查期异常的，运行期异常不遵循这个规则(RuntimeException 以及子类)
案例二：通过throw抛出异常
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class TestException { public static void main(String[] args) { String s = "abc"; if(s.equals("abc")) { throw new NumberFormatException("不能相等"); } else { System.out.println(s); } } }throw异常 |
运行结果如下：
面试题：Throw 和Throws有什么区别？
Throw语句是用在方法体内表示抛出的异常由方法体内的语句处理
Throws 语句是在方法声明之后抛出异常表示在抛出的异常交给调用者处理
Throws 要么使用try –catch –finally 处理要么继续抛出
四.自定义异常
所谓自定义异常，通常就是定义一个类，去继承Exception类或者它的子类。因为异常必须直接或者间接地继承自Exception类。
通常情况下，会直接继承自Exception类，一般不会继承某个运行时的异常类。
自定义异常可以用于处理用户登录错误，用户输入错误提示等。
自定义异常需要遵循以下步骤
- 继承RuntimeExcetion 或者Exception
- 写一个无参的构造函数
- 写一个String类型的构造函数
举例：自定义异常：
|
1
2
3
4
5
6
7
8
9
10
11
|
public class MyException extends Exception{ public MyException() { super(); } public MyException(String message) { super(message); }} |
一种处理异常方式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class ExceptionTest4{ public void method(String str) throws MyException { if(null == str) { throw new MyException("传入的字符串参数不能为null！"); } else { System.out.println(str); } } public static void main(String[] args) throws MyException //异常处理方式1，不断向外抛出 { ExceptionTest4 test = new ExceptionTest4(); test.method(null); }} |
另一种异常处理方式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
public class ExceptionTest4{ public void method(String str) throws MyException { if (null == str) { throw new MyException("传入的字符串参数不能为null！"); } else { System.out.println(str); } } public static void main(String[] args) { //异常处理方式2，采用try...catch语句 try { ExceptionTest4 test = new ExceptionTest4(); test.method(null); } catch (MyException e) { e.printStackTrace(); } finally { System.out.println("程序处理完毕"); } }} |
最后说一句，try-catch-finally虽好用，但是如果是滥用，这样只是会让程序的可读性变的很糟糕，当程序报错，就无法快速准确的定位了。
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持服务器之家！
原文链接：http://www.cnblogs.com/qdhxhz/p/6372037.html
