jdk17新特性

最新推荐文章于 2025-04-23 19:44:45 发布

GzlAndy

最新推荐文章于 2025-04-23 19:44:45 发布

阅读量1k

点赞数 19

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/GzlAndy/article/details/145796234

版权

java 专栏收录该内容

14 篇文章

订阅专栏

2.4.4 exports和open声明对外的API

2.6.2 Shenandoah垃圾回收器正式纳入jdk中

1 语法层面

1.1 文本块

文本块指的是多行字符串
使用连续的三个引号来包围一段多行的字符串
避免了换行转义的麻烦
支持String.format

public class App {
    public static void main(String[] args) {
        String str = """
                this is mutil string
                i name is %s 
                please see it
                """;
        System.out.println(String.format(str,"tom"));
    }
}

1.2 switch表达式增强

支持表达式使用
多条件匹配

public class App {
    public static void main(String[] args) {
      String name = "James1";
      switch (name){
          case "James","libai" -> System.out.println("Hello "+name);
          case "John","qiongsi" -> System.out.println("Hello1 "+name);
          default -> System.out.println("Hello3 "+name);
      }
    }
}

使用yield关键字增加返回值

public class App {
    public static void main(String[] args) {
        String name = "James1";
        int a = switch (name) {
            case "James", "libai" -> {
                System.out.println("Hello " + name);
                yield 1;
            }
            case "John", "qiongsi" -> {
                System.out.println("Hello1 " + name);
                yield 2;
            }
            default -> {
                System.out.println("Hello3 " + name);
                yield 4;
            }
        };
        System.out.println(a);
    }
}

1.3 instanceof的匹配模式

当变量类型经过instanceof匹配目标类型时，可直接声明目标类型变量，无需要再次强转

public class App {
    public static void main(String[] args) {
        Object a = "123";
        if (a instanceof Integer i) {
            System.out.println(i.longValue());
        } else if (a instanceof String s) {
            System.out.println(s.charAt(1));
        }
    }
}

1.4 var局部变量推导

对于可以推导出其具体类型的局部变量，可使var修饰

public class App {
    public static void main(String[] args) {
        var s = "123";
        System.out.println(s.charAt(1));
    }
}

2 模块化以及类封装

2.1 记录类record

被record定义的类代表不可变的常量
只能在创建时指定类的属性，不能再次修改

public record Person(String name, Integer age) {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        System.out.println(person);
        System.out.println(person.age());
        System.out.println(person.name());
    }
}

反射也不能修改record类的属性，因为record类给所有属性加上了final修饰符

2.2 隐藏类Hidden Class

不能被其他类直接使用的类
隐藏类不再依赖于类加载器
通过读取目标字节码的方式，创建一个对其他类隐藏的class对象
然后通过反射的方式创建对象，调用方法

public class App {
    private static String encode() throws IOException {
        String classPath="C:\\jwork\\jdk17demo\\target\\classes\\com\\demo\\HiddenClass.class";
        byte[] bytes = Files.readAllBytes(Paths.get(classPath));
        return new String(Base64.getEncoder().encode(bytes));
    }
    public static void main(String[] args) throws Throwable {
        String encode = encode();
        byte[] decode = Base64.getDecoder().decode(encode);
        MethodHandles.Lookup lookup = MethodHandles.lookup().defineHiddenClass(decode,
                true, MethodHandles.Lookup.ClassOption.NESTMATE);
        Class<?> aClass = lookup.lookupClass();

        //获取类名
        System.out.println(aClass.getName());
        //获取所有方法
        for (Method declaredMethod : aClass.getDeclaredMethods()) {
            System.out.println(declaredMethod.getName());
        }
        //调用静态方法
        MethodHandle printHello = lookup.findStatic(aClass, "printHello", MethodType.methodType(void.class, String.class));
        printHello.invokeExact("小明");
        printHello.invoke("小明");
        //创建实例
        MethodHandle newInstance = lookup.findConstructor(aClass, MethodType.methodType(void.class));
        Object invoke = newInstance.invoke();
        System.out.println(invoke);
        //调用实例方法
        MethodHandle sayHello = lookup.findVirtual(aClass, "sayHello", MethodType.methodType(void.class, String.class));
        sayHello.invoke(invoke,"小明");
    }
}

其中加密的方式可自由掌控，从而达到真实隐藏类的目的

2.3 密封类 Sealed Class

jdk8中一个类要么可以被继承，要么不可以被继承（final修饰）
jdk17中可以指定允许哪些类继承
sealed：表示类具有密封性，必须具有子类，通过permits执行允许继承的子类
non-sealed：表示类不具备密封性，可随意集成
final：表示类不能被继承

public sealed abstract class Shape permits Circle, Rectangle, Square {
    public abstract int lines();
}
public final class Circle  extends Shape{
    @Override
    public int lines() {
        return 0;
    }
}
public non-sealed class Square  extends Shape{
    @Override
    public int lines() {
        return 0;
    }
}
public sealed class Rectangle extends Shape permits  FilledRectangle{
    @Override
    public int lines() {
        return 0;
    }
}
public final class FilledRectangle extends Rectangle{
}

2.4 模块化Module System

2.4.1 什么是模块化

jdk9引入模块化机制
对java中package包的上一层抽象
包含一组密切相关的包，资源，以及一个模块描述文件
通过module，可以更精准的分配对象的生效范围

jdk8安装目录下，jdk内置的功能是以jar包的形式存在的
jdk17安装目录下，取而代之的是一系列以jmod后缀的文件，一个文件代表一个模块

jmod文件其实就是一个tar包

查看jdk的模块列表

2.4.2 声明一个module

在模块的class根目录下创建module-info.java⽂件声明模块
默认情况下以项目名作为模块名
module-info.java⽂件称之为模块描述文件
在module-info.java⽂件内主要包含如下内容
- 模块名
- 对其他module的依赖关系
- 当前module对外开放的API
- 使用和提供的服务