java中的反射机制详解

一、什么是Java反射机制
Java反射机制是指在运行状态中,对于任意一个类,都能够通过这个类本身获取这个类的所有属性和方法信息;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。也就是说java反射可以实现在运行时可以知道任意一个类的属性和方法。
那么我们为什么要用反射机制?直接通过new关键字创建对象不就可以了吗?这就涉及到了动态与静态的概念。
静态编译:在编译时确定类型,绑定了具体对象。
动态编译:运行时确定类型,绑定对象。动态编译最大限度发挥了java的灵活性,体现了多态的应用,有以降低类之间的藕合性。
java反射机制的优点:
通过java反射机制可以实现动态创建对象和编译,体现出很大的灵活性,特别是在J2EE的开发中它的灵活性就表现的十分明显。例如spring 的 IOC/DI、javaBean和jsp之间调用、struts的 FormBean 和页面之间的调用、JDBC 的 classForName()的使用、hibernate的 find(Class clazz)的使用等。 
java反射机制的缺点:
大量使用反射会使系统性能大打折扣。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这种操作总是慢于只直接执行相同的操作。
Java反射机制的主要功能:
1、确定一个对象的类。
2、取出类的数据成员,方法,构造器,和超类等相关信息。
3、找出某个接口里定义的常量和方法说明。
4、创建一个类实例,这个实例在运行时刻才有名字(运行时间才生成的对象)。
5、在运行时刻调用动态对象的方法.
6、创建数组,数组大小和类型在运行时刻才确定,也能更改数组成员的值.


二、Class类
Class类是Java反射的基础,Class类表示正在运行的java应用程序中的类和接口。Class只有私有的构造函数。Class类在加载类时由Java虚拟机以及调用类加载器中的 defineClass方法自动创建的。只在内存中存在一份加载类的Class类。 所有的类都是java.lang.Class类的实例对象。
1、如何获取一个Class类的实例
对于普通的对象,我们一般都会这样创建和表示:
MyClass myClass = new MyClass();
上面说了,所有类都是Class的对象,那么如何获取一个Class的对象呢?可不可以通过如下方式呢:
Class c = new Class();
查看Class的源码:
private  Class(ClassLoader loader) { 
    classLoader = loader; 
}
可以看到Class的构造器是私有的,只有JVM可以创建Class的对象,因此不可以像普通类一样new一个Class对象,虽然我们不能new一个Class对象,但是却可以通过已有的类得到一个Class对象,共有三种方式,如下:
(1)Class c1 = MyClass.class;
这说明任何一个类都有一个隐含的静态成员变量class,这种方式是通过获取类的静态成员变量class得到的。
(2)Class c2 = myClass.getClass();
myClass是MyClass的一个对象,这种方式是通过一个类的对象的getClass()方法获得的。
Class c3 = Class.forName("com.kang.test.MyClass");
这种方法是Class类调用forName方法,通过一个类的全类名(com.kang.test.MyClass是类MyClass的全类名)获得。
这里的c1、c2、c3都是Class的对象,他们是完全一样的,而且有个学名,叫做MyClass的类类型(class type)。顾名思义,类类型就是类的类型,也就是描述一个类是什么,都有哪些东西,所以我们可以通过类类型知道一个类的属性和方法,并且可以调用一个类的属性和方法,这就是反射的基础。
这里用String类来做个测试:
  String s = "myTest";  
  Class cls1 = s.getClass();  
  Class cls2 = String.class;  
  Class cls3 = Class.forName("java.lang.String");  
  if (cls1 == cls2) {  
   System.out.println("cls1 == cls2");  
  }  
  if (cls2 == cls3) {  
   System.out.println("cls2 == cls3");  
  }   
上述代码输出是两个true。因为他们描述的都是同一个类java.lang.String类。

2、Java反射相关操作
通过java的反射获取到Class的对象后,可以进行相关操作:
(1)获取成员方法信息
单独获取某一个方法是通过Class类的以下方法获得的:
public Method getDeclaredMethod(String name, Class<?>... parameterTypes) // 得到该类所有的方法,不包括父类的
public Method getMethod(String name, Class<?>... parameterTypes) // 得到该类所有的public方法,包括父类的
两个参数分别是方法名name和方法参数类的类类型列表parameterTypes。
示例:
public class Person {
    private String name;
    private int age;
    private String msg="hello wrold";
 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;
  }


    public Person() {
    }


    private Person(String name) {
        this.name = name;
        System.out.println(name);
  }


    public void fun() {
        System.out.println("fun");
  }


    public void fun(String name,int age) {
        System.out.println("我叫"+name+",今年"+age+"岁");
  }
}


public class MyTestDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.kang.test.Person");
            Object o = c.newInstance();
            Method method = c.getMethod("fun", String.class, int.class);
            method.invoke(o, "kang", 24);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果:
我叫kang,今年24岁
可以看到我们没有通过new关键字创建对象,但是我们仍然执行了类中的方法。

我们还可以一次性获取类中的所有自定义方法。
public class GetMethodAllDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.kang.test.Person");
            Method[] methods = c.getDeclaredMethods();
            for(Method m:methods){
                String  methodName= m.getName();
                System.out.println(methodName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果:
getName
setName
getAge
setAge
fun
fun

这里如果把c.getDeclaredMethods();改成c.getMethods();执行结果如下,多了很多方法,把Object里面的方法也打印出来了,因为Object是所有类的父类:
getName
setName
getAge
setAge
fun
fun
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll

(2)获取成员变量信息
成员变量的信息包括成员变量类型和成员变量名两部分。
类的成员变量也是一个对象,具体来说它是java.lang.reflect.Field的一个对象,所以我们通过java.lang.reflect.Field里面封装的方法来获取这些信息。
如果要单独获取某个成员变量,通过Class类的以下方法实现:
public Field getDeclaredField(String name) // 获得该类自身声明的所有变量,不包括其父类的变量
public Field getField(String name) // 获得该类自所有的public成员变量,包括其父类变量
上述两个方法中的输入参数name是对应的成员变量的名字。
示例:
public class TestGetParamDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.kang.test.Person");
            //获取成员变量
            Field field = c.getDeclaredField("msg"); //因为msg变量是private的,所以不能用getField方法
            Object o = c.newInstance();
            field.setAccessible(true);//设置是否允许访问,因为该变量是private的,所以要手动设置允许访问,如果msg是public的就不需要这行了。
            Object msg = field.get(o);
            System.out.println(msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
执行结果:
hello wrold

获取所有成员变量信息:
public class TestGetParamAllDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.kang.test.Person");
            Field[] fields = c.getDeclaredFields();
            for(Field field :fields){
                System.out.println(field.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果:
name
age
msg

(3)获取构造函数Constructor
事实上类的构造函数也是一个对象,它是java.lang.reflect.Constructor的一个对象,所以我们通过java.lang.reflect.Constructor里面封装的方法来获取关于构造函数的信息。
单独获取某个构造函数,通过Class类的以下方法实现:
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) //  获得该类所有的构造器,不包括其父类的构造器
public Constructor<T> getConstructor(Class<?>... parameterTypes) // 获得该类所以public构造器,包括父类
上述两个方法的输入参数为构造函数参数类的类类型列表。
若A类中有如下构造函数
public A(String a, int b) {
    // code body
}
那么就可以通过:
Constructor constructor = a.getDeclaredConstructor(String.class, int.class);
来获取这个构造函数。

示例:
public class TestGetCstorDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.kang.test.Person");
            //获取构造函数
            Constructor constructor = c.getDeclaredConstructor(String.class);
            constructor.setAccessible(true);//设置是否允许访问,因为该构造器是private的,所以要手动设置允许访问,如果构造器是public的就不需要这行了。
            constructor.newInstance("kang");//这里Person的构造器中有一个打印操作
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果:
kang
需要注意的是,Class中也有一个newInstance方法,但这个方法只能创建内部包含一个无参数的构造函数的类。如果某类只有带参数的构造函数,而没有不带参数的构造器,那么就要使用另外一种方式:即先调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数(这里的构造函数有两个输入参数,一个String类型,一个int类型),然后再调用Constructor类的newInstance("张三",20)方法创建对象。

获取所有的构造函数,可以通过以下步骤实现:
public class TestGetCstorAllDemo {
    public static void main(String[] args){
            Constructor[] constructors = c.getDeclaredConstructors();
            for(Constructor constructor:constructors){
                System.out.println(constructor);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
执行结果:
public com.kang.test.Person()
public com.kang.test.Person(java.lang.String)

三、java反射机制与集合的泛型
Java中集合的泛型,是用来防止错误输入的。只在编译阶段有效,绕过编译到了运行期就无效了。
测试:
public class Test {
    public static void main(String[] args) {
        List list1 = new ArrayList(); // 没有泛型 
        List<String> list2 = new ArrayList<String>(); // 有泛型




        /*
         * 1.首先观察正常添加元素方式,在编译期间就检查泛型,
         * 所以这个时候如果list2添加int类型会报错(编译时报错)。
         */
        list2.add("hello");
//      list2.add(20); // 报错!list2有泛型限制,只能添加String,添加int报错
        System.out.println("list2的长度是:" + list2.size()); // 此时list2长度为1




        /*
         * 2.然后通过反射添加元素方式,在运行期动态加载类,首先可以得到list1和list2
         * 的类类型,通过比较发现两者相同。然后再通过方法反射绕过编译器来调用add方法,         * 来插入int型的元素,发现可以添加成功。(编译器并没有提示错误)
         * 
         */
        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        System.out.println(c1 == c2); // 结果:true,说明类类型完全相同


        // 验证:我们可以通过方法的反射来给list2添加元素,这样可以绕过编译检查
        try {
            Method m = c2.getMethod("add", Object.class); // 通过方法反射得到add方法
            m.invoke(list2, 20); // 给list2添加一个int型的,这时编译器并没有提示错误。
            System.out.println("list2的长度是:" + list2.size()); 
            // 结果:2,说明list2长度增加了,并没有泛型检查
        } catch (Exception e) {
            e.printStackTrace();
        }


        /*
         * 综上可以看出,在编译器的时候,泛型会限制集合内元素类型保持一致,但是编译器结束进入
         * 运行期以后,泛型就不再起作用了,即使是不同类型的元素也可以插入集合。
         */
    }
}

运行结果:
list2的长度是:1
true
list2的长度是:2



  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值