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

interface Fish {
    String swim();    //魚(yú)的通用動(dòng)作游泳
}

public class GoldFish implements Fish{
    @Override
    public String swim() {
        return "金魚(yú)優(yōu)雅的游動(dòng)";
    }
    public void beautiful(){
        System.out.println("金魚(yú)很漂亮");    //金魚(yú)特有的屬性
    }
}
//魚(yú)可殺不可辱，兄弟你可以釣我但你不能侮辱我是草魚(yú)
public class GrassFish implements Fish{
    @Override
    public String swim() {
        return "細(xì)紋獅子魚(yú)迅速的游動(dòng)";
    }
    public void agile(){
        System.out.println("細(xì)紋獅子魚(yú)非常敏捷");    //細(xì)紋獅子魚(yú)特有的屬性
    }
}

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

//創(chuàng)建（買）一個(gè)玻璃魚(yú)缸，泛型傳入（養(yǎng)）金魚(yú)
public class GlassGoldFishTank extends FishTank<GoldFish>{
    @Override
    public String material() {
        return "在玻璃魚(yú)缸里";
    }
}

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 "在玻璃魚(yú)缸里";
        }
}

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

//創(chuàng)建（買）一個(gè)玻璃魚(yú)缸，泛型傳入（養(yǎng)）細(xì)紋獅子魚(yú)
public class GlassGrassFishTank extends FishTank<GrassFish>{
    public GlassGrassFishTank() {
        fish.alige();
    }
    @Override
    void initFish() {
        fish = new GrassFish();
    }
    @Override
    String material() {
        return "在玻璃魚(yú)缸里";
    }
}
//放入屋子中:
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() {
        //在構(gòu)造方法中打印兩個(gè)方法獲取到的類
        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(){
        // ① 獲取該類的帶有準(zhǔn)確泛型類型的父類
        Type genericSuperclass = getClass().getGenericSuperclass();
        // ② 判斷父類是否是參數(shù)化類型。由于本例中父類必定是參數(shù)化類型，因此也可以去掉②③步，在①中直接聲明變量為ParameterizedType類型
        if (genericSuperclass instanceof ParameterizedType){
            // ③ 如果是參數(shù)化類型，就將genericSuperclass強(qiáng)轉(zhuǎn)為ParameterizedType
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            // ④ 獲取泛型類型的Class對(duì)象數(shù)組。因?yàn)榭赡苡卸鄠€(gè)泛型，所以返回的是數(shù)組
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            //本例中只有一個(gè)泛型，數(shù)組中只有一個(gè)元素，所以直接取數(shù)組的第一個(gè)元素即可
            Class<F> fishClass = (Class<F>) actualTypeArguments[0];
            try {
                // ⑤ 實(shí)例化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 "在玻璃魚(yú)缸里";
    }
}

public abstract class FishTank<F extends Fish> {
                ...
                try {
                    // ⑤ 實(shí)例化fish變量
                    fish = fishClass.newInstance();
                    show();
                    // ⑥ 獲取fish類中的所有方法并遍歷
                    Method[] methods = fishClass.getMethods();
                    for (int i = 0; i < methods.length; i++) {
                        //如果該方法是fish類中的方法（為了過(guò)濾掉父類中的方法）并且返回值類型為viod（為了過(guò)濾掉swim方法），說(shuō)明是不同種類的魚(yú)特有的屬性，就執(zhí)行該方法
                        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 "在玻璃魚(yú)缸里";
    }
}