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

作者：技术拾光

时间：2026-07-29

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

文章目录

前言

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

一、反射机制详解

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

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

Java 程序中的对象在运行时存在两种类型：编译时类型和运行时类型。例如 Person p = new Student()，p 的编译时类型是 Person，运行时类型却是 Student。程序需要在运行时确定对象和类的真实身份，反射正是为此而生。核心涉及以下几个类：

官方文档链接如下，建议收藏：

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 与集合更好地配合，集合类新增了一些接口方法：

对应接口	新增方法
Collection	removeIf()、spliterator()、stream()、parallelStream()、forEach()
List	replaceAll()、sort()
Map	getOrDefault()、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 的灵活性和表现力，但在性能或可维护性方面也存在相应的权衡。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印，自由调节做旧程度。

使用 ›

图片压缩

选择画质和输出格式，预览压缩前后的大小。

使用 ›

上一篇：CSS动画性能抖动：用will-change开启硬件加速下一篇：Java中如何正确重写hashCode()和equals()方法