Java异常使用心得

异常处理是 Java 设计最引以为傲的一个地方。Java 的设计者们提供了处理编译及运行时异常的机制，这极大的增强了程序的健壮性。这里不得不提 Java 的设计哲学：没有完善异常处理的代码根本没有机会被执行。

Java 异常的体系结构

java.lang.Throwable
—|——Error：错误，程序中不进行处理
——|——Exception：异常，要求在编写程序时，就要考虑到对这些异常的处理
———|——编译时异常：在编译期间会出现的异常（执行 javac.exe 命令时，出现异常）
———|——运行时异常：在运行期间出现的异常（执行 java.exe 命令时，出现异常）

Error

/**
 * @author kyyee
 *
 */
public class TestError {
    public static void main(String[] args) {
        // java.lang.StackOverflowError
        main(args);
        // java.lang.OutOfMemoryError: Java heap space
        // byte[] b = new byte[1024 * 1024 * 1024];
        System.out.println(b);
    }
}

代码 main(args)； 会出现 StackOverflowError （栈空间溢出错误）。
代码 byte[] b = new byte[1024*1024*1024]; 会出现 OutOfMemoryError （堆空间溢出错误）。

Exception

异常通常被分为两种：检查型异常（CheckedException）、运行时异常（RuntimeException）。

注意：检查型异常与编译时异常同义。

1.常见的运行时异常：

1. 数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException: -10
2. 算数除 0 异常：java.lang.ArithmeticException: / by zero
3. 类型转换异常：java.lang.ClassCastException: java.util.Date cannot be cast to java.lang.String
4. 空指针异常：java.lang.NullPointerException
5. 传递非法参数异常：java.lang.IllegalArgumentException
6. 数字格式错误异常：java.lang.NumberFormatException

2.检查型异常：

• 所有的非运行时异常都是检查型异常

如何处理异常

Java 提供了基于抓抛模型的异常处理办法

1.”抛“：当我们执行代码时，一旦出现异常，就会在异常的代码处生成一个对应的异常类型的对象，并将此对象抛出

• 一旦抛出此异常类的对象，那么异常之后的代码立即停止执行
• 此异常类的对象抛给方法的调用者
• Java 有两种抛出异常的方式（自动抛出/手动抛出）

2.”抓“：抓住抛出来的异常类的对象。如何抓？即为异常处理的方式

• Java 提供了两种方式来处理异常类的对象

Java 处理异常类的两种方式

方式一

将可能出现异常的代码块用 try-catch-finally 结构包起来，在 catch 中提供相应的处理办法，而 finally 中是一定会被执行的代码。

        try{
            // 可能出现异常的代码
            ...
        } catch(Exception1 e1){
            // 处理的方式1
            ...
        } catch(Exception2 e2){
            // 处理的方式2
            ...
        } finally {
            // 一定会执行的代码
            ...
        }

捕获IO异常

// 编译时异常
    @Test
    public void test6() {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File("hello.txt"));
            int len;
            byte[] b = new byte[10];
            while ((len = fis.read(b)) != -1) {
                System.out.println(b);
                System.out.println(len);
            }
        } catch (FileNotFoundException e) { // 子类异常在父类异常上被捕获
        } catch (IOException e) {
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

注意：

1. try{} 代码块内声明的变量类似于局部变量，出了 try{} 语句，就不能被使用
2. finally 是可选的
3. catch 语句内部是对异常对象的处理=>e.getMessage(); =>e.printStackTrace();
4. 可以有多个 catch 语句，try 中抛出的异常类对象从上往下去匹配 catch 中的异常类的类型，一旦满足就执行 catch 中的代码。执行完跳出其后的多余 catch 语句
5. 如果异常处理了，那么其后的代码继续执行
6. 若 catch{} 多个异常类型是“并列”关系，孰上孰下都可以。若 catch{} 多个异常类型是“包含”关系，须将子类放在父类的上面进行处理，否则编译错误
7. finally 中存放的是一定会被执行的代码，不管 try 中、catch 中是否仍有异常未被处理，以及是否有 return 语句
8. try-catch 是可以嵌套的

对于运行时异常来说，可以不显示的进行处理。对于编译时异常来说，必须要显式的进行处理。

方式二

在方法的声明处，显式的抛出该异常对象的类型，关键字：throws。
当在此方法内部出现异常的时候，会抛出一个异常类的对象，抛给方法的调用者，异常类的对象可以逐层向上抛，直至 main 方法。
当然在向上抛的过程中，可以在方法调用者中通过 try-catch-finally 来处理抛出的异常。

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * Created by kyyee on 2017/6/8.
 */
public class TestException {
    public static void main(String[] args) {
        TestException t = new TestException();
        try {
            t.TestInput();
        } catch (IOException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }

    private void TestInput() throws IOException {
        FileInputStream fis = new FileInputStream(new File("hello.txt"));
        int b;
        while ((b = fis.read()) != -1) {
            System.out.println((char) b);
        }
        fis.close();
    }
}

如何自定义一个异常类

自定义的异常类继承现有的异常类，提供一个序列号，提供几个重载的构造器。

public class MyException extends RuntimeException {
    private static final long serialVersionUID = 2989193327207396613L;

    public MyException() {
        super();
    }

    public MyException(String message, Throwable cause) {
        super(message, cause);
    }

    public MyException(String message) {
        super(message);
    }

    public MyException(Throwable cause) {
        super(cause);
    }
}

如何手动抛出一个异常类

抛出的异常类型，若是RuntimeException，可以不用显式的处理，若是一个Exception，必须要显式的处理。换句话说，RuntimeException不用向外抛（throws）或不用抓（try-catch-finally）；而Exception要么向外抛（throws），要么在某一级抓（try-catch-finally）。

public class TestCricle {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Cricle cricle = new Cricle(3.14);
        Cricle cricle2 = new Cricle(4.24);
        System.out.println(cricle.compareTo(cricle2));
        System.out.println(cricle.compareTo(2));
    }
}

final class Cricle {
    private double radius = 0D;

    public Cricle() {
        super();
    }

    public Cricle(double radius) {
        super();
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public String toString() {
        return "Cricle [radius=" + radius + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        long temp;
        temp = Double.doubleToLongBits(radius);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Cricle other = (Cricle) obj;
        if (Double.doubleToLongBits(radius) != Double
                .doubleToLongBits(other.radius))
            return false;
        return true;
    }

    public int compareTo(Object obj) {
        if (this == obj) {
            return 0;
        } else if (obj instanceof Cricle) {
            Cricle c = (Cricle) obj;
            if (c.radius < this.radius) {
                return -1;
            } else if (c.radius == this.radius) {
                return 0;
            } else {
                return 1;
            }
        } else {
            throw new MyException("传入类型与Circle类型不匹配");
        }
    }
}

重写方法含有 throw Exception

重写方法不能抛出父类中没有的检查型异常
重写方法不能抛出父类抛出异常的父异常，如父类中的方法抛出FileNotFoundException，则该重写方法不能抛出IOException

public class TestOverride {
    public static void main(String[] args) {
        A a = new B();
        try {
            a.method1();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        B b = new B();
        try {
            b.method1();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class A {
    public void method1() throws IOException {
        System.out.println("我是父类");
    }
}

class B extends A {
    /*
     * (non-Javadoc)
     * 
     * @see com.nantian.exception.A#method1()
     */
    @Override
    public void method1() throws FileNotFoundException {
        System.out.println("我是子类");
    }
}

结语

java的异常处理：抓抛模型

1. 抓：异常的处理，有两种方式（1.try-catch-finally，2.throws）
2. 抛：一旦执行过程中出现异常，会抛出一个异常类的对象（自动抛出 vs 手动抛出 throw new 异常类对象），既可以是系统现有的异常类，也可以是自己创建的异常类

总结： Java 异常处理有 5 个关键字：try , catch , finally , throws , throw。自定义异常继承自 Exception，如果不处理异常，则编译不通过，也就是说继承自 Exception 的异常是检查型异常；自定义异常继承自RuntimeException，可以不处理异常，可编译通过，也就是说继承自 RuntimeException 的异常是运行时异常。