本文介绍了Java中的反射机制，包括反射的工作原理、使用方法及其优缺点。同时，文章探讨了枚举的引入、用途、常见方法以及优缺点。最后，讨论了反射是否能获取枚举实例，并通过源码分析得出结论：枚举类无法通过反射创建实例。
反射
Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制
反射工作原理
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类
反射的使用和基本方法
在反射之前，我们需要做的第一步就是先拿到当前需要反射的类的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 +
'}';
}
}
第一种，使用 Class.forName(“类的全路径名”); 静态方法。
前提：已明确类的全路径名
public static void reflectNewInstance() {
try {
Class<?> c1 = Class.forName("Student");
Student student = (Student)c1.newInstance();
System.out.println("学生对象："+student);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
reflectNewInstance()
}
通过 Class.forName就可以在另外一个类中获取学生类的成员变量和属性了
第二种，使用 .class 方法。
说明：仅适合在编译前就已经明确要操作的 Class
public static void reflectPrivateConstructor() {
try {
Class<?> c1 = Class.forName("Student");
Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class);
//私有的一般都要加（是否戒除私有包装）
constructor.setAccessible(true);
Student student = (Student)constructor.newInstance("gaoo",19);
System.out.println(student);
} 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);
}
}
public static void main(String[] args) {
reflectPrivateConstructor();
}
第三种，使用类对象的 getClass() 方法
public static void reflectPrivateField() {
try {
Class<?> c1 = Class.forName("Student");
Field field = c1.getDeclaredField("name");
field.setAccessible(true);
Student student = (Student)c1.newInstance();
field.set(student,"唐老鸭");
System.out.println(student);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
reflectPrivateField();
}
反射的优点和缺点
优点：1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。
缺点：
- 使用反射会有效率问题。会导致程序效率降低。
- 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。
枚举
枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：
public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;
但是常量举例有不好的地方，例如：可能碰巧有个数字1，但是他有可能误会为是RED，现在我们可以直接用枚举来进行组织，这样一来，就拥有了类型，枚举类型。而不是普通的整形1.
public enum TestEnum {
RED,BLACK,GREEN;
}
优点：将常量组织起来统一进行管理
场景：错误状态码，消息类型，颜色的划分，状态机等等…
枚举的使用常见方法
使用switch语句
public enum TestEnum {
RED,BLACK,GREEN,WHITE;
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;
}
}
在这里插入图片描述
常见方法
values() ：以数组形式返回枚举类型的所有成员
public enum TestEnum {
RED ,BLACK, GREEN;
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i]);
}
}
}
ordinal() ：获取枚举成员的索引位置
public enum TestEnum {
RED ,BLACK, GREEN;
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i]+" 索引："+testEnums[i].ordinal());
}
}
valueOf() ：将普通字符串转换为枚举实例
public enum TestEnum {
RED, BLACK, GREEN;
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i]+" 索引："+testEnums[i].ordinal());
}
System.out.println("==========");
TestEnum testEnum = TestEnum.valueOf("GREEN");
System.out.println(testEnum);
}
compareTo()：比较两个枚举成员在定义时的顺序
public enum TestEnum {
RED(1,"red"),
BLACK(2,"black"),
GREEN(3,"green");
private String color;
private int ordinal;
//默认是私有的
TestEnum(int ordinal,String color) {
this.color = color;
this.ordinal = ordinal;
}
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i]+" 索引："+testEnums[i].ordinal());
}
System.out.println("==========");
TestEnum testEnum = TestEnum.valueOf("GREEN");
System.out.println(testEnum);
System.out.println(RED.compareTo(GREEN));
}
枚举的优缺点
优点：1. 枚举常量更简单安全 。
2. 枚举具有内置方法 ，代码更优雅
缺点：1. 不可继承，无法扩展
反射和枚举
上面我们将来反射和枚举，那么枚举是否可以通过反射，拿到实例对象呢？
我们刚刚在反射里边看到了，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那么枚举的构造方法也是私有的，我们是否可以拿到呢？接下来，我们来实验一下：
package testenmu;
import java.lang.reflect.Constructor;
/**
* @Author 12629
* @Description：
*/
public class TestReflectEnum {
public static void reflectPrivateConstructor() {
try {
Class<?> classStudent = Class.forName("testenmu.TestEnum");
//注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和int。
Constructor<?> declaredConstructorStudent =
classStudent.getDeclaredConstructor(String.class,int.class);
//设置为true后可修改访问权限
declaredConstructorStudent.setAccessible(true);
Object objectStudent = declaredConstructorStudent.newInstance("父类参数",111,666,"绿色");
TestEnum testEnum = (TestEnum) objectStudent;
System.out.println("获得枚举的私有构造函数："+testEnum);
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
reflectPrivateConstructor();
}
}
此时我们发现通过反射获取枚举对象代码报出java.lang.NoSuchMethodException:testenmu.TestEnum.(java.lang.String, int)
通过报错信息我们可以知道没有对应的构造方法，我们不是提供的枚举的构造方法就是两个参数分别是 String 和 int，但是这里我们上面说过了所有枚举类都是默认继承java.lang.Enum，继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！而我们写的类，并没有帮助父类构造，而根据枚举的源码我们可以发现
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
也就是说，我们自己的构造函数有两个参数一个是String一个是int，同时他默认后边还会给两个参数，一个是String一个是int。也就是说，这里我们正确给的是4个参数：
package testenmu;
import java.lang.reflect.Constructor;
/**
* @Author 12629
* @Description：
*/
public class TestReflectEnum {
public static void reflectPrivateConstructor() {
try {
Class<?> classStudent = Class.forName("testenmu.TestEnum");
//注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和int。
Constructor<?> declaredConstructorStudent =
classStudent.getDeclaredConstructor(String.class,int.class,
int.class,String.class);
//设置为true后可修改访问权限
declaredConstructorStudent.setAccessible(true);
Object objectStudent = declaredConstructorStudent.newInstance("父类参数",111,666,"绿色");
TestEnum testEnum = (TestEnum) objectStudent;
System.out.println("获得枚举的私有构造函数："+testEnum);
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
reflectPrivateConstructor();
}
}
我们这里添加了四个参数为什么还是报错
java.lang.IllegalArgumentException: ，我们再来看一下反射的源码
根据源码我们就会发现枚举在这里被过滤了，你不能通过反射获取枚举类的实例！
总结
1、枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum
2、枚举可以避免反射和序列化问题
扫一扫
1111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
