反射机制的相关类
java.lang.Class
获取Class对象,可以使用Class.forName(……)或者对象的getClass()方法
Class.forName(……)会导致类加载,类加载那么类当中的静态代码块必然执行
//Class.forName()是一个静态方法,参数是一个完整类名的字符串,完整类名必须带包名
Class c1=Class.forName("java.lang.String");
//c1代表String.class字节码文件,代表String类型
String s="abc";
Class x=s.getClass();
System.out.println(x==c1);
System.out.println(int.class!=Integer.class);//true
常用方法:
- getName():获取带包名的完整类名
c1.getName();//java.lang.String
- getSimpleName():获取不带包名的完整类名
c1.getSimpleName();//String
- getSuperclass():获取父类
c1.getSuperclass();//java.lang.Object
- getInterfaces():获取实现类接口
Class[] interfaces = c1.getInterfaces();
for(Class i:interfaces){
System.out.println(i.getName());
}
/*
java.io.Serializable
java.lang.Comparable
java.lang.CharSequence
java.lang.constant.Constable
java.lang.constant.ConstantDesc
*/
java.lang.reflect.Method
定义一个UserService类,用反射机制获取方法
public class UserService{
public boolean login(String name,String password){
if("admin".equals(name) && "123".equals(password)) {
return true;
}
return false;
}
private void logout(int i){
System.out.println("logout");
}
}
反射方法:
Class u=Class.forName("UserService");
Method[] declaredMethods = u.getDeclaredMethods();
for(Method method:declaredMethods){
//修饰符
int modifiers = method.getModifiers();
String s = Modifier.toString(modifiers);
//返回类型
Class<?> returnType = method.getReturnType();
String simpleName = returnType.getSimpleName();
//方法名
String name = method.getName();
//参数
Class<?>[] parameterTypes = method.getParameterTypes();
String[] ps=new String[parameterTypes.length];
int i=0;
for(Class ParameterType:parameterTypes){
ps[i++]=ParameterType.getSimpleName();
}
Parameter[] parameters = method.getParameters();
System.out.println(s+" "+simpleName+" "+ name+"("+ps[0]+" "+
parameters[0].getName()+")");
}
用反射机制调用方法:
//用反射机制调用方法
Class u=Class.forName("UserService");
//Object obj=u.newInstance();
Object obj=u.getDeclaredConstructor().newInstance();
Method login = u.getDeclaredMethod("login", String.class, String.class);
Object admin = login.invoke(obj, "admin", "123");
System.out.println(admin);
java.lang.reflect.Constructor
java.lang.reflect.Field
定义一个User类,用反射机制获取属性
pulic class User{
public int no;//一个完整的field对象
private String name;
protected int age;
boolean sex;
public User() {
System.out.println("无参构造");
}
}
反射属性:
public class ReflectTest01 {
public static void main(String[] args) {
Class<User> c= (Class<User>) Class.forName("User");
//调用无参构造,反射来创建新对象,newinstance在JDK9以后已过时
User u=c.getDeclaredConstructor().newInstance();
//获取所有public属性,其他private\protected不包括在内,返回一个Field[]
Field[] fields = c.getFields();
System.out.println(fields.length);
//获取属性名
System.out.println(fields[0].getName());
//获取所有的Field
Field[] declaredFields = c.getDeclaredFields();
System.out.println(declaredFields.length);
for(Field field:declaredFields){
//获取属性修饰符,返回的是修饰符的代号
int modifiers = field.getModifiers();
//获取属性类型
Class<?> type = field.getType();
String fname=type.getSimpleName();
//获取属性名字
String name = field.getName();
System.out.println(Modifier.toString(modifiers) +" "+fname+" "+name);
}
}
}
用反射机制区访问和设置对象属性:
Class u=Class.forName("User");
//用反射机制去访问对象的属性
Object obj=u.getDeclaredConstructor().newInstance();
Field no = u.getDeclaredField("no");
no.set(obj,222);
System.out.println(no.get(obj));
//访问私有对象
Field name = u.getDeclaredField("name");
//打破封装就可以访问私有变量
name.setAccessible(true);
name.set(obj,"jack");
System.out.println(name.get(obj));
System.out.println(((User) obj).no);