还不懂Java的泛型？只用这一篇文章，保证你面试对答如流

List list = new ArrayList();
list.add(1);
list.add("zhuan2quan");
list.add("程序新视界");
for (int i = 0; i < list.size(); i++) {
    String value = (String) list.get(i);
    System.out.println("value=" + value);
}

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

List<String> list = new ArrayList<>();
list.add(1);
list.add("zhuan2quan");
list.add("程序新视界");
for (String value : list) {
    System.out.println("value=" + value);
}

Required type: String
Provided: int

List<String> list = new ArrayList<>();
list.add(1);

@Test
public void test3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    Method add = list.getClass().getMethod("add", Object.class);
    add.invoke(list,"程序新视界");
    System.out.println(list);
    System.out.println(list.get(1));
}

[1, 程序新视界]
程序新视界

Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #6                  // String zhuan2quan
      11: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      16: pop
      17: aload_1
      18: ldc           #7                  // String 程序新视界
      20: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      25: pop
      26: aload_1
      27: invokeinterface #18,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      32: astore_2
      33: aload_2
      34: invokeinterface #19,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      39: ifeq          80

class name<T1, T2, ..., Tn> { /* ... */ }

// T为任意标识，比如用T、E、K、V等表示泛型
public class Foo<T> {
    // 泛化的成员变量，T的类型由外部指定
    private T info;
    // 构造方法类型为T，T的类型由外部指定
    public Foo(T info){
        this.info = info;
    }
    // 方法返回值类型为T，T的类型由外部指定
    public T getInfo() {
        return info;
    }
    public static void main(String[] args) {
        // 实例化泛型类时，必须指定T的具体类型，这里为String。
        // 传入的实参类型需与泛型的类型参数类型相同，这里为String。
        Foo<String> foo = new Foo<>("程序新视界");
        System.out.println(foo.getInfo());
    }
}

Foo foo11 = new Foo(1);

public interface Context<T> {
    T getContext();
}

// 实现泛型接口时已传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
public class TomcatContext implements Context<String> {
    @Override
    public String getContext() {
        return "Tomcat";
    }
}

// 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
public class SpringContext<T> implements Context<T>{
    @Override
    public T getContext() {
        return null;
    }
}

public interface GenericInterfaceSeveralTypes< T, R > {
    R performAction( final T action );
}

public <T> T func(T obj) {}

protected abstract<T, R> R performAction( final T action );
static<T, R> R performActionOn( final Collection< T > action ) {
    final R result = ...;
    // Implementation here
    return result;
}

public class GenericsMethodDemo1 {
    //1、public与返回值中间<T>，声明此方法的泛型类型。
    //2、只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
    //3、<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
    //4、T可以为任意标识，如T、E、K、V等。
    public static <T> T printClass(T obj) {
        System.out.println(obj);
        return obj;
    }
    public static void main(String[] args) {
        printClass("abc");
        printClass(123);
    }
}

// 方法一
public T getKey(){
    return key;
}
// 方法二
public <T> T showKeyName(T t){
    return t;
}

@SafeVarargs
public final <T> void print(T... args){
 for(T t : args){
  System.out.println("t=" + t);
 }
}
public static void main(String[] args) {
 GenericDemo2 demo2 = new GenericDemo2();
 demo2.print("abc",123);
}

t=abc
t=123

/**
 * 在使用List<Number>作为形参的方法中，不能使用List<Ingeter>的实例传入，
 * 也就是说不能把List<Integer>看作为List<Number>的子类；
 */
public static void getNumberData(List<Number> data) {
    System.out.println("data :" + data.get(0));
}
/**
 * 在使用List<String>作为形参的方法中，不能使用List<Number>的实例传入;
 */
public static void getStringData(List<String> data) {
    System.out.println("data :" + data.get(0));
}
/**
 * 使用类型通配符可以表示同时是List<Integer>和List<Number>、List<String>的引用类型。
 * 类型通配符一般是使用?代替具体的类型实参，注意此处是类型实参；
 * 和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。
 */
public static void getData(List<?> data) {
    System.out.println("data :" + data.get(0));
}

/**
 * 类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。
 */
public static void getUperNumber(List<? extends Number> data) {
    System.out.println("data :" + data.get(0));
}

public static void getData(List<? extends T> data) {
    System.out.println("data :" + data.get(0));
}

public static void getData(List<? super Integer> data) {
    System.out.println("data :" + data.get(0));
}

final List< Long > longs = new ArrayList<>();
final Set< Integer > integers = new HashSet<>();

final List< Long > longs = new ArrayList<>();
longs.add( 0L ); // 'long' 包装为 'Long'
long value = longs.get( 0 ); // 'Long'解包'long'

final Map<String, Collection<String>> map =
    new HashMap<String, Collection<String>>();
for(final Map.Entry< String, Collection<String> > entry: map.entrySet()) {
}

final Map< String, Collection<String>> map = new HashMap<>();