Java反射和应用

 

什么是反射

反射就是指程序在运行的时候可以知道一个类的自身信息。

• 对于任何一个类：可以知道这个类的属性和方法。

• 对于任何一个对象：可以调用这个对象的任何一个方法和属性。

反射就是把java类中的各种成分映射成一个个的Java对象。

例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行 解剖，把个个 组成部分映射成一个个对象。

反射的功能

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

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

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

• 在运行时调用任何一个对象的方法

• 生成动态代理

反射的优点和缺点

动态编译和静态编译

反射用到的是动态编译，既然有动态编译，就会有静态编译。

那么动态编译和静态编译又有什么区别？

静态编译:在编译的时候进确定类型，如果绑定对象成功，new 是静态加载类，就编译通过

 

public class Phone{
      public static void main(String[] args){
          if("iphone".equals(args[0])){
              Iphone iphone = new Iphone();
              iphone.call();
          }
          if("xiaomi".equals(args[0])){
              Xiaomi xiaomi = new Xiaomi();
              xiaomi.call();
          }
      }
  }
  class Xiaomi{
      public void call(){
          System.out.println("xiaomi is calling");
      }
  }
  class Iphone{
      public void call(){
          System.out.println("iphone is calling");
      }
  }

当在Phone.java里面写好代码的时候，如果需要添加新的类，则需要直接在文件里面修改代码。假如需要添加一个华为手机，则我需要在Phone.java文件里面加个if语句判断传进来的参数是不是"huawei",这样增加了类之间的耦合性。

当删除一个类的时候Phone.java编译可能会出现错误。 假如我删除了小米手机这个类，phone.java文件没有删除if判断语句，那么phone.java在编译的时候则会失败。

动态编译:在运行的时候确定类型，绑定对象。最大发挥了Java的多态，降低类之间的耦合性。

Phone.java

public static void main(String[] args){
          try{
              Class c = Class.forName("Huawei");
              PhoneInterface cellPhone = (PhoneInterface)c.newInstance();
              cellPhone.ring();
          }catch (Exception  e){
              e.printStackTrace();   
          }
      }
 

PhoneInterface.java

 interface PhoneInterface{
      void ring();
  }

 Huawei.java

  public class Huawei implements PhoneInterface{
      @Override
      public void ring(){
          System.out.println("huawei is ringing...");
      }
  }

OnePlus.java

  public class OnePlus implements PhoneInterface{
      @Override
      public void ring(){
          System.out.println("OnePlus is ringing...");
      }
  }

对比静态编译，当我们需要往Phone.java里面传递新的类参数的时候，根本不需要修改Phone.java的代码，因为这里应用了Java的多态。只要新建一个新的类实现了PhoneInterface的接口，把类名传进去就可以调用。这里体现了 需要哪个类的对象就动态的创建哪个类的对象，也就是说动态的实现了类的加载。

优点

以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。

缺点

对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

Class类和类类型

Class类

所有的类是java.lang.Class类的对象，Class类是所有类的类，反射的基础。

Class对象（类类型）

普通类构造对象是：Student s = new Student();

但Class对象则不是，看Class类的源码，构造器是私有的，则用户无法直接像普通类那样new一个Class的对象，只有JVM才可以构造Class对象。

private Class(ClassLoader loader) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }

但是我们可以通过一个已知的类获得Class对象

有以下三种方式：

Class s = Student.class;
Class s1 = new Student().getClass();
Class s2 = Class.forName("Student");

反射相关操作

文章开始说过，反射会把一个类的成分（成员变量，方法，构造器）各自映射成一个个对象（Field对象，Method对象，Construct对象），

一个类中这些成员方法、构造方法、在加入类中都有一个类来描述。

java.lang.reflect.Constructor; 
java.lang.reflect.Field;  
java.lang.reflect.Method;  
java.lang.reflect.Modifier;

通过Class对象我们可以做什么呢？

• 获取成员方法Method

• 获取成员变量Field

• 获取构造函数Construct

获取成员方法

用法

public Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
// 得到该类所有的方法，不包括父类的 
public Method getMethod(String name, Class<?>... parameterTypes) 
// 得到该类所有的public方法，包括父类的

//具体使用

Method[] methods = class1.getDeclaredMethods();
//获取class对象的所有声明方法 
Method[] allMethods = class1.getMethods();
//获取class对象的所有public方法 包括父类的方法 
Method method = class1.getMethod("info", String.class);
//返回次Class对象对应类的、带指定形参列表的public方法 
Method declaredMethod = class1.getDeclaredMethod("info", String.class);
//返回次Class对象对应类的、带指定形参列表的方法

例子

public static void main(String[] args) {
        try {
            Class c = Class.forName("General.Student");
            Object o = c.newInstance();
            Method method = c.getMethod("fun",String.class,int.class);
            method.invoke(o,"X_man",30);
        } catch (Exception  e) {
            e.printStackTrace();
        }
    }

 

package General;

import java.lang.reflect.Method;

public class Student {
    private String name;
    private int age;
    private String msg = "I am a student";

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

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

    public Student(){

    }

    private Student(String name){

    }

    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 String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

}

结果：

我叫X_man，今年30岁

只要知道包的限定名，就可以对Student这个类进行所有操作

获取成员变量信息

获取成员变量，通过Class类的以下方法，变量是 成员变量名

public Field getDeclaredField(String name) 
// 获得该类自身声明的所有变量，不包括其父类的变量
public Field getField(String name) 
// 获得该类自所有的public成员变量，包括其父类变量

//具体实现
Field[] allFields = class1.getDeclaredFields();
//获取class对象的所有属性 
Field[] publicFields = class1.getFields();
//获取class对象的public属性 
Field ageField = class1.getDeclaredField("age");
//获取class指定属性 
Field desField = class1.getField("des");
//获取class指定的public属性

例子

public static void main(String[] args) {
        try {
            Class c = Class.forName("General.Student");
            Object o = c.newInstance();
            Field field = c.getDeclaredField("msg");
//msg在例子中是私有变量，如果没设置之前，用c.getField（）是会报错的
            field.setAccessible(true); //private设置为public
            System.out.println(c.getField("msg")); 
//用getFiled（）则可以直接访问
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

获取构造函数信息

用法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
//  获得该类所有的构造器，不包括其父类的构造器
public Constructor<T> getConstructor(Class<?>... parameterTypes) 
// 获得该类所以public构造器，包括父类

//具体
Constructor<?>[] allConstructors = class1.getDeclaredConstructors();
//获取class对象的所有声明构造函数 
Constructor<?>[] publicConstructors = class1.getConstructors();
//获取class对象public构造函数 
Constructor<?> constructor = class1.getDeclaredConstructor(String.class);
//获取指定声明构造函数 
Constructor publicConstructor = class1.getConstructor(String.class);
//获取指定声明的public构造函数