Java核心编程总结(四、异常与线程)

/** 2.空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！ */

String name = null ;

System.out.println(name); // 直接输出没有问题

// System.out.println(name.length()); // 此处出现了空指针异常。代码在此处直接执行死亡！

/** 3.类型转换异常：ClassCastException。 */

Object o = “齐天大圣”;

//Integer s = (Integer) o; // 此处出现了类型转换异常。代码在此处直接执行死亡！

/** 5.数学操作异常：ArithmeticException。 */

// int c = 10 / 0 ; // 此处出现了数学操作异常。代码在此处直接执行死亡！

/** 6.数字转换异常： NumberFormatException。 */

String num = “23aa”;

Integer it = Integer.valueOf(num); // 此处出现了数字转换异常。代码在此处直接执行死亡！

System.out.println(it+1);

System.out.println(“程序结束。。。。。。”);

}

}

1.3异常的产生处理默认机制

---

异常的产生默认的处理过程解析（了解即可）：

1. 默认会在出现异常的代码那里自动的创建一个异常对象：ArithmeticException

2. 异常会从方法中出现的点这里抛出给调用者，调用者最终抛出给JVM虚拟机

3. 虚拟机接收到异常对象后，现在控制台直接输出异常栈信息数据。

4. 直接从当前执行的异常点干掉当前程序。

5. 后续代码没有机会执行了，因为程序已经死亡

默认的异常处理机制并不好，一旦真的出现异常，程序立即死亡

1.3编译时异常的处理方式

---

方式一：抛出异常

格式：

方法 throws Exception{

}

• 在出现编译时异常的地方层层把异常抛出去给调用者，调用者最终抛出给JVM虚拟机，JVM虚拟机输出异常信息，直接干掉程序，这种方式与默认方式是一样的。虽然可以解决代码编译时的错误，但是一旦运行时真的出现异常，程序还是会立即死亡，这种方式并不好

方式二：捕获处理：在出现异常的地方自己处理，谁出现谁处理

格式：

try{

// 监视可能出现异常的代码

}catch{异常类型1 变量}{

// 处理异常

}catch{异常类型2 变量}{

// 处理异常

}

• 第二中方式，可以处理异常，并且出现异常后代码也不会死亡，但是从理论上来说，这种方式不是最好的，上层调用者不能直接知道底层的执行情况！

方式三：在出现异常的地方把异常一层一层的抛出给最外层调用者，最外层调用者集中捕获处理

try{

// 可能出现异常的代码

}catch(Exception e){

e.printStackTrae(); //直接打印异常栈信息

}

• 这种方案最外层调用者可以知道底层执行的情况，同时程序在出现异常后也不会立即死亡，这是理论上最好的方案。

• 虽然异常有三种处理方式，但是开发中只要能解决你的问题，每种方式都可能用到！

1.4finally关键字

---

• 用在捕获处理的异常格式中，放在最后面

try{

//可能出现异常的代码！

}catch{Exception e}{

e.printStackTrace();

}finally{

// 无论代码是出现异常还是正常执行,最终一定要执行这里的代码！！

}

• finally的作用：可以在代码执行完毕后进行资源的释放操作

• 资源都是实现了Closeable接口的，都自带close()关闭方法

• try ： 出现1次

• catch：出现0 - N 次(如果有finally那么 catch 可以没有)

• finally：出现0 - 1 次

1.5自定义异常（了解）

---

Java已经为开发中可能出现的异常都设计了一个类来代表，但是在实际开发中，异常可能有无数中情况，Java无法为这个世界上所有的异常都定义了一个类。假如一个企业如果想为自己认为的某种业务问题定义成一个异常，就需要自己来自定义异常类。

1.4多线程(并发编程)

---

1. 什么是进程？

答：程序是静止的，运行中的程序就是进程

2. 进程的三个特征

• 独立性：进程与进程之间是相互独立的，彼此有自己独立内存区域

• 动态性：进程是运行中的程序，要动态的占用内存，CPU和网络等资源

• 并发性：CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常快，给我们的感觉像是在同时执行，这就是并发性

• 并发：同一时刻同时有多个在执行

3. 什么是线程？

答：线程是属于进程的，一个进程可以包含多个线程，这就是多线程

1.5线程的创建方式

---

多线程是很有用的，我们在进程中创建线程的方式有三种：

1.5.1继承Thread类

继承Thread类的方式：

1. 定义一个线程类继承Thread类

2. 重写run()方法

3. 创建一个新的线程对象

Thread t = new MyThread();

4. 调用线程对象的start()方法启动线程

public class ThreadDemo {

// 启动后的ThreadDemo当成一个进程。

// main方法是由主线程执行的，理解成main方法就是一个主线程

public static void main(String[] args) {

// 3.创建一个线程对象

Thread t = new MyThread();

// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！

t.start();

for(int i = 0 ; i < 100 ; i++ ){

System.out.println(“main线程输出：”+i);

}

}

}

// 1.定义一个线程类继承Thread类。

class MyThread extends Thread{

// 2.重写run()方法

@Override

public void run() {

// 线程的执行方法。

for(int i = 0 ; i < 100 ; i++ ){

System.out.println(“子线程输出：”+i);

}

}

}

1.5.2实现Runnable接口

1. 创建一个线程任务类实现Runnable接口

2. 重写run()方法

3. 创建一个线程任务对象（注意：线程任务对象不是线程对象，只是执行线程的任务的）

Runnable target = new MyRunnable();

4. 把线程任务对象包装成线程对象,且可以指定线程名称

// Thread t = new Thread(target);

Thread t = new Thread(target,“1号线程”);

5. 调用线程对象的start()方法启动线程

public class ThreadDemo {

public static void main(String[] args) {

// 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)

Runnable target = new MyRunnable();

// 4.把线程任务对象包装成线程对象.且可以指定线程名称

// Thread t = new Thread(target);

Thread t = new Thread(target,“1号线程”);

// 5.调用线程对象的start()方法启动线程

t.start();

Thread t2 = new Thread(target);

// 调用线程对象的start()方法启动线程

t2.start();

for(int i = 0 ; i < 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+“==>”+i);

}

}

}

// 1.创建一个线程任务类实现Runnable接口。

class MyRunnable implements Runnable{

// 2.重写run()方法

@Override

public void run() {

for(int i = 0 ; i < 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+“==>”+i);

}

}

}

1.5.2.1Thread的构造器

• public Thread(){}

• public Thread(String name){}

• public Thread(Runnable target){}:分配一个新的Thread对象

• public Thread(Runnable target,String name)：分配一个新的Thread对象,且可以指定新的线程名称

1.5.2.1优缺点

缺点：代码复杂一点

优点：

• 线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口(避免乐单继承的局限性)

• 同一个线程任务对象可以被包装成多个线程对象

1.5.3实现Callable接口

1. 定义一个线程任务类实现Callable接口，申明线程返回的结果类型

2. 重写线程任务类的call方法，这个方法可以直接返回执行的结果

3. 创建一个Callable的线程任务对象

4. 把Callable的线程任务对象包装成一个未来任务对象

5. 把未来任务对象包装成线程对象

6. 调用线程的start()方法启动线程

public class ThreadDemo {

public static void main(String[] args) {

// 3.创建一个Callable的线程任务对象

Callable call = new MyCallable();

// 4.把Callable任务对象包装成一个未来任务对象

// – public FutureTask(Callable callable)

// 未来任务对象是啥，有啥用？

// – 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！

// – 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。

FutureTask task = new FutureTask<>(call);

// 5.把未来任务对象包装成线程对象

Thread t = new Thread(task);

// 6.启动线程对象

t.start();

for(int i = 1 ; i <= 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+" => " + i);

}

// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果

try {

String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）

System.out.println(rs);

} catch (Exception e) {

e.printStackTrace();

}

}

}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型

class MyCallable implements Callable{

// 2.重写线程任务类的call方法！

@Override

public String call() throws Exception {

// 需求：计算1-10的和返回

int sum = 0 ;

for(int i = 1 ; i <= 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+" => " + i);

sum+=i;

}

return Thread.currentThread().getName()+“执行的结果是：”+sum;

}

}

1.5.4优劣点

优点：全是优点

1.6线程的常用API

---

Thread 类的 API

1. public void setName(String name): 给当前线程取名字

2. public void getName(): 获取当前线程的名字

• 线程存在默认名称，子线程的默认名称是：Thread - 索引

• 主线程的默认名称是：main

3. public static Thread currentThread(): 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象

4. public static void sleep(long time):让当前线程休眠多少毫秒再继续执行

5. public Thread(String name):创建对象并取名字

---

public class ThreadDemo {

// 启动后的ThreadDemo当成一个进程。

// main方法是由主线程执行的，理解成main方法就是一个主线程

public static void main(String[] args) {

// 创建一个线程对象

Thread t1 = new MyThread();

t1.setName(“1号线程”);

t1.start();

//System.out.println(t1.getName()); // 获取线程名称

Thread t2 = new MyThread();

t2.setName(“2号线程”);

t2.start();

//System.out.println(t2.getName()); // 获取线程名称

// 主线程的名称如何获取呢？

// 这个代码在哪个线程中，就得到哪个线程对象。

Thread m = Thread.currentThread();

m.setName(“最强线程main”);

//System.out.println(m.getName()); // 获取线程名称

for(int i = 0 ; i < 10 ; i++ ){

System.out.println(m.getName()+“==>”+i);

}

}

}

// 1.定义一个线程类继承Thread类。

class MyThread extends Thread{

// 2.重写run()方法

@Override

public void run() {

// 线程的执行方法。

for(int i = 0 ; i < 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+“==>”+i);

}

}

}

---

线程休眠api

public class ThreadDemo02 {

public static void main(String[] args) {

for(int i = 0 ; i < 10 ; i++ ) {

System.out.println(i);

try {

// 项目经理让我加上这行代码

// 如果用户交钱了，我就去掉。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

public class ThreadDemo02 {

public static void main(String[] args) {

for(int i = 0 ; i < 10 ; i++ ) {

System.out.println(i);

try {

// 项目经理让我加上这行代码

// 如果用户交钱了，我就去掉。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-VJP2lNR5-1715755339216)]

[外链图片转存中…(img-uSeuiEWh-1715755339216)]

[外链图片转存中…(img-Yt8t1g0M-1715755339217)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！