懒人之道——使用泛型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的模板代码了，你的代码是不是变得更高雅了呢~

这只是一个小技巧，并不是什么很牛逼的技能，只不过上面几个办法你可能平时很少用到或许底子没用过，不知道有这几个办法，当然也就不知道能够这么完成了。所以咱们在研究技能的深度时，也不要太忽视技能的广度，究竟地基打的牢，房子才能盖的结实美丽。