1、反射
能够分析类能力的程序称为反射。反射机制可以用来：
在运行时分析类的能力；
在运行时检查对象；
实现泛型数组操作代码；
利用Method对象，这个对象很像C++中的函数指针。
Reflection 是 Java被视为动态语言（运行时改变其结构）的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
加载完类之后，在对内存的方法去中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象地称之为：反射
正常方式创建对象：
- 引入需要的包的名称
- 通过new实例化
- 获得实例化对象
反射方式创建对象：
- 实例化对象
- getClass()方法
- 得到完整的包的名称
2、优缺点
- 可以实现动态创建对象和编译，体现出很大的灵活性
- 可以在程序运行过程中，操作这些对象。
- 可以解耦，提高程序的可扩展性。
- 对性能有所影响
3、相关API
- java.lang.Class：代表一个类
- java.lang.reflect.Method：代表类的方法
- java.lang.reflect.Field：代表类的成员变量
- java.lang.reflect.Constructor：代表类的构造器
4、使用
通过反射创建对象
获取类的Class对象有三种方法
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取
多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
多用于对象的获取字节码的方式
package reflect;
public class fanshe {
public static void main(String[] args) throws ClassNotFoundException {
Class c1 = Class.forName("reflect.User");
System.out.println(c1.hashCode());
Class c2 = User.class;
System.out.println(c2.hashCode());
Class c3 = new User().getClass();
System.out.println(c3.hashCode());
}
}
class User{
public User() {
}
public User(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
private int age;
private String name;
}
结果：
1607521710
1607521710
1607521710
结论：
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
Class类
Object类中定义以下方法
public final native Class<?> getClass();这个方法的返回值就是Class类，Class类是反射的源头
- Class本身也是一个类
- Class对象只能由系统建立对象
- 一个加载的类在JVM中只会有一个Class实例
- 一个Class对象对应的是一个 加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个Class实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的对象
拥有Class对象的类型
class：外部类、内部内、静态内部类等
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void
public class Demo3 {
public static void main(String[] args) {
Class c1 = Object.class;
Class c2 = Collection.class;
Class c3 = int[].class;
Class c4 = ElementType.class;
Class c5 = SuppressWarnings.class;
Class c6 = Integer.class;
Class c7 = void.class;
}
}通过反射获得类的信息
Class对象功能：
获取功能：
1. 获取成员变量们
Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)
2. 获取构造方法们
Constructor<?>[] getConstructors()
Constructor<T> getConstructor(类<?>... parameterTypes)
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
3. 获取成员方法们：
Method[] getMethods()
Method getMethod(String name, 类<?>... parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>... parameterTypes)
4. 获取全类名
String getName() （全类名）
package reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class fansheget {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("reflect.User");
//获取所有public修饰的成员变量
Field[] fields = c1.getFields();
//获取所有的成员变量，不考虑修饰符
Field[] declaredFields = c1.getDeclaredFields();
// 获得指定属性
Field declaredField = c1.getDeclaredField("name");
// 获得所有公有方法
Method[] methods = c1.getMethods();
// 获得所有方法
Method[] declaredMethods = c1.getDeclaredMethods();
// 获得指定方法
c1.getDeclaredMethod("setAge", int.class);
}
}
通过反射获得类的对象
通过newInstance()方法
- Constructor:构造方法（Constructor反射包）
创建对象：
T newInstance(Object... initargs)
如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法 - 类必须含有一个无参构造器
- 类的构造器的访问权限要足够
package reflect; import java.lang.reflect.Field; import java.lang.reflect.Method; public class fansheget { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InstantiationException { Class c1 = Class.forName("reflect.User"); //无参构造 User user = (User) c1.newInstance(); System.out.println(user); } }
-
总结：获得类的实例的步骤
- 通过类的Class对象
- 如果想通过调用无参构造方法创建实例
- 直接调用Class对象的newInstance()方法
- 将返回值强转为对应的类型
- 如果想通过有参构造方法创建实例
- 调用Class对象的getDeclaredConstructor()并传入构造方法相应的参数的类型
- 通过获得的有参构造器，调用newInstance()方法，传入相应参数
- 将返回值强转为对应的类型
通过反射调用类的方法
package reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class fansheget {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class c1 = Class.forName("reflect.User");
//通过反射调用类的方法
User user2 = (User) c1.newInstance();
Method setAge = c1.getDeclaredMethod("setAge", int.class);
setAge.invoke(user2,44);
System.out.println(user2.getAge());
}
}
步骤
- 获得类的Class对象
- 调用Class对象的newInstance()方法，获取类的对象
- 调用Class对象的getDeclaredMethod()方法
- 调用返回对象的invoke()方法，传入所需的参数（参数包含对哪个对象调用该方法），如 setName.invoke(user, 44);
通过反射设置属性值
操作：
1. 设置值
void set(Object obj, Object value)
2. 获取值
get(Object obj)
3. 忽略访问权限修饰符的安全检查
setAccessible(true):暴力反射
（如果没有就访问不到私有成员）方法：私有成员.setAccessible(true)
package reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class fansheget {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class c1 = Class.forName("reflect.User");
//通过反射设置属性值
User user3 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
name.setAccessible(true);
name.set(user3,"ny");
System.out.println(user3.getName());
}
}
步骤
- 获得类的Class对象
- 调用Class对象的newInstance()方法，获取类的对象
- 调用Class对象的getDeclaredField()方法，获取属性
- 调用属性对象的set()方法进行赋值
- 如果是私有属性，还需要调用name.setAccessible(true);方法进行设定
通过获得注解信息
public class Demo6 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("main.study.day4.Student");
Student student = (Student) c1.newInstance();
// 获得类的注解
Annotation[] declaredAnnotations = c1.getDeclaredAnnotations();
System.out.println(Arrays.toString(declaredAnnotations));
// 获得属性上的注解
Field name = c1.getDeclaredField("name");
Annotation annotation = name.getAnnotation(FieldAnnotation.class);
System.out.println(annotation);
// 获得方法的注解
Method getName = c1.getDeclaredMethod("getName");
MethodAnnotation methodAnnotation = getName.getAnnotation(MethodAnnotation.class);
System.out.println(methodAnnotation);
}
}
@ClassAnnotation(name = "myStudent")
class Student {
@FieldAnnotation(name = "name")
private String name;
@FieldAnnotation(name = "age")
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@MethodAnnotation(name = "getName")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
/**
* @author Nyima
* 类的注解
*/
@interface ClassAnnotation {
String name();
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
/**
* @author Nyima
* 属性的注解
*/
@interface FieldAnnotation {
String name();
}
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
/**
* @author Nyima
* 方法的注解
*/
@interface MethodAnnotation {
String name();
}步骤
- 先获取到对应的类，如
- 想获得类注解，需要先获得Class类对象
- 想获得属性的注解，需要先获得对应的属性
- 想获得方法的注解，需要先获得对应的方法
- …
- 通过对应的对象调用getDeclaredAnnotation()或者其他获取注解的方法，并传入需要的参数即可
4370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
