懒人之道——使用泛型Class优雅的消除模板代码
Class作为实现反射功能的类，在开发中经常会用到，最常见的就是启动一个Activity：
startActivity(new Intent(this,AnotherActivity.class))。众所周知，获取某一个类的Class有如下三种方法：
Class d1 = Demo.class;
Class d2 = new Demo().getClass();
Class d3 = Class.forName("com.xxx.xxx.Demo);
然而，当Class遇上泛型后，事情就变得不是那么简单了。当你需要使用泛型的Class时，你可能会略微感到一丝蛋疼：无法通过上面三种方法获取到泛型的Class，因为泛型它不是一个确定的具体的类，自然就无法通过上面方法获取到Class。
举个栗子
假设我们有这样一个需求：用鱼缸养鱼。首先定义一个接口鱼：
interface Fish {
String swim(); //鱼的通用动作游泳
}
鱼有很多种类，我们创建两种鱼：
public class GoldFish implements Fish{
@Override
public String swim() {
return "金鱼优雅的游动";
}
public void beautiful(){
System.out.println("金鱼很漂亮"); //金鱼特有的属性
}
}
//鱼可杀不可辱，兄弟你可以钓我但你不能侮辱我是草鱼
public class GrassFish implements Fish{
@Override
public String swim() {
return "细纹狮子鱼迅速的游动";
}
public void agile(){
System.out.println("细纹狮子鱼非常敏捷"); //细纹狮子鱼特有的属性
}
}
好鱼有了，下面我们来创建鱼缸，鱼缸也有不同材质的，所以将鱼缸定义为抽象类，并且创建抽象方法abstract String material()：
public abstract class FishTank<F extends Fish> {
F fish;
public FishTank() {
show();
}
private void show(){
System.out.println(material() + fish.swim());
}
abstract String material();
}
鱼缸里要有鱼，但是鱼缸里又不一定会养什么鱼，因此为鱼缸添加了泛型<F extends Fish>，并声明鱼的变量F fish。
现在鱼缸也有了，接下来我们买一个玻璃鱼缸来养金鱼：
//创建（买）一个玻璃鱼缸，泛型传入（养）金鱼
public class GlassGoldFishTank extends FishTank<GoldFish>{
@Override
public String material() {
return "在玻璃鱼缸里";
}
}
将鱼缸放进屋子中，我们来看一看结果：
public class Room {
public static void main(String[] args) {
new GlassFishTank();
}
}
发现崩溃了...
Exception in thread "main" java.lang.NullPointerException
at com.testapplication.FishTank.show(FishTank.java:10)
at com.testapplication.FishTank.<init>(FishTank.java:6)
at com.testapplication.GlassGoldFishTank.<init>(GlassGoldFishTank.java:3)
at com.testapplication.Room.main(Room.java:13)
不慌，问题不大，原因很简单，变量fish没有实例化，实例化一下即可。但此时你会发现，无法在FishTank中实例化fish，因为变量fish的类型是泛型。嗯..问题也不大，创建一个负责实例化fish的抽象方法abstract void initFish()去交给子类实现即可：
public abstract class FishTank<F extends Fish> {
F fish;
public FishTank() {
initFish();
show();
}
private void show(){
System.out.println(material() + fish.swim());
}
abstract void initFish();
abstract String material();
}
public class GlassGoldFishTank extends FishTank<GoldFish>{
@Override
public void initFish(){
fish = new GoldFish();
}
@Override
public String material() {
return "在玻璃鱼缸里";
}
}
ok，再来试一下：
在玻璃鱼缸里金鱼优雅的游动
我们还可以展示一下金鱼特有的属性：
public class GlassGoldFishTank extends FishTank<GoldFish>{
public GlassGoldFishTank() {
fish.beautiful();
}
@Override
void initFish() {
fish = new GoldFish();
}
@Override
String material() {
return "在玻璃鱼缸里";
}
}
结果如下：
在玻璃鱼缸里金鱼优雅的游动
金鱼很漂亮
简直完美，无敌~
过了两天，你看金鱼看够了，又买了个玻璃鱼缸，这次养的是草鱼（细纹狮子鱼：我tm***你个**）
//创建（买）一个玻璃鱼缸，泛型传入（养）细纹狮子鱼
public class GlassGrassFishTank extends FishTank<GrassFish>{
public GlassGrassFishTank() {
fish.alige();
}
@Override
void initFish() {
fish = new GrassFish();
}
@Override
String material() {
return "在玻璃鱼缸里";
}
}
放入屋子中:
public class Room {
public static void main(String[] args) {
new GlassGoldFishTank();
new GlassGrassFishTank();
}
}
试下效果：
在玻璃鱼缸里金鱼优雅的游动
金鱼很漂亮
在玻璃鱼缸里细纹狮子鱼迅速的游动
细纹狮子鱼非常敏捷
呦西，完美~
又过两天，你又看够了，这回你买了个水晶鱼缸来养金鱼：
public class CrystalGoldFishTank extends FishTank<GoldFish>{
...
@Override
void initFish() {
fish = new GoldFish();
}
...
}
又过两天，你又看够了，又买了个钻石鱼缸来养草鱼：
public class DiamondGrassFishTank extends FishTank<GrassFish>{
...
@Override
void initFish() {
fish = new GrassFish();
}
...
}
...
一个问题
不知道你有没有发现，每买一个鱼缸，就要实现一下initFish()方法，但是这个方法里面的代码功能是一样的，每个鱼缸的initFish()方法里面都是做的实例化fish的操作，只不过实例化的对象不同罢了。这就是典型的模板代码，随着鱼缸越来越多，写这些模板代码浪费的时间也就越来越多。其实一开始崩溃的时候你的第一反应就是在FishTank里面实例化fish，但是又发现fish是泛型类型，无法实例化，没办法只能通过抽象方法交给子类去实例化，也就产生了无用的模板代码。
其实不光是这个例子，在实际开发中也会遇到这种情况，比如我们在封装BaseActivity的时候，如果项目使用MVVM架构，那么BaseActivity里就要持有ViewModel，因此就要给BaseActivity加上ViewModel的泛型：
public abstract class BaseActivity<VM extends BaseViewModel>{
protected VM mViewModel;
...
}
ViewModel需要实例化，但是它的类型却是个泛型，那一些经验不够丰富的童鞋可能就不知道如何在BaseActivity中进行实例化，就只能创建抽象方法abstract void initViewModel()在具体子类业务Activity中去进行实例化，这就跟上面例子中的实例化fish一样是模板代码了。
如何解决
那到底有没有办法在基类中实例化泛型呢？答案是有的，就是使用Class类中的getGenericSuperclass()方法。这个方法的作用是获取该类的带有准确泛型类型的父类，它与getSuperclass()方法的区别是getSuperclass方法返回的是宽泛的父类类型，不包含具体泛型信息。如果该类的父类不是参数化类型（即没有泛型），那么这两个方法的效果是一样的。光说不容易理解，上代码：
public class GlassFishTank extends FishTank<GrassFish>{
@RequiresApi(api = Build.VERSION_CODES.P)
public GlassFishTank() {
//在构造方法中打印两个方法获取到的类
print(getClass().getGenericSuperclass().getTypeName());
print(getClass().getSuperclass().getTypeName());
}
}
运行结果：
com.testapplication.FishTank<com.testapplication.GrassFish>
com.testapplication.FishTank
可以看到，getGenericSuperclass方法获取到了代码运行时FishTank类的泛型的准确类型，即GrassFish。既然知道了准确的泛型类型了，那么就可以获取到泛型的Class，获取到了泛型的Class，自然就可以实例化了。话不多说，直接上代码：
public abstract class FishTank<F extends Fish> {
F fish;
@RequiresApi(api = Build.VERSION_CODES.P)
public FishTank() {
initFish();
}
private void initFish(){
// ① 获取该类的带有准确泛型类型的父类
Type genericSuperclass = getClass().getGenericSuperclass();
// ② 判断父类是否是参数化类型。由于本例中父类必定是参数化类型，因此也可以去掉②③步，在①中直接声明变量为ParameterizedType类型
if (genericSuperclass instanceof ParameterizedType){
// ③ 如果是参数化类型，就将genericSuperclass强转为ParameterizedType
ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
// ④ 获取泛型类型的Class对象数组。因为可能有多个泛型，所以返回的是数组
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
//本例中只有一个泛型，数组中只有一个元素，所以直接取数组的第一个元素即可
Class<F> fishClass = (Class<F>) actualTypeArguments[0];
try {
// ⑤ 实例化fish变量
fish = fishClass.newInstance();
show();
} catch (Exception e) {
e.printStackTrace();
}
}
}
private void show(){
print(material() + fish.swim());
}
abstract String material();
}
如此一来，实例化fish的代码就只需在FishTank中写一次，无需在每个鱼缸中都实例化fish了，玻璃鱼缸现在变成了这样：
public class GlassFishTank extends FishTank<GrassFish>{
public GlassFishTank() {
fish.agile();
}
@Override
String material() {
return "在玻璃鱼缸里";
}
}
试一下效果：
在玻璃鱼缸里细纹狮子鱼迅速的游动
细纹狮子鱼非常敏捷
完美~
甚至还可以再简洁一点，将鱼特有的属性也放入FishTank中：
public abstract class FishTank<F extends Fish> {
...
try {
// ⑤ 实例化fish变量
fish = fishClass.newInstance();
show();
// ⑥ 获取fish类中的所有方法并遍历
Method[] methods = fishClass.getMethods();
for (int i = 0; i < methods.length; i++) {
//如果该方法是fish类中的方法（为了过滤掉父类中的方法）并且返回值类型为viod（为了过滤掉swim方法），说明是不同种类的鱼特有的属性，就执行该方法
if (methods[i].getDeclaringClass() == fishClass && methods[i].getReturnType() == void.class)
methods[i].invoke(fish);
}
}
private void show(){
print(material() + fish.swim());
}
abstract String material();
}
此时玻璃鱼缸变成了这样：
public class GlassFishTank extends FishTank<GoldFish>{
@Override
String material() {
return "在玻璃鱼缸里";
}
}
是不是非常简洁了，想养其他鱼只需修改一下泛型类型即可，完全不需要做其他任何操作。看一下执行效果：
在玻璃鱼缸里金鱼优雅的游动
金鱼很漂亮
灰常完美~
我们也可以将这个技巧应用到BaseActivity中，这样就不用每个具体业务Activity中都要写实例化ViewModel的模板代码了，你的代码是不是变得更优雅了呢~
这只是一个小技巧，并不是什么很牛逼的技术，只不过上面几个方法你可能平时很少用到或者根本没用过，不知道有这几个方法，当然也就不知道可以这么实现了。所以我们在钻研技术的深度时，也不要太忽视技术的广度，毕竟地基打的牢，房子才能盖的结实漂亮。
转载自:https://juejin.cn/post/7239606270026629176