Java 25: Những Thay Đổi Ngôn Ngữ Quan Trọng Bạn Nên Biết

Java 25 không chỉ là một bản phát hành về JVM và tooling. Nó cũng mang đến một số thay đổi quan trọng ở mức ngôn ngữ, giúp Java dễ viết hơn, dễ dạy hơn, và trong một vài trường hợp còn dễ reasoning hơn hẳn.

Trong bài tổng quan, chúng ta đã nhìn Java 25 ở mức cao. Ở bài này, chúng ta sẽ tập trung riêng vào các thay đổi ngôn ngữ ảnh hưởng trực tiếp đến cách source code trông như thế nào và hoạt động ra sao.

Những mục quan trọng nhất là:

• JEP 511: Module Import Declarations
• JEP 512: Compact Source Files and Instance Main Methods
• JEP 513: Flexible Constructor Bodies
• JEP 507: Primitive Types in Patterns, instanceof, and switch (Third Preview)

Không phải mục nào cũng có cùng mức tác động trong production. Một số là tính năng ngôn ngữ đã hoàn thiện và có thể dùng ngay. Một số khác vẫn đang ở trạng thái preview, phù hợp hơn với việc học và thử nghiệm hơn là trở thành coding style mặc định trong production.

Phân Loại Nhanh

Trước khi đi sâu, đây là cách thực tế nhất để nhìn các thay đổi ngôn ngữ trong Java 25:

Đã sẵn sàng cho production trong Java 25

• Module Import Declarations
• Compact Source Files and Instance Main Methods
• Flexible Constructor Bodies

Vẫn là preview trong Java 25

• Primitive Types in Patterns, instanceof, and switch

Phân biệt này rất quan trọng. Khi một tính năng còn ở trạng thái preview, bạn nên đánh giá kỹ và tránh biến nó thành convention mặc định của team quá sớm.

1. Module Import Declarations

JEP 511 bổ sung module import declarations, cho phép bạn import tất cả package được export bởi một module chỉ với một declaration.

Vấn Đề Mà Nó Muốn Giải Quyết

Import truyền thống trong Java hoạt động ở mức package hoặc type:

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

Điều này hoàn toàn ổn với ứng dụng bình thường, nhưng lại hơi nhiều ceremony trong:

• ví dụ giảng dạy,
• prototype nhanh,
• script,
• demo program,
• và utility nhỏ.

Khi bạn đã biết mình muốn dùng API từ một module cụ thể, việc lặp lại quá nhiều import có thể giống boilerplate hơn là sự rõ ràng cần thiết.

Java 25 Bổ Sung Gì

Với Java 25, bạn có thể viết:

import module java.base;

Lệnh này import theo kiểu on-demand tất cả public top-level class và interface từ các package mà module đó export.

Tính năng này đặc biệt đáng chú ý vì nó kết hợp rất tốt với compact source files, phần mà chúng ta sẽ nói tiếp ngay sau đây.

Vì Sao Nó Quan Trọng

Đây là kiểu tính năng nhìn qua release notes thì có vẻ nhỏ, nhưng lại thay đổi cảm giác tiếp cận Java trong những chương trình nhỏ.

Lợi ích chính là:

• giảm boilerplate ở phần import,
• ví dụ và tutorial gọn hơn,
• trải nghiệm scripting mượt hơn,
• và tạo một on-ramp nhẹ nhàng hơn cho người mới.

Có Nên Dùng Ở Mọi Nơi Không?

Có lẽ là không.

Với codebase production lớn, explicit imports vẫn có nhiều giá trị:

• giúp dependency hiện rõ hơn,
• giúp source file dễ lướt hơn,
• và phù hợp với convention Java hiện tại.

Vì vậy, lời khuyên thực tế là:

• dùng module imports có chọn lọc cho ví dụ ngắn và chương trình nhỏ,
• giữ explicit imports làm mặc định trong codebase business lớn trừ khi team của bạn chủ động chọn cách khác.

2. Compact Source Files and Instance Main Methods

JEP 512 là một trong những thay đổi ngôn ngữ dễ thấy nhất của Java 25 vì nó trực tiếp giảm ceremony trong các chương trình nhỏ.

Nó Giải Quyết Vấn Đề Gì

Kiểu "Hello, World!" truyền thống của Java từ lâu luôn trông nặng hơn nhiều so với code tương đương ở nhiều ngôn ngữ khác:

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

Điều này không khó một khi bạn đã biết Java, nhưng nó buộc người mới nhìn thấy hàng loạt khái niệm ngay từ đầu:

• public
• static
• String[] args
• khai báo class tường minh

Những khái niệm đó đều hữu ích trong Java thực tế, nhưng không phải tất cả đều cần ngay ngày đầu tiên.

Java 25 Cho Phép Điều Gì

Java 25 hoàn thiện hướng đi từ các preview trước đó và cho phép bạn viết code gọn hơn cho các chương trình nhỏ:

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

Bạn cũng có thể dùng lớp hỗ trợ IO mới:

void main() {
    IO.println("Hello, World!");
}

Đây là một thay đổi đáng kể trong cách Java có thể được giới thiệu cho người mới học.

Vì Sao Nó Quan Trọng Hơn Vẻ Bề Ngoài

Nhiều developer giàu kinh nghiệm có thể xem đây chỉ là tính năng phục vụ việc dạy học. Cách nhìn đó hơi hẹp.

Nó cũng hữu ích cho:

• utility chạy command line,
• experiment,
• demo nội bộ,
• prototype nhanh,
• và script ngắn.

Java đang cố gắng bớt awkward hơn cho các tác vụ nhỏ mà không tạo ra một dialect "Java mini" riêng. Điểm thiết kế này rất quan trọng. Mục tiêu không phải tách ngôn ngữ thành Java cho người mới và Java "thật". Mục tiêu là để một chương trình nhỏ có thể grow dần lên thành chương trình class-based bình thường một cách tự nhiên.

Góc Nhìn Thực Tế Trong Team

Với ứng dụng production, phần lớn code vẫn sẽ sống trong các class thông thường. Vì vậy, tính năng này sẽ không làm codebase Spring Boot thay đổi tận gốc.

Nhưng nó cải thiện rõ ràng cho:

• onboarding,
• workshop,
• tài liệu hướng dẫn,
• ví dụ trong playground,
• và script hỗ trợ local.

Vì thế nó hữu ích hơn cảm giác ban đầu khá nhiều.

3. Flexible Constructor Bodies

JEP 513 có lẽ là thay đổi ngôn ngữ quan trọng nhất trong Java 25 đối với developer production hằng ngày.

Ràng Buộc Cũ

Trong một thời gian rất dài, Java yêu cầu phần thân constructor phải bắt đầu bằng một trong hai thứ:

• super(...), hoặc
• this(...)

Điều đó khiến validation hoặc setup logic thường bị đẩy vào những chỗ khá gượng.

Ví dụ, theo luật cũ của Java, kiểu code như thế này là không hợp lệ:

class Employee extends Person {
    Employee(String name, int age) {
        if (age < 18) {
            throw new IllegalArgumentException("age must be at least 18");
        }
        super(name, age);
    }
}

Vấn đề không nằm ở logic. Vấn đề nằm ở luật của ngôn ngữ.

Java 25 Thay Đổi Điều Gì

Java 25 cho phép các statement xuất hiện trước explicit constructor invocation, miễn là chúng không tham chiếu sai cách đến object đang được khởi tạo.

Điều đó có nghĩa là code như sau giờ đây trở nên hoàn toàn tự nhiên:

class Employee extends Person {
    Employee(String name, int age) {
        if (age < 18) {
            throw new IllegalArgumentException("age must be at least 18");
        }
        super(name, age);
    }
}

Vì Sao Điều Này Quan Trọng Trong Code Thực Tế

Nó cải thiện Java ở vài điểm rất cụ thể:

• validation trong constructor rõ ràng hơn,
• fail-fast checks dễ biểu đạt hơn,
• constructor code đọc theo thứ tự top-down tự nhiên hơn,
• và độ an toàn khi khởi tạo được cải thiện trong một số tình huống inheritance.

Đây đúng là kiểu thay đổi mà Java developer nhiều kinh nghiệm sẽ cảm nhận ngay. Nó không cố làm Java trở nên flashy. Nó chỉ loại bỏ một friction point cũ và để cho code đúng trông tự nhiên hơn.

Tác Động Trong Production

Tính năng này đã hoàn thiện trong Java 25 và có giá trị ngay lập tức với code ứng dụng thông thường.

Trong tất cả các thay đổi ngôn ngữ của JDK 25, đây có lẽ là thứ mà nhiều team sẽ dùng đầu tiên trong business code.

4. Primitive Types in Patterns, instanceof, and switch

JEP 507 là chủ đề ngôn ngữ nâng cao nhất trong nhóm này, và nó vẫn là preview feature trong Java 25.

Hướng Đi Chung

Java hiện đại đã tiến đều theo hướng pattern matching phong phú hơn:

• pattern matching cho instanceof,
• pattern matching cho switch,
• record patterns,
• và luồng điều khiển biểu đạt tốt hơn.

Nhưng primitive types vẫn là một khoảng trống khá awkward trong câu chuyện này.

Java 25 Đang Thử Điều Gì

Java 25 mở rộng mô hình pattern matching để primitive types có thể tham gia nhất quán hơn vào:

• pattern contexts,
• instanceof,
• và switch.

Ví dụ, một switch có thể biểu đạt tốt hơn:

switch (status) {
    case 0 -> "okay";
    case 1 -> "warning";
    case 2 -> "error";
    case int i -> "unknown status: " + i;
}

Điều này thú vị vì nó khiến control flow dựa trên pattern trở nên đồng nhất hơn. Thay vì primitive là một góc riêng biệt của ngôn ngữ, Java tiến gần hơn đến mô hình nơi pattern hoạt động nhất quán trên cả reference type lẫn primitive type.

Vì Sao Nó Vẫn Là Preview

Mảng này chạm đến những phần khá tinh vi của ngôn ngữ:

• exact conversions,
• quy tắc narrowing và widening,
• numeric safety,
• và cách instanceof nên hoạt động với primitive types.

Vì vậy, dù hướng đi rất hứa hẹn, đây chưa phải thứ mà đa số team nên chuẩn hóa trong production code.

Lời Khuyên Thực Tế

Hãy dùng tính năng này để:

• học hướng phát triển tiếp theo của Java,
• thử nghiệm trong side project,
• và hiểu giai đoạn tiếp theo của pattern matching.

Đừng dùng nó chỉ vì nhìn hiện đại. Chỉ nên dùng khi team của bạn chủ động bật preview features và hiểu rõ tác động ở build/runtime.

Thay Đổi Ngôn Ngữ Nào Quan Trọng Nhất?

Nếu xếp hạng các thay đổi ngôn ngữ trong Java 25 theo tác động thực tế, một thứ tự hợp lý là:

1. Flexible Constructor Bodies cho phát triển production mainstream.
2. Compact Source Files and Instance Main Methods cho dạy học, script và utility nhỏ.
3. Module Import Declarations để giảm ceremony trong ví dụ và chương trình nhỏ.
4. Primitive Types in Patterns, instanceof, and switch cho thử nghiệm theo hướng tương lai.

Thứ hạng này không nói về độ tinh vi kỹ thuật. Nó nói về khả năng mỗi tính năng sẽ ảnh hưởng đến development hằng ngày trong tương lai gần.

Điều Gì Sẽ Thay Đổi Trong Codebase Backend Điển Hình?

Nếu bạn đang maintain một codebase backend bình thường, đặc biệt là ứng dụng Spring Boot, đây là bức tranh thực tế:

• Bạn nhiều khả năng sẽ nhận ra Flexible Constructor Bodies đầu tiên.
• Bạn có thể dùng Compact Source Files cho demo, ví dụ nội bộ hoặc script thay vì application code.
• Bạn có thể hiếm khi dùng Module Import Declarations trong production module lớn.
• Bạn nên theo dõi Primitive Patterns như một tính năng đang tiến hóa hơn là coding standard mặc định.

Vì vậy, câu chuyện ngôn ngữ của Java 25 không chủ yếu là viết lại enterprise application. Nó thiên về việc làm Java dễ chịu hơn trên toàn phổ, từ ví dụ rất nhỏ đến code production thực tế.

Kết Luận

Những thay đổi ngôn ngữ chính trong Java 25 đáng chú ý vì chúng giải quyết các loại vấn đề khác nhau.

• Flexible Constructor Bodies loại bỏ một pain point cũ trong code ứng dụng thực tế.
• Compact Source Files và Module Import Declarations giảm ceremony và giúp Java dễ tiếp cận hơn.
• Primitive Types in Patterns cho thấy ngôn ngữ vẫn đang tiếp tục tiến hóa.

Gộp lại, chúng cho thấy một hướng đi rất rõ: Java muốn tiếp tục nghiêm túc cho hệ thống lớn, đồng thời bớt awkward hơn cho chương trình nhỏ và nhất quán hơn trong mô hình type và pattern.

Đó là một hướng đi lành mạnh cho ngôn ngữ này.

Trong bài tiếp theo, chúng ta sẽ đi xuống một tầng thấp hơn và nhìn vào các cải tiến về JVM và hiệu năng trong Java 25, bao gồm compact object headers, hướng tối ưu ahead-of-time và generational Shenandoah.