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

奋斗吧

擅长邻域：未填写

标签： Java语言----反射、枚举以及lambda表达式 Java博客 51CTO博客

2023-07-07 18:24:22 191浏览

Java语言----反射、枚举以及lambda表达式，目录一.反射1.1反射的基本情况1.2反射中最重要的类1.2.1Class类1.2.2Field类1.2.3Constructor类1.2.4Method类1.3反射优缺点二.枚举2.1概念2.2枚举（enum）类方法2.3枚举的构造三.Lambda表达式3.1Lambda介绍3.2函数式接口3.2使用lambda表达式3.2.1不使用Lambda表达式调用3.2.2使用Lambd

一.反射

1.1反射的基本情况

1.2反射中最重要的类

1.2.1 Class类

1.2.2Field类

1.2.3Constructor类

1.2.4Method类

1.3反射优缺点

二.枚举

2.1概念

2.2枚举（enum）类方法

2.3枚举的构造

三.Lambda表达式

3.1Lambda介绍

3.2 函数式接口

3.2使用lambda表达式

3.2.1不使用Lambda表达式调用

3.2.2使用Lambda表达式

3.2.3二者区别

3.3变量捕获

3.3.1匿名内部类的变量捕获

3.3.2Lambda变量捕获

总结

?个人主页：tq02的博客_CSDN博客-C语言,Java,Java数据结构领域博主 ?梦的目标：努力学习，向Java进发，拼搏一切，让自己的未来不会有遗憾。 ?欢迎各位→点赞? + 收藏⭐ + 评论?+关注✨ 本章讲解内容：反射、枚举以及Lambda表达式

使用编译器：IDEA

一.反射

1.1反射的基本情况

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

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

用途：1.在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用 Java的反射机制 来获取所需的私有成员或是方法。
2. 反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

1.2反射中最重要的类

类名	用途
class类	代表类的实体，在运行的Java应用程序中表示类和接口
Field类	代表类的成员变量、类的属性
Method类	代表类的方法
Constructor类	代表类的构造方法

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

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);
 } 
  
 @Override
 public 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 比较，发现都是true
 System.out.println(c1.equals(c2));
 System.out.println(c1.equals(c3));
 System.out.println(c2.equals(c3));
 }

1.2.2Field类

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

方法	用途
getFiled（String name）	获取某个公有的属性对象
getFileds()	获取所有公用的属性对象
getDeclaredField(String name)	获取某个属性对象
getDeclcareFileds（）	获取所有属性对象

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.3Constructor类

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

方法	用途
getConstructor(类型.class,类型.class）	获取该类中与参数类型匹配的公有构造方法
getConstructors(）	获得该类的所有公有构造方法
getDeclaredConstructors(类型.class,类型.class）	获取该类中与参数匹配的构造方法(包含私有构造方法)
getDeclaredConstructors（）	获取该类所有的构造方法

代码实例：

//反射构造方法
     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.4Method类

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

方法	用途
getMethod("方法名"，类型.class)	使用该类的某个公有的方法
getMethods（）	使用该类所有公有的方法
getDeclaredMethod("方法名"，类型.class)	使用该类的某个方法
getDeclaredMethod()	使用该类所有方法

实例代码：

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）类方法

方法名	用法
values()	以数组形式返回枚举的所有类型
ordinal()	获取该枚举成员的下标值
valueOf()	将普通字符串转换成枚举实例
compareTo()	比较两个枚举成员定义时的顺序

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.1Lambda介绍

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 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。

代码实例：

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

3.2使用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就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。

3.2.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.2.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);
 }
 }