Java 泛型深度学习笔记

泛型

描述泛型的优点

使用泛型类和接口

定义泛型类和接口

解释为什么泛型类型可以提高可靠性和可读性

定义并使用泛型方法和受限泛型类型

使用原始类型向后兼容

解释为什么有必须压迫必要有通配的泛型类型

描述泛型消除并列出一些由类型消除引起的泛型上的限制和局限性

设计并实现泛型矩阵类

21.1 引言

泛型（generic）是指参数化类型的能力。
使用泛型的主要优点是能够在编译时而不是运行时检测出错误。

21.2 动机和优点

package java.lang;
public interface Comparable<T> {
    pubic int compareTo(T o);
}

这里的<T>表示形式泛型类型（formal generic type）
随后可以用一个实际具体类型（actual concrete type）来替换它。
替换泛型类型称为泛型实例化(generic instantiation)
按照惯例，像E,T这类单个大写字母用于表示一个形式泛型类型

泛型类型必须是引用类型，
误：ArrayList<int> intList = new ArrayList<int>;
正：ArrayList<Integer> intList = new ArrayList<Integer>;

自动打包：intList.add(5)，Java会自动把5包装为new Integer(5)
自动解包：int x = new Integer(5)，

从泛型定义好的变量中取值时，不需要再做强制转化。

21.3 定义泛型类和接口

为了创建一个字符串堆栈，可以使用new GenericStack()
这个可能会会引起对构造方法的误解：
误：pubic GenericStack<E>()
正：pubic GenericStack()

有时候，泛型类可能会有多个参数。所有的参数应以其放在尖括号中，
并用逗号隔开。例如：<E1,E2,E3>

可以定义一个类或一个接口作为泛型或者接口的子类型。
譬如在Java API中，java.lang.String类被定义为实现Comparable接口

public class String implements Comparable<String>

21.4 泛型方法

可以定义泛型接口和泛型类，还可以使用泛型类型来定义泛型方法。
为了调用泛型方法，需要将实际类型放在尖括号内作为方法名的前缀。

public class GenericMethodDemo{
    public static void main(String[] args) {
        Integer[] integers = {1,2,3,4,5};
        String[] strings = {"London","Paris","NewYork","Austin"};

        GenericMethodDemo.<Integer>print(integers);
        GenericMethodDemo.<String>print(strings);
    }
    public static <E> void print(E[] list){

        Stream.of(list).forEach {

            x -> {System.out.println(x);}
        }
    }
}

可以将泛型指定为另一种类型的子类型。这样的泛型成为受限的（bounded）

非受限类型<E和<E extends Object>是一样的。

• 为了定义一个类为泛型类型，需要将泛型类型放在类名之后。
  例如GenericStack<E>，
• 为了定义一个方法为泛型类型，要将泛型类型放在方法返回类型之前。
  例如<E> void max <E o1, E o2>

21.5 原始类型和向后兼容

GenricStack stack = new GenericStack();
像GenericStack和ArrayList这样不使用类型参数的泛型类成为原始类型(raw type)

使用原始类型的Comparable

public class Max{
    public static Comparable max (Comparable o1, Comparable o2)  {
        if (o1.compareTo(o2) > 0)
            return o1;
        else
            return o2;
    }
}

这样的代码是不安全的， 因为Max.max("Welcome",23); 编译时不会出错，但运行时会出错。
更好的编程方法就是使用泛型类型。

public class Max{
    public static <E extends Comparable<E>> E max (E o1, E o2)  {
        if (o1.compareTo(o2) > 0)
            return o1;
        else
            return o2;
    }
}

E extends Comparable<E> 表示E是Comparable的子类型。
将其放在尖括号内<E extends Comparable<E>>放在函数的前面，表示定义这个方法为泛型类型。
E max (E, E),表示这个函数入力为两个E型，返回值也为E型。

21.6 通配泛型

public static double max(Generic<Number> stack){}
public static void main(String[] args) {
    GenericStack<Integer> intStack = new GenericStack<Integer>();
}

这样会出编译错误。因为GenericStack<Integer> 不是GenericStack<Number>的实例
通配泛型有3种形式，?，? extends T，? super T
第一种形式 ?称为非受限通配(unbounded wildcard)，
它和? extends Object是一样的

第二种形式? extends T 成为受限通配(bounded wildcard),
表示T或者T的一个未知子类型。

第三种形式? super T 称为下限通配（lower-bounded wildcard）
表示T或者T的一个未知父类型。

使用下面的代码就可以修复上面的错误。

public static double max(Generic<E extends Number> stack){}

尽管Integer是Object的一个子类型，但是
GenericStack<Integer>并不是GenericStack<Object>的子类型

什么时候需要<? super T>通配符

public static void main(String[] args) {
    GenericStack<String> stack1 = new GenericStack<String>();
    GenericStack<Object> stack2 = new GenericStack<Object>();
    stack2.push("Java");
    stack2.push(2);
    stack1.push("Sun");
    add(stack1,stack2);
    print(stack2);
}
public static <T> void add(GenericStack<T> stack1, GenericStack<? super T> stack2){
    while (！stack1.isEmpty())
        stack2.push(stack1.pop());
}

如果用<T>代替<? super T> 那么在add处会产生编译错误。
因为stack1的类型为GenericStack而stack2的类型为GenericStack