异常与IO（二）

课程笔记Day17

• JDK8的时间类
• 异常类

第一章 JDK8的时间类

第01节 基础理论

常用类

1. LocalDateTime  操作日期和时间的。日期（年月日星期）时间（时分秒毫秒）
2. LocalDate      操作日期（年月日星期）
3. LocalTime 	  操作时间（时分秒毫秒）

备注：JDK8的时间类是 线程安全的

第02节 常用API

创建对象格式

1. 获取当前时间
	LocalDateTime ldt = LocalDateTime.now();
	
2. 设置指定时间
	LocalDateTime ldt = LocalDateTime.of(2021,8,3,9,6,10);

时间增、删、改、查

1. 查询时间，获取单独的时间点。
	int getYear()
	int getMonthValue()
	Month getMonth()
	int getDayOfMonth()
	DayOfWeek getDayOfWeek()
	int getHour()
	int getMinute()
	int getSecond()
	
2. 增删时间操作
	plusXxxx()  增删时间。正数向后，负数向前
	minusXxx()  增删时间。正数向前，负数向后
	
3. 修改时间操作
	withXxx()  修改时间点

格式化和解析

1. 格式化： 时间对象 --> 字符串
	String pattern = "yyyy年MM月dd日 HH:mm:ss";
	String text = ldt1.format(DateTimeFormatter.ofPattern(pattern));
	System.out.println("text = " + text);

2. 解析: 字符串 ---> 时间对象
	String str2 = "2021年08月03日10:18:14";
	String pattern2 = "yyyy年MM月dd日HH:mm:ss";
	LocalDateTime ldt2 = LocalDateTime.now();
	LocalDateTime ldt3 = ldt2.parse(str2,DateTimeFormatter.ofPattern(pattern2));
	System.out.println("ldt3 = " + ldt3);

相互转换

1. LocalDateTime ---> LocalDate
		//LocatDateTime --> LocalDate
        LocalDate ld = ldt1.toLocalDate();
        System.out.println("ld = " + ld);

2.  LocalDateTime ---> LocalTime
		//LocalDateTime --> LocalTime
        LocalTime lt = ldt1.toLocalTime();
        System.out.println("lt = " + lt);

3. LocalDate,LocalTime ---> LocalDateTime
		LocalDateTime ldt2 = LocalDateTime.of(ld,lt);
        System.out.println("ldt2 = " + ldt2);

第03节 练习题

//练习：显示日历
public class Test09 {

    public static void main(String[] args) {
        //1.键盘录入年份和月份:
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份和月份: 2021-08");
        String str = sc.nextLine();
        //2. 想办法，获取到 这个月的第一天星期几，获取到这个月有几天。 LocalDate
        String[] array = str.split("-");
        int year = Integer.parseInt(array[0]);
        int month = Integer.parseInt(array[1]);
        //设置当前的时间
        LocalDate ld = LocalDate.of(year, month, 1);
        //firstDay: 这个月1号星期几。
        int firstDay = ld.getDayOfWeek().getValue();
        //回到这个月的最后一天，看看是这个月 有几天。月份+1 天数-1
        int lastDay = ld.plusMonths(1).plusDays(-1).getDayOfMonth();
        //搞个数组，循环操作
        int[] arrayTwo = new int[firstDay+lastDay];
        //给arrayTwo赋值就可以了。
        int index = 1;
        for (int i = 0; i < arrayTwo.length; i++) {
            if (i>=firstDay){
                arrayTwo[i] = index;
                index++;
            }
        }
        //打印输出结果
        StringBuilder sb = new StringBuilder();
        sb.append("SUN").append("\t");
        sb.append("MON").append("\t");
        sb.append("TUE").append("\t");
        sb.append("WED").append("\t");
        sb.append("THU").append("\t");
        sb.append("FRI").append("\t");
        sb.append("SAT").append("\n");
        //循环遍历
        for (int i = 0; i < arrayTwo.length; i++) {
            if (arrayTwo[i] == 0 ){
                sb.append(" ").append("\t");
            }else{
                sb.append(arrayTwo[i]).append("\t");
            }
            //遇到7的倍数就要来一个换行
            if ((i+1)%7==0){
                sb.append("\n");
            }
        }
        //打印输出
        System.out.println(sb);
    }
}

第二章 异常类

第01节 基础理论

什么是异常呢？

程序出现了不正常的情况，我们就叫做异常。

例如：
	1. 数组索引越界异常 ArrayIndexOutOfBoundsException
	2. 空指针异常 NullPointerException 
	3. 类转换异常 ClassCastException
	4. 解析异常 ParseException
	5. IO异常   IOException
	6. SQL异常  SQLEeception

异常有什么作用呢？

出现问题之后，给出一些预警的信息。包含有 异常的原因、异常的类型、异常的位置。
当问题出现之后，可以快速的定位问题，进而解决问题。

异常的分类

1. 异常 Exception  出现了问题，这个问题，可以通过修复代码去解决。
2. 错误 Error  出现了问题，这个问题，不可以通过修复代码解决。

黄杰：周围发地震了，不能正常来上课。（错误：我们无法解决的问题）
黄杰：走在路上，被蚂蚁踩伤了，不能正常上课。（异常：我们可以解决）

异常体系结构

异常的分类

1. 编译时异常（受检异常） 
	A. 含义:
		代码刚刚写完，直接报错，强制性要求你去解决问题。
	B. 底层:
		父类是 Eception 而不是 RuntimeException
	C. 例如:
		黄杰早上过来上课的过程当中，还没出门，就发现自己不行了。需要120解决
		
2. 运行时异常（非受检异常）
	A. 含义: 
		代码写完，不会报错，运行的过程当中，出现错误。
	B. 底层:
		父类是 RuntimeException
	C. 例如:
		黄杰早上过来上课的过程当中，走在路上，被美女拉走了。因为扶老太太，被鹅了

第02节 异常处理方式

方案一：抛出异常（甩锅）

格式

public static 返回值类型 方法名称(参数列表)  throws  异常类名称1, 异常类名称2{
	....
}

虚拟机默认异常的效果图

案例代码

//异常类的快速入门（抛出异常）
public class Test01 {

    public static void main(String[] args) throws ParseException {

        String text = "2021/8/3";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d = sdf.parse(text);
        System.out.println(d);
    }
}

注意事项

如果我们一直往外抛出异常，最后由 main方法抛出异常，最终会抛给java虚拟机（JVM）帮我们处理。
JVM 处理异常的方式是什么呢?
中断处理。程序会停止，后续代码不再执行了。

方式二：捕获异常（接盘）

格式

try{
	....可能会出现异常的代码....
}catch(异常类名称 异常对象名称){
	....出现异常之后，处理的代码.....
}

案例代码

//异常类的快速入门（捕获异常）
@SuppressWarnings("all")
public class Test03 {

    public static void main(String[] args){

        try {
            method();
        } catch (ParseException e) {
            e.printStackTrace();
        }

        System.out.println("看看我执行了吗?");
    }

    public static void method() throws ParseException {
        String text = "2021/8/3";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d = sdf.parse(text);
        System.out.println(d);
    }
}

捕获异常的好处：

程序不会中断执行，会继续向下执行。

第03节 父亲的方法

三个方法

1. String getMessage()    //异常原因
2. String toString()      //异常原因 + 异常类型
3. void printStackTrace() //异常原因 + 异常类型 + 异常位置

第04节 注意事项

处理异常需要注意的问题

1. 如果存在多个异常要怎么处理?
	方案一： 一个try...多个catch...
	方案二： 多对 try...catch...

2. 如果异常没有被 catch 到会怎么办?
	采用JVM虚拟机默认的处理方式，中断处理，后续不再执行了。

3. 如果出现子父类异常要怎么办?
	方案：子在上，父在下。

第05节 异常应用

效果演示

案例代码

//异常应用
public class Test08 {

    public static void main(String[] args) {
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数:");
        int number = sc.nextInt();
        //定义状态码
        int code = 0;
        //调用下面的方法
        try {
            method(number);
            code = 200;
        } catch (ParseException e) {
            //e.printStackTrace();
            code = 500;
        } catch (IOException e) {
            //e.printStackTrace();
            code = 302;
        } catch (NullPointerException e){
            //e.printStackTrace();
            code = 404;
        }
        //展示状态码
        System.out.println("code = " + code);
    }


    public static void method(int num) throws NullPointerException,ParseException,IOException{
        //如果是 1-10 出现异常
        if (num>=1&&num<10){
            //制造异常。（造锅）
            throw new NullPointerException("网线被咬了");
        }
        //如果是 10-20 出现异常
        if (num>=10&&num<20){
            //制造异常。（造锅）
            throw new ParseException("路由器炸了",0);
        }
        //如果是 20-30 出现异常
        if (num>=20&&num<30){
            //制造异常。（造锅）
            throw new IOException("电脑没有网卡");
        }
        System.out.println("一切正常...可以上网...");
    }
}

小结： throw 和 throws 有啥区别呢？

throw 表示制造异常，写在方法当中。格式是 throw new 异常类名称(参数);

throws 表示抛出异常，写在方法声明上。格式是 throws 异常类名称1,异常类名称2,异常类名称3

第06节 自定义异常

理论

当现有的异常，无法满足我们异常的需求的情况下，则需要自定义异常。
例如：考试成绩可以去设置异常。成绩存在范围 0-100 之间。
如果说给你一个分数，这个分数是 负数。 -20 可以吗? 不行的

但是我们现有的异常当中，是不存在分数相关的异常的。这种情况下需要自己去定义异常。

用法

1. 写一个类，去继承 Exception 或者是 RuntimeException
	A. 如果继承的是 Exception 则表示，当前的异常是 编译时异常。代码写完，直接报错，强制要求解决。
	B. 如果继承的是 RuntimeException 则表示当前的异常是 运行时异常。代码写完，不会出错，不要求强制解决。选择性解决。
	
2. 实现构造方法
	A. 无参数构造方法
	B. 带有字符串参数构造方法（字符串：异常的原因）
	
3. 在需要异常的地方，去制造异常。
	throw  new  异常类名称(异常原因); 

案例代码

自定义编译时异常

//作为编译时异常使用。代码写完直接报错。
//编译时异常，继承 Exception
public class LowScoreException extends Exception{

    public LowScoreException() {
    }

    public LowScoreException(String message) {
        super(message);
    }
}

测试类

public class Test {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入考试成绩:");
        int score = sc.nextInt();

        try {
            method(score);
        } catch (LowScoreException e) {
            e.printStackTrace();
        }
    }

    //因为是编译时异常，会强制要求你解决，不解决，程序无法运行。
    public static void method(int score) throws LowScoreException {
        //判断是否会出现低分异常
        if (score < 0) {
            //制造异常
            throw new LowScoreException("你的老师真爱你");
        }
        System.out.println("程序正常:" + score);
    }
}