Java 中泛型的限制

2025 年 1 月 6 日 | 阅读 9 分钟

Java 泛型允许定义带有类型参数的类、接口和方法，这可以提高类型安全性并减少显式类型转换的需要，但由于泛型的设计和实现，它存在一些重要的限制。这些限制是由于 Java 为了兼容性原因而选择使用类型擦除来实现其泛型。

1. 类型参数无法实例化

Java 泛型的一个主要限制是无法直接实例化类型参数，这是因为泛型是使用类型擦除来实现的，在运行时会擦除泛型类型信息。类型擦除是与 Java 泛型相关的一个重要概念，它使得泛型代码能够与旧式代码兼容。

public class Box<T> {
    private T value;
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}

尝试直接实例化 T 会导致编译错误。

更正后的格式

使用 Class 参数

文件名：BoxGeneric.java

class Box<T> {
    private T value;
    private Class<T> type;
    public Box(Class<T> type) {
        this.type = type;
    }
    public T createInstance() throws IllegalAccessException, InstantiationException {
        return type.newInstance();
    }
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}
public class BoxGeneric {
    public static void main(String[] args) {
        try {
            Box<String> stringBox = new Box<>(String.class);
            String strInstance = stringBox.createInstance();
            stringBox.setValue("Hello, Generics!");
            System.out.println("String Box Value: " + stringBox.getValue());
            Box<Integer> integerBox = new Box<>(Integer.class);
            // Integer cannot be instantiated using newInstance() directly, so we need a different approach.
            // This example showcases the limitation with Integer type and we will use another method later.
            // Integer intInstance = integerBox.createInstance(); // This will throw InstantiationException
            integerBox.setValue(123);
            System.out.println("Integer Box Value: " + integerBox.getValue());
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

}

输出

String Box Value: Hello, Generics!
Integer Box Value: 123

2. 静态上下文

Java 泛型中的静态上下文由于类级别和实例级别行为的分离而施加了某些限制。静态字段和方法不能直接使用类级别的类型参数，这需要为泛型静态方法使用方法级别的类型参数。

// MyClassWithErrors.java - The code contains errors
public class MyClassWithErrors<T> {
    // Static field using generic type parameter - It will cause a compilation error
    private static T value;  // Error: Cannot make a static reference to the non-static type T
    // Static method using generic type parameter - It will cause a compilation error
    public static void staticMethod(T param) {  // Error: Cannot make a static reference to the non-static type T
        System.out.println(param);
    }
    public static void main(String[] args) {
        // Attempt to call the static method - It will cause a compilation error
        MyClassWithErrors<String>.staticMethod("Hello, World!"); // Error: Cannot make a static reference to the non-static type T
    }
}

更正后的格式

文件名：MyClass<T>.java

// MyClass.java - Corrected version
public class MyClass<T> {
    // Corrected version does not use the generic type parameter T in static context
    private static Object staticValue;
    // Static method using method-level type parameter
    public static <U> void staticMethod(U param) {
        System.out.println("Static method parameter: " + param);
    }
    // Static method to set the staticValue
    public static void setStaticValue(Object value) {
        staticValue = value;
    }
    // Static method to get the staticValue
    public static Object getStaticValue() {
        return staticValue;
    }
    public static void main(String[] args) {
        // Correct usage of the static method with method-level type parameter
        MyClass.staticMethod("Hello, Generics with Static Method!");
        MyClass.staticMethod(123);
        // Correct usage of the static field methods
        MyClass.setStaticValue("This is a static value");
        System.out.println("Static Value: " + MyClass.getStaticValue());
    }
}

输出

Static method parameter: Hello, Generics with Static Method!
Static method parameter: 123
Static Value: This is a static value

3. 对原始数据类型的限制

Java 泛型的一个显著限制是它们只能与引用类型一起使用，而不能与原始类型一起使用，这个限制根植于 Java 的设计和类型系统中。

尝试将原始类型 int 与泛型一起使用 - 这将导致编译错误

// BoxWithPrimitiveError.java - the code contains errors
public class BoxWithPrimitiveError<T> {
    private T value;
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
    public static void main(String[] args) {
        BoxWithPrimitiveError<int> intBox = new BoxWithPrimitiveError<>(); // Error: unexpected type
        intBox.setValue(10);
        System.out.println("Boxed value: " + intBox.getValue());
    }
}

更正后的格式

使用包装类

使用泛型处理原始类型的正确方法是使用它们对应的包装类。

文件名：BoxWithPrimitive<T>.java

// Box.java - Corrected version using wrapper classes
public class BoxWithPrimitive<T> {
    private T value;
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
    public static void main(String[] args) {
        // Using wrapper class Integer instead of primitive type int
        BoxWithPrimitive<Integer> intBox = new BoxWithPrimitive<>();
        intBox.setValue(10); // Autoboxing: primitive int to Integer
        System.out.println("Boxed value: " + intBox.getValue()); // Unboxing: Integer to int
    }
}

输出

Boxed value: 10

使用专用类

在某些情况下，为了避免自动装箱和拆箱的性能开销，您可能需要使用专用类。

文件名：IntBox.java

// IntBox.java - Specialized class for primitive int type
public class IntBox {
    private int value;
    public void setValue(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
    public static void main(String[] args) {
        IntBox intBox = new IntBox();
        intBox.setValue(10);
        System.out.println("Boxed value: " + intBox.getValue());
    }
}

输出

Boxed value: 10

4. 对数组创建的限制

在 Java 中，由于存在一些关键限制，数组和泛型无法无缝地协同工作。这些限制主要源于类型擦除和堆污染的可能性。

限制 1：使用类型参数实例化数组

我们不能直接实例化一个元素类型为类型参数的数组。原因是类型擦除会在运行时移除泛型类型信息，因此编译器不知道要创建哪种特定类型的数组。

public class Box<T> {
    private T[] array;
    public Box() {
        array = new T[10]; // Compilation error: generic array creation
    }
}

更正后的格式

传递类型兼容的数组引用

我们可以传递一个类型兼容数组的引用作为参数，并将其分配给数组字段。

文件名：ABox<T>.java

public class ABox<T> {
    private T[] array;
    public ABox(T[] array) {
        this.array = array;
    }
    public T get(int index) {
        return array[index];
    }
    public void set(int index, T value) {
        array[index] = value;
    }
    public static void main(String[] args) {
        String[] strArray = new String[10];
        ABox<String> stringABox = new ABox<>(strArray);
        stringABox.set(0, "Hello");
        System.out.println(stringABox.get(0)); // Output: Hello
    }
}

输出

Hello

限制 2：使用特定类型的泛型引用创建数组

我们不能创建特定类型泛型引用的数组，因为编译器不知道要创建哪种特定类型的数组。此限制与第一个类似，但适用于泛型类型的数组。

public class GenericBox<T> {
    private GenericBox<String>[] boxes; // Compilation error: generic array creation
    public GenericBox() {
        boxes = new GenericBox<String>[10]; // Compilation error
    }
}

更正后的格式

使用通配符

在原始类型的位置使用通配符可以帮助保留一些类型检查，并使代码更安全。

文件名：GenericBox<T>.java

public class GenericBox<T> {
    private GenericBox<?>[] boxes;
    public GenericBox(int size) {
        boxes = new GenericBox<?>[size]; // Use wildcard for some type safety
    }
    public void set(int index, GenericBox<?> box) {
        boxes[index] = box;
    }
    public GenericBox<?> get(int index) {
        return boxes[index];
    }
    public static void main(String[] args) {
        GenericBox<String> stringBox = new GenericBox<>(10);
        stringBox.set(0, new GenericBox<String>(10)); // Specify the type parameter explicitly
        System.out.println(stringBox.get(0)); // Output: GenericBox@<hashcode>
    }
}

输出

GenericBox@2b2fa4f7

2. 通配符在写入上下文中的限制

Java 泛型中的通配符（?）在保持类型安全的同时，提供了处理不同类型的灵活性。然而，它们在写入上下文中存在一些限制，可能难以处理。

错误 1：错误地使用 ? extends T 通配符

import java.util.ArrayList;
import java.util.List;
public class WildcardExample {
    public static void main(String[] args) {
        List<? extends Number> numbers = new ArrayList<>();
        numbers.add(new Integer(10)); // Compilation error here
        Number num = numbers.get(0); // OK: Can read from the list
    }
}

语句 numbers.add(new Integer(10)); 会导致编译错误，因为 List<? extends Number> 可能指向 List<Integer>、List<Double> 等，编译器无法保证将 Integer 添加到可能不同的子类型中时的类型安全。

文件名：WildcardExample.java

import java.util.ArrayList;
import java.util.List;
public class WildcardExample {
    public static void main(String[] args) {
        List<Integer> integers = new ArrayList<>();
        integers.add(10); // OK: Adding Integer to a List<Integer>
        List<? extends Number> numbers = integers;
        Number num = numbers.get(0); // OK: Can read from the list
        System.out.println(num); // Output: 10
    }
}

输出

在更正后的代码中，integers 被显式键入为 List<Integer>，这允许直接添加 Integer 元素。然后将 numbers 列表分配给 integers，这是安全的，因为 List<Integer> 是 List<? extends Number> 的子类型。读取元素（numbers.get(0)）仍然有效，因为编译器知道该列表包含 Number 或其子类型。

错误 2：错误地使用 ? super T 通配符

import java.util.ArrayList;
import java.util.List;
public class WildcardExample {
    public static void main(String[] args) {
        List<? super Integer> integers = new ArrayList<>();
        integers.add(new Integer(10)); // OK: Can add Integer or its subtypes
        Integer num = integers.get(0); // Compilation error here
    }
}

语句 Integer num = integers.get(0); 会导致编译错误，因为 List<? super Integer> 可能指向 List<Integer>、List<Number>、List<Object> 等。在不知道列表的确切类型的情况下，将元素作为 Integer 读取不是类型安全的。

文件名：WildcardExample1.java

import java.util.ArrayList;
import java.util.List;
public class WildcardExample1 {
    public static void main(String[] args) {
        List<? super Integer> integers = new ArrayList<>();
        integers.add(Integer.valueOf(10)); // Use valueOf method instead of deprecated constructor
        Object obj = integers.get(0); // OK: Reading as Object (needs casting for Integer)
        Integer num = (Integer) obj; // Casting to Integer
        System.out.println(num); // Output: 10
    }
}

输出

在更正后的代码中，integers 被显式键入为 List<? super Integer>，允许添加 Integer 或其子类型。检索元素 (integers.get(0)) 时，会作为 Object 获取，需要转换为 Integer，因为编译器将其视为 Object。

6. 原始类型

Java 中的原始类型是指在使用泛型类或接口时未指定类型参数。例如，List 而不是 List<T>。虽然为了与旧代码库兼容，Java 允许使用原始类型，但通常不鼓励使用，原因包括未检查的警告和潜在的类型安全问题。

文件名：RawTypeExample.java

import java.util.ArrayList;
import java.util.List;
public class RawTypeExample {
    // Method to print elements of a raw type list
    public static void printRawList(List list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }
    public static void main(String[] args) {
        // Create a raw type list
        List list = new ArrayList();
        // Adding elements to the raw type list
        list.add("String"); // OK: Adding String to a raw list
        list.add(10); // OK: Adding Integer to a raw list (no compile-time error)
        // Type safety issue: Retrieving elements without type casting
        String str = (String) list.get(0); // Compiles but potential ClassCastException at runtime
        System.out.println("Element at index 0: " + str); // Output: String
        // Type safety issue: Adding elements without type checking
        for (Object obj : list) {
            // Unchecked warning: obj is treated as Object
            System.out.println(obj);
        }
        // Using raw type with generic methods (Unchecked warnings)
        List<Integer> integerList = new ArrayList<>();
        integerList.add(100);
        integerList.add(200);
        printRawList(integerList); // Unchecked warning: raw use of parameterized class 'List'
        // Raw type with a parameterized method (Unchecked warning)
        List<String> stringList = new ArrayList<>();
        stringList.add("Java");
        stringList.add("Programming");
        addToList(list, "Hello"); // Unchecked warning: raw use of parameterized class 'List'
        // Compile-time safety with parameterized list
        List<String> typedList = new ArrayList<>();
        typedList.add("Type");
        typedList.add("Safety");
        printList(typedList); // No warning: Correct use of parameterized class 'List<String>'
    }
    // Method to add an element to a raw type list
    public static void addToList(List list, Object element) {
        list.add(element); // Adding element to raw type list
    }
    // Method to print elements of a parameterized list
    public static void printList(List<String> list) {
        for (String str : list) {
            System.out.println(str);
        }
    }
}

输出

Note: RawTypeExample.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
Element at index 0: String
String
10
100
200
Type
Safety

结论

Java 泛型施加限制是为了维护类型安全并与遗留代码库保持兼容。虽然这些限制有时可能需要变通的解决方案或额外的谨慎，但它们对于编写健壮且可维护的代码至关重要。

下一主题使用多线程在 Java 中计算单词数

Java 中泛型的限制

1. 类型参数无法实例化

更正后的格式

2. 静态上下文

更正后的格式

3. 对原始数据类型的限制

更正后的格式

4. 对数组创建的限制

限制 1：使用类型参数实例化数组

更正后的格式

限制 2：使用特定类型的泛型引用创建数组

更正后的格式

2. 通配符在写入上下文中的限制

错误 1：错误地使用 ? extends T 通配符

错误 2：错误地使用 ? super T 通配符

6. 原始类型

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中泛型的限制

1. 类型参数无法实例化

更正后的格式

2. 静态上下文

更正后的格式

3. 对原始数据类型的限制

更正后的格式

4. 对数组创建的限制

限制 1：使用类型参数实例化数组

更正后的格式

限制 2：使用特定类型的泛型引用创建数组

更正后的格式

2. 通配符在写入上下文中的限制

错误 1：错误地使用 ? extends T 通配符

错误 2：错误地使用 ? super T 通配符

6. 原始类型

结论

相关帖子

Java 中静态和动态的区别

Java 缩进

How to Achieve Abstraction in Java?

Java ExecutorService

Java 中的精度设置

Flow control in try catch finally in Java

如何将 ArrayList 传递给 Java 方法

Java 中的 DAO 类

如何在 Java 中创建具有特定所有者和组的文件

Java 中空类的大小

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器