[Java] 异常处理,线程_exception in thread "main" java.lang.runtimeexcept-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_47652477/article/details/115221640

第一章异常

1.1 异常概念

异常: 指的是程序执行过程中,出现的非正常情况,最终会导致JVM的非正常停止

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

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

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable,其下有两个子类:java.lang.Error与java,lang.Exception,平常我们说的异常指的是java,lang.Exception

在这里插入图片描述

Throwable体系:

Error: 严重错误Error,无法通过处理的错误,只能避免,好比绝症
Exception: 表示异常,可以纠正使程序可以正常运行

Throwable的常用方法

public void printStackTrace();打印异常信息
- 包含了异常的类型,原因和位置,该方法在开发调试过程中十分常用
public String getMessage() 获取异常发生的原因
- 提示用户的时候,就是提示错误原因
public String toString()获取异常的类型和异常描述信息(不用)

以后报错了我们直接取API文档去查

1.3 异常分类

异常的分类

编译时期异常:(checked异常) 在编译时期,就会检查.如果没有处理异常,就会编译失败
运行时期异常:(runtime异常) 在运行时期,检查异常,在编译时期,运行异常不会被编译器检测到

在这里插入图片描述

1.4 异常产生过程解析

测试代码:

package demo03;
// 异常产生过程的解析

public class Exception {
    public static void main(String[] args) {
        //创建数组
        int[] arr = {1,2,3};

        int e = getElement(arr,3);//ArrayIndexOutOfBoundsException
        System.out.println(e);

    }
//    定义一个方法，获取数组指定索引处的元素。
    public static int getElement(int[] arr, int index){
        int ele = arr[index];

        return ele;
    }
}

我们发现,爆出了索引越界异常,那么异常产生的过程是什么呢?

JVM会根据异常产生的原因创建一个异常对象,对象包含了异常产生的(内容,原因和位置)
在getElement方法中没有异常的处理(try…catch语句),那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常,
main方法接收到了异常对象,main方法也没有异常的处理逻辑,那么继续把对象抛出给他的调用者JVM处理
JVM接收到了对象,做了两件事情
1. 把异常对象的原因,位置,内容,以红色的字体打印在控制台
2. JVM会终止当前正在执行的java程序—>中断处理

第二章异常的处理

java异常处理的5个关键字:try,catch,finally,throw,throws

2.1 抛出异常 throw

在编写程序时,我们必须要考虑程序出现问题的情况.比如: 在定义方法的时候,方法需要参数,那么,当调用方法的时候,方法接收到参数,那么就要对参数进行一个判断,若是数据不合法,就应该通过抛出异常的方式告诉调用者

注意:

throw关键字必须写在方法的内部
throw关键字后面的new对象必须是Exception或者Exception的子类对象
throw和关键字抛出指定的异常对象,呢么我们一定要处理这个对象(如果是RuntimeExceotion的异常,那么不用处理,交给JVM),如果是编译异常,那么一定要处理

在java中,提供一个throw关键字,它用来抛出一个指定的异常对象.那么,抛出一个异常具体如何操作呢?

格式:

throw new 异常类名(参数);

例如:

package demo03;
// throw可以在指定的方法中抛出指定的异常

//格式 throw new  XXXException("原因")

import javax.sound.midi.Soundbank;

public class Exception {
    public static void main(String[] args) {
        int[ ] bb = null;
        int p = getElement(bb,0);

        System.out.println(p);
    }

    public static int getElement(int[] arr, int index) {
        if (arr == null){
            throw new NullPointerException("我是你爹,传进来一个傻逼数据");
        }
        int ele = arr[index];

        return ele;
    }
}

错误是:

Exception in thread "main" java.lang.NullPointerException: 我是你爹,传进来一个傻逼数据
	at demo03.Exception.getElement(Exception.java:18)
	at demo03.Exception.main(Exception.java:11)

注意:示例中的异常是运行期异常,是不用处理的

2.2 Object非空判断

这个类由一些静态方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),那么在它的源码中,对对象为null的值进行了抛出异常操作

public static <T> T requireNonNull(T obj,String message):查看指定引用对象不是null. 后面的是,可选参数,可以不填,是异常的原因

查看源码发现这里对为null的进行了抛出异常操作

public static <T> T requireNonNull(T obj){
    if(obj == null){
        throw new NullPointerException();
    }
    return obj;
}

示例:

import java.util.List;
import java.util.Objects;

public class Exception {
    public static void main(String[] args) {
        List<Integer> list = null;

        System.out.println(Objects.requireNonNull(list));//抛出空指针异常了·
    }
}

2.3 声明异常throws

声明异常: 将问题标识出来,报告给调用者,如果方法内通过throw抛出了编译时异常,而没有捕获处理,那么必须通过throws进行声明,让调用者去处理

关键字throws方法于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(交给别人处理)

注意：

throws关键字必须写在方法声明处
throws关键字后面声明的异常必须是Exception的子类
方法内部如果抛出了多个异常对象，那么throws后面必须也声明多个异常
1. 如果抛出的多个异常对象有子类父类关系，那么直接声明父类异常即可
调用了一个声明抛出异常的方法，我们就必须处理声明的异常
- 要么方法的调用者继续使用throws，直到交给JVM
- 要么使用try。。catch语句自己处理异常

格式

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

代码演示:

package demo03;


import java.io.FileNotFoundException;

public class Exception  {
    public static void main(String[] args) throws FileNotFoundException {
        readFile("我是你爹");//主函数接收到了这个异常，但是还是要继续抛出处理
    }

    public static void readFile (String filename)  throws FileNotFoundException{
        if (!filename.equals("c:\\a.txt")){
            throw new FileNotFoundException("文件找不到！");//这是一个编译异常，一定要处理
        }
    }
}

2.4 捕获异常try…catch

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

该方法不处理，而是声明抛出，由该方法的调用者来处理
该方法中使用try-catch语句来处理异常。

try-catch语句就是捕获异常

异常捕获： java中队异常有针对性地语句进行捕获，可以对出现地一场进行指定方式地处理。
try当中可能产生多个异常，我们可以使用多个catch来处理这些异常对象
如果try中产生了异常，那么就会执行catch异常处理逻辑，执行完毕catch中地处理逻辑，继续执行try…catch后面的代码

捕获异常语法如下：

try{
    
}catch{
    
}

代码示例

package demo03;


import java.io.FileNotFoundException;

public class Exception  {
    public static void main(String[] args)  {
        try {
            readFile("我是你爹");//主函数接收到了这个异常，用这个语句来处理
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        
          System.out.println("没想到吧！ 就算报错了，爷也可以执行！");
    }

    public static void readFile (String filename)  throws FileNotFoundException{
        if (!filename.equals("c:\\a.txt")){
            throw new FileNotFoundException("文件找不到！");//这是一个编译异常，一定要处理
        }
    }
}

获取异常信息的三种方法

throwable类中定义了一些查看方法

public String getMessage():获取异常的描述信息,原因
public String toString(): 获取异常的类型和异常的描述信息(不用)
public void printStackTrace()打印异常的跟踪栈信息,并输出控制台(默认用这个方法,因为提供的信息是最全面的)

catch语句可以将编译器异常转换为运行期异常

2.5 finally代码块

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

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

当我们在try语句中打开了一些物理资源,我们都得在使用完成之后,最终关闭打开的资源
- 原因就是try语句中一旦发生了异常,那么try里面的后面的语句就不会执行了

finally的语法:

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

注意: finally语句不能单独使用

比如,我们之后学习的IO流中,当打开了一个关联文件的资源,最后程序不管结果如何,都需要把这个资源关闭掉

参考代码:

package demo03;


import java.io.FileNotFoundException;

public class Exception {
    public static void main(String[] args) {
        try {
            System.out.println("资源打开");
            readFile("我是你爹");//主函数接收到了这个异常，但是还是要继续抛出处理
            System.out.println("资源关闭");//这里因为上面有异常,这里无法执行了
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            System.out.println("关闭资源");//这里一定会运行
        }

    }

    public static void readFile(String filename) throws FileNotFoundException {
        if (!filename.equals("c:\\a.txt")) {
            throw new FileNotFoundException("文件找不到！");//这是一个编译异常，一定要处理
        }
    }
}

2.6 异常注意事项

面对异常,我们可以

多个异常分别处理
多个异常一次捕获,多次处理
多个异常一次捕获,一次处理

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

try{
    编写可能会出现异常的语句
}catch(异常类型A e){
    处理异常代码
}catch(异常类型B e){
    处理异常代码
}finally{
    XXX
}

注意: 这种异常处理方式要求catch里面的异常不能相同,并且若是catch中的多个异常中有父类子类关系,那么子类一定要放在众多catch的前列,父类靠后放，因为try在发生异常之后，会从上到下的将异常交catch，若是父类写在了上面，那就变成运行父类的catch了（用到了多态）相当于 XXXException e = new 子类异常（参数）

运行时的异常被抛出可以不处理，即不捕获也不声明抛出
如果父类抛出了多个异常，子类覆盖父类方法时，只能抛出相同的异常或者是他的子集。
父类的方法抛出了异常,那么子类重写该方法的时候就可以抛出和父类相同的异常或者其子类,也可以不抛出异常(总结:爱咋咋地)
父类方法没有写抛出异常，子类覆盖父类方法时也不可以抛出异常。此时子类产生该异常，只能捕获处理,不能声明抛出,
在try…catch语句后面加上finally语句,这里面的代码一定会被执行,通常用于资源回收
如果finally有return语句,永远返回finally中的结果,避免该情况(不要在finally里面写return)

第三章自定义异常

3.1 概述

为什么需要自定义异常?

开发中总有一些异常情况是没有包含在已有的异常上面个的,同时,我们自己创建的类也会出现一些逻辑上的问题而非编译问题,如(年龄负数,成绩负数等),要靠为我们自己定义一个异常

什么是自定义异常类

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

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

异常类如何定义?

自定义一个编译期异常:自定义类,并继承于java.lang.Exception
自定义一个运行时期的异常类: 自定义类,并继承于java.lang.RuntimeException

package demo03;

public class RegisterException extends java.lang.Exception {
    //添加一个空参数的构造方法,调用父类的方法,调用父类的构造方法
    public RegisterException() {
        super();
    }


    //添加一个带异常信息的构造方法
    public RegisterException(String s) {
        super(s);
    }

}

注意:

自定义类的名字一般都是以Exception结尾,说明类是一个异常类
自定义异常类,必须的继承Exception或者RuntimeException

3.2 自定义异常练习

要求: 我们模拟注册操作,如果用户名已经存在,则抛出异常提示

分析:

使用数组来保存已经注册过的用户(数据库)
使用Scanner获取用户输入的注册的用户名(前端,页面)
定义一个方法,对用户输入的用户名进行判断
1. 遍历数组并比较,若是存在,则抛出Register异常,告诉用户名已经被注册
2. 如果循环结束了,还没有找到用户名有重复,则给用户一个用户名可用的提示

首先我们定义一个登录异常类RegisterException

package demo03;

//业务逻辑异常

public class RegisterException extends java.lang.Exception {



    //添加一个空参数的构造方法,调用父类的方法,调用父类的构造方法
    public RegisterException() {
        super();
    }


    //添加一个带异常信息的构造方法
    public RegisterException(String s) {
        super(s);
    }

}

主函数

package demo03;

import java.util.Scanner;

public class demo1 {
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) throws RegisterException {
        Scanner cin = new Scanner(System.in);
        System.out.println("请输出您要注册的用户名");

        String username = cin.next();

        checkUsername(username);
    }

    //校验用户名的方法
    public static void checkUsername( String name) throws RegisterException {
        for (String username : usernames) {
            if (name.equals(username)){
                throw new RegisterException("你输入的用户名已被占用,请重新输入!");
            }
        }
        System.out.println("用户名可以使用!");

    }
}

第四章多线程(重点掌握)

4.1 并发与并行

并发: 指两个或多个时间在同一个时间段内发生(交替执行,吃一口饭吃一口菜)
并行: 指两个或多个事件在同一时刻发生(同时执行,两人吃两个馒头)

注意: 单核处理的计算机肯定是不能并行的处理多个任务的, 只能是多个任务在单个CPU上并发运行.同理,线程也是一样的,从宏观角度上理解线程是并行运行的,但是从微观的角度来看趋势串行运行的,即一个线程一个线程的去运行,当系统只有一个CPU时,线程就会以某种顺序执行多个线程,我们把这个情况称之为 线程调度

4.2 线程与进程

进程: 指的是一个内存中运行的应用程序,每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个进程,进程也是程序的一次执行过程,是系统运行的基本单位**;系统运行一个程序即是一个进程从创建,运行到消亡的过程.**
线程: 线程是进程中的一个执行单元,负责当前进程中的程序的执行,一个进程中至少有一个线程. 一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序.
简而言之: 一个程序运行后至少有一个进程,一个进程中可以包含多个线程

进程示意图

在这里插入图片描述

线程示意图

在这里插入图片描述

线程调度

分时调度
- 所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间,
抢占式调度
- 优先让优先级高的线程使用CPU(让CPU执行到这个程序的几率更大),如果线程的优先级相同,那么会随机选择一个(线程随机性),java使用的为抢占式调度
- 设置线程优先级
  -

主线程: 执行主方法的线程

java程序中只有一个线程,那就是执行从main方法开始,从上到下依次执行

单线程的弊端: 一旦前面发生错误,后面代码的执行就会受阻

4.3 创建线程类

java使用java.lang.Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例化对象.每个线程的作用都是完成一定的任务,实际上就是执行一段程序流即一段顺序执行的代码.java使用线程执行体来代表这段程序流.

java中通过继承Thread类来创建并启动多线程的步骤如下:

定义Thread类的子类,并重写run()方法,该方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程的执行体
创建Thread子类的实例化对象,即创建了线程对象
调用线程对象的start()方法来启动该线程

注意

多次启动一个线程是非法的,线程执行结束之后,就不能重新启动
java是抢占式调度

创建线程代码如下:

//子类对象
package demo04;

//创建多线程的第一种方式: 创建Thread子类

//1 创建Thread子类
public class Demo01Thread extends Thread {

    //重写run()方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run" + i);
        }
    }
}
//主函数
package demo04;

public class Main {

    public static void main(String[] args) {
        //3 创建实例对象
        Demo01Thread demo = new Demo01Thread();
        //4 调用Thread的start方法
        demo.start();

        for (int j = 0; j < 20; j++) {
            System.out.println("main" + j);
        }
    }
}
//结果就是两个线程并发的运行,当前线程(main线程)和另一个线程(执行run方法)
//run0
//main0
//run1
//main1
//...
//run17
//main18
//run18
//main19
//run19