Java面向对象基础02

文章目录

类的续集

3 枚举

3.1 枚举定义3.2 模拟实现枚举类3.3 常用方法3.4 注意事项 4 注解

4.1 @Override注解4.2 @Deprecated注解4.3 @SuppressWarnings()注解4.4 JDK中的元注解(认识即可)

4.4.1 @Retention注解4.4.2 @documented注解4.4.3 @Inherited注解 5 异常

5.1 异常基本介绍5.2 常见的运行时异常5.3 常见的编译异常5.4 异常处理5.5 try-catch异常处理5.6 throws异常处理5.7 自定义异常5.8 throws与throw区别 6 String类

6.1 String基本介绍6.2 String对象特性6.3 String常用方法6.4 StringBuffer类

6.4.1 StringBuffer类基本介绍6.4.2 StringBuilder类构造器6.4.3 StringBuffer常用方法6.4.4 String与StringBuffer区别与转换 6.5 StringBuilder类6.6 String、StringBuffer和StringBuilder区别 7 Math类常用方法(数学)8 Arrays类常用方法9 System类常用方法10 BigInteger和BigDecimal类11 日期类

11.1 第一代日期类(Date)11.2 第二代日期类(Calendar)11.3 第三代日期类

类的续集 3 枚举 3.1 枚举定义

1️⃣ 定义：枚举是一组常量的量，枚举属于一种特殊的类，里面只包含一组有限并且特定的对象。

2️⃣ 实现形式：使用 enum 关键字实现枚举。

3️⃣ enum实例：

 enum Season_01 {
     SPRING("春天","温暖"),SUMMER("夏天","炎热"),
     AUTUMN("秋天","凉爽"),WINTER("冬天","寒冷");
     private String name;//姓名
     private String desc;//描述

     Season_01(String name, String desc) {
         this.name = name;
         this.desc = desc;
     }
 }

3.2 模拟实现枚举类

问题1：尝试自己写一个类似于枚举类，具体需要注意什么？

接下来看几个代码段，试试分析一波

⭕️ Season_01 season = Season_01.AUTUMN;

能通过类名直接调用AUTUMN（Season_01类的一个常量对象)就说明AUTUMN是被static修饰并且是public的，而且在Season_01类的内部创建对象。

⭕️ 既然叫枚举常量，总所周知常量是不能被修改的，由于字符串放在常量池中，这里的无法修改只能是引用不能被修改，所以被final修饰。

⭕️ Season_01 s = new Season_01(); 这样的语句正确吗？

常量一般只需一份即可，所以这个语句是错误的。说明Enum实现类的构造器是私有的，无法被外部创建。

 总结(明确目标)

类内部实例化对象，并且被public、static和final修饰，构造器私有化。

 class Season_02 {
     private String name;
     private String desc;
     //Season_02类 内部实例化对象
     public static final Season_02 SPRING= new Season_02("春天","温暖");
     public static final Season_02 SUMMER= new Season_02("夏天","炎热");
     public static final Season_02 AUTUMN= new Season_02("秋天","凉爽");
     public static final Season_02 WINTER= new Season_02("冬天","寒冷");
    
     private Season_02(String name, String desc) {//构造器私有化
         this.name = name;
         this.desc = desc;
     }
 }
 //调用语句
 Season_02 s2 = Season_02.AUTUMN;

3.3 常用方法

name()方法

作用：返回输出枚举对象的名称，返回类型String。

实例：Season_01.SPRING.name();

ordinal()方法

作用：返回该枚举对象的次序(编号)，从0开始编号，次序是按照定义顺序。

实例：Season_01.SPRING.ordinal();

values()方法

作用：返回该枚举类型的数组，数组内存放所定义的枚举对象。

实例：Season_01[] ss = Season_01.values();

valueOf(String str)方法

作用：返回一个枚举对象，将字符串str转换成枚举对象，该字符串与枚举对象名相同则返回枚举对象，否则报错。

实例：Season_01.valueOf(“SPRING”)

compareTo()方法

作用：比较两个枚举常量的编号，返回编号的差值。

实例：Season_01.SPRING.compareTo(Season_01.WINTER)

3.4 注意事项

使用Enum关键字后就不能继承其他类，但是可以继承接口。使用enum实现枚举，要求将定义的常量(对象)，写在实现过程的首行，如有多个枚举常量之间用逗号隔开。

4 注解

注解不全，其后补齐

4.1 @Override注解

使用说明：

@Override表示指定重写父类的方法(从编译层面验证),如果父类没有某方法用@Override则会报错。@Override只修饰方法。查看@Override源码为@Target(ElementType.METHOD)说明只能修饰方法(Target的参数)。

4.2 @Deprecated注解

使用说明：

@Deprecated修饰某个元素，表示该元素已经过时(不推荐使用，但仍然可以使用)。可以修饰方法、类、包、参数等。@Deprecated的作用可以做到新旧版的兼容过渡。

4.3 @SuppressWarnings()注解

使用说明：

当我们不希望看到警告时，可以使用@SuppressWarnings()注解，来抑制警告信息。@SuppressWarnings({“unused”,“unchecked”}) 大括号内的时选项，代表抑制哪一类警告。可以查SuppressWarnings文档来查看警告类型@SuppressWarning作用范围是和放置的位置有关

4.4 JDK中的元注解(认识即可)

基本介绍：JDK的元注解用于修饰其他注解。

注解类型：

Retention指定注解范围，三种SOURCE、CLASS、RUNTIME；Target指定注解可以在哪些地方使用；

documented指定该注解是否会在Javadoc体现；Inherited指子类会继承父类的注解；

4.4.1 @Retention注解

基本介绍：只能用于修饰一个注解定义，用于指定该注解可以保留多长时间，@Retention包含一个RetentionPolicy类型的成员变量，使用@Retention时必须为该value成员变量指定值。

//例：@Retention(RetentionPolicy.SOURCE)
public @interface Retention {//部分源码
    RetentionPolicy value();
}

@Retention三种参数：

RetentionPolicy.SOURCE;编译器使用后直接丢弃策略的注解。RetentionPolicy.CLASS;编译器将把注解记录在class文件中，当运行Java程序时JVM会不会保留注解。（这是默认值）RetentionPolicy.RUNTIME;编译器将把注解记录在class文件中，当运行Java程序时JVM会保留注解，程序可以通过反射获取注解。

4.4.2 @documented注解

基本介绍：用于指定被该元注解修饰的注解类，将被javadoc工具提取成文档，即在生成文档时，可以看到该注解。

4.4.3 @Inherited注解

基本介绍：被它修饰的注解将具有继承性，如果某个类使用了被@Inherited修饰的注解，则其子类将自动具有该注解。

5 异常 5.1 异常基本介绍

异常是Java设计者提供的异常处理机制。在Java语言中，将程序中发生的不正常情况称为“异常”。

⭕️ 执行过程中所发生的异常事件可分为两大类：

Error(错误)：Java虚拟机无法解决的严重问题。例如：JVM系统内部问题、资源耗尽等严重情况。Error是严重错误，程序会崩溃。

Exception(异常)：其因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空引用访问，试图读取不存在文件等。

⭕️ Exception分为两大类：运行时异常和编译时异常

运行时异常：一般指编程时逻辑错误，是程序员应该避免其出现的异常。编译时异常：是编译器要求必须处置的异常。

注：Exception和Error继承子类未展示完全

5.2 常见的运行时异常

NullPointerException(空指针异常)

当应用程序试图在需要对象的地方使用Null时，抛出的异常。

ArithmeticException(算术异常)

当出现异常的运算条件时，抛出异常。例如：3/0

ClassCastException(类型转换异常)

当试图将对象强制转换为不是实例的子类时，抛出异常。

ArrayIndexOutOfBoundsException(数组下标越界)

用非法索引访问数组时抛出异常。

NumberFormatException(数字格式不正确)

当应用程序试图将字符串转换为一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。

5.3 常见的编译异常

SQLException：操作数据库时，查询表可能发生的异常。IOException：文件操作时，发生的异常。FileNotFoundException：当操作一个不存在的文件时，发生异常。ClassNotFoundException：加载类时该类不存在抛出异常。EOFException：当输入过程意外到达文件或流的末尾时，抛出异常。IllegalArgumentException： 抛出的异常表明向方法传递了一个不合法或不正确的参数。

5.4 异常处理

基本介绍：当发生异常时，应当进行对应的处理。

处理方式：

1️⃣ try-catch-finally方式

​ 程序员在代码中捕获发生的异常，自行处理。

2️⃣ throws方式

​ 将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者就是JVM。

try-catch-finally方式

 try{
 //代码可能有异常的部分
 } catch (Exception e){
 
 }finally {
 
 }

throws方式

 public void P(int number) throws FileNotFoundException {
     
     FileInputStream fileInputStream = new FileInputStream("D://aa.txt");
     //其它处理...
 }

throws处理机制：将异常交给调用者(方法)来处理，调用者可以选择try-catch或者throws。

⭕️ JVM处理异常:输出异常信息，退出程序。

5.5 try-catch异常处理

Java提供 try-catch处理异常，try块中包含可能出错的代码，catch块用于处理 try块中发生的异常。

 //基本语法：
 try{
 //代码可能有异常的部分
 } catch (Exception e){
 
 }finally {
 
 }

注意细节：

如果发生异常了，则异常发生后面的代码不会执行，直接进入catch块。如果希望是否发生异常都要执行的代码放到finally块中。如果没有发生异常则顺序执行try的代码块，不会进入catch块。可以有多个catch语句，捕获不同的异常(进行不同的业务处理）要求父类异常在后，子类异常在前。如果发生异常则会匹配一个catch块。可以进行try-finally语句配合使用，虽然try块报错，但还是执行了finally块中语句。

 例1：调用method()返回数字是多少？

public static int method() {
    try{
        String[] names = new String[3];
        if(names.equals("tom")){
            System.out.println(names[1]);
        }else{
            names[3]="haha";
        }
        return 1;
    }catch (ArrayIndexOutOfBoundsException e){
        return 2;
    }catch (NullPointerException e){
        return 3;
    }finally {
        return 4;
    }
}

答案：4

解析：调用method()方法，进入try块创建names字符串数组，执行equals()方法但此时names存储值全为null，抛出空指针异常进入catch(NullPointerException e)块遇到返回语句，在返回之前必须执行finally块语句在其中遇到return语句，则返回4。

 例2：调用method()返回数字是多少？

public static int method() {
    int i = 1;
    try {
        i++;
        String[] names = new String[3];
        if (names[1].equals("tom")) {
            System.out.println(names[i]);
        } else {
            names[3] = "haha";
        }
        return 1;
    } catch (ArrayIndexOutOfBoundsException e) {
        return 2;
    } catch (NullPointerException e) {
        return ++i;
    } finally {
        ++i;
        System.out.print("i=" + i+" ");
    }
}

答案：i=4 3

解析：调用method()方法，i被赋值为1，进入try块后i++，i为2，在equals处抛出空指针异常进入catch (NullPointerException e)块，执行++i，i为3然后返回，但是必须执行finally块，在finally中i变为4，输出"i=4"。由于进入finally前把i=3时的临时值已存放内存中(和i的地址不同)，执行完finally块后返回3；

5.6 throws异常处理

基本介绍：

如果一个方法(语句执行时)产生异常，但是并不能确定如何处理这种异常，则此方法显明地抛出异常，表明该方法将不对这些异常进行处理而由该方法的调用者负责处理。在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

 public void P(int number) throws FileNotFoundException {
     
     FileInputStream fileInputStream = new FileInputStream("D://aa.txt");
     //其它处理...
 }

注意事项：

对于编译异常必须处理，try-catch或throws。对于运行异常，程序中如果没有处理，默认为throws的方式处理。子类重写父类方法时，对抛出异常规定：子类重写父类方法，所抛出异常类型要么和父类抛出的异常一致，要么为父类抛出的异常类型的子类型。

5.7 自定义异常

基本介绍：当程序中出现了某些"错误"但该错误信息并没有在Throwable子类中描述处理，这时候可以设计异常类，用于描述该错误信息。

自定义异常的步骤：自定义异常类名继承Exception或RuntimeExpectation

class SmartException extends RuntimeException {
    public SmartException(String message){
        super(message);//调用RuntimeException的构造器
    }
}
调用throw new SmartExpectation("保持微笑");

5.8 throws与throw区别

6 String类

6.1 String基本介绍

基本解释：

String对象用于保存字符串，也就是一组字符序列字符串常量对象是用双引号括起来的字符序列。字符串的字符使用Unicode字符编码，一个字符(不区分字母或汉字)占2个字节。char也是两个字节。String类是final的不能被继承String中有private final byte[] value;用于存放字符串内容。

//String的创建：
String s = "haha";//方式一
String s1 = new String("hehe");//方式二

方式一：先从常量池中查看是否有"haha"数据，如果有直接指向；如果没有则创建然后指向。String最终指向的是常量池空间地址。

方式二：先创建String实例化对象的空间(在堆中)，String维护了value属性，指向常量池中的"hehe"的空间。如果常量池没有则创建然后指向。s1最终指向的是堆中空间地址。

6.2 String对象特性

String类被final修饰字符串是不可变的，一个字符串对象一旦被分配对象其内容不可变。

String s = "haha";
s = "hehe";//s是引用，s指向的地址改变但"haha"没有改变

⭕️题1：创建几个对象？

String s = "hello" + "abc";

答案：1个

解析：编译器将 “hello” + “abc” —(优化)–> “helloabc” 进行字符串常量创建。

⭕️题2：创建几个对象？

String a = "hello";
String b = "abc";
String c = a+b;

答案：3个

解析：

先创建 StringBuilder实例化对象(暂定为strBuilder)然后执行 strBuilder.append(“hello”);再执行 strBuilder.append(“abc”);创建String对象进行返回，return new String(value,0,count);value为刚刚拼接的字符串，0和count为起始和结束位置。c接收返回堆中对象的地址。

6.3 String常用方法

equals：判断内容是否相等(区分大小写)c.equalsIgnoreCase：判断内容是否相等(不区分大小写)length：获取字符个数，字符串长度indexOf：获取字符在字符串中第一次出现的索引，索引从0开始，未找到返回-1lastIndexOf：获取字符在字符串中最后一次出现的索引，索引从0开始，未找到返回-1substring：截取指定范围的子串charAt：获取某索引处的字符toUpperCase：返回转换后字符的大写形式，如果有的话；否则返回字符本身toLowerCase：返回转换后字符的小写形式，如果有的话；否则返回字符本身concat：返回连接后的新字符串。replace：替换后生成的新字符串。split：根据匹配给定的正则表达式来拆分字符串。compareTo：比较两个字符串的大小toCharArray：转换成字符数组format：格式化字符串

6.4 StringBuffer类 6.4.1 StringBuffer类基本介绍

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删很多方法与String相同，但StringBuilder是可变长度的StringBuffer是一个容器在AbstractStringBuffer有属性byte[] value;，不是final，该value数组存放字符串内容，因此字符串存放于堆中。StringBuffer是final类不能被继承

6.4.2 StringBuilder类构造器

StringBuffer()：构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符StringBuffer(CharSequence seq)：构造一个字符串缓冲区，包含与指定的CharSequence相同的字符StringBuffer(int capacity)：具有指定初始化大小容量的字符缓冲区，即value大小为capacityStringBuffer(String str)：构造一个字符缓冲区，并将其内容初始化为指定的字符串内容(容量为字符串长+16) 6.4.3 StringBuffer常用方法

append：添加（末尾添加）delete(start,end)：start和end都是索引，索引从0开始replace(int start, int end, String str)：将start->end间的内容替换掉(不含end)indexOf：查找子串在字符串第一次出现的索引，找不到返回-1，索引从0开始insert：插入length：获取字符串长度

6.4.4 String与StringBuffer区别与转换

⭕️ 区别

String保存的是常量里面的值不能更改，每次String类的更新实际上就是更改地址StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址(空间不够才会扩容)

⭕️ 转换

 String->StringBuffer

String str = “Hello Tom”;

1️⃣ 方式一

StringBuffer m = new StringBuffer(str);//对str无影响

2️⃣ 方式二

StringBuffer m2 = new StringBuffer();

m2 = m2.append(str);//对str无影响(拼接)

 StringBuffer->String

StringBuffer m = new StringBuffer(“haha”);

1️⃣ 方式一

String s = m.toString();//StringBuffer类重写了toString方法

2️⃣ 方式二

String s2 = new String(m);//利用构造器

6.5 StringBuilder类

一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步(线程不安全)。如果可能，建议优先使用该类，因为在大多数实现中，它比StringBuffer要快。在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。被final修饰，不可继承。StringBuilder对象字符序列仍然存放在父类AbstractStringBuilder的byte[] value；StringBuilder的方法，没有做互斥的处理，即没有synchronized关键字，因此在单线程的情况下使用StringBuilder。

6.6 String、StringBuffer和StringBuilder区别

StringBuilder和StringBuffer非常类似，均代表可变的字符序列而且方法类似。

String：不可变字符序列，效率低，但复用率高。

StringBuffer：可变字符序列，效率高(增删)，线程安全。

StringBuilder：可变字符序列，效率最高，线程不安全。

String s = “a”;//创建字符串

s += “b”;//实际上原来的"a"字符串已经丢掉，现在又产生了一个字符串 s+“b”(也就是"ab")

如果多次执行这些改变字符串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中会极大影响性能。结论：如果经常内容，尽量不要使用String类型

使用的原则，结论：

如果字符串存在大量的修改操作，一般使用StringBuffer(线程安全)或StringBuilder(线程不安全)。如果字符串修改很少，被多个对象引用使用String。

7 Math类常用方法(数学)

abs：求绝对值pow：求幂ceil：向上取整floor：向下取整round：四舍五入sqrt：求开平方random：求随机数max：求两个数的最大数min：求两个数的最小数

8 Arrays类常用方法

Arrays类里包含了一系列的静态方法，用于管理或操作数组。

toString：返回数组的字符串形式

int[] arr = {1,2,3,4,5,6,7,8,9};
System.out.println(Arrays.toString(arr));

sort：排序

1️⃣ 默认排序

int[] arr = {1,2,3,4,5,100,6,7,8,9};
Arrays.sort(arr);//从小到大
System.out.println(Arrays.toString(arr));

2️⃣ 定制排序

    int[] arr = {1,2,3,4,5,100,6,7,8,9};

    bubble02(arr, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            int i1 = (Integer) o1;
            int i2 = (Integer) o2;
            return i2 - i1;// return i2 - i1;
        }
    });
    System.out.println(Arrays.toString(arr));
}

//使用冒泡完成排序
public static void bubble01(int[] arr) {
    int temp = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            //从小到大
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

//结合冒泡 + 定制
public static void bubble02(int[] arr, Comparator c) {
    int temp = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
            if (c.compare(arr[j], arr[j + 1]) > 0) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

binarySearch：通过二分搜索发进行查找，要求必须排好序。

int[] arr = {1,2,3,4,5,100,6,7,8,9};
Arrays.sort(arr);
Arrays.binarySearch(arr,1);

copyOf：数组元素复制，返回复制的数组

int[] inArr = Arrays.copyOf(arr,arr.length);

第一个需要拷贝的数组，第二个拷贝个数。如果拷贝长度大于拷贝数组的长度增加null补位；如果拷贝超度小于0抛出异常。

fill数组元素的填充

fill(1,2);
1：带表需要充填的数组；2：填充数据(数组内容全部由填充成第二个参数内容)

equals：比较两个数组元素内容是否完全一致,返回布尔值

int[] a = {1,2,3,4,5,6,7,8,9};
int[] b = {1,2};
boolean flag = Arrays.equals(a,b);

asList：将一组值转换为List集合

Arrays.asList(1,2,3);

9 System类常用方法

exit：退出当前程序arraycopy：复制数组元素，比较适合底层调用。currentTimeMillis：返回当前时间距离1970-1-1的毫秒数gc：运行垃圾回收机制arraycopy(src,srcPos,dest,destPos,length)：src源数组、srcPos从源数组哪一索引开始拷贝、dest目标数组、destPos从源数组拷贝的数据放在目标数组开始位置索引、length拷贝多少数据。

10 BigInteger和BigDecimal类

应用场景：BigInteger适合保存比较大的整型数、BigDecimal适合存储精度更高的浮点数(小数)

11 日期类 11.1 第一代日期类(Date)

Date类：精确到毫秒，代表特定的瞬间。SimpleDateFormat：格式和解析Date类

SimpleDateFormat格式化和解析日期的具体类，它允许进行格式化(日期->文本)、解析(文本到日期)和规范化。

 Date构造器

Date date = new Date(90000000);//在1900-1-1的基础上加上传入的数据；

Date date = new Date();//获取当前系统时间
System.out.println(date);//默认输出格式为西式的，因此通常格式转换输出

 格式转换

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
String s = sdf.format(date);
System.out.println(s);

创建SimpleDateFormat的对象可以指定相应的格式字母是规定好的，不能乱用

11.2 第二代日期类(Calendar)

第二代日期类主要是Calendar类(日历)Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OFMONTH等日历字段之间的转换提供了一些方法，并为操作日历字段(例如：获得下星期的日期)提供一些方法。

Calendar是抽象类，并且它的构造器是私有的可以通过 getInstance()来获取实例，提供了大量的方法和字段给程序员使用

Calendar calendar = Calendar.getInstance();
//获取日历对象的某个日历字段
System.out.println("年：" + calendar.get(Calendar.YEAR));
//因为 Calendar返回月的时候是按照0开始编号的
System.out.println("月：" + calendar.get(Calendar.MONTH) + 1);
System.out.println("日：" + calendar.get(Calendar.DAY_OF_MONTH));
//Calendar.HOUR字段获取12小时制时间，Calendar.HOUR_OF_DAY字段获取24小时制时间
System.out.println("小时：" + calendar.get(Calendar.HOUR));
System.out.println("分钟：" + calendar.get(Calendar.MINUTE));
System.out.println("秒：" + calendar.get(Calendar.SECOND));
//Calendar 没有专门的格式化方法，所以需要程序员自己组合显示(按需获取相应字段)
System.out.println(calendar.get(Calendar.YEAR) + "年" + (calendar.get(Calendar.MONTH) + 1)+ "月" + calendar.get(Calendar.DAY_OF_MONTH) + "日");

11.3 第三代日期类

 前面两代日期类的不足：JDK 1.0中包含了java.util.Date类，但它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了，而Calendar也存在问题是：

可变性：像日期和时间这样的类应该是不可变的。偏移性：Date中的年份是从1900开始的，而月份都是从0开始。格式化：格式化只对Date有用，而Calendar不行。此外：它们也不是线程安全的；不能处理闰秒(每隔2天，多出1s)。

 第三代日期类常见方法：

LocalDate(日期，包含年月日)、LocalTime(时间，时分秒)、LocalDateTime(日期，年月日时分秒)，在JDK8中加入。

        //使用 now() 返回当前日期时间的对象
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        System.out.println(now.getYear());
        System.out.println(now.getMonthValue());
        System.out.println(now.getMonth());
        System.out.println(now.getDayOfMonth());
        System.out.println(now.getHour());
        System.out.println(now.getMinute());
        System.out.println(now.getMinute());
        LocalDate now1 = LocalDate.now();//获取年月日
        LocalTime now2 = LocalTime.now();//获取时分秒

DateTimeFormatter格式日期类(类似于SimpleDateFormat)

LocalDateTime e = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String format = dtf.format(e);//返回字符串是格式化好的
System.out.println(format);

Instant时间戳(类似于Date)

//提供了一系列和Date类转换的方式
Instant now = Instant.now();
System.out.println(now);
//Instant->Date:
Date from = Date.from(now);
//Date->Instant:
Instant instant = from.toInstant();

如发现错误，恳请留言或私信我。谢谢