反射的简单理解

反射机制的相关类

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);