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

一、反射机制详解

Java的反射机制允许在程序运行期间，针对任意一个类，都能获取其所有属性和方法；对于任意一个对象，都能调用其任意方法和属性。既然能够获取这些信息，我们就可以修改部分类型信息。这种动态获取信息以及动态调用对象方法的功能，被称为Java语言的反射机制。

1. 反射的应用场景

在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的，或是只对系统应用开放。此时，就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。除此之外，反射最重要的用途就是开发各种通用框架。

反射的应用场景对应的技术说明图 — **反射的应用场景**概括反射的应用场景的核心概念、关键要点与实践提示。

例如在Spring框架中，我们将所有的类Bean交给Spring容器管理。无论是通过XML配置Bean还是注解配置，当我们从容器中获取Bean进行依赖注入时，容器会读取配置。配置中给出的是类的信息，Spring根据这些信息，需要创建哪些Bean，就动态地创建这些类。

2. 运行时类型识别（RTTI）

Java程序中许多对象在运行时会出现两种类型：运行时类型（RTTI）和编译时类型。例如代码 Person p = new Student()；中，变量p在编译时类型为Person，而在运行时类型为Student。程序需要在运行时发现对象和类的真实信息。通过使用反射，程序就能判断出该对象和类属于哪些类。

3. 核心API参考

在反射操作中，我们主要会用到以下核心类，供参考的帮助文档如下：

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

Class类与反射机制基础

Class类是Java反射机制的基石，它代表了类的实体。在运行时的Java应用程序中，Class对象表示类和接口。当Java源文件被编译后，会生成.class文件。JVM在加载这些文件时，会将.class文件解析为一个对象，这个对象即为java.lang.Class。因此，在程序运行期间，每个Java类最终都会对应一个Class类对象实例。通过反射机制操作这个实例，我们可以获取甚至修改类的属性和方法，使类具备动态特性。为了深入理解，我们先列举Class类中常见的方法。

获取类相关信息的方法

以下是常用获取类相关信息的API：

方法	用途
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()	获得该类所有方法

反射实例演示

接下来，我们将通过具体代码演示几个重要的反射方法。首先，我们定义一个简单的Student类：

package reflectdemo;
public class Student {
    //私有属性name
    private String name = "bit";
    //公有属性age
    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方法的源码：

    /**
     * Returns the {@code Class} object associated with the class or
     * interface with the given string name.  Invoking this method is
     * equivalent to:
     *
     * 
     *  {@code Class.forName(className, true, currentLoader)}
     * 
     *
     * where {@code currentLoader} denotes the defining class loader of
     * the current class.
     *
     *  For example, the following code fragment returns the
     * runtime {@code Class} descriptor for the class named
     * {@code java.lang.Thread}:
     *
     * 

     *   {@code Class t = Class.forName("java.lang.Thread")}
     * 
     * 
     * A call to {@code forName("X")} causes the class named
     * {@code X} to be initialized.
     *
     * @param      className   the fully qualified name of the desired class.
     * @return     the {@code Class} object for the class with the
     *             specified name.
     * @exception LinkageError if the linkage fails
     * @exception ExceptionInInitializerError if the initialization provoked
     *            by this method fails
     * @exception ClassNotFoundException if the class cannot be located
     */
    @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对象：

Class c2 = Student.class;

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

为了验证这三种方法是否指向同一个类对象，我们将代码修改如下：

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对象。通过该对象提供的核心API，我们能够在程序运行期间动态地探查任意类的全部属性与方法，并调用其任意方法或访问属性。既然能够获取Class实例，我们便具备了修改部分类型信息的能力。获取Class对象主要有以下三种途径：

Class.forName()：使用静态方法传入类的全限定名，前提是我们必须明确类的完整路径。
.class属性：这种方式仅适用于在编译阶段就已经确定要操作的Class类型。
getClass()方法：通过已有的类实例调用该方法来获取对应的Class对象。

反射实战：构造方法与私有成员访问

接下来，我们将对代码进行具体修改以演示反射的实际应用。首先，我们尝试通过newInstance方法创建对象。在深入该方法内部实现时，我们会发现它涉及特定的异常处理机制。因此，我们需要对代码进行补充，以正确处理可能抛出的异常。

执行上述代码后，我们将观察到预期的运行结果。同理，我们可以编写获取私有构造方法的代码。然而，直接运行可能会遇到问题，原因在于对于标识为private的构造方法，Java默认禁止外部访问。为了解决这一问题，我们需要额外添加一行关键语句，即强制访问检查。这行代码的作用是明确告知JVM：我们已知该方法是私有的，并确认要强行获取它。

添加该语句后再次运行，即可成功获取到刚创建的对象实例。随后，我们继续演示反射私有属性的代码实现，并观察其运行结果。最后，我们展示如何反射私有方法，并查看相应的执行反馈。

反射的核心价值与应用

综上所述，Java反射机制具有显著的优势。首先，它允许我们在运行时动态地获取任意类的所有属性和方法，并调用任意对象的方法。其次，反射极大地增加了程序的灵活性和扩展性，有效降低了模块间的耦合度，从而提高了系统的自适应能力。目前，反射技术已广泛应用于众多主流框架中，例如Struts、Hibernate以及Spring等，成为现代Java开发不可或缺的基础设施。

二、枚举：

枚举是在JDK1.5以后引入的。主要用途是将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式如下：

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

但是常量举例有不好的地方，例如可能碰巧有个数字1，但是他有可能误会为是RED，现在我们可以直接用枚举来进行组织，这样一来，就拥有了类型，枚举类型。而不是普通的整形1。

public enum TestEnum {
    RED,BLACK,GREEN;
}

枚举的优点是将常量组织起来统一进行管理，可以用于如下的场景，错误状态码，消息类型，颜色的划分，状态机等等。枚举的本质是java.lang.Enum的子类，也就是说，自己写的枚举类，就算没有显示的继承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));
    }
}

其运行结果如下：

需要注意的是，枚举的构造方法默认是私有的。我们刚刚说过，在Java当中枚举实际上就是一个类。所以我们在定义枚举的时候，还可以这样定义和使用枚举：

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 e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

其运行结果如下：

三、Lambda表达式：

Lambda表达式是Java SE 8中一个重要的新特性。Lambda表达式允许你通过表达式来代替功能接口。和方法一样，它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda表达式基于数学中的λ演算得名，也可称为闭包。其基本语法如下：

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

Lambda表达式由三部分组成，paramaters，类似方法中的形参列表，这里的参数是函数式接口里的参数，这里的参数类型可以明确的声明，也可不声明而由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 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

在深入理解Lambda表达式之前，我们需要回顾一下前文提到的枚举类型反射问题。报错信息指出我们没有这个构造方法，但我们明明已经在上面提供了相同的构造方法，那为什么会出现这种情况呢？这是因为我们在调用的时候，只是传入了继承了父类的子类的两个参数，而对于父类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 e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

再次尝试运行，得到如下的结果：

那么为什么会出现一个这个错误呢？我们先去看下newInstance方法的源码：

    /**
     * Uses the constructor represented by this {@code Constructor} object to
     * create and initialize a new instance of the constructor's
     * declaring class, with the specified initialization parameters.
     * Individual parameters are automatically unwrapped to match
     * primitive formal parameters, and both primitive and reference
     * parameters are subject to method invocation conversions as necessary.
     *
     * If the number of formal parameters required by the underlying constructor
     * is 0, the supplied {@code initargs} array may be of length 0 or null.
     *
     * 
If the constructor's declaring class is an inner class in a
     * non-static context, the first argument to the constructor needs
     * to be the enclosing instance; see section 15.9.3 of
     * The Java™ Language Specification.
     *
     * 
If the required access and argument checks succeed and the
     * instantiation will proceed, the constructor's declaring class
     * is initialized if it has not already been initialized.
     *
     * 
If the constructor completes normally, returns the newly
     * created and initialized instance.
     *
     * @param initargs array of objects to be passed as arguments to
     * the constructor call; values of primitive types are wrapped in
     * a wrapper object of the appropriate type (e.g. a {@code float}
     * in a {@link java.lang.Float Float})
     *
     * @return a new object created by calling the constructor
     * this object represents
     *
     * @exception IllegalAccessException    if this {@code Constructor} object
     *              is enforcing Java language access control and the underlying
     *              constructor is inaccessible.
     * @exception IllegalArgumentException  if the number of actual
     *              and formal parameters differ; if an unwrapping
     *              conversion for primitive arguments fails; or if,
     *              after possible unwrapping, a parameter value
     *              cannot be converted to the corresponding formal
     *              parameter type by a method invocation conversion; if
     *              this constructor pertains to an enum type.
     * @exception InstantiationException    if the class that declares the
     *              underlying constructor represents an abstract class.
     * @exception InvocationTargetException if the underlying constructor
     *              throws an exception.
     * @exception ExceptionInInitializerError if the initialization provoked
     *              by this method fails.
     */
    @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");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

这里面的代码出现了对枚举类型的判断，如果它检测到了枚举类型，那么它就会直接抛出异常，所以其实原则上来说，虽然枚举类型的构造方法是私有的，但是在反射机制中，它是不被允许使用的。这就说明枚举类型是比较安全的，即使通过反射我也无法获知内部信息。

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

Lambda表达式中存在变量捕获，了解了变量捕获之后，我们才能更好的理解Lambda表达式的作用域。Java当中的匿名内部类中，会存在变量捕获。匿名内部类就是没有名字的内部类。我们这里只是为了说明变量捕获，所以匿名内部类只要会使用就好，那么下面我们来简单的看看匿名内部类的使用就好了。具体想详细了解的读者可以看这篇文章：

匿名内部类详解 - SQP51312 - 博客园

我们通过简单的代码来学习一下：

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这个方法！");
            }
        };
    }
}

在Lambda表达式中，变量捕获是一个核心概念。它指的是Lambda表达式可以访问其外部作用域中的变量。与匿名内部类类似，Lambda表达式捕获的局部变量必须是最终变量（final）或者事实上是最终的（effectively final）。这意味着一旦变量被赋值，就不能再修改其值。这种限制确保了Lambda表达式在多线程环境下的安全性，避免了因变量状态变化导致的不可预测行为。

接下来我们来看一下它们的基本使用：

//无返回值无参数
@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就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。没有使用Lambda表达式的时候的调用方式：

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

具体使用可见如下代码：

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);
    }
}

对于Lambda表达式来说，它遵循如下的简化规则，参数类型可以省略，如果需要省略，每个参数的类型都要省略；参数的小括号里面只有一个参数，那么小括号可以省略；如果方法体当中只有一句代码，那么大括号可以省略；如果方法体中只有一条语句，且是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表达式更加简洁易读。例如，当只有一个参数时，可以省略小括号；当方法体只有一条语句时，可以省略大括号和return关键字。这种语法糖极大地提高了代码的可读性和简洁性，使得Lambda表达式成为处理集合操作和事件监听等场景的理想选择。通过掌握这些简化规则，开发者可以更高效地编写Lambda表达式，提升代码质量。

匿名内部类与变量捕获机制

在上述代码的 main 函数中，展示了一个匿名内部类的简单使用场景。其中，变量 a 即为被捕获的局部变量。根据 Java 语言规范，这个被捕获的变量必须满足特定条件：要么被 final 修饰，要么虽然不是 final 修饰，但必须保证在 Lambda 表达式使用之前，其值没有被修改过。如果违反了这一规则，编译器将直接报错。

例如，以下代码就是典型的错误示例：

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
                    +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

这段代码在编译时会直接报错。需要特别注意的是，即便我们将修改 a 值的代码逻辑移到 Lambda 表达式外部执行，依然会引发编译错误。这是因为在编译期间，编译器需要确保被捕获变量的状态一致性，而局部变量的可变性可能导致不可预知的行为。

在 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 表达式的结合

为了使 Lambda 表达式能够更顺畅地与 Java 集合框架协同工作，Java 在集合接口中新增了一些方法，以便与 Lambda 表达式完美对接。以上方法的具体作用可自行查阅官方帮助手册。这里我们将通过示例演示部分核心方法的使用。需要强调的是，Collection 接口的 forEach() 方法实际上是从父接口 java.lang.Iterable 中继承而来的。

首先我们来演示 forEach 方法，该方法在 Iterable 接口中的原型定义如下：

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

该方法的作用是遍历容器中的每个元素，并对每个元素执行 action 参数所指定的动作。我们可以将传统的迭代器写法修改为如下更简洁的代码：

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 方法的源码。该方法根据参数 c 指定的比较规则，对容器内的元素进行排序操作。

我们可以键入如下代码来实现排序：

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");
    //调用带有2个参数的方法，且返回长度的差值
    list.sort((str1,str2)-> str1.length()-str2.length());
    System.out.println(list);
}

二者的运行结果同样完全一致，但 Lambda 表达式的写法更加简洁直观。最后，我们再来看 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) {
            // this usually means the entry is no longer in the map.
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

它的作用是对 Map 集合中的每个键值对映射执行 action 参数指定的操作。我们给出如下代码示例来展示其具体用法：

Lambda表达式的简化与优劣分析

我们可以利用Lambda表达式对代码进行如下简化处理，使得逻辑更加紧凑。尽管两者的运行结果完全一致，但Lambda表达式的优势在于显著提升了代码的简洁度，使核心逻辑一目了然。然而，其劣势同样明显，即代码的可读性有所下降，对于不熟悉Lambda语法的开发者而言，理解成本较高。总体而言，Lambda表达式具备多项显著优点：首先，它极大地简化了代码结构，从而提升了开发效率；其次，它使得函数式编程变得轻而易举；再次，它极大地方便了并行计算的实现，能够充分利用多核处理器的性能；最后，Java引入Lambda表达式后，集合框架的操作变得更加直观和高效。

与此同时，我们也不能忽视其带来的挑战。代码可读性的降低是首要问题，特别是在复杂逻辑中，Lambda表达式可能使代码变得晦涩难懂。其次，在非并行计算的场景下，某些传统for循环的性能可能优于Lambda表达式，因为后者存在额外的方法调用开销。此外，由于Lambda表达式的匿名性和简洁性，在进行断点调试时，往往难以追踪具体的执行路径，增加了调试的难度。

五、泛型的通配符详解

在Java泛型体系中，通配符用于表示某种未知的具体类型。它主要解决了泛型参数过于固定从而导致方法复用性较差的问题。由于Java泛型具有不变性特征，一个具体的泛型类型不能自然地代表其他相关的泛型类型。因此，当一个方法需要接收多种不同类型的泛型对象时，使用通配符便成为了解决这一问题的关键手段。

无界与有界通配符的应用场景

无界通配符表示可以接收任意类型的泛型对象。然而，由于具体的元素类型是未知的，我们无法安全地向其中写入确定类型的数据，因此它主要适用于通用的数据接收和读取展示场景。通配符上界通过 extends 上界类型来定义，表示实际类型必须是该上界类型或其子类。这种设计非常适合读取数据的场景，因为从容器中取出的对象至少可以被安全地视为上界类型；但在写入数据时则存在风险，因为编译器无法确定容器中实际保存的是哪一个具体的子类，强行写入可能会破坏类型安全。

通配符下界则使用 super 下界类型来定义，表示实际类型必须是该下界类型或其父类。这种设计非常适合写入数据的场景，因为将下界类型或其子类对象写入容器一定是类型安全的；然而，在读取数据时，由于无法确定真实的父类范围，因此不能直接按下界类型来接收数据，只能将其视为更宽泛的类型进行处理。

简单总结而言，通配符使得泛型方法变得更加灵活，而上下界通配符则在灵活性与类型安全之间建立了有效的约束机制。通常遵循“上界偏向读取，下界偏向写入”的原则，即常说的生产者用extends，消费者用super。

总结

Java核心特性深度解析

反射机制与枚举类型

本文系统介绍了Java中的反射、枚举和Lambda表达式三大特性。反射机制允许程序在运行时动态获取类信息并操作对象，通过Class类实现，常用于框架开发和访问私有成员，但存在性能开销；枚举类型(enum)用于组织常量集合，提供类型安全且不可变，其构造方法天然私有且反射机制无法破坏；

Lambda表达式与泛型通配符

Lambda表达式是函数式编程的核心语法，简化了匿名内部类的写法，通过函数式接口实现代码简洁化，但可能降低可读性。文章还涉及泛型通配符的使用场景，包括无界通配符、上界extends和下界super的适用情况。这些特性共同增强了Java的灵活性和表现力，但也各自存在性能或可维护性方面的权衡。

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

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 e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (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);
            Student student = constructor.newInstance("suzhe", 21);
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectPrivateConstructor();
    }
}

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 e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectPrivateConstructor();
    }
}

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 e) {
            throw new RuntimeException(e);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (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 e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args){
        reflectPrivateMethod();
    }
}

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

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
                    +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

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
                    +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

对应的接口	新增的方法
Collection	removeIf()、spliterator()、stream()、parallelStream()、forEach()
List	replaceAll()、sort()
Map	getOrDefault()、forEach()、replaceAll()、putIfAbsent()、remove()、replace()、computeIfAbsent()、computeIfPresent()、compute()、merge()

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+" ");
        }
    });
}

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) {
    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);
        }
    });
}

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));
}

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());
    }
}

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());
    }
}

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){
        // 此时可以修改！！添加的是Fruit 或者Fruit的子类
        temp.setPlate(new Apple());//这个是Fruit的子类
        temp.setPlate(new Fruit());//这个是Fruit的本身
        //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate());//只能直接输出
    }
}