9.泛型(Thinking in java 学习九)

多态算是一种泛化机制，但是拘泥于单继承体系，也会使程序受限太多。JavaSE5中提出了泛型的概念。

泛型概念：泛型实现了参数化类型的概念，使代码可以应用于多种类型。

简单泛型（泛型类）

为了创造容器类，是促成了泛型出现的主要原因。泛型的主要目的之一是用来指定容器要持有什么类型的对象，而且由编译器来保证类的正确性。

public class Holder<T>{
    private T a; 
    Holder(T a){this.a = a;}
    public T get(){return a;}
    public static void main(String[] args){
        Holder<String> h = new Holder<String>(new String("dd"));
        String s = h.get(); //自动得到正确类型
    }
}

Java泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。

1. 一个元组类库

元组：它是将一组对象直接打包存储于其中的一个单一对象。
注：可以利用继承机制实现长度更长的元组。

public class TwoTuple<A, B>{
    public final A first;
    public final B second;
    public TwoTuple(A a, B b){
        first = a;
        second = b;
    }
}

1. 一个堆栈类

public class LinkedStack<T>{
    T item;
    public void push(T item){
        this.item = item;
    }
    ...
}

泛型接口

泛型也能应用于接口，例如生成器（generator）一种专门负责创建对象的类。

public interface Generator<T>{
    T next();
}

public class StrGenerator implements Generator<String>{
    public String next(){
        return new String();
    }
}

接口使用泛型和类使用泛型并没有什么区别。

泛型方法

泛型方法是的该方法能够独立于类而产生变化，如果能用泛型方法代替将整个类泛型化，那应该使用泛型方法。

对于一个static方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。

要定义泛型方法，只需将泛型参数列表置于返回值之前。

public <T> void f(T t){
    ...
}

注意， 当使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，因为编译器会为我们找出具体的类型，这称为参数推断。我们可以像使用普通方法一样使用f().
如果参入基本类型，自动打包机制会介入将基本类型值包装成对应对象。

• 利用类型参数推断；

public New{
    public static <K,V> Map<K,V> map(){
        return new HashMap<K, V>();
    }
}
Map<String,List<String>> m = New.map(); //利用类型推断，不用强制转换

在非赋值语句的时候，需要额外的显式指明类型

f(New.<String, List<String>>map());//在.和方法名之间插入声明

• 可变参数与泛型方法；

public static <T> List<T> makeList(T... args){
    List<T> resutl = new ArrayList<T>();
    for(T item: args){
        resulr.add(item);
    }
    return result;
}

内部类

泛型还可以应用于内部类以及匿名内部类。

构建复杂模型

泛型的一个重要好处就是能够简单而安全的创建复杂的模型。
例如：List元组。

擦除的神秘之处

我们来看一个例子

Class c1 = new ArrayList<Integer>().getClass();
Class c2 = new ArrayList<String>().getClass();
System.out.println(c1==c2); //true

为什么输出是true？

Java泛型是用擦除来实现的，这==意味着当你在使用泛型时，任何具体的类型信息都被擦除了==，在泛型代码内部，无法获得任何有关泛型参数类型的信息。你唯一知道你在使用一个对象。因此List<Integer>和List<String>在运行时事实上是相同的类型，都被擦除成他们的“原生”类型，即List.

有时候我们需要用泛型调用某个具体对象方法，由于有擦除，Java编译器无法知道能否调用。我们必须借助泛型类，给定泛型类的边界，以此告知编译器只能接受遵循此边界的类型。

public class HasF{
    public void f(){
        ...
    }
}
class Manipulator<T>{
    private T obj;
    public void test(){
        obj.f();
    }
}

上面编译会出错， 编译器不知道obj能否调用f()；

修改，指定边界则可以通过编译

class Manipulator<T extends HasF>{
    private T obj;
    public void test(){
        obj.f();
    }
}

边界<T extends HasF>声明T必须具有HasF或子类的类型。泛型类型参数将擦除到它的第一个边界。

擦除的问题

擦除的代价是显著的，泛型不能用于显式地引用运行时类型的操作之中，例如转型、instanceof、new表达式，因为所有关于参数的类型信息都丢失。

擦除的补偿

擦除丢失了在泛型代码中执行某些操作的能力，我们可以通过引入类型标签Class<T>来对擦除进行补偿，这意味着需要显式地传递你的类型的Class对象，以便在表达式中使用。

public class ClassTye<T>{
    Class<T> kind;
    public ClassType(Class<T> kind){
        this.kind = kind
    }
    
}

通配符

通配符：在泛型参数表达式中的问号。
分为两种：

1. ==限定通配符==

限定通配符对类型进行了限制，有两种限定通配符，

• 一种是<? extends T>它通过确保类型必须是T或T的子类来设定类型的上界
• 另一种是<? super T>它通过确保类型必须是T或T的父类来设定类型的下界。

泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。

1. ==无界通配符==

无界通配符<?>看起来意味着“任何事物”，因此使用无界通配符好像等价于使用原生类型。

问题

1. List<?>和List<? extends Object>的区别？

List<?>可以使用原生类型，而List<? extends Object>必须指定类型。

static List list1;
static List<?> list2;
static List<? extends Object> list3

static void assigne1(List list){
    list1 = list;
    list2 = list;
   // list3 = list; //不行
}
//除了List list不能赋给List<? extends Object> list3，其他都可以互相赋值。

1. Java泛型的限制之一，不能将基本类型用作类型参数。需要使用自动包装机制。但是自动包装机制不能应用于数组。
2. 数组可以用泛型吗？

==不能直接创建泛型数组==。一般解决方案是在想要创建泛型数组的地方都用ArrayList代替。（创建泛型数组的唯一方式是创建一个被类型擦除的新数组，然后对其转型）

1. ==一个类能否实现同一个泛型接口的两种变体==？

不能，由于擦除的原因，这个两个变体会成为相同的接口，相当于重复实现相同的接口。

1. 转型

使用带有泛型类型参数的转型或instanceof不会有任何效果。

1. 重载

public class UseList<W, T>{
    void f(List<T> v){}
    void f(List<W> w){}
}

上面的程序是不能编译的。因为由于擦除的原因，重载方法将产生相同的类型签名。

异常

由于擦除的原因，catch语句不能捕获泛型类型的异常，因为在编译期和运行期都必须知道异常的确切类型。泛型类也不能直接或间接继承自Throwable