JDK17的新特性_jdk 17 新特性-优快云博客

本文链接：https://blog.youkuaiyun.com/ShuoGuangNian/article/details/142432350

【注】需要关注的版本LTS（Long term support）长期支持版本目前JDK17 版本是长期支持版本

新特性1:jdk17对swtich语句增强

package jdktest;


public class SwitchExample {
    public static void main(String[] args) {
        int dayOfWeek = 3; // 假设今天是星期三
        Integer LLL = 1;
        extracted(dayOfWeek);

        extracted1(dayOfWeek);

        extracted2(dayOfWeek);

        String s = extracted3(LLL);
        System.out.println(s);
    }

    /**
     * 初始写法
     *
     * @param dayOfWeek
     */
    private static void extracted(int dayOfWeek) {
        switch (dayOfWeek) {
            case 1:
                System.out.println("今天是星期一");
                break;
            case 2:
                System.out.println("今天是星期二");
                break;
            case 3:
                System.out.println("今天是星期三");
                break;
            case 4:
                System.out.println("今天是星期四");
                break;
            case 5:
                System.out.println("今天是星期五");
                break;
            case 6:
                System.out.println("今天是星期六");
                break;
            case 7:
                System.out.println("今天是星期日");
                break;
            default:
                System.out.println("输入的数字不在1到7之间");
                break;
        }


    }

    /**
     * jdk14 引入的新写法
     *
     * @param dayOfWeek
     */
    private static void extracted1(int dayOfWeek) {
        switch (dayOfWeek) {
            case 1 -> System.out.println("今天是星期一");
            case 2 -> System.out.println("今天是星期二");
            case 3 -> System.out.println("今天是星期三");
            case 4 -> System.out.println("今天是星期四");
            case 5 -> System.out.println("今天是星期五");
            case 6 -> System.out.println("今天是星期六");
            case 7 -> System.out.println("今天是星期七");
            default -> System.out.println("异常");
        }
    }

    /**
     * jdk17 增强
     *
     * @param dayOfWeek
     */
    private static void extracted2(int dayOfWeek) {
        switch (dayOfWeek) {
            case 1, 2, 3, 6 -> System.out.println("今天是星期一");
            default -> System.out.println("异常");
        }

        switch (dayOfWeek) {
            case 1, 2, 3, 6 -> {
                System.out.println(2555);
                // 支持 方法块
                extracted1(dayOfWeek);
            }
            default -> System.out.println("异常");
        }
    }

    /**
     * jdk17 引入的新写法
     *
     * @param o
     */
    private static String extracted3(Object o) {
        return switch (o) {
            case null -> "o is null ";
            case Integer i -> String.format("Integer i : %s", i);
            default -> o.toString();
        };
    }
    /**
     * private static String extracted3(Object o) { ... }：这是一个静态方法 extracted3，它接受一个 Object 类型的参数 o 并返回一个 String。
     * return switch (o) { ... };：这里使用 switch 表达式来决定返回哪个字符串。switch 表达式在这里用作返回值，这与传统的 switch 语句不同，后者不能直接返回值。
     * case null -> "o is null ";：如果传入的参数 o 是 null，则 switch 表达式返回 "o is null "。
     * case Integer i -> String.format("Integer i : %s", i);：如果传入的参数 o 是 Integer 类型，则 switch 表达式将其解包为一个名为 i 的 Integer 对象，并返回格式化的字符串 "Integer i : " + i.toString()。
     * default -> o.toString();：如果传入的参数 o 不匹配上述任何情况，则 switch 表达式返回 o 的字符串表示形式。
     */

}

优点：大大开发了，我们开发的效率，可阅读性增强

新特性2：instanceof

package jdktest;

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark");
    }
}

/**
 * instanceof 增强
 */
public class InstanceOfExample {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 创建 Dog 对象，但将其赋值给 Animal 类型的引用

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is a Dog");
            // 由于 myAnimal 确实是 Dog 的实例，我们可以安全地进行向下转型
            Dog myDog = (Dog) myAnimal;
            myDog.makeSound(); // 输出 "Bark"
        } else {
            System.out.println("myAnimal is not a Dog");
        }

        Object o = 1;

        if (o instanceof Integer i) {
            System.out.println(i.intValue());
        }
    }
}

新特性3:密封类 Sealed Classes(限制继承类)，用来修饰父类、接口上

定义四个类

People、Man、Woman 、Dog

public sealed class People permits Man ,Woman{
}
public final class Man extends People {
}
public non-sealed class Woman extends People {
}

Dog 类继承People就会报错

//public class Dog extends People{
//}

注意点：

1.父类必须使用sealed 和 permits 关键字

2.子类必须使用 final 或 non-sealed

3.final: 无法再被子类继承

4. non-sealed 可以再被子类继承

5.相关类必须在同一个包中

优点：安全，限制了继承。可控，只有当前包中的类可用。

新特性5 Record类（类似lombok的属性只读对象）

特点

不可变性：record 类是隐式不可变的，这意味着一旦创建了 record 实例，其状态就不能更改。
简洁性：与传统的 Java 类相比，声明 record 类需要更少的代码。
自动实现：record 类会自动为所有声明的组件生成构造器、访问器（getter）、equals()、hashCode() 和 toString() 方法。
组件声明：record 类通过声明一个或多个组件来定义其状态。这些组件就像是类的字段，但不需要显式声明为字段。
紧凑的声明方式：record 类的声明看起来像是创建一个实例，组件名在 record 关键字之后列出。

public record RecordExampleBean(String name, String year) {
}

public class RecordExample {

    public static void main(String[] args) {
        RecordExampleBean bean = new RecordExampleBean("1", "d");
        RecordExampleBean bean1 = new RecordExampleBean("1", "d");
        RecordExampleBean bean2 = new RecordExampleBean("3", "d");
        bean.name();
        bean.year();
        boolean equals = bean.equals(bean1);// true
        boolean equals1 = bean1.equals(bean2);// false
        System.out.println(equals);
        System.out.println(equals1);

    }

}

record类能实现接口吗？

import java.util.Comparator;

public record Person(String name, int age) implements Comparable<Person> {
@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age);
}
}

public class RecordInterfaceExample {
public static void main(String[] args) {
Person person1 = new Person("张三", 30);
Person person2 = new Person("李四", 25);

int comparisonResult = person1.compareTo(person2);
System.out.println("比较结果：" + comparisonResult);
}
}

在这个例子中，Person 是一个 record 类，它实现了 Comparable 接口。实现 Comparable 接口的 record 类必须提供一个 compareTo 方法，用于比较两个对象的大小。在这个例子中，我们根据年龄来比较两个 Person 对象。

需要注意的是，record 类不能有实例字段，只能有组件。因此，实现接口时，如果接口需要实例字段，record 类将无法直接实现该接口。但是，如果接口只依赖于类的方法，record 类可以轻松地实现它。

【注意】record 使用场景有限