Java中的反射,枚举及lambda表达式的使用详解

Java中的反射,枚举及lambda表达式的使用详解

目录一、反射1.1定义1.2用途1.3反射基本信息1.4与反射相关的类1.5Class类(反射机制的起源)1.6Class类中的相关方法1.7获得Class对象的三种方式1.8反射的使用1.9反射优点和缺点二、枚举2.1Enum类的常用方法2.2枚举的优点和缺点三、Lambda表达式3.1Lambda表达式的语法及基本使用3.2函数式接口3.3变量捕获总结

一、反射

1.1 定义

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

1.2 用途

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

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

1.3 反射基本信息

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

1.4 与反射相关的类

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

1.5 Class类(反射机制的起源 )

Class代表类的实体，在运行的Java应用程序中表示类和接口 .

Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个类文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类 .

1.6 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()获得该类中所以构造方法

1.7 获得Class对象的三种方式

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

第一种，使用 Class.forName("类的全路径名"); 静态方法。

前提：已明确类的全路径名。

第二种，使用 .class 方法。

说明：仅适合在编译前就已经明确要操作的 Class。

第三种，使用类对象的 getClass() 方法。

代码示例：

本节代码均在一个包下面。

package reflectTest;

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 +

'}';

}

}

public class test01 {

public static void main(String[] args) {

try {

//通过 Class 对象的 forName() 静态方法来获取，用的最多，

//但可能抛出 ClassNotFoundException 异常

Class> c1 = Class.forName("reflectTest.Student");

//直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高

//这说明任何一个类都有一个隐含的静态成员变量 class

Class> c2 = Student.class;

//通过getClass获取Class对象

Student student = new Student();

Class> c3 = student.getClass();

System.out.println(c1.equals(c2));

System.out.println(c1.equals(c3));

System.out.println(c2.equals(c3));

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

输出结果：

1.8 反射的使用

package reflectTest;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

/**

* 通过class类的newInstance方法获取类的实例

*/

public class ReflectClassDemo {

public static void reflectNewInstance(){

try {

//获得Class对象

Class> c1 = Class.forName("reflectTest.Student");

//创建类的实例

Student student = (Student) c1.newInstance();

System.out.println(student);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

}

}

/**

* 反射私有的构造方法

*/

public static void reflechttp://tPrivateConstructor() {

try {

Class> c1 = Class.forName("reflectTest.Student");

//构造方法

Constructor> constructor = c1.getDeclaredConstructor(String.class,int.class);

//设置为true后可修改访问权限

constructor.setAccessible(true);

Student student = (Student) constructor.newInstance("world",18);

System.out.println(student);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (NoSuchMethodException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

/**

* 反射私有属性

*/

public static void reflectPrivateField() {

try {

Class> c1 = Class.forName("reflectTest.Student");

Student student = (Student) c1.newInstance();

Field field = c1.getDeclaredField("name");

field.setAccessible(true);

field.set(student,"zhang");

System.out.println(student);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (NoSuchFieldException e) {

e.printStackTrace();

}

}

// 反射私有方法

public static void reflectPrivateMethod() {

try {

Class> c1 = Class.forName("reflectTest.Student");

Student student = (Student) c1.newInstance();

Method method = c1.getDeclaredMethod("function",String.class);

method.setAccessible(true);

method.invoke(student,"我是私有的方法的参数");

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (NoSuchMethodException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

// reflectNewInstance();

// reflectPrivateConstructor();

// reflectPrivateField();

reflectPrivateMethod();

}

}

1.9 反射优点和缺点

优点：

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

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

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

缺点：

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

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

二、枚举

枚举的主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：

public static int final RED = 1;

public static int final GREEN = 2;

public static int final BLACK = 3;

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

代码示例：

package enumTest;

public enum test01 {

RED,BLACK,GREEN,WHITE;

public static void main(String[] args) {

// System.out.println(test01.BLACK);

// System.out.println(BLACK);

test01 te = test01.BLACK;

switch (te) {

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("green");

break;

default:

break;

}

}

}

输出结果：

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

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

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

2.1 Enum 类的常用方法

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

values()代码示例 ：

public enum test01 {

RED,BLACK,GREEN,WHITE;

public static void main(String[] args) {

test01[] te = test01.values();

for (int i = 0; i < te.length; i++) {

System.out.println(te[i]);

}

}

}

输出结果：

ordinal() 代码示例：

public enum test01 {

RED,BLACK,GREEN,WHITE;

public static void main(String[] args) {

test01[] te = test01.values();

for (int i = 0; i < te.length; i++) {

System.out.println(te[i] + " --> " + te[i].ordinal());

}

}

}

输出结果：

valueOf() 、compareTo() 代码示例：

public enum test01 {

RED,BLACK,GREEN,WHITE;

public static void main(String[] args) {

//把字符串变成对应的枚举对象

test01 te = test01.valueOf("RED");

System.out.println(te);

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

System.out.println(BLACK.compareTo(RED));//1

}

}

输出结果：

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

public enum test01 {

//枚举对象

RED("red",1),BLACK(),GREEN(),WHITE();

public String color;

public int ordinal;

//private 加或者不加其都是私有的

test01(String color, int ordinal) {

this.color = color;

this.ordinal = ordinal;

}

//无参构造

test01(){

}

}

2.2 枚举的优点和缺点

优点：

1.枚举常量更简单安全 。

2.枚举具有内置方法 ，代码更优雅。

缺点：

1.不可继承，无法扩展。

枚举非常安全，不能通过反射，拿到实例对象。枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承于 java.lang.Enum枚举可以避免反射和序列化问题

三、Lambda 表达式

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

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

代码示例：

package lambdaTest;

@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 OneParameterRetuhttp://rn {

int test(int a);

}

//有返回值多参数

@FunctionalInterface

interface MoreParameterReturn {

int test(int a,int b);

}

public class test01 {

public static void main(String[] args) {

// {} return 可以省略

NoParameterReturn noParameterReturn = ()->{return 10;};

int ret = noParameterReturn.test();

System.out.println(ret);//10

//()可以省略

OneParameterReturn oneParameterReturn = (a) -> a;

System.out.println(oneParameterReturn.test(10));//10

MoreParameterReturn moreParameterReturn = (a,b) -> a+b;

System.out.println(moreParameterReturn.test(1,2));//3

}

public static void main3(String[] args) {

//() {} 可省略

OneParameterNoReturn oneParameterNoReturn = (a)-> System.out.println(a);

oneParameterNoReturn.test(10);//10

//int类型可以省略

MoreParameterNoReturn moreParameterNoReturn = (a,b)-> System.out.println(a+b);

moreParameterNoReturn.test(10,20);//30

}

public static void main2(String[] args) {

NoParameterNoReturn noParameterNoReturn = () -> System.out.println("重写方法");

noParameterNoReturn.test();

}

public static void main1(String[] args) {

NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){

public void test(){

System.out.println("重写方法");

}

};

noParameterNoReturn.test();

}

}

3.2 函数式接口

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

注意：

1.如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口。

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

代码示例：

@FunctionalInterface

//函数式接口

interface NoParameterNoReturn {

//注意：只能有一个方法

void test();

}

public static void main1(String[] args) {

NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){

public void test(){

System.out.println("重写方法");

}

};

noParameterNoReturn.test();

}

}

3.3 变量捕获

Lambda 表达式中存在变量捕获 ，了解了变量捕获之后，我们才能更好的理解Lambda 表达式的作用域 。Java当中的匿名类中，会存在变量捕获。

package lambdaTest;

class Test {

public void func(){

System.out.println("func()");

}

}

public class test02 {

public static void main(String[] args) {

int a = 100;

new Test(){

@Override

public void func() {

System.out.println("我是内部类，且重写了func这个方法！");

System.out.println("捕获遍历" + a);//能捕获到的变量，要么是常量，要么未发生改变过。

}

};

}

}

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的xRoVRhqgjb简洁。缺点也很明显，代码不易读。

优点：

代码简洁，开发迅速；方便函数式编程；非常容易进行并行计算；Java 引入 Lambda，改善了集合操作；

缺点：

代码可读性变差；在非并行计算中，很多计算未必有传统的 for 性能要高；不容易进行调试；

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。