异常类&线程

总结

异常

异常：就是Java中程序的一种错误

Java中异常机制：
表示程序的某个错误，当错误发生的时候，将程序结束，提示在那个位置出现什么错误

Java中异常的体系结构：每种错误就是一个类
Throwable类：java中错误、异常的父类
Error:错误，不能用Java代码处理错误

​ eg:
​ VirtualMachineError：虚拟机损坏的错误
​ StackOverflowError：堆栈溢出

​ Exception:异常，需要使用Java代码处理错误

​ 1. 编译时异常：编译之前必须处理的异常，强制处理的异常

​ 2. 运行时异常：不强制处理的异常

常见的异常

1. 运行时异常
   NullPointerException:空指针异常（对象在堆里面没有引用，就直接调用方法）
   对象在调用方法或属性的时候需要做非空判断
   StringIndexOutOfBoundsException:字符串下标越界的异常
   只要操作数组下标，必须要做合法性判断
   ArrayIndexOutOfBoundsException:数组下标越界
   操作数组先做非空和空数组
   ArithmeticException:算术异常
   NumberFormatException:数值的格式异常
   ClassCastException:类型转化异常，对象向下转型的时候
2. 编译时异常
   ParseException:转换日期格式的异常

区分编译时异常和运行时异常：
只要异常的父类时RuntimeException就是运行时异常，其他就是编译时异常

异常的处理方式：

1. 甩锅式 在方法上抛出异常或者在方法里直接抛出
   throws在方法的声明上面抛出异常
   只要程序出现抛出的异常，JVM会创建相应对象，再去调用相应的方法来提示错误
   在方法体内抛出异常，throw 异常对象

   public class ExceptionDemo3 {
       // 声明一个方法
       public static void m() throws ParseException {  // 抛出异常，异常抛给调用者，thorws
           // 省略方法体
           new SimpleDateFormat("yyyy-MM-dd").parse("2023/12/19");
       }
      
       public static void mm() throws IOException {
       }
       
       public static void main(String[] args) throws ParseException   { // 直接抛给JVM
           m();
           mm();
   
           String str = "";
           str.length();
       }
   }
   

2. 背锅式
   try{
   可能会出现异常的代码
   }catch(异常类名 参数名) {
   报这种异常错误信息的代码
   }…注意:catch的顺序时先子后父
   finally {
   处理异常的出口
   作用：关闭资源
   }

   public class ExceptionDemo4 {
       public static void main(String[] args) throws ParseException {
           try {
              new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2023-12-19 14:11:20");
               return; // 结束方法
               System.exit(0);
           } catch (ParseException e) {
               throw new RuntimeException(e);
           } finally {
               System.out.println("异常处理的出口");
           }
   
           new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2023-12-19 14:11:20");
   
       }
   }
   

   自定义异常

   ​ 写程序执行过程有不满条件情况都是异常，需要自己定义
   ​ class 自定义异常的名字（XxxException） extends Exception {
   ​ // 自定义编译时异常
   ​ 书写两个构造方法
   ​ 一个无参
   ​ 一个有1个字符串参数的构造方法
   ​ }
   ​ class 自定义异常的名字（XxxException） extends RuntimeException {
   ​ // 自定义运行时异常
   ​ }

   public class AccountStartWithCharException extends RuntimeException {
       public AccountStartWithCharException() {
       }
   
       public AccountStartWithCharException(String message) {
           super(message);
       }
   }
   

   /**
    * 自定义的异常：账号不在6-18位就会报这个异常
    */
   public class AccountSizeException extends Exception {
       public AccountSizeException() {
       }
   
       public AccountSizeException(String message) {
           super(message);
       }
   }
   

线程

1. 进程：一个应用软件就是一个进程，一大段程序（代码）
   每一个进行运行都有独立内存空间
   优酷：进程A
   腾讯：进程B
   快播：进程C
   进程的运行相互不干扰

2. 线程：一个进程里面独立某个功能就是一个线程，一小段代码
   其实软件运行的就是线程
   一个进程里面至少有一个线程，也可以有多个线程
   线程的运行也是独立，每个线程也有独立运行内存，这个内存时进程的内存

3. 线程时怎样执行？
   1）、启动线程
   2）、线程就是待运行状态
   3）、cpu会统计目前内存中有多少个待运行的线程
   会将运行时间平均分配给每个待运行的线程
   4）、那个线程获得这个时间片，那这个线程就开始执行，直到时间片用完，线程就暂停
   注意：在cpu里面同一时间只能运行一个线程

4. 为什么软件要设计位多线程？

   Java实现多线程的方式

   1）、继承Thread类，重写run()
   使用多线程

   public class Play extends Thread{ // Play是多线程
       // 重写run():线程获得时间片后执行的代码
   
       @Override
       public void run() {
           for (int i = 1; i <= 10; i++) {
               // 获取当前线程的名字
               String name = Thread.currentThread().getName();
               System.out.println(name + ":播放视频第" + i + "次");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
       }
   }
   

   /**
    * 多线程的测试类
    */
   public class PlayTest {
       public static void main(String[] args) {
           // 1、创建线程
           Play p1 = new Play(); // 开启一个线程 Thread-0
           Play p2 = new Play(); // 开启一个线程 Thread-1
           Play p3 = new Play(); // 开启一个线程 Thread-2
           // 2、开启线程，start()
   //        p1.start(); // 启动p1线程
   //        p2.start();
   //        p3.start();
           p1.setDaemon(true);
           p1.setName("蘋蘋");
           System.out.println(p1.isDaemon());
   //        p1.setPriority(10);
   //        System.out.println(p1.getPriority());
   
       }
   }
   

   2)、实现Runnable接口，重写run()

   /**
    * 实现Runnable接口，来实现多线程
    */
   public class Down implements Runnable{
       @Override
       public void run() {
           for (int i = 1; i <= 10 ; i++) {
               System.out.println("下载视频第" + i + "次");
           }
       }
   }
   

   /**
    * 实现接口创建多线程的测试类
    */
   public class DownTest {
       public static void main(String[] args) {
           // 1、创建Runnable对象
           Down d1 = new Down();
           // 2、创建线程对象
           Thread t1 = new Thread(d1); // 创建第一个线程
           Thread t2 = new Thread(d1); // 创建第一个线程
           Thread t3 = new Thread(d1); // 创建第一个线程
           // 3、启动线程
           t1.start();
           t2.start();
           t3.start();
       }
   }
   

   讲解Thread类中常用的方法

   1. 常用字段（常量）
      线程的优先级：1-10

       System.out.println("最高优先级："+ Thread.MAX_PRIORITY);
       System.out.println("默认优先级："+ Thread.NORM_PRIORITY);
       System.out.println("最低优先级："+ Thread.MIN_PRIORITY);
      

   2. 优先级越高获得时间片的概率越大
      线程默认优先级都是：5

   3. 构造方法
      Thread()：创建默认名字的线程。
      Thread(String name)：创建一个指定名字的线程
      Thread(Runnable target) ：根据传入Runnable对象创建线程，线程的名字是默认的
      Thread(Runnable target, String name) ：根据传入Runnable对象创建线程，线程的名字是指定的

   4. 常用方法

      1. getName():获取线程名字
      2. currentThread() ：获取当前线程
      3. getPriority() ：获取线程的优先级
      4. setPriority(int newPriority) ：设置线程优先级
      5. setName(String name) ：设置线程名字
      6. sleep(long millis)：设置线程休眠的时间
      7. 线程分为：前台线程，后台线程（守护线程）
         **GC:**垃圾回收机制(GC属于后台线程)
      8. isDaemon()：判断线程是否位守护线程
      9. setDaemon(boolean on)：设置线程位守护线程

   梳理线程

   ​ 线程的执行流程：

   1. 启动线程
   2. cpu分配时间片
   3. 拿到时间片的线程开始执行（run()的代码）
   4. 直到run()里面的代码执行完毕后，线程解结束
               交替执行
   

   java中实现多线程的方式：

   1. 继承Thread，重写run方法
   2. 实现Runnable接口
   

   创建线程，启动线程

   Thread常用的方法:

   1. 获取当前的线程
   2. 线程休眠
   3. 获取线程名字

   线程的状态：

   1. 新建 new Play();
   2. 就绪 new Play().start();
   3. 运行 执行run方法的时候
   4. 阻塞 sleep()
   5. 死亡（结束） run方法执行完毕