|
反射是Java被视为准动态语言的关键，反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及其方法(包括private关键字修饰的)
想要获取或操作类创建的对象的内部属性及其方法，首先就要获取该类的Class对象，该类的Class对象是在初始化的时候创建的
1、获得类的Class对象
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException {
//方式一：通过实例化对象获得
Class c1 = new TestReflection().getClass();
//方式二：forName方法获得
Class c2 = Class.forName("com.hu.www.reflection.TestReflection");
//方式三：通过类名获得
Class c3 = TestReflection.class;
//输出并对比它们的hashCode
System.out.println(c1.hashCode() +"\n"+ c2.hashCode() +"\n"+ c3.hashCode());
}
}
得到的3个hashCode都是相同的，说明一个类只有一个Class对象
2、获取运行时类的完整结构
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//获取类的信息
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class aClass = Class.forName("com.hu.www.reflection.User");
//1、获得类的名字
System.out.println(aClass.getName()); //获得包名 + 类名
System.out.println(aClass.getSimpleName()); //获得类名
Field[] declaredFields = aClass.getDeclaredFields(); //可以找到所有的属性，包括私有的
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//2、获得指定属性值
Field name = aClass.getDeclaredField("name"); //可以找到private修饰的属性
System.out.println(name);
//3、获得类的所有方法
methods = aClass.getDeclaredMethods(); //获得本类的所有方法，包括私有的
for (Method method : methods) {
System.out.println("getDeclaredMethods：\t" + method);
}
//4、获得指定方法
Method getName = aClass.getMethod("getName", null);
Method setName = aClass.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
//5、获得指定的构造器
Constructor[] constructors = aClass.getConstructors();
Constructor[] declaredConstructors = aClass.getDeclaredConstructors();
Constructor constructor = aClass.getConstructor(String.class, int.class, int.class);
System.out.println(constructor);
}
}
class User{
private String name;
private int id;
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3、创建运行时类的对象并调用方法和属性
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//通过反射动态地创建对象
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//获得Class对象
Class aClass = Class.forName("com.hu.www.reflection.User");
//1、通过Class对象调用newInstance方法创建对象
User user1 = (User)aClass.newInstance();
System.out.println(user1);
//2、通过Class对象获取构造器对象，构造器对象再调用newInstance方法创建对象
Constructor constructor = aClass.getConstructor(String.class, int.class, int.class);
User user2 = (User)constructor.newInstance("Hu", 001, 18);
System.out.println(user2);
//3、通过反射调用普通方法
User user3 = (User)aClass.newInstance();
//该类的Class对象通过反射获取方法
Method setName = aClass.getMethod("setName", String.class);
//获取到的方法对象调用invoke方法激活
setName.invoke(user3,"Hu");
System.out.println(user3.getName());
//4、通过反射调用属性
User user4 = (User)aClass.newInstance();
//该类的Class对象通过反射获取属性
Field name = aClass.getDeclaredField("name");
//关闭权限检测
name.setAccessible(true);
//获取到的属性对象调用set方法设置，不能直接操作私有属性，需要关闭程序的安全检测
name.set(user4,"hu");
System.out.println(user4.getName());
}
}
class User{
private String name;
private int id;
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
4、反射操作泛型
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
//通过反射获取泛型
public class TestReflection {
public void test01(Map<String,User> map,List<User> list){
System.out.println("test01");
}
public Map<String,User> test02(){
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
//1、获取参数的泛型信息
//通过反射获取方法
Method method = TestReflection.class.getMethod("test01", Map.class, List.class);
//方法对象调用getGenericParameterTypes方法获取泛型类型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
//循环输出所有泛型类型
System.out.println(genericParameterType);
//判断泛型的类型是否为ParameterizedType--参数化类型
if (genericParameterType instanceof ParameterizedType){
//泛型类型为参数化类型，强转为ParameterizedType--参数化类型；并使用getActualTypeArguments方法获取它的真实参数信息
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
//循环输出所有泛型的真实类型
System.out.println(actualTypeArgument);
}
}
}
System.out.println("-----------------------------------------------------");
//2、获取返回值的泛型信息
//通过反射获取方法
method = TestReflection.class.getMethod("test02",null);
//方法对象调用getGenericReturnType方法获取泛型类型
Type genericReturnType = method.getGenericReturnType();
//判断泛型的类型是否为ParameterizedType--参数化类型
if (genericReturnType instanceof ParameterizedType){
//泛型类型为参数化类型，强转为ParameterizedType--参数化类型；并使用getActualTypeArguments方法获取它的真实参数信息
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
//循环输出所有泛型的真实类型
System.out.println(actualTypeArgument);
}
}
}
}
5、反射操作注解
package com.hu.www.reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
//联系反射操作注解
public class TestReflection12 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
//创建Student2类的Class对象
Class aClass = Class.forName("com.hu.www.reflection.Student");
//通过反射获得注解
Annotation[] annotations = aClass.getAnnotations();
//获得Student2类的注解
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得Student2类的注解value的值
TableHu tableHu = (TableHu)aClass.getAnnotation(TableHu.class);
System.out.println(tableHu.value());
//获得类指定属性的注解
Field field = aClass.getDeclaredField("name");
FieldHu annotation = field.getAnnotation(FieldHu.class);
//获得Student2类的name属性的注解信息
System.out.println("列名：" + annotation.columnName());
System.out.println("类型：" + annotation.type());
System.out.println("长度：" + annotation.length());
}
}
@TableHu("db_student")
class Student{
@FieldHu(columnName = "db_id",type = "int",length = 10)
private int id;
@FieldHu(columnName = "db_age",type = "int",length = 10)
private int age;
@FieldHu(columnName = "db_name",type = "varchar",length = 3)
private String name;
public Student(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableHu{
String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldHu{
String columnName();
String type();
int length();
}
|