java反射

Java Reflection

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

反射相关的主要API：

java.lang.Class:代表一个类

java.lang.reflect.Method:代表类的方法

java.lang.reflect.Field:代表类的成员变量

java.lang.reflect.Constructor:代表类的构造方

Class 类：

在Object类中定义了以下的方法，此方法将被所有子类继承： public final Class getClass()

Class 类的常用方法：

实例：

import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestReflection {
    //有了反射，可以通过反射创建一个类的对象，并调用其中的属性、方法
    
    public void test3(){
        Person p=new Person();
        Class cla=p.getClass();//通过运行时类的对象，调用其getClass方法，返回其运行时类
        System.out.println(cla);
    }
      
    public void test2() throws Exception{
     Class cla=Person.class;
     
     //1.创建cla对应的运行时类Person类的对象
     Person p=(Person)cla.newInstance();
     System.out.println(p);
     
     //2.通过反射调用运行时类的指定的属性
     //2.1
     Field f1=cla.getField("name");
     f1.set(p, "LiMing");
     System.out.println(p);
     //2.2
     Field f2=cla.getDeclaredField("age");
     f2.setAccessible(true);
     f2.set(p, 20);
     System.out.println(p);
     
     //3.通过反射调用运行时类的指定的方法
     Method m1=cla.getMethod("show");
     m1.invoke(p);
     
     Method m2=cla.getMethod("display", String.class);
     m2.invoke(p, "China");
    }    
    
    //不使用反射的情况下，创建一个对象，并调用其中的属性、方法    
    public void test1(){
       Person person=new Person();
       person.setName("LiMing");
       person.setAge(20);
       person.show();
       person.display("HK");
    }
}
public class Person {
     private String name;
     private int age;
     public Person(){
         super();
     }
     public Person(String name){
         super();
         this.name=name;
     }
     public Person(String name,int age){
         super();
         this.name=name;
         this.age=age;
     }
     
     public void setName(String name){
         this.name=name;
     }
     public String getName(){
         return name;
     }
     public void setAge(int age){
         this.age=age;
     }
     public int getAge(){
         return age;
     }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public void show(){
        System.out.println("我是一个人！");
    }
    public void display(String nation){
        System.out.println("我的国籍是："+nation);
    }
}

java.lang.Class:是反射的源头

我们创建了一个类，通过编译（javac.exe）生成相应的.class文件。之后我们使用java.exe加载（JVM的类加载器）此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在缓冲区，那么这个运行时类本身就是一个Class实例。

1.一个运行时类只加载一次。

2.有了Class类的实例以后，我们才可以进行如下的操作：

1）创建对应的运行时类的对象

2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解...）

3）调用对应的运行时类的指定的结构（属性、方法、构造器）

4）反射的应用：动态代理

实例化Class类对象(四种方法)：

1.若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

实例：Class clazz = String.class;

2.已知某个类的实例，调用该实例的getClass()方法获取Class对象

实例：Class clazz = “www.atguigu.com”.getClass();

3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

实例：Class clazz = Class.forName(“java.lang.String”);

4.通过类的加载器（类加载器是用来把类(class)装载进内存的）（了解）

ClassLoader cl = this.getClass().getClassLoader();

Class clazz4 = cl.loadClass(“类的全类名”);

public void test4() throws ClassNotFoundException{
        //调用运行时类本身的.class属性
        Class cla1=Person.class;
        System.out.println(cla1.getName());//返回com.atguigu.java.Person
        Class cla2=String.class;
        System.out.println(cla2.getName());//返回java.lang.String
        
        //通过运行时类的对象获取
        Person p=new Person();
        Class cla3=p.getClass();
        System.out.println(cla3.getName());//返回com.atguigu.java.Person
        
        //通过运行时类的静态方法forName获取
        Class cla4=Class.forName("com.atguigu.java.Person");
        System.out.println(cla4.getName());//返回com.atguigu.java.Person
    }

创建类对象并获取类的完整结构：

创建类的对象：调用Class对象的newInstance()方法

要求：1）类必须有一个无参数的构造器。

2）类的构造器的访问权限需要足够。

//1.根据全类名获取对应的Class对象

String name = “atguigu.java.Person";

Class clazz = Class.forName(name);

//2.调用指定参数结构的构造器，生成Constructor的实例

Constructor con = clazz.getConstructor(String.class,Integer.class);

//3.通过Constructor的实例创建对应类的对象，并初始化类属性

Person p2 = (Person) con.newInstance("Peter",20);

System.out.println(p2);

通过反射调用类中的指定方法、指定属性：

1.调用指定属性

先获取属性

public Field getField(String name) 返回此Class对象表示的类或接口的指定的public的Field。

public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field。

在Field中：

public Object get(Object obj) 取得指定对象obj上此Field的属性内容

public void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容

注：在类中属性都设置为private的前提下，在使用set()和get()方法时，首先要使用Field类中的setAccessible(true)方法将需要操作的属性设置为可以被外部访问。

public void setAccessible(true)访问私有属性时，让这个属性可见。

2.调用指定方法

通过反射，调用类中的方法，通过Method类完成。步骤：

1）.通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

2）.之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

    //调用运行时类中指定的属性
    public void test5() throws Exception{
        Class cla=Person.class;
        //1.获取指定的属性
        Field name=cla.getField("name");
        //2.创建运行时类的对象
        Person p=(Person)cla.newInstance();
        //3.将运行时类的指定的属性赋值
        name.set(p, "LiMing");
        System.out.println(p);
        
        Field age=cla.getDeclaredField("age");
        age.setAccessible(true);
        age.set(p, 20);
        System.out.println(p);
    }
    //调用运行时类中指定的方法
    public void test6() throws Exception{
        Class cla=Person.class;
        //获取运行时类中声明为public的指定的方法
        Method m1=cla.getMethod("show");
        Person p=(Person)cla.newInstance();
        //调用指定的方法
        Object returnVal=m1.invoke(p);
        
        //对于运行时类中静态方法的调用,无需创建运行时类的对象，直接使用类调用对象
        Method m2=cla.getMethod("info");
        m2.invoke(Person.class);
    }