一、异常

异常的根类是 java.lang.Throwable ，其下有两个⼦类： java.lang.Error 与 java.lang.Exception ，平常所说的异常指 java.lang.Exception 。

Throwable体系：

Error：严重错误Error，⽆法通过处理的错误，只能事先避免，好⽐绝症。

Exception：表示异常，异常产⽣后程序员可以通过代码的⽅式纠正，使程序继续运⾏，是

必须要处理的。好⽐感冒、阑尾炎。

Throwable中的常⽤⽅法：

public void printStackTrace() ：打印异常的详细信息。包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使⽤ printStackTrace。

public String getMessage() ：获取发⽣异常的原因。提示给⽤户的时候，就提示错误原因。

public String toString() ：获取异常的类型和异常描述信息（不⽤）。

1.异常Exception

1、异常（Exception）的分类：

编译时期异常：checked异常。在编译时期，就会检查，如果没有处理异常，则编译失败。

（如⽇期格式化异常）

|- parseException - 格式化异常
|- IOException - IO异常
|- FileNotFoundException - 文件未找到
|- ClassNotFoundException - 类未找到
|- UnsupportedEncodingException - 不支持的字符集异常

运⾏时期异常：runtime异常。在运⾏时期，检查异常。在编译时期，运⾏异常不会编译器  

检测（不报错）。（如数学异常）

|- NullPointerException - 空指针异常
|- IndexOutOfBoundException - 下标越界异常
|- ClassCastException - 类型转换异常
|- NumberFormatException - 数值转换异常
|- IllegalArgumentException - 非法的参数
|- UnsupportedOpertionException - 不支持的操作

2、异常的处理

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

2.1捕获异常try…catch

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

try {

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

} catch(异常类型 e) {

处理异常的代码

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

}

try：该代码块中编写可能产⽣异常的代码。

catch：⽤来进⾏某种异常的捕获，实现对捕获到的异常进⾏处理。

注意：try和catch都不能单独使⽤，必须连⽤。

如何获取异常信息：

Throwable类中定义了⼀些查看⽅法：

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

public String toString() ：获取异常的类型和异常描述信息（不⽤）。

public void printStackTrace() ：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使⽤ printStackTrace。

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;/*try- catch解决已检查异常*/
public class ExceptionDemo01 {public static void main(String[] args) {//格式化类SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");try {Date parse = sdf.parse("yyyy/MM-dd");} catch (ParseException e) {e.printStackTrace();//打印堆栈信息/*java.text.ParseException: Unparseable date: "yyyy/MM-dd"at java.base/java.text.DateFormat.parse(DateFormat.java:388)at b_exception.ExceptionDemo01.main(ExceptionDemo01.java:20)*/}try {BufferedImage read = ImageIO.read(ExceptionDemo01.class.getResourceAsStream("a.png"));} catch (IOException e) {e.printStackTrace();/** Exception in thread "main" java.lang.IllegalArgumentException: input == null!at java.desktop/javax.imageio.ImageIO.read(ImageIO.java:1356)at b_exception.ExceptionDemo01.main(ExceptionDemo01.java:26)*/}//UnsupportedEncodingExceptiontry {new String(new byte[10],"UTF-8");} catch (UnsupportedEncodingException e) {e.printStackTrace();}}
}

/*try-catch解决 运行时异常*/
public class RuntimeExceptionDemo02 {public static void main(String[] args) {//相当于if - elsetry{Demo03Array.method01();System.out.println("正常运行的情况");Demo04NullPointer.method02();/*catch (NullPointerException e){System.out.println("空指针异常已经抛出");}*/}catch(ArrayIndexOutOfBoundsException e){System.out.println("数组下标越界异常已解决");//e.printStackTrace();//打印栈路径}catch (NullPointerException e){System.out.println("空指针异常已经抛出");}catch (RuntimeException e){System.out.println("运行时异常已经解决");//e.printStackTrace();}/* //异常二:空指针异常String[] str = new String[3];System.out.println(str[1].length());//异常三:类型转换异常Object o = new String("哈哈");Integer i = (Integer) o;*/}
}

2.2finally 代码块

finally：有⼀些特定的代码⽆论异常是否发⽣，都需要执⾏。另外，因为异常会引发程序跳转，

导致有些语句执⾏不到。⽽finally就是解决这个问题的，在finally代码块中存放的代码都是⼀定

会被执⾏的。

finally的语法：

try...catch....finally：⾃身需要处理异常，最终还得关闭资源。

注意：finally不能单独使⽤。

注意：

1. 多个异常分别处理。

2. 多个异常⼀次捕获，多次处理。

3. 多个异常⼀次捕获⼀次处理。

⼀般我们是使⽤⼀次捕获多次处理⽅式，格式如下：

try {

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

} catch(异常类型A e) { 当try中出现A类型异常,就⽤该catch来捕获.

处理异常的代码

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

} catch(异常类型B e) { 当try中出现B类型异常,就⽤该catch来捕获.

处理异常的代码

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

}

注意：这种异常处理⽅式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有⼦⽗类异常的关系，那么⼦类异常要求在上⾯的catch处理，⽗类异常在下⾯的catch处理。

4.运⾏时异常被抛出可以不处理。即不捕获也不声明抛出。

5.如果finally有return语句，永远返回finally中的结果，避免该情况.。

6.如果⽗类抛出了多个异常，⼦类重写⽗类⽅法时，抛出和⽗类相同的异常或者是⽗类异常的⼦类或者不抛出异常。

7.⽗类⽅法没有抛出异常，⼦类重写⽗类该⽅法时也不可抛出异常。此时⼦类产⽣该异常，只能捕获处理，不能声明抛出。

/*try - catch - finally*/
public class Demo05 {public static void main(String[] args) {// 相当于if - else return;try{Demo03Array.method01();Demo04NullPointer.method02();return;}catch(NullPointerException e){System.out.println("抛出空指针");}catch (ArrayIndexOutOfBoundsException e){System.out.println("抛出下标越界");}catch (RuntimeException e){System.out.println("抛出运行时异常");}finally {//finally中所有代码,必须执行System.out.println("finally执行的代码");}}
}

import java.util.Scanner;/*finally 和 return 的执行顺序结论: 运行程序,先遇到了try中有finally关键词,则会先去查看finally中的内容如果try遇到了return,则标记方法结束.在方法结束之前,try先去finally中读取内容,读取完成直接返回return中之前标记好的结果.*/
public class Demo06Method {public static void main(String[] args) {int i = m1();System.out.println(i);}public static int m1(){Scanner sc = new Scanner(System.in);int a = 10;try{a += 20;return a;// 30,标记方法结束 30} catch (RuntimeException e){System.out.println("抓到异常");}finally {sc.close();//释放资源a++;System.out.println("finally中a的值:" + a);//31}return 0;}
}

2.3抛出异常throw

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

在java中，提供了⼀个throw关键字，它⽤来抛出⼀个指定的异常对象。

步骤：

1. 创建⼀个异常对象。封装⼀些提示信息（信息可以⾃⼰编写）。

2. 需要将这个异常对象告知给调⽤者。怎么告知呢？怎么将这个异常对象传递到调⽤者处呢？

通过关键字throw就可以完成。throw 异常对象。

throw ⽤在⽅法内，⽤来抛出⼀个异常对象，将这个异常对象传递到调⽤者处，并结束当前

⽅法的执⾏。

throw new 异常类名(参数);

2.4声明异常throws

声明异常：将问题标识出来，报告给调⽤者。如果⽅法内通过throw抛出了编译时异常，⽽没有

捕获处理（稍后讲解该⽅式），那么必须通过throws进⾏声明，让调⽤者去处理。

关键字throws运⽤于⽅法声明之上，⽤于表示当前⽅法不处理异常，⽽是提醒该⽅法的调⽤者

来处理异常（抛出异常）。

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

throws⽤于进⾏异常类的声明，若该⽅法可能有多种异常情况产⽣，那么在throws后⾯可以写多个异常类，⽤逗号隔开。

import java.io.IOException;/*
throw new 异常
throws 解决 已检查异常*/
public class Demo02 {public static void main(String[] args) throws Exception {//创建一个 运行时异常 - 可解决可不解决/* throw new RuntimeException();throw new NullPointerException();*/// 手动创建 已检查异常 - 必须要解决的//方式一: try- catchtry{throw new IOException();}catch (IOException e){}//方式二: 直接抛出异常throw new Exception();}
}

throw 和 throws 的区别:a.throws 是用来声明一个方法可能会抛出的异常类型,表示异常的一种可能性.throw 是创建一个具体的异常类型,执行throw则一定会抛出某种异常对象b.throws 出现在方法上throw 出现在方法中

3、自定义异常

异常类如何定义：

1. ⾃定义⼀个编译期异常：⾃定义类，并继承于 java.lang.Exception 。

2. ⾃定义⼀个运⾏时期的异常类：⾃定义类，并继承于 java.lang.RuntimeException 。

// 业务逻辑异常
public class RegisterException extends Exception {/*** 空参构造*/public RegisterException() {}/*** @param message 表示异常提示*/public RegisterException(String message) {super(message);}
}public class Demo {// 模拟数据库中已存在账号private static String[] names = {"bill", "hill", "jill"};public static void main(String[] args) { // 调⽤⽅法try {// 可能出现异常的代码checkUsername("nill");System.out.println("注册成功"); // 如果没有异常就是注册成功} catch(RegisterException e) {// 处理异常e.printStackTrace();}}// 判断当前注册账号是否存在// 因为是编译期异常，⼜想调⽤者去处理 所以声明该异常public static boolean checkUsername(String uname) throws LoginException
{for (String name : names) {if (name.equals(uname)) {//如果名字在这⾥⾯ 就抛出登陆异常throw new RegisterException("亲" + name + "已经被注册了！");}}return true;}
}

二、线程

1.相关概念

程序：“计算机程序或者软件程序(通常简称程序)是指一组指示计算机每一步动作的指令,通常用某种程序设计语言编写,运行于某种目标体系结构上。

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

线程：线程是进程中的⼀个执⾏单元，负责当前进程中程序的执⾏，⼀个进程中⾄少有⼀个线程。⼀个进程中是可以有多个线程的，这个应⽤程序也可以称之为多线程程序。

简⽽⾔之：⼀个程序运⾏后⾄少有⼀个进程，⼀个进程中可以包含多个线程。

并行：指两个或多个事件在同⼀时刻发⽣（同时发⽣）。

并发：指两个或多个事件在同⼀个时间段内发⽣。

 线程调度：

• 分时调度 ：所有线程轮流使⽤ CPU 的使⽤权，平均分配每个线程占⽤ CPU 的时间。
• 抢占式调度：优先让优先级⾼的线程使⽤ CPU，如果线程的优先级相同，那么会随机选择⼀个（线程随机性），Java使⽤的为抢占式调度。

2.创建自定义线程

1.方式一

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

2.方式二

采用 java.lang.Runnable 也是⾮常常⻅的⼀种，我们只需要重写 run 方法即可，步骤如下：

//步骤一: 继承Thread线程类
public class MyThread extends Thread{//步骤二: 重写run()public void run() {for (int i = 0; i < 10; i++) {System.out.println("自定义线程执行了" + i);}}
}//步骤一: 自定义类,实现Runnable接口
public class MyRunnable implements Runnable{//步骤二: 重写run()public void run() {for (int i = 0; i < 10; i++) {System.out.println("Runnable执行了" + i);}}
}/*创建线程的方式*/
public class ThreadDemo01 {//主方法自带一个主线程public static void main(String[] args) {/* //主线程的运行for (int i = 0; i < 10; i++) {System.out.println("main的线程" + i);}*///步骤三: 创建线程对象MyThread th = new MyThread();// 调用类中的普通方法//th.run();//步骤四: 开启线程th.start();//主线程的运行for (int i = 0; i < 10; i++) {System.out.println("main的线程" + i);}//步骤三: 创建任务类对象MyRunnable my = new MyRunnable();//步骤四:开启线程,就必须是线程类//步骤四.1:创建线程对象Thread t = new Thread(my);t.start();}
}

3.Thread和Runnable的区别

如果⼀个类继承 Thread，则不适合资源共享。但是如果实现了 Runable 接⼝的话，则很容易的实现资源共享。

总结： 实现 Runnable 接口⽐继承 Thread 类所具有的优势

1. 适合多个相同的程序代码的线程去共享同⼀个资源。

2. 可以避免 java 中的单继承的局限性。

3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独⽴。

4. 线程池只能放⼊实现 Runnable 或 Callable 类线程，不能直接放⼊继承 Thread 的类。

eg:在 java 中，每次程序运⾏⾄少启动2个线程。⼀个是 main 线程，⼀个是垃圾收集线程。因为每当使⽤ java 命令执⾏⼀个类的时候，实际上都会启动⼀个 JVM，每⼀个 JVM 其实在就是在操作系统中启动了⼀个进程。

4.线程常用API

构造方法：

public Thread() ：分配⼀个新的线程对象。

public Thread(String name) ：分配⼀个指定名字的新的线程对象。

public Thread(Runnable target) ：分配⼀个带有指定⽬标新的线程对象。

public Thread(Runnable target, String name) ：分配⼀个带有指定⽬标新的线程对象并指定名字。

常用方法：

public String getName() ：获取当前线程名称。

public void start() ：导致此线程开始执⾏；Java虚拟机调⽤此线程的run⽅法。

public void run() ：此线程要执⾏的任务在此处定义代码。

public static void sleep(long millis) ：使当前正在执⾏的线程以指定的毫秒数暂停 （暂时停⽌执⾏）。

public static Thread currentThread() ：返回对当前正在执⾏的线程对象的引⽤。

5.匿名内部类方式实现线程的创建

使⽤线程的内匿名内部类⽅式，可以⽅便的实现每个线程执⾏不同的线程任务操作。

使⽤匿名内部类的⽅式实现 Runnable 接⼝，重写 Runnable 接⼝中的 run ⽅法：

/*匿名内部类的方式实现线程类的创建*/
public class Demo {public static void main(String[] args) {//局部内部类 - Thread/*class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + ":" + i);}}}new MyThread().start();*///匿名内部类的方式优化 -//匿名内部类的作用: 继承抽象类/实现接口//匿名内部类结合 Thread创建的 线程类Thread t = new Thread() {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + ":" + i);}}};t.start();//开启线程//匿名内部类结合 Runnable接口使用Runnable r = new Runnable() {@Overridepublic void run() {Thread t = Thread.currentThread();for (int i = 0; i < 10; i++) {System.out.println(t.getName() + ":" + i);}}};//通过线程对象开启线程Thread tt = new Thread(r);tt.start();}
}

3.线程安全

1.线程安全

如果有多个线程在同时运⾏，⽽这些线程可能会同时运⾏这段代码。程序每次运⾏结果和单线程 运⾏的结果是⼀样的，⽽且其他的变量的值也和预期的是⼀样的，就是线程安全的。

当我们使⽤多个线程访问同⼀资源的时候，且多个线程中对资源有写的操作，就容易出现线程安

全问题，要解决该问题可使用同步机制（synchronized）来解决。

为了保证每个线程都能正常执⾏原⼦操作，Java引⼊了线程同步机制。

有三种⽅式完成同步操作：

1. 同步代码块。

2. 同步⽅法。

3. 锁机制。

2.同步代码块

同步代码块： synchronized 关键字可以⽤于⽅法中的某个区块中，表示只对这个区块的资源实⾏互斥访问。

synchronized(同步锁) {

需要同步操作的代码

}

同步锁：

对象的同步锁只是⼀个概念，可以想象为在对象上标记了⼀个锁。

1. 锁对象，可以是任意类型。

2. 多个线程对象，要使⽤同⼀把锁。

3.同步方法

同步⽅法：使⽤ synchronized 修饰的⽅法，就叫做同步⽅法，保证A线程执⾏该⽅法的时候，其他线程只能在⽅法外等着。

public synchronized void method() {

可能会产⽣线程安全问题的代码

}

4.锁机制

Lock锁

java.util.concurrent.locks.Lock 机制提供了⽐synchronized代码块和synchronized⽅法更⼴泛的锁定操作，同步代码块/同步⽅法具有的功能Lock都有，除此之外更强⼤，更体现⾯向对象。

Lock锁也称同步锁，加锁与释放锁⽅法化了，如下：

public void lock() ：加同步锁。

public void unlock() ：释放同步锁。

4.线程状态

在 API 中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

1.Timed Waiting（计时等待）

2.BLOCKED（锁阻塞）

3.Waiting（⽆限等待）

JAVA day24，25，26 异常（try、catch、finally、throw、throws），线程（Thread、Runnable、Callable）相关推荐

1. java 线程 Thread Runnable 实现样例

   1: /**  * Thread  实现多线程样例(可继承)  */ public class ThreadImplementsTest implements Runnable{     public ...

2. java catch后面_java 异常被catch后 将会继续执行的操作

   我就废话不多说了,大家还是直接看代码吧~ import java.util.UUID; public class Test { public static void main(String[] arg ...

3. 【原】Java学习笔记030 - 异常

   1 package cn.temptation; 2 3 public class Sample01 { 4 public static void main(String[] args) { 5 /* ...

4. Java 基础系列：异常

   Java 中的异常(Exception)又称为例外,是一个在程序执行期间发生的事件,它中断正在执行的程序的正常指令流.为了能够及时有效地处理程序中的运行错误,必须使用异常类. 1. 异常类型 Thro ...

5. Java笔试面试总结—try、catch、finally语句中有return 的各类情况

   点击上方蓝色"方志朋",选择"设为星标" 回复"666"获取独家整理的学习资料! 前言 之前在刷笔试题和面试的时候经常会遇到或者被问到 tr ...

6. java i o流异常问题_第四章 Java的I/O流和异常处理

   Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标.  Java.io包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等.  一个流可以理解为一个数据 ...

7. c++异常Try catch

   c++异常Try catch 分类: c++专区 功能函数测试集锦2014-04-09 17:43 1505人阅读 评论(0) 收藏 举报 一.简单的例子 首先通过一个简单的例子来熟悉C++ 的 tr ...

8. java中的常见异常1 -- 新手上路，减速慢行

   Throwable: 异常的顶级父类             ----Error:错误,程序无法处理             ----Exception:异常,可通过编码修复              ...

9. java在己有的类创子类怎么创_如何使用Java创建自己的异常子类

   Java不知道学了多少课时了,你知道如何使用Java创建自己的异常子类吗,Java的内置异常处理有哪些常见的错误呢,今天IT培训网小编就来给大家详细介绍下吧: 尽管Java的内置异常处理大多数常见错误 ...

最新文章

1. RPC 【Remote Procedure Call】 原理
2. ASP.NET常见面试题及答案（130题）
3. 如何区分netty是udp还是tcp_鲜奶粉还是大包粉，到底该如何区分？
4. Html文件转换为Aspx文件后发现样式丢失或失效
5. Catch That Cow（POJ-3278）
6. OpenStack Trove2
7. 第三方库之 - SDWebImage
8. springboot获取Spring容器中的bean(ApplicationContextAware接口的应用)避免过多的或不用if..else,switch
9. 关于opencv中图像的坐标原点的区分
10. Kibana操作Elasticsearch-Aggregations聚合数据分析
11. 超50万人推荐的神奇兼实用App，个个精品，打死也不能错过
12. css——font 样式和对照表 颜色格式和颜色渐变
13. 写技术文章的一点感悟
14. 什么是HTTP状态码 常见状态码集合
15. node-exporter安装
16. echarts X轴文字排列方式总结
17. 图神经网络论文阅读(九) Break the Ceiling: Stronger Multi-scale Deep Graph Convolutional Networks，NeurIPS2019
18. 如何用计算机破解ipad,ipad解id锁方法介绍【图文】】
19. 中科大凌青老师凸优化课程——目录
20. 打开心扉计算机谱子,谁知道《泰坦尼克号》的主题曲《我心永恒》的谱子？？？...

热门文章

1. 中国吉他效果市场趋势报告、技术动态创新及市场预测
2. 军事卫星行业调研报告 - 市场现状分析与发展前景预测
3. 2021年中国制药机械市场趋势报告、技术动态创新及2027年市场预测
4. mysql数据库的远程访问_mysql数据库远程访问设置方法
5. Google与GitHub 结盟，为保护软件供应链而战
6. 编码技术新突破：字节跳动AVG让视频缩小13%
7. 编程网站 Perl.com 被劫，售价 19 万美元
8. HarmonyOS 生态最重的拼图，手机开发者 Beta 版终于到来
9. Redis 突然变 慢 了，是运维还是开发的错？
10. 趣图 | 著名的悖论蒙提霍尔问题到底是什么？