异常处理

 * try...catch...finally的处理格式：
 *         try {
 *             可能出现问题的代码;
 *         }catch(异常名 变量) {
 *             针对问题的处理;
 *         }finally {
 *             释放资源;
 *         }
 *
 * 变形格式：
 *         try {
 *             可能出现问题的代码;
 *         }catch(异常名 变量) {
 *             针对问题的处理;
 *         }
 *
 * 注意：
 *         A:try里面的代码越少越好
 *         B:catch里面必须有内容，哪怕是给出一个简单的提示
 */

多个异常项的时候

注意事项：
 *                 1:能明确的尽量明确，不要用大的来处理。
 *                 2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。

---------------------------------------------------------------------------------------------------------------

/*
 * JDK7出现了一个新的异常处理方案：
 *         try{
 *
 *         }catch(异常名1 | 异常名2 | ...  变量 ) {
 *             ...
 *         }
 *
 *         注意：这个方法虽然简洁，但是也不够好。
 *             A:处理方式是一致的。(实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理)
 *            B:多个异常间必须是平级关系。
 */

public static void main(String[] args) {
        method();
    }

    public static void method() {
        int a = 10;
        int b = 0;
        int[] arr = { 1, 2, 3 };

    

        // JDK7的处理方案
        try {
            System.out.println(a / b);
            System.out.println(arr[3]);
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
            System.out.println("出问题了");
        }

        System.out.println("over");
    }

异常中常见的打印方法

 * 异常中要了解的几个方法：
 * public String getMessage():异常的消息字符串        
 * public String toString():返回异常的简单信息描述
 *         此对象的类的 name(全路径名)
 *         ": "（冒号和一个空格）
 *         调用此对象 getLocalizedMessage()方法的结果 (默认返回的是getMessage()的内容)
 * printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。把信息输出在控制台。
 */

// e.getMessage();
 System.out.println(e.getMessage());
// Unparseable date: "2014-11-20"

// toString()
 System.out.println(e.toString());
 // java.text.ParseException: Unparseable date: "2014-11-20"
            
 e.printStackTrace();

在方法时候抛出异常

/*
 * 有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。
 * 或者说，我处理不了，我就不处理了。
 * 为了解决出错问题，Java针对这种情况，就提供了另一种处理方案：抛出。
 *
 * 格式：
 *         throws 异常类名
 *         注意：这个格式必须跟在方法的括号后面。
 *
 * 注意：
 *         尽量不要在main方法上抛出异常。
 *
 * 小结：
 *         编译期异常抛出，将来调用者必须处理。
 *         运行期异常抛出，将来调用可以不用处理。
 */

例

public static void method2() throws ArithmeticException {}

throw和throws的区别

/*
 * throw:如果出现了异常情况，我们可以把该异常抛出，这个时候的抛出的应该是异常的对象。
 * 
 * throws和throw的区别(面试题)
    throws
        用在方法声明后面，跟的是异常类名
        可以跟多个异常类名，用逗号隔开
        表示抛出异常，由该方法的调用者来处理
        throws表示出现异常的一种可能性，并不一定会发生这些异常
    throw
        用在方法体内，跟的是异常对象名
        只能抛出一个异常对象名
        表示抛出异常，由方法体内的语句处理
        throw则是抛出了异常，执行throw则一定抛出了某种异常
 */

例

public static void method2() throws Exception {
        int a = 10;
        int b = 0;
        if (b == 0) {
            throw new Exception();
        } else {
            System.out.println(a / b);
        }
    }

final,finally和finalize中区别:

/*
 * 面试题：
 * 1:final,finally和finalize的区别
 * final：最终的意思，可以修饰类，成员变量，成员方法
 *         修饰类，类不能被继承
 *         修饰变量，变量是常量
 *         修饰方法，方法不能被重写
 * finally：是异常处理的一部分，用于释放资源。
 *         一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了
 * finalize：是Object类的一个方法，用于垃圾回收
 * 
 * 2:如果catch里面有return语句，请问finally里面的代码还会执行吗?
 *   如果会，请问是在return前，还是return后。
 *        会。前。
 * 
 *      准确的说，应该是在中间。
 * 
 * 3:try...catch...finally的格式变形
 *         A:try...catch...finally
 *         B:try...catch
 *         C:try...catch...catch...
 *         D:try...catch...catch...finally
 *         E:try...finally
 *             这种做法的目前是为了释放资源。
 */

例子

public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a;
            /*
             * return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。
             * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
             * 再次回到以前的返回路径，继续走return 30;
             */
        } finally {
            a = 40;
            return a;//如果这样结果就是40了。
        }
         return a;
    }

自己定义的Exception中要在自己的类中继承Exception和RuntimeException

例：

public class MyException extends Exception {}
or
public class MyException extends RuntimeException {}

继承异常注意事项

/*
 * 异常注意事项:
 * A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
 * B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
 * C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
 */

public class ExceptionDemo {

}

class Fu {
    public void show() throws Exception {
    }

    public void method() {
    }
}

class Zi extends Fu {
    @Override
    public void show() throws ArithmeticException {

    }

    @Override
    public void method() {
        // String s = "2017-11-20";
        // SimpleDateFormat sdf = new SimpleDateFormat();
        // Date d = sdf.parse(s);
        // System.out.println(d);
    }
}