异常:程序出现了不正常的情况。
       
异常的体系
        Throwable
                       
                Error:严重 问题，通常出现重大问题如：运行的类不存在或者内存溢出等。是不需要处理的。
                                一般这种情况是需要修改代码的。
                                这儿的处理指的是（try{}catch(){}或者throws），出现error这样严重问题的时候
                                靠处理的方式是解决不了的，必须找出那个地方犯了这么严重的错误，然后修改代码，改正确了之后，
                                程序才能够运行起来，否则程序绝对运行不起来。
                         
                Exception:不严重
                          1：编译期间：这个是我们需要处理的。（Exception下面 非RuntimeException 的异常）
                                编译期异常就是在咱们写代码的时候程序提示你，这儿以后可能会出现一些常见的问题，让咱们在写代码的时候就得针对这常见的问题
                                采取措施，不要等运行的时候出现了并且报出了哪出的错再去解决，因为这个问题很常见，可以预防，所以java呢为了这样提示咱们就
                                让咱们编译的时候都不让咱们编译通过，必须要采取措施，而我们采取的措施一个就是用try{}catch(){} 另一个就是不用管这个异常啦
                                直接抛给虚拟机把，这两种方式都证明咱们开发人员知道这儿可能会出现异常了并采取措施了。
                                所以说编译期异常的处理方式有两种
                               
                                1）声明异常（就是抛出异常）
                                        在方法声明的后面(即大括号前面):throws 异常类型，不明确要怎么处理的时候
                               
                                2）try{
                                                  编译期异常代码       
                                     }catch(异常类名 变量名){
                                                  异常处理代码。
                                     }

                        2：运行期间：这个是我们不需要处理，但是也可以处理  （RuntimeException下的异常）
                               
                                1）如果不处理，java就会用jvm会采用自动的处理方式，
                                        它就把异常的类型，原因，位置直接显示在了控制台。并且退出当前线程（可以理解为退出虚拟机）
                                        同时后面的代码是不能执行的。

                                2）如果处理,   我们会采用try{}catch(){}
                                        try{
                                                  可能发生问题的代码。       
                                          }catch(异常类名 变量名){
                                                  异常处理代码。
                                          }

                       
                                        ①：一个代码中，有多个问题，怎么解决呢?
                                          A:一个个用异常处理方案解决。（也就是写多个try{}catch(){}）
                                          B:针对所有问题，写一个try...catch代码。
                                                          try{}catch(){}catch(){}...

                                                        针对多个异常，写一个try的代码，catch里面会不会有顺序问题呢?
                                                                 *如果异常是平级关系，没有顺序问题。
                                                                 *如果异常存在着子父关系，父一定要放在最后。
                                                       
                                                        写多个catch(){}我们觉得很麻烦这时候就有了JDK7的新特性
                                                                JDK7新特性：多个catch用一个catch替代。 不是说多个catch的内容，用一个Exception处理。
                                                                  格式：
                                                                          catch(异常1 | 异常2 | 异常3 ... 变量名){}

                                        ②：我们一直在处理异常的时候都是打印的一句话，虽然我们提示了有错误，但是告诉开发人员是哪一行代码出错了吗？
                                                告诉开发人员是哪个异常了吗？没有吧？ 那这样的话，不利于开发人员对代码进行维护，所以我们就有了
                                                标准的异常catch代码，既能打印出异常消息，显示出哪一行出的错，又能不影响后面的代码执行

                                                首先介绍：Throwable中的方法：
                                                                  public String getMessage():返回的是异常的消息字符串。
                                                                  public String toString()：返回异常的简单描述信息。
                                                                                                  全路径类名 : 消息字符串
                                                                 public void printStackTrace():把错误信息显示在控制台。

                                                学完了printStackTrace()后，就学习了catch标准代码
                                                        try{
                                                                          可能有问题的代码
                                                         }catch(异常类名 变量名){
                                                                  变量名.printStackTrace();
                                                         }finally{
                                                                释放资源代码。(数据库,IO)
                                                         }

                               
                                3）如果处理运行期异常，我们还可以采用Throws 抛出异常，但是我们一般不用（为什么？请看下面解释）
                                       
                                        编译期异常：Exception下面 非RuntimeException 的异常
                                        运行期异常：RuntimeException下的异常

                                        如果是运行期异常的话我们抛出，和不抛出有区别吗？是不是一样的啊？而且只要运行时出现异常的话，抛出和不抛出
                                        后面的代码都不会再继续执行了，那么我们为什么有个抛出异常这种处理方式呢？这就又引出了编译期异常，
                                        编译器异常就是在咱们写代码的时候程序提示你，这儿以后可能会出现一些常见的问题，让咱们在写代码的时候就得针对这常见的问题
                                        采取措施，不要等运行的时候出现了并且报出了哪出的错再去解决，因为这个问题很常见，可以预防，所以java呢为了这样提示咱们就
                                        让咱们编译的时候都不让咱们编译通过，必须要采取措施，而我们采取的措施一个就是用try{}catch(){} 另一个就是不用管这个异常啦
                                        直接抛给虚拟机把，这两种方式都证明咱们开发人员知道这儿可能会出现异常了并采取措施了。 所以抛出异常是给谁准备的？给编译器异常
                                        准备的？ 运行期异常虽然能用，但是没啥实际意义，所以运行期异常我们一般还是用try{}catch(){}
                       
                        3：自定义异常
                                对于JDK里面提供给我们的异常对于咱们基础班写程序肯定是够用了，但是对于项目中某些业务的需要，是不够用的，
                                需要我们自己定义一些异常，
                               
                                1）先定义一个类
                                2）继承Exception或者RuntimeException。
                                3）写一个有参构造方法
                                        public MyException(String message) {
                                                super(message);
                                        }
                                4）在不满足条件的代码里面直接throw异常
                                        if (score < 0 || score > 100) {
                                                // System.out.println("分数错误");
                                                MyException my = new MyException("分数不在指定范围内");
                                                throw my;
                                        } else {
                                                System.out.println("分数正确");
                                        }





异常重点掌握4点：（其他的理解就ok）
        1：异常体系
        2：如何使用标准的try{}catch(){}
        3: 编译期异常的其中一种处理方式throws
        4：如何自定义一个异常并注意throw和throws的区别

                                                                                       

异常:程序出现了不正常的情况。
       
异常的体系
        Throwable
                       
                Error:严重 问题，通常出现重大问题如：运行的类不存在或者内存溢出等。是不需要处理的。
                                一般这种情况是需要修改代码的。
                                这儿的处理指的是（try{}catch(){}或者throws），出现error这样严重问题的时候
                                靠处理的方式是解决不了的，必须找出那个地方犯了这么严重的错误，然后修改代码，改正确了之后，
                                程序才能够运行起来，否则程序绝对运行不起来。
                         
                Exception:不严重
                          1：编译期间：这个是我们需要处理的。（Exception下面 非RuntimeException 的异常）
                                编译期异常就是在咱们写代码的时候程序提示你，这儿以后可能会出现一些常见的问题，让咱们在写代码的时候就得针对这常见的问题
                                采取措施，不要等运行的时候出现了并且报出了哪出的错再去解决，因为这个问题很常见，可以预防，所以java呢为了这样提示咱们就
                                让咱们编译的时候都不让咱们编译通过，必须要采取措施，而我们采取的措施一个就是用try{}catch(){} 另一个就是不用管这个异常啦
                                直接抛给虚拟机把，这两种方式都证明咱们开发人员知道这儿可能会出现异常了并采取措施了。
                                所以说编译期异常的处理方式有两种
                               
                                1）声明异常（就是抛出异常）
                                        在方法声明的后面(即大括号前面):throws 异常类型，不明确要怎么处理的时候
                               
                                2）try{
                                                  编译期异常代码       
                                     }catch(异常类名 变量名){
                                                  异常处理代码。
                                     }

                        2：运行期间：这个是我们不需要处理，但是也可以处理  （RuntimeException下的异常）
                               
                                1）如果不处理，java就会用jvm会采用自动的处理方式，
                                        它就把异常的类型，原因，位置直接显示在了控制台。并且退出当前线程（可以理解为退出虚拟机）
                                        同时后面的代码是不能执行的。

                                2）如果处理,   我们会采用try{}catch(){}
                                        try{
                                                  可能发生问题的代码。       
                                          }catch(异常类名 变量名){
                                                  异常处理代码。
                                          }

                       
                                        ①：一个代码中，有多个问题，怎么解决呢?
                                          A:一个个用异常处理方案解决。（也就是写多个try{}catch(){}）
                                          B:针对所有问题，写一个try...catch代码。
                                                          try{}catch(){}catch(){}...

                                                        针对多个异常，写一个try的代码，catch里面会不会有顺序问题呢?
                                                                 *如果异常是平级关系，没有顺序问题。
                                                                 *如果异常存在着子父关系，父一定要放在最后。
                                                       
                                                        写多个catch(){}我们觉得很麻烦这时候就有了JDK7的新特性
                                                                JDK7新特性：多个catch用一个catch替代。 不是说多个catch的内容，用一个Exception处理。
                                                                  格式：
                                                                          catch(异常1 | 异常2 | 异常3 ... 变量名){}

                                        ②：我们一直在处理异常的时候都是打印的一句话，虽然我们提示了有错误，但是告诉开发人员是哪一行代码出错了吗？
                                                告诉开发人员是哪个异常了吗？没有吧？ 那这样的话，不利于开发人员对代码进行维护，所以我们就有了
                                                标准的异常catch代码，既能打印出异常消息，显示出哪一行出的错，又能不影响后面的代码执行

                                                首先介绍：Throwable中的方法：
                                                                  public String getMessage():返回的是异常的消息字符串。
                                                                  public String toString()：返回异常的简单描述信息。
                                                                                                  全路径类名 : 消息字符串
                                                                 public void printStackTrace():把错误信息显示在控制台。

                                                学完了printStackTrace()后，就学习了catch标准代码
                                                        try{
                                                                          可能有问题的代码
                                                         }catch(异常类名 变量名){
                                                                  变量名.printStackTrace();
                                                         }finally{
                                                                释放资源代码。(数据库,IO)
                                                         }

                               
                                3）如果处理运行期异常，我们还可以采用Throws 抛出异常，但是我们一般不用（为什么？请看下面解释）
                                       
                                        编译期异常：Exception下面 非RuntimeException 的异常
                                        运行期异常：RuntimeException下的异常

                                        如果是运行期异常的话我们抛出，和不抛出有区别吗？是不是一样的啊？而且只要运行时出现异常的话，抛出和不抛出
                                        后面的代码都不会再继续执行了，那么我们为什么有个抛出异常这种处理方式呢？这就又引出了编译期异常，
                                        编译器异常就是在咱们写代码的时候程序提示你，这儿以后可能会出现一些常见的问题，让咱们在写代码的时候就得针对这常见的问题
                                        采取措施，不要等运行的时候出现了并且报出了哪出的错再去解决，因为这个问题很常见，可以预防，所以java呢为了这样提示咱们就
                                        让咱们编译的时候都不让咱们编译通过，必须要采取措施，而我们采取的措施一个就是用try{}catch(){} 另一个就是不用管这个异常啦
                                        直接抛给虚拟机把，这两种方式都证明咱们开发人员知道这儿可能会出现异常了并采取措施了。 所以抛出异常是给谁准备的？给编译器异常
                                        准备的？ 运行期异常虽然能用，但是没啥实际意义，所以运行期异常我们一般还是用try{}catch(){}
                       
                        3：自定义异常
                                对于JDK里面提供给我们的异常对于咱们基础班写程序肯定是够用了，但是对于项目中某些业务的需要，是不够用的，
                                需要我们自己定义一些异常，
                               
                                1）先定义一个类
                                2）继承Exception或者RuntimeException。
                                3）写一个有参构造方法
                                        public MyException(String message) {
                                                super(message);
                                        }
                                4）在不满足条件的代码里面直接throw异常
                                        if (score < 0 || score > 100) {
                                                // System.out.println("分数错误");
                                                MyException my = new MyException("分数不在指定范围内");
                                                throw my;
                                        } else {
                                                System.out.println("分数正确");
                                        }





异常重点掌握4点：（其他的理解就ok）
        1：异常体系
        2：如何使用标准的try{}catch(){}
        3: 编译期异常的其中一种处理方式throws
        4：如何自定义一个异常并注意throw和throws的区别