Thinking in Java：第十五章-泛型

1：泛型实现了参数化类型的概念，使代码可以应用于多种类型，“泛型”的含义就是“适用于好多好多的类型”。

2：实现自己的内部链式存储机制：LinkedStack

// 使用泛型设计的一个简单的栈
public class LinkedStack<T> {

    private 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<>();

    public void push(T item) {
        top = new Node<>(item, top);
    }

    public T pop() {
        T item = top.item;
        top = top.next;
        return item;
    }

    public static void main(String[] args) {
        LinkedStack<String> lss = new LinkedStack<String>();
        for (String s : "memoirs of geisha".split(" ")) {
            lss.push(s);
        }
        String s;
        while ((s = lss.pop()) != null) {
            System.out.println(s);
        }
    }
}

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

public <T> void f(T x)

4：在泛型代码内部，不会获得任何有关泛型参数类型的信息。擦除减少了泛型的泛型化，泛型在Java中仍旧是有用的，只不过不如它本来设想的那么有用，原因就是泛型：LostInformation

import java.util.*;

// Java的泛型使用擦除来实现，在泛型
// 代码内部，不会获得任何有关泛型参数类型的信息
public class LostInformation {

    // 没有返回值的泛型函数
    public <T> void f(T x) {
        System.out.println(x);
    }

    // 带返回值的泛型函数
    public <T> T g(T x) {
        return x;
    }

    public static void main(String[] args) {
        List<User> list = new ArrayList<User>();
        Map<String, Integer> map = new HashMap<String, Integer>();

        // getTypeParameters返回有泛型申明的类型参数
        System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(map.getClass().getTypeParameters()));

    }
}