Java Class类与反射机制

java.lang.Class 类是 Java 反射机制的基础
通过 Class 类可以获得关于一个类的相关信息。

• Class 是一个 java 类，也继承了Object（Class是Object的直接子类）
• Class 只是个类，只不过名字比较特殊
• Class 是一个 java 中的泛型类型，

public final class Class implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement { ... }

1. 获取Class对象的3种方式

• 对象.getClass() 方法
• 类名.getClass() 方法
• Class.forName("包名+类名")
• Java一切是对象，平常定义的类也是对象，属于Class类的对象

private static void getClassTest() {
    // 1.对象.getClass() 方法
    Customer c = new Customer();
    Class c1 = c.getClass();
    System.out.println("c1: " + c1);

    // 2.类名.getClass() 方法
    Class c2 = Customer.class;
    System.out.println("c2: " + c2);

    // 3.Class.forName("包名+类名")
    Class c3 = null;
    try {
        c3 = Class.forName("com.shuai.advance.Customer"); // ClassNotFoundException
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.out.println("c3: " + c3);
}

c1: class com.shuai.advance.Customer
c2: class com.shuai.advance.Customer
c3: class com.shuai.advance.Customer

注意：Class <> 里可以为 , ,

2. Class对象获取构造函数

• 获取构造器：Class对象.getDeclaredConstructors()
• 获取参数列表：Constructor对象.getParameterTypes()
• Constructor类新建对象：Constructor对象.newInstance("tom", 40);
• Java一切是对象，构造器函数就是Constructor类的对象，
  所以Constructor类对象可以像构造器一下新建对象实例。

private static void getConstructors(Class c) {

    // 与Class一样，Constructor是构造器的反射类
    Constructor[] constructors = c.getDeclaredConstructors(); // 获取类中定义的构造器数组
    System.out.println("构造器个数: " + constructors.length);

    // 打印每个构造器
    int i = 1;
    for (Constructor con : constructors) {
        System.out.println("构造器" + i + ": " + con);

        // 打印参数类型
        Class[] params = con.getParameterTypes();
        System.out.println("参数个数: " + params.length);
        if (params.length != 0) {
            System.out.println("参数类型");
            for (Class p : params) {
                System.out.println(p);
            }
        }

        // 使用包含2个参数的构造器
        if (params.length == 2) {
            Customer customer = null;
            try {
                customer = (Customer) con.newInstance("tom", 40);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("采用构造器类新建对象: " + customer);
        }
        i++;
    }
}

构造器个数: 2
构造器1: public com.shuai.advance.Customer()
参数个数: 0
构造器2: public com.shuai.advance.Customer(java.lang.String,int)
参数个数: 2
参数类型
class java.lang.String
int
采用构造器类新建对象: Customer{name='tom', age=40}

3. Class对象获取类定义的方法

• 获取方法：Class.getDeclaredMethods()
• 得到方法之后也可以用 getDeclaredMethods() 方法获取参数列表
• Method类调用方法 invoke 函数，可变参数列表
• Java一切是对象，类定义的方法就是Method类的对象
  所以Method类可以像普通函数一样设置参数列表调用方法（invoke函数）

private static void getMethods(Class c) {
    // Method是函数的反射类
    Method[] methods = c.getDeclaredMethods(); // 类中定义的方法
    System.out.println("方法总数: " + methods.length);

    Customer customer = new Customer(); // 新建类

    // 打印类中定义的方法
    for (Method m : methods) {
        System.out.println(m);

        // 调用类的setName方法实例化对象
        if (m.getName().equals("setName")) {
            try {
                m.invoke(customer, "Tom"); // 调用方法 invoke函数采用的是可变参数，因为不确定函数有几个参数
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    System.out.println(customer);
}

方法总数: 8
public boolean com.shuai.advance.Customer.equals(java.lang.Object)
public java.lang.String com.shuai.advance.Customer.toString()
public int com.shuai.advance.Customer.hashCode()
public int com.shuai.advance.Customer.compareTo(java.lang.Object)
public java.lang.String com.shuai.advance.Customer.getName()
public void com.shuai.advance.Customer.setName(java.lang.String)
public void com.shuai.advance.Customer.setAge(int)
public int com.shuai.advance.Customer.getAge()

Customer{name='Tom', age=0} // 调用类的setName方法实例化对象

4. Class对象获取类定义的属性

private static void getFields(Class c) {
    // Field是属性的反射类
    Field[] fields = c.getDeclaredFields();
    System.out.println("属性个数: " + fields.length);
    for (Field f : fields) {
        System.out.println(f);
    }
    System.out.println();
}

属性个数: 2
private java.lang.String com.shuai.advance.Customer.name
private int com.shuai.advance.Customer.age

5. 反射机制获取 泛型 被 实际传递的类

package com.shuai.reflect;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class MyRef {

    public static void main(String[] args) {
        UserDao u = new UserDao();
        Class c = u.getClass();
        System.out.println(c);

        // ParameterizedType represents a parameterized type such as Collection
        // parameterized type 含参数类型
        ParameterizedType pt = (ParameterizedType) c.getGenericSuperclass(); // 获得c继承的父类Dao
        System.out.println(pt);

        // UserDao继承Dao时 指定泛型的2个类型
        for (Type t : pt.getActualTypeArguments()) {
            System.out.println(t);
        }
    }
}

// 自定义泛型Dao类
class Dao { // 指定2个泛型
}

// UserDao 继承泛型 Dao
class UserDao extends Dao { // 指定泛型的2个类型
}

class com.shuai.reflect.UserDao
com.shuai.reflect.Dao
class com.shuai.reflect.Customer
class java.lang.String