Java 新特性探索：从 JDK9 到 JDK17 的关键改进与示例代码

JDK 新特性

JDK9

jshell 交互式工具

• 引入了一个交互式的编程工具，可以在命令行中(cmd)直接执行和测试 Java 代码片段。

// 示例1：在jshell中执行简单的Java代码
jshell> int a = 10;
a ==> 10
 
jshell> int b = 20;
b ==> 20
 
jshell> int sum = a + b;
sum ==> 30
 
// 示例2：定义一个简单的方法
jshell> void greet(String name) {
   ...>     System.out.println("Hello, " + name + "!");
   ...> }
|  created method greet(String)
 
jshell> greet("Alice");
Hello, Alice!
 
jshell> greet("Bob");
Hello, Bob!

模块化开发

• 引入了模块系统，将代码划分为模块，以提高可维护性、安全性和性能。

JDK10

var 局部变量推导

• 引入了 var 关键字，可以根据初始化值的类型自动推导出变量的类型。

// 示例1：使用var进行局部变量推导
var message = "Hello, World!";
System.out.println(message);
 
// 示例2：与集合框架一起使用
var numbers = List.of(1, 2, 3, 4, 5);
for (var number : numbers) {
    System.out.println(number);
}
 
// 示例3：与Lambda表达式一起使用
var runnable = (Runnable) () -> {
    System.out.println("Running...");
};
runnable.run();

JDK11

单文件程序

• 可以直接在命令行中运行单个 Java 源文件，无需显式地编译为字节码文件。

• 可在【命令行工具】，直接运行 java 文件，例如 java TestB. java

• 注意：无法识别 import 语句，需要先删除再执行运行语句

// 示例：直接运行单个Java源文件
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
 
// 在命令行中执行以下命令
java HelloWorld.java

shebang 脚本

• 支持在 Java 源文件中使用 shebang（#!）来指定解释器，使得 Java 程序可以像脚本一样直接执行。

• #! 符号叫做 shebang，可音译成：释伴，解释伴随行。

• #i/bin/bash 以此开头的文件，在执行时会实际调用 /bin/bash 程序来执行

JDK14

instanceof 增强

• 增强了 instanceof 运算符，使其可以在【条件表达式】中直接获取转换后的类型。

// 示例：使用instanceof判断对象类型
Object obj = "Hello";
 
if (obj instanceof String str) { // 这里相当于将 obj 赋值给了 str
    System.out.println("Length: " + str.length());
} else {
    System.out.println("Not a string");
}

空指针提示

• 报空指针异常时，会具体到显示是哪个变量为 null，而 JDK8 的只会显示哪一行报空指针异常。

JDK16

record 类

• 引入了 record 关键字，可以更方便地定义不可变的数据类，自动生成常用方法如 构造函数、equals、hashCode 等。

// 示例：定义一个record类
record Person(String name, int age) {}
 
// 创建一个Person对象
Person person = new Person("Alice", 25);
 
// 访问record类的属性
System.out.println(person.name());
System.out.println(person.age());

JDK17

sealed 类

• 引入了 sealed 关键字，用于限制哪些类可以继承或实现某个类或接口，增强了类的封装性和安全性。

核心关键字含义：

1. sealed：sealed 是 Java 17 引入的关键字，用于修饰类或接口。当一个类或接口被声明为 sealed 时，它的子类或实现类必须显式地声明在 permits 子句中，否则无法继承或实现该类或接口。
2. non-sealed：non-sealed 是与 sealed 相对的概念。当一个类或接口声明为 non-sealed 时，它可以被任意类或接口继承或实现，而不需要显式地声明在 permits 子句中。
3. final：被 final 修饰的类不可继承，即不能有子类。
4. permits：permits 是 sealed 关键字后的一个子句，用于指定允许继承或实现的类或接口。在 permits 子句中列出的类或接口是被允许继承或实现 sealed 类或接口的类或接口。

以下是一个简单的代码示例：

// 定义一个 sealed 类
sealed class Shape permits Circle, Rectangle, Triangle {
    abstract double area();
}
 
// 定义 Circle 类作为 Shape 的子类
final class Circle extends Shape {
    private final double radius;
 
    Circle(double radius) {
        this.radius = radius;
    }
 
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}
 
// 定义 Rectangle 类作为 Shape 的子类
final class Rectangle extends Shape {
    private final double length;
    private final double width;
 
    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
 
    @Override
    double area() {
        return length * width;
    }
}
 
// 定义 Triangle 类作为 Shape 的子类
final class Triangle extends Shape {
    private final double base;
    private final double height;
 
    Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
 
    @Override
    double area() {
        return 0.5 * base * height;
    }
}
 
public class SealedClassExample {
    public static void main(String[] args) {
        // 创建不同形状的对象并计算面积
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);
        Shape triangle = new Triangle(3.0, 8.0);
 
        System.out.println("Circle Area: " + circle.area());
        System.out.println("Rectangle Area: " + rectangle.area());
        System.out.println("Triangle Area: " + triangle.area());
    }
}
 

代码解释：

在这个示例中，Shape 类被声明为 sealed 类，并且明确声明了允许的子类（Circle、Rectangle、Triangle）。这样的设计可以更好地控制类的继承关系，并提高代码的可维护性。

switch 模式匹配

JDK 17 引入了一种新的 switch 语句的模式匹配功能，它允许在 switch 语句中使用模式来进行更灵活的匹配。这种模式匹配的语法使得在 switch 语句中处理复杂的条件逻辑更加简洁和易读。

以下是一个示例代码：

public class PatternMatchingSwitch {
 
    public static void main(String[] args) {
        Object value = "Hello";
 
        // 在 switch 表达式中使用模式匹配
        String result = switchExpressionExample(value);
        System.out.println(result);
    }
 
    private static String switchExpressionExample(Object value) {
        return switch (value) {
            case String s -> "It's a String: " + s.length();
            case Integer i && (i > 0) -> "It's a positive Integer: " + i;
            case Integer i && (i < 0) -> "It's a negative Integer: " + i;
            case Double d -> "It's a Double: " + d;
            default -> "Unknown type";
        };
    }
}

代码解释

• 在这个示例中，使用了不同的模式来匹配不同的对象类型和条件。
• 这包括字符串长度、正整数、负整数和双精度浮点数。
• 使用模式匹配可以使代码更加清晰和简洁。