java - 泛型

java - 泛型

java - 泛型

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

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

1. 简单泛型

public class Holder<E> {

    private E ele;

    public Holder(E e) {
        this.ele = e;
    }

    public E get() {
        return ele;
    }

}

Holder 类现在可以持有任何类型的对象。如：

    public static void main(String[] args) {
        Holder<String> h1 = new Holder<String>("string");
        Holder<Exception> h2 = new Holder<>(new Exception());
        Exception e = h2.get(); // 取出时自动就是目标类型了
    }

2. 泛型接口

定义接口 Generator —— 生成器，专门用于创建对象的类。

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

编写辅助类：Fruit 及其子类 苹果，西瓜，梨。

public class Fruit {
    private static long counter = 0;
    private final long id = counter++; // counter 是属于类的，每次创建对象都会自增

    @Override
    public String toString() {
        String c = getClass().getSimpleName();
        return String.format("%-15s%-10d", c, id); // 格式化字符串
    }

    static class Apple extends Fruit {
    }

    static class Watermelon extends Fruit {
    }

    static class Pear extends Fruit {
    }
}

现在可以编写类实现 Generator< Fruit >接口，用于产生水果：

public class FruitGenerator implements 
    Generator<Fruit>, 
    Iterable<Fruit>  { // 使可以在 foreacher 语句中迭代

    private Random random = new Random(47);
    private Class[] types = {Fruit.Apple.class, Fruit.Watermelon.class, Fruit.Pear.class};
    private int size; // 边界值，产生器的生产量边界

    public FruitGenerator(int size) {
        this.size = size;
    }

    @Override
    public Iterator<Fruit> iterator() {
        return new FruitIterator();
    }

    @Override
    public Fruit next() {
        Class type = types[random.nextInt(types.length)];
        Fruit fruit = null;
        try {
            fruit = (Fruit) type.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return fruit;
    }

    class FruitIterator implements Iterator<Fruit> { // 迭代器
        int count = size;

        @Override
        public boolean hasNext() {
            return count > 0;
        }

        @Override
        public Fruit next() {
            count--;
            return FruitGenerator.this.next(); // 随机产生[水果]
        }
    }

    public static void main(String[] args) {
        for (Fruit f : new FruitGenerator(10)) {
            System.out.println(f);
        }
    }
}

利用反射使随机产生水果。
输出：

Pear           0         
Pear           1         
Watermelon     2         
Pear           3         
Watermelon     4         
Pear           5         
Watermelon     6         
Pear           7         
Apple          8         
Watermelon     9         

泛型的一个局限性：基本类型无法作为类型参数，不过，java SE 5 具备了自动打包和拆包功能，可以很方便的在基本类型与其包装类之间转换。

3. 泛型方法

1. 是否拥有泛型方法与其所在类是否为泛型类没有关系。
2. 使用泛型类或泛型方法的原则：无论何时，只要你做得到，就应该尽量使用泛型方法。
3. 对于一个 static 方法，其无法访问所在泛型类的类型参数，所以，静态方法使用泛型的唯一方式是使其自己成为泛型方法。（类似于类的静态成员和非静态成员的关系，静态成员是属于类的，静态成员无法访问非静态成员，同理，类型参数是属于对象的，静态成员无法访问）。

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

public class GenericMethods {

    public static <E> void printClassName(E e) {
        System.out.printf(e.getClass().getSimpleName());
    }

    public static <E, T, F> void printSameMethods(E e, T t, F f) {
        Method[] ems = e.getClass().getMethods();
        Method[] tms = t.getClass().getMethods();
        Method[] fms = f.getClass().getMethods();

        Set<String> set = new HashSet<>(); // Set 集合元素不能重复
        for (Method m : ems) {
            set.add(m.getName());
        }
        for (Method m : tms) {
            set.add(m.getName());
        }
        for (Method m : fms) {
            set.add(m.getName());
        }

        for (String s : set) {
            System.out.printf(s + "\n");
        }

    }

    public static void main(String[] args) {
        // 不必指明参数类型
        GenericMethods.printClassName(AbstractCollection.class);
        System.out.printf("\n");
        GenericMethods.printSameMethods(HashSet.class, ArrayList.class, TreeMap.class);
    }

}

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

泛型有时需要向程序中加入更多的代码

创建一个持有 List 的 Map：
在 JDK 1.6 之前，你需要通过如下方式声明：
Map<Integer,List<String>> map = new HashMap<Integer, List<String>>();
JDK 1.6 之后得到了简化：
Map<Integer, List<String>> map = new HashMap<>();

显示的类型说明

在泛型方法中，可以显示的指明类型，但这种语法很少使用，要显示的指明类型，必须在点操作符与方法名之间插入尖括号，然后把类型置于尖括号内。

public class Test {


    public static void main(String[] args) {

        Test test = new Test();
        test.f(test.<String, Integer>map());
    }

    public void f(Map map) {
    }

    public <K, V> Map<K, V> map() {
        return new HashMap<>();
    }

}

4 可变参数与泛型

可变参数与泛型可以很好的共存。

public class Test {


    public static void main(String[] args) {
        Test t = new Test();
        for (Integer i : t.list(1, 2, 3, 4, 5)) {
            System.out.printf(i + " ");
        }

    }

    public <T> List<T> list(T... ts) {
        return Arrays.asList(ts);
    }

}

输出

1 2 3 4 5 

5 擦除的神秘之处

    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.printf(c1.equals(c2) ? "true" : "false");
    }

输出结果为 true，ArrayList<String> 和 ArrayList<Integer>很容易被认为是不同的类型，不同的类型在行为方面肯定不同，但事实是他们是同样的类型。

在泛型代码内部，无法获得任何有关泛型参数类型的信息

java 是使用擦除来实现的，这意味着当你使用泛型时，任何具体的类型信息都被擦除了。

public class Test {

    public static void main(String[] args) {
        Test t = new Test();
        t.test(t.new Te());
    }

    private <E> void test(E e) {
        e.f(); // 编译无法通过
    }

    class T {
        void f() {
        }
    }

    class Te extends T {
    }

}

上面的例子在泛型方法 test 中调用了 e 对象的 f 方法，对于 C++ ，这是允许的，C++ 编译器将对此进行检查，它看到 e 对象调用了 f 方法，而此时 e 映射到的类型 Te 拥有 f 方法，编译就通过，否则编译出错，这样就保证了类型安全。 java 则不同，由于有了擦除，编译器无法将 test 方法通过参数 e 调用 f 方法这一需求映射到 e 对象拥有 f 方法这一事实上。我们必须协助泛型类，给定泛型的边界，以此告知编译器只能接受遵循这个边界的类型。这样就能通过编译：

public class Test {


    public static void main(String[] args) {
        Test t = new Test();
        t.test(t.new Te());
    }

    private <E extends T> void test(E e) {
        e.f(); // 编译通过
    }

    class T {
        void f() {
        }
    }

    class Te extends T {
    }

}

泛型类型擦除会擦除到他的第一个边界，因而 e 对象可以调用 T 类型的所有可访问方法。

6 迁移兼容性

擦除是 java 泛型实现的一个折中，因为泛型不是 java 语言出现时就有的组成部分，所以这种折中是必须的。

泛型类型只有在静态类型检查期间才出现，在此之后，程序中的所有泛型类型都将被擦除，替换为他们的非泛型上界，例如，诸如 List<T>这样的类型擦除时将被替换为 List ，而普通的类型变量在未指定边界的情况下将被擦除为 Object 。

擦除的核心动机是使得泛化的客户端可以使用非泛化的类库，反之亦然，这经常被称为 迁移兼容性。java 泛型必须支持向后兼容性，即现有的代码和类文件仍旧合法，并且继续保持其之前的定义，并且当某个类库变为泛型时，不会破坏依赖于它的代码和应用程序。

7 擦除的问题

擦除的主要正当理由是从非泛化代码到泛化代码的转变过程，以及在不破坏现有类库的情况下，将泛型融入 java 语言。

擦除的代价时显著的，泛型不能用于显示的引用运行时类型的操作中，例如转型、instanceof 和 new 操作，因为所有有关类型的信息都丢失了。

public class Foo<T>{
    T var;
}

Foo<String> f = new Foo<String>();

在泛型类 Foo 中，看似类型 T 都在被替换为 String ，但事实并非如此，无论何时，当你在编写这个类的代码时，必须提醒自己：“不，它只是一个 Object 。”

@SuppressWarnings(“unchecked”)

禁止【未检查类型】警告，该注解在 java SE 5 之前不支持。

这个注解被放置在产生这类警告的方法之上，而不是整个类上，当要关闭警告时，最好是尽量的“聚焦”，这样就不会因为过于宽泛的关闭警告，而导致意外的遮蔽掉正在的问题。

public class Test {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        TC tc = new TC(); 
        tc.put(""); //未指明类型参数类型，因而在赋值时编译器无法进行类型安全检查

    }

    static class TC<T> {
        T t;

        void put(T t) {
            this.t = t;
        }

        T get() {
            return t;
        }
    }

}

8 边界处的动作

public class Test {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        TC tc = new TC();
        List list = tc.create(1, 2, 3, 4, 5); // 未检查警告
        System.out.println(list);
    }

    static class TC<T> {
        List<T> create(T... ts) {
            List<T> result = new ArrayList<T>();
            for (T t : ts) {
                result.add(t);
            }
            return result;
        }
    }
}

即使编译器无法知道有关 create 方法中的 T 的任何信息，但它仍旧可以确保你放置到 result 中的对象具有 T 类型，使其适合 ArrayList<T>，因此，即使擦除在方法或类内部移除了有关实际类型的信息，编译器仍旧可以在方法或类中使用类型的 内部一致性 。

因为擦除在方法体中移除了类型信息，所以在运行时的问题就是边界：即对象进入和离开方法的地点。这些正是编译器在编译期间执行类型检查并插入转型代码的地点。

为上述 TC 类添加如下方法：
void set(T t) { ele = t; }
当外部调用 set 方法时，编译器会进行类型检查，当然，前提是指定 TC 类的类型参数，即修改上述代码中 tc 的定义如下：
TC<Integer> tc = new TC<>();
这样，当向 set 方法传入错误的类型，编译器会提醒你（编译无法通过），若不指定类型参数，则只会得到未检查类型 警告。

添加如下方法：
T get(){ return (T)"str";} // 此时会得到未检查类型转换异常
对比如下实现：
T get(){ return ele;} // 合法
外部调用：
Integer num = tc.get(); // 指定类型参数为 Integer
由于擦除，这里 get 方法中的 T 在运行时就是 Object 。但外部调用 get 方法时却无需进行显示的类型转换，然而这里的类型转换是必须的。事实是，编译器完成了这个动作，编译器会在编译期插入对传递出去值的转型。

修改后的代码：

public class Test {

//    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        TC<Integer> tc = new TC<>();
//        tc.set(""); // 编译无法通过
        List list = tc.create(1, 2, 3, 4, 5);
        System.out.println(list);

        tc.set(13);
        Integer num = tc.get();
        System.out.println("\n" + num);
    }

    static class TC<T> {
        T ele;

        List<T> create(T... ts) { // 编译期类型检查
            List<T> result = new ArrayList<T>();
            for (T t : ts) {
                result.add(t);
            }
            return result;
        }

        // 边界就是发生动作的地方
        void set(T t) { // 编译期类型检查
            ele = t;
        }

        T get() {
            return ele; // 编译期转型代码插入发生的地方
        }
    }
}

9 擦除的补偿

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

要想在运行时获得类型信息只能通过类型判断，当然，这就违背了 java 泛型的主旨：参数化类型

public class Test {

    public static void main(String[] args) {
        TC<Person> tc = new TC<>();
        System.out.println(Person.class.getSimpleName());
        tc.check(new Person("tom", 12));
    }

    static class TC<T> {
        void check(T t) {
            if (t.getClass().equals(Person.class)) {
                Person p = (Person) t;
                System.out.println(p.getName());
            }
        }
    }

    static class Person {
        String name;
        int id;

        public Person(String name, int id) {
            this.name = name;
            this.id = id;
        }

        public String getName() {
            return name;
        }

        int getId() {
            return id;
        }
    }
}

需要知道确切类型的操作都无法工作。

    static class TC<T> {
        void test() {
//            T[] ts = new T[1]; // 错误
//            T t = new T(); // 错误
//            T[] ts1 = (T[]) new Object[1]; // 未检查类型转换
        }
    }

擦除补偿：类型标签

需要显示的传递类型的 Class 对象，以便可以在类型表达式中使用。

public class Test {

    public static void main(String[] args) {
        TC<A> tc = new TC<>(A.class);
        System.out.println(tc.check(""));
        System.out.println(tc.check(new A()));
    }

    static class TC<T> {
        Class<T> kind;

        public TC(Class<T> kind) {
            this.kind = kind;
        }

        boolean check(Object obj) {
            return kind.isInstance(obj);
        }
    }

    static class A {
    }
}

输出：

false
true

isInstance 方法将检查 obj 的类型是否为 kind。

---

文章大部分摘抄自《Java 编程思想》 第 15 章 泛型，加上部分自己的理解，若有错误，欢迎指正。

END