目录
反射
定义：Java的反射(reflection)机制是在运行状态中，对于任意一个类，都能够知道这个类的
所有属性和方法;对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那
么，我们就可以修改部分类型信息;这种动态获取信息以及动态调用对象方法的功能称
为java语言的反射(reflection)机制
反射基本信息：Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，
例如Person p = newStudent()；这句代码中p在编译时类型为Person，运行时类型为Student。程序
需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。
反射相关的类(重要)
Class类代表类的实体，在运行的Java应用程序中表示类和接口
Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的
Java文件.class也被JVM解析为 一个对象，这个对象就是java.lang.Class .这样当程序
在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反
射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这
个类成为一个动态的类
获得Class对象的三种方式
第一种，使用 Class.forName("类的全路径名"); 静态方法 前提:已明确类的全路径名
通过 Class 对象的 forName() 静态方法来获取，用的最多， 但可能抛出
ClassNotFoundException 异常 注意这里是类的全路径，如果有包需要加包的路径
第二种，使用 .class 方法 说明:仅适合在编译前就已经明确要操作的 Class
直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高 这说明任何一个
类都有一个隐含的静态成员变量 class
第三种，使用类对象的 getClass() 方法
一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的
代码图片演示：
Class类中的相关方法演示
首先定义一个学生类，然后下面进行演示
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 static void reflectNewInstance() {//newInstance()方法创建类的实例
Class<?> classStudent = null;
try {
//获得Class对象
classStudent = Class.forName("demo1.Student");
//创建类的实例
Student student = (Student) classStudent.newInstance();
System.out.println(student);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}(重要)常用获得类中属性相关的方法
代码演示：
// 反射私有属性
public static void reflectPrivateField() {//getDeclaredField()获得所有属性对象
Class<?> classStudent = null;
try {
classStudent = Class.forName("demo1.Student");
//获得所有属性对象
Field field = classStudent.getDeclaredField("name");
//创建类的实例
Student student = (Student) classStudent.newInstance();
//相当于询问你确不确定要执行
field.setAccessible(true);
//修改student对象的属性
field.set(student, "Nan");
System.out.println(student);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
(重要)获得类中构造器相关的方法
代码演示：
// 反射私有的构造方法 屏蔽内容为获得公有的构造方法
public static void reflectPrivateConstructor() {//getDeclaredConstructor()获得该类所有构造方法
Class<?> classStudent = null;
try {
classStudent = Class.forName("demo1.Student");
//获取该类所有构造方法 注意传入对应的参数
Constructor<?> constructor = classStudent.getDeclaredConstructor(String.class, int.class);
//相当于询问你确不确定要执行 设置为true后可修改访问权限
constructor.setAccessible(true);
Student student = (Student) constructor.newInstance("nan", 18);
System.out.println(student);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}(重要)获得类中方法相关的方法
代码演示：
// 反射私有方法
public static void reflectPrivateMethod() {//getDeclaredMethods()获得该类所有方法
Class<?> classStudent = null;
try {
classStudent = Class.forName("demo1.Student");
//参数填方法名和反射参数
Method method = classStudent.getDeclaredMethod("function", String.class);
method.setAccessible(true);
//两种
Student student = (Student) classStudent.newInstance();
Object student1 = classStudent.newInstance();
//修改student方法的输出
method.invoke(student, "我是一个反射的参数！");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}反射优点和缺点
优点:
1. 对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法
2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
3. 反射已经运用在了很多流行框架如:Struts、Hibernate、Spring 等等
缺点:
1. 使用反射会有效率问题。会导致程序效率降低。
2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂
总结
1.反射的意义
2. 反射重要的几个类: Class类 、Field类、 Method类、 Constructor类
3. 学会合理利用反射，一定要在安全环境下使用
枚举
枚举是抽象类，枚举的构造方法默认是私有的(重要)
枚举是在JDK1.5以后引入的。主要用途是:将一组常量组织起来，在这之前表示一组常量通常使用
定义常量的方式:
public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;但是常量举例有不好的地方，例如：可能碰巧有个数字1，但是他有可能误会为是RED，现在我们
可以直接用枚举来进行组织，这样一来，就拥有了类型，枚举类型。而不是普通的整型
public enum TestEnum {
RED,BLACK,GREEN;
}
优点:将常量组织起来统一进行管理
本质:是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但
是其默认继承了 Enum这个类
枚举的使用
常用方法
常用方法代码演示：
public enum TestEnum {//枚举类 我们这个TestEnum类默认继承Enum类 所以也会继承Enum类的构造方法
//枚举对象
RED(1, "红色"),
GREEN(2, "绿色"),
BLACK(3, "黑色");
private int ordinal;
private String color;
private TestEnum(int ordinal, String color) {
this.ordinal = ordinal;
this.color = color;
}
public static void main(String[] args) {
//values()以 数组形式 返回 枚举类型的所有成员
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
//获取枚举成员的索引位置
System.out.println(testEnums[i].ordinal());
}
TestEnum v = TestEnum.valueOf("BLACK");//将普通字符串转换为枚举实例
System.out.println(v);
System.out.println(RED.compareTo(BLACK));//比较两个枚举成员在定义时的顺序
}
}疑问：Enum类源码里没有values方法，为什么可以被调用
这是因为在编译枚举类时，Java 编译器会为每个枚举类自动添加一个名为 values() 的静态方
法，用于返回该枚举类中所有枚举常量的数组，虽然在源代码中你看不到 values() 方法的实
现，但它实际上在编译时被添加到了编译后的字节码中，因此可以被调用。
枚举尝试反射
枚举是否可以通过反射，拿到实例对象呢? 答案是不能
代码演示：
public static void func() {
Class<?> c1 = null;
try {
c1 = Class.forName("demo2.TestEnum");
//我们这个TestEnum类默认继承Enum类 所以也会继承Enum类的构造方法
Constructor<?> constructor = c1.getDeclaredConstructor(int.class, String.class);
constructor.setAccessible(true);
TestEnum testEnum = (TestEnum) constructor.newInstance("白色", 7, 6, "蓝色");
System.out.println(testEnum);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}结果发现报异常了！异常的原因是没有对应的构造方法
我们去枚举类的底层源码看它有个构造方法，我们所有的枚举类，都是默认继承java.lang.Enum ,
说到继承，继承了什么？继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！而
我们写的类，并没有帮助父类构造
接着帮父类构造让我们看看代码以及结果
public static void func() {
Class<?> c1 = null;
try {
c1 = Class.forName("demo2.TestEnum");
//我们这个TestEnum类默认继承Enum类 所以也会继承Enum类的构造方法
Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class, String.class);
constructor.setAccessible(true);
TestEnum testEnum = (TestEnum) constructor.newInstance("白色", 7, 6, "蓝色");
System.out.println(testEnum);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
又报异常了！当我们点进去看源码发现不能通过反射获取枚举类的实例
总结
1、枚举本身就是一个类(抽象类)，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum
2、枚举可以避免反射和序列化问题
Lambda表达式
基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表达式由三部分组成：
1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明
也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。2. ->：可理解为“被用于”的意思
3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反
回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。
函数式接口
要了解Lambda表达式,首先需要了解什么是函数式接口
函数式接口定义:一个接口有且只有一个抽象方法
定义方式：
//函数式接口
@FunctionalInterface
interface NoParameterNoReturn1 {
//注意：只能有一个方法
void test();
}
注意:
1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的
定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，
只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。
Lambda表达式的基本使用
定义无返回值的接口:
//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a, int b);
}
代码演示：
public static void main2(String[] args) {
//Lambda表达式 无返回值无参数
NoParameterNoReturn noParameterNoReturn = () -> System.out.println("重写了test方法!" );
noParameterNoReturn.test();
//Lambda表达式 无返回值一个参数
OneParameterNoReturn oneParameterNoReturn = (a) -> System.out.println("oneParameterNoReturn :" + a);
oneParameterNoReturn.test(10);
//Lambda表达式 无返回值多个参数
MoreParameterNoReturn moreParameterNoReturn = ((a, b) -> System.out.println(a + b));
moreParameterNoReturn.test(1, 2);
}定义有返回值的接口：
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
int test(int a, int b);
}代码演示：
public static void main3(String[] args) {
//Lambda表达式 有返回值无参数
//NoParameterReturn noParameterReturn = () -> 10;
NoParameterReturn noParameterReturn = () -> {
return 10;
};
System.out.println(noParameterReturn.test());
//Lambda表达式 有返回值一个参数
OneParameterReturn oneParameterReturn = (a) -> {
return a;
};
System.out.println(oneParameterReturn.test(20));
//Lambda表达式 有返回值多参数
MoreParameterReturn moreParameterReturn = (q, w) -> {
return q + w;
};
System.out.println(moreParameterReturn.test(10, 20));
}