Java基础知识整理 (Date类，Calender类，枚举，异常，throw和throws抛出异常)

常量在编译时期就能确定其值（需要声明的同时赋值）

变量在编译时期不能确定其值，只能在运行时才可以

System.in 标准输入流 System.out标准输出流

arraycopy——赋值数组 复制原数组指定位置的元素，到目标数组中的指定位置指定复制长度

ArrayList—扩容就是使用arraycopy完成

Date类

Date是一个时间类，JDK1.0就存在，JDK1.1中就不提倡使用，在包java.util.date中。

Java提供一种机制：方法过时机制(废弃)，提示编程者当前不再提供维护，在以后的版本里面有可能删除删除当前方法，所以不建议使用过时方法 ——但是date类一直在用

@Deprecated——让方法显示过时，平时自己写的方法也是可以用

Date类可以表示一个特定瞬间，精确到毫秒，

DateFormat/SimpleDateFormat类—时间格式化

Date date = new Date();
显示声明当前类属于那个包  java.util.Date date1 = new java.util.Date();

date.getTime();返回值long 返回1970年1月1日距离当前日期的毫秒值

DateFormat格式化类

格式化返回的String类型

Date date = new Date();
DateFormat df = DateFormat.getInstance;//时间风格 SHORT风格
String time = df.format(date);

长风格的时间格式化 修改df对象引用
df = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String time = df.format(date);

解析时间 String类型转换成Date对象

解析时要注意时间格式要对应，使用哪种形式的格式化时间，就需要使用哪种方式解析

（当时长风格就要时，要先转成短风格再转成Date）
df = DateFormat.getInstance();
Date date2 = df.parse(time);//从String到Date

DateFormat的格式是固定的，不能自定义

SimpleDateFormat日期格式化

当前类是DateFormat的子类，支持自定义时间

//自定义时间格式
String str = "yyyy/mm/dd hh时mm分ss秒";
SimpleDateFormat sdf = new SimpleDateFormat();
//设置使用时间格式
sdf.applyPattern(str);//设置时间格式
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy/mm/dd hh时mm分ss秒");两部合成一步

String time = sdf.format(new date());

若使用当前格式格式化当前时间 ，必须要用这种格式格式化回来

Date date2 = sdf.parse(time);//从String到Date

Calender类

Calender类代替Date出现，并且是一个抽象类不能new。使用getInstance（）获取对象

Calender可以获取当前系统所在时区的日历对象，通过对这个日历对象获取时间

//获取日历类对象
Calendar c = Calender.getInstance();
//在日历类中获取有用数据 使用静态常量获取
//get()-通过参数获取日历类对象中储存的数据
int year = c.get(Calendar.YEAR);
//表示月份很特殊，从0开始11结束 需要进行+1操作
int month = c.get(Calendar.MONTH)+1;
//天数 时分秒
int day = c.get(Calendar.DATE);
int h = c.get(Calendar.HOUR);
int m = c.get(Calendar.MINUTE);
int s = c.get(Calendar.SECOND);

Calendar 转化成Date对象

Calendar c = Calender.getInstance();
Date time = c.getTime();
// 获取2019年4月12日是这一年的第几天（考虑到平年闰年），一周中的第几天，一个月的第几天
Calendar c = Calendar.getInstance();
		c.set(2019, 3, 12);//月份要减一
		//当年对应天数
		int day = c.get(Calendar.DAY_OF_YEAR);
		//一周中第几天
		int week = c.get(Calendar.DAY_OF_WEEK);
		//一个月中的第几天
		int dayForMonth = c.get(Calendar.DAY_OF_MONTH);
		System.out.println(day + " " + week + " " +dayForMonth);

枚举

枚举是一种类型——枚举中存储的是常量—静态常量

用来表述一些使用变量无法描述的事物-----例如春夏秋冬

枚举只能获取枚举存储的类型，不能获取其他类

//那一天可以休息
Person p = new Person();
p.setDay(3);
if(p.getDay()==6 || p.getDay()==7){
    //可以休息
}else{
    //在上班
}
getDay方法里面的参数是没有什么限制的，可以传负数，大于7的数，出现1-7以外的值，表述不明确，不知道1代表什么

根据上述问题 需要语意明确，又传值清晰

public class week{
     /*
      public static final int MONDAY = 1;
      public static final int TUESDAR = 2;
      public static final int WEDNESDAY = 3;
      public static final int THURSDAY = 4;
      public static final int FRIDAY = 5;
      public static final int SATURDSAY = 6;
      public static final int SUNDAY = 7;
      */
      private Week(){}
      public static final Week MONDAY = new week();
      public static final Week TUESDAR = new week();
      public static final Week WEDNESDAY = new week();
      public static final Week THURSDAY = new week();
      public static final Week FRIDAY = new week();
      public static final Week SATURDSAY = new week();
      public static final Week SUNDAY = new week();
}

上述代码还是很繁琐的，JDK1.5开始系统提供了Enum枚举类型来完成

枚举是一个应用类型

public enum Week{
    //定义常量
     MONDAY,TUESDAR,WEDNESDAY,THURSDAY,FRIDAY,SATURDSAY,SUNDAY
}

语法： 权限修饰符 enum 枚举类名{常量} （多个常量用逗号隔开）

1.枚举是继承与Enum存在的

2.底层是一个类，所以枚举可以定义成员变量、成员方法、静态方法、静态变量的

3.因为默认私有构造方法，枚举本事是一个单例

4.枚举只能获取枚举常量值，不能通过new创建对象

5.若需要枚举中的常量值 用 枚举名.常量名 即可

6通过反编译，发现一个隐藏方法，系统API中没有，values

枚举扩展

枚举本身就是一个类，一个单例，枚举单例定义
访问权限修饰符 enum 枚举名{
      需要定义使用的名称（枚举常量）
}
public enum Type{
     INSTANCE;
     Sting name;
     public String getName{
        return name;
     }
}
一旦枚举中提供了属性和方法，枚举常量必须用分号 ；结尾
枚举中声明多个常量，所有的常量都共享属性和方法
public enum Type{
       INSTANCEA{//当前范围内的都属于A，B获取不到
            String name;
            public String getName{
               return name;
            }
       }
       INSTANCEB;
}枚举实现接口，但是不能继承

枚举和Switch最配 JDK1.7之后提供了Switch和String的搭配，所以枚举用的少了

只是用String限制数据问题不能解决

异常

java中有一个异常和错误的父类 ——-Throwable

Error(错误) 一般是指JVM出现不可修复的问题，此时异常退出JVM情况

如：内存溢出，堆溢出(OOM) ，JVM崩溃

出现描述的时候 xxxxError，其中Error作为结尾出现

Exception(异常)： 当前程序出现不正常情况，出现异常信息，提示异常信息进行修改，所有异常又是Exception作为结尾

两种异常：

1.编译时异常（必须处理）：在编写代码时就出现的异常提示

2.运行时异常：当程序运行起来后出现的异常信息，出现后修改，若能发现及时修改（RuntimeException）

常见的异常

NullPointerException 空指针异常 引用了一个地址是null对象并调用了自身

ArrayIndexOutOfBoundsException 数组下标越界异常 下标越界

NumberFormatException 数据格式化异常 将数据格式化的时候出现的问题

ClassCastException 强制类型转换异常 将一个父类的引用类型转换为其子类时，当前子类与对象原有类型不匹配

ArithenmticException 算数异常 除数为0

try….catch….finally

保证代码的正常运行

try{
    //可能出现的异常代码
}catch(ArithenmticException e){
    //对异常进行处理 打印信息
    1.直接打印提示信息System.out.println("出现了异常")
    2.异常类型后面的e相当于异常对象，所以对e进行操作，
        打印错信息：用e.getMessage();
        打印异常类型和异常信息：e.toString();
        打印异常跟踪栈信息：e.printStackTrace();//
}

出现多个异常时的抓取方式 try-catch多个

注意：父类异常不能在子类异常上一个catch中，因为父类异常会将所有异常抓取走，剩余的异常信息抓起不会执行

try{
//可能出现的异常代码
}catch(ArithenmticException e){
//对异常进行处理 打印信息

}catch(ArrayIndexOutOfBoundsException e){

}catch(Exception e){//父类异常
}

JDK1.7推出了一个平行异常（平行抓去）

父类异常不能在子类异常之前

try{
//可能出现的异常代码
}catch( ArrayIndexOutOfBoundsException|ArithenmticException|Exception e){
//对异常进行处理 打印信息

}

代码中有多个异常，但是不知道异常有哪些，直接用Exception万能抓取方式

finally代码块

特点：finall语句快表达式最终都会被执行，无论是否出现异常当前的finally一定会执行

可以添加到catch的后面，可以进行一些资源的释放工作

当使用try捕捉异常时，

语法：可以跟try catch联用，也可单独和try一起使用
try{
//可能出现的异常代码
}catch( ArrayIndexOutOfBoundsException|ArithenmticException|Exception e){
//对异常进行处理 打印信息
}finally{
//释放资源
}

try{
//可能出现的异常代码
}finally{
//释放资源
}

只要finally语句块中有return语句，永远执行finally里面的return

final finally finalize之间有什么区别

throw和throws抛出异常

throw抛出异常 运用在方法体的内部类，抛出一个具体的异常对象

throw new 异常类(“异常信息”)；

这个throw在方法体中，相当于是一个return关键字，可以终止方法

1.当前需要返回值，素有情况都满足了，但是有一种特殊情况，此时可以抛出异常

例如：工厂方法
public static Person createPerson(String gender){
    switch(gender){
        case man:
            return new man();
        case woman:
            return new woman();
        default:
            //这里可以返回null，但是使用的时候需要加判断，不然会有空指针异常
            //所以最好的方式应该是抛出异常
            throw new RuntimeException("没有这个性别，确定后输入");
    }
}

2.当前方法中会出现异常，但是方法处理异常时机不是很好，此时可以将异常再次抛出

String str = "123";
try{
    int num = getNumber(str);
    System.out.println(num);    
}catch{
    System.out.println(e.getMessage());
}

public static int getNumber(String str){
    try{
        return new Integer(str).intValue;
    }catch(NumberFormatException e){
        throw new NumberFormatException("大哥您输入的字符串有问题");
    }
}

throws

用于方法的声明之上，throws和throw完全不一样。作用于方法之上，将整个方法出现的异常抛给调用者.最终throws会抛到main方法上，main方法对异常进行抛出—JVM接受 —崩溃

throws只能抛出异常，不能处理异常

public static int getNumber(String str)throws NumberFormatException{
    return new Integer(str).intValue;
}

throw和throws不一起使用，但是有一种特殊情况 ，当方法中抛出的异常时编译时异常时，此时需要同时使用，此时也可以单独只使用throws，直接抛出一个编译时异常即可

public static int getNumber(String str)throws(Exception e){
    try{
        return new Integer(str).intValue;
    }catch(ception e){
        throw new Exception("大哥您输入的字符串有问题");//
    }
}

自定义异常：

java中有很多异常类，这些异常类都是一些具体的作用与说明

1.当前自定义异常定义的是运行时异常———只需要继承与RuntimeException即可仿父类生成构造方法

2.当前自定义异常定义的是编译时异常———只需要继承Exception即可并仿照生成自己的构造方法

package com.qfedu.Exception;
//自定义异常
public class ZhangPangLeExcetpion extends RuntimeException{
/** *就是区分JDK版本使用 */
    private static final long serialVersionUID = 1L;
//只要仿照构造方法,什么都需要写
    public ZhangPangLeExcetpion() {
    super();
            // TODO Auto-generated constructor stub
    }
    public ZhangPangLeExcetpion(String message, Throwable cause, boolean enableSuppression,
            boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
        // TODO Auto-generated constructor stub
    }
    public ZhangPangLeExcetpion(String message, Throwable cause) {
        super(message, cause);
        // TODO Auto-generated constructor stub
    }
    public ZhangPangLeExcetpion(String message) {
        super(message);
// TODO Auto-generated constructor stub
        }
    public ZhangPangLeExcetpion(Throwable cause) {
        super(cause);
        // TODO Auto-generated constructor stub
} }
package com.qfedu.Exception;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
    Scanner input = new Scanner(System.in); 
    System.out.println("请输入你今天的体重:"); 
    double d = input.nextDouble(); checkPang(d);
    }
    public static void checkPang(double d) {
        if(d > 100) {
            throw new ZhangPangLeExcetpion("恭喜胖了!!!!请继续加油!!!!");
        }
    }
}

异常链和异常转换

异常转换：当位于最上层的调用代码时，不需要关系底层代码的异常细节，可以将原始异常进行一次转换

异常链: 把原始异常记性一次包装会的得到一个新的异常,并给此后都会对新的异常进行包装,可以得到一个有序的排序，这个排序就是异常链