java 断言 异常_Java基础-异常、断言

处理错误

如果Java程序运行期间出现了错误，并且由于出现错误导致某些操作没有完成，程序应该能够返回到一种安全状态，并能够让用户执行一些其他的命令；或者允许用户保存所有操作结果，并以妥善的方式终止程序。

其中错误的来源可能有以下几种：

1.用户输入错误

例如：程序定义输入为int，但是用户输入了String。

2.设备错误

例如：网络设备损坏。

3.物理限制

例如：存储空间占满。

4.代码错误

例如：程序方法返回了错误的结果。

异常

定义：Java代码在运行期间发生的问题就是异常。在Java程序设计语言中，Throwable类是所有错误和异常的超类，异常对象都是派生于Throwable类的一个实例。

Java异常层次的简化示意图：

所有的异常都是由Throwable继承而来，在下一层分解为两个分支：Error和Exception。

Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误，应用程序不应该抛出这种类型的对象。

Exception层析结构又分为两个分支：

Runtime Exception：由程序错误导致的异常。

其他异常：程序本身没有问题，但是由于像I/O错误(IOException)这类问题导致的异常。

注意：

Error这种内部错误，编译时不会出现，一旦出现错误，除了通告用户，并尽量使程序安全地终止制外，无法针对处理，只能修正代码，使得程序符合系统资源要求等。

Exception这种异常，可以针对抛出的具体异常进行针对性处理。一般编写程序时，重点关注异常。

异常的创建和抛出过程：

JVM创建异常对象。

将异常对象抛出给方法的调用者，一旦异常被抛出了，后面的所有程序都不再执行。

Java语言规范将派生于Error或RuntimeException类的所有异常称为非受查异常，所有其他的异常称为受查异常。编译器将核查是否为所有的受查异常提供了异常处理器。

抛出异常throw

在编写程序时，必须考虑程序出现问题的情况。

例如：在定义方法时，方法需要接受参数。那么，当调用方法使用接收到的参数时，首先需要先对参数数据进行合法的判断，参数若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。

throw用在方法内，用来创建并抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行，格式如下：

1 throw new 异常类名(参数);

示例代码如下：

1 public static void main(String[] args) throws Exception {

2

3 int[] arr = null;

4 int i = getArray(arr);

5 System.out.println(i);

6 }

7

8 public static int getArray(int[] arr) throws Exception {

9

10 if(arr == null){

11 throw new Exception("数组为null");

12 }else if(arr.length == 0){

13 throw new Exception("数组中无元素");

14 }else {

15 int i = arr[arr.length - 1];

16 return i;

17 }

18

19 }

在getArray方法中，当整型数组arr为null或为空时，使用throw关键字new一个异常对象。

throws子句

方法应该在其首部声明所有可能抛出的异常，如果方法内通过throw抛出了编译时的异常，而没有捕获并处理，那么必须通过throws关键字进行声明，让调用者去处理，声明格式武如下：

1 修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2… { }

throws用于方法进行异常类的声明上，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

示例代码中getArray和main方法都在后面使用throws关键字，逐层往上抛给调用者去处理该异常。

1 public static void main(String[] args) throws Exception {

2 ......

3 }

4

5

6 public static int getArray(int[] arr) throws Exception {

7 ......

8 }

在编写方法时，不必将所有可能抛出的异常都进行声明，下面列举应该抛出异常的情况：

调用一个抛出受查异常的方法。

程序运行过程中发现错误，并且利用throw语句抛出一个受查异常。

程序出现错误。

Java虚拟机和运行时库出现的内部错误。

捕获异常(try/catch)

当某个异常发生时，没有在任何位置进行捕获，程序就会终止执行，并在控制台上打印出异常信息，其中包括异常的类型和堆栈的内容。

要想捕获异常，必须设置try/catch语句块，格式如下：

1 try {

2 //被检测的代码

3 //可能产生异常的代码

4 }

5 catch(异常类 变量) {

6 //异常的处理代码语句

7 }

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，编写异常处理代码，实现对捕获到的异常进行处理。

如果在try语句中的任何代码抛出了一个在catch子句中说明的异常类：

1. 程序将跳过try语句块的其余代码。

2. 程序将执行catch子句中的处理器代码。

捕获多个异常

在一个try语句块中可以捕获多个异常，并对不同类型的异常做出不同的处理。

1 try {

2 //被检测的代码

3 //可能产生异常的代码

4 }

5 catch(异常类1 变量) {

6 //异常的处理代码语句

7 }

8 catch(异常类2 变量) {

9 //异常的处理代码语句

10 }

11 ......

捕获多个异常不仅会让代码看起来更简单，还会更高效。

多catch使用条件：

彼此之间不存在子类关系，多catch时没有顺序影响。

彼此之间存在子类关系，多catch时有顺序影响，应该先catch子类异常，再逐级catch超类异常(原因在于多态)。

try/catch示例代码如下：

1 public static void main(String[] args) {

2 int[] arr = {1,2,3};

3 try {

4 int i = getArray(arr);

5 System.out.println(i);

6 }catch (NullPointerException ex){

7 System.out.println(ex + ",捕获到空指针异常");

8 }catch (ArrayIndexOutOfBoundsException ex){

9 System.out.println((ex + ",捕获到数组越界异常");

10 }

11 System.out.println("程序继续执行！");

12 }

13

14 public static int getArray(int[] arr) {

15

16 int x = 5;

17 if (arr == null) {

18 throw new NullPointerException("数组为null");

19 } else if (arr.length < x) {

20 throw new ArrayIndexOutOfBoundsException("数组越界");

21 } else {

22 return arr[5] + 1;

23 }

24

25 }

finally代码块

当代码抛出一个异常时，就会终止方法中剩余代码处理，并退出这个方法的执行。如果方法获得了一些本地资源，并且只有该方法自己知道，当方法退出前这些资源必须被回收，就会产生资源回收问题。

解决方式有两种：

一种是捕获并重新抛出所有的异常。

另一种是使用finally子句。

finally

有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

上文示例代码的一部分：

1 try {

2 int i = getArray(arr);

3 System.out.println(i);

4 } catch (NullPointerException ex) {

5 System.out.println(ex + ",捕获到空指针异常");

6 } catch (ArrayIndexOutOfBoundsException ex) {

7 System.out.println(ex + ",捕获到数组越界异常");

8 } finally {

9 System.out.println("必须执行的代码，用以释放资源！");

10 }

11 ......

运行时期异常

RuntimeException和他的所有子类异常,都属于运行时期异常。

运行时期异常的特点：

方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常。

运行时期异常一旦发生,需要程序人员修改源代码。

特点一就是上文两段完整的示例代码不同的原因。

NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常，因此不需要throws声明。

Exception不属于运行时期异常，因此需要throws声明。

继承关系抛出异常

超类的方法如果抛出异常，子类覆盖超类方法时：

可以不抛出异常。

也可以抛出超类相同的异常，或着超类异常的子类异常。

超类的方法如果没有抛出异常，子类覆盖超类方法时：

不能抛出异常。

当子类方法调用了抛出异常的方法时，别无选择，只能try/catch。

自定义异常

通过阅读异常源代码：发现java中所有的异常类，都是继承Throwable，或者继承Throwable的子类。这样该异常才可以被throw抛出。

说明这个异常体系具备一个特有的特性：可抛性：即可以被throw关键字操作。

并且查阅异常子类源码，发现每个异常中都调用了超类的构造方法，把异常描述信息传递给了超类，让超类帮助进行异常信息的封装。

例如：NullPointerException异常类源代码：

1 public class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {

2 private static final long serialVersionUID = -5116101128118950844L;

3

4 /**

5 * Constructs an ArrayIndexOutOfBoundsException with no

6 * detail message.

7 */

8 public ArrayIndexOutOfBoundsException() {

9 super();

10 }

11

12 /**

13 * Constructs a new ArrayIndexOutOfBoundsException

14 * class with an argument indicating the illegal index.

15 *

16 * @param index the illegal index.

17 */

18 public ArrayIndexOutOfBoundsException(int index) {

19 super("Array index out of range:" + index);

20 }

21

22 /**

23 * Constructs an ArrayIndexOutOfBoundsException class

24 * with the specified detail message.

25 *

26 * @param s the detail message.

27 */

28 public ArrayIndexOutOfBoundsException(String s) {

29 super(s);

30 }

31 }

通过查询JDK API 1.8可以看到继承关系如下：

由此可知，自定义异常类的格式如下：

1 Class 异常类名 extends RuntimeException{

2 public 异常类名(){

3 }

4 public 异常类名(String s){

5 super(s);

6 }

7 }

自定义异常类的超类通常是RuntimeException，也可以是Exception等。

定义Person类，如果年龄age小于0或者大于150岁，抛出AgeWrongException异常，示例代码如下：

Person类代码：

1 public class Person {

2 private String name;

3 private int age;

4

5 public Person(String name, int age) throws AgeWrongException {

6

7 int maxAge = 150;

8 if (age < 0 || age > maxAge) {

9 throw new AgeWrongException("Age信息错误！");

10 } else {

11 System.out.println("Age :" + age);

12 }

13 this.name = name;

14 this.age = age;

15 }

16

17 @Override

18 public String toString() {

19 return "Person{" +

20 "name='" + name + '\'' +

21 ", age=" + age +

22 '}';

23 }

24 }

自定义异常AgeWrongException类代码：

1 public class AgeWrongException extends Exception{

2 public AgeWrongException(){

3 super();

4 }

5

6 public AgeWrongException(String message){

7 super(message);

8 }

9 }

测试类代码：

1 public class AgeWrongExceptionTest {

2 public static void main(String[] args) {

3 try {

4 Person person = new Person("Dcl_Snow", 300);

5 System.out.println(person);

6 } catch (AgeWrongException e) {

7 System.out.println(e + "Age数值非法！");

8 }

9 }

10 }

如果自定义异常类继承的是RuntimeException，则throws子句和try/catch都可省略。

使用异常机制的技巧

1. 异常处理不能代替简单的测试。

2. 不要过分的细化异常。

3. 利用异常的层次结构，不要只抛出RuntimeException异常，应该寻找更加适当的子类或自定义的异常类。

4. 不要压制异常，不要强烈的倾向于关闭异常，如果认为异常非常重要，就应该进行处理。

5. 在检查错误时，“苛刻”要比放任更好。

6. 不要羞于传递异常，不要只倾向于捕获异常，有时候让高层次的方法通知用户发生了错误，或者放弃不成功的命令会更加适宜。

断言

断言机制允许再测试期间向代码中插入一些检查语句。当代码发布时，这些插入的检查语句将会被自动移走。Java语言的断言引入关键字assert，格式如下：

1 assert 条件;

1 assert 条件 : 表达式;

两种方式都会对条件进行检测，如果结果为false，则抛出一个AssertionError异常。在第二种形式中，表达式会被传入AssertionError的构造器中，并转换成一个消息字符串。

注意：

“表达式”部分唯一的目的就是产生一个消息字符串。AssertionError对象并不存储表达式的值，因此并不能在以后得到它。

例如：要想断言x时一个非负数值：

1 assert x >= 0;

或者将x的实际值传递给AssertionError对象，从而可以在后面显示出来：

1 assert x >= 0 : x;

启用和禁用断言

默认情况下，断言被禁用，可以在运行程序时用-enableassertions或-ea选项启动：

1 java -enableassertions MyApp

也可以在某个类或整个包中使用断言：

1 java -ea:MyClass -ea:com.xxx.yyy...

这条命令开启MyClass类和com.xxx.yyy包及其子包中所有的类的断言。

禁用断言，使用-disableassertions和-da选项。

-ea和-da选项不能应用于那些没有类加载器的“系统类”，对于系统类来说，使用-enablesystemassertions或-esa选项启用断言。

使用断言的时机：

断言失败时致命的、不可恢复的错误。

断言检查只用于开发和测试阶段。

因此不应该使用断言向程序的其他部分通告发生了可恢复性的错误，或者不应该作为程序向用户通告问题的手段。断言只应该用于在测试阶段确定程序内部的错误位置。

IntelliJ IDEA设置启用断言

打开IntelliJ IDEA，创建一个断言测试类：

1 public class AssertTest {

2 public static void main(String[] args) {

3 int x = 1;

4 int y = 2;

5 assert x > y;

6 System.out.println(x + y);

7 }

8 }

此时执行程序，打印输出结果3，不会报任何异常。

然后点击IntelliJ IDEA主界面右上角的下拉箭头，选择“Edit Configurations...”：

打开配置界面：

此时左侧时选择需要启用断言的类，默认是刚刚创建的AssertTest类在选项“VM oprions:”中填写“-ea”：

启用断言即完成，此时执行程序报出断言异常。