首页手记 JDK17新特性资料：初学者必看教程

JDK17新特性资料：初学者必看教程

标签：

Java

概述

JDK17作为Java开发工具包的第17个长期支持版本，带来了多项增强和新特性，包括强制性引用、模块化系统增强、静态变量和静态方法的封装以及移除NestMates注解。这些改进不仅增强了代码的安全性和可维护性，还提高了开发效率和应用性能。通过这些新特性，开发者能够更好地组织和管理代码，提供更稳定的开发环境。JDK17新特性资料详细介绍了这些改进及其应用。

引入JDK17

JDK17简介

JDK17是Java开发工具包（Java Development Kit，JDK）的第17个长期支持（Long Term Support，LTS）版本。它于2021年9月发布，是继JDK11之后的下一个主要的长期支持版本。JDK17延续了Java社区对稳定性和性能的关注，提供了一系列新的语言特性和改进，增强了开发者的体验。JDK17的发布标志着Java平台在长期支持版本中的迭代，保证了对重要特性和安全性的支持，同时也为开发者提供了稳定的开发环境。

重要更新概述

JDK17引入了一系列新的特性和改进，包括：

强制性引用（Sealed Classes）：引入了密封类的概念，使得类的继承关系更加严格，有助于代码的模块化和安全性。
模块化系统增强：进一步增强了Java模块系统，使得应用开发更加灵活和高效。
移除NestMates注解：NestMates注解在JDK17中被移除，进一步简化了类的访问控制。
静态变量和静态方法的封装：改进了对静态变量和静态方法的封装方法，使得代码更加安全和易维护。
其他增强：包括改进的垃圾回收器、增强的工具和改进的性能等。

这些特性不仅增强了代码的安全性和可维护性，还提高了开发效率和应用的运行性能。

代码示例：强制性引用

// 定义一个密封类，仅允许特定的子类继承
public sealed class BaseClass permits ChildClass1, ChildClass2 {
    public void baseMethod() {
        System.out.println("This is a method in BaseClass.");
    }
}

// 定义ChildClass1，它是BaseClass的子类
public final class ChildClass1 extends BaseClass {
    public void childMethod() {
        System.out.println("This is a method in ChildClass1.");
    }
}

// 定义ChildClass2，它是BaseClass的子类
public final class ChildClass2 extends BaseClass {
    public void childMethod() {
        System.out.println("This is a method in ChildClass2.");
    }
}

// 尝试创建一个非法的子类，会报编译错误
// public class ChildClass3 extends BaseClass { }

代码示例：模块化系统增强

module my.module {
    requires java.base;
    requires java.logging;
    requires java.xml;
    requires jakarta.servlet.*; // 使用通配符指定依赖
}

module my.module {
    requires jakarta.servlet.api;
    requires jakarta.servlet.api.version;
}

代码示例：移除NestMates注解

public class ExampleClass {
    private static int privateField = 10;

    public static int getPrivateField() {
        return privateField;
    }

    public static void setPrivateField(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Value cannot be negative");
        }
        privateField = value;
    }
}

代码示例：静态变量和静态方法的封装

public class ExampleClass {
    private static int staticVariable = 0; // 定义静态变量

    // 定义getter方法
    public static int getStaticVariable() {
        return staticVariable;
    }

    // 定义setter方法
    public static void setStaticVariable(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Static variable cannot be negative");
        }
        staticVariable = value;
    }
}

public class Main {
    public static void main(String[] args) {
        // 访问静态变量
        System.out.println(ExampleClass.getStaticVariable()); // 输出：0

        // 设置静态变量
        ExampleClass.setStaticVariable(10);
        System.out.println(ExampleClass.getStaticVariable()); // 输出：10

        // 尝试设置非法值
        try {
            ExampleClass.setStaticVariable(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("Failed to set static variable with invalid value: " + e.getMessage());
        }
    }
}

强制性引用的使用

什么是强制性引用

强制性引用（Sealed Classes）是Java 16引入的一个特性，在JDK17中继续得到支持。其主要功能是限制类的继承关系，允许一个类指定一组特定的子类可以继承它，而其他类无法继承它。这一特性能够帮助开发者更好地控制类的继承层次，提高代码的安全性和模块化。

从语法上来说，强制性引用通过在类声明中使用sealed关键字来实现。sealed关键字表明该类仅允许特定的子类继承，这有助于解决多继承带来的复杂性和不确定性。

如何使用强制性引用

为了更好地理解强制性引用的使用，我们通过一个简单的示例来演示如何限制类的继承。以下是一个具体的案例：

// 定义一个密封类，仅允许特定的子类继承
public sealed class BaseClass permits ChildClass1, ChildClass2 {
    public void baseMethod() {
        System.out.println("This is a method in BaseClass.");
    }
}

// 定义ChildClass1，它是BaseClass的子类
public final class ChildClass1 extends BaseClass {
    public void childMethod() {
        System.out.println("This is a method in ChildClass1.");
    }
}

// 定义ChildClass2，它是BaseClass的子类
public final class ChildClass2 extends BaseClass {
    public void childMethod() {
        System.out.println("This is a method in ChildClass2.");
    }
}

// 尝试创建一个非法的子类，会报编译错误
// public class ChildClass3 extends BaseClass { }

在以上代码中，我们定义了一个BaseClass，它是一个密封类，只允许ChildClass1和ChildClass2继承它。任何其他试图继承BaseClass的类（如ChildClass3）都会导致编译错误。这样的设计使得类的继承关系更加明确和可控。

模块化系统增强

模块化系统简介

Java模块系统（Java Platform Module System，JPMS）引入于Java 9，是Java平台的一个重要改进。模块化系统通过定义模块（module）来封装代码和资源，使得Java程序能够更好地组织和管理代码，从而提高开发效率和代码的安全性。每个模块都定义了一组类、接口和资源文件，这些模块之间可以通过依赖关系进行交互。

模块化系统的核心组件包括模块声明文件（module-info.java）、模块描述符（module-info）和模块路径（--module-path）。通过这些组件，开发者可以更清晰地定义模块间的依赖关系，使得整个程序的结构更加清晰、易于维护。

新特性介绍与使用

JDK17在Java模块系统的基础上引入了一些新的特性，进一步增强了模块化编程的能力。

更灵活的依赖管理

JDK17允许开发者在模块声明中使用通配符来指定依赖。例如：

module my.module {
    requires java.base;
    requires java.logging;
    requires java.xml;
    requires jakarta.servlet.*; // 使用通配符指定依赖
}

通过使用通配符，可以简化对多个相关模块的引用，减少代码的复杂性。这种方式使得依赖管理更加灵活和高效。

更精确的版本控制

JDK17引入了更加精确的版本控制机制，允许开发者指定模块的版本。这有助于解决依赖冲突和版本兼容性问题。例如：

module my.module {
    requires jakarta.servlet.api;
    requires jakarta.servlet.api.version;
}

通过指定模块的版本，可以确保应用程序使用的是已知版本的依赖模块，从而避免潜在的不兼容问题。

更强大的反射支持

JDK17提高了反射功能在模块化系统中的使用。开发者可以在模块声明中明确指定反射访问权限：

module my.module {
    exports com.example.my.module;
    opens com.example.my.module to java.base;
}

上述代码中，通过exports关键字定义了模块的导出包，并通过opens关键字允许特定模块访问该包的内部类。这样的设计使得反射操作更加安全和可控。

更高效的类加载

JDK17通过优化类加载机制，提高了模块化系统的运行效率。新的类加载器设计使得模块间的类加载更加高效，减少了加载时间。例如，通过模块路径（module-path）指定模块位置：

java --module-path /path/to/modules --add-modules my.module

这种方式使得类加载过程更加高效，提升了程序的启动速度和运行效率。

示例代码

为了更好地展示模块化系统的使用，以下是一个简单的示例：

// 定义模块声明文件 module-info.java
module com.example.my.module {
    requires java.base;
    requires java.logging;
    exports com.example.my.module;
    opens com.example.my.module to java.base;
}

// 定义一个简单的模块类
package com.example.my.module;

public class ExampleModule {
    public void printMessage() {
        System.out.println("This is a module class in com.example.my.module.");
    }
}

在这个示例中，我们定义了一个模块声明文件module-info.java，指定了模块的依赖关系和导出包。同时，定义了一个简单的模块类ExampleModule，展示了模块化系统的基本使用。

静态变量和静态方法的封装

为什么要封装静态变量和静态方法

封装静态变量和静态方法是面向对象编程中的一个重要概念，其主要目的是提高代码的安全性和可维护性。静态变量和静态方法属于类本身，而不是特定的对象实例，因此它们能够被类的所有实例共享。但是，不适当的访问和修改静态变量可能导致数据不一致和潜在的并发问题。

封装静态变量和静态方法可以通过提供公开的访问点（getter和setter方法）来实现，这些访问点可以提供额外的控制逻辑，确保静态变量的安全访问和修改。例如，可以通过setter方法进行输入验证，防止非法数据的写入；通过getter方法返回经过处理的数据，以保护内部实现细节。

封装静态变量和静态方法的方法

封装静态变量和静态方法的基本步骤如下：

定义静态变量：在类中定义静态变量，并将其声明为私有（private），以限制直接访问。
提供getter和setter方法：定义getter方法（如getStaticVariable()）来返回静态变量的值，定义setter方法（如setStaticVariable()）来设置静态变量的值，并在setter方法中添加必要的验证逻辑。

public class ExampleClass {
    private static int staticVariable = 0; // 定义静态变量

    // 定义getter方法
    public static int getStaticVariable() {
        return staticVariable;
    }

    // 定义setter方法
    public static void setStaticVariable(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Static variable cannot be negative");
        }
        staticVariable = value;
    }
}

优势

通过封装静态变量和静态方法，可以实现以下优势：

提高安全性：通过setter方法提供额外的验证逻辑，确保数据的安全性。
增强可维护性：通过getter和setter方法，可以在不修改类的其他部分的情况下，修改静态变量的访问和修改逻辑。
确保一致性：通过集中管理静态变量的访问，避免多个地方修改静态变量导致的数据不一致问题。

示例代码

以下是一个具体的示例，展示了如何封装静态变量和静态方法：

public class ExampleClass {
    private static int staticVariable = 0; // 定义静态变量

    // 定义getter方法
    public static int getStaticVariable() {
        return staticVariable;
    }

    // 定义setter方法
    public static void setStaticVariable(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Static variable cannot be negative");
        }
        staticVariable = value;
    }
}

public class Main {
    public static void main(String[] args) {
        // 访问静态变量
        System.out.println(ExampleClass.getStaticVariable()); // 输出：0

        // 设置静态变量
        ExampleClass.setStaticVariable(10);
        System.out.println(ExampleClass.getStaticVariable()); // 输出：10

        // 尝试设置非法值
        try {
            ExampleClass.setStaticVariable(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("Failed to set static variable with invalid value: " + e.getMessage());
        }
    }
}

在这个示例中，我们定义了一个ExampleClass类，其中包含一个静态变量staticVariable。通过getter方法getStaticVariable()获取静态变量的值，通过setter方法setStaticVariable(int value)设置静态变量的值，并在setter方法中添加了输入验证逻辑。这种方式确保了静态变量的安全访问和修改，避免了数据不一致和潜在的错误。

移除NestMates注解

NestMates注解的作用

NestMates注解是Java平台的一个内部注解，用于指定类之间的访问关系。它允许一个类访问另一个类的私有成员，即使这两个类不位于同一个包中。NestMates注解通常用于内部实现，让Java虚拟机（Java Virtual Machine，JVM）能够更好地管理类之间的访问权限。然而，它并不是公共API的一部分，开发者通常不会直接使用它。

示例代码

以下是一个使用NestMates注解的示例：

import java.lang.reflect.Modifier;

public class ExampleClass {
    private int privateField = 10;

    public static void main(String[] args) {
        boolean isPrivate = Modifier.isPrivate(ExampleClass.class.getDeclaredField("privateField").getModifiers());
        System.out.println("privateField is private: " + isPrivate); // 输出：privateField is private: true
    }
}

在这个示例中，我们定义了一个私有成员变量privateField。通过反射API（java.lang.reflect.Modifier）检查该变量的访问权限，确认它是私有的。

移除NestMates注解的原因

JDK17中移除了NestMates注解，主要是为了简化Java平台的内部实现和提高安全性。NestMates注解的存在使得类的访问控制更加复杂，容易引起混淆和误用。移除NestMates注解之后，Java平台的内部实现变得更加清晰，减少了潜在的复杂性和风险。

移除NestMates注解后的变化

移除NestMates注解后，Java平台会自动管理类之间的访问关系，不再需要显式的注解来控制访问权限。这种方式不仅简化了类的内部实现，还提高了代码的安全性和可维护性。

示例代码

以下是一个删除NestMates注解后的示例：

public class ExampleClass {
    private static int privateField = 10;

    public static int getPrivateField() {
        return privateField;
    }

    public static void setPrivateField(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Value cannot be negative");
        }
        privateField = value;
    }
}

public class Main {
    public static void main(String[] args) {
        // 访问静态变量
        System.out.println(ExampleClass.getPrivateField()); // 输出：10

        // 设置静态变量
        ExampleClass.setPrivateField(10);
        System.out.println(ExampleClass.getPrivateField()); // 输出：10

        // 尝试设置非法值
        try {
            ExampleClass.setPrivateField(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("Failed to set private field with invalid value: " + e.getMessage());
        }
    }
}

在这个示例中，我们直接定义了私有成员变量privateField，并使用反射API检查该变量的访问权限。这种方式更加简单和直观，不再需要额外的注解来控制类之间的访问关系。

总结与资源推荐

简短总结

JDK17带来了多项重要的语言特性和改进，包括强制性引用、模块化系统增强、静态变量和静态方法的封装以及NestMates注解的移除。这些特性不仅提高了代码的安全性和可维护性，还增强了Java平台的灵活性和性能。通过这些改进，开发者能够更好地组织和管理代码，提高开发效率和应用性能。

进一步学习的资源推荐

为了进一步学习和掌握JDK17的新特性，推荐以下资源：

官方文档：Java官方文档是了解新特性的最佳来源。开发者可以在Oracle官方网站上找到详细的文档和示例，深入了解各个特性的使用方法和最佳实践。
在线课程：慕课网（imooc.com）提供了丰富的Java课程，涵盖了从基础到高级的各种主题，适合不同水平的开发者学习。
社区支持：加入Java社区和论坛，如Stack Overflow、GitHub等，可以与其他开发者交流经验，获取问题解答和技术支持。
实践项目：通过实际项目的开发，可以更好地理解和应用新特性。建议开发者参与开源项目或自定义项目，实践所学知识。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

FFIVE

手记
篇

粉丝

70

获赞与收藏

459

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342495 3164

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

JDK17新特性资料：初学者必看教程

代码示例：强制性引用

代码示例：模块化系统增强

代码示例：移除NestMates注解

代码示例：静态变量和静态方法的封装

更灵活的依赖管理

更精确的版本控制

更强大的反射支持

更高效的类加载

示例代码

封装静态变量和静态方法的方法

优势

示例代码

示例代码

移除NestMates注解的原因

移除NestMates注解后的变化

示例代码

阅读免费教程