自定义异常，抛出异常

异常：
      在程序运行过程中，出现的不正常情况叫做异常
  注意：
      1.相同的代码在运行的时候，根据输入的参数或者操作的不同，有可能会发生异常，有可能不会发生异常，
          应该在写代码的过程中尽可能的保证代码的正确性，不要到处都是bug
      2.如果要解决代码中出现的异常，需要添加非常复杂的代码逻辑来进行判断，会使代码变得非常臃肿，不利于维护，
          可读性比较差，因此，推荐大家使用异常机制来处理程序运行过程中出现的问题。
      3.程序在运行过程中如果出现了问题，会导致后面的代码无法正常执行，而使用异常机制之后，可以对异常情况进行处理
          同时后续的代码会继续执行，不会中断整个程序
      4.在异常的处理过程中，不要只是简单的输出错误，要尽可能的将详细的异常信息进行输出
          e.printStackTrace():打印异常信息的最后一行开始追踪，寻找自己编写的Java类
异常的处理方式：
  1.捕获异常
    try{可能出现异常代码逻辑}catch(Exception e){异常处理逻辑}
    try{可能出现异常代码逻辑}catch(具体的异常Exception e){异常处理逻辑}catch(具体的异常);
        可以针对每一种具体的异常做相应的更丰富的处理
  注意：当使用多重的catch的时候一定要注意相关异常的顺序，将子类放在最前面的catch，父类放在后面的catch
      执行过程中可能存在的情况：
        1.正常执行，只执行try中的代码
        2.遇到异常情况，会处理try中异常代码之前的逻辑，后面的逻辑不会执行，最后会执行catch中的代码
        3.使用多重catch的时候，会遇到异常子类不匹配的情况，此时依然会报错，因此建议在catch的最后将所有的异常的父类写上

InputMismatchException 输入参数不匹配异常
ArithmeticException 数学异常

public class TestException {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入被除数：");
        try{
            int num1 = in.nextInt();
            System.out.print("请输入除数：");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1,num2,num1 / num2));
        }catch(ArithmeticException e){
            System.out.println("除数不能为0");
            //Throwable类里的getMessage方法
            System.out.println(e.getMessage());
            //跟踪堆栈信息
            e.printStackTrace();
            System.out.println("ArithmeticException");
        }catch(InputMismatchException e){
            e.printStackTrace();
            System.out.println("InputMismatchException");
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("Exception");
        }
        System.out.println("感谢使用本程序！");
        System.out.println("这是红色字体，一般用来标识异常信息");

        try {
            FileInputStream fileInputStream = new FileInputStream(new File("D://e.txt"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            Class.forName("com.tensent.helloWorld");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

       //如何把字符串类型转换成int类型
        String s = "123";
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}

java中只存在值转递
   自定义异常：在Java的api中提供了非常丰富的异常类，但是在某些情况下不太满足我们的需求，此时需要自定义异常
    步骤：
        1.继承Exception类
        2.自定义实现构造方法
        3.需要使用的时候，使用throw new 自定义异常的名称;
什么时候需要自定义异常？
        一般情况下不需要
        但是在公司要求明确，后者要求异常格式规范统一的时候是必须要自己实现的
 

在程序运行过程中，如果处理异常的部分包含finally的处理，那么无论代码是否发生异常，finally中的代码总会执行
   finally包含哪些处理逻辑
       1.I/O流的关闭操作一般放在finally中
       2.数据库连接的关闭操作一般放在finally中

public class FinallyDemo {
    public static void main(String[] args) {
        try{
            System.out.println(1 / 0);
            System.out.println("try中的语句");
        }catch(Exception e){
            e.printStackTrace();
            System.exit(1);
            return;
        }finally{
            System.out.println("无论是否有异常finally语句块都会被执行！");
            return;
        }
        System.out.println("try...catch...finally...语句块后面的代码逻辑！");
    }
}

throws:声明异常
    在异常情况出现的时候，可以使用try...catch...finally的方式对异常进行处理，除此之外，可以将异常向外抛出，由外部的调用者进行处理
    1.在方法调用过程中，可以存在N多个方法之间的调用，此时假如每个方法中都包含了异常情况
        那么就需要在每个方法中都进行try...catch...另外一种比较简单的方式，就是在方法的最外层调用处理一次即可
        使用throws的方法，对所有执行过程中的所有方法出现的异常进行统一集中处理
    2.如何判断是使用throws还是使用try...catch...
        最稳妥的方法是在每个方法中都进行异常处理
        偷懒的方法是判断在整个调用的过程中，外层的调用方法是否有对异常的处理，如果有直接使用throws，如果没有
            那么就要使用try...catch...
 throws：声明异常，是声明异常是在声明方法的头部去写的，后面可以跟多个异常。
 throw:抛出异常，是在方法内部使用的，后面只能写一个异常
 NullPointerException：空指针异常
 

Error：错误
RuntimeException:运行时异常,是编译的时候出错的，我们是看不出来的
Checked:检查时异常,是编译不通过
main方法:只有JVM虚拟机能调用main方法
异常：Exception的顶级父类是Throwable老祖宗是Object
五个常见的运行时异常：ClassCastException (类转换异常)、IndexOutOfBoundsException (数组越界异常)、NullPointerException (空指针异常)、ArrayStoreException (数据存储异常，操作数组时类型不一致)、BufferOverflowException (还有IO操作的,缓冲溢出异常)