Java 泛型详解：语法、擦除与通配符 | 极客日志

Javajava

Java 泛型详解：语法、擦除与通配符

Java 泛型通过类型参数实现代码复用与类型安全。主要内容包括泛型类与方法的定义语法，利用 extends 和 super 设置类型边界。深入解析类型擦除机制，解释编译期检查与运行期信息丢失的影响。介绍通配符 ?、? extends 及 ? super 在读写操作中的区别与限制。总结泛型无法使用基本类型、不能创建泛型数组等常见限制，并提供最佳实践建议。

人间过客发布于 2026/2/10更新于 2026/4/188.4K 浏览

Java 泛型详解：语法、擦除与通配符

Java 泛型详解

泛型类

语法

class 泛型类名称<类型形参列表> {
    // 这里可以使用类型参数
}

class ClassName<T1, T2, ..., Tn> {
}

class 泛型类名称<类型形参列表> extends 继承类 {
    // 这里可以使用类型参数
}

class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
    // 可以只使用部分类型参数
}

使用

// 定义一个泛型类引用
class MyArray<T> {
    public Object[] array = new Object[10];
    public void set(int pos, T val) { array[pos] = val; }
    public T get(int pos) { return (T)array[pos]; }
    public Object[] getArray() { return array; }
}

public class Test {
    public static void main(String[] args) {
        MyArray<String> myArray = new MyArray<>();
    }
}

泛型上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

定义

class 泛型类名称<类型形参 extends 类型边界> {
    ...
}

使用

 <T  > {
     Object[] array =  [];
       { array[pos] = val; }
     T  {  (T)array[pos]; }
     Object[] getArray() {  array; }
}

   {
        {
        
        
        
        MyArray<Integer> myArray =  <>();
    }
}

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

Keycode 信息
查找任何按下的键的javascript键代码、代码、位置和修饰符。在线工具，Keycode 信息在线工具，online
Escape 与 Native 编解码
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。在线工具，Escape 与 Native 编解码在线工具，online
JavaScript / HTML 格式化
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。在线工具，JavaScript / HTML 格式化在线工具，online
JavaScript 压缩与混淆
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。在线工具，JavaScript 压缩与混淆在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

class MyArray<E> { // E 会被擦除为 Object }
class MyArray<E extends Comparable<E>> { // E 被擦除为 Comparable }

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

class Message<T> {
    private T message;
    public T getMessage() { return message; }
    public void setMessage(T message) { this.message = message; }
}

public class Test {
    // 可以传入任意类型的 Message
    public static void fun(Message<?> temp) {
        System.out.println(temp.getMessage());
    }
    public static void main(String[] args) {
        Message<String> message = new Message<>();
        message.setMessage("你好！");
        fun(message);
        Message<Integer> message2 = new Message<>();
        message2.setMessage(199);
        fun(message2);
    }
}

class Food { }
class Fruit extends Food { }
class Apple extends Fruit { }
class Banana extends Fruit { }
class Message<T> {
    private T message;
    public T getMessage() { return message; }
    public void setMessage(T message) { this.message = message; }
}

public class Test1 {
    public static void funExtends(Message<? extends Fruit> temp) {
        System.out.println(temp.getMessage());
        // 通配符的上界来说 是不可以进行修改元素的
        // temp.setMessage(new Banana());
        // 向上转型
        Fruit fruit = temp.getMessage();
    }
    public static void main(String[] args) {
        Message<Apple> message1 = new Message<>();
        message1.setMessage(new Apple());
        Message<Banana> message2 = new Message<>();
        message2.setMessage(new Banana());
        funExtends(message1);
        funExtends(message2);
    }
}

class Food { }
class Fruit extends Food { }
class Apple extends Fruit { }
class Banana extends Fruit { }
class Plate<T> {
    private T plate;
    public T getPlate() { return plate; }
    public void setPlate(T plate) { this.plate = plate; }
}

public class Test1 {
    public static void funSuper(Plate<? super Fruit> temp) {
        // 此时可以修改！！添加的是 Fruit 或者 Fruit 的子类
        temp.setPlate(new Apple());
        temp.setPlate(new Banana());
        // Fruit fruit = temp.getPlate(); // 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate()); // 只能直接输出
    }
    public static void main(String[] args) {
        Plate<Fruit> message1 = new Plate<>();
        Plate<Food> message2 = new Plate<>();
        funSuper(message1);
        funSuper(message2);
    }
}

方法限定符 <类型形参列表> 返回值类型 方法名称 (形参列表) { ... }

class Alg2 {
    // 泛型方法
    public static <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

public class Test2 {
    public static void main(String[] args) {
        Integer[] array = {1, 13, 51, 71, 19};
        Integer ret = Alg2.<Integer>findMax(array);
        System.out.println(ret);
    }
}