Java语言——反射、枚举以及lambda表达式而配置中给的就是类的信息

2024-06-30 20:27:11 [百科] 来源：避面尹邢网

Java语言——反射、反射枚举以及lambda表达式

作者：Java码农之路 2023-07-31 07:43:07开发前端在日常的枚举第三方应用开发过程中，经常会遇到某个类的达式某个成员变量、方法或是反射属性是私有的或是只对系统应用开放，这时候就可以利用 Java的枚举反射机制来获取所需的私有成员或是方法。

一.反射

1.1 反射的达式基本情况

定义：Java在运行状态时，对于任意一个类，反射都能知道这个类的枚举所有属性和方法。

这种动态获取信息以及动态调用对象方法的达式功能称为java语言的反射（reflection）机制

Java语言——反射、枚举以及lambda表达式而配置中给的就是类的信息

用途：

Java语言——反射、枚举以及lambda表达式而配置中给的就是类的信息

1.在日常的第三方应用开发过程中，经常会遇到某个类的反射某个成员变量、方法或是枚举属性是私有的或是只对系统应用开放，这时候就可以利用 Java的达式反射机制来获取所需的私有成员或是方法。

Java语言——反射、枚举以及lambda表达式而配置中给的就是类的信息

2. 反射最重要的反射用途就是开发各种通用框架，比如在spring中，枚举我们将所有的达式类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

1.2 反射中最重要的类

在讲解这些类之前，我们需要先构建一个类，方便进行反射的操作：

class Student{ //私有属性name    private String name = "tq02";//公有属性age    public int age = 22;//不带参数的构造方法    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);}  @Overridepublic String toString() {     return "Student{ " +    "name='" + name + '\'' +    ", age=" + age +    '}';}}

注：1.反射私有的构造方法、属性、方法时，Java具有安全性，因此我们需要使用.setAccessible("boolean");

2.使用Class类、Field、Constructor类时，需要处理异常。

1.2.1 Class类

在反射之前，第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，我们就可以修改部分类型信息。

使用Class获取类的三种方法：

第一种：使用Class.forName("类的全路径名“”); //静态方法

第二种：使用.class方法。

第三种：使用类对象的getClass()方法;

注：无论哪种方法获取，其实获取的都是同一个类。

代码实例 :

public class TestDemo { public static void main(String[] args) { //1.通过getClass获取Class对象    Student s1 = new Student();    Class c1 = s1.getClass(); //2.直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高//这说明任何一个类都有一个隐含的静态成员变量 class    Class c2 = Student.class; //3、通过 Class 对象的 forName() 静态方法来获取，用的最多，//但可能抛出 ClassNotFoundException 异常    Class c3 = null;    try { //注意这里是类的全路径，如果有包需要加包的路径    c3 = Class.forName("Student");    } catch (ClassNotFoundException e) {     e.printStackTrace();    }  //一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的//c1,c2,c3进行 equals 比较，发现都是trueSystem.out.println(c1.equals(c2));System.out.println(c1.equals(c3));System.out.println(c2.equals(c3));}

1.2.2 Field类

作用：可对类中属性进行操作

public static void reflectPrivateField() {   try {             Class<?> classStudent = Class.forName("Student");                                                     //获取name成员变量            Field field = classStudent.getDeclaredField("name");            field.setAccessible(true);            Student student= (Student)classStudent.newInstance();//修改成员变量，将student中的name值改成"小明"；            field.set(student, "小明");            String name = (String) field.get(student);            System.out.println("反射私有属性修改了name：" + name);        } catch (Exception ex) {             ex.printStackTrace();        }}

1.2.3 Constructor类

作用：对构造方法进行操作

代码实例：

//反射构造方法    public static void reflect() {        try {            Class<?> c1 = Class.forName("Student");           Constructor<?> c2= c1.getDeclaredConstructor(String.class,int.class);           c2.setAccessible(true);            c2.newInstance("汤琦",22);       }catch(Exception ex)       {            ex.printStackTrace();       }    }

1.2.4 Method类

作用：对类中方法进行操作

实例代码：

public static void reflectPrivateMethod() {         try {             Class<?> c1 = Class.forName("Student");            Method m1=c1.getDeclaredMethod("function", String.class);            m1.setAccessible(true);             Student fw=(Student) c1.newInstance();            m1.invoke(fw,"给私有的function函数传的参数");         }catch(Exception ex)        {             ex.printStackTrace();        }    }

1.3 反射优缺点

优点： 1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法

2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力

3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点： 1. 使用反射会有效率问题。会导致程序效率降低。

2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂

二.枚举

2.1 概念

在Java中，可以说是一个集合，从下标0开始的集合。注：枚举是jdk1.5以后引用的。

使用格式： public enum 类名{

常量1、常量2、常量3；

}

就是将class换成了enum

代码实例：

public enum TestEnum {     RED,BLACK,GREEN,WHITE;//相当于集合，第一个常量下标值为0，第二个常量下标值为1......    public static void main(String[] args) {          TestEnum testEnum2 = TestEnum.BLACK;         switch (testEnum2) {          case RED: System.out.println("red"); break;         case BLACK:System.out.println("black");break;         case WHITE:System.out.println("WHITE");break;         case GREEN:System.out.println("black");break;         default:break;}}

2.2 枚举（enum）类方法

2.3 枚举的构造

枚举的构造方法默认是私有的。

public enum TestEnum {     RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);    private String name;    private int key;/*** 1、当枚举对象有参数后，需要提供相应的构造函数* 2、枚举的构造函数默认是私有的 这个一定要记住* @param name* @param key*/    private TestEnum (String name,int key) {         this.name = name;        this.key = key;    }    public static TestEnum getEnumKey (int key) {         for (TestEnum t: TestEnum.values()) {         if(t.key == key) {         return t;        }    }     return null;}    public static void main(String[] args) {         System.out.println(getEnumKey(2));    }}

注：自己写的枚举类，默认继承与enum这个类的。

三.Lambda表达式

3.1 Lambda介绍

Lambda本质是匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）

语法格式：（parameters）->expression 或 (parameters)->{ statements;}

parameters:类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由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)

3.2 函数式接口

定义：该接口有且只有一个抽象方法

注：如果某接口含有@FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。

代码实例：

@FunctionalInterfaceinterface NoParameterNoReturn { 	//注意：只能有一个方法	void test();}

3.3 使用lambda表达式

先建立几个接口：

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

Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。

3.3.1 不使用Lambda表达式调用

public class TestDemo { public static void main(String[] args) { //接口使用匿名内部类    NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){     @Override    public void test() {     System.out.println("hello");    }    };noParameterNoReturn.test();}

3.3.2 使用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);}}