D0823-日期与异常

JDK7的日期时间类。

Date类

Date类表示时间，时间可以精确到毫秒。创建一个Date对象，其实就表示时间的对象。

public class NewDate {
    public static void main(String[] args) {
        
        Date date1 = new Date();  //获取当前日期
        System.out.println(date1);
        
        Date date2 = new Date(100000);  //获取毫秒值对应的日期
        System.out.println(date2);
        
        long time1 = date1.getTime();  //获取日期对应的毫秒值
        System.out.println(time1);
        
        date1.setTime(0);  //将指定日期改成毫秒值对应的日期
        System.out.println(date1);
    }
}

SimpleDateFormat类

SimpleDateFormat类可以对日期进行格式化和解析的操作。

public class NewSimpleDateFormal {
    public static void main(String[] args) throws ParseException {
    
        规定对象格式化以及字符串解析的格式
        SimpleDateFormat sim = new SimpleDateFormat("yyyy年MM月dd日");
        String s=sim.format(new Date());  //format 将 Date 对象格式化为字符串
        System.out.println(s);

        //调用 parse 方法时会有编译异常，直接抛出即可，可将 将字符串解析为 Date
        Date par = sim.parse(s);  
        System.out.println(par);
    }
}

SimpleDateFormat在进行日期格式化或者解释时，需要识别一些特定符号
	yyyy:	年  			1999年
	MM:		年中的月	  8月
	dd:		月中的天	  28日
	HH:		天中的小时	 16时
	mm:		时中的分	  20分
	ss:		分中的秒      18秒
	SS:		毫秒
	
//在进行日期格式化和解析之前，必须使用以上的符号创建SimpleDateFormat对象，来指定日期或者时间的格式
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日  HH时mm分ss秒");

JDK8新增的日期类

LocalDateTime获取对象

LocalDateTime类 可以表示时间的(年、月、日、时、分、秒)

public static LocalDateTime now()
    获取当前的系统时间LocalDateTime对象
public static LocalDateTime of(int y,int m,int d,int h,int m,int s)
    获取指定时间的LocalDateTime对象

LocalDateTime的转换方法

三者的区别
	LocalDateTime： 包含年、月、日、时、分、秒
	LocalDate： 包含年、月、日
	LocalTime:  包含时、分、秒
	
可以通过LocalDateTime转换为LocalDate和LocalTime
	public LocalDate toLocalDate()
        把LocalDateTime转换为LocalDate
    public LocalTime toLocalTime()
        把LocalDateTime转换为LocalTime

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

        LocalDateTime now1 = LocalDateTime.now();  //获取当前年月日，时分秒，都可以通过 get.. 获取
        //使用指定年月日和时分秒初始化一个LocalDateTime对象
        LocalDateTime of1 = LocalDateTime.of(2020, 11, 02, 03, 03);
        int y1 = now1.getYear();  //获取 now1 对象的年份，月日，时分秒也可以通过类似的 get.. 获取
        LocalDateTime l1 = now1.plusYears(1);  //添加或者减去年份，月日，时分秒也可以通过类似的 plus.. 获取
        LocalDateTime l2 = now1.minusYears(1);  //减去或者添加年份，月日，时分秒也可以通过类似的 minus.. 获取
        LocalDateTime l3 = now1.withYear(1);  //直接更改年份，月日，时分秒也可以通过类似的 with.. 获取

        LocalDate d=now1.toLocalDate();  //将 LocalDateTime 对象转化为 LocalDate 对象
        LocalTime t=now1.toLocalTime();  //将 LocalDateTime 对象转化为 LocalTime 对象

        //LocalDateTime 对象要转化为字符串要先创建一个日期格式化器，即 ateTimeFormatter 对象
        //并在 DateTimeFormatter 对象中确定要将 LocalDateTime 对象转化成什么样
        DateTimeFormatter parttern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String s=now1.format(parttern);  //利用 LocalDateTime 里的 format 方法格式对象
        
        //解析与格式化相反，利用 LocalDateTime 里的 parse 方法格式对象
        LocalDateTime l=LocalDateTime.parse(s,parttern);
        //LocalDate 对象与 LocalTime 对象的解析与格式化与其类似

        LocalDate now2 = LocalDate.now();  //获取当前年月日，都可以通过 get.. 获取
        //使用指定年月日初始化一个LocalDateTime对象
        LocalDate of2 = LocalDate.of(2020, 11, 02);
        int y2 = now2.getYear();  //获取 now2 对象的年份，月日也可以通过类似的 get.. 获取

        LocalTime now3 = LocalTime.now();  //获取当前时分秒，都可以通过 get.. 获取
        //使用指定年月日和时分秒初始化一个LocalDateTime对象
        LocalTime of3 = LocalTime.of( 03, 03,29);
        int h1 = now3.getHour();  //获取 now2 对象的小时，分秒也可以通过类似的 get.. 获取
    }
}

时间间隔类

Period类：计算两个时间间隔的年、月、日

Duration类：计算两个时间间隔的时、分、秒

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

        //Period 类，计算两个时间间隔的年、月、日
        LocalDate now1 = LocalDate.now();
        LocalDate of1 = LocalDate.of(1993, 10, 18);
        Period p=Period.between(now1,of1);  //获取时间间隔对象
        int years = p.getYears();           //获取年份间隔
        int months = p.getMonths();         //获取月份间隔
        int days = p.getDays();             //获取天数间隔

        //Duration 类，计算两个时间间隔的时、分、秒
        LocalTime now2 = LocalTime.now();
        LocalTime of2 = LocalTime.of(01, 01,01);
        Duration d = Duration.between(now2, of2);  //获取时间间隔对象
        long hours = d.toHours();                 //获取小时间隔
        long hours1 = d.toHoursPart();            //获取小时间隔,相当于小时数相减
        long minutes = d.toMinutes();             //获取分钟间隔
        long minutes1 = d.toMinutesPart();        //获取分钟间隔,相当于分钟数相减
        long seconds = d.toSeconds();             //获取秒钟间隔
        long seconds1 = d.toSecondsPart();        //获取秒钟间隔,相当于秒钟数相减
    }
}

异常

异常其实就是程序在编译和运行时期的一些不正常的异常。 Java的工程师们，把一些常见的问题都封装了异常类 ，在API中给你列举出来了。当我们使用Java语言写代码的时候，可能会出现这些问题，当出现这些问题的时候，就可以去API中找，哪里出现了问题。

异常类的继承体系

Throwable 是所有异常和错误的根类
	Error: 错误，不能解决的问题。
	Exception: 异常，可以解决的问题。
		RuntimeException: 运行时异常，在运行时才出现问题
		非RuntimeException：编译时异常，编译时有问题。

异常的处理

• 虚拟机自己处理

直接停止程序运行，然后把异常信息打印在控制台

• try…catch手动处理

try{
    //检查代码中是否有异常
}catch(异常类 e){
    //如果try中有异常，就会被catch捕获到
}

好处：处理之后的代码还可以继续执行

• throws 声明异常

throws用在方法上，用来声明一个方法它可能会有异常

//如果一个方法后面有throws声明异常，那么调用方法的时候就需要处理异常。
public static void method(String str) throws ParseException {
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    Date date = sdf.parse(str);
    System.out.println(date);
}

Throwable的方法

public  String getMessage()  
    获取异常信息
public String toString()  
    返回异常类名+异常信息
public void printStackTrace() 
    打印详细的异常信息

throw 产生一个异常

如果你是写API的人，在写方法的时候，会考虑到方法的调用者传递非法的参数。你必须先对这些参数左一些合法性的校验，如果不通过，告诉调用者一个异常。

public static void main(String[] args) {
    sale(7);
}

public static void sale(int money){
    if(money==5||money==10){
        System.out.println("钱是真的，可以正常买东西");
    }else{
        throw new RuntimeException("钱是假的，我报警了，等着！！！");
    }
}

自定义异常

如果在写一个方法的时候，API中提供的异常类，还不足以说明程序的问题。你就可以自己定义一个异常类

自定义异常类的步骤：
	1.写一个类继承Exception或者RuntimeException
	2.自动生成两个构造方法
	
注意：自定义异常，名称一定要见名知意(最好是能够使用异常类的名称，来说明问题)