Java 反射

作者: wuchao226 | 来源:发表于2021-01-06 15:56 被阅读0次

JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。

Java反射机制主要提供了以下功能：

在运行时构造任意一个类的对象
在运行时获取或者修改任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法（属性）

Class

反射始于 Class，Class 是一个类，封装了当前对象所对应的类的信息。一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是 Class，它应该有类名，属性，方法，构造器等。Class是用来描述类的类。

Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例。

获取 Class 对象的四种方式

如果我们动态获取到这些信息，我们需要依靠 Class 对象。Class 类对象将一个类的方法、变量等信息告诉运行的程序。Java 提供了四种方式获取 Class 对象:

知道具体类的情况下可以使用：即直接获取某一个对象的 class

Class alunbarClass = TargetObject.class;
Class<?> klass = int.class; 
Class<?> classInt = Integer.TYPE;

但是我们一般是不知道具体类的，基本都是通过遍历包下面的类来获取 Class 对象，通过此方式获取 Class 对象不会进行初始化

通过 Class.forName() 传入类的路径获取：

Class alunbarClass1 = Class.forName("cn.study.TargetObject");

Class.forName(className) 方法：

public static Class<?> forName(String className) throws ClassNotFoundException {
   Class<?> caller = Reflection.getCallerClass();
   return forName(className, true, ClassLoader.getClassLoader(caller));
}

第2个 boolean 参数表示类是否需要初始化，Class.forName(className) 默认是需要初始化。
一旦初始化，就会触发目标对象的 static 块代码执行，static 参数也会被再次初始化。

通过对象实例 instance.getClass()获取：即调用某个对象的 getClass() 方法

StringBuilder str = new StringBuilder("123"); 
Class<?> klass = str.getClass();

通过类加载器xxxClassLoader.loadClass()传入类路径获取

class clazz = ClassLoader.LoadClass("cn.study.TargetObject");

通过类加载器获取 Class 对象不会进行初始化，意味着不进行包括初始化等一些列步骤，静态块和静态对象不会得到执行。

判断是否为某个类的实例

一般地，我们用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中 Class 对象的 isInstance()方法来判断是否为某个类的实例，它是一个 native 方法：

public native boolean isInstance(Object obj);

使用方法：

if(B.Class.isInstance(a)){

}

表示：a 是否能强转为 B 类型

判断是否为某个类的类型：

public boolean isAssignableFrom(Class<?> cls)

isAssignableFrom 是 Class 类的方法，主要用于判断此 Class 对象表示的类或接口是否与指定的 Class 参数表示的类或接口相同，或者是它们的超类或超接口。

创建实例

通过反射来生成对象主要有两种方式。

使用 Class 对象的 newInstance() 方法来创建 Class 对象对应类的实例。

Class<?> c = String.class; 
Object str = c.newInstance();

先通过 Class 对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance() 方法来创建实例。这种方法可以用指定的构造器构造类的实例。

//获取String所对应的Class对象 
Class<?> c = String.class; 
//获取String类带一个String参数的构造器 
Constructor constructor = c.getConstructor(String.class); 
//根据构造器创建实例 
Object obj = constructor.newInstance("23333"); 
System.out.println(obj);

获取构造器信息

获取构造器的方法

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的public构造函数(包括父类） 
Constructor[] getConstructors() -- 获得类的所有公共构造函数 
Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(包括私有) 
Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获取类构造器的用法与上述获取方法的用法类似。主要是通过 Class 类的 getConstructor 方法得到 Constructor 类的一个实例，而 Constructor 类有一个 newInstance 方法可以创建一个对象实例:

public T newInstance(Object ... initargs)

获取类的成员变量（字段）信息

获得字段信息的方法：

Field getField(String name) -- 获得命名的公共字段 
Field[] getFields() -- 获得类的所有公共字段 
Field getDeclaredField(String name) -- 获得类声明的命名的字段
Field[] getDeclaredFields() -- 获得类声明的所有字段

调用方法

获得方法信息的方法

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法 
Method[] getMethods() -- 获得类的所有公共方法 
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法 
Method[] getDeclaredMethods() -- 获得类声明的所有方法

当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。 invoke 方法的原型为:

public Object invoke(Object obj, Object... args)

利用反射创建数组

数组在 Java 里是比较特殊的一种类型，它可以赋值给一个 Object Reference 其中的 Array 类为 java.lang.reflect.Array 类。我们通过 Array.newInstance() 创建数组对象，它的原型是:

public static Object newInstance(Class<?> componentType, int length);

反射获取泛型真实类型

当我们对一个泛型类进行反射时，需要得到泛型中的真实数据类型，来完成如 json 反序列化的操作。此时需要通过 Type 体系来完成。 Type 接口包含了一个实现类(Class)和四个实现接口，他们分别是：

TypeVariable
泛型类型变量。可以获得泛型上下限等信息；
ParameterizedType
具体的泛型类型，可以获得元数据中泛型签名类型(泛型真实类型)
GenericArrayType
当需要描述的类型是泛型类的数组时，比如List[],Map[]，此接口会作为Type的实现。
WildcardType
通配符泛型，获得上下限信息；

TypeVariable

/**
 * TypeVariable
 * 泛型变量, 泛型信息在编译时会被转换为一个特定的类型, 而TypeVariable就是用来反映在JVM编译该泛型前的信息.
 * TypeVariable就是<T>、<C extends Collection>中的变量T、C本身; 它有如下方法:
 *
 * Type[] getBounds(): 获取类型变量的上边界, 若未明确声明上边界则默认为Object
 * D getGenericDeclaration(): 获取声明该类型变量的类型
 * String getName(): 获取在源码中定义时的名字
 * 注意:
 *
 * 类型变量在定义的时候只能使用extends进行(多)边界限定, 不能用super;
 *
 * 为什么边界是一个数组? 因为类型变量可以通过&进行多个上边界限定，因此上边界有多个
 *
 * @param <K>
 * @param <V>
 */
public class TestType<K extends Comparable & Serializable, V> {
  K key;
  V value;

  public static void main(String[] args) throws Exception {
    // 获取字段的类型
    Field fk = TestType.class.getDeclaredField("key");
    Field fv = TestType.class.getDeclaredField("value");

    TypeVariable keyType = (TypeVariable) fk.getGenericType();
    TypeVariable valueType = (TypeVariable) fv.getGenericType();
    // getName 方法
    System.out.println(keyType.getName());                 // K
    System.out.println(valueType.getName());               // V
    // getGenericDeclaration 方法
    System.out.println(keyType.getGenericDeclaration());   // class com.test.TestType
    System.out.println(valueType.getGenericDeclaration()); // class com.test.TestType
    // getBounds 方法
    System.out.println("K 的上界:");                        // 有两个
    for (Type type : keyType.getBounds()) {                // interface java.lang.Comparable
      System.out.println(type);                          // interface java.io.Serializable
    }
    System.out.println("V 的上界:");                        // 没明确声明上界的, 默认上界是 Object
    for (Type type : valueType.getBounds()) {              // class java.lang.Object
      System.out.println(type);
    }
  }
}

ParameterizedType

/**
 * ParameterizedType
 * 具体的泛型类型, 如Map<String, String>
 * 有如下方法:
 * <p>
 * Type getRawType(): 返回承载该泛型信息的对象, 如上面那个Map<String, String>承载范型信息的对象是Map
 * Type[] getActualTypeArguments(): 返回实际泛型类型列表, 如上面那个Map<String, String>实际范型列表中有两个元素, 都是String
 */
public class TestType {
  Map<String, String> map;

  public static void main(String[] args) throws Exception {
    Field f = TestType.class.getDeclaredField("map");
    System.out.println(f.getGenericType());   // java.util.Map<java.lang.String, java.lang.String>                            
    ParameterizedType pType = (ParameterizedType) f.getGenericType();
    System.out.println(pType.getRawType());   // interface java.util.Map
    for (Type type : pType.getActualTypeArguments()) {
      System.out.println(type); // 打印两遍: class java.lang.String
    }
  }
}

GenericArrayType

/**
 * GenericArrayType
 * 泛型数组,组成数组的元素中有范型则实现了该接口; 它的组成元素是ParameterizedType或TypeVariable类型,它只有一个方法:
 * <p>
 * Type getGenericComponentType(): 返回数组的组成对象
 *
 * @param <T>
 */
public class TestType<T> {

  List<String>[] lists;

  public static void main(String[] args) throws Exception {
    Field f = TestType.class.getDeclaredField("lists");
    GenericArrayType genericType = (GenericArrayType) f.getGenericType();
    System.out.println(genericType.getGenericComponentType()); // java.util.List<java.lang.String>
  }
}

WildcardType

/**
 * WildcardType
 * 该接口表示通配符泛型, 比如? extends Number 和 ? super Integer 它有如下方法:
 *
 * Type[] getUpperBounds(): 获取范型变量的上界
 * Type[] getLowerBounds(): 获取范型变量的下界
 * 注意:
 *
 * 现阶段通配符只接受一个上边界或下边界, 返回数组是为了以后的扩展, 实际上现在返回的数组的大小是1
 */
public class TestType {
  private List<? extends Number> a;  // 上限
  private List<? super String> b;     //下限

  public static void main(String[] args) throws Exception {
    Field fieldA = TestType.class.getDeclaredField("a");
    Field fieldB = TestType.class.getDeclaredField("b");
    // 先拿到范型类型
    ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType();
    ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType();
    // 再从范型里拿到通配符类型
    WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
    WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0];
    // 方法测试
    System.out.println(wTypeA.getUpperBounds()[0]);   // class java.lang.Number
    System.out.println(wTypeB.getLowerBounds()[0]);   // class java.lang.String
    // 看看通配符类型到底是什么, 打印结果为: ? extends java.lang.Number
    System.out.println(wTypeA);
  }
}

Gson反序列化

public class TypeRefrence<T> {
  Type type;
  T t;

  protected TypeRefrence() {
    //获得泛型类型
    Type genericSuperclass = getClass().getGenericSuperclass();
    ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
    //因为类泛型可以定义多个  A<T,E..> 所以是个数组
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    type = actualTypeArguments[0];
  }

  public Type getType() {
    return type;
  }
}

package com.wuc.test.reflect;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

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

public class Deserialize {

  static class Response<T> {
    T data;
    int code;
    String message;

    @Override
    public String toString() {
      return "Response{" +
          "data=" + data +
          ", code=" + code +
          ", message='" + message + '\'' +
          '}';
    }

    public Response(T data, int code, String message) {

      this.data = data;
      this.code = code;
      this.message = message;
    }
  }

  static class Data {
    String result;

    public Data(String result) {
      this.result = result;
    }

    @Override
    public String toString() {
      return "Data{" +
          "result=" + result +
          '}';
    }
  }

  static class ChildTypeRefrence {
    Response<Data> t;
  }

  public static void main(String[] args) {
    Response<Data> dataResponse = new Response(new Data("数据"), 1, "成功");

    Gson gson = new Gson();
    String json = gson.toJson(dataResponse);
    System.out.println(json);

    //反序列化......

    /**
     *  有花括号： 代表是匿名内部类，创建一个匿名内部类的实例对象
     *  没花括号：创建实例对象
     */
    Type type = new TypeRefrence<Response<Data>>() {}.getType();

    System.out.println(type);
    Response<Data> response = gson.fromJson(json, type);

    // 为什么TypeToken要定义为抽象类？
    Response<Data> resp = gson.fromJson(json, new TypeToken<Response<Data>>() {}.getType());

    System.out.println(response.data.getClass());
    System.out.println(resp.data.getClass());
  }
}

在进行 GSON 反序列化时，存在泛型时，可以借助 TypeToken 获取 Type 以完成泛型的反序列化。但是为什么 TypeToken 要被定义为抽象类呢？

因为只有定义为抽象类或者接口，这样在使用时，需要创建对应的实现类，此时确定泛型类型，编译才能够将泛型signature信息记录到 Class 元数据中。

实例

实例一：注解+反射自动完成 findViewById 的功能

创建 InjectView 注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectView {
  @IdRes int value();
}

public class InjectUtils {
  public static void injectView(Activity activity) {
    Class<? extends Activity> cls = activity.getClass();
    //获取此类所有成员
    Field[] declaredFields = cls.getDeclaredFields();
    for (Field field : declaredFields) {
      // 判断属性是否被 InjectView 注解声明
      if (field.isAnnotationPresent(InjectView.class)) {
        InjectView injectView = field.getAnnotation(InjectView.class);
        // 获取注解中设置的id
        int id = injectView.value();
        View view = activity.findViewById(id);
        field.setAccessible(true);// 设置访问权限，允许操作 private 的属性
        try {
          // 反射设置 属性的值
          field.set(activity, view);
        } catch (IllegalAccessException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

在 Activity 中的使用

public class InjectActivity extends AppCompatActivity {

  @InjectView(R.id.tv)
  private AppCompatTextView tv;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_inject);
    InjectUtils.injectView(this);
    tv.setText("结果展示");
  }
}

实现效果：

实例二：通过自定义注解与反射实现页面跳转的参数注入

实现以下功能：

InjectActivity 跳转到 SecondActivity 时使用 Intent 携带参数:
new Intent().putExtra("name","Lance").putExtra("boy",true);

SecondActivity 利用反射实现自动注入获取参数：
@Autowired
public String name;
@Autowired("boy")
public boolean isBoy

利用反射实现自动注入：
name = getIntent().getStringExtra("name"); //根据属性名获取值
isBoy = getIntent().getBooleanExtra("boy"); //根据注解元素值获取

创建实现 Serializable 的 UserSerializable 类

public class UserSerializable implements java.io.Serializable {
  String name;

  public UserSerializable(String name) {
    this.name = name;
  }

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

创建实现 Parcelable 的 UserParcelable 类

public class UserParcelable implements Parcelable {
  String name;

  public UserParcelable(String name) {
    this.name = name;
  }

  protected UserParcelable(Parcel in) {
    name = in.readString();
  }

  @Override
  public void writeToParcel(Parcel dest, int flags) {
    dest.writeString(name);
  }

  @Override
  public int describeContents() {
    return 0;
  }

  public static final Creator<UserParcelable> CREATOR = new Creator<UserParcelable>() {
    @Override
    public UserParcelable createFromParcel(Parcel in) {
      return new UserParcelable(in);
    }

    @Override
    public UserParcelable[] newArray(int size) {
      return new UserParcelable[size];
    }
  };

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

创建 Autowired 注解：

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.SOURCE)
public @interface Autowired {
  String value() default "";
}

创建 InjectUtils 类，通过注解和反射获取参数

public class InjectUtils {
  public static void injectAutowired(Activity activity) {
    Class<? extends Activity> cls = activity.getClass();
    //获得数据
    Intent intent = activity.getIntent();
    Bundle extras = intent.getExtras();
    if (extras == null) {
      return;
    }
    //获得此类所有成员
    Field[] declaredFields = cls.getDeclaredFields();
    for (Field field : declaredFields) {
      // 判断属性是否被 Autowired 注解声明
      if (field.isAnnotationPresent(Autowired.class)) {
        Autowired autowired = field.getAnnotation(Autowired.class);
        // 获得 key
        String key = TextUtils.isEmpty(autowired.value()) ? field.getName() : autowired.value();
        if (extras.containsKey(key)) {
          Object obj = extras.get(key);
          // todo Parcelable数组类型不能直接设置，其他的都可以.
          //获得数组单个元素类型
          Class<?> componentType = field.getType().getComponentType();
          //当前属性是数组并且是 Parcelable（子类）数组
          if (field.getType().isArray() &&
              Parcelable.class.isAssignableFrom(componentType)) {
            Object[] objs = (Object[]) obj;
            //创建对应类型的数组并由objs拷贝
            Object[] objects = Arrays.copyOf(objs, objs.length, (Class<? extends Object[]>) field.getType());
            obj = objects;
          }
          field.setAccessible(true);
          try {
            field.set(activity, obj);
          } catch (IllegalAccessException e) {
            e.printStackTrace();
          }
        }
      }
    }
  }
}

在 Activity 中的使用

public class InjectActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_inject);
 
    ArrayList<UserParcelable> userParcelableList = new ArrayList<>();

    userParcelableList.add(new UserParcelable("Jett"));
    Intent intent = new Intent(this, SecondActivity.class)
        .putExtra("name", "Lance")
        .putExtra("attr", "帅")
        .putExtra("array", new int[] { 1, 2, 3, 4, 5, 6 })
        .putExtra("userParcelable", new UserParcelable("Lance"))
        .putExtra("userParcelables", new UserParcelable[] { new UserParcelable("Alvin") })
        .putExtra("users", new UserSerializable[] { new UserSerializable("Jett") })
        .putExtra("strs", new String[] { "1", "2" })
        .putParcelableArrayListExtra("userParcelableList", userParcelableList);
    startActivity(intent);
  }
}

SecondActivity 接收参数：

public class SecondActivity extends AppCompatActivity {

  @Autowired
  String name;

  @Autowired("attr")
  String attr;

  @Autowired
  int[] array;

  @Autowired
  UserParcelable userParcelable;

  @Autowired
  UserParcelable[] userParcelables;

  @Autowired
  List<UserParcelable> userParcelableList;

  @Autowired("users")
  UserSerializable[] userSerializables;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_second);
    InjectUtils.injectAutowired(this);
    Log.i("SecondActivity", toString());
  }

  @Override
  public String toString() {
    return "SecondActivity{" +
        "name='" + name + '\'' + ",\n" +
        " attr='" + attr + '\'' + ",\n" +
        " array=" + Arrays.toString(array) + ",\n" +
        " userParcelable=" + userParcelable + ",\n" +
        " userParcelables=" + Arrays.toString(userParcelables) + ",\n" +
        " userParcelableList=" + userParcelableList + ",\n" +
        " userSerializables=" + Arrays.toString(userSerializables) + "\n" +
        '}';
  }
}

效果图：

实例三：利用反射、注解、动态代理实现 OnClick 事件的自动注入

@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventType {
  Class listenerType();
  String listenerSetter();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@EventType(listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener")
public @interface OnClick {
  int[] value();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@EventType(listenerType = View.OnLongClickListener.class, listenerSetter = "setOnLongClickListener")
public @interface OnLongClick {
  int[] value();
}

public class InjectUtils {

  public static void injectEvent(Activity activity) {
    Class<? extends Activity> activityClass = activity.getClass();
    // 获得类声明的所有方法
    Method[] declaredMethods = activityClass.getDeclaredMethods();
    for (Method method : declaredMethods) {
      // 获得方法上所有注解
      Annotation[] annotations = method.getAnnotations();
      for (Annotation annotation : annotations) {
        // 注解类型
        Class<? extends Annotation> annotationType = annotation.annotationType();
        // 判断属性是否被 EventType 注解声明
        if (annotationType.isAnnotationPresent(EventType.class)) {
          EventType eventType = annotationType.getAnnotation(EventType.class);
          // OnClickListener.class
          Class listenerType = eventType.listenerType();
          //setOnClickListener
          String listenerSetter = eventType.listenerSetter();
          try {
            // 不需要关心到底是OnClick 还是 OnLongClick
            Method valueMethod = annotationType.getDeclaredMethod("value");
            int[] viewIds = (int[]) valueMethod.invoke(annotation);
            valueMethod.setAccessible(true);

            ListenerInvocationHandler<Activity> handler = new ListenerInvocationHandler(activity, method);
            Object listenerProxy = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class[] { listenerType }, handler);
            // 遍历注解的值
            for (int viewId : viewIds) {
              // 获得当前activity的view（赋值）
              View view = activity.findViewById(viewId);
              // 获取指定的方法(不需要判断是Click还是LongClick)
              // 如获得：setOnClickLisnter方法，参数为OnClickListener
              // 获得 setOnLongClickLisnter，则参数为OnLongClickLisnter
              Method setter = view.getClass().getMethod(listenerSetter, listenerType);
              // 执行方法
              setter.invoke(view, listenerProxy);//执行setOnclickListener里面的回调 onclick方法
            }
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
    }
  }

  /**
   * 还可能在自定义view注入，所以是泛型： T = Activity/View
   *
   * @param <T>
   */
  static class ListenerInvocationHandler<T> implements InvocationHandler {

    private Method method;
    private T target;

    public ListenerInvocationHandler(T target, Method method) {
      this.method = method;
      this.target = target;
    }

    @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      return this.method.invoke(target, args);
    }
  }
}

动态代理InvocationHandler和Proxy

在 Activity 中使用

public class MainActivity extends AppCompatActivity {

  private static final String TAG = "MainActivity";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    InjectUtils.injectEvent(this);
  }

  @OnClick({ R.id.btn1, R.id.btn2 })
  public void click(View view) {
    switch (view.getId()) {
      case R.id.btn1:
        Log.i(TAG, "click: 按钮1");
        break;
      case R.id.btn2:
        Log.i(TAG, "click: 按钮2");
        break;
    }
  }

  @OnLongClick({ R.id.btn1, R.id.btn2 })
  public boolean longClick(View view) {
    switch (view.getId()) {
      case R.id.btn1:
        Log.i(TAG, "longClick: 按钮1");
        break;
      case R.id.btn2:
        Log.i(TAG, "longClick: 按钮2");
        break;
    }
    return false;
  }
}

效果图：

Java 反射

Class

获取 Class 对象的四种方式

判断是否为某个类的实例

创建实例

获取构造器信息

获取类的成员变量（字段）信息

调用方法

利用反射创建数组

反射获取泛型真实类型

TypeVariable

ParameterizedType

GenericArrayType

WildcardType

Gson反序列化

实例

实例一：注解+反射自动完成 findViewById 的功能

实例二：通过自定义注解与反射实现页面跳转的参数注入

实例三：利用反射、注解、动态代理实现 OnClick 事件的自动注入

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java 反射

Class

获取 Class 对象的四种方式

判断是否为某个类的实例

创建实例

获取构造器信息

获取类的成员变量（字段）信息

调用方法

利用反射创建数组

反射获取泛型真实类型

TypeVariable

ParameterizedType

GenericArrayType

WildcardType

Gson反序列化

实例

实例一：注解+反射 自动完成 findViewById 的功能

实例二：通过自定义注解与反射实现页面跳转的参数注入

实例三：利用反射、注解、动态代理实现 OnClick 事件的自动注入

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

实例一：注解+反射自动完成 findViewById 的功能