Java反射、枚举、Lambda表达式及泛型通配符实例详解

前言

这次我们集中聊几个平时开发中高频出现、但不少同学又容易模糊的概念——反射、枚举、Lambda 表达式，以及泛型通配符。这几个知识点单独拎出来都不算难，但放在一起梳理一遍，能帮我们把 Ja va 的类型系统、运行时动态性以及函数式风格串起来，理解会更深。

一、反射

Ja va 的反射机制，说白了就是让程序在运行的时候“看穿”一个类——它能知道这个类有哪些属性、方法，甚至能调用私有的成员。如果在运行时拿到了 Class 对象，就能修改类的部分信息。这种动态获取信息、动态调用方法的能力，就是反射。

在实际开发中，反射出镜率最高的场景有两个：一是做第三方 SDK 集成时，经常遇到某些类或方法被标记为 private，常规手段调不了，反射就成了“后门”；二是各大框架的底层，比如 Spring，容器接管了所有 Bean 的管理，不管是 XML 配置还是注解配置，最终都是靠反射去动态创建实例、注入依赖。可以说，没有反射，就没有现在这些灵活的框架。

Ja va 程序中的对象在运行时其实有两种类型：编译时类型和运行时类型。比如 `Person p = new Student()`，p 的编译时类型是 Person，运行时类型却是 Student。程序需要在运行时搞清楚对象和类的真实身份，反射就是干这个的。核心用到以下几个类：

下面是官方文档的链接，值得收藏：

Class | API reference | Android Developers
Field | API reference | Android Developers
Constructor | API reference | Android Developers
Method | API reference | Android Developers

Class 类是反射的起点，它代表类的实体。Ja va 文件编译后生成 .class 文件，JVM 解析它时，会把它变成一个 ja va.lang.Class 对象。这样一来，每个 Ja va 文件在运行时都变成了 Class 类的一个实例。通过反射操作这个实例，就能获取甚至修改类的属性和行为，让类“活”起来。先看看这几个类的常用方法：

常用获得类相关的方法：

常用获得类中属性相关的方法（返回值是 Field 类）：

常用获得类中注解相关的方法（了解即可）：

常用获得类中构造器相关的方法（返回值是 Constructor 类）：

常用获得类中方法相关的方法（返回值是 Method 类）：

接下来，我们用代码说话。先写一个学生类：

package reflectdemo;
public class Student {
    private String name = "bit";
    public int age = 18;
    public Student(){
        System.out.println("Student()");
    }
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }
    private void eat(){
        System.out.println("i am eat");
    }
    public void sleep(){
        System.out.println("i am pig");
    }
    private void function(String str) {
        System.out.println(str);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

获取 Class 对象有三种方式。先看 forName 的源码：

    @CallerSensitive
    public static Class forName(String className)
                throws ClassNotFoundException {
        Class caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

方法声明了异常，所以调用时得 try-catch。代码写出来是这样：

package reflectdemo;
public class Test {
    public static void main(String[] args){
        try {
            Class c1 = Class.forName("reflectdemo.Student");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

另外两种方式也一并列出来：

Class c2 = Student.class;

Student student = new Student();
Class c3 = student.getClass();

验证一下这三种方式拿到的是否同一个 Class 对象：

package reflectdemo;
public class Test {
    public static void main(String[] args){
        try {
            Class c1 = Class.forName("reflectdemo.Student");
            Class c2 = Student.class;
            Student student = new Student();
            Class c3 = student.getClass();
            System.out.println(c1.equals(c2));
            System.out.println(c2.equals(c3));
            System.out.println(c1.equals(c3));
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

结果很清楚：三种方式拿到的都是同一个 Class 对象。所以反射的第一步，就是拿到目标类的 Class 对象，然后通过它去操作类的属性和方法。总结一下获取 Class 的三种方式：

• Class.forName("类的全路径名")：静态方法，适合在运行时明确知道类名的情况。
• 类名.class：适合在编译前就已经明确要操作的类。
• 对象.getClass()：通过实例获取。

接下来演示反射创建实例：

package reflectdemo;
public class Test {
    public static void reflectNewInstance(){
        try {
            Class c1 = Class.forName("reflectdemo.Student");
            Student student = (Student)c1.newInstance();
            System.out.println(student);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectNewInstance();
    }
}

同理，获取私有构造方法：

package reflectdemo;
import ja va.lang.reflect.Constructor;
import ja va.lang.reflect.InvocationTargetException;
public class Test {
    public static void reflectPrivateConstructor(){
        try {
            Class c1 = Class.forName("reflectdemo.Student");
            Constructor constructor = (Constructor)c1.getDeclaredConstructor(String.class, int.class);
            constructor.setAccessible(true);
            Student student = constructor.newInstance("suzhe", 21);
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectPrivateConstructor();
    }
}

注意，对于私有构造方法，必须调用 setAccessible(true) 来“确认知情并强制获取”，否则会报错。

反射私有属性：

package reflectdemo;
import ja va.lang.reflect.Constructor;
import ja va.lang.reflect.Field;
import ja va.lang.reflect.InvocationTargetException;
public class Test {
    public static void reflectPrivateField(){
        try {
            Class c1 = Class.forName("reflectdemo.Student");
            Field field = c1.getDeclaredField("name");
            field.setAccessible(true);
            Student student = (Student)c1.newInstance();
            field.set(student, "suzhe");
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectPrivateField();
    }
}

反射私有方法：

package reflectdemo;
import ja va.lang.reflect.Constructor;
import ja va.lang.reflect.Field;
import ja va.lang.reflect.InvocationTargetException;
import ja va.lang.reflect.Method;
public class Test {
    public static void reflectPrivateMethod(){
        try {
            Class c1 = Class.forName("reflectdemo.Student");
            Method method = c1.getDeclaredMethod("function", String.class);
            method.setAccessible(true);
            Student student = (Student)c1.newInstance();
            method.invoke(student, "new arg");
        } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectPrivateMethod();
    }
}

反射的优点在于：可以动态获取类的所有信息，调用任意方法，增加程序的灵活性和扩展性，降低耦合度。很多流行框架（Struts、Hibernate、Spring）的底层都有它的身影。但缺点也很明显——性能开销大，毕竟是在运行时做类型检查和解析。

二、枚举

枚举是 JDK 1.5 之后加入的特性，主要用来解决一个问题：常量管理。以前我们这样定义常量：

public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;

这样写的问题在于，类型是 int，如果碰巧有个数字 1，它可能被误认为是 RED。现在用枚举，就有了真正的类型：

public enum TestEnum {
    RED,BLACK,GREEN;
}

枚举的本质是 ja va.lang.Enum 的子类——就算没有显式继承，它也默认继承了。看一个简单的使用示例：

package enumdemo;
public enum TestEnum {
    RED,WHITE,GREEN,BLACK;
    public static void main(String[] args) {
        TestEnum testEnum = RED;
        switch(testEnum){
            case RED:
                System.out.println("RED");
                break;
            case BLACK:
                System.out.println("BLACK");
                break;
            case GREEN:
                System.out.println("GREEN");
                break;
            case WHITE:
                System.out.println("WHITE");
                break;
            default:
                System.out.println("No Match...");
                break;
        }
    }
}

枚举的常用方法：

简单演示一下：

package enumdemo;
public enum TestEnum {
    RED,WHITE,GREEN,BLACK;
    public static void main(String[] args) {
        TestEnum[] testEnums = TestEnum.values();
        for(int i = 0; i < testEnums.length; i++){
            System.out.println(testEnums[i] + ":" + testEnums[i].ordinal());
        }
        TestEnum testEnum = TestEnum.valueOf("WHITE");
        System.out.println(testEnum);
        System.out.println(WHITE.compareTo(GREEN));
    }
}

注意，枚举的构造方法默认是私有的。枚举本质上还是类，所以也可以这样定义：

package enumdemo;
public enum TestEnum {
    RED(0, "RED"), WHITE(1, "WHITE"), GREEN(2, "GREEN"), BLACK(3, "BLACK");
    public int ordinal;
    public String color;
    private TestEnum(int ordinal, String color){
        this.ordinal = ordinal;
        this.color = color;
    }
    public static void main(String[] args) {
        TestEnum[] testEnums = TestEnum.values();
        for(int i = 0; i < testEnums.length; i++){
            System.out.println(testEnums[i] + ":" + testEnums[i].ordinal());
        }
        TestEnum testEnum = TestEnum.valueOf("WHITE");
        System.out.println(testEnum);
        System.out.println(WHITE.compareTo(GREEN));
    }
}

结果和之前一样。枚举的优点很明显：常量更安全、有内置方法、代码更优雅。缺点是：不可继承，无法扩展。

刚刚在反射那部分，我们说过任何类哪怕构造方法私有，也能通过反射拿到实例。那枚举的构造方法也是私有的，能不能通过反射创建实例呢？试试看：

package enumdemo;
import ja va.lang.reflect.Constructor;
import ja va.lang.reflect.InvocationTargetException;
public class Test {
    public static void main(String[] args) {
        try{
            Class c1 = Class.forName("enumdemo.TestEnum");
            Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);
            constructor.setAccessible(true);
            TestEnum testEnum = (TestEnum)constructor.newInstance(4, "BLUE");
            System.out.println(testEnum);
        } catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

报错说没有这个构造方法，但实际上我们确实提供了。这是因为我们只传了子类的两个参数，而父类 Enum 的构造方法也需要参数。修改一下，传入四个参数：

package enumdemo;
import ja va.lang.reflect.Constructor;
import ja va.lang.reflect.InvocationTargetException;
public class Test {
    public static void main(String[] args) {
        try{
            Class c1 = Class.forName("enumdemo.TestEnum");
            Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class, String.class);
            constructor.setAccessible(true);
            TestEnum testEnum = (TestEnum)constructor.newInstance(4, "BLUE");
            System.out.println(testEnum);
        } catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

还是报错？这是因为 newInstance 方法的源码里明确做了判断：

    @CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        // ...
    }

看到没？一旦检测到是枚举类型，反射直接抛出异常。所以枚举类型是安全的——即使反射也无法破坏它的构造。

三、Lambda 表达式

Lambda 表达式是 Ja va 8 引入的一个重要特性，核心就是用表达式代替功能接口的实现。基本语法：

(parameters) -> expression
(parameters) ->{ statements; }

参数部分可以显式声明类型，也可以由 JVM 推断，当只有一个参数时，圆括号可以省略。箭头后面是方法体，可以是一个表达式或代码块。

// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值
(String s) -> System.out.print(s)

理解 Lambda 之前，先搞清楚什么是函数式接口——就是有且只有一个抽象方法的接口。如果一个接口只有一个抽象方法，它就是函数式接口。如果加了 @FunctionalInterface 注解，编译器会强制检查：

@FunctionalInterface
interface NoParameterNoReturn {
    void test();
    default void test2() {
        System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
    }
}

基本使用示例：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

Lambda 可以理解为匿名内部类的简化写法。没有 Lambda 时：

NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
    @Override
    public void test() {
        System.out.println("hello");
    }
};
noParameterNoReturn.test();

有了 Lambda 之后：

public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = ()->{
            System.out.println("无参数无返回值");
        };
    noParameterNoReturn.test();
    OneParameterNoReturn oneParameterNoReturn = (int a)->{
        System.out.println("一个参数无返回值："+ a);
    };
    oneParameterNoReturn.test(10);
    MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
        System.out.println("多个参数无返回值："+a+" "+b);
    };
    moreParameterNoReturn.test(20,30);
    NoParameterReturn noParameterReturn = ()->{
        System.out.println("有返回值无参数！");
        return 40;
    };
    int ret = noParameterReturn.test();
    System.out.println(ret);
    OneParameterReturn oneParameterReturn = (int a)->{
        System.out.println("有返回值有一个参数！");
        return a;
    };
    ret = oneParameterReturn.test(50);
    System.out.println(ret);
    MoreParameterReturn moreParameterReturn = (int a,int b)->{
        System.out.println("有返回值多个参数！");
        return a+b;
    };
    ret = moreParameterReturn.test(60,70);
    System.out.println(ret);
    }
}

简化规则：参数类型可以省略（要省就全省）；只有一个参数时小括号可省；方法体只有一句代码时大括号可省；如果方法体只有一条 return 语句，大括号和 return 关键字都可以省略。

public static void main(String[] args) {
    MoreParameterNoReturn moreParameterNoReturn = ( a, b)->{
        System.out.println("无返回值多个参数，省略参数类型："+a+" "+b);
    };
    moreParameterNoReturn.test(20,30);
    OneParameterNoReturn oneParameterNoReturn = a ->{
        System.out.println("无参数一个返回值,小括号可以省略："+ a);
    };
    oneParameterNoReturn.test(10);
    NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有一行代码");
    noParameterNoReturn.test();
    //方法体中只有一条语句，且是return语句
    NoParameterReturn noParameterReturn = ()-> 40;
    int ret = noParameterReturn.test();
    System.out.println(ret);
}

四、变量捕获及 Lambda 在集合中的使用

Lambda 表达式中有变量捕获的概念，理解它才能更好地把握作用域。匿名内部类中也有变量捕获。先看一个匿名内部类的简单例子：

class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
            }
        };
    }
}

再来看变量捕获：

class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == "+a
                    +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

变量 a 就是被捕获的变量。它要么被 final 修饰，要么在使用前没有被修改过。下面这段代码会编译报错：

public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                a = 99; // 编译错误
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == "+a
                    +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

即使把修改操作提到外部，也会报错：

public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        a = 99;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == "+a
                    +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

Lambda 中同样有变量捕获：

@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
public static void main(String[] args) {
    int a = 10;
    NoParameterNoReturn noParameterNoReturn = ()->{
        // a = 99; error
        System.out.println("捕获变量："+a);
    };
    noParameterNoReturn.test();
}

为了让 Lambda 与集合更好地配合，集合类也新增了一些接口方法：

先看 forEach 方法，它来自 Iterable 接口：

default void forEach(Consumer action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

使用示例：

public static void main(String[] args) {
    ArrayList list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.forEach(new Consumer(){
        @Override
        public void accept(String str){
            System.out.print(str+" ");
        }
    });
}

用 Lambda 简化后：

public static void main(String[] args) {
    ArrayList list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.forEach(s -> {
        System.out.println(s);
    });
}

再看 sort 方法：

public void sort(Comparator c) {
    final int expectedModCount = modCount;
    Arrays.sort((E[]) elementData, 0, size, c);
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

传统写法：

public static void main(String[] args) {
    ArrayList list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.sort(new Comparator() {
        @Override
        public int compare(String str1, String str2){
            return str1.length()-str2.length();
        }
    });
    System.out.println(list);
}

Lambda 写法：

public static void main(String[] args) {
    ArrayList list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.sort((str1,str2)-> str1.length()-str2.length());
    System.out.println(list);
}

最后看 Map 的 forEach 方法：

default void forEach(BiConsumer action) {
    Objects.requireNonNull(action);
    for (Map.Entry entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

传统写法：

public static void main(String[] args) {
    HashMap map = new HashMap<>();
    map.put(1, "hello");
    map.put(2, "bit");
    map.put(3, "hello");
    map.put(4, "lambda");
    map.forEach(new BiConsumer(){
        @Override
        public void accept(Integer k, String v){
            System.out.println(k + "=" + v);
        }
    });
}

Lambda 写法：

public static void main(String[] args) {
    HashMap map = new HashMap<>();
    map.put(1, "hello");
    map.put(2, "bit");
    map.put(3, "hello");
    map.put(4, "lambda");
    map.forEach((k,v)-> System.out.println(k + "=" + v));
}

Lambda 的优点：代码简洁、开发迅速、方便函数式编程、容易并行计算，改善了集合操作。缺点：代码可读性变差，非并行场景下性能未必优于传统 for 循环，调试起来相对麻烦。

五、泛型的通配符

泛型中的通配符 ? 用来表示某个未知类型，主要解决泛型参数过于固定导致方法复用性差的问题。由于泛型具有不变性，某个具体泛型类型不能自然代表其他泛型类型，所以通配符的出现让方法能接收多种不同类型的泛型对象。

public class TestDemo {
    public static void main(String[] args) {
        Message message = new Message();
        message.setMessage(55);
        fun(message);
    }
    public static void fun(Message temp){
        //temp.setMessage(100); 无法修改！
        System.out.println(temp.getMessage());
    }
}

无界通配符可以接收任意泛型类型，但因为具体类型未知，所以不能安全地写入数据，只适合做通用接收和读取展示。

通配符上界使用 ? extends 上界类型，表示实际类型只能是该上界类型或其子类。适合读取数据的场景，因为取出的对象至少可以被看作上界类型；但不适合写入数据，因为编译器无法确定容器中保存的是哪个子类。

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Message {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Message message = new Message<>();
        message.setMessage(new Apple());
        fun(message);
        Message message2 = new Message<>();
        message2.setMessage(new Banana());
        fun(message2);
    }
    public static void fun(Message temp){
        //temp.setMessage(new Banana()); //仍然无法修改！
        //temp.setMessage(new Apple()); //仍然无法修改！
        System.out.println(temp.getMessage());
    }
}

通配符下界使用 ? super 下界类型，表示实际类型只能是该下界类型或其父类。适合写入数据的场景，因为写入下界类型或其子类一定是安全的；但读取时无法确定真实父类范围，只能把它看作更宽泛的类型。

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Plate {
    private T plate;
    public T getPlate() {
        return plate;
    }
    public void setPlate(T plate) {
        this.plate = plate;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Plate plate1 = new Plate<>();
        plate1.setPlate(new Fruit());
        fun(plate1);
        Plate plate2 = new Plate<>();
        plate2.setPlate(new Food());
        fun(plate2);
    }
    public static void fun(Plate temp){
        temp.setPlate(new Apple());
        temp.setPlate(new Fruit());
        //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate());
    }
}

简单总结：通配符让泛型方法更灵活，上界偏向读取，下界偏向写入。行业里常说的原则就是——生产者用 extends，消费者用 super。

总结

这篇内容系统梳理了 Ja va 中的反射、枚举和 Lambda 三大特性。反射让程序在运行时动态获取类信息并操作对象，通过 Class 类实现，常用于框架开发和访问私有成员，但性能有损耗；枚举用于组织常量集合，类型安全且不可变，构造方法天然私有，连反射都无法破坏；Lambda 是函数式编程的核心，简化了匿名内部类的写法，通过函数式接口实现代码简洁化，但可读性会下降。另外也涉及了泛型通配符的使用场景，包括无界、上界 extends 和下界 super。这些特性共同增强了 Ja va 的灵活性和表现力，但各自在性能或可维护性上也有相应的权衡。