Java-基础-03-反射

凤邪摩羯
153 阅读6分钟

1 反射（Reflect）

反射之中包含了一个「反」字，所以了解反射我们先从「正」开始。
一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。
反射则是一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。这时候，我们使用 JDK 提供的反射 API 进行反射调用。反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。
Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的內部信息，并能直接操作任意对象的内部属性及方法。

  • Java反射机制主要提供了以下功能：
  1. 在运行时构造任意一个类的对象
  2. 在运行时获取任意一个类所具有的成员变量和方法
  3. 在运行时调用任意一个对象的方法（属性）

Java 是一门面向对象的语言。在面向对象的世界里，万事万物皆对象，既然万事万物皆对象，那么我们的类是不是对象呢？我们写的每一个类都可以看成一个对象，是 java.lang.Class 类的对象。每一个类对应的Class放在哪里呢？当我们写完一个类的Java文件，编译成class文件的时候，编译器都会将这个类的对应的class对象放在class文件的末尾。里面都保存了些什么？大家可以理解保存了类的元数据信息，一个类的元数据信息包括什么？有哪些属性，方法，构造器，实现了哪些接口等等，那么这些信息在Java里都有对应的类来表示。

1.1 Class类

Class是一个类，封装了当前对象所对应的类的信息

一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是Class，它应该有类名，属性，方法，构造器等。Class是用来描述类的类。
Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。

对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例

image.png

1.2 获取Class对象

 

image.png

获取Class对象的三种方式

1.通过类名获取 类名.class   
2.通过对象获取 对象名.getClass()

  1. 通过全类名获取 Class.forName(全类名) classLoader.loadClass(全类名)
  • 直接获取某一个对象的 class
Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

 

  • 使用 Class 类的 forName 静态方法
public void jumpB() {
startActivity(new Intent(this,BActivity.class));
}
  • 调用某个对象的 getClass() 方法
StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

1.3 获取类名（通过 class 对象）

image.png

1.4 获取Field、Method、构造方法（通过 class 对象）

image.png

当我们从类中获取了一个方法后，我们就可以用这个方法对象来调用invoke() 方法:

        method = clazz.getDeclaredMethod("setAge", int.class)    
        method.setAccessible(true);   
 	method.invoke(obje, 18);

 

1. 5  创建类的实例（通过 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);

 

2 反射获取泛型的真实类型

当我们对一个泛型类进行反射时，需要得到泛型中的真实数据类型，来完成如json反序列化的操作。此时需要通

过Type 体系来完成。Type 接口包含了一个实现类(Class)和四个实现接口，他们分别是：

TypeVariable

泛型类型变量。可以泛型上下限等信息；

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

具体的泛型类型，可以获得元数据中泛型签名类型(泛型真实类型)

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

当需要描述的类型是泛型类的数组时，比如List[],Map[]，此接口会作为Type的实现。

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());
    }
}

WildcardType

通配符泛型，获得上下限信息；

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

 

3 json 反序列化

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

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

 

 

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 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 +
                '}';
    }
}
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);
    //为什么TypeToken要定义为抽象类？
    Response<Data> resp = gson.fromJson(json, new TypeToken<Response<Data>>() {
    }.getType());
    System.out.println(resp.data.result);
}

 

4 Viewbinding 的基类定义：

public abstract class CommonActivity<T extends ViewBinding> extends UIActivity  {


    protected T mBinding;

    /**
     * 重写ViewBinding初始化方法,通过反射方式获取对应的ViewBinding
     */
    @Override
    protected void initViewBinding() {
        //这行代码获取当前类的泛型父类。例如，如果当前类继承了一个带泛型的类，如 BaseActivity<T>，这将返回泛型父类 BaseActivity<T>。
        Type superclass = getClass().getGenericSuperclass();
        try {
            //这里通过 ParameterizedType 提取父类的第一个泛型参数的实际类型，也就是 ViewBinding 的具体类型 T。
            Class<?> aClass = (Class<?>) ((ParameterizedType) superclass).getActualTypeArguments()[0];
            //通过反射获取 inflate 方法，该方法通常用于将 XML 布局文件解析成相应的 ViewBinding 对象。
            Method method = aClass.getDeclaredMethod("inflate", LayoutInflater.class);
            //使用反射调用 inflate 方法，传入 LayoutInflater 实例，从而获得 ViewBinding 对象。然后，通过 setContentView() 方法将根视图设置为活动的内容视图。
            mBinding = (T) method.invoke(null, getLayoutInflater());
            setContentView(mBinding.getRoot());
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
avatar
文章
阅读
粉丝