反射
1. 反射
定义：程序在运行状态中，对于任意一个类，都可以知道这个类的所有属性和方法；对于任意一个对象，都能够调用他的任意方法和属性
加载流程：假设我们写了一个User类，这个User类加载进内存前jvm会为这种类创建唯一的对应的Class类实例，注意这里的Class是一个类型，所有User类都共享同一个对应的Class类，这个Class类包含包名，类名，属性，方法等种种信息
2.Class类
获取Class有三种方法
Class cls = User.class; //通过类名.class
Class cls = user.getClass(); //通过实例.getClass()
Class cls = Class.forName("User"); //通过Class.forName("全限定类名")- Class实例是唯一的存在，所以上面获取的Class都是同一个。但这注意 instance of 匹配的是本类及其子类，而Class只匹配本类，不包括子类
Class常用方法
方法 | 解释 |
|---|---|
newInstance() | 创建由此类对象表示的类的新实例 |
forName(String className) | 返回与给定字符串名称的类或接口相关联的类对象 |
getClassLoader() | 返回类的类加载器 |
getPackage() | 获取此类的包 |
getResourceAsStream(String name) | 查找具有给定名称的资源（返回类型为InputStream） |
getDeclaredField(Srting name) | 反映此表示的类或接口的指定已声明字段类对象 |
getDeclaredMethod(String name, Class<?>... p) | 返回一个 方法对象，它反映此表示的类或接口的指定声明的方法 类对象 |
getDeclaredConstructor(Class<?>... p) | 返回Constructor对象 |
- Class.newInstance()只能调用public的无参数构造方法
3. Field类
获取字段的方法
方法名 | 解释 |
|---|---|
getField(String name) | 根据字段名获取某个public的field（包括父类） |
getDeclaredField(String name) | 根据字段名获取当前类的某个field（不包括父类） |
getFields() | 获取所有public的field，返回数组（包括父类） |
getDeclaredFields() | 获取当前类的所有field，返回数组（不包括父类） |
- 其中，没有Declared的能获取父类，本类public的field，而有Declared的只能访问本类的所有field
字段常用方法
方法 | 解释 |
|---|---|
get(Object obj) | 返回该所表示的字段的值Field ，指定的对象上 |
set(Object obj, Object value) | 将指定对象参数上的此 Field对象表示的字段设置为指定的新值 |
getName() | 返回由此Field对象表示的字段的名称 |
getType() | 返回一个 类对象标识了此表示的字段的声明类型 Field对象 |
getModifiers() | 返回由该 Field对象表示的字段的Java语言修饰符，作为整数 |
操作（这里准备了UserExtends类）
public class UserExtends {
private int id = 1;
public String email;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}具体操作
public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
Class cls = UserExtends.class;
//可以获取字段
System.out.println(cls.getDeclaredField("id"));
System.out.println("----------------------------------");
//可以获取字段的名字，类型，修饰符
Field f = cls.getDeclaredField("id");
System.out.println(f.getName());
System.out.println(f.getType());
int m = f.getModifiers();
System.out.println(Modifier.isPrivate(m)); //Modifiers是一个类，不同数值代表不同修饰符
System.out.println("-------------------------------------");
//获取私有字段的值，需要改变一些方法 1. 字段改为public 2.用f.setAccessible(true);
//SecurityManager,可以防止private属性访问，所以不用说设置private包装那有什么用了
f.setAccessible(true);
UserExtends ue = new UserExtends();
ue.setId(2);
//获取参数对象的字段值
Object value = f.get(ue);
System.out.println(value);
//修改参数对象的字段值
f.set(ue, 3);
System.out.println(ue.getId());
}输出
private int reflectionfield.UserExtends.id
----------------------------------
id
int
true
-------------------------------------
2
34. Method
获取方法的方法
方法 | 解释 |
|---|---|
getMethod(name, Class...) | 获取某个public的Method（包括父类） |
getDeclaredMethod(name, Class...) | 获取当前类的某个Method（不包括父类） |
getMethods() | 获取所有public的Method（包括父类） |
getDeclaredMethods() | 获取当前类的所有Method（不包括父类） |
常用方法
方法 | 解释 |
|---|---|
getName() | 返回方法名称 |
getReturnType() | 返回方法返回值类型 |
getParameterTypes() | 返回方法的参数类型 |
getModifiers() | 返回方法的修饰符，返回一个整形 |
invoke(Object obj, Object... args) | 在具有指定参数的 方法对象上调用此 方法对象表示的底层方法 |
操作（准备了PersonExtends类，里面有两个方法）
public class PersonExtends extends Person{
public int getScore(String type) {
return 99;
}
private int getGrade(int year) {
return 1;
}
}public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//获取类类型
Class cls = PersonExtends.class;
//获取方法,第一个参数为方法名，第二个为参数类型的类类型
System.out.println(cls.getDeclaredMethod("getGrade", int.class));
//方法的基本信息
Method md = cls.getDeclaredMethod("getGrade", int.class);
md.getName();
md.getReturnType();
md.getParameters(); //返回的是Class数组
md.getModifiers();
//invoke第一个参数是实例对象，对二个填写参数，就是正常调用时方法的参数
PersonExtends ps = new PersonExtends();
System.out.println( md.invoke(ps,123) );
// 静态方法，第一个参数对象就写null
Method med = Integer.class.getMethod("parseInt", String.class);
System.out.println( med.invoke(null, "123"));
//本类的私有方法
//m.setAccessible(true);
//任然遵循多态，反射父类方法，方法传入子类对象，调用的是子类方法
}private int reflectionmethod.PersonExtends.getGrade(int)
1
123- 方法支持多态，反射父类方法，方法传入子类对象，调用的是子类方法
5. Constructor
获取构造方法也是那四种，就不写了
操作（准备了User类，里面含有无参及有参构造函数）
public class User {
public int id = 1;
public String name = "Howl";
public User(){
}
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
//Class的newInstance只支持public的无参构造函数
User user = User.class.newInstance();
System.out.println(user.getId());
System.out.println(user.getName());
//与Method不同，这里的Constructor直接返回一个实例对象
//参数直接填写参数的类类型，实现重载
Constructor cst = User.class.getConstructor(int.class,String.class);
User user1 = (User) cst.newInstance(2,"Howlet");
System.out.println(user1.getId());
System.out.println(user1.getName());
}1
Howl
2
Howlet- 构造函数不支持多态，只能调用本类的构造函数
6. 反射实现动态代理
在编译时期不写接口的实现类，反而在运行时期创建接口的实例，这就叫做动态代理
interface类型的变量总是通过向上转型并指向某个实例，在反射中有体现，比如有个接口叫User，某个实现了接口的类叫做UserImp，那么他们转型可以这样写
User user = new UserImp();具体还可以了解代理模式，请戳这里 代理模式
腾讯云开发者
