java反射详解

一、java反射的介绍

1 、Java 反射机制是 Java 语言一个很重要的特性，它使得 Java 具有了“动态性”。在 Java 程序运行时，对于任意的一个类，我们能不能知道这个类有哪些属性和方法呢？对于任意的 一个对象，我们又能不能调用它任意的方法？答案是肯定的！这种动态获取类的信息以及动 态调用对象方法的功能就来自于 Java语言的反射（Reflection）机制。

2、反射的作用，RTTI（运行时类型识别）和 DC（动态创创建）。

反射机制允许程序在运行时取得任何一个已知名称的 class 的内部信息，包括其 modifiers(修饰符)，fields(属性)，methods(方法)等，并可于运行时改变 fields 内容或调methods。那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进 行源代码链接，降低代码的耦合度；还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！

二、 创建对象过程

         java代码编写后经过编译产生字节码.class文件，当要使用类时，类加载器会把字节码加载到内存中，加载任何一个类时都会在方法区中建立“这个类对应的 Class 对象”，“Class 对象”包含了这个类的整个结构信息，所以我们可以通过这个“Class 对象” 来操作这个类。创建对象时内存结构的变化。

        我们要使用一个类，首先要加载类；加载完类之后，在堆内存中，就产生了一个 Class 类 型的对象（一个类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象知道类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的结构， 所以，形象的称之为：反射。 因此，“Class 对象”是反射机制的核心。

三、 反射的具体实现

1 、获取 Class 对象的三种方式

        （1）通过 getClass()方法。

Users users = new Users();
Class clazz = users.getClass();

        （2）通过 getClass()方法获取 Class对象

Class clazz = Users.class;

        （3）通过 forName()获取Class对象

Class clazz = Class.forName("Users");//Users类的包名加类名

2、 获取类的构造方法

                

 

public class Users {        //创建Users类，下面演示如何获取该的构造方法
private String username;
private int userage;
public Users(){}
public Users(String username,int userage){
this.username= username;
this.userage=userage;
}
public Users(String username){
this.username= username;
}
private Users(int userage){
this.userage = userage;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getUserage() {
return userage;
}
public void setUserage(int userage) {
this.userage = userage;
}
}

public class GetConstructor {
public static void main(String[] args)throws Exception {
    Class clazz = Users.class;
    Constructor[] arr = clazz.getDeclaredConstructors();
    for(Constructor c:arr){
    System.out.println(c);
    }
    System.out.println("---------------------");
    Constructor[] arr1 = clazz.getConstructors();
    for(Constructor c:arr1){
        System.out.println(c);
     }
    System.out.println("------------------------");
    Constructor c = clazz.getDeclaredConstructor(int.class);
    System.out.println(c);
    System.out.println("------------------------");
    Constructor c1 = clazz.getConstructor(null);
    System.out.println(c1);
    }
}

通过构造方法创建对象

public class GetConstructor2 {
public static void main(String[] args)throws Exception {
    Class clazz = Users.class;
    Constructor constructor = clazz.getConstructor(String.class,int.class);
    Object o = constructor.newInstance("OldLu",18);
    Users users = (Users)o;
    System.out.println(users.getUsername()+"\t"+users.getUserage());
    }
}

3 、获取类的成员变量

         3.1获取成员变量

public class GetField {
public static void main(String[] args)throws Exception {
    Class clazz = Users.class;
    Field[] fields = clazz.getFields();
    for(Field f:fields){
    System.out.println(f);
    System.out.println(f.getName());
    }
    System.out.println("------------------------");
    Field[] fields2 = clazz.getDeclaredFields();
    for(Field f:fields2){
    System.out.println(f);
    System.out.println(f.getName());
    }
    System.out.println("------------------------");
    Field field = clazz.getField("userage");
    System.out.println(field);
    System.out.println("---------------------");
    Field field1 = clazz.getDeclaredField("username");
    System.out.println(field1);
}
}

3.2操作成员变量

public class GetField2 {
public static void main(String[] args)throws Exception {
    Class clazz = Users.class;
    Field field = clazz.getField("userage");
//对象实例化
    Object obj = clazz.newInstance();
//为成员变量赋予新的值
    field.set(obj,18);
//获取成员变量的值
    Object o = field.get(obj);
    System.out.println(o);
    }
}

4、 获取类的方法

         4.1获取方法

public class GetMethod {
public static void main(String[] args)throws Exception{
Class clazz = Users.class;
Method[] methods = clazz.getMethods();
for(Method m: methods){
System.out.println(m);
System.out.println(m.getName());
}
System.out.println("---------------------------");
Method[] methods2 = clazz.getDeclaredMethods();
for(Method m: methods2){
System.out.println(m);
System.out.println(m.getName());
}
System.out.println("--------------------------");
Method method = clazz.getMethod("setUserage", int.class);
System.out.println(method.getName());
System.out.println("--------------------------");
Method method1 = clazz.getDeclaredMethod("suibian");
System.out.println(method1.getName());
}
}

4.3调用方法

public class GetMethod2 {
public static void main(String[] args)throws Exception {
Class clazz = Users.class;
Method method = clazz.getMethod("setUsername",String.class);
//实例化对象
Object obj = clazz.newInstance();
//通过 setUserName 赋值
method.invoke(obj,"oldlu");
//通过 getUserName 获取值
Method method1 = clazz.getMethod("getUsername");
Object value = method1.invoke(obj);
System.out.println(value);
}
}

5、获取类的其他信息（类、包名，超类，接口）

public class GetClassInfo {
public static void main(String[] args) {
    Class clazz = Users.class;
//获取类名
    String className = clazz.getName();
    System.out.println(className);
//获取包名
    Package p = clazz.getPackage();
    System.out.println(p.getName());
//获取超类
    Class superClass = clazz.getSuperclass();
    System.out.println(superClass.getName());
//获取该类实现的所有接口
    Class[] interfaces = clazz.getInterfaces();
    for(Class inter:interfaces){
    System.out.println(inter.getName());
        }
    }
}

四、 反射机制的效率

        由于 Java 反射是要解析字节码，将内存中的对象进行解析，包括了一些动态类型，而 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多！

setAccessible 方法：setAccessible是启用和禁用访问安全检查的开关。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查;默认值为 false。 由于 JDK 的安全检查耗时较多.所以通过 setAccessible(true)的方式关闭安全检查就可以 达到提升反射速度的目的。

五、总结

Java 反射机制是 Java 语言一个很重要的特性，它使得 Java 具有了“动态性”。

 反射机制的优点：  更灵活。  更开放。

反射机制的缺点：  降低程序执行的效率。  增加代码维护的困难。

 获取 Class 类的对象的三种方式：   运用 getClass()。  运用.class 语法。  运用 Class.forName()（最常被使用）。

反射机制的常见操作 ： 动态加载类、动态获取类的信息（属性、方法、构造器）。  动态构造对象。  动态调用类和对象的任意方法。  动态调用和处理属性。  获取泛型信息。  处理注解