java(9)-泛型

使用泛型

class ArrayList<T>
{
    private T[] array;
    private int size;
    public void add(T e) 
    {}
}

使用泛型

        ArrayList list = new ArrayList(); //不定义泛型时，相当于是Object
        List<Number> list1 = new ArrayList<Number>();

//泛型接口
interface Comparable<T>
{
    int compareTo(T o);
}

class Person implements Comparable<Person>
{
    String name;
    int score;
    Person(String name, int score)
    {
        this.name = name;
        this.score = score;
    }
    public int compareTo(Person person)
    {
        return this.name.compareTo(person.name);
    }
}


class ArrayList<T> implements List<T>
{
    private T[] array;
    private int size;

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<T> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        return null;
    }

    public boolean add(T e)
    {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public T get(int index) {
        return null;
    }

    @Override
    public T set(int index, T element) {
        return null;
    }

    @Override
    public void add(int index, T element) {

    }

    @Override
    public T remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<T> listIterator() {
        return null;
    }

    @Override
    public ListIterator<T> listIterator(int index) {
        return null;
    }

    @Override
    public List<T> subList(int fromIndex, int toIndex) {
        return null;
    }
}

编写泛型

//多个泛型类型
class Map<T,K>
{
    private T first;
    private K second;
}

class Pair<T>
{
    private T first;
    private T second;
    public Pair(T first, T second)
    {
        this.first = first;
        this.second = second;
    }
    public T getFirst()
    {
        return first;
    }
    public <K> void getSecond()
    {
        //return second;
    }
    //静态泛型
    //静态方法不能引用泛型类型<T>，必须定义其他类型（例如<K>）来实现静态泛型方法；
    public static <K> Pair<K> create(K first, K last)
    {
        return new Pair<K>(first, last);
    }

}

泛型方法

//泛型方法
class Demo
{
    public <T> void show(T t)
    {
    }
    public <Q> void print(Q q)
    {
    }
}

擦拭法

        //所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的
        Pair<String> p1 = new Pair<String>("1", "2");
        Pair<Integer> p2 = new Pair<Integer>(1,2);
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        //c1 && c2 是同一个Class， 都是Object的Class


class Pai3<T> {
    private T first;
    private T last;

    public Pai3(Class<T> cls) throws IllegalAccessException, InstantiationException {
        // Compile error:
//        first = new T();
//        last = new T();
//        在擦拭后变成了
//        first = new Object();
//        last = new Object();
        first = cls.newInstance();
    }
}

class Pai<T> {
    private T first;
    private T last;
    public Pai(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

//经过编译器后：
// 编译器把类型<T>视为Object，编译器根据<T>实现安全的强制转型，
// 虚拟机执行的上述代码：
class Pai1 {
    private Object first;
    private Object last;
    public Pai1(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}
// 所以泛型不能处理不是继承Object的基本类型
//e.g.pair<int> error

泛型继承

//泛型继承

class intPair extends Pair<Integer>
{
    public intPair(Integer first, Integer second)
    {
        super(first, second);
    }
}

Class<intPair> cls = intPair.class;
        Type t = cls.getGenericSuperclass();
        if (t instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) t;
            Type[] types = pt.getActualTypeArguments(); // 可能有多个泛型类型
            Type firstType = types[0]; // 取第一个泛型类型
            Class<?> typeClass = (Class<?>) firstType;
            System.out.println(typeClass); // Integer
        }