Day8 异常.线程

1.异常：1>分类：Exception（与error是Throwable的子类），是可以避免的；

                             Exception编译期异常，其中RuntimeException是运行期异常；

              2>异常产生过程：->JVM检测到异常；

                                           ->根据异常原因创建异常对象（包含异常发生的内容、原因、位置）；

                                              //new ArrayIndexOutOfBoundsException("3")；

                                           ->没有异常处理的逻辑（try...catch），JVM会把异常对象抛给方法调用者main()；

                                           ->main也没有异常处理逻辑，就把异常对象给main的JVM；

                                           ->JVM接收到后，把异常对象（内容、原因、位置）打印在控制台；

                                           ->终止当前正在执行的java程序；

                                           ->终端处理；

              3>判断异常：<1>throw关键字：指定方法中抛出指定异常；//throw new xxxException(“异常产生原因”);

                                                                 必须写在方法内部，new后面必须是Exception或其子类对象；

                                                                 当throw抛出RuntimeException可以不处理，交给JVM；

                                                                 当throw抛出编译异常，必须用throws或者try...catch处理异常；

                                   <2>Objects类里的requireNonNull方法：直接判断传递进来的对象是否为空；

                                                                                                   //Objects.requireNonNull(obj,"传递的对象的值为null");

              4>处理异常：<1>throws关键字：将异常对象抛出给调用方法的调用者处理，自己不处理；

                                                                    /* 修饰符 放回值类型方法吗（参数列表）throws{

                                                                        throw new xxxException("产生原因")；} */

                                                                    需要写在方法声明处，后面必须是Exception或其子类对象；

                                                                    方法内部有多个异常对象，需要声明多个异常，若是子父类，声明父类即可；

                                    <2>try...catch关键字：自己处理异常，try产生异常，catch就执行，没有异常，catch就不执行；

                                                                        执行完毕，继续执行catch之后的代码；

                                                                        /* try{

                                                                                可能产生异常的代码

                                                                           }catch(定义一个异常的变量，用来接收try抛出的异常变量){

                                                                                                        // catch(异常类名 变量名IOException e){

                                                                                异常处理逻辑，如何处理异常对象System.out.println("balabala");

                                                                              } */

              5>Throwable类中异常处理的方法：<1>String getamessage()：返回这个throwable的简短描述；

                                                                       <2>String toString()：返回这个throwable的详细消息字符串；

                                                                       <3>void printStackTrace()：JVM打印异常对象，默认此方法，打印信息全面；

              6>finally代码块：<1>无论是否有异常，都会执行，不能单独使用，必须与try一起用；

                                                属于一种资源释放； //try{...} catch{...} final{}

                                          <2>finally有return语句：会一直返回final的返回值，所以要避免这种情况；

              7>多异常的捕获处理：<1>多个异常分别处理，用多个try...catch；

                                                  <2>多个异常一次捕获，多次处理，用一个try多个catch；

                                                        catch里的异常变量，若有子父类关系，子类的必须写上面，父类在下面，类似多态；

                                                  <3>多异常一次捕获，一次处理，用一个try一个catch；

              8>子父类异常：<1>父类有异常：子类可以抛出相同异常 / 抛出父类异常的子类 / 不抛出异常；

                                       <2>父类没有异常：子类重写方法时不能抛出异常 / 有异常只能try...catch捕获，不能throws抛出；

              9>自定义异常类：public class xxxException extends Exception / RuntimeException{

                                                添加一个空参数构造方法

                                                添加一个带异常信息的构造方法 }

                                           //Exception通过throw或try..catch处理；RuntimeException交给虚拟机处理，进行中断；

              10>练习：

 

2.线程：1>并发：交替执行；并行：同时执行；

              2>进程和线程：<1>进程：从硬盘里进入到内存中的应用程序；

                                       <2>线程：是进程的执行单一，负责进程中程序的执行，一个进程可以有一个或多个线程；

                                                        单线程：高速切换；多线程好处：效率高，多线程之间互不影响；

              3>线程调度：java使用的是抢占式调度，谁的优先级高，先执行谁的概率大；

              4>主线程：执行主方法main的线程，从main开始，从上到下；

                                JVM执行main方法，main方法进入栈内存，JVM在操作系统里开辟一个main方法同学cpu的执行路径；

                                cpu通过路径执行main方法，该路径为main(主)线程；

              5>创建Thread类的子类：创建多线程；