总结Java中反射+枚举+Lambda表达式

Posted 满眼*星辰

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了总结Java中反射+枚举+Lambda表达式相关的知识，希望对你有一定的参考价值。

反射+枚举+Lambda表达式

反射

定义

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。

基本信息

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

反射相关的类

（反射当中几个重要的类型）

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

反射机制起源

Java文件被编译后，生成了.class文件，.class文件需要加载到JVM虚拟机上
在这里插入图片描述

字节码文件所对应的对象就是Class对象，它会板寸当前类型的信息

所以反射的根本就是从Class对象出发点

Class对象只有一个，因为.class文件是从.java文件的类对象信息获取的，类只有一个

我们通过Java的反射机制应用到这个Class对象实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类

Class类中相关方法及使用

获得类相关方法

方法用途
getClassLoader()获得类的加载器
getDeclaredClasses()返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)
forName(String className)根据类名返回类的对象
newInstance()创建类的实例
getName()获得类的完整路径名字
    //通过反射创建对象
    public static void reflectNewInstance() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 创建类的实例
            Student student = (Student) c1.newInstance();
            //3. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectNewInstance();
    }

获得属性相关方法

方法用途
getField(String name)获得某个公有的属性对象
getFields()获得所有公有的属性对象
getDeclaredField(String name)获得某个属性对象
getDeclaredFields()获得所有属性对象
    // 反射获取属性
    public static void reflectPrivateField() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到全部的属性（包括私有的）
            //getField()：获取到公有的属性
            Field field = c1.getDeclaredField("name");
            //3. 私有属性必须设置为true后可修改访问权限
            field.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) c1.newInstance();
            //5. 更改student中的属性name
            field.set(student,"lala");
            //6. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateField();
    }

获得类中方法相关方法

方法用途
getMethod(String name, Class…<?> parameterTypes)获得该类某个公有的方法
getMethods()获得该类所有公有的方法
getDeclaredMethod(String name, Class…<?> parameterTypes)获得该类某个方法
getDeclaredMethods()获得该类所有方法
    //反射获取类中方法
    public static void reflectMethod() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到全部的方法（包括私有的）
            //getMethod()：获取到公有的方法
            Method method = c1.getDeclaredMethod("function", String.class);
            //3. 私有方法必须设置为true后可修改访问权限
            method.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) c1.newInstance();
            //5. 调用student对象中添加function方法
            method.invoke(student,"我是给私有的function函数传的参数");
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectMethod();
    }

获得类中构造器相关方法

方法用途
getConstructor(Class…<?> parameterTypes)获得该类中与参数类型匹配的公有构造方法
getConstructors()获得该类的所有公有构造方法
getDeclaredConstructor(Class…<?> parameterTypes)获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()获得该类所有构造方法
    // 反射获取私有的构造方法
    public static void reflectPrivateConstructor2() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到带有参数的构造方法
            //getDeclaredConstructor()：获取到所有的构造方法
            Constructor<?> constructor =
                    c1.getDeclaredConstructor(String.class,int.class);
            //3. 私有方法必须设置为true后可修改访问权限
            constructor.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) constructor.newInstance("狒狒",21);
            //5. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    // 反射获取属性
    public static void reflectPrivateField() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到全部的属性（包括私有的）
            //getField()：获取到公有的属性
            Field field = c1.getDeclaredField("name");
            //3. 私有属性必须设置为true后可修改访问权限
            field.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) c1.newInstance();
            //5. 更改student中的属性name
            field.set(student,"lala");
            //6. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateConstructor();
        reflectPrivateConstructor2();
    }

反射优点和缺点

优点：

  1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
  2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
  3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点：

  1. 使用反射会有效率问题。会导致程序效率降低。具体参考这里：http://www.imooc.com/article/293679
  2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

枚举

定义

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

public enum TestEnum {
	RED,BLACK,GREEN;
}

优点：将常量组织起来统一进行管理

场景：错误状态码，消息类型，颜色的划分，状态机等等…

本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了这个类。

使用

switch语句

public enum TestEnum {
    RED,GREEN,BLACK;

    public static void main(String[] args) {
        TestEnum testEnum = TestEnum.BLACK;
        switch (testEnum) {
            case RED:
                System.out.println("red");
                break;
            case GREEN:
                System.out.println("green");
                break;
            case BLACK:
                System.out.println("black");
                break;
            default:
                break;
        }
    }
}

常用方法

方法名描述
values()以数组形式返回枚举类型的所有成员
ordinal()获取枚举成员的索引位置
valueOf()将普通字符串转换为枚举实例
compareTo()比较两个枚举成员在定义时的顺序
public enum TestEnum {
    RED,GREEN,BLACK;

    public static void main(String[] args) {
        //将当前的枚举对象，封装为数组
        TestEnum[] testEnums = TestEnum.values();
        for (TestEnum testEnum : testEnums) {
            System.out.print(testEnum + " ");//RED GREEN BLACK
        }
        System.out.println();
        //打印枚举对象数组的下标
        for (int i = 0; i < testEnums.length; i++) {
            System.out.print(testEnums[i].ordinal() + " ");//0 1 2
        }
        System.out.println();
        //根据字符串解析出来一个枚举对象
        System.out.println(TestEnum.valueOf("GREEN"));//GREEN

        System.out.println(RED.compareTo(BLACK));//-2
    }
}

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

public enum TestEnum {
    RED("red",1),GREEN("green",2),BLACK("black",3);

    public String color;
    public int ordinal;

    /**
     *  1、当枚举对象有参数后，需要提供相应的构造函数
     *  2、枚举的构造函数默认是私有的
     * @param color
     * @param ordinal
     */
    private TestEnum(String color,int ordinal) {
        this.color = color;
        this.ordinal = ordinal;
    }
}

枚举优点缺点

优点：

  1. 枚举常量更简单安全 。
  2. 枚举具有内置方法 ，代码更优雅

缺点：

  1. 不可继承，无法扩展

枚举和反射

枚举是否可以通过反射，拿到实例对象呢？

如果一个类的构造方法是私有的，那么在类外通过反射可以拿到这个类的对象，那么枚举应该也可以吗？

public enum TestEnum {
    RED("red",1),GREEN("green",2),BLACK("black",3);

    public String color;
    public int ordinal;

    /**
     *  1、当枚举对象有参数后，需要提供相应的构造函数
     *  2、枚举的构造函数默认是私有的
     * @param color
     * @param ordinal
     */
    private TestEnum(String color,int ordinal) {
        this.color = color;
        this.ordinal = ordinal;
    }

    public static void reflectPrivateConstructor() {
        try {
            Class<?> c1 = Class.forName("work5_10.TestEnum");
            Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class,String.class,int.class);
            constructor.setAccessible(true);
            TestEnum yello = (TestEnum) constructor.newInstance("黄色",4,"父类的参数",10);
            System.out.println(yello);
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

自己的枚举类是继承java.lang.Enum的，Enum是抽象类，子类需要帮助父类进行构造
这里编译器自动帮我们进行构造了，我们不写也可以
但是我们在用反射传入构造方法的时候，需要再给两个父类的参数

Exception in thread “main” java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at work5_10.TestEnum.reflectPrivateConstructor(TestEnum.java:37)
at work5_10.TestEnum.main(TestEnum.java:46)

会报出这个异常，反射不能拿到内聚类

得出结论：枚举很特殊，就算是反射，也不能拿到对象

用枚举来实现单例模式是最好的

单例模式分为：懒汉式和饿汉式
实现单例模式：可以用静态内部类，可以用枚举
（之后会发博客专门解释单例模式）

总结枚举

  1. 枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum
  2. 枚举可以避免反射和序列化问题
  3. 枚举的优点和缺点

Lambda表达式

Lambda语法

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

  1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明
    也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
  2. ->：可理解为“被用于”的意思
  3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反
    回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

举例说明

// 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)

函数式接口

函数式接口定义：一个接口有且只有一个抽象方法 。

注意：

  1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
  2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求
    该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口
    中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。
@FunctionalInterface
interface NoParameterNoReturn {
	//只能有一个方法
	void test();
}

但是也可以有默认类型的具体方法

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

Lanmbda表达式使用

Lambda表达式本质是一个匿名函数，我们在调用接口的时候只需要关注：参数 -> 方法体

1. 无返回值无参数

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}

//无返回值无参数
NoParameterNoReturn noParameterNoReturn = () -> {
    System.out.println("lala");
};
noParameterNoReturn.test();//lala

2. 无返回值一个参数

//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}

//无返回值一个参数
OneParameterNoReturn oneParameterNoReturn = (int a) -> {
    System.out.println(a);
};
oneParameterNoReturn.test(10);//10

3. 无返回值多个参数

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

//无返回值多个参数
MoreParameterNoReturn moreParameterNoReturn = (int a,int b) -> {
    System.out.println(a+b);
};
moreParameterNoReturn.test(10,20);//30

4. 有返回值无参数

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}

//有返回值无参数
NoParameterReturn noParameterReturn = () -> {
    return 10;
};
System.out.println(noParameterReturn.test());//10
//可简写
NoParameterReturn noParameterReturn2 = () -> 10;
System.out.println(noParameterReturn2.test());//10

5. 有返回值一个参数

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}

//有返回值一个参数
OneParameterReturn oneParameterReturn = (int a) -> {
    return a;
};
System.out.println(oneParameterReturn.test(4));//4
//可简写
OneParameterReturn oneParameterReturn2 = a -> a;
System.out.println(oneParameterReturn2.test(10));

6. 有返回值多参数

//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

//有返回值多参数
MoreParameterReturn moreParameterReturn = (int a,int b) -> {
    return a+b;
};
System.out.println(moreParameterReturn以上是关于总结Java中反射+枚举+Lambda表达式的主要内容，如果未能解决你的问题，请参考以下文章
 

 JAVA 反射枚举 Lambda 表达式详解


 JAVA 反射枚举 Lambda 表达式详解


 Java反射, 枚举,Lambda表达式


 Java集合与数据结构 反射枚举及Lambda表达式


 Java集合与数据结构 反射枚举及Lambda表达式


 Java集合与数据结构 反射枚举及Lambda表达式