Java反射机制

Java反射机制——获取成员变量&构造函数
一、成员变量是java.lang.reflect.Field的对象
1、Field类封装了关于成员变量的操作
2、Field[] fs = c.getFields()方法获取所有public的成员变量Field[]信息
3、c.getDeclaredFields获取的是该类自己声明的成员变量信息
4、field.getType()获得成员类型的类类型
5、field.getName()获得成员的名称
二、构造函数是java.lang.Constructor类的对象
1、通过Class.getConstructor()获得Constructor[]所有公有构造方法信息
2、建议getDeclaredConstructors()获取自己声明的构造方法
3、Constructor.getName():String
4、Constructor.getParameterTypes():Class[]
成员变量也是对象，是java.lang.reflect.Field的对象

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassUtil {
    public static void printMethedsMessage(Object obj){
        Class cs=obj.getClass();
        Method []method =cs.getMethods();
        for(Method meth:method){
            System.out.print(meth.getName()+"(");
            Class ptype[] = meth.getParameterTypes();
            for(Class type:ptype){
                System.out.print(type.getName()+",");
            }
            System.out.println(")");
        }
    }
    public static void printConMessage(Object obj) {
        Class c=obj.getClass();
        Constructor[] con= c.getDeclaredConstructors();
        for(Constructor constructor:con){
            System.out.print(constructor+"(");
            Class[]field =constructor.getParameterTypes();
            for(Class ff:field){
                System.out.print(ff+",");
            }
            System.out.println(")");
        }
        
    }
}

通过反射机制调用方法

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ClassMethod {
    public static void main(String arg[]){
        A a1= new A();
        Class cs=a1.getClass();//都要首先获取类类型
        try {
            Method m = cs.getMethod("print",new Class[]{});
            try {
                /*
                 * 对应的参数列表
                 */
                m.invoke(new A());//利用反射机制反向调用方法
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}
class A{
    public void print(){
        System.out.println("helloWorld");
    }
}

通过反射了解泛型的本质

import java.lang.reflect.Method;
import java.util.ArrayList;

public class fanxing {

    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<String>();
        ArrayList list = new ArrayList();
        list1.add("HelloWorld");
        /*
         * list1.add(20);//工具提示错误，说明eclipse是自动编译的
         */
        Class cs = list1.getClass();
        Class no = list.getClass();
        if(cs == no)
            System.out.println(true);
        /*
         * 答案是true  说明编译之后的集合是去泛型化的
         * Java集合的泛型，是防止输入错误的，只在编译时有效，绕过编译就无效了
         * 我们可以用方法的反射来操作，绕过编译
         */
        try {
            @SuppressWarnings("unchecked")
            Method m = cs.getMethod("add",Object.class);
            m.invoke(list1, 20);//绕过编译就绕过了泛型
            System.out.println(list1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

}

 

import java.lang.reflect.Method;import java.util.ArrayList;
public class fanxing {
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<String>();ArrayList list = new ArrayList();list1.add("HelloWorld");/* * list1.add(20);//工具提示错误，说明eclipse是自动编译的 */Class cs = list1.getClass();Class no = list.getClass();if(cs == no)System.out.println(true);/* * 答案是true  说明编译之后的集合是去泛型化的 * Java集合的泛型，是防止输入错误的，只在编译时有效，绕过编译就无效了 * 我们可以用方法的反射来操作，绕过编译 */try {@SuppressWarnings("unchecked")Method m = cs.getMethod("add",Object.class);m.invoke(list1, 20);//绕过编译就绕过了泛型System.out.println(list1);} catch (Exception e) {e.printStackTrace();}}
}