Java编程思想 -- 异常

杂谈

人们在使用软件时，遇到程序错误会很不爽。如果一个用户在运行期间，由于程序的错误或一些外部环境的影响造成用户数据的丢失，用户就有可能不在使用这个程序了。为了必选这类事情的发生，至少应该做到以下几点:

• 向用户通告错误
• 返回到一种安全的状态，并能够让用户自行一些其他的命令
• 允许用户保存所有的操作的结果，并以妥善的方式终止程序。

程序需要关心的错误种类

• 用户输入错误
  除了不可避免的键盘输入错误，有些用户喜欢个行其事，不遵守程序的要求。
• 设备错误
  硬件不总是让它干做什么，它就做什么。打印机可能关掉了，可能断网了。
• 物理限制
  磁盘满了，可用存储空间已被用完了。
• 代码错误
  程序方法可能错误的执行。计算的数组索引不合法。试图让空栈弹出错误，这些都是代码错误。

异常分类

Throwable是所有异常的基类。
大致类图如下

受检异常与非受检异常

（1）受检异常：

• 如果在代码中抛出（throw）受检异常或者调用的方法中抛出受检异常，则一定要用try-catch语句处理或者在方法声明中用throws语句声明。
• 除了Error（或其子类）和RunTimeException（或其子类）的异常类都是受检异常。
• Throwable，Exception也是受检异常。

（2）非受检异常

• Error表示Java运行时系统的内部错误和资源耗尽的错误。应用程序不应该抛出这种类型的异常。如果出现这种内部错误，除了通报给用户，并尽力使程序安全地退出终止之外，再也无能为力。
• RunTimeException指程序错误导致的异常。出现这类这错误。是程序员的问题，并且这类错误是可以通过编码避免的。

语法

基本语法

自定义异常

/**
 * 自定义异常，只需要继承某个异常类即可
 */
public class MyException extends Exception{

}

捕获同时多种异常

package 异常.捕获多个异常;

import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        try {
            A a = new A();
            a.f();

            B b = new B();
            b.f();

            C c = new C();
            c.f();

            D d = new D();
            d.f();
        } catch (AException  | BException | CException | DException e) {
            //这种写法更加清晰，切执行效率更高
            e.printStackTrace();
        }

    }
}

class AException extends IOException{}

class BException extends IOException{}

class CException extends IOException{}

class DException extends IOException{}

class A{
    public void f() throws AException{
        throw new AException();
    }
}

class B{
    public void f() throws BException{
        throw new BException();
    }
}

class C{
    public void f() throws CException{
        throw new CException();
    }
}

class D{
    public void f() throws DException{
        throw new DException();
    }
}

finally子句

格式

        try {
            do something
        }catch (Exception e) {
            do something
        }finally {
            不管有没有发生异常，finally子句的内容都会执行。
            常用于关闭资源。
            如果try子句，catch子句有return语句，也会在return之前执行finally子句的内容。
            如果finally子句也有return语句，finally子句的返回值会覆盖try或者catch里面的返回值。
        }

例1

package 异常.finally语句;

public class Test {
    public static void main(String[] args) {
        People p = new People();
        int n = 3;
        try {
            p.f(3);
            return;
        } catch (Exception e) {
            System.out.println("catch " + n);
        }finally {
            System.out.println("finally " + n);
        }
    }
}

class People{
    void f(int n) throws Exception{
        if(n == 2){
            throw new Exception(); 
        }

        System.out.println("f()  " + n);
    }

}

结果：

f()  3
finally 3

例2

package 异常.finally语句;

import javax.swing.plaf.synth.SynthStyle;

public class Test {
    public static void main(String[] args) {
        int n = 5;
        System.out.printf("f(%d) 的返回值是 %d\n", n, f(n));

        n = 2;
        System.out.printf("f(%d) 的返回值是 %d\n", n, f(n));
    }

    public static int f(int n){
        try{
            return n * n;
        }finally {
            if(n == 2){
                return 0;
            }
        }
    }
}

结果：

f(5) 的返回值是 25
f(2) 的返回值是 0

注意

（1）如果父类的某个方法没有声明任何异常，子类的那个方法就不能声明任何异常。
那如果子类需要抛出受检异常那该怎么办？
只能包装成非受检异常抛出。
（2）子类声明的异常不能比父类更通用。