泛型程序设计

一种将类型明确工作延后到生成对象或调用方法时的机制——把类型也当做参数。这种机制设计的初衷是为了规避杂乱地使用Object变量，产生的强转异常。

ArrayList的add方法即是一个典型案例：

public boolean add(E var1) {
        this.ensureCapacityInternal(this.size + 1);
        this.elementData[this.size++] = var1;
        return true;
    }

这种情况下，只需要创建ArrayList时候声明泛型类型，该方法就能被指定参数类型；否则ArrayList需要如下多个重载方法:

public boolean add(String var1);
public boolean add(Boolean var1);
public boolean add(Integer var1);
...

基本使用方法

ArrayList<String> arrayList = new ArrayList<>();
泛型声明如果不明确使用，则默认为Object类型
JDK7开始后面的类型声明可以省略.泛型声明类型只能被引用数据类型填充

• 在类上声明泛型
  类中使用到E类型的地方会被限定类型
  public interface Collection<E> extends Iterable<E> {}
• 在方法中声明泛型
  可以和类中声明的泛型不一致，方法调用时候，传入什么类型就当做什么类型处理

public class EObj<T> {
        public <E> void show(E e){
            System.out.println(e);
        }
    }
public static void main(String[] args) {
        TestClass testClass = new TestClass();
        TestClass.EObj eObj = testClass.new EObj<String>();
        eObj.show("pdddd");
        eObj.show(14);
        eObj.show(true);
//这里还涉及到自动装箱和拆箱的机制
    }

• 在接口中声明泛型

public interface FanAdapter<E> {
    void show(E e);
}
//实现方案一，将类型提前声明
private class FanAdapterImp implements FanAdapter<String>{
        @Override
        public void show(String s) {

        }
    }
//实现方案二，将泛型带到子类中
//集合框架常用该设计
private class FanAdapterImp<E> implements FanAdapter<E>{
        @Override
        public void show(E e) {
            
        }
    }

高级用法

• 通配符<?>，匹配任意类型

//指定的泛型中前后类型必须一致
        Collection<String> collection = new ArrayList<String>();//correct
        Collection<String> collection1 = new ArrayList<Object>();//wrong
        ArrayList<String> arrayList = new ArrayList<Object>();//wrong
        //？通配符下的泛型类型可以引用任何类型
        Collection<?> collection3 = new ArrayList<Boolean>();
        Collection<?> collection4 = new ArrayList<Integer>();
        ArrayList<?> collection2 = new ArrayList<String>();

• <? extends E> 向下限定

        ArrayList<? extends Animal> arrayList = new ArrayList<Animal>();
        ArrayList<? extends Animal> arrayList1 = new ArrayList<Cat>();
        ArrayList<? extends Animal> arrayList2 = new ArrayList<Dog>();
        ArrayList<? extends Animal> arrayList3 = new ArrayList<String>();//wrong

• <* super E> 向上限定

        ArrayList<? super Animal> arrayList1 = new ArrayList<Object>();
        ArrayList<? super Animal> arrayList2 = new ArrayList<Animal>();
        ArrayList<? super Animal> arrayList3 = new ArrayList<Cat>();//wrong

优势：

• 避免了强制类型转换（声明了类型后就遍历集合时就无需强转）
  泛型机制修饰的代码，然后