使用記錄（records）來創(chuàng)建不可變數(shù)據(jù)載體，它自動生成構(gòu)造函數(shù)、訪問器、equals、hashCode和toString方法，適用于DTO或簡單域模型；2. 使用密封類（sealed classes）限制繼承體系，通過permits關(guān)鍵字明確允許的子類，實(shí)現(xiàn)封閉的類型層次，提升switch表達(dá)式的窮盡性與安全性；3. 將記錄與密封類結(jié)合，可構(gòu)建類型安全、結(jié)構(gòu)清晰、易于模式匹配的數(shù)據(jù)模型，如代數(shù)數(shù)據(jù)類型或表達(dá)式樹，從而提高代碼的可讀性、可維護(hù)性和正確性。

Java has evolved significantly over the years, and with Java 16 (as a standard feature), records and sealed classes were introduced to make it easier to model immutable data and control class hierarchies. These features are especially useful in modern Java development for writing cleaner, safer, and more maintainable code.

Let’s break down how and why to use them.

1. Records: Immutable Data Carriers

A record is a special kind of class designed to model immutable data. It automatically generates constructors, accessors, equals(), hashCode(), and toString() methods based on the components you declare.

When to Use Records

Use records when you’re creating a class whose main purpose is to hold data — like DTOs (Data Transfer Objects), configuration holders, or simple domain models.

public record Person(String name, int age) {}

That single line gives you:

• A constructor: Person(String name, int age)
• Public accessor methods: name() and age()
• Proper equals(), hashCode(), and toString() implementations

Key Rules

• Records are implicitly final and can’t be extended.
• The fields are private final and cannot be modified.
• You can add static fields, methods, or even custom constructors (with validation), but the core components remain immutable.

Adding Behavior (Optional)

You can enhance a record with additional methods:

public record Person(String name, int age) {
    public boolean isAdult() {
        return age >= 18;
    }
}

? Best Practice: Use records for data-centric classes. If you need behavior, inheritance, or mutability, stick with regular classes.

2. Sealed Classes: Controlled Inheritance

Sealed classes let you restrict which classes can extend or implement them. This is useful when you want to define a closed set of types — like in domain modeling or pattern matching scenarios.

Why Use Sealed Classes?

They allow you to:

• Model algebraic data types (ADTs)
• Make switch expressions more exhaustive and safe
• Prevent unexpected subclasses from appearing elsewhere

Syntax Example

public sealed abstract class Shape permits Circle, Rectangle, Triangle {
    // common behavior
}

final class Circle extends Shape {
    public final double radius;
    public Circle(double radius) { this.radius = radius; }
}

final class Rectangle extends Shape {
    public final double width, height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
}

final class Triangle extends Shape {
    public final double a, b, c;
    public Triangle(double a, double b, c) {
        this.a = a; this.b = b; this.c = c;
    }
}

Here:

• permits Circle, Rectangle, Triangle explicitly lists allowed subclasses.
• Each permitted class must be final, sealed, or non-sealed (a new keyword).

? The non-sealed modifier allows a subclass to be open for extension even within a sealed hierarchy.

Use with Pattern Matching (Modern Java Combo)

Sealed classes shine when used with switch expressions and pattern matching:

double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius * c.radius;
        case Rectangle r -> r.width * r.height;
        case Triangle t -> { // Heron's formula
            double s = (t.a   t.b   t.c) / 2;
            yield Math.sqrt(s * (s - t.a) * (s - t.b) * (s - t.c));
        }
    };
}

Because Shape is sealed and all subtypes are known, the compiler knows the switch is exhaustive — no default needed.

3. Combining Records and Sealed Classes

One of the most powerful modern Java patterns is using records with sealed classes to model data variants cleanly.

Example: Expressions in a Calculator

public sealed interface Expr permits Constant, Add, Multiply {}

record Constant(double value) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
record Multiply(Expr left, Expr right) implements Expr {}

Now you can write a recursive evaluator:

double evaluate(Expr expr) {
    return switch (expr) {
        case Constant c -> c.value();
        case Add a -> evaluate(a.left())   evaluate(a.right());
        case Multiply m -> evaluate(m.left()) * evaluate(m.right());
    };
}

This approach gives you:

• Immutability via records
• Type safety via sealed hierarchy
• Clean, readable code
• Exhaustive pattern matching

Final Thoughts

Records and sealed classes are not just syntactic sugar — they represent a shift toward modeling data more precisely and safely in Java.

• ? Use records for transparent, immutable data carriers.
• ? Use sealed classes/interfaces when you want to define a closed type hierarchy.
• ? Combine them to build expressive domain models, especially for trees, expressions, or state machines.

They work best with other modern Java features like pattern matching (instanceof and switch) and enhance code clarity and correctness.

Basically, if you're still writing POJOs with getters, setters, and toString() boilerplate — or allowing unlimited inheritance — it’s time to give records and sealed classes a try.

以上是使用現(xiàn)代爪哇的記錄和密封課程的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！