class 類名<T，R...> {  //...表示可以有多個(gè)泛型
        成員
}

interface 接口名 <T，R...> {
}

修飾符 <T，R...>返回類型 方法名(參數(shù)列表) {
}

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("寶馬",100);//當(dāng)調(diào)用方法時(shí)傳入?yún)?shù)，編譯器就會(huì)確定類型
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList<>(),1.1f);
    }
}
//泛型方法，可以定義在普通類中，也可以定義在泛型類中
class Car { //普通類
    public void run() { //普通方法
    }
    //說(shuō)明，泛型方法
    //1. <T,R>就是泛型
    //2. 是提供給fly使用的
    public <T,R> void fly(T t, R r) { //泛型方法
        System.out.println(t.getClass()); //String
        System.out.println(r.getClass()); //Integer
    }
}
class Fish<T,R> { //泛型類
    public void run() { //普通方法
    }
    public<U,M> void eat(U u, M m) { //泛型方法
    }
    //說(shuō)明
    //1.下面的hi方法不是泛型方法
    //2.是hi方法使用了類聲明的泛型
    public void hi(T t){
    }
    //泛型方法可以使用類聲明的泛型，也可以使用自己聲明泛型
    public<K> void hello(R r,K k){
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

/**
 * @author 咕咕貓
 * @version 1.0
 * 泛型的繼承與通配符
 */
@SuppressWarnings({"all"})
public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("XXX");
        //泛型沒(méi)有繼承性
        //List<Object> list = new ArrayList<String>();
        //舉例說(shuō)明下面三個(gè)方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();
        //如果是 List<?> c ，可以接受任意的泛型類型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        //List<? extends AA> c： 表示 上限，可以接受 AA 或者 AA 子類
        // printCollection2(list1);//×
        // printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√
        //List<? super AA> c: 支持 AA 類以及 AA 類的父類，不限于直接父類
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×
    }
        //說(shuō)明: List<?> 表示 任意的泛型類型都可以接受
        public static void printCollection1(List<?> c) {
            for (Object object : c) { // 通配符，取出時(shí)，就是 Object
                System.out.println(object);
            }
        }
        // ? extends AA 表示 上限，可以接受 AA 或者 AA 子類
        public static void printCollection2(List<? extends AA> c) {
            for (Object object : c) {
                System.out.println(object);
            }
        }
        // ? super 子類類名 AA:支持 AA 類以及 AA 類的父類，不限于直接父類，
        //規(guī)定了泛型的下限
        public static void printCollection3(List<? super AA> c) {
            for (Object object : c) {
                System.out.println(object);
            }
        }
}
class AA {
}
class BB extends AA {
}
class CC extends BB {
}