java.lang.Class 类是 Java 反射机制的基础
通过 Class 类可以获得关于一个类的相关信息。
- Class 是一个 java 类，也继承了Object（Class是Object的直接子类）
- Class 只是个类，只不过名字比较特殊
- Class 是一个 java 中的泛型类型，<? extends Object>
public final class Class<T> 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<? extends Customer> 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 <> 里可以为 <?>, <Customer>, <? extends Customer>
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<String>
// 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<T1, T2> { // 指定2个泛型
}
// UserDao 继承泛型 Dao
class UserDao extends Dao<Customer, String> { // 指定泛型的2个类型
}
class com.shuai.reflect.UserDao
com.shuai.reflect.Dao<com.shuai.reflect.Customer, java.lang.String>
class com.shuai.reflect.Customer
class java.lang.String
