异常和线程详解（附加代码）

第一章 异常

1.1 异常概念

异常，就是不正常的意思。在生活中：医生说，你的身体某个部位有异常，该部位和正常部位相比有点不同，该部位的功能将受影响，在程序中的意思就是：

·异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

//tips：异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：

java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception

Throwable体系：

·Error：严重错误Error，无法通过处理的错误，只能事先避免

·Exception：表示异常，异常产生后程序员可以通过代码块的方式纠正，使程序继续运行，是必须要处理的

java.lang.Throwable:类是Java语言中所有错误或异常的超类

Exception：编译其异常，进行编译（写代码）Java程序出现的异常

​ RuntimeException：运行期异常，Java程序运行过程中出现的问题

​ 异常就相当于程序得了一个小毛病（感冒，发烧），把异常处理掉，程序可以继续执行

Error：错误

​ 错误就相当于一个程序得了一个无法治愈的毛病，必须修改源代码，程序才能继续执行

1.3 异常的产生过程解析

代码演示：

/**
 *异常的产生过程解析（分析异常怎么产生的，如何处理异常）
*/
public class Demo02Exception {
    public static void main(String[] args) {
        int [] arr = {20,30,74,10};
        int result = getElement(arr,4);
        System.out.println(result);
    }
/**定义一个方法，获取数组指定索引的元素

参数：
    int [] arr
    int index
* */
    private static int getElement(int [] arr,int index) {
        int result = arr[index];
        return result;
    }
}

过程解析：

①访问了数组中的4索引，而数组是没有4索引的，JVM就会检测出程序会出现的异常

JVM会做两件事：

1、JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的（内容、原因、位置）

​ new ArrayIndexOutOfBoundsException(“4”);

2、在getElement方法中，没有异常处理逻辑（try…catch），那么JVM就会把异常抛出给方法的调用者main方法来处理这个异常

main方法接收到了这个异常对象，main方法也没有异常的处理逻辑，继续把对象抛出给main方法的调用者JVM处理

JVM接收到了这个异常对象，做了两件事

​ 1、把异常对象（内容、位置、原因）以红色的字体打印在控制台

​ 2、JVM会终止当前正在执行的java程序–>中断处理

第二章 异常的处理

Java异常处理的五个关键字:try、catch、finally、throw、throws

2.1 抛出异常throw

在编写程序时，我们必须考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在Java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1、创建一个异常对象。封装一些提示信息（信息可以自己编写）

2、需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw异常对象

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行

使用格式：

throw new 异常类名(参数);

代码演示：

/**
 * throw关键字
 * 作用：
 *      可以使用throw关键字在指定的方法中抛出指定的异常
 * 使用格式：
 *      throw new xxxException("异常产生的原因");
 * 注意事项：
 *      1、throw关键字必须写在方法的内部
 *      2、throw关键字后边new的对象必须是Exception或者是Exception的子类对象
 *      3、throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
 *          throw关键字后边创建的是RuntimeException或者是RuntimeException的子类
 *          对象，我们可以不处理，默认交给JVM处理（打印异常对象，终端程序）
 *
 *          throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，
 *          要么throws，要么try...catch
*/
public class Demo03Throw {
    public static void main(String[] args) {
        int [] arr ={19,53,2,5};
        getElement(arr,4);
    }
    /**定义一个方法，获取数组指定索引的元素
     参数：
     int [] arr
     int index
     以后（工作中）我们首先必须对方法传递过来的参数进行合法性校验
     如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题
     注意：
        NullPointerException是一个运行期异常，我们不用处理，默认交给JVM处理
        ArrayIndexOutofBoundsException是一个运行期异常，我么你不用处理，默认交给JVM
     * */
    private static int getElement(int [] arr,int index) {
        /**
         * 我们可以对传递过来的参数数组，进行合法性校验
         * 如果数组arr的值是null
         * 那么我们就抛出空指针异常，告知方法的调用者“传递的数组的值是null”
        */
        if (arr == null) {
            throw new NullPointerException("传递的数组是null");
        }
        /**
         * 我们可以对传递过来的参数进行合法校验
         * 如果index的范围不在数组的索引范围内
         * 那么我们就抛出数组索引越界异常，告知方法的调用者“传递的索引超出了数组的使用范围”
        */
        if (index<0 || index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("数组的索引越界了");
        }
        int result = arr[index];
        return result;
    }
}

2.2 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（后面会讲到），那么必须通过throws进行声明，让调用者去处理

关键字throws运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常（抛出异常）

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类型1,异常类名2...{ }

代码演示：

/**
 * throws关键字：异常处理的第一种方式，交给别人处理
 * 作用：
 *      当方法内部抛出异常对象时，那么我们就必须处理这个异常对象
 *      可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理），
 *      最终交给JVM处理-->中断程序
 * 使用格式：在方法声明时使用
 *      修饰符 返回值类型   方法名（参数列表）throws aaaException,bbbException{
 *          throw new aaaException("产生原因");
 *          throw new bbbException("产生原因");
 *          ...
 *      }
*/
public class Demo04Throws {
    /**
     * FileNotFoundException extends IOException extends Exception
     * 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
    */
    public static void main(String[] args) throws Exception {
        readFile("c:\\a.txt");
    }

    /**
     * 定义一个方法，对传递的文件路径继续合法性判断
     * 如果路径不是“c:\a.txt”那么我们就抛出文件找不到异常对象，告知方法的调用者
     *
     * 注意：
     *  FileNotFoundException是编译异常，抛出了编译异常就必须处理这个异常
     *  可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
    */
    private static void readFile(String fileName) throws FileNotFoundException,IOException {
        if (!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }
        /**
         * 如果传递的路径不是.txt结尾
         * 那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
        */
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

注意事项：

1、throws关键字必须写在方法声明处（方法上）

2、throws关键字后边声明的异常必须是Exception或者Exception的子类

3、方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常

​ 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可

4、调用一个声明抛出异常的方法，我们就必须处理声明的异常

​ 要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM

要么try…catch自己处理异常

2.3 捕获异常try…catch

如果异常出现的话，会立刻终止程序，所以我们得处理异常：

1、该方法不处理，而是声明抛出，由该方法的调用者来处理（throws）

2、在方法中使用try…catch的语句块来处理异常

try…catch的方式就是吧捕获异常。

·捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try{

​ 编写可能出现异常的代码

}catch(异常类型 e){

​ 处理异常的代码

​ //记录日志/打印异常信息/继续抛出异常

}

代码演示：

/**
 * try...catch异常处理的第二种方式，自己处理异常
 * 格式：
 *  try{
 *      可能出现异常的代码块
 *  }catch（定义一个异常的变量，用来接收try中抛出的异常对象）{
 *      异常的处理逻辑，产生异常对象之后，怎么处理异常对象
 *      一般在工作中，会把异常的信息记录到一个日志中
 *  }
 *  ...
 *  catch（异常类型 变量名）{
 *
 *  }
 * 注意：
 * 1、try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
 * 2、如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，
 * 继续执行try...catch之后的代码
 *    如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行
 *    try...catch之后的代码
*/
public class Demo05TryCatch {
    public static void main(String[] args) {
        try {
            readFile("c:\\a.tx");
            //方法上抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
        }catch (IOException e){
            System.out.println("catch -->传递的文件后缀名不是.txt");
        }
        System.out.println("后续代码");
    }

    /**
     * 如果传递的路径不是.txt结尾
     * 那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
    */
    private static void readFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
            System.out.println("路径没有问题，读取文件");
    }
}

如何获取异常信息;

Throwable类中定义了一些查看方法：

·public String getMessage():获取异常的描述信息、原因（提示给用户的时候，就提示错误原因）

·public String toString():获取异常的类型和异常描述信息

·public void printStackTrace():打印异常的跟踪栈信息并输出到控制台

​ 包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace。

在开发中呢也可以在catch将编译期异常转换成运行期异常处理。

2.4 finally 代码块

**finally：**有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

当我们在try语句中打开了一些物理资源（磁盘文件/网络链接/数据库连接等），我们都得在使用完之后最终关闭打开的资源

finally的语法：

try…catch…finally:自身需要处理异常，最终还得关闭资源

**注意：**finally不能单独使用

2.5 异常注意事项

·多个异常使用捕获又该如何处理呢？

1、多个异常分别处理

2、多个异常一次捕获，多次处理

3、多个异常一次捕获一次处理

一般我们是使用一次捕获多次处理方式，格式如下：

try{

​ 编写可能会出现异常的代码

}catch(异常类型A e){ 当try中出现A类型异常，就用该catch捕获

​ 处理异常的代码

​ //记录日志/打印异常信息/继续抛出异常

}catch(异常类型B e){ 当try中出现B类型异常，就用该catch捕获

​ 处理异常的代码

​ //记录日志/打印异常信息/继续抛出异常

}

**注意：**这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理

public class Demo06Exception {
    public static void main(String[] args) {
        //1、多个异常分别处理
        int [] arr = {1,2,3};
        /*try {
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }*/


        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3);
        /*try {
            System.out.println(list.get(3));
        }catch (Exception e){
            System.out.println(e);
        }*/

        //2、多个异常一次捕获，多次处理
       /* try {
            System.out.println(arr[3]);
            System.out.println(list.get(3));
        }catch (ArrayIndexOutOfBoundsException e ){
            System.out.println(e);
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }*/
        /*
        * 一个try多个catch注意事项：
        * catch里边定义的异常变量，如果又子父类关系，那么子类的异常变量必须写在上边，否则就会报错
        * ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
        * */

        //3、多个异常一次捕获一次处理
        try {
            System.out.println(arr[3]);
            System.out.println(list.get(3));
        }catch (Exception e){
            System.out.println(e);
        }
        System.out.println("后续代码");
    }
}

第三章 自定义异常

3.1 概述

为什么需要自定义异常类：

我们说了Java中不同的异常类，分别表示着某一种具体的异常情况，那么在开发中总是有些异常，情况是SUN没有定义好的，此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题，考试成绩负数问题等等

什么是自定义异常：

在开发中根据自己业务的异常情况来定义异常类

自定义一个业务逻辑异常：RegisterException。一个注册异常类

异常类如何定义：

1、自定义一个编译器异常：自定义类并继承与java.lan.Exception

2、自定义一个运行时期的异常类：自定义类并继承与java.lang.RuntimeException

/**
 * 自定义异常类：
 *        Java提供的异常类不够我们使用，需要自己定义一些异常类
 * 格式：
 * public class XXXException |RuntimeException{
 *     添加一个空参的构造方法
 *     添加一个带异常信息的构造方法
 * }
 * 注意：
 *  1、异常类一般都是以Exception结尾，说明该类是一个异常类
 *  2、自定义异常类，必须继承Exception或者RuntimeException
 *  继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就
 *  必须处理这个异常，要么throws，要么try...catch
 *
 *  继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）
*/
public class RegisterException extends RuntimeException {
    //添加一个空参的构造方法
    public RegisterException(){
        super();
    }
    //添加一个带异常信息的构造方法
    /**
     * 查看源码发现，所有的异常类都会有一个异常信息的构造方法，方法内部会调用父类异常信息
     * 的构造方法，让父类来处理这个异常信息
    */
    public RegisterException(String message){
        super(message);
    }
}

3.2 自定义异常类的练习

要求：模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

分析：
 * 1、使用数组保存已经注册过的用户名（数据库）
 * 2、使用Scanner获取用户输入的注册的用户名（前端页面）
 * 3、定义一个方法，对用户输入的注册的用户名进行判断
 *      遍历存储已经注册过用户名的数组，获取每一个用户名
 *      使用获取到的用户名和输入的用户名比较
 *          true：
 *              用户名已经存在，抛出RegisterException异常，告知用户：”亲，该用户名已被注册“
 *          false：
 *              继续遍历比较
 *       如果循环结束了，还没有找到重复的用户名，提示用户：“恭喜您，注册成功！”
*/
public class Demo02RegisterException {
    //1.使用数组保存已经注册过的用户名（数据库）
    static String [] usernames= {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //2.使用Scanner获取用户输入的注册的用户名（前端页面）
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名:");
        String username = sc.next();
        checkUsername(username);

    }
    //3.定义一个方法，对用户输入的注册的用户名进行判断
    public static void checkUsername(String username) /*throws RegisterException*/ {
        //遍历存储已经注册过用户名的数组，获取每一个用户名
        for (String name:usernames){
            //使用获取到的用户名和输入的用户名比较
            if (name.equals(username)){
                try {
                    throw new RegisterException("亲，该用户名已经被注册！");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return; //结束方法
                }
            }
        }
        System.out.println("恭喜您，注册成功！");
    }
}

第四章 多线程

4.1 并发与并行

· 并发：指两个或多个事件在同一个时间段内发生（交替执行）

· 并行：指两个或多个事件在同一时刻发生（同时执行）

图示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gNKoA1B8-1612432140843)(D:\Program Files\java笔记\Java自我小结\linux\并发与并行图.PNG)]

4.2 线程与进程

· 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程

· 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也可以被称之为多线程程序

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

内存：所有的应用程序都需要进入到内存中执行 进行临时存储（也叫RAM）

​

cpu：中央处理器，对数据进行计算，指挥电脑中的软件和硬件干活

cpu的分类：1、AMD 2、Inter

多线程好处：1、效率高 2、多个线程互不影响

线程调度：

· 分时调度

​ 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

· 抢占式调度

​ 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的是抢占式调度

4.3创建线程类

​ Java使用java.labg.Thread类代表线程，所有的线程对象都必须是Thread类或者其子类的实例，每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表河段程序流，Java中通过继承Thread类来创建并启动多线程的步骤如下：

1、定义Thread类的子类，并重写该类类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。

2、创建Thread子类的实例，即创建了线程对象

3、调用线程对象的start()方法来启动该线程

代码如下：（单线程）

/**
 * 主线程：执行main方法的线程
 *
 * 单线程：Java程序中只有一个线程
 * 执行从main方法开始，从上到下依次执行
 *
 * JVM执行main方法，main方法会进入到栈内存当中，JVM会找操作系统开辟一条main方法通向cpu的执行
 * 路径，cpu就可以通过这个路径来执行main方法，而这个路径有一个名字，叫main（主）线程

*/
public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("张三");
        p1.run();

        Person p2 = new Person("李四");
        p2.run();
    }
}

代码如下：（多线程的创建）

/**
 * 创建多线程的第一种方式：创建Thread类的子类
 * java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
 *
 * 实现步骤：
 *  1、创建一个Thread类的子类
 *  2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）
 *  3、创建Thread类的子类对象
 *  4、调用Thread类中的方法start方法，开启新的线程，执行run方法
 *
 *   void start()   使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
 *   使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
 *   结果是两个线程并发地运行；当前线程（主线程）和另一个线程（创建的新线程，执行其 run 方法）。
 *   多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
 *
 *

*/
public class Demo01Thread {
    public static void main(String[] args) {
        //3、创建Thread类的子类对象
        MyThread mt =new  MyThread();
        //4、调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();


        for (int i = 0; i < 20; i++) {
            System.out.println("main"+i);

        }
    }
}