异常处理机制及其使用原则

异常：------原则：
              1.考虑避免异常，彻底杜绝异常 ，不能避免异常，应尽量减少异常的发生；
              2.在异常不能完全避免的情况下，应先准备好异常处理措施；
              3.对于系统发生异常，有些可以自身处理，有些需要借助其他系统来处理；
              4.系统遇到异常，应先自己处理，实在不能解决，才去借助其他方法；
           ---------合理的运用这套异常机制，可以提高系统的【健壮性】；

java异常处理机制：
     
            处理异常时要注意两点：1.如何表示异常？ 2.如何控制处理异常的流程；
            优势：
                  1.java首先将异常分类，并用java的专用类来表示，我们称为【常类】，将各种各样的异常常用类称为分类；
                  2.正常代码与异常代码分离，提高阅读性，简化代码；
                  3.灵活的处理异常的方式：可以捕获处理，也可以抛出交由其他程序处理；

JVM的方法调用栈处理异常：
            JVM方法调用栈，来跟踪每一个线程中一系列的方法调用情况，该栈保存了每个线程的信息--->方法的栈结构，每个线程都有一个独立的方法调用栈，
            main()方法位于【栈的底部】，而正在执行的方法在【栈的顶部】；

public class MainApp {
    public static void main(String[] args) {
        System.out.println("Main()开始");
        methodA();
        System.out.println("Main()结束");
    }
    public static void methodA(){
        System.out.println("A开始");
        methodB();
        System.out.println("A结束");
    }
    public static void methodB(){
        System.out.println("B执行");
    }
}
-------------------->Main()开始
A开始
B执行
A结束
Main()结束

处理异常的两种方法：

           1.try....catch...;         2.自身抛出；
    2.如果在方法中出现异常，jvm首先要找到出该异常的catch代码，如果存在，那么执行catch里面的代码，然后运行catch后面的代码，否则，jvm会从调用栈中
      立即弹出该方法的栈结构，继续到前面一个方法去找catch，找到catch后，执行catch中的代码，流程继续从catch后面的代码执行；
                main()--->methodA()--->methodB();
    3.如果在上述中的前一个方法也没有找到catch,一直到main方法；如果这时候都还没有catch语句，那么JVM将采取以下措施：
 
        1.调用异常对象的printStackTrace()方法，打印方法调用的异常信息；
        2.如果该线程不是主线程，那么终止该线程，其他线程正常运行；如果是主线程，那么终止整个线程；

         try.....catch...用于捕获异常
               try{
                        //可能出现异常的代码
                  }catch(Exception e)
                     {
                        //捕获异常后怎么处理
                     }
        当发生异常的时候，程序立即停止转向catch语句，然后继续向下执行；

          finally--------->在程序发生异常时，会中断程序执行，但有些代码在【任何条件下都应该被执行，否则会影响整个程序】,在这种情况下，出现了finally语句，
                           finally语句中的代码在任何条件下都会被执行；

         throws---------->如果一个方法可能会出现异常，但自身没有处理的能力，就应该在方法上用throws声明此方法将发生异常，这样谁调用这个方法，
                           谁就用try...catch处理它(如果还不能处理，再次抛出)；
                            用throws抛出多种异常：public void main()throws IOException,SQLException{......}
              
         throw------------>throw用于在代码中抛出异常，也被称为【手动抛出异常】；
                            throw用法有如下几种方法：
                                1.判断到错误，然后用throw语句抛出异常让其他调用者处理；
                                    public static int mehtod(int x,int y)throws Exception{
                                       if(y==0){
                                              throw new Exception("参数不能为零");
                                              }else{
                                                    int z=x/y;
                                                    }
                                      }
                               2.在try...catch...中处理部分异常，但还没有全部处理完毕，需要再次抛出，由调用者处理；
                                        public static int mehtod(int x,int y)throws Exception{
                                            try{
                                                  return x/y;
                                                }catch(Exception e){
                                                   System.out.println("发生错误！！！");//日志
                                                   throw new Exception();
                                                }
                                        }
                           throw语句后面应该通过new关键字来创建异常对象，该对象只能是java.lang.Throwable类及其子类；
                            【方法中使用了throw，该类后面必须用上throws语句】

java异常语句的使用规则：
                     1.try语句不能脱离catch语句或finally语句单独使用，try语句后面至少要跟一个catch语句或finally语句；
                     2.try语句要么和catch语句连用，要么和finally语句连用；
                       try...catch...,try....finally...,try...catch....finally...
                     3.catch语句可以有多个（可以有0个）而finally有且只能用一个（可以有0个）;
                     4.当catch与finally连用的时候，catch与finally是不能互换的，
                     5.try中定义的变量只能在try中使用，catch和finally是无法访问的，如果三者都要方法，需定义在try语句之外；
                     6.当try后面的声明多个catch的时候，依据声明的顺序，JVM会将抛出的异常类型与catch中声明的类型逐个匹配，当发现异常类型是声明的异常类型
                        或该类型的子类的时候就进入此catch语句，而不会再次执行下面的catch语句，同时，应该注意catch的【顺序由小到大】，否则会编译出错；
                            try{
                                 ...................IOException
                                ....................SQLException
                                }catch(IOException e){
                                 .................
                                }catch(SQLException e){
                                   ...............
                                }
                                ......................
                                  
                     7.如果一个方法出现【受检查异常】，那么一定要用try...catch或throws处理，否则编译无法通过；
                     8.throw语句后面是不能跟其他正常语句，【因为出现throw时，其后面的语句是不会执行的】；