Java 22 和 IntelliJ IDEA

Sue

Read this post in other languages:

• English

Java 22 现已正式发布，IntelliJ IDEA 2024.1 全面支持该版本，您可以使用其中的新功能！

从新手开发者到 Java 专家，从寻求性能和安全功能的大型组织到尖端技术爱好者，从 Java 语言的新特性到 JVM 平台的改进，Java 22 可以满足各种群体的各类需求。

这些 Java 功能在一个又一个版本发布后良好配合，创造出更多可能，深度助力开发者创建解决现有痛点、更强劲且更安全的应用程序。

本博文并未覆盖所有 Java 22 功能。 如果您有兴趣，我建议查看此链接，详细了解 Java 22 中的新增内容和变化，包括 bug。

在这篇博文中，我将介绍 IntelliJ IDEA 如何帮助您上手、启动和运行 Java 22 功能，例如字符串模板、隐式声明的类与实例 main 方法、super() 之前的语句，以及未命名变量和模式。

过去一个月，我发布了多篇博文分别详细介绍了每个主题。 如果您不熟悉这些主题，我强烈建议阅读这些详细的博文（我在这篇博文的相应小节中附上了链接）。 在这篇博文中，我将提及先前博文中的一些部分，特别是 IntelliJ IDEA 如何支持这些功能。 首先，我们将 IntelliJ IDEA 配置为使用 Java 22 功能。

IntelliJ IDEA 配置

配置完成，我们从我最喜欢的新功能之一“字符串模板”开始。

字符串模板（预览语言功能）

IntelliJ IDEA 能够高亮显示可被替换为字符串模板的代码

假设您定义了以下代码，记录一条使用串联运算符组合字符串文字和变量值的消息：

public void processOrder(int orderId, String product, int qty, LocalDate orderDate) {
   if (quantity <= 0) {
       String errorMessage = "Invalid order quantity: " + qty + " for product " + product + ", order ID " + orderId;
       logger.error(errorMessage);
       return;
   }
   //.. Remaining code
}

字符串模板和 IntelliJ IDEA 中的嵌入式表达式

将字符串模板与文本块结合使用

语言注入和字符串模板

您可以查看此链接，详细了解 IntelliJ IDEA 中注入语言或引用的好处和用法。

预定义模板处理器

自定义模板处理器

让我们使用先前博文中未涉及的自定义字符串模板。假设您想要创建一个记录实例，例如 WeatherData，存储上一节中使用的 JSON 的详细信息。

假设您定义以下记录来存储由上一节中的 JSON 表示的天气数据：

public record WeatherData (String cod, City city) { }
public record City (int id, String name, String country, Coord coord) {}
public record Coord (double lat, double lon) { }

您可以创建一个方法返回自定义字符串模板来处理内插字符串、接受类名（本例中为 WeatherData）并返回其实例：

public <T> StringTemplate.Processor<T, RuntimeException> getJSONProcessorFor(Class<T> classType) {
        return StringTemplate.Processor.of(
                (StringTemplate st) -> {

                    List<Object> sanitizedLst = new ArrayList<>();
                    for (Object templateExpression : st.values()) {
                        switch (templateExpression) {
                            case String str -> sanitizeStr(str, sanitizedLst);
                            case Number _, Boolean _ -> sanitizedLst.add(templateExpression);
                            case null -> sanitizedLst.add("");
                            default -> throw new IllegalArgumentException("Invalid value");
                        }
                    }
                    String jsonSource = StringTemplate.interpolate(st.fragments(), sanitizedLst);
                    System.out.println(jsonSource);

                    try {
                        ObjectMapper objectMapper = new ObjectMapper();
                        return objectMapper.readValue(jsonSource, classType);
                    } catch (JsonProcessingException e) {
                        throw new RuntimeException(e);
                    }
                });
    }

根据应用程序的逻辑，您可能希望对在通过模板表达式内插的 JSON 值中遇到的特殊字符进行转义、将其删除或抛出错误，如下所示（以下方法选择转义特殊字符并将其作为 JSON 值的一部分包含在内）：

    private void sanitizeStr(String str, List<Object> sanitizedLst) {
        String sanitizedStr = str.replace("\\", "\\\\")
                                 .replace("\"", "\\\"")
                                 .replace("/", "\\/")
                                 .replace("\b", "\\b")
                                 .replace("\f", "\\f")
                                 .replace("\n", "\\n")
                                 .replace("\r", "\\r")
                                 .replace("\t", "\\t");
        sanitizedLst.add("\"" + sanitizedStr + "\"");
    }

您可以初始化并使用此自定义 JSON 模板处理器，如下所示。 可以看到，文本块和字符串模板的组合使解决方案相当优雅简洁。 JSON 易于阅读、编写和理解（得益于文本块）。 模板表达式使非常量且将由变量注入的部分清晰明了。 最后，自定义模板处理器 WEATHER_JSON 将确保生成的 JSON 根据您定义的逻辑得到验证，并返回 WeatherData 的实例（听起来是不是很神奇？） ：

StringTemplate.Processor<WeatherData, RuntimeException> WEATHER_JSON = getJSONProcessorFor(WeatherData.class);

String cod = null;
String name = "Amazing City";
Double lat = 55.7522;
    
WeatherData weatherData = WEATHER_JSON."""
                  {
                    "cod": \{cod},
                    "city": {
                      "id": 524901,,,
                      "name": \{name},
                      "country": "XYZ",
                      "coord": {
                        "lat": \{lat},
                        "lon": 37.6156
                      }
                    }
                  }""";

隐式声明的类与实例 main 方法（预览语言功能）

Java 21 之前和之后的 ‘HelloWorld’ 类

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

void main() {
    System.out.println("Hello World");
}

编译和执行代码

编写完代码后，下一步就是执行。

C:\code\MyHelloWorldProject\javac HelloWorld.java
C:\code\MyHelloWorldProject\java HelloWorld

C:\code\MyHelloWorldProject\java HelloWorld.java

但是，由于实例 main 方法和隐式类为预览语言功能，您应该使用这些命令添加标记 --enable-preview 和 --source 22，如下所示：

C:\code\MyHelloWorldProject\java --enable-preview --source 22 HelloWorld.java

除了将消息打印到控制台之外，main() 还能做什么？

• • 示例 1.
    变量声明、赋值和简单计算
  • 示例 2.
    打印模式，例如使用指定字符的大字母
  • 示例 3.
    为多行文本添加动画 – 一次一个单词
  • 示例 4.
    数据结构问题
  • 示例 5.
    基于文本的 Hangman 游戏

将隐式类改为常规类

使用 main() 方法创建源代码文件但没有类声明时会发生什么？

隐式类中 main 方法的变体

众所周知，方法可以被重载。 这是否意味着隐式类可以定义多个 main 方法？ 如果答案是肯定的，那么哪一个有资格作为主要的 main 方法？这是一个有趣的问题。 首先，请注意，您不能定义具有相同签名（即具有相同方法形参）的 static 和非 static main 方法。 以下方法被视为隐式类中有效的 main() 方法：

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

如果没有检测到有效的 main 方法，IntelliJ IDEA 可以为您添加一个，如以下 gif 所示：

教育工作者可以使用此功能向学生逐步介绍其他概念

super() 之前的语句 – 预览语言功能

示例 – 在派生类构造函数中验证传递给 super() 的值

public class Element {
   int atomicNumber;
   Color color;

   public Element(int atomicNumber, Color color) {
       if (color == null)
           throw new IllegalArgumentException("color is null");
       this.atomicNumber = atomicNumber;
       this.color = color;
   }
    // rest of the code
}

public class IndustryElement extends Element{
   private static final int MIN_ATOMIC_NUMBER = 1;
   private static final int MAX_ATOMIC_NUMBER = 118;
  
   public IndustryElement(int atomicNumber, Color color) {
       super(checkRange(atomicNumber, MIN_ATOMIC_NUMBER , MAX_ATOMIC_NUMBER), color);
   }

   private static int checkRange(int value, int lowerBound, int upperBound) {
       if (value < lowerBound || value > upperBound)
           throw new IllegalArgumentException("Atomic number out of range");
       return value;
   }
}

从 Java 22 开始，您可以在派生类的构造函数中内联 static 方法的内容，如以下 gif 所示：

这是生成的代码：

public class IndustryElement extends Element{
    private static final int MIN_ATOMIC_NUMBER = 1;
    private static final int MAX_ATOMIC_NUMBER = 118;

    public IndustryElement(int atomicNumber, Color color) {
        if (atomicNumber < MIN_ATOMIC_NUMBER || atomicNumber > MAX_ATOMIC_NUMBER)
            throw new IllegalArgumentException("Atomic number out of range");
        super(atomicNumber, color);
    }
}

您还会在哪里使用此功能？

• • • 示例 2 – 使用注解进行验证的基类构造函数形参
    • 示例 3 – 在调用基类构造函数之前，转换派生类构造函数中接收的变量值。
    • 示例 4 – 在 Records 的构造函数中于 this() 之前执行语句
    • 示例 5 – 在 Enum 构造函数中于 this() 之前执行语句
    • 示例 6 – 在类中于 this() 之前执行语句

它在后台是如何运作的？

javap -c IndustryElement.class

https://docs.oracle.com/javase/specs/jvms/se21/html/jvms-6.html#jvms-6.5.aload_n

在调用 super() 之前可以执行“任何”语句吗？

未命名变量和模式

IntelliJ IDEA 配置

一个快速示例

switch 构造中的未使用模式和模式变量

sealed interface GeometricShape {}
record Point   ( int x,
                 int y)         implements GeometricShape { }
record Line    ( Point start,
                 Point end)     implements GeometricShape { }
record Triangle( Point pointA,
                 Point pointB,
                 Point PointC)  implements GeometricShape { }
record Square  ( Point pointA,
                 Point pointB,
                 Point PointC,
                 Point pointD)  implements GeometricShape { }

int calcArea(GeometricShape figure) {
    return switch (figure) {
        case Point    (int x, int y)                        -> 0;
        case Line     (Point a, Point b)                    -> 0;
        case Triangle (Point a, Point b, Point c)           -> areaTriangle(a, b, c);
        case Square   (Point a, Point b, Point c, Point d)  -> areaSquare  (a, b, c, d);
    };
}

int calcArea(GeometricShape figure) {
    return switch (figure) {
        case Point _, Line _                                -> 0;  
        case Triangle (Point a, Point b, Point c)           -> areaTriangle(a, b, c);
        case Square   (Point a, Point b, Point c, Point d)  -> areaSquare  (a, b, c, d);
    };
}

未使用的模式或变量和嵌套记录

对于具有多个未使用模式或模式变量的嵌套记录，此功能也非常方便，如以下示例代码所示：

record Name       (String fName, String lName) { }
record PhoneNumber(String areaCode, String number) { }
record Country    (String countryCode, String countryName) { }
record Passenger  (Name name,
                   PhoneNumber phoneNumber,
                   Country from,
                   Country destination) { }

public class GeoMaps {
    boolean checkFirstNameAndCountryCodeAgain (Object obj) {
        if (obj instanceof Passenger(Name (String fName, _),
                                     _,
                                     _,
                                     Country (String countryCode, _) )) {

            if (fName != null && countryCode != null) {
                return fName.startsWith("Simo") && countryCode.equals("PRG");
            }
        }
        return false;
    }
}

您还可以在哪里使用此功能？

• • 要求发生变化，但您需要构造的副作用，例如增强的 for 循环
  • 异常处理程序中未使用的形参；其签名无法修改
  • try-with-resources 语句中未使用的可自动关闭资源

• • 未使用的 lambda 形参
  • 具有多重职责的方法

预览功能

总结

Subscribe to IntelliJ IDEA Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

提交此表单，即表示我同意 JetBrains s.r.o. ("JetBrains") 使用我的姓名、电子邮件地址和位置数据向我发送简报和商业通讯，并为此目的而处理我的个人数据。我同意 JetBrains 根据 JetBrains 隐私政策为此目的使用第三方服务处理上述数据。我了解我可以在我的个人资料中随时撤回此同意。此外，每封电子邮件中也都包含退订链接。

Submit

谢谢！