当前位置：首页 > 全部内容 > Java反射、枚举、Lambda表达式与泛型通配符实例详解

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

作者：技术拾光时间：2026-07-29 09:29:04浏览：304

Java反射机制允许程序在运行时动态获取类的属性、方法及私有成员，是框架底层实现依赖注入和实例创建的核心技术。枚举、Lambda表达式及泛型通配符与反射共同构成Java类型系统、运行时动态性与函数式编程的关键要素。

前言

在日常 Java 开发中，反射、枚举、Lambda 表达式以及泛型通配符这几个概念出现频率很高，但不少开发者对其理解仍不够深入。本文将这些知识点集中梳理，帮助读者串联 Java 的类型系统、运行时动态性以及函数式编程风格，从而加深对 Java 语言核心机制的理解。

一、反射机制详解

Java 反射机制允许程序在运行时获取类的完整信息，包括属性、方法以及私有成员。通过获取 Class 对象，开发者可以动态调用方法、修改属性值，甚至访问私有成员。这种动态获取信息和调用方法的能力，构成了反射机制的核心。

在实际开发中，反射的应用场景主要集中在两个方面：第一，在第三方 SDK 集成时，某些类或方法被标记为 private，常规手段无法调用，反射提供了一种有效的解决方案；第二，主流框架的底层实现，例如 Spring 框架中 Bean 的创建和依赖注入，无论是基于 XML 配置还是注解配置，最终都是通过反射来实现。可以说，没有反射机制，就没有当今灵活强大的 Java 框架体系。

Java 程序中的对象在运行时存在两种类型：编译时类型和运行时类型。例如 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 类是反射的起点，代表类的实体。Java 文件编译后生成 .class 文件，JVM 解析时将其转换为 java.lang.Class 对象。这样一来，每个 Java 文件在运行时都成为 Class 类的一个实例。通过反射操作这个实例，就能获取甚至修改类的属性和行为，让类在运行时具备动态性。以下是这些类的常用方法：

常用获取类相关的方法：

方法用途
getClassLoader()获取类的加载器
getDeclaredClasses()返回数组中包含该类所有类和接口的对象（包括私有）
forName(String className)根据类名返回类的对象
newInstance()创建类的实例
getName()获取类的完整路径名称

常用获取类中属性相关的方法（返回值类型为 Field）：

方法用途
getField(String name)获取某个公有属性对象
getFields()获取所有公有属性对象
getDeclaredField(String name)获取某个属性对象
getDeclaredFields()获取所有属性对象

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

方法用途
getAnnotation(Class annotationClass)返回该类中与参数类型匹配的公有注解对象
getAnnotations()返回该类所有公有注解对象
getDeclaredAnnotation(Class annotationClass)返回该类中与参数类型匹配的所有注解对象
getDeclaredAnnotations()返回该类所有注解对象

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

方法用途
getConstructor(Class...> parameterTypes)获取该类中与参数类型匹配的公有构造方法
getConstructors()获取该类的所有公有构造方法
getDeclaredConstructor(Class...> parameterTypes)获取该类中与参数类型匹配的构造方法
getDeclaredConstructors()获取该类所有构造方法

常用获取类中方法相关的方法（返回值类型为 Method）：

方法用途
getMethod(String name, Class...> parameterTypes)获取该类某个公有方法
getMethods()获取该类所有公有方法
getDeclaredMethod(String name, Class...> parameterTypes)获取该类某个方法
getDeclaredMethods()获取该类所有方法

接下来通过代码示例进行说明。先创建一个学生类：

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 java.lang.reflect.Constructor;
import java.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 java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.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 java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.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，可能导致误用。使用枚举后，具备了真正的类型约束：

public enum TestEnum {
    RED,BLACK,GREEN;
}

枚举的本质是 java.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;
        }
    }
}

枚举的常用方法：

方法名称描述
values()以数组形式返回枚举类型的所有成员
ordinal()获取枚举成员的索引位置
valueOf()将普通字符串转换为枚举实例
compareTo()比较两个枚举成员在定义时的顺序

简单演示：

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 java.lang.reflect.Constructor;
import java.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 java.lang.reflect.Constructor;
import java.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 表达式是 Java 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 与集合更好地配合，集合类新增了一些接口方法：

对应接口新增方法
CollectionremoveIf()、spliterator()、stream()、parallelStream()、forEach()
ListreplaceAll()、sort()
MapgetOrDefault()、forEach()、replaceAll()、putIfAbsent()、remove()、replace()、computeIfAbsent()、computeIfPresent()、compute()、merge()

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

default void forEach(Consumer super T> 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 super E> 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 super K, ? super V> 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 extends Fruit> 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 super Fruit> temp){
        temp.setPlate(new Apple());
        temp.setPlate(new Fruit());
        //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate());
    }
}

总结来说，通配符让泛型方法更加灵活，上界通配符偏向读取操作，下界通配符偏向写入操作。行业中的通用原则是——生产者使用 extends，消费者使用 super。

总结

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