异常

1 java的异常处理机制
1.1 异常在java中以类和对象的形式存在。那么异常的继承结构是怎么样的？
我们可以使用UML图来描述一下结构继承。
画UML图有很多工具，例如：Rational Rose（收费的）、startUML等...
Object
Object下有Throwable（可抛出的）
Throwable下有两个分支：Error（不可处理的，直接退出JVM）和Exception（可处理的）
Exception下有两个分支：
Exception的直接子类：编译时异常。（要求程序员在编写程序阶段必须预先对这些异常进行处理，如果不处理编译器报错，因此得名编译时异常。）
RuntimeException：运行时异常。（在编写程序阶段程序员可以预先处理，也可以不管，都行。）

1.2 编译时异常和运行是异常，都是发生在运行阶段。编译阶段异常是不会发生的。
编译时异常因为什么而得名？
因为编译时异常必须在编译（编写）阶段预先处理，如果不处理编译器报错，因此得名。
所有一掺个都是在运行阶段发生的，因为只有程序运行阶段才可以new对象。
因为异常的发生就是new异常对象。

1.3 编译时异常和运行时异常的区别？
编译时异常一般发生的概率比较高。
运行时异常一般发生的概率比较低。
举个例子：
你看到外面下雨了，倾盆大雨的。
你出门之前会预料到:如果不打伞，我可能会生病（生病是一种异常）。
而且这个异常发生的概率很高，所以我们出门之前要拿一把伞。
“拿一把伞”就是对“生病异常”发生之前的一种处理方式。

对于一些发生概率较高的异常，需要在运行之前对其进行预处理。

运行时异常一般发生的概率比较低。
举个例子：
小明走在大街上，可能会被天上的飞机轮子砸到。
被飞机轮子砸到也算一种异常。
但是这种异常发生概率较低。
再出门之前你没必要提前对这种发生概率较低的异常进行预处理。
如果你预处理这种异常，你将活的很累。

假设你再出门之前，你把能够发生的异常都预先处理，你这个人会更加的安全，但是你这个人活的很累。

假设java中没有对异常进行划分，没有分为：编译时异常和运行时异常。
所有的异常都需要在编写阶段对其进行预处理，将是怎样的效果呢？
首先，如果这样的话，程序肯定是绝对安全的。
但是程序员编写程序太累，代码到处都是处理异常的代码。

1.4 编译时异常还有其他名字：
受检异常：CheckdException
受控异常

1.5 运行时异常还有其他名字：
未受控异常：UnCheckdException
非受控异常。

1.6 再次强调：所有的异常都是发生在运行阶段的。

1.7 java语言中对异常的处理包括两种方式：
第一种方式：在方法生命的位置上，使用throws关键字，抛给上一级。
谁调用我，我就抛给谁。抛给上一级。

第二种方式：使用try..catch语句进行异常的捕捉。
这件事发生了，谁也不知道，因为我给抓住了。

举个例子：
我是某集团的一个销售员，因为我得失误，导致公司损失了1000元，
“损失1000元”这可以看做是一个异常发生了。我有两种处理方式，
第一种方式：我把这件事情告诉我的领导【异常上抛】
第二种方式：我自己掏腰包把这个钱补上。【异常的捕捉】

什么是异常，java提供异常机制有什么用？

package com.javase.Exception;
/*
1 什么是异常，java提供异常机制有什么用？
    以下程序执行过程中发生了不正常的情况，而这种不正常的情况叫做：异常
    java语言是很完善的语言，提供了异常的处理方式，以下程序执行过程中出现了不正常情况，
    java把该异常信息打印输出到控制台，供程序员参考。
    程序员看到以后，可以对程序进行修改，让程序更加的健壮。
    
    什么是异常：程序执行过程中的不正常情况。
    异常的作用：增强程序的健壮性。
    
2 以下程序执行控制台出现了：
    Exception in thread "main" java.lang.ArithmeticException: / by zero
   at com.javae.Exception.ExceptionTest01.main(ExceptionTest01.java:17)
   这个信息被我们称作：异常信息。这个信息是JVM打印的。
*/
public class ExceptionTest01 {
    public static void main(String[] args) {
        
        int a= 10;
        int b = 1;
        // 实际上JVM在执行到此处的时候，会new异常对象。 new ArithmeticException("/ by zero");对象
        // 并且JVM将new的异常对象抛出，打印输出信息到控制台了。
        int c = a / b;
        System.out.println(a +" / "+ b + " = " + c);
        
        // 此处运行也会创建一个：ArithmeticException类型的对象。
        System.out.println(100 / 0);
        
        // 我观察到异常信息之后，对程序进行修改，更加健壮。
        /*int a = 10;
        int b = 0;
        if(b == 0){
            System.out.println("除数不能为0");
            return;
        }
        // 程序执行到此处表示除数一定不是0
        int c = a / b;
        System.out.println(a +" / "+ b + " = " + c);*/
    }
}

java语言中异常是以什么形式存在的呢？

package com.javase.Exception;
/*
java语言中异常是以什么形式存在的呢？
    1 异常在java中以类的形式存在，每一个异常都是一个类。
    2 异常对应的现实生活中是怎样的？
        火灾（异常类）：
            2008年8月8日小明家着火了（异常对象）
            2008年8月18日小刚家着火了（异常对象）
            2008年8月28日小红家着火了（异常对象）
        类是：模板。
        对象是：实际存在的个体。
        
        钱包丢了（异常类）：
            2008年1月8日:小明的钱包丢了（异常对象）
            2008年1月9日:小明的钱包又丢了（异常对象）
            ...
*/
public class ExceptionTest02 {
    public static void main(String[] args) {
        // 通过"异常类"实例化"异常对象"
        NumberFormatException numberFormatException = new NumberFormatException("数字格式化异常");
        
        // java.lang.NumberFormatException: 数字格式化异常
        System.out.println(numberFormatException);
        
        // 通过“异常类”创建“异常对象”
        NullPointerException nullPointerException = new NullPointerException("空指针异常发生了");
        // java.lang.NullPointerException: 空指针异常发生了
        System.out.println(nullPointerException);
    }
}

ArithmeticException异常案例：

package com.javase.Exception;


public class ExceptionTest03 {
    public static void main(String[] args) {
        /*
        程序执行到此处发生了ArithmeticException: / by zero异常。
        底层new了一个ArithmeticException异常对象。
        然后抛出了，由于是main方法调用了100/0
        所以这个异常ArithmeticException抛给了main方法
        main方法没有处理，将这个异常抛给了JVM。
        JVM最终终止程序的执行。
        
        ArithmeticException继承了RunTimeException，属于运行时异常。
        在编写程序阶段不需要对这种异常进行预先的处理。
         */
        System.out.println(100 / 0);
        
        // 这里的Hello World没有输出，没有执行。
        System.out.println("Hello World");
    }
}

分析代码异常报错原因案例：

package com.javase.Exception;
/*
以下代码报错的原因是什么？
    因为doSome()方法声明位置上使用了throws ClassNotFoundException
    而ClassNotFoundException是编译时异常。必须编写代码时处理，没有处理编译器报错
*/
public class ExceptionTest04 {
    public static void main(String[] args) {
        // main方法中调用doSome()方法
        // 因为doSome()方法声明位置上有:throws ClassNotFoundException
        // 我们在调用doSome()方法的时候必须对着汇总异常进行预先的处理。
        // 如果不处理，编译器就会报错。
        // 编译器报错信息:Unhandled exception: java.lang.ClassNotFoundException
        // doSome();
    }
    
    /**
     * doSome方法在声明的位置使用了：throws ClassNotFoundException
     * 这个代码表示doSome()方法在执行过程中，有可能会出现ClassNotFoundException异常。
     * 叫做类没有找到异常，这个异常直接父类是：Exception，所以ClassNotFoundException属于编译时异常。
     * @throws ClassNotFoundException
     */
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome方法执行了");
    }
}

异常的捕捉和上抛：

package com.javase.Exception;


public class ExceptionTest05 {
    // 第一种处理方式：在声明的位置上继续使用：throws来完成异常的继续上抛，抛给调用者。
    // 上抛类似于推卸责任（继续向上抛给调用者）
    /*public static void main(String[] args) throws ClassNotFoundException{
        doSome();
    }*/
    
    // 第二种处理方式：try..catch进行捕捉
    // 不做等于把异常拦下了，异常真正的解决了。（调用者是不知道的。）
    public static void main(String[] args) {
        try {
            doSome();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome方法执行了");
    }
}

异常的上报和捕捉：

package com.javase.Exception;


import java.io.FileNotFoundException;
import java.io.FileOutputStream;


/*
处理异常的第一种方式：在方法声明的位置使用throws关键字抛出，谁调用我这个方法，我就抛给谁，抛给调用者处理。
    这种处理异常的态度：上报。
    
处理异常的第二种方式：
    使用try..catch语句对异常进行捕捉。
    这个异常不会上报，自己把这个事处理了。
    异常抛到此处为止，不在上抛了。
    
注意：
    只要异常没有捕捉，采用上报的方式，此方法的后续代码不会执行。
    另外需要注意，try语句块中的某一行出现异常，该行后面的代码不会执行。
    try..catch执行完成后，该方法后面的java语句会执行。
*/
public class ExceptionTest06 {
    // 一般不建议在main方法上使用throws，因为这个异常如果真正发生了，一定会抛给JVM、JVM只有终止。
    // 异常处理机制的作用就是增强程序的健壮性，怎么能做到、异常发生了也不影响程序的执行。
    // 所以一般main方法中的异常建议使用try..catch进行捕捉，main就不要继续向上抛了。
    public static void main(String[] args) {
        System.out.println("main begin");
        // try尝试
        try {
            m1();
        // 以上代码出现异常，直接进入catch语句块中执行。
        } catch (FileNotFoundException e) { // catch后面的好像一个方法的形参
            // 这个分支中可以使用e引用，e引用保存的内存地址是那个new出来异常对象的内存地址。
            // catch是捕捉 异常之后走的分支
            // 在catch分支中干什么？处理异常。
            System.out.println("文件不存在，可能路径错误！也可能该文件被删除了。");
            System.out.println(e);// java.io.FileNotFoundException: C:哇哈哈哈哈哈哈哈哈.txt (拒绝访问。)
        }
        // try..catch把异常抓住以后，这里的代码会继续执行。
        System.out.println("main end");
        
    }
    
    public static void m1() throws FileNotFoundException {
        System.out.println("m1 begin");
        m2();
        // 出现异常以下代码不会被执行
        System.out.println("m1 end");
    }
    
    // 抛别的不行，抛ClassCastException说明你还是没有对FileNOtFoundException进行处理
    // 抛FileNotFoundException的父类对象IOException，这样是可以的。因为IOException包括FileNotFoundException
    // private static void m2() throws FileNotFoundException {
    // 这样也可以，因为Exception包括所有的异常。
    // private static void m2() throws Exception {
    // throws后面也可以写多个异常，使用逗号隔开
    // private static void m2() throws ClassNotFoundException,FileNotFoundException{
    private static void m2() throws FileNotFoundException{
        System.out.println("m2 begin");
        m3();
        // 出现异常以下代码不会被执行
        System.out.println("m2 end");
    }
    
    private static void m3() throws FileNotFoundException {
        // 调用SUN jdk中某个类的构造方法
        // 这个类还没有接触过，后期IO流的时候就知道了。
        // 我们只是借助这个类学习一下异常处理机制。
        // 创建一个输入流对象，该流指向一个文件。
        System.out.println("m3 begin");
        /*
        编译报错的原因是什么？
            1 第一：这里调用了一个构造方法：FileInputStream(String name)
            2 第二：这个构造方法的声明位置上有：throws FileNotFoundException
            3 第三：通过类的继承结构看到：FileNotFoundException的父类是IOException，IOException的父类是Exception
            最终得知，FileNotFoundException是编译时异常。
            
            错误原因？编译时异常要求程序员编写程序阶段必须对他进行处理，不处理编译器报错。
            
         */
        // 我们采用第一种处理方式：在方法声明的位置上使用throws继续上抛。
        // new FileOutputStream("C:\Users\xlWu\Desktop\学习\异常\学习.txt");
        new FileOutputStream("C:哇哈哈哈哈哈哈哈哈.txt");
        // 出现异常以下代码不会被执行
        System.out.println("m1 end");
    }
}

深入try..catch：

package com.javase.Exception;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


/*
深入try..catch
    1 catch后面的小括号中的类型可以是具体的异常类型，也可以是该异常类型的父类型。
    2 catch可以写多个，建议catch的时候，精确的一个一个处理，这样有利于程序的调试。
    3 catch写多个的时候，从上到下，必须遵循从小到大。
    
在以后的开发中，处理编译时异常，应该上报还是捕捉呢，怎么选？
    如果希望调用者来处理，选择throws上报。
    其它情况使用捕捉的方式。
*/
public class ExceptionTest07 {
    /*public static void main(String[] args) throws Exception, FileNotFoundException,NullPointerException,NumberFormatException {
    
    }*/
    
    /*public static void main(String[] args) throws Exception {
    
    }*/
    
    public static void main(String[] args) {
        /*try {
            FileInputStream fis =  new FileInputStream("D:\Users\xlWu\Desktop\学习\异常\异常的继承结构图.uml");
            System.out.println("出现异常，这里无法执行！");
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
        }
    
        System.out.println("hello world!");*/
    
        /*try {
            FileInputStream fis =  new FileInputStream("D:\Users\xlWu\Desktop\学习\异常\异常的继承结构图.uml");
            System.out.println("出现异常，这里无法执行！");
        *//*} catch (IOException e) {// 多态 IOException e = new FileNotFoundException();*//*
        } catch (Exception e) {// 多态 Exception e = new FileNotFoundException();
            System.out.println("文件不存在！");
        }*/
    
        /*try {
            // 创建输入流
            FileInputStream fis =  new FileInputStream("D:\Users\xlWu\Desktop\学习\异常\异常的继承结构图.uml");
            // 读文件
            fis.read();
        } catch (Exception e) { // 所有的异常都走这个分支
            System.out.println("文件不存在！");
        }*/
    
        /*try {
            // 创建输入流
            FileInputStream fis =  new FileInputStream("D:\Users\xlWu\Desktop\学习\异常\异常的继承结构图.uml");
            // 读文件
            fis.read();
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
        } catch (IOException e) {
            System.out.println("读文件报错了！");
        }*/
        
        // 编译报错  自上而下执行  必须由小到大
        /*try {
            // 创建输入流
            FileInputStream fis =  new FileInputStream("D:\Users\xlWu\Desktop\学习\异常\异常的继承结构图.uml");
            // 读文件
            fis.read();
        } catch (IOException e) {
            System.out.println("文件不存在！");
        } catch (FileNotFoundException e) {
            System.out.println("读文件报错了！");
        }*/
        
        // JDK8的新特性
        try {
            // 创建输入流
            FileInputStream fis =  new FileInputStream("D:\Users\xlWu\Desktop\学习\异常\异常的继承结构图.uml");
            // 进行数学运算
            System.out.println(10 / 0);// 这个是运行时异常，编写程序时可以处理，也可以不处理。
        } catch (FileNotFoundException | ArithmeticException | NullPointerException e) {
            System.out.println("文件不存在？数学异常？空指针异常？都有可能！");
        }
    }
}