常用API(时间日期)&异常

包装类

基本类型包装类的作用
每一种基本类型,都有对应的引用类型(包装类)
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一:用于基本数据类型与字符串之间的转换
基本类型对应的包装类

基本类型             包装类
byte                 Byte
short                Short
int                  Integer
long                 Long
float                Float
double               Double
char                 Character
boolean              Boolean

获取包装类对象
使用包装类valueOf方法,获取包装类对象

//获取Integer对象
Integer i1=Integer.valueOf(100);
Integer i1=Integer.valueOf("100");//把"100"转化为100

//获取Double对象
Double d1=Double.valueOf(3.14);
Double d2=Double.valueOf("3.14");  //把"3.14"转化为3.14

注意:如果把字符串转化为一个整数或者小数,不能包含不可转化字符,否则就会出现NumFormatException

基本类型和String类型的相互转化

 - 基本类型 转为String类型
//任何类型通过String类的静态方法valueOf,就可以转化为String
String s1=String.valueOf(3.14);
String s1=String.valueOf(true);

 - String类型 转为 基本类型
 //口诀:想要什么样的基本类型,就找它的包装类的静态方法parseXxx
 int a=Integer.parseInt("123");
 int b=Double.parseDouble("3.14");
 boolean c=Boolean.parseBoolean("true");

自动装箱和拆箱
在java中只有类型统一才能运算,如果基本类型和包装类进行运算他们会自动进行转化,称之为自动装箱和自动装箱

 -自动装箱:把基本类型转化为包装类
 -自动拆箱:把包装类转化为基本类型

//自动装箱
Integer i=10;//自动的
//Integer i=Integer.valueOf(10);手动的

//自动拆箱
Integer a=10;
int b=a;//自动的
//int c=a.intvalue();手动的

Date类

Date表示一个特定的时间,精确到毫秒

//创建Date对象,表示当前系统时间
Date d=new Date();
System.out.println(d);

//创建Date对象，表示指定的时间的毫秒值
//正数： 1970年以后
//负数： 1970年以前
Date d2=new Date(-1000L*60*60*24*365);
System.out.println(d2);

Date类有一个getTime和setTime方法来获取和设置毫秒值

Date d=new Date();
//获取Date对象的毫秒值
long time = d.getTime();
System.out.println(time);

//设置Date对象的毫秒值
d.setTime(1000);
//获取Date对象的毫秒值
long time1 = d.getTime();
System.out.println(time1); 

注意:获取Date的毫秒值是于相对19701月1日8点

SimpleDateFormat

SimpleDateFormat是用来对日期进行格式化和解析的

 - 格式化: Date对象-->String
 - 解析: String -->Date对象
 
 注意:在进行格式化和解析之前,必须要保证日期格式统一,按照下面的模式书写
 yyyy     年
 MM       月
 dd       日
 HH       时
 mm       分
 ss       秒
 SS       毫秒
 比如表示"2020年6月15日 22:03"的时间 模式"yyyy年MM月dd日 HH:mm"

SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss")

//当前时间的date对象
Date date=new Date();
//格式化:Date-->String
String strTime=sdf.format(date);
System.out.println(strTime);

//解析: String-->Date
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-mm-dd");
String birthday="1996-07-14";
Date date2=sdf1.parse(birthday);
System.out.println(date2);

封装工具类

public class DateUtils {
    //格式化：Date-->String
    public static String dateToString(Date date,String format){
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        String str = sdf.format(date);
        return str;
    }

//解析: String-->Date
    public static Date stringToDate(String dateStr,String format) throws ParseException {
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        Date date = sdf.parse(dateStr);
        return date;
    }
}

Calendar类

Calendar表示日历类,它提供了一些方法对日历的字段进行操作,日历字段用一些大写的单词表示

Calenda.YEAR                    年
Clalendar.MONTH                 月
Clalendar.DAY_OF_MONTH     月中的天
Clalendar.DAY_OF_YEAR      年中的天      
Clalendar.MONTH_WEEK      星期中的第几天

Calendar是一个抽象类,他不能直接创建对象,可以通过getInstance()方法获取一个对象,再进行设置、获取、计算等操作

//获取Clendar的子类对象
Calendar c=Carlendar.getInstance();

//使用Calendar对象对日历字段,进行操作

//修改时间： 2008年8月8日
c.set(Calendar.YEAR,2008);
c.set(Calendar.MONTH,7); //7 表示8月
c.set(Calendar.DAY_OF_MONTH,8);

//计算时间：把月中的天往后加20天
c.add(Calendar.DAY_OF_MONTH,20);

//获取时间
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year);
//获取时间
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year);

//获取星期几
int index = c.get(Calendar.DAY_OF_WEEK);
String[] weeks={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
System.out.println(weeks[index]);

键盘录入哪一年，计算这一年是平年还是闰年
提示：二月的最后一天是28日，就是平年; 二月的最后一天是29日，就是闰年

Scanner sc=new Scanner(System.in);
System.out.println("请输入一个年份：");
int year = sc.nextInt();
//把时间设置到录入的年份 3月1日
Calendar c = Calendar.getInstance();
//c.set(Calendar.YEAR,year);
//c.set(Calendar.MONTH,2);
//c.set(Calendar.DAY_OF_MONTH,1);
c.set(year,2,1);

//把月中的天，往前减1天.
c.add(Calendar.DAY_OF_MONTH,-1);

//获取月中的天
int day = c.get(Calendar.DAY_OF_MONTH);
if(day==28){
  System.out.println("平年");
}else{
  System.out.println("闰年");
}

异常

在程序的编译和运行时出现的一些不正常的状况,就叫做异常。

写Java程序经常会出现一些问题，为了让开发者知道这些问题产生的原因，Sun公司就把这些常见的异常封装成了类(在API中可以查看)，方便于开发人员出现问题的时候，去找问题出现的原因。
异常的继承体系
 Throwable
  -- Eroor：非常严重的问题(无法解决，癌症晚期)
  -- Exception：可以解决的问题
   -- RuntimeException: 运行时异常，程序终止
   -- 非RuntimeException: 编译时异常(受检异常)，编译报错

JVM自己处理异常
发现异常,程序立即终止执行,把异常信息打印输出在控制台。开发者根据信息找问题

try…catch处理异常
如果使用try…catch处理异常，出现异常程序还可以继续执行。

一般使用try…catch处理编译时异常

//快捷键：alt+enter --> Surround with try/catch 自动把有异常的代码包裹起来。
try{
  有可能发现异常的代码
  (一般把提示有编译时异常的代码括起来)
}catch(异常类名1 e){
  处理异常1的代码 //出现异常才执行catch里面的语句，否则就不执行
}catch(异常类名2 e){
  处理异常2的代码
}catch(Exception e){
  如果出现异常上面的都不处理，就交给此处处理
}

后面的代码可以正常执行

【注意：范围较大的异常尽量往后写】

比如对日期字符串进行解析,字符串的格式有可能出现问题

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Date date = null;
try {
  date = sdf.parse("2008/08-08");
  System.out.println(date);
} catch (ParseException e) {
  e.printStackTrace(); //打印输出异常信息
} 

System.out.println("over");

• 注意事项
• 这个throws格式是跟在方法的括号后面的
• 编译时异常必须要进行处理，两种处理方 案：try…catch …或者 throws，如果采用 throws 这种方案，将来谁调用谁处理
• 运行时异常可以不处理，出现问题后，需要我们回来修改代码

public static void show(int num) throws Exception{
  ...
  }

自定义异常
当API中给你提供的异常类，不足以描述你需求中的问题，那么就可以自定义异常。

自定义异常的步骤
 - 写一个类继承Exception或者RuntimeException
  就说明你的类就是异常类，【建议名称以Exception结尾，见名知意】
 - 利用父类生成两个构造方法(alt+insert)
     空参构造
     有参构造

public class FlaseMoneyException extends Exception {

    public FlaseMoneyException(String s) {
        System.out.println(s);
    }
}

public static void main(String[] args) throws FlaseMoneyException {
  sale(7);
} 
//卖东西
public static void sale(int money) throws FlaseMoneyException{
  if(money==7){
    //产生一个异常 假钱异常对象
    throw new FlaseMoneyException(money+"面值的钱不存在，系统已经自动报警，等着！！！");
  }else if(money==5){
    System.out.println("买了一瓶脉动");
  }
}

throws和throw的区别
throws接在方法后+异常类{方法体} 声明可能出现一个异常
throw 用在方法内+异常对象 是异常出现对异常的处理

throws可以单独使用，但throw不能， throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使 用，然后再由处理异常的方法捕获。
–狒狒你呐