6时间&异常

InLoadwetrust

已于 2022-02-08 19:09:46 修改

阅读量232

点赞数

分类专栏： javase 文章标签： java

于 2021-08-26 15:21:45 首次发布

本文链接：https://blog.csdn.net/InLoadwetrust/article/details/119931925

版权

javase 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

今日目标

1、能够熟练使用Date类和SimpleDateFormat类中的常见方法

2、能够了解Jdk1.8新提供的日历类的使用

3、能够理解什么是异常

知识点

时间日期类
JDK8时间类
异常

1.时间日期类

1.1 时间概述(视频01) （5‘’）

北京时间需要在世界标准时间加上8小时
计算机中时间原点（UNIX操作系统,C语言的诞生日）

1970年1月1日 00:00:00

3.时间换算单位

1秒 = 1000毫秒

1.2 时间日期类-Date构造方法(视频02) （7‘’）

什么是Date类

Date 代表了一个特定的时间，精确到毫秒

2.Date类构造方法

方法名	说明
public Date()	创建 Date对象，默认存储当前时间，单位毫秒
public Date(long date)	创建 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

示例代码

package com.itheima.mydate;

import java.util.Date;

public class DateDemo1 {
    public static void main(String[] args) {
        //public Date()		创建一个Date对象，表示默认时间
        //public Date(long date)	创建一个Date对象，表示指定时间

        //那么这个时间就表示电脑中的当前时间。
        Date date1 = new Date();
        System.out.println(date1);

        //从计算机的时间原点开始，过了指定毫秒的那个时间。
        Date date2 = new Date(0L);
        System.out.println(date2);//Thu Jan 01 08:00:00 CST 1970
        //从时间原点开始，过了0毫秒。
        //因为我们是在中国，我们是在东八区需要+8小时。

        //1970年1月1日 上午的10点
        Date date3 = new Date(2 * 3600L * 1000);
        System.out.println(date3);
    }
}

1.3 时间日期类-Date成员方法（应用）(视频03) （4‘’）

常用方法

方法名说明
public long getTime() 获取从1970年1月1日 00:00:00到该日期对象代表时间的毫秒值
public void setTime(long time) 设置时间，给的是毫秒值

方法名	说明
public long getTime()	获取从1970年1月1日 00:00:00到该日期对象代表时间的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

示例代码

package com.itheima.mydate;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo2 {
    public static void main(String[] args) {
        //public long getTime()			获取时间对象的毫秒值
          //public void setTime(long time)		设置时间，传递毫秒值

        //method1();
        //method2();

  }

    private static void method2() {
        Date date1 = new Date();
        date1.setTime(0L);
        System.out.println(date1);
    }

    private static void method1() {
        //把当前时间封装成一个date对象
        Date date1 = new Date();
        
        //获取这个date对象的毫秒值 --- 获取当前时间的毫秒值
        long time = date1.getTime();
        System.out.println(time);
		
        long time2 = System.currentTimeMillis();
        System.out.println(time2);
    }
}

1.4 SimpleDateFormat类（应用）(视频04) （12‘’）

(共2点)

1.SimpleDateFormat类有什么作用？

SimpleDateFormat可以对Date对象,进行格式化和解析

2.如何使用？

1.常用的模式字母及应对关系如下:

HH：24小制,hh:12小时制

在这里插入图片描述

2.SimpleDateFormat类构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式

3.SimpleDateFormat类的常用方法

格式化(从Date到String)

public final String format(Date date)：将日期格式化成日期/时间字符串

解析(从日期/时间字符串String到Date)

public Date parse(String source)：从给定字符串的开始解析文本以生成日期

示例代码（公历日期标准格式为；2007年2月6日；或：2007-02-06）

//将Date转换成固定格式的字符串
public class DateDemo3 {
    public static void main(String[] args) {
        //当前时间的Date对象
        Date date = new Date();

        //创建了一个日期格式。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String result1 = sdf.format(date);
        System.out.println(result1);
    }
}

//将固定格式的字符串转换成Date
public class DateDemo4 {
    public static void main(String[] args) throws ParseException {
        String s = "2048-01-01";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		
        Date date = sdf.parse(s);
        System.out.println(date);
    }
}

自由练习-8分钟 - (parse&format方法)

1.5 时间日期类练习 (应用) （视频05）(9’’)

需求

秒杀开始时间是2020年11月11日 00:00:00,结束时间是2020年11月11日 00:10:00,用户小贾下单时间是2020年11月11日 00:03:47,用户小皮下单时间是2020年11月11日 00:10:11,判断用户有没有成功参与秒杀活动
实现步骤
1. 判断下单时间是否在开始到结束的范围内
2. 把字符串形式的时间变成毫秒值
代码实现

```java``

  package com.itheima.mydate;
  
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
import java.util.Date;
  
  public class DateDemo5 {
    public static void main(String[] args) throws ParseException {
          //开始时间：2020年11月11日 0:0:0
          //结束时间：2020年11月11日 0:10:0
  
          //小贾2020年11月11日 0:03:47
          //小皮2020年11月11日 0:10:11
  
          //1.判断两位同学的下单时间是否在范围之内就可以了。
          //2.要把每一个时间都换算成毫秒值。
  
          String start = "2020年11月11日 0:0:0";
          String end = "2020年11月11日 0:10:0";
  
          String jia = "2020年11月11日 0:03:47";
          String pi = "2020年11月11日 0:10:11";
  
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
          long startTime = sdf.parse(start).getTime();
          long endTime = sdf.parse(end).getTime();
  	
          long jiaTime = sdf.parse(jia).getTime();
          long piTime = sdf.parse(pi).getTime();
  
          if(jiaTime >= startTime && jiaTime <= endTime){
              System.out.println("小贾同学参加上了秒杀活动");
          }else{
              System.out.println("小贾同学没有参加上秒杀活动");
          }
  
          System.out.println("------------------------");
  
          if(piTime >= startTime && piTime <= endTime){
              System.out.println("小皮同学参加上了秒杀活动");
          }else{
              System.out.println("小皮同学没有参加上秒杀活动");
          }
      }
  }

小结

1北京时间需要在世界标准时间加上8小时

2 计算机中时间原点 1970年1月1日 00:00:00

3时间换算单位 1秒 = 1000毫秒

4.Date类

这个类是干什么的？时间类、 Date 代表了一个特定的时间，精确到毫秒

如何创建时间对象? new Date()

常用方法： getTime()

SimpleDateFormat类

这个类是干什么的？定义日期的格式，用于格式转换

如何创建时间对象? new SimpleDateFormat(“日期模式”)

常用方法：

format(Date date) 将Date转换成字符串

parse(String source) 将字符串转换成Date ```

2.JDK8时间日期类

2.1 JDK8时间类-初体验（视频6） (7’’)

需求

定义一个时间，String start = ""2020年11月11日 00:00:00;

将这个时间+1天，再按照原来的格式进行输出


```java
//jdk8以前的写法
private static void JDKMethod() throws ParseException {
    //定义时间格式
    String s = "2020年11月11日 00:00:00";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

    //转换成Date
    Date date = sdf.parse(s);

    //将时间+1天
    long time = date.getTime();
    time = time + (1000 * 60 * 60 * 24);
    Date newDate = new Date(time);

    //转换成String
    String result = sdf.format(newDate);
    System.out.println(result);
}

//jdk8写法
private static void JDK8Method() {
    //定义时间格式
    String s = "2020年11月11日 00:00:00";
    DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

    //转换成LocalDateTime
    LocalDateTime localDateTime = LocalDateTime.parse(s, pattern);

    //将时间+1天
    LocalDateTime newLocalDateTime = localDateTime.plusDays(1);

    //转换成String
    String result = newLocalDateTime.format(pattern);
    System.out.println(result);
}

2.2 JDK8时间类-获取时间对象 (应用) (视频7) (6’’)

1.jdk8中新增的时间类有哪些？

LocalDate 表示日期（年月日）
LocalTime 表示时间（时分秒）
LocalDateTime 表示时间+ 日期（年月日时分秒）（最常用）

2 如何创建LocalDateTime对象? (应用)

方法说明

方法名	说明
public static LocalDateTime now()	获取当前系统时间相当于new Date()
public static LocalDateTime of (年, 月 , 日, 时, 分, 秒)	使用指定年月日和时分秒初始化一个LocalDateTime对象 new Date(1000L);指定一下时间

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

public class JDK8DateDemo2 {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);


        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 11);
        System.out.println(localDateTime);
    }
}

2.3 LocalDateTime获取方法 (了解)（视频8）(8’’)

方法说明

方法名	说明
public int getYear()	获取年
public int getMonthValue()	获取月份（1-12）
public int getDayOfMonth()	获取月份中的第几天（1-31）
public int getDayOfYear()	获取一年中的第几天（1-366）
public DayOfWeek getDayOfWeek()	获取星期
public int getHour()	获取小时
public int getMinute()	获取分钟

| public int getSecond() | 获取秒 |

示例代码

package com.itheima.jdk8date;

import java.time.DayOfWeek;
import java.time.LocalDateTime;
import java.time.Month;

public class JDK8DateDemo3 {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 20);
        //public int getYear()           获取年
        int year = localDateTime.getYear();
        System.out.println("年为" +year);
        
        //public int getMonthValue()     获取月份（1-12）
        int month = localDateTime.getMonthValue();
        System.out.println("月份为" + month);

        Month month1 = localDateTime.getMonth();
        //System.out.println(month1);

        //public int getDayOfMonth()     获取月份中的第几天（1-31）
      	int day = localDateTime.getDayOfMonth();
        System.out.println("日期为" + day);

        //public int getDayOfYear()      获取一年中的第几天（1-366）
        int dayOfYear = localDateTime.getDayOfYear();
        System.out.println("这是一年中的第" + dayOfYear + "天");

        //public DayOfWeek getDayOfWeek()获取星期
        DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
        System.out.println("星期为" + dayOfWeek);

        //public int getMinute()        获取分钟
        int minute = localDateTime.getMinute();
        System.out.println("分钟为" + minute);
        
        //public int getHour()           获取小时
        int hour = localDateTime.getHour();
        System.out.println("小时为" + hour);
    }
}

2.4 LocalDateTime转换方法 (了解)(视频9) (3’’)

方法说明

方法名	说明
public LocalDate toLocalDate ()	转换成为一个LocalDate对象
public LocalTime toLocalTime ()	转换成为一个LocalTime对象

示例代码

public class JDK8DateDemo4 {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 12, 8, 10, 12);
        
        //public LocalDate toLocalDate ()    转换成为一个LocalDate对象
        LocalDate localDate = localDateTime.toLocalDate();
        System.out.println(localDate);

        //public LocalTime toLocalTime ()    转换成为一个LocalTime对象
        LocalTime localTime = localDateTime.toLocalTime();
        System.out.println(localTime);
    }
}

2.5 JDK8时间类-格式化和解析 (应用)(视频10) (7’’)

方法说明

方法名	说明
public String format (指定格式)	把一个LocalDateTime格式化成为一个字符串
public static LocalDateTime parse (准备解析的字符串, 解析格式)	把一个日期字符串解析成为一个LocalDateTime对象
public static DateTimeFormatter ofPattern(String pattern)	使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象

示例代码

package com.itheima.jdk8date;


import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class JDK8DateDemo5 {
    public static void main(String[] args) {
        //method1();
        //method2();
    }
	
  //public static LocalDateTime parse (准备解析的字符串, 解析格式) 把一个日期字符串解析成为一个LocalDateTime对象
  private static void method2() {
        
        String s = "2020年11月12日 13:14:15";
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        LocalDateTime parse = LocalDateTime.parse(s, pattern);
        System.out.println(parse);
    }
	
    //public String format (指定格式)   把一个LocalDateTime格式化成为一个字符串
    private static void method1() {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 12, 13, 14, 15);
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        
        String s = localDateTime.format(pattern);
        System.out.println(s);
    }
}

自由练习-8分钟

2.6 jdk8时间类-plus (了解)(视频11) （6‘’）

方法说明

方法名	说明
public LocalDateTime plusYears (long years)	添加或者减去年
public LocalDateTime plusMonths(long months)	添加或者减去月
public LocalDateTime plusDays(long days)	添加或者减去日
public LocalDateTime plusHours(long hours)	添加或者减去时
public LocalDateTime plusMinutes(long minutes)	添加或者减去分
public LocalDateTime plusSeconds(long seconds)	添加或者减去秒
public LocalDateTime plusWeeks(long weeks)	添加或者减去周

示例代码

/**
 * JDK8 时间类添加或者减去时间的方法
 */
public class JDK8DateDemo6 {
    public static void main(String[] args) {
        //public LocalDateTime plusYears (long years)   添加或者减去年

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
        //LocalDateTime newLocalDateTime = localDateTime.plusYears(1);
        //System.out.println(newLocalDateTime);

        LocalDateTime newLocalDateTime = localDateTime.plusYears(-1);
        System.out.println(newLocalDateTime);
    }
}

2.7 jdk8时间类-minus (了解)（视频12）（3‘’）

方法说明

方法名	说明
public LocalDateTime minusYears (long years)	减去或者添加年
public LocalDateTime minusMonths(long months)	减去或者添加月
public LocalDateTime minusDays(long days)	减去或者添加日
public LocalDateTime minusHours(long hours)	减去或者添加时
public LocalDateTime minusMinutes(long minutes)	减去或者添加分
public LocalDateTime minusSeconds(long seconds)	减去或者添加秒
public LocalDateTime minusWeeks(long weeks)	减去或者添加周

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

/**
 * JDK8 时间类减少或者添加时间的方法
 */
public class JDK8DateDemo7 {
    public static void main(String[] args) {
      //public LocalDateTime minusYears (long years)  减去或者添加年
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
        //LocalDateTime newLocalDateTime = localDateTime.minusYears(1);
      //System.out.println(newLocalDateTime);

        LocalDateTime newLocalDateTime = localDateTime.minusYears(-1);
        System.out.println(newLocalDateTime);

    }
}

2.8 LocalDateTime修改方法 (了解)(视频13) （4‘’）

方法说明

方法名	说明
public LocalDateTime withYear(int year)	直接修改年
public LocalDateTime withMonth(int month)	直接修改月
public LocalDateTime withDayOfMonth(int dayofmonth)	直接修改日期(一个月中的第几天)
public LocalDateTime withDayOfYear(int dayOfYear)	直接修改日期(一年中的第几天)
public LocalDateTime withHour(int hour)	直接修改小时
public LocalDateTime withMinute(int minute)	直接修改分钟
public LocalDateTime withSecond(int second)	直接修改秒

示例代码

/**
 * JDK8 时间类修改时间
 */
public class JDK8DateDemo8 {
    public static void main(String[] args) {
        //public LocalDateTime withYear(int year)   修改年
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
       // LocalDateTime newLocalDateTime = localDateTime.withYear(2048);
       // System.out.println(newLocalDateTime);

        LocalDateTime newLocalDateTime = localDateTime.withMonth(20);
        System.out.println(newLocalDateTime);

    }
}

2.9 Period (了解)(视频14) （9‘’）

方法说明

方法名	说明
public static Period between(开始时间,结束时间)	计算两个“时间"的间隔
public int getYears()	获得这段时间的年数
public int getMonths()	获得此期间的总月数
public int getDays()	获得此期间的天数
public long toTotalMonths()	获取此期间的总月数

示例代码

计算两个时间的间隔

package com.itheima.jdk8date;

import java.time.LocalDate;
import java.time.Period;  
public class JDK8DateDemo9 {
      public static void main(String[] args) {
        //public static Period between(开始时间,结束时间)  计算两个"时间"的间隔  
   LocalDate localDate1 = LocalDate.of(2020, 1, 1);
      LocalDate localDate2 = LocalDate.of(2048, 12, 12);
      Period period = Period.between(localDate1, localDate2);
      System.out.println(period);//P28Y11M11D
  
    //public int getYears()         获得这段时间的年数
      System.out.println(period.getYears());//28
      //public int getMonths()        获得此期间的月数
      System.out.println(period.getMonths());//11
      //public int getDays()          获得此期间的天数
      System.out.println(period.getDays());//11
  
      //public long toTotalMonths()   获取此期间的总月数
      System.out.println(period.toTotalMonths());//347  
  }
}

2.10 Duration (了解)(视频14) （9‘’）

方法说明

方法名	说明
public static Duration between(开始时间,结束时间)	计算两个“时间"的间隔
public long toSeconds()	获得此时间间隔的秒
public int toMillis()	获得此时间间隔的毫秒
public int toNanos()	获得此时间间隔的纳秒

示例代码

计算两个时间的间隔

package com.itheima.jdk8date;

import java.time.Duration;
import java.time.LocalDateTime;

/**
 *  计算两个时间的间隔
 */

public class JDK8DateDemo10 {
    public static void main(String[] args) {
        //public static Duration between(开始时间,结束时间)  计算两个“时间"的间隔

        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 1, 1, 13, 14, 15);
        LocalDateTime localDateTime2 = LocalDateTime.of(2020, 1, 2, 11, 12, 13);
        Duration duration = Duration.between(localDateTime1, localDateTime2);
        System.out.println(duration);//PT21H57M58S
        //public long toSeconds()	       获得此时间间隔的秒
        System.out.println(duration.toSeconds());//79078
        //public int toMillis()	           获得此时间间隔的毫秒
        System.out.println(duration.toMillis());//79078000
        //public int toNanos()             获得此时间间隔的纳秒
        System.out.println(duration.toNanos());//79078000000000
        
        
        //计算年龄
        String birtthday="1995-01-01 00:00:00";
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime birthdayTime = LocalDateTime.parse(birtthday, dateTimeFormatter);
        
        //计算活了多少天
        Duration between = Duration.between( birthdayTime,LocalDateTime.now());
        long days = between.toDays();
        System.out.println(days);
        //计算活了多少岁
        Period period = Period.between(
                birthdayTime.toLocalDate(),
                LocalDateTime.now().toLocalDate());
        System.out.println("活了"+period.getYears()+"岁，零"+period.getMonths()+"月，零"+period.getDays()+"天");
    }
}

2.11 jdk8时间类-小结(视频15) （4‘’）

创建时间对象（now， of ）

将日期类转换成字符串（format）
将字符串转换成日期类（parse）

获取时间对象中的年，月，日，时，分，秒 (get开头)
增加或减少时间的方法（plus开头，minus开头）
修改时间（with开头）
计算间隔(until方法)

这么多类、这么多方法，要疯

记不住啊

关键要会观察、会查询帮助文档

3.异常

3.1 异常的体系结构和分类（记忆）（视频16）(9’’)

1.什么是异常？

异常就是程序出现了不正常的情况(其实就是: 代码报错了)

**注意：**语法错误不算在异常体系中

2.异常的体系结构

在这里插入图片描述

//除RuntimeException之外的异常
public class ExceptionDemo1 {
  public static void main(String[] args)  {
//        int [] arr = {1,2,3,4,5};
//        System.out.println(arr[10]);//ArrayIndexOutOfBoundsException


//        String s = null;
//        System.out.println(s.equals("嘿嘿"));//NullPointerException

      SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
      sdf.parse("2048-1月1日");//ParseException
  }
}

3.编译时异常和运行时异常的区别（记忆）

编译时异常
- 都是Exception类及其子类
- 必须显式处理(手动处理)，否则程序就会发生错误，无法通过编译
运行时异常
- 都是RuntimeException类及其子类
- 无需显式处理(手动处理)，也可以和编译时异常一样处理
图示

3.2 JVM默认处理异常的方式（理解）（视频17）(4’’)

异常处理 ：并不是把异常解决掉，而是把发生异常的信息(什么地方出现了什么异常) 展示出来

在这里插入图片描述

1.如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理，处理方式有如下两个步骤：

把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
程序停止执行

在这里插入图片描述

package com.itheima.exce;


public class ExceptionDemo2 {
    public static void main(String[] args){
        //思考:控制台为什么会有这样的红色字体呢? 是谁打印的?
        int [] arr = {1,2,3,4,5};
        System.out.println(arr[10]);//当代码出现了异常,那么就在这里创建了一个异常对象.
                                    //new ArrayIndexOutOfBoundsException();
                                    //首先会看,程序中有没有自己处理异常的代码.
                                    //如果没有,交给本方法的调用者处理.
                                    //最终这个异常会交给虚拟机默认处理.
                                    //JVM默认处理异常做了哪几件事情:
                                    //1,将异常信息以红色字体展示在控制台上.
                                    //2,停止程序运行. --- 哪里出现了异常,那么程序就在哪里停止,下面的代码不执行了.
        System.out.println("嘿嘿嘿,我最帅");


    }
}

3.3throws方式处理异常（应用）(视频18) (5’’)

1.定义格式

public void 方法() throws 异常类名 {
    
}

示例代码

package com.itheima.exce;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ExceptionDemo6 {
    public static void main(String[] args) throws ParseException {
        method1(); //此时调用者也没有处理.还是会交给虚拟机处理.
        method2(); //还是继续交给调用者处理.而main方法的调用者是虚拟机还是会采取虚拟机默认处理异常的方法.
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    private static void method1() /*throws NullPointerException*/ {
        int [] arr = null;
        for (int i = 0; i < arr.length; i++) {//出现的空指针异常,还是由虚拟机创建出来的.
            System.out.println(arr[i]);
        }
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    private static void method2() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        sdf.parse("2048-10月10日");
    }
}

3.4 throws方式处理异常-注意事项（应用）(视频19) (2’’)

简单来说: 编译时的异常，必须声明由谁处理，最多让jvm来处理. 运行时异常可以不声明

package com.itheima.exce;


import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ExceptionDemo6 {
    public static void main(String[] args) throws ParseException {
        method1(); //此时调用者也没有处理.还是会交给虚拟机处理.
        method2(); //还是继续交给调用者处理.而main方法的调用者是虚拟机还是会采取虚拟机默认处理异常的方法.
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    //如果声明的异常是一个运行时异常,那么声明的代码可以省略
    private static void method1() /*throws NullPointerException*/ {
        int [] arr = null;
        for (int i = 0; i < arr.length; i++) {//出现的空指针异常,还是由虚拟机创建出来的.
            System.out.println(arr[i]);
        }
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    //如果声明的异常是一个编译时异常,那么声明的代码必须要手动写出.
    private static void method2() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        sdf.parse("2048-10月10日");
    }
}

3.5 throw抛出异常 (应用) (视频20) (10’’)

1.格式

throw new 异常();

2.注意

这个格式是在方法内的，表示当前代码手动抛出一个异常，下面的代码无法再执行了

3.抛出处理异常的意义

1.在方法中,当传递的参数有误时,没有继续运行的必要了，采取抛出处理,表示该方法结束

告诉调用者方法中出现了问题

4.throws和throw的区别

throws （抛出现有异常）	throw （主动制造异常）
用在方法声明后面，跟的是异常类名	用在方法体内，跟的是异常对象名
可以声明多个异常	只能有一个

示例代码

package com.itheima.exce;
public class ExceptionDemo7 {
    public static void main(String[] args) {
        System.out.println("家里有一个貌美如花的老婆");
      	System.out.println("还有一个当官的兄弟");
        System.out.println("自己还有一个买卖");
        System.out.println("这样的生活你要不要?");
        throw new RuntimeException(); //当代码执行到这里,就创建一个异常对象
                                    //该异常创建之后,暂时没有手动处理.抛给了调用者处理
                                    //下面的代码不会再执行了.
        //System.out.println("武大郎的标准生活");
    }


}

 package com.itheima.exce;
  public class ExceptionDemo8 {
      public static void main(String[] args) {
          //int [] arr = {1,2,3,4,5};
          int [] arr = null;
          printArr(arr);//就会 接收到一个异常.
                          //我们还需要自己处理一下异常.
      }
 private static void printArr(int[] arr) {
      if(arr == null){
          //调用者知道成功打印了吗?
          //System.out.println("参数不能为null");
          throw new NullPointerException(); //当参数为null的时候
                                              //手动创建了一个异常对象,抛给了调用者.
      }else{
          for (int i = 0; i < arr.length; i++) {
              System.out.println(arr[i]);
          }
      }
  }
}

3.6 try-catch自己处理异常（应用）(视频21) (5’’)

定义格式

try {
	可能出现异常的代码;
} catch(异常类名 变量名) {
	异常的处理代码;
}

idea快捷键 ctrl + alt + t 自动生成try{}catch(){}代码

执行流程
- 程序从 try 里面的代码开始执行
- 出现异常，就会跳转到对应的 catch 里面去执行
- 执行完毕之后，程序还可以继续往下执行

示例代码

package com.itheima.exce;


public class ExceptionDemo9 {
    public static void main(String[] args) {

        //好处:为了能让代码继续往下运行.
        int [] arr = null;
        try{
            //有肯能发现异常的代码
            printArr(arr);
        }catch (NullPointerException e){
            //如果出现了这样的异常,那么我们进行的操作
            System.out.println("参数不能为null");
        }


        System.out.println("嘿嘿嘿,我最帅!!!");

    }

    private static void printArr(int[] arr) {
        if(arr == null){
            throw new NullPointerException();
        }else{
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
        }
    }
}

3.7 try-catch常见问题（视频22）（15‘’）

如果 try 中没有遇到问题，怎么执行？

会把try中所有的代码全部执行完毕,不会执行catch里面的代码
如果 try 中遇到了问题，那么 try 下面的代码还会执行吗？

那么直接跳转到对应的catch语句中,try下面的代码就不会再执行了
当catch里面的语句全部执行完毕,表示整个体系全部执行完全,继续执行下面的代码

如果出现的问题没有被捕获，那么程序如何运行？

那么try…catch就相当于没有写.那么也就是自己没有处理.
默认交给虚拟机处理.

同时出现多个异常怎么处理？

出现多个异常,那么就写多个catch就可以了.
注意点:如果多个异常之间存在子父类关系.那么父类一定要写在下面

package com.itheima.exce;

import java.util.Scanner;

public class ExceptionDemo10 {
    public static void main(String[] args) {
        //1.如果 try 中没有遇到问题，怎么执行？ --- 会把try中所有的代码全部执行完毕,不会执行catch里面的代码
        //2.如果 try 中遇到了问题，那么 try 下面的代码还会执行吗？
                            //那么直接跳转到对应的catch语句中,try下面的代码就不会再执行了
                            //当catch里面的语句全部执行完毕,表示整个体系全部执行完全,继续执行下面的代码
        //3.如果出现的问题没有被捕获，那么程序如何运行？
                             //那么try...catch就相当于没有写.那么也就是自己没有处理.
                             //默认交给虚拟机处理.
        //4.同时有可能出现多个异常怎么处理？
                            //出现多个异常,那么就写多个catch就可以了.
                            //注意点:如果多个异常之间存在子父类关系.那么父类一定要写在下面
        // method1();
    try {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        String line = sc.nextLine();
        int age = Integer.parseInt(line);//格式化异常
        
        System.out.println(age);
        System.out.println(2 / 0); //数学异常
    } catch (Exception e) {
        //以后我们针对于每种不同的异常,有可能会有不同的处理结果.
    }
    System.out.println("测试456");
}

private static void method1() {
    try {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        String line = sc.nextLine();
        int age = Integer.parseInt(line);//格式化异常
        System.out.println(age);
        
        System.out.println(2 / 0); //数学异常
    } catch (NumberFormatException e) {
        System.out.println("格式化异常出现了");
    }catch (ArithmeticException e) {
        System.out.println("数学运算异常出现了");
    }
    System.out.println("测试456");
}

3.8 Throwable中的常见方法（应用）（视频23）(4’’)

常用方法

方法名	说明
public String getMessage()	返回此 throwable 的详细消息字符串
public String toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常的错误信息输出在控制台

示例代码

package com.itheima.exce;


public class ExceptionDemo11 {
    //public String getMessage()    返回此 throwable 的详细消息字符串
    //public String toString()      返回此可抛出的简短描述
  //public void printStackTrace() 把异常的错误信息输出在控制台(字体为红色的)
    public static void main(String[] args) {

        try {
            int [] arr = {1,2,3,4,5};
            System.out.println(arr[10]);//虚拟机帮我们创建了一个异常对象 new ArrayIndexOutOfBoundsException();
        } catch (ArrayIndexOutOfBoundsException e) {
            /*String message = e.getMessage();
          System.out.println(message);*/
           /* String s = e.toString();
            System.out.println(s);*/
           e.printStackTrace();
      }

        System.out.println("嘿嘿嘿");

  }
}

3.9 异常的练习 (应用) （视频24）(11’’)

在这里插入图片描述

需求

键盘录入学生的姓名和年龄,其中年龄为18 - 25岁,超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止
实现步骤
1. 创建学生对象
2. 键盘录入姓名和年龄，并赋值给学生对象
3. 如果是非法数据就再次录入

代码实现

学生类

package com.itheima.exce;

public class Student {
  private String name;
    private int age;

  public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
      this.age = age;
    }

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public int getAge() {
      return age;
    }

    public void setAge(int age) {
        if(age >= 18 && age <= 25){
            this.age = age;
        }else{
            //自定义异常的目的:为了让异常信息更加的见名知意
            throw new RuntimeException("年龄超出了范围");
          
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
  }
}

 package com.itheima.exce;

  
import java.util.Scanner;
  
  public class ExceptionDemo12 {
      public static void main(String[] args) {
          // 键盘录入学生的姓名和年龄,其中年龄为 18 - 25岁,
          // 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。
  
          Student s = new Student();
  
          Scanner sc = new Scanner(System.in);
          System.out.println("请输入姓名");
          String name = sc.nextLine();
          s.setName(name);
         while(true){
             System.out.println("请输入年龄");
             String ageStr = sc.nextLine();
             
             
             try {
                 int age = Integer.parseInt(ageStr);
                 s.setAge(age);
                 break;
             } catch (NumberFormatException e) {
                 System.out.println("请输入一个整数");
                 continue;
             } catch (AgeOutOfBoundsException e) {
                 System.out.println(e.toString());
                 System.out.println("请输入一个符合范围的年龄");
                 continue;
             }
             /*if(age >= 18 && age <=25){
               s.setAge(age);
                 break;
             }else{
                 System.out.println("请输入符合要求的年龄");
                 continue;
             }*/
         }
          System.out.println(s);
  
      }
  }

3.10 自定义异常（应用）(视频25)(6’’)

1.什么是自定义异常？

当Java中提供的异常不能满足我们的需求时,我们可以自定义异常

2.为什么要自定义异常？

有一个原则：异常类要与业务相关（见名知意）

3.实现步骤

定义异常类
写继承关系
提供空参/带参构造

4.代码实现

异常类

public class AgeOutOfBoundsException extends RuntimeException {
    public AgeOutOfBoundsException() {
    }

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

学生类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 18 && age <= 25){
            this.age = age;
        }else{
            //如果Java中提供的异常不能满足我们的需求,我们可以使用自定义的异常
            throw new AgeOutOfBoundsException("年龄超出了范围");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class ExceptionDemo12 {
    public static void main(String[] args) {
        // 键盘录入学生的姓名和年龄,其中年龄为 18 - 25岁,
        // 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。

        Student s = new Student();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名");
        String name = sc.nextLine();
        s.setName(name);
       while(true){
           System.out.println("请输入年龄");
           String ageStr = sc.nextLine();
           try {
               int age = Integer.parseInt(ageStr);
               s.setAge(age);
               break;
           } catch (NumberFormatException e) {
               System.out.println("请输入一个整数");
               continue;
           } catch (AgeOutOfBoundsException e) {
               System.out.println(e.toString());
               System.out.println("请输入一个符合范围的年龄");
               continue;
           }
           /*if(age >= 18 && age <=25){
               s.setAge(age);
               break;
           }else{
               System.out.println("请输入符合要求的年龄");
               continue;
           }*/
       }
        System.out.println(s);

    }
}

异常小结

1.什么是异常

异常就是程序出现了不正常的情况

2.异常的分类

Error & 编译期异常 & 运行时异常

3.如何捕获异常

通过try…catch来捕获

4.故意制造一个异常

throw new 异常类()

5.声明异常(甩锅)

throws

6.为什么要自定义异常

在实际开发过程中有很多异常是jdk没有帮我们定义好的，比如age负数或超出范围异常，

因此我们需要根据实际的业务自定义异常，从而达到见名知意

7.如何自定义异常

继承RuntimeException，调用父类中的空参/带参构造方法

InLoadwetrust

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
6时间&异常

今日目标1、能够熟练使用Date类和SimpleDateFormat类中的常见方法2、能够了解Jdk1.8新提供的日历类的使用3、能够理解什么是异常知识点时间日期类JDK8时间类异常1.时间日期类1.1 时间概述(视频01) （5‘’）北京时间需要在世界标准时间加上8小时计算机中时间原点（UNIX操作系统,C语言的诞生日） 1970年1月1日 00:00:003.时间换算单位 1秒 = 1000毫秒1.2 时间日期类-Date构造方法(视频02)
复制链接

扫一扫