Java on boboboker~

泛型

Fri, 16 May 2025 00:00:00 +0800

泛型

泛型(Generic)是非常重要的语言功能，广泛应用于各种项目、工具、框架。
本文主要关注泛型的应用，由浅入深介绍和讨论能力和限制，给出相关示例来演示应用。

演示代码语言/平台采用最新LTS或主流支持版本，详细情况如下：

C# 12 on .NET 8 (LTS)

F# 8 on .NET 8 (LTS)

Java 21 on JDK 21 (LTS)

Scala 3.3.x (LTS) on JDK 21 (LTS)

Scala 2.13.x on JDK 21 (LTS)

Python 3.13.x

.NET版本支持策略参考官方文档: .NET Support Policy; C#和F#随.NET一同发布/更新

Scala与JDK兼容情况可参考官方介绍: JDK Compatibility
Scala 2.x 维护计划在Scala 2 maintenance plans及Scala development guarantees中有介绍，简言之2.13将持续维护，2.12将在sbt 1广泛应用期间持续维护
Scala 2.13相对与2.12的变化可参考: Migrating a Project to Scala 2.13’s Collections, Scala 2.13.0 is now available!, Releases / Scala 2.13.0
Scala 3相对于2的变化可参考: Scala 3 Migration Guide

Python的版本支持情况可参考官方介绍: Status of Python versions

基本语法

本节简要介绍泛型在各语言中的基本使用。

C#

官方文档: \

Generics in .NET

C# specifications / Types / Constructed types

Generic classes and methods

……

泛型接口、泛型类和泛型方法

如下代码演示了泛型接口、泛型类、泛型方法(实例方法及静态方法)的定义和调用。\

Generic Classes (C# Programming Guide)

Generic Interfaces (C# Programming Guide)

Generic methods (C# programming guide)

// ==========[定义泛型]==========

// 定义泛型接口
interface IWritable<T>
{
    void Write(T value);
}
interface IReadable<T>
{
    T Read();
    // 接口自带默认实现
    string ReadString() => Read().ToString();
}

// 定义泛型类(并实现泛型接口)
class Response<T> : IReadable<T>, IWritable<T>
{
    public int Code { get; set; }
    public string Message { get; set; }
    // Data属性是个泛型属性
    public T Data { get; set; }

    // 构造器方法
    public Response() { }
    public Response(int code, string message, T data) : this()
    {
        this.Code = code;
        this.Message = message;
        this.Data = data;
    }
    // 解构方法
    public void Deconstruct(out int code, out string message, out T data)
    {
        code = Code;
        message = Message;
        data = Data;
    }

    // 实现泛型接口中定义的方法
    public T Read() => Data;
    public void Write(T value) => Data = value;

    // 定义泛型实例方法
    public bool TryRefreshData<U>(U data)
    {
        if (data is T t)
        {
            this.Data = t;
            return true;
        }
        return false;
    }

    // 尽量避免在泛型类中定义静态方法，调用相对比较麻烦
    // 定义泛型静态方法
    public static Response<U> Success<U>(U data)
        => new(0, "success", data);
    // 定义静态方法
    public static Response<string> Failed(string message)
        => new(1, message, "failed");
}

// 定义工具类
// C#中，泛型静态方法最好放在单独的工具类中，可以直接以
class ResponseHelper
{
    // 定义泛型静态方法
    public static Response<T> Success<T>(T data)
        => new(0, "success", data);
    public static Response<string> Failed(string message)
        => new(1, message, "failed");
}

// 定义(静态)扩展类
static class ResponseExtension
{
    // 定义泛型扩展方法
    public static Response<T> Copy<T>(this Response<T> response)
        => new(response.Code, response.Message, response.Data);
    // 定义泛型扩展方法
    public static bool IsSuccess<T>(this Response<T> response)
        => response.Code == 0;
}

// ==========[使用泛型]==========
// 初始化对象(调用构造器)
var response = new Response<string>(0, "success", "data");
// 初始化对象(属性初始化)
var response = new Response<string>
{
    Code = 0,
    Message = "success",
    Data = "data"
};
// 初始化对象(new表达式)
Response<string> response = new(0, "success", "data");
// 解构对象
var (code, _, data) = response;

// 泛型方法调用时，编译器可以从参数中推断类型，因此一般无需声明类型

// 调用泛型实例方法
response.TryRefreshData(123);
// 调用泛型实例方法(声明类型)
response.TryRefreshData<short>(123);

// 调用静态泛型方法
// 调用泛型类中的静态方法时，必须要声明泛型类的具体类型(泛型静态方法的类型一般无需声明)
var response = Response<string>.Success<short>(123);
// 调用普通工具类中的静态方法(泛型静态方法的类型一般无需声明)
var response = ResponseHelper.Success<short>(123);

// 调用泛型扩展方法(与实例方法调用语法一致)
var success = response.IsSuccess();
var copy = response.Copy();

泛型接口、泛型类、泛型方法算是面向对象编程中对泛型最基本的应用。
此外泛型抽象类并未因泛型而新增特殊之处，其本身的功能及限制只是因为它是“抽象类”而非“泛型”，因此代码中并未演示。

泛型委托和泛型事件

委托和事件C#独有的语言功能，两者皆支持泛型，此处演示相关应用。相关详细概念请参考官方文档。

Generic Delegates (C# Programming Guide)

Delegates (C# Programming Guide)

Events (C# Programming Guide)

// 定义泛型委托
delegate T BiOp<T>(T a, T b);

// 使用泛型委托
BiOp<int> add = (a, b) => a + b;
var c = add(1, 2);

class Singleton<T>
{
    // 定义事件
    public event EventHandler<T> ValueChanged;

    private T _value;
    public T Value 
    { 
        get => _value;
        set
        {
            if (!EqualityComparer<T>.Default.Equals(Value, value))
            {
                _value = value;
                OnValueChanged(value);
            }
        }
    }

    protected virtual void OnValueChanged(T value)
    {
        // 触发事件
        ValueChanged?.Invoke(this, value);
    }
}

// 初始化对象
var singleton = new Singleton<int>();
// 订阅事件(多个事件处理程序)
singleton.ValueChanged += (_, i) => Console.WriteLine($"int = {i}");
// 赋值&触发事件
singleton.Value = 1;
// 重复赋值&不触发事件
singleton.Value = 1;

事件本质上是特殊类型的委托。对两者的深入探讨请参考官网文档。、

Introduction to delegates

Introduction to events

Distinguishing Delegates and Events

泛型数组

Generics and Arrays (C# Programming Guide)

泛型数组本身没什么特殊，此处需要特别注明的是一维数组自动实现IList<T>接口，这有助于实现一个泛型方法对数组或其他集合进行遍历。
但要注意自动实现的IList<T>接口仅支持数据读取，不能用于从数组中增删元素(会抛出异常)。

// 直接以集合初始化语法定义并初始化数组和List
int[] array = [1, 2, 3, 4, 5];
List<int> list = [1, 2, 3, 4, 5];

// 以一致的方式访问(读取)数组和List
ProcessItems(array);
ProcessItems(list);

static void ProcessItems<T>(IList<T> list)
{
    // 数组对象调用IsReadOnly返回True,List对象会返回False
    Console.WriteLine("IsReadOnly returns {0} for this collection.", list.IsReadOnly);

    // 对数组对象调用Insert/RemoveAt方法会导致抛出异常
    //list.RemoveAt(4);

    foreach (T item in list)
    {
        Console.Write(item?.ToString() + " ");
    }
    Console.WriteLine();
}

F#

TBD

Java

泛型约束

泛型约束声明了类型参数预期的能力，声明约束后可以安全地调用支持的操作。

C#

Constraints on type parameters (C# Programming Guide)

C#具备种类丰富的泛型约束，下方列表中对各种类型进行简要介绍。

泛型约束	简介
`where T : struct`	`T`必须是不可为NULL的值类型(Value Type)(可以是`record struct`类型)。由于所有值类型必定存在可用的无参构造器，因此这也隐含声明`new()`约束。 `struct`约束不能与`new()`及`unmanaged`约束组合使用。
`where T : class`	`T`必须是引用类型(Reference Type)。 `T`可以是类、记录类(record class)、接口、委托、数组。在允许为NULL上下文(nullable context)中，`T`必须是不可为NULL的引用类型。
`where T : class?`	`T`必须是引用类型(Reference Type)，可以是允许为NULL的引用类型，也可以是不允许为NULL的引用类型。 `T`可以是类、记录类(record class)、接口、委托、数组。
`where T : notnull`	`T`必须是不可为NULL的类型。 `T`可以是不可为NULL的引用类型、不可为NULL的值类型。
`where T : unmanaged`	`T`必须是不可为NULL的非托管类型(Unmanaged Type)。 `unmanaged`约束隐含声明`struct`，不能与`struct`及`new()`约束组合使用。注：非托管类型包括内置值类型及布尔类型、枚举类型、指针类型、成员都是非托管类型的元组(tuple)和结构(struct)类型。但该约束依然不允许指针和可为NULL的非托管类型。
`where T : new()`	`T`必须有公开的无参构造器。当与其他约束组合使用时，`new()`约束必须放在最后。 `new()`约束不能与`struct`及`unmanaged`约束组合使用。
`where T : <class name>`	`T`必须是给定的类或继承自给定的类。在允许为NULL上下文(nullable context)中，`T`必须是不可为NULL的引用类型。
`where T : <class name>?`	`T`必须是给定的类或继承自给定的类。在允许为NULL上下文(nullable context)中，`T`可以是允许为NULL的引用类型，也可以是不允许为NULL的引用类型。
`where T : <interface name>`	`T`必须是给定的接口或实现了给定的接口。可以声明多个接口约束；约束中给定的接口也可以是泛型接口。在允许为NULL上下文(nullable context)中，`T`必须是实现给定接口的不允许为NULL的类型。
`where T : <interface name>?`	`T`必须是给定的接口或实现了给定的接口。可以声明多个接口约束；约束中给定的接口也可以是泛型接口。在允许为NULL上下文(nullable context)中，`T`必须是实现给定接口的可为NULL引用类型、不可为NULL的引用类型、值类型。`T`不可以是允许为NULL的值类型。
`where T : U`	`T`必须是类型参数`U`给定的类型或继承自给定类型。在允许为NULL上下文(nullable context)中，若`U`是不允许为NULL的引用类型，则`T`也必须是不可为NULL的引用类型；若`U`是允许为NULL的引用类型，则不限制`T`是否可为NULL。
`where T : default`	`T`必须未声明`struct`或`class`约束。该约束仅在显式实现接口方法或重写方法时可用，用于声明期望实现/重写的是`T`未被约束的方法。
`where T : allows ref struct`	该反约束允许`T`是`ref struct`类型。 `T`可能是`ref struct`实例，泛型类型和方法必须遵循引用安全规则(ref safety rules)。 C# 13.0+可用

某些约束是互斥的，某些约束必须遵循特定的顺序。

struct/class/class?/notnull/unmanaged约束至多允许一个，且必须是第一个约束；
基类约束(where T : Base/where T : Base?)至多允许一个，使用where T : Base?支持可为NULL的基类，基类约束不能与struct/class/class?/notnull/unmanaged约束组合使用；
不允许同时声明单个接口的可NULL和不可NULL形式(where T : I1, I1? ×; where T : I1, I2? √)；
new()约束不能与struct/unmanaged约束组合使用；若存在new()约束，其必须位于约束的最后(反约束可以放在它后面)；
default约束只能用于方法重写和显式实现接口方法场景，且不能与struct/class约束组合使用；
反约束allows ref struct不能与class/class?约束组合使用，且必须跟在所有约束的后面。

部分约束有如下注意事项。\

使用class约束时避免使用比较操作符==/!=。这组操作符只比较引用是否相等，不进行值比较。该行为不会因具体类型是否重载比较操作符而变化，因为编译时仅能得知类型是引用类型，必须调用对所有引用类型都合法有效的实现。若要在泛型代码中进行值比较，请使用where T : IComparable<T>或where T : IEquatable<T>约束并为实际类型实现相关接口。
若类型参数没有任何约束(例如SampleClass<T>{}中的T)称为未绑定类型(unbounded type parameter)，应当遵循如下规则：
- 不能使用比较操作符==/!=，因为不能保证实际类型支持该操作符；
- 可以显式转换为任何接口类型，也可以转换成System.Object类型(或者由System.Object转换成T)；
- 可以与null进行比较(T是值类型时会返回false)
notnull约束用以声明类型参数将约束为不可为NULL的值类型/引用类型，违反notnull约束时，编译器只会生成警告，不会报告错误。notnull约束仅在可空代码上下文中生效，若在忽略可空性的代码上下文使用，违反约束时编译器不会生成任何警告或错误。

以下对部分约束进行详细解释及代码演示。

泛型约束常规应用

// 单个类型参数的泛型约束
struct Container<T> where T : struct
{
    public T Value { get; set; }
}

// 多个类型参数的泛型约束(各自约束互不干涉)
class Container<K, V>
    where K : struct
    where V : class, new()
{
    // ...
}

// 类型参数作为约束
class SampleClass<T, U, V> where T : V { }
class List<T>
{
    public void Add<U>(List<U> items) where U : T {/*...*/}
}

`default`约束

参考文档: dotnet/csharplang/proposals/csharp-9.0/unconstrained-type-parameter-annotations

default约束是用于在重写/实现方法时消除nullable泛型重载的歧义。以下以代码演示其功能。

关于`?`标注

C# 8.0中，?仅能用于显式约束了值类型或引用类型的类型参数；在C# 9.0中，?可以用于任意类型参数，无论是否存在约束。
但要注意，?标注仅能用于设置了#nullable enable的代码上下文中。

若是类型参数T是个引用类型，T?表示该引用类型的可NULL实例。

1
2

var s1 = new string[0].FirstOrDefault();  // string? s1
var s2 = new string?[0].FirstOrDefault(); // string? s2

若是类型参数T是个值类型，T?表示该值类型的实例。

1
2

var i1 = new int[0].FirstOrDefault();  // int i1
var i2 = new int?[0].FirstOrDefault(); // int? i2

若是类型参数T是其他标注过的类型U?，T?依然表示标注过的类型U?，而不是U??。

1
2

var u1 = new U[0].FirstOrDefault();  // U? u1
var u2 = new U?[0].FirstOrDefault(); // U? u2

若是类型参数T是其他类型U，T?表示标注过的类型U?，即使在#nullable disable上下文中。

1
2

#nullable disable
var u3 = new U[0].FirstOrDefault();  // U? u3

实际上T?仅是个标注，并非一定是在构造新类型。
FirstOrDefault方法的声明是public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source);，返回值部分只是声明可能为NULL，并不是将返回值变成真正的可空类型TSource?。
对于值类型TSource(如int)，TSource?和TSource在IL中都是int，方法泛型返回值不能为int标注?(int?实际是Nullable<int>，是个新结构)。
对于返回值，T?等同于[MaybeNull] T，对于参数值，T?等同于[AllowNull] T。当重写方法或实现接口时该等同性非常重要。
以下代码演示了该等同性。

public abstract class A
{
    // 以特性方式声明抽象方法
    // 没有声明`class`/`struct`约束，编译器认为存在歧义，会添加`where T : default`约束

    // 实际等同于public abstract T? F1<T>(); (也会默认添加where T : default约束)
    [return: MaybeNull] public abstract T F1<T>();
    // 实际等同于public abstract void F2<T>(T? t)
    public abstract void F2<T>([AllowNull] T t);
}

public class B : A
{
    // 重写时必须显式声明where T : default约束
    public override T? F1<T>() where T : default { return defalut(T); } // matches A.F1<T>()
    public override void F2<T>(T? t) where T : default {  }             // matches A.F2<T>()
}

使用T?或注解形式的可为NULL声明且不存在class/struct约束时，编译器认为存在歧义，会默认添加where T : default约束，表示没有约束class/struct。
方法重写/实现接口时，必须声明where T : default约束，用来表示重写/实现的是不约束class/struct的方法。\

关于歧义

参考如下代码，除泛型约束外，两个方法是一致的形式，但方法签名不包含泛型约束信息。理论上，两个方法不应同时存在。

class C
{
    public virtual void F<T>(T? t) where T : struct { }
    public virtual void F<T>(T? t) where T : class { }
}

实际上，以上代码是合法的，两个方法是不同的签名。

C#8.0引入可为NULL引用类型支持，T?的意义取决于T是值类型或是引用类型。

泛型约束	`T?`的含义	真实参数类型
`where T : struct`	可为NULL值类型	`Nullable<T>`
`where T : class`	可为NULL引用类型	`T`(带可为NULL元数据)

以上代码在编译器视角中的实际形式如下。

using System.Diagnostics.CodeAnalysis;

class C
{
    public virtual void F<T>(Nullable<T> t) where T : struct { }
    public virtual void F<T>([AllowNull] T t) where T : class { }
}

两个方法的参数在编译器视角中是不同的类型，函数签名不同，因此可以同时存在。
但是对常规写法而言，用户读到的代码是一样的，因此便出现了歧义。

消除歧义

显式class/struct约束的代码，重写/实现时可以通过显式约束消除歧义。

class A1
{
    public virtual void F1<T>(T? t) where T : struct { }
    public virtual void F1<T>(T? t) where T : class { }
}

class B1 : A1
{
    public override void F1<T>(T? t) /*where T : struct*/ { }
    public override void F1<T>(T? t) where T : class { }
}

注: 显式struct约束的方法参数实际是Nullable<T>，相对于参数为T的方法，这是个约束更强(更具体)的版本，在编译器解析时具备更高的优先级。
因此重写方法时的where T : struct约束可以省去，但非常不建议这样做。

而当存在有约束和无约束版本的方法时，可以使用default约束来消除歧义。

class A2
{
    public virtual void F2<T>(T? t) where T : struct { }
    public virtual void F2<T>(T? t) { }
}

class B2 : A2
{
    public override void F2<T>(T? t) /*where T : struct*/ { }
    public override void F2<T>(T? t) where T : default { }
}

where T : default声明此处重写的是无class/struct约束的版本。

`unmanaged`约束

该约束可用于期望以直接操作内存块的方式读写类型实例的代码，如下所示。

unsafe public static byte[] ToByteArray<T>(this T argument) where T : unmanaged
{
    var size = sizeof(T);
    var result = new Byte[size];
    Byte* p = (byte*)&argument;
    for (var i = 0; i < size; i++)
        result[i] = *p++;
    return result;
}

由于对未知的类型T调用sizeof操作符，因此代码必须声明为不安全上下文(unsafe context)；若没有将类型参数T约束为unmanaged，sizeof操作符不可用。

委托约束

C#语言规范中未提供类似where T : delegate形式的约束，但可以用类型约束来实现类似的功能。
可以将T约束为System.Delegate/System.MulticastDelegate的子类，就可以在满足类型安全的前提下对委托进行操作。
代码演示如下所示。

// 操作委托的扩展方法
// 合并相同相同类型的委托
public static T? TypeSafeCombine<T>(this T source, T target) where T : Delegate
    => Delegate.Combine(source, target) as T;

// 定义两个相同类型的委托
Action first = () => Console.WriteLine("this");
Action second = () => Console.WriteLine("that");
// 合并&调用
var combined = first.TypeSafeCombine(second);   // √
combined!();

// 定义一个不同类型的委托
Func<bool> test = () => true;
// 如下的调用是错误的
var badCombined = first.TypeSafeCombine(test);  // ×

枚举约束

与委托调用类似，C#语言规范中并未直接提供纯粹的where T : enum约束(unmanaged约束允许传入枚举，但不是只允许枚举)，但可以用类型约束来实现类似功能。
可以将T约束为System.Enum的子类，就可以约束为仅允许枚举传入。
代码示例如下所示。

// 操作枚举的扩展方法
// 将给定枚举的值和名称构造成字典对象
public static Dictionary<int, string> EnumNamedValues<T>() where T : Enum
{
    var result = new Dictionary<int, string>();
    var values = Enum.GetValues(typeof(T));

    foreach (int item in values)
    {
        result.Add(item, Enum.GetName(typeof(T), item)!);
    }
    return result;
}
// 定义枚举
enum SomeValue {A, B, C, D}
// 调用扩展方法并初始化字典
var dict = EnumNamedValues<SomeValue>();

类型参数继承/实现声明的类/接口(F-Bound)

本质是F-Bound，此处仅简要介绍官方文档对该约束的介绍及演示(样例中涉及到对C#支持接口静态成员的语言功能)，请参考下文(F-Bound)对该技巧的详细介绍。

// T必须实现接口本身
interface IAdditionSubtraction<T> where T : IAdditionSubtraction<T>
{
    // C#接口支持声明静态成员
    static abstract T operator +(T left, T right);
    static abstract T operator -(T left, T right);
}

`allows ref struct`约束

该约束是C#13.0新增的语言功能。

allows ref struct实际上是反约束，允许指定的类型参数可以是ref struct类型，因此该类型实例必须遵守如下规则：

不能被装箱
必须遵守引用安全规则(ref safety rules)
不能在禁止使用ref struct的地方使用该类型，例如static字段
实例可以使用scoped修饰符进行标记

F-Bound

F-Bound是一种泛型编程技巧，通常用于面向对象编程中，帮助在继承层次结构中实现类型自参的自引用。简单来说，是指通过继承某个类型的泛型类，子类可以返回类型自己。这个技巧在做流式接口设计、构建DSL或者处理复杂类型时非常有用。

F-Bound通常用于实现以下模式：基类定义了一个泛型方法，该方法返回该类（或者子类）的类型。而子类继承基类时，能够实现这个方法并返回自己的类型。

以下代码演示基本应用。

using System;

// 基类 Shape，使用 F-Bound 技巧
public abstract class Shape<T> where T : Shape<T>
{
    // 一个设置颜色的方法，返回当前类型（T）本身
    public T SetColor(string color)
    {
        Console.WriteLine($"Setting color to {color}");
        return (T)this;  // 返回当前类型本身
    }
    // 计算形状的面积（可以在子类中实现具体的面积计算）
    public abstract double GetArea();
}

// Circle 类，继承自 Shape<T>，并指定自己为 T
public class Circle : Shape<Circle>
{
    public double Radius { get; set; }
    public Circle(double radius)
    {
        Radius = radius;
    }
    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
    // 可以链式调用 SetColor 方法
    public Circle SetRadius(double radius)
    {
        Radius = radius;
        return this;
    }
}

// Rectangle 类，继承自 Shape<T>，并指定自己为 T
public class Rectangle : Shape<Rectangle>
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }
    public override double GetArea()
    {
        return Width * Height;
    }
    // 可以链式调用 SetColor 方法
    public Rectangle SetDimensions(double width, double height)
    {
        Width = width;
        Height = height;
        return this;
    }
}

// 测试 F-Bound
class Program
{
    static void Main(string[] args)
    {
        // 创建一个 Circle 对象，设置颜色和半径
        Circle circle = new Circle(5);
        circle.SetColor("Red")
              .SetRadius(10);
        Console.WriteLine($"Circle Area: {circle.GetArea()}");

        // 创建一个 Rectangle 对象，设置颜色和尺寸
        Rectangle rectangle = new Rectangle(4, 5);
        rectangle.SetColor("Blue")
                 .SetDimensions(6, 7);
        Console.WriteLine($"Rectangle Area: {rectangle.GetArea()}");
    }
}

可变性

可变性(variance)包含协变(covariance)、逆变(contravariance)和不变(invariance)。
语言层面的可变性支持是类型系统支持多态的关键部分，有的是由严格的语法支持，有的语言通过子类型兼容性简介体现。

简单来讲，协变(covariance)是指子类型可以赋值给父类型，常用于返回值(输出)场景；逆变(contravariance)是指父类型可以赋值给子类型，常用于参数(输入)场景；不变(invariance)是指完全相同的类型才能赋值，最安全也最严格。

可变性的核心概念(类型转换中派生类与基类之间的方向)在非泛型场景中也存在，但一般是隐式的，或称为“类型兼容性”问题。有些“类型兼容性”问题(例如数组协变)依赖编译器推断，但在运行时检查，可能抛出异常。常规场景中，参数逆变，返回值协变，便已是足够完善可靠的规则。

语言	协变(covariant)	逆变(contravariant)	说明
C#	✅ `out`	✅ `in`	泛型接口/委托支持，数组协变（但运行时检查）
Java	✅ `? extends`	✅ `? super`	使用通配符在泛型中表达变体，没有关键字（只能在使用处）
Scala	✅ `+T`	✅ `-T`	在泛型定义中支持变体标注，极其灵活
Python	✅（Typing 协变）	✅（Typing 逆变）	使用 `typing.Generic` + `covariant=True` 表达
Kotlin	✅ `out T`	✅ `in T`	类似 C#，在泛型类型定义中支持关键字
Swift	✅ 协变支持	✅（使用 protocol）	支持返回值协变、协议泛型逆变较间接
TypeScript	✅ 自动推导	✅ 自动推导	没有变体关键字，但函数/接口参数/返回值类型由结构类型系统自动推导
Rust	⚠️ 不支持协变/逆变关键字	⚠️ 不支持显式变体	有复杂的生命周期变体（‘a: ‘b）机制，不针对泛型类型参数

语言	泛型定义处变体	使用处变体	自动推导	安全检查	使用推荐度
C#	✅ `in`/`out`	✅ 委托	❌	✅ 编译时	✅✅✅
Java	❌	✅ `? extends` / `? super`	❌	✅ 编译时	✅✅
Scala	✅ `+T` / `-T`	✅	✅	✅	✅✅✅✅
Kotlin	✅ `out T` / `in T`	✅	✅	✅	✅✅✅
Swift	❌	部分支持	❌	✅	✅✅
TypeScript	❌	✅	✅✅✅	✅（结构化）	✅✅✅
Python	✅ (Typing)	✅	❌	✅（类型检查器）	✅✅
Rust	❌ 泛型不支持	❌	❌	✅（生命周期）	✅（不同维度）

上表整理自ChatGPT,其中Kotlin/Swift/TypeScript/Rust的相关内容尚未审慎求证。

C#

官方文档:\

Covariance and contravariance in generics

Covariance and Contravariance (C#) - Overview

Variance in Generic Interfaces (C#)

Creating Variant Generic Interfaces (C#)

Using Variance in Interfaces for Generic Collections (C#)

Variance in Delegates (C#)

Using Variance in Delegates (C#)

Using Variance for Func and Action Generic Delegates (C#)

泛型接口/委托中的可变性

泛型类、泛型方法中不能独立使用可变性修饰符in/out

// 定义泛型接口(实际是标准库中的类型，此处用以演示)
// 比较器接口(逆变)
public interface IEqualityComparer<in T>
{
    bool Equals(T? x, T? y);
    int GetHashCode([DisallowNull] T obj);
}
// 只读集合接口(协变)
public interface IReadOnlyList<out T> : IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
{
    T this[int index] { get; }
}

// 简单的继承关系
class Base { }
class Derived : Base { }

// 实现基类的比较器
class BaseComparer : IEqualityComparer<Base>
{
    public int GetHashCode(Base baseInstance)
    {
        return baseInstance.GetHashCode();
    }

    public bool Equals(Base? x, Base? y)
    {
        return x == y;
    }
}

// 基类的比较器可以作为派生类的比较器使用，此处体现了逆变
IEqualityComparer<BaseClass> baseComparer = new BaseComparer();
IEqualityComparer<DerivedClass> childComparer = baseComparer;

// 子类的集合可以作为基类的集合的使用，体现了协变
IReadOnlyList<Derived> childList = [];
IReadOnlyList<Base> baseList = childList;

// 泛型委托定义，参数逆变，返回值协变
public delegate TResult Func<in T, out TResult>(T arg);

// 两个委托实例
// 委托1：接受派生类，返回基类
Func<Derived, Base> func1 = (Derived d) =>
{
    Console.WriteLine(d);
    return new Base();
};
// 委托2：接受基类，返回派生类
Func<Base, Derived> func2 = (Base b) =>
{
    Console.WriteLine(b);
    return new Derived();
};

// 参数逆变：委托1期望接受派生类，实际可以接受基类
// 返回值协变：委托1期望返回基类，实际可以返回派生类
// 因此以下赋值是有效的(类型兼容)，委托2的实例可以作为委托1的实例调用
func1 += func2;

非泛型场景中的可变性

数组协变(强烈不推荐使用)

// 构造字符串数组实例，可以赋值给对象数组
object[] array = new string[] { "a", "b", "c" };
// 一般的读取不会有类型安全问题
var value = array[0];
// 赋值语句可以通过编译，但会在运行时抛出异常
array[0] = 1;

类型不安全。
该功能是编译器隐式支持的功能，但在运行时检查安全性。
协变的数组变量不存在严格的写保护，极有可能出现不经意的赋值操作，生产环境中应当避免使用。

方法重写返回值类

class A
{
    // 基类型中定义虚方法，返回值是基类型A
    public virtual A CreateInstance() { return new A(); }
}

class B : A
{
    // 派生类中重写方法，返回值类型是派生类型B，返回值协变
    public override B CreateInstance() { return new B(); }
}

类型安全。
该功能是编译器隐式支持的功能。
虚方法在子类中重写时，参数必须保持一致，但返回值可以是更具体的类型(返回值是协变的)，两个方法依然是“类型兼容”的。

非泛型委托的协变和逆变

// 定义基类型Animal及派生类型Dog
class Animal { }
class Dog : Animal { }

// 定义委托类型
delegate Animal Creator();
delegate void Handler(Dog dog);

// 定义普通方法
static Dog CreateDog() { return new Dog(); }
static void FeedAnimal(Animal animal) { }

// 方法可以构造为委托实例
Creator creator = CreateDog;    // 返回值协变
Handler handler = FeedAnimal;   // 参数逆变

类型安全。
该功能是编译器隐式支持的功能。
委托Creator期望生产Animal实例，实际上得到Dog实例，Dog作为Animal使用是类型安全的，因此Dog生产者作为Animal生产者也是类型安全的。这体现的是协变。
委托Handler期望消费Dog实例，因此调用Handler时给出的必定是Dog(或Dog派生类)实例，现在handler实际上是个消费Animal的实例，Dog作为Animal使用是类型安全的，消费Animal的方法消费Dog也是类型安全的，因此Animal消费者作为Dog消费者也是类型安全的。这体现的是逆变。
委托可以视为类型安全的函数类型，函数类型也可以视为构造类型(由参数类型+返回类型构造),在这个视角看待类型兼容也许有不一样的发现。可参考本站文章CTFP(category theory for programmer/面向程序员的范畴论)中协变和逆变的相关内容。

高阶泛型

Higher Kind

Higher Rank

参考链接

Generic programming

Parametric polymorphism

本文内容经过较长时间整理、

Java语言功能更新

Thu, 08 May 2025 00:00:00 +0800

Java语言功能更新

当前整理范围: JDK9->JDK21(LTS)

参考链接

A categorized list of all Java and JVM features since JDK 8 to 21 by Dávid Csákvári
New language features since Java 8 to 21 by Dávid Csákvári
Java 9 到 21 的语言特性更新 by Alex Tan - 本文是引文2中文翻译&整理
Java Language and Virtual Machine Specifications
Java Platform, Standard Edition Java Language Updates, Release 21 - Oracle官方整理的Java SE 9到特定版本的语言功能更新(修改URL中的版本号可以查看9到其他版本的功能更新)
JEP 0: JEP Index

参考以上内容进消化整理

Java 9

该版本新增的语言功能详情可参考: JEP 213: Milling Project Coin

1. 接口中允许私有方法

Java8允许接口实现默认方法，在Java9中允许接口实现私有方法。可以将期望复用但又不想公开暴露的代码放到私有方法中，由默认方法调用。

public interface Interface {
    default void op1() {
        // code ...
        common();
    }
    default void op2() {
        // code ...
        common();
    }
    private void common() {
        // common code
    }
}

2. 匿名内部类的钻石操作符

Java7引入钻石操作符<>，调用构造器时允许编译器推断泛型类型，降低没必要的类型参数声明，例如：List<Integer> numbers = new ArrayList<>();。但该功能并不支持匿名内部类，相关邮件: Diamond operator and anonymous classes。

相关问题已在Java9解决，此后以下代码可被接受了。

Callable<Integer> task = new Callable<>() {
    public Integer call() {
        return doSomething();
    }
};

Comparator<MyClass> FORWARD = new Comparator<>() {
    @Override
    public int compare(MyClass first, MyClass second) {
        // comparator logic
    }
};

3. effectively-final变量在`try-with-resources`语句中可作为资源使用

Java7引入try-with-resources语句来简化资源释放，示例如下。

// java7之前需要手动管理资源释放
BufferedReader br = new BufferedReader(...);
try {
    return br.readLine();
} finally {
    if (br != null) {
        br.close();
    }
}

// java7可以用该语句自动释放资源，减少样板代码
try (BufferedReader br = new BufferedReader(...)) {
    return br.readLine();
}

实际使用中，也会存在一些短板，示例如下。

// 多个资源的时候代码有点难读
try (BufferedReader br1 = new BufferedReader(...);
    BufferedReader br2 = new BufferedReader(...)) {
    System.out.println(br1.readLine() + br2.readLine());
}

// 处理已有资源的时候仍需要定义变量
try (Closeable c = resouce) {
    // ...
}

Java9解决了这些问题，现在也可以处理不可变或实际不可变的局部变量，示例如下。

BufferedReader br1 = new BufferedReader(...);
BufferedReader br2 = new BufferedReader(...);
try (br1; br2) {
    System.out.println(br1.readLine() + br2.readLine());
}

注意，由于变量在try-with-resources语句外可用，但此时资源已被释放，所以操作基本都会失败，要特别注意。示例如下。
1
2
3
4
5
BufferedReader br = new BufferedReader(...);
try (br) {
    System.out.println(br.readLine());
}
br.readLine(); // Boom!

4. 下划线不可作为标识符使用

Java8中将_作为标识符使用时，编译器会输出警告。Java9更进一步，将此情形视为错误，这是保留该符号未来做特殊使用。

// java7-: 变量可用
// java8: 编译警告 变量可用
// java9 -> 20: 编译错误
// java21(开启预览功能): 编译通过 变量不可用
// java22+: 编译通过 变量不可用
int _ = 10;

5. 警告改进

@SafeVarargs注解只能用于不可被覆写的方法，此前只包括构造方法、静态方法、final实例方法。实际上私有实例方法也算是，现在可以将@SafeVarargs注解在私有方法上用以抑制Type safety: Potential heap pollution via varargs parameter警告。可变参数和泛型两者结合使用时可能产生问题，编译器会输出警告，当程序员确保没有进行危险操作时，使用该注解抑制警告。注解使用示例如下(参考自Annotation Type SafeVarargs)。

// 此前只能用于标记构造函数、static方法、final方法

@SafeVarargs // 实际上并不安全
static void m(List<String>... stringLists) {
    Object[] array = stringLists;
    List<Integer> tmpList = Arrays.asList(42);
    array[0] = tmpList; // 该赋值实际上不合法、但编译会正常通过
    String s = stringLists[0].get(0); // 运行时抛出ClassCastException
}

此外编译器不再为引入废弃类型告警，这些警告已经在调用的地方展示了。参考JEP 211: Elide Deprecation Warnings on Import Statements

Java 11 (LTS)

局部变量类型推断

Java 10(JEP 286: Local-Variable Type Inference)中引入(Lambda中尚不支持)，Java 11(JEP 323: Local-Variable Syntax for Lambda Parameters)中得到改进

该功能允许声明局部变量时可以略去显式类型声明，变量类型由编译器推断，某些场景中可以使代码精炼易读。如下所示。

`1`	`var awesome = new MyAwesomeClass();`

注意：与动态类型无关。

但也有些场景，使用显式类型声明更具优势，以下通过几个例子讨论。

在源码中移除显式的类型信息，可能会影响可读性。IDE能起到一定帮助，但是在代码评审或快速浏览代码时就会有影响。例如在工厂模式或构造者模式中，就要找到负责构建对象的代码，才能推断出其类型。参考以下示例。

1
2
3

var date = LocalDate.parse("2019-08-13");   // LocalDate 
var dayOfWeek = date.getDayOfWeek();        // java.time.DayOfWeek
var dayOfMonth = date.getDayOfMonth();      // int

对以上示例，若使用Joda库，调用date.getDayOfWeek()时返回值为整型，同样的方法名在不同的库中返回值也不一定相同。当代码较长时，翻看上下文确定类型变得更加困难，因此使用var要时刻考虑代码可读性。

时刻考虑可读性

此外，var消除所有可用的类型信息，甚至导致无法被推断。绝大多数情形中编译器能捕获问题，例如var不能针对lambda和方法引用进行推断，因为编译器依赖于表达式左边的声明来确定类型。但也存在一些例外。

比如当和钻石操作符搭配使用时。例如var map = new HashMap<>();，语法上是可行的，编译器甚至不会报出警告。然而完全不指定泛型类型，类型推断会给出Map<Object, Object>的结果，这大概率并非预期。此时可以考虑常规语法Map<String, String> map = new HashMap<>();，或者替换掉类型操作符var map = new HashMap<String, String>();。

与基础类型使用时也会有问题，例如byte b = 1/short s = 1/int i = 1/long l = 1/floate f = 1/double d = 1，没有显式类型声明时，类型会被推断为int。处理基本类型时，要么使用类型字面量(例如1L/1.0F/1.0D)，要么完全不使用var。

保留重要的类型信息

参考官方针对var的代码风格指南(Local Variable Type Inference Style Guidelines)和常见问题(Local Variable Type Inference Frequently Asked Questions)。

使用中尽量以保守的态度引入代码，在局部变量中使用，使之尽量在较小的作用域中生效。

仍需强调，var并非是个新的关键字，而是个保留类名。当它用作类型名的时候是有特殊含义的，其他场景下依然是个合法的标识符。例如var var = 10是个合法的声明。

目前尚不存在特定的关键字来声明不可变(例如val或const)，目前可以用final var达成预期。

参考官方的代码风格指南

Java 14

`switch`表达式

可用: 14-JEP 361: Switch Expressions (预览: 12-JEP 325: Switch Expressions (Preview); 13-JEP 354: Switch Expressions (Second Preview))

switch不再只是语句，可以是表达式，但要注意两者语法略有区别。

语句示例如下，官方文档请参考The switch Statement

// switch语句语法，逻辑上是if-else-if的简化。
// 接受的数据类型如下:
//  1. 基本数据类型: byte short int char
//  2. 包装数据类型: Byte Short Integer Character
//  3. 字符串(Java SE 7开始支持)
//  4. 枚举类型(Java SE 7开始支持)
// 注意：
//  1. 缺少break会导致的击穿(fall-through，即代码连续执行)；
//  2. null会导致抛出空指针异常
//  3. 所有case共享一个作用域(临时变量不允许重复定义)
switch (expr) {
    case value1:
        // code
        break;
    case value2:
    case value3:
        // code
        break;
    default:
        // code
}

表达式示例如下，可用于任何接受表达式的地方，例如函数参数。

int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY -> 7;
    default -> {
        String s = day.toString();
        int result = s.length();
        yield result;
    }
};

表达式不存在击穿，可以为case指定多个常量，逗号分隔。
分支可以是单个表达式，也可是语句块中的多条语句(必须以yield value;语句返回该语句块的求值结果)。
分支是独立作用域，因此可以随意定义同名变量。
表达式必须覆盖所有条件，对于常规的字符串、基本类型及其包装类型等，必须提供default分支；对于枚举，要么显式声明所有情况，要么提供default，前者是最佳实践，当枚举值变更时，编译阶段即可发现错误。

推荐使用表达式而不是语句

此处同时记录类似语句的冒号语法，但强烈不建议使用！
1
2
3
4
5
6
7
int result = switch (s) {
    case "foo":
    case "bar":
        yield 2;
    default:
        yield 3;
};
这种形式也能作为表达式使用，但击穿和共享作用域也出现了。强烈不推荐，使用箭头形式的表达式即可，避免所有问题。

Java 15

1. 文本块

可用: 15-JEP 378: Text Blocks (预览: 13-JEP 355: Text Blocks (Preview); 14-JEP 368: Text Blocks (Second Preview))

String html = """
          <html>
            <body>
              <p>Hello, world</p>
            </body>
          </html>
          """;

System.out.println(html);

该功能简化多行文本初始化工作。文本块与字符串字面量相似，但换行和引号都不需要转义。

文本块以"""开始，后面紧跟换行；以"""结束，可以紧跟最后一行，也可以单独一行。源代码中每个换行的地方都会产生一个\n字符。

文本段可以和相邻的Java代码对齐，编译器会检查每行用于缩进的空格，找到缩进最少的行，然后将每行都转化为这个相同的最少缩进。若结尾的"""是在一个单独的行，注意它的缩进情况，有可能会整体的缩进发生改变。开头的"""不会影响缩进移除，所以文本块没有必要和其对齐。

String类提供了编程方式处理缩进的方法，indent方法接受一个整数参数，返回新的符合特定缩进级别的字符串；stripIndent方法返回移除所有缩进的字符串。

此外，使用文本块需要注意以下事项：

尚不支持插值，当前可以用String::formatted及String::format来实现。
行尾空格通常会被忽略掉，当需要行尾空格时，要在行尾添加\s或\t。
换行使用\n，与当前操作系统或源代码采用的换行符无关，若存在兼容性问题，可以用String::replace进行替换。
源代码可以采用任意类型的缩进：制表符、空格或者两者混用，但文本块的每行必须使用一致的缩进。

2. 携带详细信息的空指针异常

可用: 15-Enable ShowCodeDetailsInExceptionMessages by default (14-JEP 358: Helpful NullPointerExceptions 启动程序时需指定-XX:+ShowCodeDetailsInExceptionMessages参数)

node.getElementsByTagName("name").item(0).getChildNodes().item(0).getNodeValue();

// 以前的异常信息
Exception in thread "main" java.lang.NullPointerException
        at Unlucky.method(Unlucky.java:83)

// 现在的异常信息，包含不能被执行的步骤，及其失败原因
Exception in thread "main" java.lang.NullPointerException:
  Cannot invoke "org.w3c.dom.Node.getChildNodes()" because the return value of "org.w3c.dom.NodeList.item(int)" is null
        at Unlucky.method(Unlucky.java:83)

空指针异常扩展是在JVM层面实现的，即使代码编译为较老的Java版本或者其他的JVM语言(例如Scala或Kotlin)也同样能受益。

但并非所有的空指针异常都能得到这些额外的信息，仅仅是被JVM创建并抛出的才行：

对null读写字段
对null调用方法
对null数据读写元素(索引信息不会输出)
对null拆箱

此外，该功能不支持序列化。例如通过RMI方式远程调用代码发生异常时，异常信息里不会包含相关信息。

Java 16

1. 记录类

可用: 16-JEP 395: Records (预览: 14-JEP 359: Records (Preview); 15-JEP 397: Sealed Classes (Second Preview))

其它相关内容: Data Classes and Sealed Types for Java; Records Come to Java

记录类给Java带来了数据类和封闭类型(Data Classes and Sealed Types for Java)，用于携带不可变数据。记录类可以视为元组(tuple)。

`1`	`public record Point(int x, int y) {}`

以上简练的语法声明了一个记录类Point，其具备以下定义

两个private final字段int x和int y
一个接受x和y作为参数的构造器
字段getter方法x()和y()
纳入字段x和y的方法hashCode、equals和toString

使用方式与普通类一致。

1
2
3

var point = new Point(1, 2);
point.x(); // returns 1
point.y(); // returns 2

记录类设计为浅层不可变数据(shallowly immutable data)的透明载体(transparent carriers)，定义和使用都存在限制。

记录类的字段默认final，实际上不允许非final字段。
定义记录时必须提供所有字段，记录体内不允许定义额外字段。
允许定义额外的构造方法来提供默认值，但无法隐藏包含所有字段的标准构造方法(canonical constructor)。
不能继承其它类，是隐式final的，不能被继承。
不能是抽象的。
不能声明native方法。

记录类强调不可变性，字段赋值只能通过构造方法。编译器自动添加的隐式标准构造方法和类具有一致的可见性，显式声明标准构造方法时其可见性不低于类本身。可以自定义构造方法，可以是任意可见性，但其实现必须最终委派给标准构造方法完成初始化。

对于其中的每个字段，会自动生成其getter，名称与字段名一致。可以显式定义甚至重写。

记录类可以拥有静态方法和实例方法。

代码示例如下。

record Point(int x, int y) {
    // 显式声明标准构造方法，对数据进行验证，只能保持或放大可见性
    public Point {
        if (x < 0) {
            throw new IllegalArgumentException("x >= 0");
        }
        if (y < 0) {
            // 只能在标准构造方法中进行赋值操作
            y = 0;
        }
    }
    // 声明额外构造方法，委派给标准构造方法，可以限制可见性
    Point(int i) {
        this(i, i);
    }
    // 声明额外构造方法，委派给其它构造方法，最终由标准构造方法完成初始化，可以限制可见性
    private Point() {
        this(0);
    }
    // 显式定义或重写默认为x提供的getter，同样可以处理hashCode equals toString
    @Override
    public int x() {
        // code...
        return x;
    }
    // 支持静态方法
    static Point zero() {
        // 调用了私有构造方法
        return new Point();
    }
    // 支持实例方法
    boolean isZero() {
        return x == 0 && y == 0;
    }
}

记录类专注于承载数据，因此定制性略有受限。但也是得益于这样的设计，序列化也十分容易且安全(相比于常规的类)。

记录类的实例能被序列化和反序列化。然而不能通过提供writeObject readObject readObjectNoData writeExternal或 readExternal方法来自定义其处理流程。记录类的组件（字段）负责序列化，而记录类的标准构造方法掌管反序列化。

序列化正好基于成员变量的状态，反序列化又总会调用标准构造方法，所以不可能创建一个无效状态的记录类。从开发者角度看，序列化和反序列化与以往一样。

public record Point(int x, int y) implements Serializable { }

public static void recordSerializationExample() throws Exception {
    Point point = new Point(1, 2);

    // 序列化
    ObjectOutputStream oos =
        new ObjectOutputStream(new FileOutputStream("tmp"));
    oos.writeObject(point);

    // 反序列化
    ObjectInputStream ois =
        new ObjectInputStream(new FileInputStream("tmp"));
    Point deserialized = (Point) ois.readObject();
}

关于记录类，推荐注意以下实践。

使用本地记录类来构建中间转化变量

复杂的数据转换需要中间变量，Java 16之前的典型方案是依赖于Pair或三方库里相似的holder类，再或者是自己定义（可能是静态内部）类来承载数据。前者通常不够灵活，后者又在仅用于单个方法的上下文中引入了其它类，污染了命名空间。虽然也可以在方法体中定义类，但也因为其啰嗦的语法很少这么用。

Java 16进行了改进，可以在方法体中定义本地记录类。

public List<Product> findProductsWithMostSaving(List<Product> products) {
    record ProductWithSaving(Product product, double savingInEur) {}

    products.stream()
        .map(p -> new ProductWithSaving(p, p.basePriceInEur * p.discountPercentage))
        .sorted((p1, p2) -> Double.compare(p2.savingInEur, p1.savingInEur))
        .map(ProductWithSaving::product)
        .limit(5)
        .collect(Collectors.toList());
}

记录类紧凑的语法正好契合 Steam API 紧凑的语法。

除了记录类外，这个改进也适用于本地枚举甚至接口。

检查引用的类库

记录类没有遵循JavaBeans的约定，一些遵循约定的工具类和记录类可能不能正常使用。

没有默认的构造方法
没有setter方法
访问器方法不依照getX()格式

例如，记录类不能用作JPA(例如Hibernate)的实体。有一些关于JPA遵循记录类规范的讨论，但迄今为止没找到相关开发进度的报道。但也有文章指出将记录类能应用到项目中且没有问题。

大多数Dávid Csákvári 试过的工具类（包括Jackson，Apache Commons Lang，JSON-P，Guava ）都支持记录类，但还存在些小问题。比如，流行的JSON库Jackson较早就支持记录类。它的大多数特性，包括对记录类和 JavaBeans 的序列化、反序列化都没什么问题，但操控对象的特性还没适配。

Spring也在许多情况下对记录类提供开箱即用的支持，包括序列化甚至依赖注入，但许多 Spring 应用程序使用的ModelMapper库不支持将JavaBeans映射到记录类。

建议在使用记录类前先升级并检查使用的工具库，避免意外之喜，但大体上来说，可以认为流行的工具库已经涵盖了大部分特性。

参看关于记录类的工具库集成试验。

使用模式匹配快速访问字段

实践中建议考虑使用switch模式匹配及instanceof模式匹配与记录类结合使用，便捷地解构对象。

2. `instanceof`模式匹配

可用: 16-JEP 394: Pattern Matching for instanceof (预览: 14-JEP 305: Pattern Matching for instanceof (Preview); 15-JEP 375: Pattern Matching for instanceof (Second Preview))

// 传统形式代码，需要进行显式类型转换
if (obj instanceof String) {
    String s = (String) obj;
    // code
}

// 现在更简练
if (obj instanceof String s) {
    // code
}

该模式是类型检查(obj instanceof String)和模式变量(s)的组合，类型检查和旧的instanceof操作符几乎一样，但模式确定无法匹配的话会导致编译错误。示例如下。

// 该模式匹配必定失败，因此在编译时报错
Integer i = 1;
if (i instanceof String s) { 
    // code
}

仅在检查通过时，模式变量才会从目标变量中提取出来。几乎和常规的非final变量一样，值能被修改、会隐藏(shadow)字段、同名变量引发编译错误。但模式变量作用域是基于控制流分析确定的，仅限在**明确匹配(definitely matched)**的作用域内生效，甚至支持更复杂的情形。

// 可以用于后续判断
if (obj instanceof String s && s.length() > 5) {
    // code...
}

// 也支持提前返回值或抛出异常
private static int getLength(Object obj) {
    if (!(obj instanceof String s)) {
        throw new IllegalArgumentException();
    }
    // 代码是正确的，此处是模式变量的作用域
    return s.length();
}

流程控制的作用域解析和现有的流程解析很相似，比如对明确赋值(definite assignment)的检查，代码示例如下。

private static int getDoubleLength(String s) {
    int a; // 声明但未赋值
    if (s == null) {
        return 0; // 已返回
    } else {
        a = s.length(); // 赋值
    }
    // 已确定完成赋值 因此直接可用
    a = a * 2;
    return a;
}

相对于其它现代编程语言还是稍显啰嗦，例如kotlin无需声明模式变量，直接在原变量上调用方法。但实际上模式变量是确保向后兼容性的手段。改变obj instanceof String 中的类型也就意味着，在其被用作重载方法参数的时候，调用可能会被解析成这个方法的不同版本。

1
2
3

if (obj is String) {
    print(obj.length)
}

在该版本中预览了记录类和模式匹配组合使用的“记录类模式”，该模式匹配将在下文详细介绍。

Java 17 (LTS)

封闭类

可用: 17-JEP 409: Sealed Classes (预览: 15-JEP 360: Sealed Classes (Preview); 16-JEP 397: Sealed Classes (Second Preview))

封闭类用于限定哪些类或接口可以被用于继承或实现它们。之前的机制是final结合访问修饰符，标记为final的类不允许被继承，配合访问修饰符就能确保仅同一包中的类才能继承。封闭类提供更细粒度的控制，让开发者能显式地列举其子类。

// sealed声明封闭类，permits声明允许直接继承该封闭类的类型(实际上permits是要求必须直接继承封闭类)
public sealed class Shape
    permits Circle, Quadrilateral, WeirdShape {}

// final声明该类不允许再被继承
public final class Circle extends Shape {}

public sealed class Quadrilateral extends Shape
    permits Rectangle, Parallelogram {}
public final class Rectangle extends Quadrilateral {}
public final class Parallelogram extends Quadrilateral {}

// non-sealed声明该类可以被任意继承
public non-sealed class WeirdShape extends Shape {}

继承封闭类时，必须通过添加final/sealed/non-sealed显式定义出封闭类的边界，这也就使整条继承链的继承情况是明确定义的。

被允许继承的类必须和父类（封闭类）在同一个包里，如果是使用java模块，那它们必须在同一模块中。

如果类都比较简短，且大部分和数据相关，可以声明在同一个源文件，permits关键字可以忽略。

public sealed class Shape {
    public final class Circle extends Shape {}

    public sealed class Quadrilateral extends Shape {
        public final class Rectangle extends Quadrilateral {}
        public final class Parallelogram extends Quadrilateral {}
    }

    public non-sealed class WeirdShape extends Shape {}
}

记录类是隐式final的，可以作为封闭类的子类。

推荐使用封闭类而非枚举

，比如： java

enum Expression { ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION }

在封闭类出现前，只能用枚举类对固定可选项建模。然而所有的情况都要在同一个源文件中写完，且枚举类仅支持常量，不支持需要实例的情况，例如表示一个类型的单个消息。

封闭类提供一个比枚举类更好的选择，使得用普通类来为固定可选项建模成为可能。配合switch模式匹配就更能充分发挥其作用，封闭类能像枚举一样在switch表达式中使用，编译器能自动检查代码是否涵盖了全部情况。

枚举类的值可以使用values方法列举出来。对应到封闭类和封闭接口，可以使用getPermittedSubclasses方法例举出所有被允许继承的子类。

Java 21 (LTS)

1. `switch`模式匹配

可用: 21-JEP 441: Pattern Matching for switch; 预览: 17-JEP 406: Pattern Matching for switch (Preview); 18-JEP 420: Pattern Matching for switch (Second Preview); 19-JEP 427: Pattern Matching for switch (Third Preview); 20-JEP 433: Pattern Matching for switch (Fourth Preview)

switch表达式可以对任意类型进行复杂的模式匹配，以下通过示例演示。

switch支持常量模式匹配，与传统的表达式用法基本一致

// 对枚举值进行匹配
var symbol = switch (expr) {
    case ADDITION       -> "+";
    case SUBTRACTION    -> "-";
    case MULTIPLICATION -> "*";
    case DIVISION       -> "/";
};

switch支持类型模式匹配，类似instanceof模式匹配

return switch (expression) {
    case Addition expr       -> "+";
    case Subtraction expr    -> "-";
    case Multiplication expr -> "*";
    case Division expr       -> "/";
};

模式还支持卫语句(guard)，写法为type pattern when guard expression

String formatted = switch (o) {
    case Integer i when i > 10 -> String.format("a large Integer %d", i);
    case Integer i             -> String.format("a small Integer %d", i);
    default                    -> "something else";
};

这与instanceof模式匹配是一致的，代码如下所示。

if (o instanceof Integer i && i > 10) {
    return String.format("a large Integer %d", i);
} else if (o instanceof Integer i) {
    return String.format("a large Integer %d", i);
} else {
    return "something else";
}

模式变量作用域也类似，是分支敏感的。例如在case Integer i && i > 10 -> String.format("a large Integer %d", i);语句中，变量i作用域是卫语句及其右侧的表达式。

switch支持匹配null值。传统的switch语句接受到null时会抛出空指针异常，switch表达式为保持后向兼容性，当没有显式声明null模式时也会抛出异常。

switch (s) {
    case null  -> System.out.println("Null");
    case "Foo" -> System.out.println("Foo");
    default    -> System.out.println("Something else");
}

switch表达式必须是详尽的，要求覆盖所有可能输入。该约束与枚举、封闭类和泛型能很好协作。若只有一组固定输入，那便可以略去默认分支。这对维护代码有很大帮助，例如当给枚举新增常量，那么涉及该枚举的所有缺失默认分支的匹配都会在编译时抛出错误。详尽性检查是在编译时进行，但如果在运行时有新的实现（例如来自单独的编译），编译器还会插入一个默认分支去抛出MatchException。

sealed interface I<T> permits A, B {}
final class A<X> implements I<String> {}
final class B<Y> implements I<Y> {}

static int testGenericSealedExhaustive(I<Integer> i) {
    return switch (i) {
        case B<Integer> bi -> 42;
    };
}

以上代码来自JEP 441: Pattern Matching for switch，展示了模式匹配与封闭类和泛型的写作，代码能正确通过编译是因为编译器可以检测到只有A和B是I的有效子类型，并且由于泛性参数Integer，该参数只能是B<Integer>的实例。

编译器也会执行与详尽性检查相反的操作，当编译器发现一个分支完全涵盖另一个分支时，会报出编译错误。代码示例如下。

Object o = 1234;
// 编译错误，第二个条件已包含在第一个条件分支中
String formatted = switch (o) {
    case Integer i             -> String.format("a small Integer %d", i);
    case Integer i when i > 10 -> String.format("a large Integer %d", i);
    default                    -> "something else";
};

出于代码可读性及正确性原因，强烈建议将常量匹配放在其相应的类型匹配之前，使更具体的分支先被匹配到。考虑以下代码，如果将常量匹配与带卫语句的类型匹配交换次序，当传入1时，会得到不同的结果。

switch(num) {
    case -1, 1 -> "special case";
    case Integer i when i > 0 -> "positive number";
    case Integer i -> "other integer";
}

原文说的是编译器强制要求常量置前，实测并非如此。

2. 记录类模式

可用: 21-JEP 440: Record Patterns (预览: 19-JEP 405: Record Patterns (Preview); 20-JEP 432: Record Patterns (Second Preview))

记录类模式可以看作更强大的类型模式，在匹配时可以直接解构出对象的值(支持嵌套)。

interface Point { }
record Point2D(int x, int y) implements Point { }
record Point3D(int x, int y, int z) implements Point { }

enum Color { RED, GREEN, BLUE }
record ColoredPoint(Point p, Color c) { }

// 构造对象
Point p1 = new ColoredPoint(new Point2D(3, 4), Color.GREEN);
Point p2 = new ColoredPoint(new Point2D(1, 2, 3), Color.RED);

// switch模式匹配解构对象
var length = switch (p) {
    case ColoredPoint(Point3D(int x, int y, int z), Color c) -> Math.sqrt(x*x + y*y + z*z);
    case ColoredPoint(Point2D(int x, int y), Color c) -> Math.sqrt(x*x + y*y);
    case ColoredPoint(Point p, Color c) -> 0;
}

// instanceof模式匹配也可以直接解构，实践中按需选择即可
if (p instanceof ColoredPoint(Point2D(int x, int y), Color c)) {
    // code
} else if (p instanceof ColoredPoint(Point3D(int x, int y, int z), Color c)) {
    // code
}

记录类模式简化了复杂的对象类型验证及字段提取工作，尤其是有嵌套对象的场景。

3. 其它预览功能

JDK21中还有如下的预览语言功能，此处仅记录。待到下个LTS版本发布(Java 25 2025-09)再做详细整理。

匿名模式和匿名变量 JEP 443: Unnamed Patterns and Variables (Preview)
字符串模板 JEP 430: String Templates (Preview)
未具名类和实例主方法 JEP 445: Unnamed Classes and Instance Main Methods (Preview)

近期终于能稍微抽身，做些“新潮”的东西，动手时与时代的脱节感愈发强烈，甚至感觉无从下手。翻看Git仓库，上次正经整理博客是2020年，已经是五年前的事情了。这五年感觉像是遗失的梦一般，倏忽跳跃到现在，向前回忆却想不到闪光之处。懈怠多年，轻易挥霍时光，对自己感到遗憾和抱歉。学习应当是终生坚持的事情，无论是编程还是其他。重新出发，充实自己，永不止步。

Java on boboboker~

泛型

泛型

基本语法

C#

泛型接口、泛型类和泛型方法

泛型委托和泛型事件

泛型数组

F#

Java

泛型约束

C#

泛型约束常规应用

default约束

关于?标注

关于歧义

消除歧义

unmanaged约束

委托约束

枚举约束

类型参数继承/实现声明的类/接口(F-Bound)

allows ref struct约束

F-Bound

可变性

C#

泛型接口/委托中的可变性

非泛型场景中的可变性

高阶泛型

Higher Kind

Higher Rank

参考链接

Java语言功能更新

Java语言功能更新

参考链接

Java 9

1. 接口中允许私有方法

2. 匿名内部类的钻石操作符

3. effectively-final变量在try-with-resources语句中可作为资源使用

4. 下划线不可作为标识符使用

5. 警告改进

Java 11 (LTS)

局部变量类型推断

Java 14

switch表达式

Java 15

1. 文本块

2. 携带详细信息的空指针异常

Java 16

1. 记录类

2. instanceof模式匹配

Java 17 (LTS)

封闭类

Java 21 (LTS)

1. switch模式匹配

2. 记录类模式

3. 其它预览功能

`default`约束

关于`?`标注

`unmanaged`约束

`allows ref struct`约束

3. effectively-final变量在`try-with-resources`语句中可作为资源使用

`switch`表达式

2. `instanceof`模式匹配

1. `switch`模式匹配