Java反射机制

1、Java反射机制概述

1.1、反射概述

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

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象，这个Class对象其实就是每个类的.class字节码文件），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

此Class非彼class(关键字)

补充：动态语言 vs 静态语言

1、动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。

2、静态语言与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、 C++。 Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活！ 关于动态：比如java分编译和运行两个阶段：在编译的时候，我们并不能确定他要造哪个类的对象，只有在运行的时候才知道造哪个类对象，这就叫动态特性。

1.2、Java反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

1.3、反射相关的主要API

主要定义在java.lang.reflect包下

主要使用的是

java.lang.Class：代表一个类，这个是重点
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器

1.4、反射案例演示

Person 类

public class Person {

    private String name;  //私有化
    public int age;

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

    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 Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    private Person(String name) {  //私有化构造器
        this.name = name;
    }

    public Person() {
        System.out.println("Person()");
    }

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

    private String showNation(String nation){  //私有化方法
        System.out.println("我的国籍是：" + nation);
        return nation;
    }
}

普通调用方式：在考虑反射之前，在Person类外部，不可以在外部通过Person类的对象调用其内部私有结构。但是可以通过get/set方法修改

//反射之前，对于Person的操作
@Test
public void test1() {

    //1.创建Person类的对象
    Person p1 = new Person("Tom", 12);

    //2.通过对象，调用其内部的属性、方法
    p1.age = 10;
    System.out.println(p1.toString());

    p1.show();

    //在Person类外部，不可以通过Person类的对象调用其内部私有结构。
    //比如：name、showNation()以及私有的构造器
}

考虑反射，反射调用公共属性

@Test
public void  test2() throws Exception {
    Class clazz = Person.class;
    //1.通过反射，创建Person类的对象
    Constructor cons = clazz.getConstructor(String.class,int.class);
    Object obj = cons.newInstance("Tom", 12);
    Person p = (Person) obj;
    System.out.println(p.toString());
    //2.通过反射，调用对象指定的属性、方法
    //调用属性
    Field age = clazz.getDeclaredField("age");
    age.set(p,10);
    System.out.println(p.toString());

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

反射调用私有属性:

@Test
public void  test3() throws Exception {
   Class clazz = Person.class;
   //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
   //调用私有的构造器
   Constructor cons1 = clazz.getDeclaredConstructor(String.class);
   cons1.setAccessible(true);
   Person p1 = (Person) cons1.newInstance("Jerry");
   System.out.println(p1);

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

   //调用私有的方法
   Method showNation = clazz.getDeclaredMethod("showNation", String.class);
   showNation.setAccessible(true);
   String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
   System.out.println(nation);

}

1.5、补充

补充：newInstance()，调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器

java.lang.Class类里面有个newInstance()方法，这个方法是无参的，一般使用它来造对象
java.lang.reflect.Constructor类里面也有个newInstance()方法，这个方法是有参的，一般不使用它来造对象

@CallerSensitive
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }
========================================================
	@CallerSensitive
    public T newInstance()
        throws InstantiationException, IllegalAccessException
    {
        if (System.getSecurityManager() != null) {
            checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
        }

        // NOTE: the following code may not be strictly correct under
        // the current Java memory model.

        // Constructor lookup
        if (cachedConstructor == null) {
            if (this == Class.class) {
                throw new IllegalAccessException(
                    "Can not call newInstance() on the Class for java.lang.Class"
                );
            }

注意：

通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
- 建议：直接new的方式。
什么时候会使用反射的方式
- 反射的特征：动态性，即我们在编译的时候不知道，不能确定我们要造哪个类的对象，就可以使用反射。比如部署到服务器上的servelt对象和用户的交互，用户要登录我们就去造login的对象
反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
- 不矛盾。

2、理解Class类并获取Class的实例

上面讲到关于Class类型的对象，那么这个Class是什么，怎么获取这个对象呢？

2.1、类的加载过程

类的加载过程：

程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)在堆内存的方法区。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class类的一个实例。

换句话说，Class的实例就对应着一个运行时类。即Class clazz = Person.class(后面要加.class)。加载到内存中的运行时类，**会缓存一定的时间，**在此时间之内，我们可以通过不同的方式来获取此运行时类。

2.2、Class 类

Class类定义在Java.lang包下

Class类的来源：

查看Class类源码

public final class Class<T> extends Object implements Serializable, GenericDeclaration, Type, AnnotatedElement

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

public final Class getClass()

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。即在这里，对于每一个类，都可以说是Class类的实例，即这里的实例对象是每一个类(仔细点应该是.class文件)

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构**(class/interface/enum/annotation/primitive type/void/[])**的有关信息。

Class本身也是一个类
一个加载的类在 JVM 中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个 Class 实例所生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

2.3、Class类的常用方法

详细参考官方文档：docs.oracle.com/javase/8/do…

2.4、获取Class类的实例(四种方法)

前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
- 实例：Class clazz = String.class;
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
- 实例：Class clazz = “www.atguigu.com”.getClass();
前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
- 实例：Class clazz = Class.forName(“java.lang.String”);

其他方式(不做要求)

ClassLoader cl = this.getClass().getClassLoader(); 
Class clazz4 = cl.loadClass("类的全类名");

实例

@Test
public void  test() throws ClassNotFoundException {
    //方式1：调用运行时类的属性 .class
    Class cla1 = person.class;
    System.out.prin
        tln(cla1);

    //方式二：通过运行时类的对象，调用getClass()方法
    person p = new person();
    Class cla2 = p.getClass();
    System.out.println(cla2);

    //方式三：调用Class的静态方法 forName(String classPath)，体现了动态性
    Class cla3 = Class.forName("com.reflection.person");
    System.out.println(cla3);

    //方式四：通过类的加载器
    ClassLoader classLoader = reflectionTest.class.getClassLoader();
    Class cla4 = classLoader.loadClass("com.reflection.person");
    System.out.println(cla4);
    
	//说明是同一个运行时类
    System.out.println(cla1 == cla2);//true
    System.out.println(cla1 == cla3);//true
    System.out.println(cla1 == cla4);//true
}

2.5、哪些类型可以有Class对象？

class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

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[100];
Class c10 = a.getClass();
Class c11 = b.getClass();
// 只要元素类型与维度一样，就是同一个Class
System.out.println(c10 == c11);

3、类的加载与ClassLoader的理解

详见JVM

3.1、类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

加载：

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

链接：

将Java类的二进制代码合并到JVM的运行状态之中的过程。

验证：确保加载的类信息符合JVM规范，例如：字节码文件以cafe开头，没有安全方面的问题
准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化：

执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的构造器<clinit>()方法在多线程环境中被正确加锁和同步。

3.2、ClassLoader

类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象

类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器

3.3、常用方法(了解)

public class ClassLoaderTest {    
    @Test  
    public void test1(){  
        
        //对于自定义类，使用系统类加载器进行加载，因为在本类中写，所以可直接.class获取  
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();  
        System.out.println(classLoader);  
        
        //调用系统类加载器的getParent()：获取扩展类加载器  
        ClassLoader classLoader1 = classLoader.getParent();  
        System.out.println(classLoader1);  
        
        //调用扩展类加载器的getParent()：自定义类加载器无法获取引导类加载器  
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。  
        ClassLoader classLoader2 = classLoader1.getParent();  
        System.out.println(classLoader2);  //null
        ClassLoader classLoader3 = String.class.getClassLoader();  
        System.out.println(classLoader3);  //null
    }
}

3.4、Properties

Properties：用来读取配置文件，这部分在讲集合的时候提到过，只是演示了用输入流的方式来加载配置文件内容，这里提供另外一种方式，这种方式在JDBC的时候常用。

这里的配置文件名字：jdbc.properties

文件位置：根据不同情况文件的默认位置不同，应该根据文件的默认位置存放文件，即应该在当前module下还是在src下创建配置文件（最好放在src下）

注意点：打开file encoding ,勾选transparent native-to-ascii conersion(防止文件内容中文乱码)

配置文件先加载在读取

@Test  
public void test2() throws Exception {  
    Properties pros =  new Properties();  
    //此时的文件默认在当前的module下。  
    //读取配置文件的方式一：  
    //FileInputStream fis = new FileInputStream("jdbc.properties");  
    //用此种方式也可以读取src下的文件，只不过路径要补全(也是在module下)
    //FileInputStream fis = new FileInputStream("src\jdbc1.properties");  
    //pros.load(fis);  

    //读取配置文件的方式二：使用ClassLoader  
    //配置文件默认识别为：当前module的src下  
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();  
    InputStream is = classLoader.getResourceAsStream("jdbc1.properties");  
    pros.load(is);    
    //获取内容信息
    String user = pros.getProperty("user");  
    String password = pros.getProperty("password");  
    System.out.println("user = " + user + ",password = " + password);  
}

4、创建运行时类的对象

有了Class对象，能做什么？当然是用于创建运行时类(即加载到内存中的类，比如person类)的对象：调用Class对象的newInstance()方法【其实这只是一种方法，还有其余方法，如下】即可，要求：

类必须有一个无参数的构造器
类的构造器的访问权限需要足够。

4.1、NewInstance()

public class NewInstanceTest {    
    @Test  
    public void test1() throws IllegalAccessException, InstantiationException {  
        Class<Person> clazz = Person.class;  
        Person obj = clazz.newInstance();  //有了泛型就可以避免强转了，newInstance返回泛型T
        System.out.println(obj);    
    }
}

关于newInstance():

调用此方法，创建对应的运行时类的对象，内部实际调用了运行时类的空参的构造器。
要想此方法正常的创建运行时类的对象，要求：
- 运行时类必须提供空参的构造器
- 空参的构造器的访问权限得够。通常，设置为public。
在javabean中要求提供一个public的空参构造器。原因：
- 便于通过反射，创建运行时类的对象
- 便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器

@CallerSensitive
public T newInstance() throws InstantiationException, IllegalAccessException{
    if (System.getSecurityManager() != null) {
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
    }

    // NOTE: the following code may not be strictly correct under
    // the current Java memory model.

    // Constructor lookup
    if (cachedConstructor == null) {
        if (this == Class.class) {
            throw new IllegalAccessException(
                "Can not call newInstance() on the Class for java.lang.Class"
            );
        }
    }

注意1：

难道没有无参的构造器就不能创建对象了吗？不是！我们可以不用newinstace这种方法，我们只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。步骤如下：

通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
通过Constructor实例化对象。
如下：

//通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
//调用私有的构造器
Constructor cons1 = clazz.getDeclaredConstructor(String.class);
cons1.setAccessible(true);//私有的所以要设置为诶true，非私有不用设置
//通过Constructor类的newinstance方法实例化对象。 
Person p1 = (Person) cons1.newInstance("Jerry");
System.out.println(p1);

注意2：

虽然前面提到有通过 Constructor cons = clazz.getConstructor(String.class,int.class); 得到构造器这种形式来创建对象，但是一般通过newinstance就行了，如下

//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);

4.2、动态性

@Test  
public void test2(){    
    for(int i = 0;i < 100;i++){  
        int num = new Random().nextInt(3);//0,1,2  
        String classPath = "";  //先声明一个clsspath
        switch(num){  
            case 0:  
                classPath = "java.util.Date";  
                break;  
            case 1:  
                classPath = "java.lang.Object";  
                break;  
            case 2:  
                classPath = "com.atguigu.java.Person";  //copy refenerce
                break;  
        }    
        try {  
            Object obj = getInstance(classPath);  
            System.out.println(obj);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }    
}     
//创建一个指定类的对象。 

//classPath:指定类的全类名 
public Object getInstance(String classPath) throws Exception {  
    Class clazz =  Class.forName(classPath);  
    return clazz.newInstance();  
}

这样就可以在运行的时候随机确定运行时类的对象了，clazz.newInstance(); 必须保证对应的运行时类有空参构造器，java.sql.date就没有，就报错

5、获取运行时类的完整结构

通过反射可以获取运行时类的完整结构，比如：Field、Method、Constructor、Superclass、Interface、Annotation ，包括运行时类实现的全部接口，所继承的父类，全部的构造器，全部的方法，全部的Field

环境准备

父类：Creature<T> 包含泛型的父类

public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

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

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

}

MyInterface 自定义接口

public interface MyInterface {
    void info();
}

MyAnnotation 自定义注解

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})  
@Retention(RetentionPolicy.RUNTIME)  //只有在内存中的结果，才可以通过反射获取，
public @interface MyAnnotation {  
    String value() default "hello";    
}

子类：Person 类：继承了父类creature，实现了comparable和自定义接口

@MyAnnotation(value="hi")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    public Person(){}

    @MyAnnotation(value="abc")
    private Person(String name){
        this.name = name;
    }

     Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

    public String display(String interests,int age) throws NullPointerException,ClassCastException{
        return interests + age;
    }


    @Override //重写的自定义接口中的方法
    public void info() {
        System.out.println("我是一个人");
    }

    @Override //重写的继承的父类中的Serializable接口中的方法
    public int compareTo(String o) {
        return 0;
    }

    private static void showDesc(){
        System.out.println("我是一个可爱的人");
    }

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

在这里提供具有丰富结构的 Person类，然后利用反射机制来获取 Person 类的信息。下面通过上述中的各种结构，我们通过反射来获取

5.1、获取当前运行时类的属性结构

getFields() ：获取当前运行时类及其父类中所有声明为public访问权限的属性，返回数组类型

@Test
public void test1() {

    Class clazz = Person.class;

    //获取属性结构
    //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
    Field[] fields = clazz.getFields();
    for (Field f : fields) {
        System.out.println(f);
    }
}

getDeclaredFields() ：获取当前运行时类中声明的所有属性。（不包含父类中声明的属性)

@Test
public void test2() {

    Class clazz = Person.class;

    //获取属性结构
    //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
    Field[] declaredFields = clazz.getDeclaredFields();
    for(Field f : declaredFields){
        System.out.println(f);
    }
}

getField(String name)：根据字段名来获取运行时类中 public 修饰的成员变量

@Test
public void test3() throws NoSuchFieldException {

    Class clazz = Person.class;

    //获取属性结构
    //getField():根据字段名来获取当前运行时类中 public 修饰的成员变量
    Field field = clazz.getField("id");
    System.out.println(field);
}

getDeclaredField(String name)：根据字段名来获取当前运行时类中的成员变量，忽略修饰符；

@Test
public void test4() throws NoSuchFieldException {

    Class clazz = Person.class;

    //获取属性结构
    //getField():根据字段名来获取获取当前运行时类中的成员变量
    Field field = clazz.getDeclaredField("name");
    System.out.println(field);
}

5.2、获取成员变量的信息

拿到属性里面的具体结构，比如：获取属性的权限修饰符，数据类型，变量名等信息

public int getModifiers() 以整数形式返回此Field的修饰符
 
public Class<?> getType() 得到Field的属性类型
 
public String getName() 返回Field的名称。

实例

@Test
public void test1(){
    Class clazz = Person.class;
    Field[] declaredFields = clazz.getDeclaredFields();
    for(Field f : declaredFields){
        //1.权限修饰符
        int modifier = f.getModifiers(); //2,0,1，枚举类里面定义了 
        System.out.print(Modifier.toString(modifier) + "\t");

        //2.数据类型
        //调用属性的 getType() 就可以获取数据类型，而它也是一个 Class 对象
        Class type = f.getType();
        System.out.print(type.getName() + "\t");

        //3.变量名
        String fName = f.getName();
        System.out.print(fName);

        System.out.println();
    }
}

补充：

获取的修饰符返回值是一个 int，而不是期望的字符串，这是因为在 Modifier 类中声明了对应的常量值。

public static final int PUBLIC           = 0x00000001;

public static final int PRIVATE          = 0x00000002;

public static final int PROTECTED        = 0x00000004;

public static final int STATIC           = 0x00000008;

public static final int FINAL            = 0x00000010;

public static final int SYNCHRONIZED     = 0x00000020;

public static final int VOLATILE         = 0x00000040;

public static final int TRANSIENT        = 0x00000080;


public static final int NATIVE           = 0x00000100;

public static final int INTERFACE        = 0x00000200;

public static final int ABSTRACT         = 0x00000400;

public static final int STRICT           = 0x00000800;

调用 Modifier 类的 toString() 方法就可以获取对应值的修饰符。

5.3、获取运行时类的方法结构

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

@Test
public void test1() {

    Class clazz = Person.class;

    //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
    Method[] methods = clazz.getMethods();
    for (Method m : methods) {
        System.out.println(m);
    }
}

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

@Test
public void test3() {

    Class clazz = Person.class;

    //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for(Method m : declaredMethods){
        System.out.println(m);
    }
}

getMethod(String name, Class<?> ... parameterTypes)：根据方法名获取指定的public修饰的某个方法（包含父类中继承的）；

@Test
public void test3() throws NoSuchMethodException {

    Class clazz = Person.class;

    /*
        获取指定的public修饰的某个方法
        getMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
         */
    Method show = clazz.getMethod("display", String.class, int.class);
    System.out.println(show);

}

getDeclaredMethod(String name, Class<?> ... parameterTypes)：获取本类中指定的某个方法，忽略权限修饰符（不包含父类继承的）。

@Test
public void test4() throws NoSuchMethodException {

    Class clazz = Person.class;

    /*
        获取本类中指定的某个方法
        getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
         */
    Method show = clazz.getDeclaredMethod("show", String.class);
    System.out.println(show);

}

说明：

name 参数是一个 String 对象，它指定所需方法的简称
parameterTypes 参数是 Class 对象的一个数组或 0~n个 Class 对象，它按声明顺序标识该方法的形参类型
如果是无参方法，那么 parameterTypes 可以不传或者传 null。
因为可能存在重载的方法，所以在一个类中唯一确定一个方法，需要方法名和形参类型列表。

5.4、获取方法的信息

一个类中的方法可以有修饰符，返回值类型，方法名和异常列表等信息。这些都可以获取到

public Class<?> getReturnType()取得全部的返回值
public Class<?>[] getParameterTypes()取得全部的参数
public int getModifiers()取得修饰符
public Class<?>[] getExceptionTypes()取得异常信息
public String getName()获取方法名
public Annotation[] getAnnotations()获取注解信息

/*
    @Xxxx
    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
     */
@Test
public void test(){
    Class clazz = Person.class;
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for(Method m : declaredMethods){
        //1.获取方法声明的注解
        Annotation[] annos = m.getAnnotations();
        for(Annotation a : annos){
            System.out.println(a);
        }

        //2.权限修饰符
        System.out.print(Modifier.toString(m.getModifiers()) + "\t");

        //3.返回值类型
        System.out.print(m.getReturnType().getName() + "\t");

        //4.方法名
        System.out.print(m.getName());
        System.out.print("(");
        //5.形参列表
        Class[] parameterTypes = m.getParameterTypes();
        if(!(parameterTypes == null && parameterTypes.length == 0)){
            for(int i = 0;i < parameterTypes.length;i++){

                if(i == parameterTypes.length - 1){
                    System.out.print(parameterTypes[i].getName() + " args_" + i);
                    break;
                }

                System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
            }
        }

        System.out.print(")");

        //6.抛出的异常
        Class[] exceptionTypes = m.getExceptionTypes();
        if(exceptionTypes.length > 0){
            System.out.print("throws ");
            for(int i = 0;i < exceptionTypes.length;i++){
                if(i == exceptionTypes.length - 1){
                    System.out.print(exceptionTypes[i].getName());
                    break;
                }

                System.out.print(exceptionTypes[i].getName() + ",");
            }
        }

        System.out.println();
    }
}

5.5、获取构造器结构

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

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

@Test  
public void test1(){  
    Class clazz = Person.class;  
    //getConstructors():获取当前运行时类中声明为public的构造器  
    Constructor[] constructors = clazz.getConstructors();  
    for(Constructor c : constructors){  
        System.out.println(c);  
    }  

    System.out.println();

    //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器  
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();  
    for(Constructor c : declaredConstructors){  
        System.out.println(c);  
    }  
}

5.6、获取运行时类的父类以及带泛型的父类

//获取运行时类的父类
@Test  
public void test2(){  
    Class clazz = Person.class;   
    Class superclass = clazz.getSuperclass();  
    System.out.println(superclass);  
}  

//获取运行时类的带泛型的父类
@Test  
public void test3(){  
    Class clazz = Person.class;  
    Type genericSuperclass = clazz.getGenericSuperclass();  
    System.out.println(genericSuperclass);  
}

5.7、获取运行时类的带泛型的父类的泛型(重要JDBC)

@Test  
public void test4(){  
    Class clazz = Person.class;  

    Type genericSuperclass = clazz.getGenericSuperclass();  //带了泛型
    ParameterizedType paramType = (ParameterizedType) genericSuperclass;  
    
    //获取实际参数，即泛型类型，像map<>这种，里面有两个泛型，所以是数组形式
    Type[] actualTypeArguments = paramType.getActualTypeArguments();  
    //System.out.println(actualTypeArguments[0].getTypeName());  
    System.out.println(((Class)actualTypeArguments[0]).getName());  
}

5.8、获取运行时类实现的接口

@Test  
public void test5(){  
    Class clazz = Person.class;  
    Class[] interfaces = clazz.getInterfaces();  
    for(Class c : interfaces){  
        System.out.println(c);  
    }  

    System.out.println();  
    //获取运行时类的父类实现的接口  
    Class[] interfaces1 = clazz.getSuperclass().getInterfaces();  
    for(Class c : interfaces1){  
        System.out.println(c);  
    }  
}

5.9、获取运行时类所在的包、声明的注解

//所在的包
@Test  
public void test6(){  
    Class clazz = Person.class;  

    Package pack = clazz.getPackage();  
    System.out.println(pack);  
}  

//声明的注解
@Test  
public void test7(){  
    Class clazz = Person.class;  

    Annotation[] annotations = clazz.getAnnotations();  
    for(Annotation annos : annotations){  
        System.out.println(annos);  
    }  
}

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

6.1、调用运行时类中的指定的属性

方式一：通常不采用此方法

@Test
public void testField() throws Exception {
    Class clazz = Person.class;

    //创建运行时类的对象
    Person p = (Person) clazz.newInstance();


    //获取指定的属性：要求运行时类中属性声明为public
    //通常不采用此方法
    Field id = clazz.getField("id");

    /*
     设置当前属性的值
     set():参数1：指明设置哪个对象的属性   参数2：将此属性值设置为多少
   */

    id.set(p,1001);

    /*
     获取当前属性的值
     get():参数1：获取哪个对象的当前属性值
    */
    int pId = (int) id.get(p);
    System.out.println(pId);
}

方式二：掌握

@Test
public void testField1() throws Exception {
    Class clazz = Person.class;

    //创建运行时类的对象
    Person p = (Person) clazz.newInstance();
    //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
    Field name = clazz.getDeclaredField("name");
    //2.保证当前属性是可访问的,name属性是私有的，但必须有，它与属性的权限无关 
    name.setAccessible(true);
    //3.获取、设置指定对象的此属性值
    name.set(p,"Tom");
    System.out.println(name.get(p));
}

6.2、调用运行时类中的指定的方法

获取指定的某个方法：getDeclaredMethod():

参数1 ：指明获取的方法的名称
参数2：指明获取的方法的形参列表，没有可以不写

invoke():

参数1：方法的调用者，非静态方法调用者是对象，静态方法调用者是当前类
参数2：给方法形参赋值的实参
invoke()的返回值即为对应类中调用的方法的返回值

@Test
public void testMethod() throws Exception {

    Class clazz = Person.class;

    //创建运行时类的对象
    Person p = (Person) clazz.newInstance();

    /*
    1.获取指定的某个方法
    getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
    */
    Method show = clazz.getDeclaredMethod("show", String.class);
    //2.保证当前方法是可访问的
    show.setAccessible(true);

    /*
    3. 调用方法的invoke():参数1：方法的调用者-对象  参数2：给方法形参赋值的实参
    invoke()的返回值即为对应类中调用的方法的返回值。
    */
    Object returnValue = show.invoke(p,"CHN"); //String nation = p.show("CHN");
    System.out.println(returnValue);

    System.out.println("*************如何调用静态方法*****************");

    // private static void showDesc()

    Method showDesc = clazz.getDeclaredMethod("showDesc");
    showDesc.setAccessible(true);
    //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
    //Object returnVal = showDesc.invoke(null);
    Object returnVal = showDesc.invoke(Person.class);//静态方法调用者是当前类
    System.out.println(returnVal);//null

}

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

@Test
public void testConstructor() throws Exception {
    Class clazz = Person.class;

    //private Person(String name)
    /*
    1.获取指定的构造器
    getDeclaredConstructor():参数：指明构造器的参数列表
    */
    Constructor constructor = clazz.getDeclaredConstructor(String.class);

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

    //3.调用此构造器创建运行时类的对象
    Person per = (Person) constructor.newInstance("Tom");
    System.out.println(per);
}

Java日记(day24)--Java反射机制