Java泛型

版權聲明：本文為部落客原創文章，轉載請注明出處。 https://blog.csdn.net/twilight_karl/article/details/55805693

泛型類

1，泛型表示的類型不能是基本類型，隻能是引用類型,比如int，float等等都不可以作為泛型的類型，但是可以用相應的包裝類代替，如int可以表示為Integer。String不是基本類型。

2，讓方法局限在特定類型下：

//泛型類執行個體
public class test01 <T> {
    private T name;
    private T sex;

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }


    public static void main(String[] args) {
        test01<String> test = new test01();
        test.setName("張三");
        System.out.println(test.getName());
    }
}
           

泛型方法

泛型方法可以用在非泛型的類中，使用方法是在放回類型之前加： <類型>

然後該類型就可以在這個函數中使用

如：

public <T> void fun(T e){}

public <T> String fun(T e){}

繼承泛型類

已有泛型類 class abstract Father

擦除

使用，實作，繼承父類時，父類沒有指定泛型的類型

現在有泛型類Test：

public class Test <T> {
    T a;
    public <T> void test (T t){
        System.out.println(t);
    }
}           

如果在使用時不指定T的類型，T的用法類似于Object類型，是以下面這段代碼不會報錯:

public static void main(String [] args){
        Test<Object> test = new Test<Object>();
        Test<String> test2 = new Test<String>();
        test.test(test2);
}           

但是，不指定類型并不完全等同于Object，下面的代碼執行時會因為類型不比對而報錯

public static void ss(Test2<Object> t){}

    public static void main(String [] args){
        Test<String> test = new Test<Object>();
        ss(test); //報錯
    }           

通配符 ？

表示類型不确定，隻能用于聲明變量，不能用于建立對象，不能用于建立泛型類，不能用于泛型方法上。

List <?> list = new ArrayList<Integer>(); //正常

List <?> list4 = new ArrayList<?>(); //報錯

public <?> void test2(String t){} //報錯

上限

？ extends Fruit

表示Frut類型和Fruit類型的所有子類,子類的子類也可以，例如有下面的繼承關系：

class Fruit{}
class Apple extends Fruit{}
class pear extends Fruit{}
class RedApple extends Apple{}           

下面是使用時出現的幾種情況。

？的效果等同于 ？ extends Object 。是以List<?> 與List<? extends Fruit>不比對

public static void test1(List<? extends Fruit> s){}

    public static void main(String[] args) {
        List<? extends Fruit> list1 = new ArrayList<Fruit>();
        List<? extends Apple> list2 = new ArrayList<RedApple>();
        List<?> list3 = new ArrayList<Fruit>();
        test1(list1);   //正常
        test1(list2);   //正常
        test1(list3);   //報錯
    }           

形參為List

public static void test1(List<? extends Fruit> s){
        s.add(new Fruit()); //報錯
    }           

下限

super與extends相反。表示父類或自身。可能的幾種情況：

public static void test(List <? super Apple> s){}
    public static void main(String[] args) {
        List<Fruit> list1 = new ArrayList<Fruit>();
        List<RedApple> list2 = new ArrayList<RedApple>();
        List<? super Apple> list3 = new ArrayList<RedApple>(); //報錯
        List<?> list4 = new ArrayList<Apple>();
        List<? super RedApple> list5 = new ArrayList<RedApple>();

        test(list1);        //正常
        test(list2);        //報錯
        test(list4);        //報錯
        test(list5);        //報錯
    }           

可以通過泛型的嵌套通路hashmap中的Entry

Map<String,String> map = new HashMap();
        map.put("1", "a");
        map.put("2","b");
        Set<Entry<String,String>> s = map.entrySet();
        for(Entry<String,String> temp : s){
            System.out.println(temp.getValue());
        }