Java中的泛型

K - Key（键）
T - Type（Java 类），T代表在调用时的指定类型。会进行类型推断
V - Value（值）、N - Number（数值类型）
E - Element (在集合中使用，因为集合中存放的是元素)，E是对各方法中的泛型类型进行限制，以保证同一个对象调用不同的方法时，操作的类型必定是相同的。E可以用其它任意字母代替
？- 表示不确定的java类型，是类型通配符，代表所有类型。？不会进行类型推断

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class JavaTest{
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("mobai");
        coll.add("墨白");
        coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
        Iterator it = coll.iterator();
        while (it.hasNext()) {
            //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
            String str = (String) it.next();
            System.out.println(str.length());
        }
    }
}

Exception in thread "main" 5
2
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

class ArrayList<E> {
    public boolean add(E e) {
    }
    public E get(int index) {
    }
}

class ArrayList<Integer> {
    public boolean add(Integer e) {
    }
    public Integer get(int index) {
    }
}

class GeneralType<Type> {
    Type object;
    public GeneralType(Type object) {
        this.object = object;
    }
    public Type getObj() {
        return object;
    }
}
public class Test {
    public static void main(String args[]) {
        GeneralType<Integer> i = new GeneralType<Integer>(2);
        GeneralType<Double> d = new GeneralType<Double>(0.33);
        System.out.println("i.object=" + i.getObj());
        System.out.println("i.object =" + d.getObj());
    }
}

i.object=2
i.object =0.33

class GeneralMethod {
    public <Type> void printClassName(Type object) {
        System.out.println(object.getClass().getName());
    }
}
public class Test {
    public static void main(String[] args) {
        GeneralMethod gm = new GeneralMethod();
        gm.printClassName("hello");
        gm.printClassName(3);
        gm.printClassName(3.0f);
        gm.printClassName(3.0);
    }
}

interface MyGenericInterface<E> {
    public abstract void add(E e);
    public abstract E gitE();
}

class MyImpl2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {
    }
    @Override
    public E gitE() {
        return null;
    }
}

public class JavaTest {
    public static void main(String[] args) {
        MyImpl2<String> my = new MyImpl2<String>();
        my.add("墨白");
    }
}

//变量赋值或变量声明时候使用
List<?> list;
List<? extends Number> uNumberList;
List<? super Integer> intgerList;

public class JavaTest {
public static void main(String[] args) {
        Collection<Integer> c1 = new ArrayList<Integer>();
        Collection<String> c2 = new ArrayList<String>();
        Collection<Number> c3 = new ArrayList<Number>();
        Collection<Object> c4 = new ArrayList<Object>();
        getElementOne(c1);
        getElementOne(c2);// 编译报错
        getElementOne(c3);
        getElementOne(c4);// 编译报错
        getElementTow(c1);// 编译报错
        getElementTow(c2);// 编译报错
        getElementTow(c3);
        getElementTow(c4);
    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElementOne(Collection<? extends Number> collection){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElementTow(Collection<? super Number> collection){}
}

List<? extends T>只能接收该类类型型及其子类类型的List
List<? super T>只能接收该类类型及其父类型的List
例如List<? extends Number>可以接受List<Integer>或List<Float>