反射知识的理解

2018-07-18 本文已影响6人须臾之北

反射

本文参考自：https://blog.csdn.net/sinat_38259539/article/details/71799078#commentBox

一、反射概述

能够分析类能力的程序称为反射

JAVA反射机制是在运行状态中：
- 对于任意一个类，都能够知道这个类的所有属性和方法；

* 对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
* 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

反射就是把java类中的各种成分映射成一个个的Java对象
- 例如：一个类有：成员变量、方法、构造方法、包等等信息
- 利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
- (其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
- 如图是类的正常加载过程：反射的原理在与class对象。
- 熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。
image
若要学习反射，必须了解Class类

二、Class类

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。

* 也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）

Class 没有公共构造方法。
Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

返回Class类型实例

Object类中的getClass()方法

 Employee e;
 Class c1 = e.getClass();  //获取到Employee类

 /*
     此时还有一个常用的方法getName()
 */
 System.out.println(c1.getName());

T.class(),此时T为任意的java类型

 Class c1 = Random.class;
 Class c2 = int.class;
 Class c3 = Double[].class;

通过Class类中的static方法forName()

 String className = "java.util.Random";
 
 try{
     Class c1 = Class.forName(className);
     System.out.println(c1.getName());
 }
 catch(ClassNotFoundException e){
     e.getMessage();     
 }

 /*
     1. forName()方法抛出ClassNotFoundException
     2. className必须是类名或者接口
 */

通过反射获取构造方法并使用

自定义Employee类

package reflect;

import java.time.LocalDate;

public class Employee{
    
    //data field
    private String name;
    private double salary;
    private LocalDate hireDay;
    
    //constructor
    public Employee() {
        System.out.println("c1.getConstructor().newInstance()被执行，调用了无参构造器");        
    }


    public Employee(String name,double salary,int year,int month,int day){
        this.name = name;
        this.salary = salary;
        this.hireDay = LocalDate.of(year,month,day);
        System.out.println("getConstructor(Class,Class....).newInstance(para,para....)被执行");        
    }

    //method
    public String getName(){
        return name;    
    }
    
    public double getSalary(){
        return salary;  
    }
    
    public LocalDate gethireDay(){
        return hireDay;
    }
    
    public void raiseSalary(double byPercent){
        salary += salary * byPercent/100;
    }
    
    public String toString() {
        return "name : " + name + "salary : " + salary + " hireDay : " + hireDay;
    }
}

获取构造方法并使用

获取public构造器
- Constructor constructors = c1.getConstructors();
获取所有构造器
- Constructor<Employee>[] constructors = className.getDeclaredConstructors();
newIntance()方法的使用
- 调用无参构造器
  - Constructor<Employee> con = c1.getConstructor();
  - con.newInstance();
- 调用含参构造器
  - Constructor<Employee> paraCons = c1.getConstructor(String.class,double.class,int.class,int.class,int.class);
  - paraCons.newInstance("调用有参构造器",600,2018,7,18));
```
  public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
                        throws NoSuchMethodException,
                               SecurityException
```
  - 返回值为Constructor泛型，参数个数与实际构造器一致，但参数类型为Class

获取构造方法并使用例子程序

public class TestConstructors {
    
    public static void main(String[] args) {
        Class c1 = null;
        
        //获取Class对象
        try {
             c1 = Class.forName("d_1reflect.Employee");
        }catch(ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        //获取构造方法
        System.out.println("========获取所有构造方法========");
        Constructor<Employee>[] constructors = c1.getDeclaredConstructors();        
        
        //输出构造方法        
        for(Constructor cons : constructors) {
            System.out.println(cons);           
        }
        
        System.out.println();
        
        //使用构造方法中的无参构造器
        System.out.println("======使用构造方法中的无参构造器======");
        
        try {
            Constructor<Employee> nonParaCons = c1.getConstructor();
            System.out.println(nonParaCons.newInstance());
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
                | NoSuchMethodException | SecurityException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        
        System.out.println();
                
        //使用构造方法中的含参构造器
        System.out.println("======使用构造方法中的含参构造器======");
        try {
            Constructor<Employee> paraCons = c1.getConstructor(String.class,double.class,int.class,int.class,int.class);
            System.out.println(paraCons.newInstance("调用有参构造器",600,2018,7,18));
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
                | NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       
    }   
}

通过反射获取普通方法并使用

获取所有普通方法
- Method[] method = c1.getDeclaredMethods();
获取单个普通方法
- Method m = c1.getDeclaredMethod("getName")；
```
  public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
      throws NoSuchMethodException,SecurityException
```
  - 返回值为Method类型,两个参数，第一个参数为String类，即方法名称，第二个参数为Class类型

使用普通方法

  public Object invoke(Object obj,Object... args)
        throws IllegalAccessException,
               IllegalArgumentException,
               InvocationTargetException

返回值为Object，一共两个参数：
第一个参数Object是指调用该方法的对象，第二个参数是实参

通过反射获取普通方法并使用例子程序

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestMethod {
    public static void main(String[] args) {
        //获取Class对象
        Class c1 = null;
        
        try {
            c1 = Class.forName("d_1reflect.Employee");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        //获取所有普通方法并输出
        Method[] method = c1.getDeclaredMethods();
        
        System.out.println("===========获取所有普通方法===========");
        for(Method m : method) {
            System.out.println(m);
        }
        
        ///获取单个普通方法
        System.out.println("===========获取单个普通方法===========");
        Method m = null;
        try {
             m = c1.getDeclaredMethod("getName");
            System.out.println(m);
        } catch (NoSuchMethodException | SecurityException e) {
            e.printStackTrace();
        }   
        
        //使用普通方法
        System.out.println("===========使用普通方法===========");
        Employee emp;
        try {
            emp = (Employee)c1.getDeclaredConstructor(String.class,double.class,int.class,int.class,int.class).newInstance("hahaha",200,2018,7,18);
            System.out.println("调用Method类中invoke(Object,para)方法后 ： " + m.invoke(emp, null));
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
                | NoSuchMethodException | SecurityException e) {
            e.printStackTrace();
        }   
    }
}

/*
 * 在JDK1.8中输出结果为：
 * -----------------------------------------------------------------------
 * ===========获取所有普通方法===========
    public java.lang.String d_1reflect.Employee.toString()
    public java.lang.String d_1reflect.Employee.getName()
    public void d_1reflect.Employee.setName(java.lang.String)
    public double d_1reflect.Employee.getSalary()
    public java.time.LocalDate d_1reflect.Employee.gethireDay()
    public void d_1reflect.Employee.raiseSalary(double)
    public java.lang.String d_1reflect.Employee.testMethod(java.lang.String)
    ===========获取单个普通方法===========
    public java.lang.String d_1reflect.Employee.getName()
    ===========使用普通方法===========
    调用Method类中invoke(Object,para)方法后 ： hahaha
    -----------------------------------------------------------------------
 * */

通过反射获取成员变量

获取所有成员变量信息
- Field[] fields = c1.getDeclaredFields();
获取public成员变量信息
- Field[] fields = c1.getFields();
获取单个成员变量信息
- Field f = c1.getDeclaredField("name");
```
  public Field getDeclaredField(String name)
       throws NoSuchFieldException,SecurityException
```
- 返回值为Field,有一个参数，为成员变量名字

使用成员变量

  Employee emp = (Employee)c1.getConstructor().newInstance();
      
  f.setAccessible(true);//暴力反射，解除私有设定
      
  f.set(emp, "xixixi");



  public void set(Object obj,Object value)
          throws IllegalArgumentException,
              IllegalAccessException

无返回值，共两个参数，第一个参数是：要设置的对象，第二个参数是要设置的值
此时注意private的成员变量不可直接访问，但是
setAccessible()方法可解除私有设定

通过反射获取成员变量例子程序

public class TestField {
    public static void main(String[] args) {
        
        Class c1 = null;
        //获取Class对象
        try {
            c1 = Class.forName("d_1reflect.Employee");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //获取成员变量信息
        Field[] fields = c1.getDeclaredFields();
        
        System.out.println("=========获取成员变量信息=========");
        for(Field field : fields) {
            System.out.println(field);
        }
        
        //获取单个成员变量信息
        System.out.println("=========获取单个成员信息=========");
        Field f = null;
        try {
            f = c1.getDeclaredField("name");
            System.out.println(f);
        } catch (NoSuchFieldException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //使用成员变量
        Employee emp;
        try {
            emp = (Employee)c1.getConstructor().newInstance();
            f.setAccessible(true);//暴力反射，解除私有设定
            f.set(emp, "xixixi");
            System.out.println("使用了set方法修改成员变量 name： " + emp.getName());
        } catch (IllegalArgumentException | IllegalAccessException | InstantiationException | InvocationTargetException
                | NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       
    }
}
/*
 * 在JDK1.8中输出结果为：
 * ---------------------------------------------------------
 * =========获取成员变量信息=========
    private java.lang.String d_1reflect.Employee.name
    private double d_1reflect.Employee.salary
    private java.time.LocalDate d_1reflect.Employee.hireDay
    =========获取单个成员信息=========
    private java.lang.String d_1reflect.Employee.name
    c1.getConstructor().newInstance()被执行，调用了无参构造器
    使用了set方法修改成员变量 name： xixixi
    ---------------------------------------------------------
 * */

反射与配置文件结合使用

配置文件pro.txt，注意是要放在工程下面

  className = d_1reflect.Employee
  methodName = testMethod

主程序：从配置文件中获取ClassName生成Class对象，并调用方法

  public static void main(String[] args) {
  
      Class c1 = null;
      //获取创建的Class对象
      try {
          c1 = Class.forName(getValue("className"));
      } catch (ClassNotFoundException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      }
      
      Method m;
      try {
          m = c1.getDeclaredMethod(getValue("methodName"));
          m.invoke((Employee)c1.getConstructor().newInstance());
      } catch (NoSuchMethodException | SecurityException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      } catch (IllegalAccessException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      } catch (IllegalArgumentException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      } catch (InvocationTargetException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      } catch (InstantiationException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      }       
  }

配置文件的调用与返回

  public static String getValue(String str) {
      Properties pro = new Properties();  //获取配置文件对象
      FileReader in;
      try {
          in = new FileReader("pro.txt");
          pro.load(in);
      } catch (FileNotFoundException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }
      return pro.getProperty(str);
  }

  /*
   * 在JDK1.8中输出结果为：
   * --------------------------------------------------
   *  c1.getConstructor().newInstance()被执行，调用了无参构造器
      testMeod()方法被执行
      --------------------------------------------------
   * */

反射知识的理解

反射

本文参考自：https://blog.csdn.net/sinat_38259539/article/details/71799078#commentBox

一、反射概述

二、Class类

返回Class类型实例

通过反射获取构造方法并使用

自定义Employee类

获取构造方法并使用

获取构造方法并使用例子程序

通过反射获取普通方法并使用

通过反射获取普通方法并使用例子程序

通过反射获取成员变量

通过反射获取成员变量例子程序

反射与配置文件结合使用

猜你喜欢

热点阅读