java反射总结

反射机制

反射

在运行状态中，对于任何一个类都能知道这个类的属性和方法，对于任何一个类的对象，都能调用它的任意一个方法和属性(包括私有方法和属性)，这种借助反射API动态获取类的内部信息以及动态调用对象的内部属性和方法的功能即称为java反射机制

在java.exe命令执行时，就会去加载一个类，加载完之后，堆内存空间中的方法区就会产生一个Class类型的对象，注意，一个类只有一个Class对象，这个对象包括完整的类结构信息，可以通过这个对象看到类的结构

想要使用反射机制，就必须要先获取到该类的字节码文件对象(.class)，通过字节码文件对象，就能够通过该类中的方法获取到我们想要的所有信息(方法，属性，类名，父类名，实现的所有接口等等)，每一个类对应着一个字节码文件也就对应着一个Class类型的对象，也就是字节码文件对象。

Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

反射相关的主要API

java.lang.Class 代表一个类

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

java.lang.reflect.Field 代表类的属性

java.lang.reflect.Constructor 代表类的构造器

反射实例

public class Person {

    private String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private Person(String name){
        this.name = 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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void show(){
        System.out.println("你好，我是一个女生");
    }

    private String showNation(String nation){
        System.out.println("我的国籍是 " + nation);
        return nation;
    }


}

public class ReflectionTest {

    //反射之前
    @Test
    public void test(){
        Person p1 = new Person("Tom",12);
        p1.setAge(10);

        p1.show();
        System.out.println(p1.toString());

        //注意：在Person类外部，不能使Person类对象调用内部私有结构，
        // 如私有属性，方法，构造器
   }

    //反射之后
    @Test
    public void test2() throws Exception {
        //通过反射创建Person类的对象
        Class clazz = Person.class;
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object obj = constructor.newInstance("Tom", 12);

        System.out.println(obj);
        //运行发现obj是Person类对象Person{name='Tom', age=12}

        Person p = (Person)obj;

        //通过反射调用对象指定的属性和方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p);

        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        //通过反射，可以使Person类对象调用内部私有结构，
        // 如私有属性，方法，构造器

        //私有构造器
        Constructor cons = clazz.getDeclaredConstructor(String.class);
        cons.setAccessible(true);
        Object jerry = cons.newInstance("Jerry");
        System.out.println(jerry);
        Person p1 = (Person)jerry;
        System.out.println(p1);

        //调用私有属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"Mike");
        System.out.println(p1);

        //调用私有方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        showNation.invoke(p1,"中国");
    }

理解Class类并获取Class实例

类加载过程：

源文件创建后，程序经过javac.exe命令执行被编译器编译生成一个或多个字节码文件(以.class结尾的)，接着通过使用java.exe对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中，此过程称为类的加载

加载到内存中的类，我们称为运行时类，此类就作为Class的一个实例

加载到内存中的运行时类，会缓存一定的时间。在此时间内，可以通过不同的方式来获取运行时类。运行时类可以看作单例的。即下列方式中clazz, clazz2, clazz3都指向内存中的同一个运行时类

Class实例可以是的结构

• class类

• interface接口

• [] 数组

• enum 枚举

• annotation 注解

• 基本数据类型

• void

      @Test
      public void test4(){
          Class c1 = Object.class;
          Class c2 = Comparable.class;
          Class c3 = String[].class;
          Class c4 = int[][].class;
          Class c5 = ElementType.class;
          Class c6 = Override.class;
          Class c7 = int.class;
          Class c8 = void.class;
          Class c9 = Class.class;
  
          int[] a = new int[10];
          int[] b = new int[10];
          Class c10 = a.getClass();
          Class c11 = b.getClass();
          System.out.println(c10 == c11);  //true
          //只要数组的元素类型与唯独一样，就是同一个Class
  
  
      }
  

获取Class实例方式

• 调用运行时类的属性 .class

   Class clazz = Person.class;
   System.out.println(clazz);
  

• 通过运行时类的对象,调用getClass()方法

  Person p1 = new Person();
  Class clazz2 = p1.getClass();
  System.out.println(clazz2);
  

• 调用Class的静态方法 Class.forName(String className);

  className为类的全名

  Class clazz3 = Class.forName("com.csdn.day12.Person");
  System.out.println(clazz3);
  

• 使用类的加载器, ClassLoader

  ClassLoader loader = ReflectionTest.class.getClassLoader();
  Class clazz4 = loader.loadClass("com.csdn.day12.Person");
  System.out.println(clazz4);
  

创建运行时类的对象

 @Test
    public void test() throws Exception{
        Class clazz = Person.class;
     
        Object obj = clazz.newInstance();
        Person p = (Person)obj;

调用newInstance()方法创建对应的运行时类的对象,内部调用了运行时类的空参构造器

注意使用时可能出现异常，要想此方法正确的创建运行时类的对象，需要运行时类必须提供空参的构造器; 空参构造器的访问权限得够，通常设置为public

获取运行时类的完整结构

获取属性结构

getFields()，获取当前运行时类及其父类中声明为public访问权限的属性

 Class<Person> clazz = Person.class;

        Field[] fields = clazz.getFields();
        for(Field f: fields ){
            System.out.println(f);
        }

/**
public int com.csdn.java.Person.id
public char com.csdn.java.Creature.weight

getDeclaredFields(),获取当前运行时类中声明的所有属性，不包括父类中声明的属性

  Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f: declaredFields ){
            System.out.println(f);
        }
/**
private java.lang.String com.csdn.java.Person.name
int com.csdn.java.Person.age
public int com.csdn.java.Person.id

 Class<Person> clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f: declaredFields ){
            //权限修饰符
            int modifier = f.getModifiers();
            System.out.println(Modifier.toString(modifier));

            //数据类型
            Class<?> type = f.getType();
            System.out.println(type);

            //变量名
            String name = f.getName();
            System.out.println(name);


        }
/**
private
class java.lang.String
name

int
age
public
int
id

获取方法结构

getMethods():获取当前运行时类及其多有父类中声明为public权限的方法

 Class<Person> clazz = Person.class;
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }

getDeclaredMethods()：获取当前运行时类中声明的所有方法(不包括父类中声明的方法）

Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }

也可以获取方法的内部结构，如方法的权限修饰符，返回值类型，方法名等，这里不再详细解说

获取构造器

getConstructors(),获取当前运行时类中声明为public的构造器

 Class<Person> clazz = Person.class;
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor con :  constructors){
            System.out.println(con);
        }

      

getDeclaredConstructors()，获取当前运行时类中声明的所有构造器

  Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor con : declaredConstructors){
            System.out.println(con);
        }

获取运行时类的父类

Class<Person> clazz = Person.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);


//泛型父类
 Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);


/**
class com.csdn.java.Creature

com.csdn.java.Creature<java.lang.String>

获取运行时类实现的接口

Class<Person> clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for(Class inter : interfaces){
            System.out.println(inter);
        }

/**
interface java.lang.Comparable
interface com.csdn.java.MyInterface

获取运行时类的父类实现的接口

 Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class inter : interfaces1){
            System.out.println(inter);
        }
/**
interface java.io.Serializable

获取运行时类所在的包

Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);
/**
package com.csdn.java

调用运行时类的指定结构

调用运行时类中指定的结构：属性，方法，构造器

调用运行类的指定属性

set() 参数1，指明设置哪个对象的属性

​ 参数2，将此属性值设置为多少

get() 参数，获取哪个对象的当前属性值

@Test
    public void test() throws Exception {
        Class<Person> clazz = Person.class;
        Person person = clazz.newInstance();
        //获取指定的属性，要求运行时类中属性声明为public，若属性为私有，则会报错
        //所以通常不采用下面这种方式
        Field id = clazz.getField("id");

        id.set(person,1001);
        Object o = id.get(person);
        int pId = (int)o;
        System.out.println(pId);
    }
/**
1001

要掌握的方法是如下：

 @Test
    public void test2() throws Exception{
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();

        //获取运行时类中指定变量名的属性getDeclaredField(String fieldName)
        Field name = clazz.getDeclaredField("name");

        //保证当前属性可访问,不管是私有属性还是默认权限
        name.setAccessible(true);

        name.set(p,"Tom");
        System.out.println(name.get(p));
    }
/**
Tom

调用运行时类的指定方法

getDeclaredMethod()

参数1，指明获取的方法的名称

参数2，指明获取的方法的形参列表

invoke()

参数1，方法的调用者

参数2，给方法形参赋值的实参

invoke()的返回值即为对应类中调用的方法的返回值，如String show = p.show();

@Test
    public void test3() throws Exception{
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();

        Method show = clazz.getDeclaredMethod("show", String.class);

        show.setAccessible(true);
        
        show.invoke(p,"CHN");

    }

调用运行时类的指定构造器

getDeclaredConstructor()

参数：指明构造器的参数列表类型

//获取指定的构造器
        Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);

        //保证此构造器可访问
        constructor.setAccessible(true);

        //调用此构造器创建运行时类的对象
        Person tom = constructor.newInstance("Tom");
        System.out.println(tom);
/**
Person{name='Tom', age=0, id=0}

依赖的实例类有：

public class Person extends Creature<String> implements Comparable,MyInterface{

    private String name;
    int age;
    public int id;

    public Person() {
    }

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

    public String show(String nation){
        System.out.println("我的国籍是" + nation);
        return nation;
    }

    public String display(String interests){
        return interests;
    }

    Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public void info() {
        System.out.println("我是一个女生");
    }

    @Override
    public int compareTo(Object o) {
        return 0;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

public class Creature<String> implements Serializable {

    private char gender;
    public double weight;

    public void breath(){
        System.out.println("生物呼吸");
    }

    public void eat(){
        System.out.println("生物吃东西");
    }

}

public interface MyInterface {
    void info();
}

反射应用：动态代理

代理模式是常用的Java设计模式，特征是代理类与被代理类即委托类有实现相同的接口

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过内部调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象的时候，是通过代理对象来访问的，代理模式就是在访问实际对象的时候引入一定程度的间接性，因为这种间接性，可以附加多种用途。

静态代理

静态代理，由程序员创建或特定工具自动生成源代码，在编译时已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成。

动态代理

代理类在程序运行时常见的代理方式被称为动态代理。动态代理的代理类并不是在Java代码中定义好的，而是在运行时根据我们在Java代码中的指示动态生成的。相比于静态代理，动态代理的优势在于可以很方便地对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

java代理：静态代理和动态代理