Java语言----反射、枚举以及lambda表达式
目录
一.反射
1.1反射的基本情况
1.2反射中最重要的类
1.2.1 Class类
1.2.2Field类
1.2.3Constructor类
1.2.4Methood类
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.4Methood类
作用：对类中方法进行操作
| 方法 | 用途 |
| 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);
}
}3.2.3二者区别
代码实例：
1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略
3. 如果方法体当中只有一句代码，那么大括号可以省略
4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。
3.3变量捕获
变量捕获，在匿名内部类中也存在，而类似匿名内部类的Lambda表达式，自然而然也存在。
3.3.1匿名内部类的变量捕获
如上图，在匿名内部类外，已经定义了a的值，因此匿名内部类直接捕获了外部的a变量。
3.3.2Lambda变量捕获
如上图，使用直接捕获了外部的a变量。
注：无论是匿名内部类的变量捕获还是Lambda变量捕获，方法体里，不可修改外部变量的值。
总结
反射、枚举以及Lambda表达式很少使用，算是偏僻的知识点，因此不要求掌握，只要求熟悉。