Day20
2023-12-22 21:00:42
Day20
一,异常
1,Error(错误)
public class Test01 {
/**
* 知识点：Erro出现的情况
*
* 错误(Error)：JVM系统内部错误或资源耗尽等严重情况，属于JVM需要负担的责任，
* 这一类异常事件无法恢复或不可能捕获，将导致应用程序中断。
*/
public static void main(String[] args) {
//StackOverflowError - 栈内存溢出
//出现原因：调用方法，会在栈内存中开辟空间用于存储方法里的局部变量。死循环的调用方法，栈内存就满载并溢出
method();
}
public static void method(){
method();
}
}
import java.util.ArrayList;
public class Test02 {
/**
* 知识点：Erro出现的情况
*
* 错误(Error)：JVM系统内部错误或资源耗尽等严重情况，属于JVM需要负担的责任，
* 这一类异常事件无法恢复或不可能捕获，将导致应用程序中断。
*/
public static void main(String[] args) {
//OutOfMemoryError - 内存溢出的错误
//原因：new出来的对象存在集合中，对象不会被回收
ArrayList<byte[]> list = new ArrayList<>();
while(true){
byte[] bs = new byte[1024];
list.add(bs);
}
}
}
2,Exception(异常)
public class Test03 {
/**
* 知识点：异常出现的情况
*
* 异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
* 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
*
* RunntimeException：称之为运行时异常/非受检性异常，程序员在编写程序时应该避免的异常（逻辑异常）
*/
public static void main(String[] args) {
//ArithmeticException - 算数异常
System.out.println(10/0);
}
}
public class Test04 {
/**
* 知识点：异常出现的情况
*
*/
public static void main(String[] args) {
//ClassCastException - 类型转换异常
//注意：向下转型使用instanceof判断
Object obj = new String();
Integer integer = (Integer)obj;
System.out.println(integer);
}
}
public class Test05 {
/**
* 知识点：异常出现的情况
*
* 异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
* 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
*
* RunntimeException：称之为运行时异常/非受检性异常，程序员在编写程序时应该避免的异常（逻辑异常）
*/
public static void main(String[] args) {
//ArrayIndexOutOfBoundsException - 数组下标越界异常
int[] arr = new int[10];
System.out.println(arr[10000]);
}
}
public class Test06 {
/**
* 知识点：异常出现的情况
*
* 异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
* 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
*
* RunntimeException：称之为运行时异常/非受检性异常，程序员在编写程序时应该避免的异常（逻辑异常）
*/
public static void main(String[] args) {
//NullPointerException - 空指针异常
String str = null;
method(str);
}
public static void method(String str){
System.out.println(str.length());
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test07 {
/**
* 知识点：异常出现的情况
*
* 异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
* 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
*
* 一般性异常：称之为受检性异常，编译器(IDE)要求必须处置的异常。指的是程序在运行时由于外界因素造成的一般性异常。
*/
public static void main(String[] args) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:ss:mm");
//ParseException - 解析异常
Date date = sdf.parse("2023年12月22日 10:28:30");
System.out.println(date);
}
}
public class Test08 {
/**
* 知识点：异常出现的情况
*
* 异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
* 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
*
* 一般性异常：称之为受检性异常，编译器(IDE)要求必须处置的异常。指的是程序在运行时由于外界因素造成的一般性异常。
*/
public static void main(String[] args) throws ClassNotFoundException {
//ClassNotFoundException - 类未找到异常
//获取指定类的class对象
Class<?> clazz = Class.forName("java.lang.String111");
System.out.println(clazz);
}
}
3,异常处理的机制
import java.util.Scanner;
public class Test01 {
/**
* 知识点：异常处理的机制
* 1.Java程序在执行过程中如果出现异常，会自动生成一个异常类对象，
* 该异常对象将被自动提交给JVM，这个过程称为抛出(throw)异常。
* 2.当JVM接收到异常对象时，会寻找能处理这一异常的代码
* 2.1 找到了 - 把当前异常对象交给其处理，这一过程称为捕获(catch)异常和处理异常。
* 2.2 没找到 - 运行时系统将终止，相应的Java程序也将退出。
*
* 知识点：异常处理的能力
* 分类：
* 1.try...catch...
* 2.throws
* 3.throw
*
* 知识点：异常处理的能力 - try...catch...
* 语法格式：
* try{
*
* ...存放可能会出现异常的代码...
*
* }catch(异常类型 e){//捕获异常
* ...处理异常...
* }finally{
* ...不管是否发生异常，都会执行的代码...
* }
*
* 做实验：
*
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
try {
System.out.println("111");
System.out.println("222");
System.out.println(a/b);
System.out.println("333");
} catch (ArithmeticException e) {//捕获异常
//处理异常
System.out.println("处理算数异常");
} finally {
scan.close();
}
}
}
import java.util.Scanner;
public class Test02 {
/**
* 知识点：异常处理的机制
* 1.Java程序在执行过程中如果出现异常，会自动生成一个异常类对象，
* 该异常对象将被自动提交给JVM，这个过程称为抛出(throw)异常。
* 2.当JVM接收到异常对象时，会寻找能处理这一异常的代码
* 2.1 找到了 - 把当前异常对象交给其处理，这一过程称为捕获(catch)异常和处理异常。
* 2.2 没找到 - 运行时系统将终止，相应的Java程序也将退出。
*
* 知识点：异常处理的能力
* 分类：
* 1.try...catch...
* 2.throws
* 3.throw
*
* 知识点：异常处理的能力 - try...catch...
* 语法格式：
* try{
*
* ...存放可能会出现异常的代码...
*
* }catch(异常类型 e){//捕获异常
* ...处理异常...
* }finally{
* ...不管是否发生异常，都会执行的代码...
* }
*
* 做实验：
*
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
System.out.println("请输入类的全路径：");//全路径：包名+类名
String path = scan.next();
try {
System.out.println("111");
System.out.println("222");
System.out.println(a/b);
System.out.println("333");
//通过类的全路径获取class对象
Class<?> clazz = Class.forName(path);
System.out.println(clazz);
} catch (ArithmeticException e) {//捕获算数异常
//处理异常
System.out.println("处理算数异常");
} catch (ClassNotFoundException e) {//捕获类未找到异常
//处理异常
System.out.println("处理类未找到异常");
}finally {
scan.close();
}
}
}
try {
System.out.println("111");
System.out.println("222");
System.out.println(a/b);
System.out.println("333");
//通过类的全路径获取class对象
Class<?> clazz = Class.forName(path);
System.out.println(clazz);
} catch (ArithmeticException | ClassNotFoundException e) {//捕获算数异常或类未找到异常
//处理异常
System.out.println("处理异常");
}finally {
scan.close();
}
4,异常处理的能力 - throws
import java.util.Scanner;
public class Test04 {
/**
* 知识点：异常处理的能力 - throws
* 语法格式：
* public void method() throws 异常类型,异常类型,....{
* }
* 理解：抛出异常，抛给调用方
*
* 做实验：
*
*/
public static void main(String[] args){
try {
method01();
} catch (ClassNotFoundException e) {
System.out.println("处理异常");
}
}
public static void method01() throws ClassNotFoundException{
method02();
}
public static void method02() throws ClassNotFoundException{
method03();
}
public static void method03() throws ClassNotFoundException{
Scanner scan = new Scanner(System.in);
System.out.println("请输入类的全路径：");//全路径：包名+类名
String path = scan.next();
//通过类的全路径获取class对象
Class<?> clazz = Class.forName(path);
System.out.println(clazz);
scan.close();
}
}
import java.util.Scanner;
public class Test05 {
/**
* 知识点：异常处理的能力 - throw
* 语法格式：
* throw new 异常();
*
* 理解：手动抛出异常，抛给JVM
* 应用场景：自定义异常
*
* 做实验：
*
*/
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
try {
if(b == 0){
//手动抛出异常
throw new MyException();
}
} catch (MyException e) {//捕获异常
//处理异常
b = 1;
System.out.println(e);
}
System.out.println(a/b);
scan.close();
}
}
二,线程
1,线程类
public class Test01 {
/**
* 知识点：创建线程的方式1 -- 线程类
*/
//注意：main方法被主线程调用
public static void main(String[] args) {
//创建子线程的对象
MyThread t = new MyThread();
//启动线程(启动后，该线程被激活，才能去抢CPU资源)
t.start();
}
}
//线程类
public class MyThread extends Thread{
//当前线程对象抢到CPU资源后，才会调用run方法
//run()方法：编写的是当前线程的功能
@Override
public void run() {
System.out.println("用良心做教育");
}
}
2,任务类
public class Test01 {
/**
* 知识点：创建线程的方式2 -- 任务类
*/
//Thread main = new Thread();
public static void main(String[] args) {
//创建任务类的对象
Task task = new Task();
//创建子线程对象
Thread t = new Thread(task);
//启动线程
t.start();
}
}
//任务类
public class Task implements Runnable{
@Override
public void run() {
System.out.println("用良心做教育");
}
}
3,感受多线程之间争抢CPU资源的场景
public class Test01 {
/**
* 知识点：感受多线程之间争抢CPU资源的场景
*
* 需求：编写一个多线程的应用程序，
* 主线程打印1-100之间的数字，
* 子线程打印200-300之间的数字，
* 观察其输出的结果，体会多线程互相争抢资源的场景
*/
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
for (int i = 1; i <= 100; i++) {
System.out.println("主线程：" + i);
}
}
}
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 200; i <= 300; i++) {
System.out.println("子线程：" + i);
}
}
}
4,线程的优先级别
public class Test01 {
/**
* 知识点：线程的优先级别
*
* 线程的优先级别：1~10，数字越大优先级越高
* 注意：优先级越高，线程抢到CPU资源的概率越大
*
* 需求：在主线程中创建两个以上的子线程，并且设置不同优先级，
* 观察其优先级对线程执行结果的”影响”。
*/
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
//设置优先级别
a.setPriority(Thread.MAX_PRIORITY);
b.setPriority(Thread.NORM_PRIORITY);
c.setPriority(Thread.MIN_PRIORITY);
a.start();
b.start();
c.start();
}
}
public class A extends Thread{
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("A线程：" + i);
}
}
}
public class B extends Thread{
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("B线程：" + i);
}
}
}
public class C extends Thread{
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("C线程：" + i);
}
}
}
5,给线程取名字
public class Test01 {
/**
* 知识点：给线程取名字
*
* 需求：在主线程中创建两个以上的子线程，并且设置不同优先级，
* 观察其优先级对线程执行结果的”影响”。
*/
public static void main(String[] args) {
MyThread a = new MyThread("A");
MyThread b = new MyThread("B");
MyThread c = new MyThread("C");
//设置优先级别
a.setPriority(Thread.MAX_PRIORITY);
b.setPriority(Thread.NORM_PRIORITY);
c.setPriority(Thread.MIN_PRIORITY);
a.start();
b.start();
c.start();
}
}
public class MyThread extends Thread{
private String threadName;//线程名
public MyThread(String threadName) {
this.threadName = threadName;
}
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println(threadName + "线程：" + i);
}
}
}
public class MyThread extends Thread{
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
//System.out.println(super.getName() + "线程：" + i);
//Thread类的静态方法，表示获取当前线程对象
Thread t = Thread.currentThread();
System.out.println(t.getName() + "线程：" + i);
}
}
}
6,线程的休眠
import java.util.Random;
public class Test01 {
/**
* 知识点：线程的休眠
*
* 需求：编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名
*/
public static void main(String[] args) throws InterruptedException {
String[] names = {"张偲","徐灿","彭鹏","杨彩虹","刘婷婷","周隽乐","严荐翔"};
Random random = new Random();
int index = random.nextInt(names.length);
for (int i = 3; i > 0; i--) {
System.out.println(i);
//让当前线程休眠(单位：毫秒)
Thread.sleep(1000);
}
System.out.println(names[index]);
}
}
7,线程的礼让
public class Test01 {
/**
* 知识点：线程的礼让
*
* 需求：创建两个线程A,B，分别各打印100次，从1开始每次增加1，
* 其中B一个线程，每打印一次，就yield一次，观察实验结果
*/
public static void main(String[] args) {
A a = new A();
B b = new B();
a.start();
b.start();
}
}
public class B extends Thread{
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("B线程：" + i);
//礼让：让当前线程退出CPU资源，当前线程立刻进入到抢资源的状态（有可能又抢到了）
Thread.yield();
}
}
}
public class A extends Thread{
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("A线程：" + i);
}
}
}
8,线程的合并
public class Test01 {
/**
* 知识点：线程的合并
*
* 需求：主线程和子线程各打印200次，从1开始每次增加1，
* 当主线程打印到10之后，让子线程先打印完再打印主线程
*/
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread();
t.start();
for (int i = 1; i <=200; i++) {
System.out.println("主线程：" + i);
if(i == 10){
//让线程t加入到主线程中，t线程执行完毕后，主线程再继续执行
t.join();
}
}
}
}
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 1; i <= 200; i++) {
System.out.println("子线程：" + i);
}
}
}
9,线程的中断
public class Test01 {
/**
* 知识点：线程的中断
*
* 怎么中断：run方法结束！！！
*/
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread();
t.start();
Thread.sleep(3000);
//立即中断,已经弃用
t.stop();
}
}
//这样输出的尾数不确定,有时是"444","111"等都有可能
public class MyThread extends Thread{
@Override
public void run() {
while(true){
System.out.println("111");
System.out.println("222");
System.out.println("333");
System.out.println("444");
}
}
}
第二种方法:
public class Test01 {
/**
* 知识点：线程的中断
*
* 怎么中断：run方法结束！！！
*/
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread();
t.start();
Thread.sleep(3000);
//改变线程状态
t.interrupt();
}
}
public class MyThread extends Thread{
@Override
public void run() {
//Thread.currentThread().isInterrupted() - 判断当前线程是否被销毁
//false-没有被销毁 true-被销毁
while(!Thread.currentThread().isInterrupted()){
System.out.println("111");
System.out.println("222");
System.out.println("333");
System.out.println("444");
}
}
}
10,守护线程/后台线程
public class Test01 {
/**
* 知识点：守护线程/后台线程
* 理解：
* 我们创建的线程默认是前台线程
* 项目中所有的前台线程销毁后，守护线程也自动销毁
*
* 扩展：
* 1.垃圾回收器就是个后台线程
* 2.父类方法没有抛一般性异常，子类重写时就不会抛异常
*/
public static void main(String[] args) throws InterruptedException{
GuardThread guardThread = new GuardThread();
guardThread.setDaemon(true);//将当前线程设置成后台线程
guardThread.start();
for (int i = 1; i <=5; i++) {
System.out.println("主线程：" + i);
Thread.sleep(1000);
}
}
}
/**
* 重写：
* 应用场景：父类方法不满足子类对象时，在子类中重写即可
* 条件：
* 1.在子类中重写
* 2.返回值、方法名、参数列表
* 3.访问修饰符不能与父类更严格
* 4.父类没有抛异常，子类就不能抛异常
*/
class A{
public void method() throws InterruptedException{}
}
class B extends A{
@Override
public void method() throws InterruptedException{
}
}
public class GuardThread extends Thread{
@Override
public void run() {
while(true){
System.out.println("后台线程正在默默守护着前台线程");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
}
文章来源:https://blog.csdn.net/haikeydnk/article/details/135159865
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！