java反射机制详解

来源：互联网发布：linux 命令别名编辑：程序博客网时间：2024/05/21 10:17

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

在运行时判断任意一个对象所属的类。

在运行时构造任意一个类的对象。

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法。

在JDK中，主要由以下类来实现java反射机制，这些类位于java.lang.reflect包中

——Class类：代表一个类。

——Field类：代表类的成员变量（也称为类的属性）

——Method类：代表类的方法。

——Constructor类：代表类的构造方法。

——Array类：提供了动态创建数组，以及访问数组的元素的静态方法。

要想使用反射，首先需要获得待处理类或对象所对应的Class对象。

获取某个类或对象所对应的Class对象的常用的3种方式：

1）使用Class类的静态方法forName：Class.forName("java.lang.String");

2）使用类的.class语法：String.Class;

3）使用对象的getClass()方法:String s="aa"; Class<?> clazz = s.getClass();

要想通过类的不带参数的构造方法来生成对象，有以下两种方法：

1）先获得Class对象，然后通过Class对象的newInstance()方法直接生成即可：

      Class<?> classType = String.class;      Object obj = classType.newInstance();

2）先获得Class对象，然后通过该对象获得对应得Constructor对象，再通过该Constructor对象的newInstance()方法生成：

      Class<?> classType = Customer.class;       Constructor cons = classType.getConstructor(new Class[]{});       Object obj = cons.newInstance(new Object[]{});

而要想通过类的带参数的构造方法来生成对象,只能使用下面一种方法

      Class<?> classType = Customer.class;       Constructor cons = classType.getConstructor(new Class[]{String.class,int.class});       Object obj = cons.newInstance(new Object[]{"hello:,3});

通过一个实例来理解反射。

问题描述：ReflectTester类有一个copy(Object object)方法，这个方法能够创建一个和参数object同样类型的对象，然后把
object对象中的所有属性拷贝到新建的对象中，并将它返回。

首先创建一个ReflectTester.java文件，在ReflTester.java文件中创建一个Customer类

class Customer{    private Long id;    private String name;    private int age;   public Customer() {    }   public Customer(String name, int age) {        this.name = name;        this.age = age;    }    public Long getId() {        return id;    }    public void setId(Long id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

在ReflectTester类中写两个方法，一个是主函数，一个是copy函数。

public class ReflectTester {     public Object copy(Object object) throws Exception {         Class<?> classType = object.getClass();         Constructor cons = classType.getConstructor(new Class[]{});         Object objectCopy = cons.newInstance(new Object[]{});         //获得对象的所有成员变量         Field[] fields = classType.getDeclaredFields();         for(Field field:fields){             String name = field.getName();             String firstLetter = name.substring(0,1).toUpperCase();             String getMethodName = "get" + firstLetter + name.substring(1);             String setMethodName = "set" + firstLetter + name.substring(1);             Method getMethod = classType.getMethod(getMethodName,new Class[]{});             Method setMethod = classType.getMethod(setMethodName,new Class[]{field.getType()});             Object value = getMethod.invoke(object,new Object[]{});  //从目标对像中把属性值取出来    然后在set注入到返回对象中             setMethod.invoke(objectCopy,new Object[]{value});         }         return objectCopy;     }    public static void main(String[] args) throws Exception {        Customer customer = new Customer("Tom",20);        customer.setId(1L);        //利用反射拷贝一个Class对象        ReflectTester tester = new ReflectTester();        Customer customer1 = (Customer) tester.copy(customer);        System.out.println(customer1.getId() + "," + customer1.getName() + "," + customer1.getAge());    }}

运行结果为：

1,Tom,20

利用反射技术来访问某一个类的私有成员函数。

首先写一个PrivateTest类

public class PrivateTest {    private String sayHello(String name){        return "hello: " + name;    }}

再建一个TestPrivate类

public class TestPrivate {    public static void main(String[] args) throws Exception {        PrivateTest p = new PrivateTest();        Class<?> classType = p.getClass();        Method  method = classType.getDeclaredMethod("sayHello",new Class[]{String.class});        method.setAccessible(true);      //一定要设置这一项   值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。可以访问私有域        //值为 false 则指示反射的对象应该实施 Java 语言访问检查。 即不能访问私有域        String str = (String) method.invoke(p, new Object[]{"zhangsan"});        System.out.println(str);    }}

运行结果

hello: zhangsan

0 0