异常总结，配套day19

我们自己如何处理异常呢?
    A:try...catch...finally 捕获异常，处理异常，在try语句块中捕获异常，在catch块中进行匹配异常与异常处理，在finally块中进行资源释放。
    B:throws 抛出异常

try...catch...finally的处理格式：
          try {
              可能出现问题的代码;
          }catch(异常名 变量) {
              针对问题的处理;
          }finally {
              释放资源;
          }
 
变形格式：
          try {
              可能出现问题的代码;
          }catch(异常名 变量) {
              针对问题的处理;
          }
JDK7出现了一个新的异常处理方案：
          try{
 
          }catch(异常名1 | 异常名2 | ...  变量名 ) {
              ...
          }
         catch (ArithmeticException | ArrayIndexOutOfBoundsException e)
          注意：这个方法虽然简洁，但是也不够好。
             A:处理方式是一致的。(实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理)
         B:多个异常间必须是平级关系，不能包含Exception。
   
注意：
          A:try里面的代码越少越好,因为java会为try语句块内容开辟特别的空间，try越大，资源占用越多，影响运行。
          B:catch里面必须有内容，哪怕是给出一个简单的提示

        
面对众多异常如何解决？
  A:一个异常
  B:二个异常的处理
          a:每一个写一个try...catch
          b:写一个try，多个catch
              try{
                  ...
              }catch(异常类名 变量名) {
                  ...
              }
              catch(异常类名 变量名) {
                  ...
              }
              ...
 
 注意事项：
          1:能明确的尽量明确，不要用大的来处理。如果直接用Exception捕获异常，它还要去遍历他的所有子类来最终确定异常属于那个子类，耗费资源。所以最好能明确异常子类。
          2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。即Exception一定要放在其子类异常的后面去捕获，作为最终抄底者。
 
注意：
          一旦try里面出了问题，就会在这里把问题给抛出去，然后和catch里面的问题进行匹配，
          一旦有匹配的，就执行catch里面的处理，然后结束了try...catch
          继续执行后面的语句。
         
        try {
            System.out.println(a / b);
            System.out.println(arr[3]);
            System.out.println("这里出现了一个异常，你不太清楚是谁，该怎么办呢?");
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("你访问了不该的访问的索引");
        } catch (Exception e) {
            System.out.println("出问题了");     
        }//放在最后用来保底，防止出错停止运行，但这个千万不能放在它的子类前面，因为判断异常是顺序判断的，如果碰上Exception父类，直接捕获，后面的子异常都不用捕获了，因为没有意义。

       
 
编译时异常和运行时异常的区别？
Java中的异常被分为两大类：编译时异常和运行时异常。所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常

编译时异常
Java程序必须显示处理，否则程序就会发生错误，无法通过编译
运行时异常
无需显示处理，也可以和编译时异常一样处理




在try里面发现问题后，jvm会帮我们生成一个异常对象，然后把这个对象抛出，和catch里面的类进行匹配。
如果该对象是某个类型的，就会执行该catch里面的处理信息。
 
异常中要了解的几个方法：
public String getMessage():异常的消息字符串        
public String toString():返回异常的简单信息描述
      此对象的类的 name(全路径名)
      ": "（冒号和一个空格）
      调用此对象 getLocalizedMessage()方法的结果 (默认返回的是getMessage()的内容)
public void printStackTrace() ：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。把信息输出在控制台。


父类Throwable
Throwable中的方法
getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream s)
通常用该方法将异常内容保存在日志文件中，以便查阅。



第二种抛出异常方式：throws
有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。
或者说，我处理不了，我就不处理了。
为了解决出错问题，Java针对这种情况，就提供了另一种处理方案：抛出。
格式：
      throws 异常类名
      注意：这个格式必须跟在方法的括号后面。
 
注意：
      尽量不要在main方法上抛出异常。
      但是我讲课为了方便我就这样做了。
 
小结：
  编译期异常抛出，将来调用者必须处理。
          运行期异常抛出，将来调用可以不用处理。
        但要注意，若在运行期异常抛出的是编译型异常或父类异常Exception，编译器发现不是RunTimeException的时候，就会当作编译器异常来处理，此事跟编译期异常一样，调用者是必须对异常进行处理的。

  

throw:如果出现了异常情况，我们可以把该异常抛出，这个时候的抛出的应该是异常的对象。
 
throws和throw的区别(面试题)
    throws
        用在方法声明后面，跟的是异常类名
        可以跟多个异常类名，用逗号隔开
        表示抛出异常，由该方法的调用者来处理
        throws表示出现异常的一种可能性，并不一定会发生这些异常
    throw
        用在方法体内，跟的是异常对象名
        只能抛出一个异常对象名
        表示抛出异常，由方法体内的语句处理
        throw则是抛出了异常，执行throw则一定抛出了某种异常
        
        编译型异常，必须马上进行处理
        看那些需要处理的编译型异常的方法源码，就能看到其实他们是利用throw来抛出新构造的编译期异常。
        所以，若抛出运行型异常，不用进行异常抛出处理
              若抛出编译型异常，就会抛出异常需要调用者进行处理
 
 
 
我们到底该如何处理异常呢
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws

注意：把异常抛给虚拟机或方法调用者后，异常后面的方法就不能继续执行，所以有后续执行需求的人记得用try，而不要用throws。

举例:
感冒了就自己吃点药就好了,try
吃了好几天药都没好结果得了H7N9,那就的得throws到医院
如果医院没有特效药就变成Error了


finally:

　　  被finally控制的语句体一定会执行
  　　注意：如果在执行到finally之前jvm(比如System.exit(0))退出了，就不能执行了。
A:格式
          try...catch...finally...
B:用于释放资源，在IO流操作和数据库操作中会见到

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

public class FinallyDemo2 {
    public static void main(String[] args) {
        System.out.println(getInt());
    }

    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a; //先执行return 20；发现还有finally，就去执行，把a赋值完40后，返回return 30，注意，此时返回的不是变量a，而是整数30。所以后来a被赋值为40，也不会对后来的返回有影响。
             //
             //return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。
             // 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
             //再次回到以前的返回路径，继续走return 30;
             //
        } finally {
            a = 40;
            return a;//如果这样结果就是40了。
        }
        // return a;
    }
}

 

3:try...catch...finally的格式变形
          A:try...catch...finally
          B:try...catch
          C:try...catch...catch...
          D:try...catch...catch...finally
          E:try...finally
              这种做法的目前是为了释放资源。


  java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自己定义异常。
  而我们自己随意的写一个类，是不能作为异常类来看的，要想你的类是一个异常类，就必须继承自Exception或者RuntimeException
 
  两种方式：
  A:继承Exception
  B:继承RuntimeException
 
 public class Teacher {
    public void check(int score) throws MyException {
        if (score > 100 || score < 0) {
            throw new MyException("分数必须在0-100之间");
        } else {
            System.out.println("分数没有问题");
        }
    }

    // 针对MyException继承自RuntimeException
    // public void check(int score) {
    // if (score > 100 || score < 0) {
    // throw new MyException();
    // } else {
    // System.out.println("分数没有问题");
    // }
    // }
}

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