文章目录
一、异常
1、异常的产生
异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。
异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.
举例：张三让李四买手机，如果手机价值3000块，但是张三只给了1500块
张三{
//调用李四对象中买手机的方法
李四.买手机(1500) //当李四的买手机方法中抛出异常后，此时：张三也就具有异常
}
李四{
public 手机 买手机(double money){
//判断钱是否够
if(money < 3000){
//告诉张三，钱不够
throw new 异常类("钱不够！");//产生异常 throw作用：抛出异常（抛出给调用者）
//程序不再向下执行了
}
....
}
}
2 、异常体系
异常机制其实是帮助我们找到程序中的问题，
异常的根类是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():获取异常的类型和异常描述信息(不用)。
3、异常(Exception)的分类
根据在编译时期还是运行时期去检查异常
- 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
- 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)
4、异常的处理
1) 抛出异常throw
使用格式：
throw new 异常类名(参数);例如：
throw new NullPointerException("要访问的arr数组不存在"); throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
了解：
Objects工具类，由静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，将对象为null的值进行了抛出异常操作。
public static <T> T requireNonNull(T obj):查看指定引用对象不是null
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}
2) 声明异常throws
声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。
声明异常格式：
修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }
throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。
3) 捕获异常 try…catch
如果异常出现的话,会立刻终止程序,所以我们得处理异常:
-
该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
-
在方法中使用try-catch的语句块来处理异常。
**try：**该代码块中编写可能产生异常的代码。
**catch：**用来进行某种异常的捕获，实现对捕获到的异常进行处理。
**注意：**try和catch都不能单独使用,必须连用。
如何获取异常信息
Throwable类中定义了一些查看方法:
public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。 包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
在开发中呢也可以在catch将编译期异常转换成运行期异常处理。
5、finally 代码块
finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
**注意：**finally不能单独使用。当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。
6、自定义异常
- 起源：JDK提供的异常类，并不能满足开发中的所有的需求。例：当姓名存在时，引发异常
- 自定义异常类：
- 定义一个类，继承Exception 或 RuntimeException
- 继承Exception： 编译时异常
- 继承RuntimeException：运行时异常 （自定义异常类偏多）
- 自定义异常类中，添加构造方法（快捷键：alt + insert）
- 自定义异常类中，可以添加自己的方法
案例：模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册
首先定义一个注册异常类LoginException，
模拟登陆操作，使用数组模拟数据库中存储的数据，
并提供当前注册账号是否存在方法用于判断。
// 执行结果
cn.demo01Throw.LoginException: 亲bill已经被注册了！
at cn.demo01Throw.Demo.checkUsername(Demo.java:44)
at cn..demo01Throw.Demo.main(Demo.java:30)
cn.demo01Throw.LoginException: 亲bill已经被注册了！
// 业务逻辑异常
class LoginException extends Exception {
/**
* 空参构造
*/
public LoginException() {
}
/**
*
* @param message 表示异常提示
*/
public LoginException(String message) {
super(message);
}
}
public class Demo {
// 模拟数据库中已存在账号
private static String[] names = {"bill","hill","jill"};
public static void main(String[] args) {
//调用方法
try{
// 可能出现异常的代码
checkUsername("bill");
System.out.println("注册成功");//如果没有异常就是注册成功
}catch(LoginException e){
//处理异常
e.printStackTrace();
System.out.println(e);
}
}
//判断当前注册账号是否存在
//因为是编译期异常，又想调用者去处理 所以声明该异常
public static void checkUsername(String uname) throws LoginException{
for (String name : names) {
if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
throw new LoginException("亲"+name+"已经被注册了！");
}
}
}
}
小结
1、异常的分类： 编译时异常、运行时异常 （清楚两种异常的区别）
2、异常的执行流程机制：
某行代码中发生异常了，就会：停止程序向下执行，创建异常对象，
并把异常信息封装到异常对象中，
如果发生异常的代码位置，没有书写：异常处理代码，就会把异常对象抛出给调用者
如调用者也没有异常处理代码，会一直向上抛，直到抛出给JVM，
JVM直接停止，打印异常对象信息。
3、异常的处理：
1) throw //抛出
2) throws //声明 自己不处理交给别人(调用者)处理
3) try..catch //捕获 自己处理 （记住：异常最终还是需要使用try..catch来处理）
4、自定义异常类：程序员自己创建一些异常类，在开发中使用自己的异常类来代替JDK中的异常类。
-
异常
-
程序中的异常有什么影响？
- 当程序中的代码在运行(运行时异常)时，发生了突发状况(例：对象是空)，会造成程序的中断
- 健康的程序：当程序中发生异常时，可以忽略异常部分的代码，让程序继续向下执行
-
java程序中的异常：
- 编译时异常：在idea工具中书写代码时，编译器检查到代码中有异常，此时会提示，程序无法运行（必须修复后程序才可以运行）
- 修复： 添加异常处理代码（捕获 或 声明）
- 运行时异常：在程序运行过程中发生的异常
- 在编译时不会检查异常，只有程序运行了才会发生异常
- 编译时异常：在idea工具中书写代码时，编译器检查到代码中有异常，此时会提示，程序无法运行（必须修复后程序才可以运行）
-
异常的执行机制：
- 当某个方法中的代码发生异常了，此时就会在当行异常代码行，创建一个异常对象，对象中封装了异常的信息。
- JVM会检测当前有异常的代码位置处，是否有异常处理的代码（捕获处理）
- 没有异常处理代码：向上抛出（抛出给调用当前方法的位置上）
- 如果有：处理异常
- 异常抛出给方法的调用处时，调用处也会检测是否有异常处理代码（没有继续向上抛）
- 当异常抛出到main方法时，main方法中也具有异常，如果main方法没有异常处理代码，会抛出给JVM
- JVM处理异常： 打印异常对象的信息， 停止JVM
-
异常处理
-
声明处理：throws
-
应用场景：
- 当方法中有编译时异常时，编译器要求必须有异常处理代码，此时可以使用：throws，告诉编译器当前的异常自己不处理，给方法调用处处理（编译会检查方法调用处）
- 当方法中不想书写try…catch时，可以使用throws，把方法中存在的异常交给调用处来处理
-
使用方式：
-
修饰符 返回值类型 方法名(参数列表) throws 异常类1，异常类2, ... { }
-
-
-
捕获处理：try…catch
-
认知：在异常处理中真正处理异常的就是try…catch。throws只是把异常向上抛出
-
使用方式：
-
try{ //可能会发生异常的代码 }catch(异常类 对象){ //处理异常的代码 } //当try块中的代码发生异常时，会把异常对象交给catch来处理 //catch接收到异常对象时，会拿异常对象类型和catch中声明的异常类型，进行匹配，只有两个类型匹配相同，catch才会处理异常
-
-
执行流程：
- 没有异常：
- try块中的内容执行完之后，跳过catch，执行catch块后面的代码
- 有异常：
- 从try块中有异常代码的位置处，跳到catch块中执行，执行完整个catch块后，执行catch块后面的代码（try块中的代码没有全部执行完）
- 没有异常：
-
try的其它应用方式：
-
//多重catch try{ }catch(异常子类 对象1){ }catch(异常子类 对象2){ }catch(异常父类 对象3){ } //try..catch..finally try{ }catch(异常类 对象){ }catch(异常类 对象){ }finally{ } // 开发中最省事的写法： try{ }catch(Exception e){ }finally{ //finally块可选 }
-
-
-
-
自定义异常类
- 起源：JDK提供的异常类，并不能满足开发中的所有的需求。例：当姓名存在时，引发异常
- 自定义异常类：
- 定义一个类，继承Exception 或 RuntimeException
- 继承Exception： 编译时异常
- 继承RuntimeException：运行时异常 （自定义异常类偏多）
- 自定义异常类中，添加构造方法（快捷键：alt + insert）
- 自定义异常类中，可以添加自己的方法
- 定义一个类，继承Exception 或 RuntimeException
-
二、多线程
-
概念了解
- 进程、线程
- 并发、并行
- 多线程编程，简称：并发编程
问题：程序中的线程，java程序可以控制让某个线程执行吗？
答：不可以。 线程在创建之后，线程的执行是由CPU来调度（java是抢占式调度：多个线程争抢CPU执行权）
1、并行、并发，进程、线程
- 并行：指两个或多个事件在同一时刻发生（同时执行）。
- 并发：指两个或多个事件在同一个时间段内发生(交替执行)。
单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。
同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为
线程调度。
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
- 线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
进程与线程的区别
- 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。(资源分配的基本单位)
- 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。（CPU调度的基本单位）
- 注意：
1、宏观上一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。
2、Java 程序的进程里面至少包含两个线程，主进程也就是
main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。3、由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，
通常考虑创建多线程，而不是创建多进程。
- 线程调度:
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
2、Thread类
线程开启我们需要用到了java.lang.Thread类，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():返回对当前正在执行的线程对象的引用。
3、继承方式（ 创建线程方式）
java.lang.Thread线程类
- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start()方法来启动该线程
代码如下：
测试类：
public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程！");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 200; i++) {
System.out.println("main线程！"+i);
}
}
}
自定义线程类：
public class MyThread extends Thread {
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法，指定线程的名称
super(name);
}
public MyThread() {
//不指定线程的名字,线程有默认的名字Thread-0
}
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println(getName()+"：正在执行！"+i);
}
}
}
4、实现方式（创建线程方式）
实现java.lang.Runnable接口
- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
- 调用线程对象的start()方法来启动线程。
通过实现Runnable接口，使得该类有了多线程类的特征。
run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。
Thread类实际上也是实现了Runnable接口的类。
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
public class Demo {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "小强");
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("旺财 " + i);
}
}
}
Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。
而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
Thread类的构造方法：
Thread() //创建一个线程对象
Thread(Runnable target) //创建一个线程对象，参数：Runnable
Thread(Runnable target, String name) //创建一个线程对象。
// 参数1：Runnable，参数2：线程的名
//定义一个实现Runnable接口的子类
class Task implements Runnable{ //Runnable： 线程任务接口
//重写run方法
public void run(){
//线程要执行任务代码
}
}
main(){
//实例化Task
Task task = new Task();
//实例化Thread对象
Thread t1 = new Thread( task );
//启动线程，执行线程任务
t1.start();
}
5、匿名内部类（创建线程方式）
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法。
public class NoNameInnerClassThread {
public static void main(String[] args) {
Runnable r = new Runnable(){
public void run(){
for (int i = 0; i < 20; i++) {
System.out.println("小明:"+i);
}
}
};
new Thread(r).start();
for (int i = 0; i < 20; i++) {
System.out.println("小兰:"+i);
}
}
}
小结
多线程开发过程中，需要两块内容
- 线程 ==> Thread
- 任务（线程要执行的任务）==> Runnable
new Thread( new Runnable() )
线程的优先级：
-
在java语言中，线程的默认优先级别：5
-
在java语言中，线程的优先级别有：1~10
-
当在程序中需要设置线程优先级时，需要把优先级之间的间隔设置的较大
-
线程1：优先级8 线程2：优先级6 //以上两个线程的优先级，对CPU而言没有价值（优先级间隔太小，CPU无感知） //方案： 线程1：优先级8 线程2：优先级1
-
1171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
