泛型

泛型实现了参数化类型的概念,使代码应用于 多种类型。参数化类型，顾名思义就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

• 1 简单泛型

class Automobile{
    public void print(){
        System.out.println("print()");
    }
}
public class Holder<T> {
    private T t;
    public Holder(T t){
        this.t = t;
    }
    public T getT(){
        return t;
    }
    public static void main(String[] args) {
        Holder<Automobile> holder = new Holder<Automobile>(new Automobile());
        holder.getT().print();
    }
}

当你创建Holder时，必须指明想持有什么类型的对象,将其置于尖括号内，那么就只能在Holder中存入该类型的对象了，并且在你从Holder中取出他持有的对象时，自动的就是正确的类型了。这就是java泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切的细节

• 2.一个堆栈类

 public class LinkedList<T> {
    private static class Node<U>{
        U item;
        Node<U> next;
        Node(){
            item = null;
            next = null;
        }
        Node(U item, Node<U> next){
            this.item = item;
            this.next = next;
        }
        boolean end(){return item == null & next == null;}
    }
    private Node<T> top = new Node<T>();
    public void push(T item){
        top = new Node<T>(item, top);
    }
    public T pop(){
        T result = top.item;
        if(!top.end()){
            top = top.next;
        }
        return result;
    }
    public static void main(String[] args) {
        LinkedList<String> lss = new LinkedList<String>();
        for(String str : "zhou li bin".split(" ")){
            lss.push(str);
        }
        String ss;
        while((ss = lss.pop())!=null){
            System.out.println(ss);
        }
    }
}

• 3.自定义泛型接口
  泛型 也可以用作与接口

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

方法next()的返回类型是参数化 的T,接口使用泛型与类使用泛型没啥区别

import java.util.Iterator;
import java.util.Random;
class Coffee{
    private static long counter = 0;
    private final long id = counter++;
    public String toString(){
        return this.getClass().getSimpleName()+" "+ id;
    }
}
class Latte extends Coffee{}
class Mocha extends Coffee{}
class Cappuccino extends Coffee{}
class Breve extends Coffee{}
public class CoffeeGenerator implements Generator<Coffee>,Iterable<Coffee>{
    private Class[] types = {Latte.class,Mocha.class,Cappuccino.class,Breve.class};
    private static Random rand = new Random(47);
    private int size = 0;
    public CoffeeGenerator(){} 
    public CoffeeGenerator(int sz){
        this.size = sz;
    }
    public static void main(String[] args) {
        CoffeeGenerator co = new CoffeeGenerator();
        for(int i=0;i<4;i++){
            System.out.println(co.next());
        }
        for(Coffee c : new CoffeeGenerator(4)){
            System.out.println(c);
        }
    }
    @Override
    public Coffee next() {
        try{
            return (Coffee) types[rand.nextInt(types.length)].newInstance();
        }catch(Exception ex){
            throw new RuntimeException();
        }
    }
    class CoffeeIterator implements Iterator<Coffee>{
        int count = size;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return count > 0;
        }
        @Override
        public Coffee next() {
            // TODO Auto-generated method stub
            count --;
            return CoffeeGenerator.this.next();
        }
        @Override
        public void remove() {
        }
    }
    @Override
    public Iterator<Coffee> iterator() {
        return new CoffeeIterator();
    }
}

一个实现类,实现Generator<Coffee>接口，能够随机生成不同类型的Coffee对象
参数化 的Generator接口确保next()返回值是参数的类型，CoffeeIterator同时还实现了Iterable接口，所有他可以在循环中使用，这就是第二个构造器 的应用

• 4.泛型斐波那契的应用

 public class Fibonacci implements Generator<Integer>{
    private int count = 0;
    public Fibonacci(int n){
        this.count = n;
    }
    public Fibonacci(){}
    @Override
    public Integer next() {
        return fib(count++);
    }
    public int fib(int n){
        if(n < 2) return 1;
        return fib(n-2)+fib(n-1);
    }
    public static void main(String[] args) {
        Fibonacci fib = new Fibonacci();
        for(int i=0;i<18;i++){
            System.out.print(fib.next()+" "); 
        }
    }
}

这个例子引出了泛型的一个局限性：基本类型无法作为泛型参数，所以Int不行，使用Integer,但java提供了自动打包和自动拆包的功能，可以在基本类型与包装类型之间转换

• 5.泛型方法
  泛型方法适当方法可以独立于类而产生变化
  要定义泛型方法，只需将泛型参数列表置于返回值之前

 import java.util.Arrays;
public class GenericMethods {
    public <T> void f(T t){
        System.out.println(t.getClass().getSimpleName());
    }
    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("hello");
        gm.f(10);
        gm.f(Arrays.asList("zhou li bin".split(" ")));
    }
}

注意：当使用泛型类时，必须在创建对象的时候指定类型参数的值，而是用泛型方法的时候，不必指明参数的类型，因为编译器会帮我们找出具体的类型，这称为类型参数判断

• 6.一个通用的Generator

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

 public class BasicGenerator<T> implements Generator<T>{
    private Class<T> typpe;
    public BasicGenerator(Class<T> type){
        this.typpe = type;
    }
    @Override
    public T next() {
        try {
            return typpe.newInstance();
        } catch (Exception e) {
            throw new RuntimeException();
        } 
    }
    public static <T> Generator<T> create(Class<T> t){
        return new BasicGenerator<>(t);
    }
}

这个类提供了一个基本的实现,用以生成某个类的对象。这个类必须具备两个条件：（1）它必须声明为public （2）必须具有默认的构造器

• 7.匿名内部类
  泛型还可以用于内部类以及匿名内部类

 public interface Generator<T> {
    T next();
}
 public class Customer {
    private static long counter = 0;
    private final long id = counter++;
    private Customer(){}
    public String toString(){
        return "Customer\t"+id;
    }
    public static Generator<Customer> Generator(){
        return new Generator<Customer>() {
            @Override
            public Customer next() {
                return new Customer();
            }
        };
    }
}

Customer只有private的构造器，这可以强制你必须使用Generator对象

• 8.擦除的神秘之处
  尽管可以声明ArrayList.class，但是不能声明ArrayList<Integer>.class

 import java.util.ArrayList;
public class ErasedTypeEquivalence {
    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2);
    }
}

 import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
class Frob{}
class Fnorkle{}
class Quark<Q>{}
public class LostInformation {
    public static void main(String[] args) {
        ArrayList<Frob> list = new ArrayList<Frob>();
        Map<Frob,Fnorkle> map = new HashMap<Frob,Fnorkle>();
        System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
    }
}

因此残酷的现实是：在泛型代码内部，无法获得任何有关泛型参数的信息
java泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你惟一知道的就是你在使用一个对象。因此,List<String>和List<Integer>在运行时事实上都是相同的类型

• 9.擦除的补偿
  擦除丢失了在泛型代码中执行某些操作的能力。任何在运行时需要知道确切类型信息的操作都无法工作。

 public class ClassTypeCapture<T> {
    Class<T> type;
    public ClassTypeCapture(Class<T> type){
        this.type = type;
    }
    public boolean f(Object obj){
        return type.isInstance(obj);
    }
    public static void main(String[] args) {
        ClassTypeCapture<Teller> ctt  =new ClassTypeCapture<Teller>(Teller.class);
        System.out.println(ctt.f(new Automobile()));
    }
}

有时必须通过引入类型标签来对擦除进行补偿，这意味着你要显示的传递你的类型Class对象，以便你在类型表达式中用到它

• 10.泛型数组
  可以使用带范型参数值的类声明数组，却不可有创建数组

 import java.lang.reflect.Array;
public class GenericArray2<T> {
    private T[] array;
    @SuppressWarnings("unchecked")
    public GenericArray2(Class<T> type,int size){
        array = (T[]) Array.newInstance(type, size);
    }
    public void put(int index,T item){
        array[index] = item;
    }
    public T get(int index){
        return array[index];
    }
    public T[] pop(){
        return array;
    }
    public static void main(String[] args) {
        
    }
}

类型标记Class<T>被传递到构造器中,以便从擦除中恢复，使得我们可以创建需要的实际类型的数组

• 11.泛型问题
  1.任何基本类型都不能作为类型参数
  2.实现参数化接口

 一个类不能实现同一个泛型接口的两种变体，由于擦除的原因这两个变体会成为相同的接口

3.转型和警告
使用带有泛型类型参数的转型或instanceof不会有任何效果
4.重载
由于擦除的原因，重载将产生相同的类型签名
于此不同的是当被擦除的参数不能产生惟一的参数列表时，必须提供明显有区别的方法名