JAVA泛型

（github地址： https://github.com/liufeiSAP/javaStudy）

泛型类：

public class Box<T> {
    // T stands for "Type"
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
 
Box<Integer> integerBox = new Box<Integer>();
Box<Double> doubleBox = new Box<Double>();
Box<String> stringBox = new Box<String>();

泛型方法：

声明一个泛型方法很简单，只要在返回类型前面加上一个类似 <T> 或者<K, V>的形式：

 限定符：

查找一个泛型数组中大于某个特定元素的个数：

错误写法：    

public static <T> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e > elem)  // compiler error， 不能保证任意类型都是可以比较的。
            ++count;
    return count;
}
 
正确写法：
做一个类似于下面这样的声明，这样就等于告诉编译器类型参数T代表的都是实现了Comparable接口的类，这样等于告诉编译器它们都至少实现了compareTo方法。
public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e.compareTo(elem) > 0)
            ++count;
    return count;
}
 
注意： 这里可以参考String的定义：    
       public final class String implements Serializable, Comparable<String>, CharSequence

通配符：

有如下函数定义：   public void boxTest(Box<Number> n) { /* ... */ }

那么现在Box<Number> n允许接受什么类型的参数？我们是否能够传入Box<Integer>或者Box<Double>呢？答案是否定的，虽然Integer和Double是Number的子类，但是在泛型中Box<Integer>或者Box<Double>与Box<Number>之间并没有任何的关系。

错误示例：

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
 
public class GenericReading {
    static List<Apple> apples = Arrays.asList(new Apple());
    static List<Fruit> fruit = Arrays.asList(new Fruit());
    static class Reader<T> {
        T readExact(List<T> list) {
            return list.get(0);
        }
    }
    static void f1() {
        Reader<Fruit> fruitReader = new Reader<Fruit>();
        // Errors: List<Fruit> cannot be applied to List<Apple>.
        // Fruit f = fruitReader.readExact(apples);   相当于实参是List<apple>,而形参是List<frut>, 两者没有联系，虽然apple是frut的子类
    }
    public static void main(String[] args) {
        f1();
    }
}
 
正确示例：
static class CovariantReader<T> {
    T readCovariant(List<? extends T> list) {   // 用通配符来解决这个问题
        return list.get(0);
    }
}
static void f2() {
    CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
    Fruit f = fruitReader.readCovariant(fruit);
    Fruit a = fruitReader.readCovariant(apples);
}
public static void main(String[] args) {
    f2();
}
 这样就相当与告诉编译器， fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身)，这样子类和父类之间的关系也就关联上了。
 
PECS原则：
      问题： 上面可以取元素，是否可以往List中add元素。    List<? extends Fruit> flist = new ArrayList<Apple>();

       答案是否定，Java编译器不允许我们这样做，为什么呢？对于这个问题我们不妨从编译器的角度去考虑。因为List<? extends Fruit> flist它自身可以有多种含义：

1
2
3
List<? extends Fruit> flist = new ArrayList<Fruit>();
List<? extends Fruit> flist = new ArrayList<Apple>();
List<? extends Fruit> flist = new ArrayList<Orange>();
  • 当我们尝试add一个Apple的时候，flist可能指向new ArrayList<Orange>();
  • 当我们尝试add一个Orange的时候，flist可能指向new ArrayList<Apple>();
  • 当我们尝试add一个Fruit的时候，这个Fruit可以是任何类型的Fruit，而flist可能只想某种特定类型的Fruit，编译器无法识别所以会报错。

      所以对于实现了<? extends T>的集合类只能将它视为Producer向外提供(get)元素，而不能作为Consumer来对外获取(add)元素。

 
       如果我们要add元素应该怎么做呢？可以使用<? super T>：
 
   public class GenericWriting {
    static List<Apple> apples = new ArrayList<Apple>();
    static List<Fruit> fruit = new ArrayList<Fruit>();
    static <T> void writeExact(List<T> list, T item) {
        list.add(item);
    }
    static void f1() {
        writeExact(apples, new Apple());
        writeExact(fruit, new Apple());
    }
    static <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item)
    }
    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruit, new Apple());
    }
    public static void main(String[] args) {
        f1(); f2();
    }
}
 
注意：   <? extends T>  和  <? super T> 一般只作为函数的形参使用。一定要弄明白两者谁可以get， 谁可以add.        规律是： ”Producer Extends, Consumer Super”：
  • “Producer Extends” – 如果你需要一个只读List，用它来produce T，那么使用? extends T。
  • “Consumer Super” – 如果你需要一个只写List，用它来consume T，那么使用? super T。
  • 如果需要同时读取以及写入，那么我们就不能使用通配符了。

 

如何阅读过一些Java集合类的源码，可以发现通常我们会将两者结合起来一起用，比如像下面这样：

public class Collections {
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++)
            dest.set(i, src.get(i));
    }
}
 
类型擦除导致的问题：Java泛型很大程度上只能提供静态类型检查，然后类型的信息就会被擦除
        （1）：在Java中不允许创建泛型数组，类似下面这样的做法编译器会报错：
1
List<Integer>[] arrayOfLists = new List<Integer>[2];  // compile-time error

　　　　也就是说下面的这个例子是不可以的：

　　　　List<String>[] ls = new ArrayList<String>[10];

　　　　而使用通配符创建泛型数组是可以的，如下面这个例子：

　　　　List<?>[] ls = new ArrayList<?>[10]; 这样也是可以的：List<String>[] ls = new ArrayList[10];
        （2）：我们无法对泛型代码直接使用instanceof关键字
 
最后： 通配符是为了解决，在函数传参的时候， “虽然Number和Integer是继承关系，但是  List<Number>  和  List<Integer> 没有关系”  这个问题而提出的，
并且可以定义通配符的数组（单是不能定义泛型数组）。
 
补充： <T> 和  <?> 的区别：
          https://www.zhihu.com/question/31429113
          类型参数“<T>”主要用于声明泛型类或泛型方法。 无界通配符“<?>”主要用于使用泛型类或泛型方法。
      List<?>   cc = new ArrayList<String>();
      cc.add("fd");   // 编译有错误

    实际更常用的是<? extends XXX>或者<? super XXX>两种，带有上下界的通配符
          
posted @ 2017-10-07 15:43  刘大飞  阅读(186)  评论(0)    收藏  举报