Java的反射机制

反射机制主要提供以下功能： 

①在运行时判断任意一个对象所属的类；
②在运行时构造任意一个类的对象；
③在运行时获取任意一个类所具有的成员变量和方法；
④在运行时调用任意一个对象的方法；
⑤生成动态代理。（有待扩充）

 

 

新建一个Test类，继承FTest类：　

public class Test extends FTest{
    public int number;
    public String name;
    
    public Test() {
    }
    
    public Test(String name, int number) {
        this.number = number;
        this.name = name;
    }
    
    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void reflection1() {
        System.out.println("函数reflection");
    }
    
    public void reflection2(String num) {
        System.out.println("reflection" + num);
    }
}

实例化Class类对象

//实例化Class类对象
 Class<?> class1 = null;
 Class<?> class2 = null;
 Class<?> class3 = null;
 try {
    //一般有三种方法 一般使用第一种方法
    class1 = Class.forName("net.cnblog.muziqiuqiu.Test");
    class2 = new Test().getClass();
    class3 = Test.class;
    } catch (Exception e) {
       System.out.println(e);
  }

通过反射机制获取对象的类名、包名、父类、接口

Test test = new Test();
//获取对象的类名和包名
System.out.println(test.getClass().getName());
System.out.println(class1.getName());
//获取对象的父类
System.out.println(test.getClass().getSuperclass());
System.out.println(class1.getSuperclass());
//获取实现的接口(接口可能会有几个)
System.out.println(test.getClass().getInterfaces());
System.out.println(class1.getInterfaces());

通过反射机制实例化类的对象

//通过反射机制实例化一个类的对象
//第一种方法-通过默认的构造方法实例化一个类的对象
try {
    Test test2 = (Test)class1.newInstance();
    test2.setName("haha");
    System.out.println(test2.getName());
} catch (Exception e) {
    System.out.println(e);
}
//第二种方法-通过获取全部的构造函数实例化对象        
Constructor<?> cons[] = class1.getConstructors();
for(int i = 0; i < cons.length; i++) {
    Class<?> clazzs[] = cons[i].getParameterTypes();        
}try {
    Test test3 = (Test)cons[1].newInstance("haha",1); 
　　//System.out.println(test3.getName()+test3.getNumber());
} catch (Exception e) {
    System.out.println(e);
}

获取某个类的全部属性

//获取某个类的全部属性
Field[] field = class1.getDeclaredFields();    //获取当前对象所有成员变量
Field[] field1 = class1.getFields();        //获取所有为public的成员变量（包括父类和子类）
for(int i = 0; i < field.length; i++) {
    //获取变量权限
    int grade = field[i].getModifiers();        //为private时结果wei2
    String priv = Modifier.toString(grade);    
    //获取变量属性
    Class<?> type = field[i].getType();        //type.getName()结果为变量类型
}

获取某个类的全部方法

//获取某个类的全部方法
Method method[] = class1.getDeclaredMethods();    //获取当前类中所有的方法
Method method1[] = class1.getMethods();        //获取所有类型为public的方法（包括父类和子类）
for(int i = 0; i<method.length; i++) {
    Class<?> returnType = method[i].getReturnType();
    Class<?> para[] = method[i].getParameterTypes();    //方法的参数
    Class<?> exce[] = method[i].getExceptionTypes();    //所有抛出的异常
    int grade = method[i].getModifiers();
    String priv = Modifier.toString(grade);
}

通过反射机制调用某个类的方法

//通过反射机制调用某个类的方法
try {
    //使用反射机制调用无参方法
    Method method2 = class1.getMethod("reflection1");    
    method2.invoke(class1.newInstance());
    //使用反射机制调用有参方法
    Method method3 = class1.getMethod("reflection2", String.class);    
    method3.invoke(class1.newInstance(), "20");
} catch (Exception e) {
    System.out.println(e);
}

通过反射机制获取某个类属性的值

//通过反射机制调用某个类的属性
try {
    Test test2 = new Test();
    Field field2 = class1.getDeclaredField("name");    
    field2.setAccessible(true);            //只能用最近的一次
    field2.set(test2, "i an test2");
    System.out.println(field2.get(test2).toString());
} catch (Exception e) {
    System.out.println(e);
}