JAVA ParameterizedType的用处

ParameterizedType 接口继承自Type ，

public interface ParameterizedType extends Type {

Type 在Java中是所有类型（如 原始类型、参数化类型、数组类型、类型变量和基元类型）的通用的超级接口。而ParameterizedType 表示的就是参数化类型，如：如Collection＜String＞就是参数化类型。

可以通过Class.getGenericSuperclass() 和 反射中field.getGenericType() 方法获得ParameterizedType 对象。

ParameterizedType 貌似没有特别的用处，但是 ParameterizedType.getActualTypeArguments(); 方法在某些地方用处很大，其返回值为 Type[] 是当前参数化类型的参数类型数组。举个例子：

class Person {
    List<Integer> integerList;
    List<Double> doubleList;
}
public class Main {
    public static void main(String[] args) {
        Field[] fields = Person.class.getDeclaredFields();
        for (Field field : fields) {
            if (field.getGenericType() instanceof ParameterizedType) {
                ParameterizedType genericType = (ParameterizedType) field.getGenericType();
                Type[] arguments = genericType.getActualTypeArguments();
                for (Type type : arguments) {
                    System.out.println(type);
                }
            }
        }
    }
}

结果：
	java.lang.Integer
	java.lang.Double

上面的例子使用getGenericType获取当前的类的参数类型，如果调用getGenericSuperclass？ 举个列子：

public class Person<T, E> {
}

public class Student extends Person<Student, Integer> {

    public static void main(String[] args) {
        Class clazz = Student.class;
        //获取带泛型的类型
        ParameterizedType superclass = (ParameterizedType) clazz.getGenericSuperclass();
        Type[] arguments = superclass.getActualTypeArguments();
        for (Type argument : arguments) {
            System.out.println(argument);
        }
    }
    
}

结果：
	Student
	Integer

这样我们就可以延伸出一种用法，当我们的代码中出现大量同“类”对象时（这些对象有很多相同的操作），那么我们就可以创建一个基类，在基类中实现所有相同操作，并在抽象类基类中把这些同“类”对象中不同属性定义为泛型参数，然后使用反射的方式获取每个类中被定义为泛型的属性，这样当我们再使用这些同“类”对象的时候，可以直接继承这个基类，直接调用基类中的相同代码，极大的减少了冗余代码。而基于这个泛型属性的不相同的操作，自定义即可。 这段话好像有点绕，举个例子：

我们知道再android 开发中，总会出现多个 Activity，都是继承AppCompatActivity，且每个Activity 都会生成一个ViewBinding，基于ViewBinding做一系列操作，而这个**ViewBinding每个activity对象各不相同，但是每个 **activity 都会有对于actionbar 等等相同的操作，那么我们就可以生成一个基础activity: BaseActivity，然后把ViewBinding属性作为泛型参数，并用反射实现这个泛型属性 **ViewBing ,再实现一系列的重复代码：

public abstract class BaseActivity<T extends ViewBinding> extends AppCompatActivity {

    private static BaseActivity instances = null;
    
    protected T viewBinding;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        instances = this;
        
  ...重复操作实现...
  
       // 反射获取viewBinding
       //com.gensong.visualalgorithm.base.BaseActivity<com.gensong.visualalgorithm.databinding.ActivitySplashBinding>
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        //class com.gensong.visualalgorithm.databinding.ActivitySplashBinding
        Class cls = (Class) type.getActualTypeArguments()[0];
        try {
            Method inflate = cls.getDeclaredMethod("inflate", LayoutInflater.class);
            viewBinding = (T) inflate.invoke(null, getLayoutInflater());
            setContentView(viewBinding.getRoot());
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
  ...
    }

再创建Activity的时候就可以直接继承这个BaseActivity 调用重复代码：

public class MainActivity extends BaseActivity<ActivityMainBinding> {

   ...调用重复代码...
	... 使用viewBinding 调用自身代码...
    }