Java面向对象基础02

已于 2022-01-22 16:12:21 修改
阅读量250 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言 后端
于 2022-01-22 16:03:18 首次发布
本文链接：https://blog.csdn.net/C_Karen/article/details/121619414
版权

文章目录

类的续集

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 常用方法

  1. name()方法

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

实例：Season_01.SPRING.name();

  1. ordinal()方法

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

实例：Season_01.SPRING.ordinal();

  1. values()方法

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

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

  1. valueOf(String str)方法

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

实例：Season_01.valueOf(“SPRING”)

  1. compareTo()方法

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

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

3.4 注意事项

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

4 注解

注解不全，其后补齐😏

4.1 @Override注解

使用说明：

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

4.2 @Deprecated注解

使用说明：

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

4.3 @SuppressWarnings()注解

使用说明：

  1. 当我们不希望看到警告时，可以使用@SuppressWarnings()注解，来抑制警告信息。
  2. @SuppressWarnings({“unused”,“unchecked”}) 大括号内的时选项，代表抑制哪一类警告。
  3. 可以查SuppressWarnings文档来查看警告类型
  4. @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三种参数：

  1. RetentionPolicy.SOURCE;编译器使用后直接丢弃策略的注解。
  2. RetentionPolicy.CLASS;编译器将把注解记录在class文件中，当运行Java程序时JVM会不会保留注解。（这是默认值）
  3. 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 常见的运行时异常

  1. NullPointerException(空指针异常)

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

  1. ArithmeticException(算术异常)

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

  1. ClassCastException(类型转换异常)

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

  1. ArrayIndexOutOfBoundsException(数组下标越界)

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

  1. NumberFormatException(数字格式不正确)

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

5.3 常见的编译异常

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

5.4 异常处理

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

处理方式：

1️⃣ try-catch-finally方式

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

2️⃣ throws方式

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

  1. try-catch-finally方式
 try{
 //代码可能有异常的部分
 } catch (Exception e){
 /**
 * 捕获到异常部分抛出的异常，系统会将异常封装成 Exception的一个对象e
 * 转递给 catch部分如何程序员自行处理。
 */
 }finally {
 /**
 * 不管 try代码是否有异常发生，始终要执行 finally部分，
 * 所以通常将资源释放的代码放在 finally部分。
 */
 }
  1. throws方式
 public void P(int number) throws FileNotFoundException {
     /**
     * 创建一个文件流对象
     * 1. 这里的 FileNotFoundException是一个编译异常
     * 2. 这里使用 throws抛出异常
     */
     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){
 /**
 * 捕获到异常部分抛出的异常，系统会将异常封装成 Exception的一个对象e
 * 转递给 catch部分如何程序员自行处理。
 */
 }finally {
 /**
 * 不管 try代码是否有异常发生，始终要执行 finally部分，
 * 所以通常将资源释放的代码放在 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异常处理

基本介绍：

  1. 如果一个方法(语句执行时)产生异常，但是并不能确定如何处理这种异常，则此方法显明地抛出异常，表明该方法将不对这些异常进行处理而由该方法的调用者负责处理。
  2. 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。
 public void P(int number) throws FileNotFoundException {
     /**
     * 创建一个文件流对象
     * 1. 这里的 FileNotFoundException是一个编译异常
     * 2. 这里使用 throws抛出异常,让调用者(方法)处理
     * 3. throws后面的异常类型可以是方法中产生的异常类型也可以是它的父类(向上转型)
     * 4. throws关键字后可以是异常列表，即可以抛出多个异常
     */
     FileInputStream fileInputStream = new FileInputStream("D://aa.txt");
     //其它处理...
 }

注意事项：

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

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基本介绍

基本解释：

  1. String对象用于保存字符串，也就是一组字符序列
  2. 字符串常量对象是用双引号括起来的字符序列。
  3. 字符串的字符使用Unicode字符编码，一个字符(不区分字母或汉字)占2个字节。char也是两个字节。
  4. String类是final的不能被继承
  5. String中有private final byte[] value;用于存放字符串内容。
//String的创建：
String s = "haha";//方式一
String s1 = new String("hehe");//方式二

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

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

6.2 String对象特性

  1. String类被final修饰
  2. 字符串是不可变的，一个字符串对象一旦被分配对象其内容不可变。
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个

解析：

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

6.3 String常用方法

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

6.4 StringBuffer类

6.4.1 StringBuffer类基本介绍

在这里插入图片描述

  1. java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删
  2. 很多方法与String相同，但StringBuilder是可变长度的
  3. StringBuffer是一个容器
  4. 在AbstractStringBuffer有属性byte[] value;，不是final，该value数组存放字符串内容，因此字符串存放于堆中。
  5. StringBuffer是final类不能被继承
6.4.2 StringBuilder类构造器
  • StringBuffer()：构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符
  • StringBuffer(CharSequence seq)：构造一个字符串缓冲区，包含与指定的CharSequence相同的字符
  • StringBuffer(int capacity)：具有指定初始化大小容量的字符缓冲区，即value大小为capacity
  • StringBuffer(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区别与转换

⭕️ 区别

  1. String保存的是常量里面的值不能更改，每次String类的更新实际上就是更改地址
  2. 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类

在这里插入图片描述

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

6.6 String、StringBuffer和StringBuilder区别

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

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

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

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

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

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

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

使用的原则，结论：

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

7 Math类常用方法(数学)

  1. abs：求绝对值
  2. pow：求幂
  3. ceil：向上取整
  4. floor：向下取整
  5. round：四舍五入
  6. sqrt：求开平方
  7. random：求随机数
  8. max：求两个数的最大数
  9. min：求两个数的最小数

8 Arrays类常用方法

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

  1. toString：返回数组的字符串形式
int[] arr = {1,2,3,4,5,6,7,8,9};
System.out.println(Arrays.toString(arr));
  1. 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;
            }
        }
    }
}
  1. binarySearch：通过二分搜索发进行查找，要求必须排好序。
int[] arr = {1,2,3,4,5,100,6,7,8,9};
Arrays.sort(arr);
Arrays.binarySearch(arr,1);
  1. copyOf：数组元素复制，返回复制的数组
int[] inArr = Arrays.copyOf(arr,arr.length);

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

  1. fill数组元素的填充

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

  1. equals：比较两个数组元素内容是否完全一致,返回布尔值
int[] a = {1,2,3,4,5,6,7,8,9};
int[] b = {1,2};
boolean flag = Arrays.equals(a,b);
  1. asList：将一组值转换为List集合
Arrays.asList(1,2,3);

9 System类常用方法

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

10 BigInteger和BigDecimal类

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

11 日期类

11.1 第一代日期类(Date)

在这里插入图片描述

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

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

📖 Date构造器

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

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

📖 格式转换

/**
 * y 代表年
 * M 代表月
 * d 代表日
 * E 代表星期
 * H 代表24进制的小时
 * h 代表12进制的小时
 * m 代表分钟
 * s 代表秒
 * S 代表毫秒
 */
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
String s = sdf.format(date);
System.out.println(s);
  1. 创建SimpleDateFormat的对象可以指定相应的格式
  2. 字母是规定好的，不能乱用

11.2 第二代日期类(Calendar)

在这里插入图片描述

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

在这里插入图片描述

  1. Calendar是抽象类，并且它的构造器是私有的
  2. 可以通过 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也存在问题是：

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

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

  1. 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();//获取时分秒
  1. 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);
  1. Instant时间戳(类似于Date)
//提供了一系列和Date类转换的方式
Instant now = Instant.now();
System.out.println(now);
//Instant->Date:
Date from = Date.from(now);
//Date->Instant:
Instant instant = from.toInstant();

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

i笨笨i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面向对象基础实验小结_JAVA面向对象基础小结
weixin_31188325的博客
02-28 1508
JAVA基础知识JAVA的面向对象(obtion object)Java面向对象首先要理清对象和类的关系：1. 类是对象的模板，对象是类的体现；现在把一个类比较一张汽车设计图纸，对象比做刚按照这张图纸制造出来的汽车。2. 一个类有很多对象，对象不能改变类的内容。一张图纸能够造出很多汽车，，其中的一辆车进行了改装，但是没能改变设计图纸，所以后面制造出来的汽车还是没有受到影响。3.创造一个类(类名首字...
Java基础2-面向对象
spring_boot的博客
03-15 243
一、面向对象 1、面向对象主要针对面向过程。面向过程的基本单元是函数。 2、在 JAVA 中，一切都是对象，但我们用来操纵对象的却是引用。 3、对象包括变量( 属性) 和方法，变量表示对象的属性，方法用来描述对象的功能，处理过程。 4、对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。 5、实现高内聚就是要最大限度降低提高复用性（复用性好是因为高内聚）。可复用性是 OOP 的基础。 6、面...
Java面向对象基础
weixin_60719453的博客
10-13 8392
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
Java面向对象浅谈
编程界明世隐的博客
12-06 4936
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 242
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 984
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 94
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 525
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 575
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 604
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 375
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 436
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 131
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 195
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 331
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 872
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 282
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Java —— 线程
JL_L666的博客
07-26 662
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Java面向对象基础02：类、对象与封装
本资源是关于Java面向对象编程的基础教程，由李兴华编写，旨在帮助学习者理解面向对象的核心概念。主要内容包括以下几个关键知识点： 1. 类与对象：在Java中，类是一种抽象的模板，用来描述具有相似特性和行为的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值