文章目录
一、异常
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
-