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 类的一个实例。通过反射操作这个实例，就能获取甚至修改类的属性和行为，让类“活”起来。先看看这几个类的常用方法：

常用获得类相关的方法：

方法	用途
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 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;
        }
    }
}

枚举的常用方法：

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

对应的接口	新增的方法
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 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 的灵活性和表现力，但各自在性能或可维护性上也有相应的权衡。