2021.6.2：编写泛型

1、编写泛型

编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中，例如ArrayList<T>，我们很少需要编写泛型类。

我们按照以下步骤编写一个泛型类：

①、按照某种类型，例如：“String”，来编写类：

public class Pair {
    private String first;
    private String last;
    public Pair(String first,String last){
        this.first = first;
        this.last = last;
    }
    public String getFirst(){
        return first;
    }
    public String getLast(){
        return last;
    }
}

②、把所有的类型String替换为T，并在类名之后申明<T>：

public class Pair<T>{
    private T first;
    private T last;
    public Pair(T first, T last){
        this.first = first;
        this.last = last;
    }
    public T getFirst(){
        return first;
    }
    public T getLast(){
        return last;
    }
}

熟练之后，可以直接从T开始写。

2、泛型类的静态方法

编写泛型类时，要特别注意，泛型类型<T>不能用于静态方法。例如：

public class Pair<T>{
    ...
    public static Pair<T> create (T first,T last){
        return new Pair<T>(first,last);
    }
}

上述代码会导致编译错误，我们无法在静态方法create()方法参数和返回类型上使用泛型类型T。

有人发现，可以在static修饰符后边加一个<T>，编译就能通过：

public static <T> Pair<T> create(T first, T last){...}

但实际上，这个<T>与Pair<T>类型的<T>没啥关系。

对于静态方法，我们可以单独改写为泛型方法，只需要使用另一个类型（用不同的泛型字母表示）即可。对于上面的create()静态方法，我们应该把它改写为另一种泛型类型，例如<K>：

public class Pair <T>{
    ...
    //静态泛型方法应该使用其他类型区分：
    public static <K> pair<K> create(K first , K last){
        return new Pair<K>(first,last);
    }
}

这样才能把静态方法泛型类型与实例类型泛型类型区分开。

3、多个泛型类型

泛型还可以定义多种类型。

例如，我们希望Pair不总是存储两个类型一样的对象，就可以使用类型<T,K>：

public class Pair<T,K> {
    private T first;
    private K last;
    public Pair(T first , K last){
        this.first = first;
        this.last = last;
    }
    public T getFirst() {...}
    public K getLast() {...}
}

实际使用时，需要指出两种类型：

Pair<String,Integer> p = new Pair <> ("test",123);

Java标准库的Map<K,V>就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型。

总结

1、编写泛型类

除了需要在类名后写明<T>，别的和写普通的类没什么不同，只是要在类中的相关方法和属性的类型也同样写为T：

public class XXX<T>{
    private T p1;
    private T p2;
    public Pair(T p1 , T p2){
        this.p1 = p1;
        this.p2 = p2;
    }
    public T getP1(){
        return p1;
    }
    public T getP2(){
        return p2;
    }
}

2、泛型类的静态方法

需要额外指明另一种泛型类型，比如<K>：

public class Pair <T> {
    ...
    public static <K> Pair <K> func( K p1 , K p2 ){
        return new Pair<K> (p1 , p2);
    }
}

这样就能把静态方法与普通方法区分开。

3、多个泛型类型

和单个泛型类型类似，但是使用的类型是<T , K>

public class Pair <T,K>{
    private T p1;
    private K p2;
    public Pair (T p1 , K p2){
        ...
    }
    public T getP1() {...}
    public K getP2() {...}
}

实际使用时，需要指明两种泛型类型：

Pair <String , Integer> p = new Pair <> ("Test",123);

Java的Map<K,V>就是使用两种泛型类型的例子——它对Key使用一种类型，对Value使用另一种类型。