2.10号-2.8

异常概念：
异常体系
throwable（异常抛出）：error不能处理的问题
错误就相当于得了一个无法治愈的毛病，必须修改源代码，程序才能正常运行
try catch   把异常处理掉，后面还能继续使用

    try{
        
    }catch(Exception e){
        
    }

exception（编译器 异常，进行编译（写代码时期）java程序出现的问题）由于使用不当导致  可以通过修改正常使用
运行期异常，java程序运行过程中出现的问题
异常就相当于程序得了一个小毛病，把异常处理掉，程序就可以继续运行
他的子类 
runtimeException：

异常的产生过程解析：分析异常的怎么产生的，如何处理异常

异常的处理：
第一个关键词 throw关键字
作用：可以使用throw关键字在指定的方法抛出指定的异常
格式：
throw  new xxxException（“异常产生的原因”）；
注意事项:
1throw关键字必须卸载方法的内部
2.throw关键字后面new的对象必须是exception或者Exception的子类对象
3.throw关键字抛出指定的异常对象，我们就必须处理这个一场对象
throw关键字后面创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理    ，默认交给JVM处理（打印异常对象，终端程序）；
throw关键字后面创建的是便以一场（写代码的时候报错），我们就必须处理这个异常
要么throw  要么try   catch
在工作中 我们必须对方法传递过来的参数进行合法性校验，如果参数不合法，那么我们就必须使用抛出异常额方式，告知方法的调用者，产地的参数有问题
NullpointException是一个运行期异常我们不用处理，默认交给JVM处理

Objects非空判断：
public static <T> T requireNounNull(T obj){
if(obj == null)
throw new NullPointerException();
return obj;
}

直接Objects.requireNinNull（obj，“传递的对象值是空”）;
只写这个就可以直接非空判断 简化

声明异常：throws：异常处理的第一种方式，交给别人处理
作用：当方法内部抛出一场对象的时候，那么我们就必须处理这个异常对象
可以使用rhrows关键字处理一场对象，会吧一场对象生命抛出给方法额调用者处理（自己不处理，给别人处理，最终交给JVM处理，中断处理）
格式：在方法生命是使用
修饰符 返回值类型 方法名（参数列表） throws{
throw new AAAExpection（“产生原因”）;
}
注意：
1.throw关键字必须写在方法声明处
2.throw关键字后面声明的异常必须是Expection或者是Exception的子类
3.方法内部如果抛出了多个异常对象，那么throw后面必须也声明多个异常
如果抛出的多个一场对象有父子类关系，那么直接声明父类异常即可
4.调用了一个声明抛出异常的方法，我们就必须的处理声明的异常
要么继续使用hrow声明抛出，交给方法的调用者处理，最终交给JVM
要么try..catch自己处理异常

定义一个方法，对传递的文件卢静进行合法性判断
如果卢静不是“c:\\a.txt”,那么我们就抛出文件找不到一场对象，告知方法的调用者

package Learn;

import java.io.FileNotFoundException;
import java.io.IOException;

public class Throws {
    public static void main(String[] args) throws IOException {
        readFile("c:\\a.txt");
    }
    public static void readFile(String fileName) throws IOException {
        if (!fileName.equals("c:\\\\a.txt")){
            /*
            如果派出的多个异常对象有父子类关系，那么直接生命父子类异常即可
             */
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
            /*
            zhuyi :FileNotFoundException是便以一场，抛出了编译异常，就必须处理这个异常
            可以使用throw几许生命FileNotFoundException这个异常对象，让方法的调用者处理
             */

        }
        if (!fileName.equals("c:\\\\a.txt")
            throw new IOException("文件的后缀名不对");
        System.out.println("路径没有问题，读取文件");
        /*
        如果传递的路径不是.txt胡额为，那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
         */

    }
}

捕获异常：    try  catch：异常处理的第二个格式，自己处理异常：
            格式
            try{
            可能产生的异常代码
            }catch（定义一个异常变量，用来接收try中抛出的异常对象）{
            异常的处理逻辑，异常对象之后，怎么处理异常对象
            }
            .....
            catch（异常类名 变量名）{
            }
            注意：try中可能会跑出多个异常对象，那么就可以使用U盾哦个catch来处理这些异常对象
            2.如果try中产生了异常，那么就会执行catch中额异常处理逻辑，执行完毕catch中的吃力逻辑，继续执行try   ...catch中的挨骂
            如果try中没有产生异常，那么就不会执行catch异常的处理逻辑，执行完try中的代码，继续执行try..catch之后的代码
   Throwable类中3个异常处理的方法
                String getMessage();返回此throwable的简述描述
            String toMessage();返回此throwable的详细信息字符串
            void printStackTrace();jvm打印异常对象，默认此方法，打印的异常信息是最全面的
            sout（e.getmessage）
            sout（e.tomessage）
            e.printStackTrace();
finally代码块：无论怎么样都要执行的代码
try  catch：异常处理的第二个格式，自己处理异常：
            格式
            try{
            可能产生的异常代码
            }catch（定义一个异常变量，用来接收try中抛出的异常对象）{
            异常的处理逻辑，异常对象之后，怎么处理异常对象
            }
            .....
            catch（异常类名 变量名）{
            }
finally{
  无论怎么样都要执行的代码
}
注意：finally 不能单独使用，必须和try一起使用
2.finally一般用于资源施放（资源回收），武林程序是否出现异常，最后都要施放（IO）
异常的注意事项：
多一场的捕获处理：
1.多个异常分不处理   
2.多个异常一次捕获，多次处理      就是多次用try catch
3.多个异常一次捕获一次处理    一个try  多个catch
    3的注意事项：
catch里面的异常变量，若果有子父类关系，那么子类的异常变量必须卸载上面，否则会报错
运行时异常被抛出可以不处理，即不捕获也不声明抛出，默认给虚拟机处理，终止程序，什么时候不抛出异常了，什么时候再继续执行程序
如果finally有return语句 ，永远返回fianlly中的杰阔，避免该情况。
就是finally最好不写return语句

异常注意事项紫福磊异常

1如果父类抛出了多个一场，子类重写父类方法时，抛出和父类相同的异常或者父类异常的子类或者不抛出异常
2.父类方法没有抛出异常，子类重写父类该方法时也不会抛出异常 此时子类产生该异常只能捕获处理，不能声明抛出
注意：父类异常时是什么样，子类异常就什么样

自定义异常：
java提供的异常类，不够我们使用，需要自己定义一些异常类，格式：
public class  XXXException extends Exception /RuntimeException{
添加一个空参数的构造方法
添加一个带异常信息的构造方法
}
注意：1.自定义异常类一般都是一Exceotion的结尾，说明该类是一个异常类
2.自定义异常类，必须得继承Exceotion或者RuntimeException
 继承Exception：那么自定义的异常类就是一个编译器异常，如果方法内部抛出了异编译器异常，就必须处理这个异常，要么throw 要么try catch
继承RuntimeException：那么自定义的异常类就是一个运行期异常，无序处理，交给虚拟机处理（中断处理）

多线程：
并发：至两个或多个事件在同一时间段内发生  多个任务交替执行
并行：只两个火多个事件在同一个时刻发生（同时发生）。

进程的概念：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程  就是进入RAM   

线程：线程市金城的一个执行单元，一个进程至少有一个线程  一个进程中是可以有多个线程的

8线程  可以同时执行八个任务  

点击功能，cpu就可以通过这个卢静执行功能，叫做线程
线程属于进程，是进程中的一个执行单元，负责程序的执行
线程的调度：
分时调度：所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu 的时间
抢占式线程优先运行

创建主线程：执行主方法的线程
单线程恒旭：java程序中只有一个线程
执行从main方法开始，从上到下依次执行
单线程不好之处  只要有异常后面就不执行了

创建多线程的第一种方式：创建thread类的子类
实现步骤：
1.创建一个thread类的子类
2.在Thread类的子类中重写thread类中额run方法，设置线程任务（县城要做什么
3.创建thread的子类对象
4.调用thread类中的方法strart，开启新的线程，执行run方法
void start（）

多次启用一个线程是非法的，特别是当线程已经结束执行后们不能在重新启动
java程序属于抢占式调度，那个线程优先级高，那个线程就有限执行 同一个优先级，那就随机选择一个执行
package Learn;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <20; i++) {
            System.out.println("run="+i);
        }
    }
}
package Learn;

public class Made {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        for (int i = 0; i <20; i++) {
            System.out.println("main="+i);
        }
    }
}