JDK17新增语法特征

Geboren zur Sonne

已于 2024-07-15 14:53:19 修改

阅读量2.5k

点赞数 39

分类专栏： JavaSE 文章标签： java 开发语言 jdk JDK17

于 2024-06-23 00:45:07 首次发布

本文链接：https://blog.csdn.net/2401_83595513/article/details/139888884

版权

JavaSE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1、引言

Spring Boot 3.0 开始不再支持 JDK 8，转而支持 JDK 17。

这篇博客我会列举较常用的新语法特性。

2、新增语法特征

2.1 yield关键字

从Java13开始引⼊yield关键字，yield关键字应用于switch语句中，我们可以使用yield来简化代码。

正常的switch语句代码：

public static void main(String[] args) {
        int value = 0;
        String flg = "three";
        switch (flg) {
            case "one":
                value = 1;
                break;
            case "two":
                value = 2;
                break;
            case "three":
                value = 3;
                break;
            default:
                value = -1;
                break;
        }
        System.out.println(value);
    }

使用 -> 来简化代码：

public static void main(String[] args) {
        String flg = "three";
        int value = switch (flg) {//使用 -> 来简化代码
            case "one" -> 1;
            case "two" -> 2;
            case "three" -> 3;
            default -> -1;
        };//注意这里要加;
        System.out.println(value);
    }

也可以使用yield来简化代码：

public static void main(String[] args) {
        String flg = "three";
        int value = switch (flg) {//使用yield关键字来简化代码
            case "one" : yield 1;
            case "two" : yield 2;
            case "three" : yield 3;
            default : yield -1;
        };//注意这里要加;
        System.out.println(value);
    }

2.2 var关键字

从Java10开始引⼊var关键字，var关键字的出现也是为了简化代码。

代码示例：

public static void main(String[] args) {
        var name = "dings";//Java会自动推导出name是String类型
        var age = 18;//Java会自动推导出age是int类型
        System.out.println(name+" "+age);
    }

编译器会通过所赋的值来自动推导出变量的类型。

需要注意一下几点：

1.var不能用来声明字段（成员变量）

2.var不能用来声明方法的参数

3.var不能用来声明方法的返回值类型

4.var声明的变量必须初始化，且不能初始化为null

2.3 sealed关键字（密封类）

在SE的学习中，我们已经知道，当类被final修饰时，这个类就变成了密封类，被final修饰的密封类不能再被任何类所继承。

在JDK17中，引入了sealed关键字，当类被sealed修饰时，也称作密封类，但是可以缩小密封的范围，在类的末尾通过permits来将这个密封类的继承权限开放给一些类，使得这个密封类可以被某些特定的类所继承。

sealed class A permits B,C,D {//将密封类的继承权限开放给B,C,D
    //sealed修饰的类必须要有子类
    //且这些子类必须被final修饰或被sealed修饰或者被non-sealed修饰
}
non-sealed class B extends A {//子类可以被non-sealed修饰，表示 不限制

}
final class C extends A {//子类可以被final修饰

}
sealed class D extends A {//子类也可以被sealed修饰，这个子类也成为了密封类，这个子类也必须再有子类

}
non-sealed class E extends D {//继承被sealed修饰的D

}

重点总结：

1.被sealed修饰的密封类通过permits来将继承权限开放给一些类（可以开放给多个类），如果没有写permits，那这个密封类就可以被任何类继承。

2.被sealed修饰的密封类必须要有子类。

3.这些子类必须被final修饰或被sealed修饰或者被non-sealed修饰。

4.被non-sealed修饰，表示不限制，可以被任何类继承，也可以不继承。

5.如果写了permits，那没有被permits允许的类，不能继承于这个密封类。

6.sealed和final的区别就是，sealed修饰的密封类必须要有子类。而final修饰的密封类必须没有子类。

2.4 接口中的私有方法

Java 8, 接口可以有默认方法。Java9之后，可以在接口内实现私有方法的实现，这个私有方法不

用被实现接口的类重写。（私有方法主要用于默认方法的使用）

代码示例：

interface A1 {
    void func1();
    default void func2() {//接口的默认方法
        System.out.println(1);
        func3();
    };//(课件这里加了; 我试了一下，加不加都可以)
    private void func3() {//接口的私有方法
        System.out.println(2);
    }
}
public class Demo implements A1{
    @Override
    public void func1() {

    }
    public static void main(String[] args) {
        
    }
}

2.5 instanceof关键字

在SE学习向下转型的时候，我们就用到了instanceof关键字，是这样使用的：

class Animal {
    public void eat() {

    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗在吃饭");
    }
    public void swim() {
        System.out.println("狗在游泳");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal animal = new Dog();
        if(animal instanceof Dog) {//判断animal引用的是否为Dog类
            Dog dog = (Dog)animal;
            dog.swim();
        }
    }
}

以前学习时，我们使用instanceof用来做三件事：

1.判断animal引用的是否为Dog类型的数据

2.如果是将animal为强转为Dog类型

3.创建一个Dog类的临时变量，将animal赋值给这个临时变量

在JDK16中，对instanceof进行了优化，使得代码更加的简洁：

public static void main(String[] args) {
        Animal animal = new Dog();
        if(animal instanceof Dog dog) {//判断animal引用的是否为Dog类，如果是创建临时变量dog
            dog.swim();
        }
    }