33. Java对异常处理的两种方式

1. 声明异常
   throw: 关键字，用于抛出一个指定的异常对象
   必须写在方法内部、必须是Exception或Exception的子类对象
   throws: 用于方法声明上，表示当前方法不处理该异常，提醒调用者处理异常
   方法内部抛出编译器异常

/**
 * <h1>方式一: 声明异常</h1>
 * throw, throws
 * */
public class DeclareException {

    /**
     * <h2>使用 throw 关键字抛出运行时异常</h2>
     * */
    private static boolean validate01(String name) {

        if (null == name) {
            throw new NullPointerException("name is null...");
        }

        return "qinyi".equals(name);
    }

    /**
     * <h2>编译期异常, 必须处理这个异常, 或者是由 throws 继续抛出给上层调用者处理</h2>
     * */
    private static void validate02(String name) throws EOFException,
            FileNotFoundException {

        if (null == name) {
            throw new EOFException("name is null...");
        }

        if (!"qinyi".equals(name)) {
            throw new FileNotFoundException("name is not qinyi...");
        }
    }
}

2. 捕获异常
   三个关键字：try、catch、finally
   try：该代码块内编写可能产生异常的代码
   catch：用于进行某种异常的捕获并处理
   finaly: 不管代码出现异常与否，都会对该代码块执行

/**
 * <h1>方式2: 捕获异常</h1>
 * try...catch...finally
 * */
@SuppressWarnings("all")
public class CatchException {

    /**
     * <h2>validate01 抛出单个异常</h2>
     * */
    private static boolean validate01(String name) {

        if (null == name) {
            throw new NullPointerException("name is null...");
        }

        return "qinyi".equals(name);
    }

    /**
     * <h2>validate02 抛出多个异常</h2>
     * */
    private static boolean validate02(String name) {

        if (null == name) {
            throw new NullPointerException("name is null...");
        }

        if ("".equals(name)) {
            throw new IllegalArgumentException("name is blank...");
        }

        if (!"qinyi".equals(name)) {
            throw new RuntimeException("name is not qinyi...");
        }

        return true;
    }

    /**
     * <h2>打开并关闭 Stream</h2>
     * */
    private static void openAndCloseStream() {

        Stream<Path> pathStream = null;

        try {
            pathStream = Files.list(Paths.get("/tmp"));
            List<Path> paths = pathStream.collect(Collectors.toList());
            System.out.println(paths.size());
            // ....
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (null != pathStream) {
                pathStream.close();
            }
        }
    }

    public static void main(String[] args) {

        // 1. 捕获单个异常
        try {
            validate01(null);
        } catch (Throwable th) {
            System.out.println(th.getMessage());
            th.printStackTrace();
        }

        // 2.1 捕获多个异常 -- 第一种方法, 多一个异常一次捕获多次处理
        try {
            validate02("");
        } catch (NullPointerException ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace();
        } catch (IllegalArgumentException ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace();
        } catch (RuntimeException ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace();
        }

        // 2.2 捕获多个异常 -- 第二种方式, 一个 try, 一个 catch
        try {
            validate02("");
        } catch (NullPointerException | IllegalArgumentException ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace();
        }

        // 2.3 捕获多个异常 -- 第三种方式, 定义一个范围更大的父类异常对象
        try {
            validate02("");
        } catch (RuntimeException ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace();
        }
    }
}