Java使用泛型Class实现消除模板代码

Class d1 = Demo.class;
Class d2 = new Demo().getClass();
Class d3 = Class.forName("com.xxx.xxx.Demo);

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("细纹狮子鱼非常敏捷");    //细纹狮子鱼特有的属性
    }
}

public abstract class FishTank<F extends Fish> {
    F fish;
    public FishTank() {
        show();
    }
    private void show(){
        System.out.println(material() + fish.swim());
    }
    abstract String material();
}

//创建（买）一个玻璃鱼缸，泛型传入（养）金鱼
public class GlassGoldFishTank extends FishTank<GoldFish>{
    @Override
    public String material() {
        return "在玻璃鱼缸里";
    }
}

public class Room {
    public static void main(String[] args) {
        new GlassFishTank();
    }
}

    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 "在玻璃鱼缸里";
        }
}

public class GlassGoldFishTank extends FishTank<GoldFish>{
    public GlassGoldFishTank() {
        fish.beautiful();
    }
    @Override
    void initFish() {
        fish = new GoldFish();
    }
    @Override
    String material() {
        return "在玻璃鱼缸里";
    }
}

//创建（买）一个玻璃鱼缸，泛型传入（养）细纹狮子鱼
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();
        }
        ...
    }

public abstract class BaseActivity<VM extends BaseViewModel>{
    protected VM mViewModel;
    ...
}

public class GlassFishTank extends FishTank<GrassFish>{
    @RequiresApi(api = Build.VERSION_CODES.P)
    public GlassFishTank() {
        //在构造方法中打印两个方法获取到的类
        print(getClass().getGenericSuperclass().getTypeName());
        print(getClass().getSuperclass().getTypeName());
    }
}

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

public class GlassFishTank extends FishTank<GrassFish>{
    public GlassFishTank() {
        fish.agile();
    }
    @Override
    String material() {
        return "在玻璃鱼缸里";
    }
}

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 "在玻璃鱼缸里";
    }
}