Day20

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) {
			}
		}
	}
}