1.反射
1.1 定义
Java的反射机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。
1.2 原理
Java程序运行前，首先会通过编译将Java代码生成.class文件；程序运行过程中使用某个类时，如果该类还未被加载到内存中，系统会将该类的.class字节码文件读入内存，同时JVM会产生一个java.lang.Class对象代表该.class字节码文件。
通过Class对象可以得到大量的Method、Constructor、Field等对象，这些对象分别代表该类所包括的方法、构造器和属性等，反射的工作原理就是通过这些对象来执行实际的功能，例如调用方法、创建实例等。
| 类名 | 用途 |
| Class类 | 代表类的实体，在运行的Java应用程序中表示类和接口 |
| Field类 | 代表类的成员变量/类的属性 |
| Method类 | 代表类的方法 |
| Constructor类 | 代表类的构造方法 |
1.3 反射对象类中的常用方法（方法的使用在1.4中）
常用获得类相关的方法（以下方法返回值与Class相关）
| 方法 | 用途 |
| getClassLoader() | 获得类的加载器 |
| getDeclaredClasses() | 返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的) |
| forName(String className) | 根据类名返回类的对象 |
| newInstance() | 创建类的实例 |
| getName() | 获得类的完整路径名字 |
常用获得类中属性相关的方法(以下方法返回值为Field相关)
| 方法 | 用途 |
| getField(String name) | 获得某个公有的属性对象（指定参数） |
| getFields() | 获得所有公有的属性对象 |
| getDeclaredField(String name) | 获得某个属性对象（指定参数） |
| getDeclaredFields() | 获得所有属性对象 |
获得类中构造器相关的方法（以下方法返回值为Constructor相关）
| 方法 | 用途 |
| getConstructor(Class…<?> parameterTypes) | 获得该类中与参数类型匹配的公有构造方法 |
| getConstructors() | 获得该类的所有公有构造方法 |
| getDeclaredConstructor(Class…<?> parameterTypes) | 获得该类中与参数类型匹配的构造方法 |
| getDeclaredConstructors() | 获得该类所有构造方法 |
获得类中方法相关的方法（以下方法返回值为Method相关）
| 方法 | 用途 |
getMethod(String name, Class…<?> parameterTypes) |
获得该类某个公有的方法 |
| getMethods() | 获得该类所有公有的方法 |
| getDeclaredMethod(String name, Class…<?> parameterTypes) | 获得该类某个方法 |
| getDeclaredMethods() | 获得该类所有方法 |
注意：在方法中声明“Declared”后，就可以获得对象私有的属性和方法，但是必须将该对象的accessible=true，否则抛出IllegalAccessException异常。
1.4 反射示例
首先我们在一个包下写一个类，该类中有私有和公有的各类成员变量和方法，然后我们利用反射来获取该类的方法、构造器或属性等。
package reflect; public class Person { //私有属性name private String name = "张三"; //公有属性age public int age; //不带参数的构造方法 public Person() { System.out.println("Person()"); } //带参数的私有构造方法 private Person(String name, int age) { this.age = age; this.name = name; System.out.println("Person(String,name)"); } private void eat() { System.out.println("I am eating"); } public void sleep() { System.out.println("I am sleeping"); } private void function(String str) { System.out.println(str); } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
1.4.1 获取反射中的Class对象
想获取类的方法、构造器或属性等，必须先获取该类的Class对象;
且一个类只有一个Class对象，所以代码示例中的打印结果全为true.
//1.使用 Class.forName() 静态方法,需要知道类的全路径名 Class<?> c1=Class.forName("reflect.Person"); //2.使用.class方法 Class<?> c2=Person.class; //3.使用类对象的getClass()方法 Person person=new Person(); Class<?> c3=person.getClass(); System.out.println(c1==c2); System.out.println(c1==c3); System.out.println(c2==c3); // true true true
1.4.2 通过反射创建类对象
Class<?> c=Person.class; //1.通过Class对象的newInstance()方法 Person person1=(Person) c.newInstance(); //2.通过 Constructor 对象的 newInstance() 方法 Constructor<?> constructor= c.getConstructor(); Person person2=(Person) constructor.newInstance();
1.4.3 通过反射获取类属性、方法、构造器
Class<?> c=Person.class; //获取name属性 Field field=c.getDeclaredField("name"); //获取自身和父类的公有属性（不包括私有的） Field[] fields= c.getFields(); //获取自身的公有和私有属性 Field[] declaredFields = c.getDeclaredFields(); //获取function方法，参数为String Method method= c.getMethod("function", String.class); //获取自身和父类的公有方法（不包括私有的） Method[]methods= c.getMethods(); //获取自身的公有和私有方法 Method[] declaredMethods = c.getDeclaredMethods(); //获取无参的构造方法 Constructor<?> constructor=c.getConstructor(); //获取参数为String和int的构造方法 Constructor<?> constructor1=c.getDeclaredConstructor(String.class,int.class); //获取自身和父类的构造方法（不包括私有的） Constructor<?>[]constructors=c.getConstructors();
1.4.4 通过反射获取属性值及执行方法
public static void main(String[] args) { try { Class<?> c=Person.class; //通过构造方法创建对象 Constructor<?> constructor= c.getDeclaredConstructor(String.class,int.class); constructor.setAccessible(true); Person person=(Person) constructor.newInstance("王五",18); System.out.println(person); System.out.println("====================="); //字段属性 Field field=c.getDeclaredField("name"); field.setAccessible(true); field.set(person,"李四"); System.out.println(person); System.out.println("====================="); //方法属性 Method method= c.getDeclaredMethod("function", String.class); method.setAccessible(true); method.invoke(person,"我是通过反射给你传参的");//执行方法 } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (NoSuchFieldException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } // Person(String,name) Person{name='王五', age=18} ===================== Person{name='李四', age=18} ===================== 我是通过反射给你传参的
1.5 反射优点和缺点
优点：
- 反射增加了程序的灵活性。
- 反射可以让程序有很好的拓展性。
- 反射可以在不知道会运行哪一个类的情况下，获取到类的信息，创建对象以及操作对象；我们无需将类型硬编码写死，方便程序拓展，降低耦合度。
缺点：
- 反射更容易出现运行时错误。
- 使用显式的类和接口，编译器能帮我们做类型检查，但使用反射需要运行时才知道类型，此时编译器也爱莫能助。
- 反射性能不高。
- 反射是一种解释操作，在访问字段和调用方法前，需要查找到对应的 Field 和 Method，性能要低一些。
- 因此反射机制主要应用在对灵活性和拓展性要求较高的系统框架上。
- 反射会带来安全性问题。
- 反射可以随意修改私有属性和访问私有方法，破坏了类的封装，可能导致逻辑错误或者存在安全隐患。
2.枚举
2.1 背景及定义
枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来
public static int final RED = 1; public static int final GREEN = 2; public static int final BLACK = 3;
、
但是这种常量举例有不好的地方，比如：碰巧有个数字1，但是它可能会误认为是RED，现在我们可以直接用枚举类型来进行组织，这样就有了区分
public enum TestEnum { RED,BLACK,GREEN; }
本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了
这个类。
2.2 枚举的使用
1.switch语句
public enum TestEnum { RED,BLACK,GREEN,WHITE; public static void main(String[] args) { TestEnum testEnum=TestEnum.BLACK; switch (testEnum) { 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; } } } // black Process finished with exit code 0
2.常用方法
Enum类的常用方法
| 方法名称 | 描述 |
| values() | 以数组形式返回枚举类型的所有成员 |
| ordinal() | 获取枚举成员的索引位置 |
| valueOf() | 将普通字符串转换为枚举实例 |
| compareTo() | 比较两个枚举成员在定义时的顺序 |
示例：
public enum TestEnum { RED, BLACK, GREEN, WHITE; public static void main(String[] args) { //values()方法 TestEnum[] testEnums = TestEnum.values(); for (int i = 0; i < testEnums.length; i++) { //ordinal()方法 System.out.println(testEnums[i] + " 序号： " + testEnums[i].ordinal()); } System.out.println("=============="); //valueOf()方法 TestEnum testEnum = TestEnum.valueOf("GREEN"); System.out.println(testEnum); System.out.println("=============="); TestEnum testEnum1 = TestEnum.BLACK; TestEnum testEnum2 = TestEnum.RED; //compareTo()方法 System.out.println(testEnum1.compareTo(testEnum2)); System.out.println(BLACK.compareTo(RED)); System.out.println(RED.compareTo(BLACK)); } } // RED 序号： 0 BLACK 序号： 1 GREEN 序号： 2 WHITE 序号： 3 ============== GREEN ============== 1 1 -1 Process finished with exit code 0
事实上在Java中，枚举就是一个类，所以我们在定义枚举类时，如果枚举对象有参数，需要提供相应的构造函数。
枚举的构造方法默认是私有的
public enum TestEnum { RED("red",2), BLACK("black",3), GREEN("green",4), WHITE("white",5); public String color; public int ordinal; TestEnum(String color, int ordinal) { this.color = color; this.ordinal = ordinal; } }
2.3 枚举和反射
我们了解到，任何一个类，哪怕其属性或者方法是私有的，我们都可以通过反射来获取到该实例对象，枚举的构造方法也是私有的，我们可以尝试是否可以通过反射来获取到。
我们还以2.2中最后的枚举类为例：
public enum TestEnum { RED("red", 2), BLACK("black", 3), GREEN("green", 4), WHITE("white", 5); public String color; public int ordinal; TestEnum(String color, int ordinal) { this.color = color; this.ordinal = ordinal; } public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException { Class<?> c = TestEnum.class; Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class); constructor.setAccessible(true); TestEnum testEnum = (TestEnum) constructor.newInstance("海雾蓝", 9); System.out.println(testEnum); } } // Exception in thread "main" java.lang.NoSuchMethodException: TestEnum.<init>(java.lang.String, int) at java.lang.Class.getConstructor0(Class.java:3082) at java.lang.Class.getDeclaredConstructor(Class.java:2178) at TestEnum.main(TestEnum.java:19) Process finished with exit code 1
运行后报错 java.lang.NoSuchMethodException: TestEnum.<init>(java.lang.String, int)，意思是没有对应的构造方法，但我们所提供的枚举类的构造方法就是两个参数String和int。
这是因为所有的枚举类都默认继承于 java.lang.Enum ，所以在构造子类时，要先帮助父类进行构造，Enum的源码：
protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; }
所以我们需要提供四个参数来完成构造
public enum TestEnum { RED("red", 2), BLACK("black", 3), GREEN("green", 4), WHITE("white", 5); public String color; public int ordinal; TestEnum(String color, int ordinal) { this.color = color; this.ordinal = ordinal; } public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException { Class<?> c = TestEnum.class; Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class,String.class, int.class); constructor.setAccessible(true); TestEnum testEnum = (TestEnum) constructor.newInstance("海雾蓝", 9); System.out.println(testEnum); } } // Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417) at TestEnum.main(TestEnum.java:21) Process finished with exit code 1
此时仍然报错，但报错原因变为了java.lang.IllegalArgumentException: Cannot reflectively create enum objects，我们从源码中查找原因
也就是说，枚举在这里被过滤了，不能通过反射获取枚举类的实例。
2.4 总结
枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum
枚举可以避免反射和序列化问题
枚举优点缺点
优点：
1.枚举常量更简单安全 。 2. 枚举具有内置方法 ，代码更优雅
缺点：
不可继承，无法扩展
