Java - 反射

来源：互联网发布：软件开发工作汇报 ppt 编辑：程序博客网时间：2024/05/22 05:29

基本概念

[plain] view plain copy
 
利用Java语言反射机制,可以在运行时对程序进行动态控制,通过反射也可以打破类的包装机制    
在Java程序运行过程中,每个类被加载后都在内存中产生一个对应的Class对象,  
    主要包括构造器,方法,成员变量等  
    Java中无论一个类生成多少个对象,这些对象都会对应内存中同一个class对象  
在JDK中,主要由以下类来实现Java反射机制  
    Java.lang.Class类  
        对应类本身    
    Java.lang.reflect.Field类  
        对应类中定义的成员变量    
    Java.lang.reflect.Method类  
        对应类中定义的方法    
    Java.lang.reflect.Constructor类  
        对应类中定义构造方法    
    Java.lang.reflect.Array类  
        对应如何创建数组,为数组变量赋值,取数组值  

获取Class对象的三种方法

[java] view plain copy
 
方法一:Class的静态方法传入类的全称    
    Class<?> classType = Class.forName("com.itlwc.MyReflection");    
方法二:Java内置语法    
    Class<?> classType = MyReflection.class;    
方法三:使用对象的getClass()  
    Class<?> classType = new String("abc").getClass();  

Class常用方法

[java] view plain copy
 
package com.itlwc;  
  
import java.lang.reflect.Constructor;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
  
public class Test {  
    public static void main(String[] args) throws Exception {  
        // 返回指定类对应的Class对象,如果找不到指定类抛出ClassNotFoundException  
        Class<?> c = Class.forName("com.itlwc.Test");  
  
        // 返回Class对象自己定义所有构造器  
        Constructor<?> c1 = c.getDeclaredConstructor();  
        // 返回Class对象自己定义所有构造器  
        Constructor<?>[] c2 = c.getDeclaredConstructors();  
        // 返回Class对象自己定义public构造器  
        Constructor<?> c3 = c.getConstructor();  
        // 返回Class对象自己定义public构造器  
        Constructor<?>[] c4 = c.getConstructors();  
  
        // 返回Class对象自己定义所有成员变量,不包括父类继承来的成员变量  
        Field f1 = c.getDeclaredField("name");  
        // 返回Class对象自己定义成员变量数组,不包括父类继承来的成员变量  
        Field[] f2 = c.getDeclaredFields();  
        // 返回Class对象自己定义public成员变量,包括父类有访问权限的成员变量  
        Field f3 = c.getField("age");  
        // 返回Class对象自己定义public成员变量数组,包括父类有访问权限的成员变量  
        Field[] f4 = c.getFields();  
  
        // 返回Class对象自己定义所有成员方法,不包括父类继承来的成员方法  
        Method m1 = c.getDeclaredMethod("getName");  
        // 返回Class对象自己定义成员方法数组,不包括父类继承来的成员方法  
        Method[] m2 = c.getDeclaredMethods();  
        // 返回Class对象自己定义public成员方法,包括父类有访问权限的成员方法  
        Method m3 = c.getMethod("getName");  
        // 返回Class对象自己定义public成员方法数组,包括父类有访问权限的成员方法  
        Method[] m4 = c.getMethods();  
  
        // Class对象所对应类的名称  
        String str1 = c.getName();  
        // Class对象所对应类所在的包  
        Package p = c.getPackage();  
        // 返回源代码中给出的基础类的简称  
        String str2 = c.getSimpleName();  
        // 返回Class对象表示的实体的超类的Class  
        Class<?> cc = c.getSuperclass();  
        // Class对象是否为注解类型  
        boolean b1 = c.isAnnotation();  
        // Class对象是否为匿名内部类  
        boolean b2 = c.isAnonymousClass();  
        // Class对象是否为数组类型  
        boolean b3 = c.isArray();  
        // Class对象是否为枚举类型  
        boolean b4 = c.isEnum();  
        // Class对象是否为接口类型  
        boolean b5 = c.isInterface();  
        // Class对象是否为成员内部类  
        boolean b6 = c.isMemberClass();  
        // 创建加载类的对象  
        Test t = (Test) c.newInstance();  
        t.getName();  
        // Class对象转换为字符串  
        String str3 = c.toString();  
  
    }  
  
    private String name;  
    public String age;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public Test() {  
    }  
  
    public Test(String name) {  
        this.name = name;  
    }  
  
    private Test(String name, String age) {  
        this.name = name;  
        this.age = age;  
    }  
}  

Field常用方法

[java] view plain copy
 
package com.itlwc;  
  
import java.lang.reflect.Field;  
  
class PrivateClass {  
    public String name;  
    public String age;  
    private String password;  
}  
  
public class T {  
    public static void main(String[] args) throws Exception {  
        // 获取Class对象  
        Class<?> clazz = PrivateClass.class;  
        Object obj = clazz.newInstance();  
        // 返回Class对象自己定义public成员变量数组,包括父类有访问权限的成员变量  
        Field[] field = clazz.getFields();  
        for (Field f : field) {  
            // 成员变量名称  
            System.out.println(f.getName());  
            // 成员变量类型  
            System.out.println(f.getType());  
            // 成员变量值  
            System.out.println(f.get(obj));  
        }  
        // 返回Class对象自己定义的私有不带参数方法,名称为method1  
        Field f = clazz.getDeclaredField("password");  
        f.setAccessible(true);  
        System.out.println("成员变量名称: " + f.getName() + " 成员变量类型: " + f.getType()  
                + " 成员变量值: " + f.get(obj));  
    }  
}  

Method常用方法

[java] view plain copy
 
package com.itlwc;    
    
import java.lang.reflect.Method;    
    
class PrivateClass {    
    private void method1() {    
        System.out.println("调用了无参私有方法");    
    }    
    
    private String method2(String str, int a) {    
        return "调用了有参私有方法: " + str + "今年" + a + "岁";    
    }    
}    
    
public class T {    
    public static void main(String[] args) {    
        // 获取Class对象    
        Class<?> clazz = PrivateClass.class;  
        try {    
            //生成PrivateClass类的一个实例  
            Object obj= clazz.newInstance();  
            // 返回Class对象自己定义成员方法数组,不包括父类继承来的成员方法    
            Method method[] = clazz.getDeclaredMethods();    
            for (Method m : method) {    
                // 方法名称    
                m.getName();    
                // 方法返回值    
                m.getReturnType();    
                // 方法参数序列    
                Class<?>[] c = m.getParameterTypes();    
                for (Class<?> cc : c) {    
                    System.out.println(cc);    
                }    
            }    
            // 返回Class对象自己定义的私有不带参数方法,名称为method1    
            Method m = clazz.getDeclaredMethod("method1", new Class[] {});    
            m.setAccessible(true);    
            Object object = m.invoke(obj, null);    
            System.out.println(object);    
    
            // 返回Class对象自己定义的私有带参数方法,名称为method2    
            m = clazz.getDeclaredMethod("method2", new Class[] { String.class,    
                    Integer.TYPE });    
            m.setAccessible(true);    
            object = m.invoke(obj, new Object[] { "lwc", 18 });    
            System.out.println(object);    
        } catch (Exception e) {    
            e.printStackTrace();    
        }    
    }    
}  

Constructor常用方法

[java] view plain copy
 
package com.itlwc;  
  
import java.lang.reflect.Constructor;  
  
class PrivateClass {  
    public PrivateClass() {  
    }  
  
    private PrivateClass(String str) {  
        System.out.println("私有构造器");  
    }  
}  
  
public class T {  
    public static void main(String[] args) throws Exception {  
        PrivateClass pc = new PrivateClass();  
        // 获取Class对象  
        Class<?> clazz = pc.getClass();  
        // 返回Class对象自己定义所有构造器  
        Constructor<?>[] constructor = clazz.getDeclaredConstructors();  
        for (Constructor<?> cc : constructor) {  
            // 构造器名称  
            System.out.println(cc.getName());  
            // 构造器参数序列    
            Class<?>[] c = cc.getParameterTypes();    
            for (Class<?> ccc : c) {    
                System.out.print(ccc);    
            }  
        }  
    }  
}  

利用反射动态创建数组

[java] view plain copy
 
package com.itlwc;  
  
import java.lang.reflect.Array;  
  
public class Test {  
    public static void main(String[] args) throws Exception {  
        // 使用反射动态创建长度为5的一维int型数组  
        int[] intArray = (int[]) Array.newInstance(Integer.TYPE, 5);  
        // 使用反射动态创建二维String型数组,一维长度为5,二维长度为4  
        String[][] stringArray = (String[][]) Array.newInstance(String.class,  
                new int[] { 5, 4 });  
    }  
}  

0 0