Java中的泛型類、泛型方法、泛型接口

學習筆記：泛型方法
泛型的本質是參數化類型，在使用或者調用的時候才傳入參數類型。這種參數類型可以用到類、方法、接口中，分別稱爲泛型類、泛型方法、泛型接口。

泛型的定義格式：

• <類型>：指定一種類型的格式，這裏的類型可以看成是形參。
• <類型1,類型2…>:指定多種類型的格式，多種類型之間用逗號隔開，這裏的類型可以看成是形參
  將來調用時候給定的類型可以看成是實參，並且實參的類型只能是引用數據類型。

形參出現在方法定義中，在整個方法體內都可以使用， 離開該方法則不能使用。實參出現在主函數中，進入被調函數後，實參變量也不能使用。
1-比如你定義一個函數public static int add(int a,int b)，這裏的a和b就是形參。
2-當你進行函數調用的時候，add(1,2)，這裏的1和2就是實參。

1、泛型類的定義格式

修飾符 class 類名<類型> {}
範例：public class Student<T> {}

此處的T可以隨便寫爲任意修飾符，常見的如T 、E、K、 V等形式的參數常用語表示泛型

2、泛型類的方法格式

public class 類名{
    public <T> void 方法名(類型 參數名){ }}

範例：
public class Student{
      public <T> void show(T t){ }}

3、泛型接口的定義格式

修飾 interface 接口名<類型> {}

範例：public interface GenericInterface<T> {}

4、類型通配符：
爲了表示各種泛型List的父類，可以使用類型通配符
類型通配符：<?>
List<?>:表示元素類型未知的List,它的元素可以匹配任何類型
這種帶通配符的List僅表示它是各種泛型的List的父親，並不能把元素添加到其中

如果說我們不希望List<?>是任何泛型的父親，只希望它代表某一泛型List的父親，可以使用類型通配符的上限
類型通配符的上限：<?extends類型>
List<?extends Number>:它表示的類型是Number或者其子類型

除了可以指定類型通配符的上限，我們也可以指定類型通配符的下限
類型通配符的上限：<?super類型>
List<?super Number>:它表示的類型是Number或者其父型

//        類型通配符<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("-----------------------");

//        類型通配符上限：<?extend類型>
//        List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("-----------------------");

        //類型通配符的下限：<? super 類型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<? super Number> list9 = new ArrayList<Integer>();

範例

一、泛型類範例

//定義泛型類
public class Student<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        Student<String> s = new Student<String>();
        s.setT("小袁");
        System.out.println(s.getT());

        Student<Integer> s1 = new Student<Integer>();
        s1.setT(20);
        System.out.println(s1.getT());
    }
}

二、泛型方法範例

//泛型方法改進
public class Generic{
    public <T> void show(T t){
        System.out.println(t);
    }
}

/*public class Generic {
    public void show(String s){
        System.out.println(s);
    }

    public void show(int s){
        System.out.println(s);
    }

    public void show(Boolean s){
        System.out.println(s);
    }
}*/

//測試類
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("sek");
        g.show(18);
        g.show(true);
    }
}

二、泛型接口範例

//泛型接口
public interface GenericInterface<T> {
    void show(T t);
}

//實現泛型
public class GenericImpl<T> implements GenericInterface<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

//測試類
public class GenericDemo {
    public static void main(String[] args) {
        GenericImpl<String> g = new GenericImpl<String>();
        g.show("xiaoming");

        GenericImpl<Integer> g2 = new GenericImpl<Integer>();
        g2.show(20);
    }
}