超详细泛型基础加强

泛型
1. 泛型类：具有一个或多个类型变量的类，称之为泛型类！

class A<T> {
}

2. 在创建泛型类实例时，需要为其类型变量赋值

A<String> a = new A<String>();
  * 如果创建实例时，不给类型变量赋值，那么会有一个警告！

3. 泛型方法：具有一个或多个类型变量的方法，称之为泛型方法！

class A<T> {
  public T fun(T t1) {}
}

fun()方法不是泛型方法！它是泛型类中的一个方法！

public <T> T fun(T t1) {} --> 它是泛型方法

* 泛型方法与泛型类没什么关系，泛型方法不一定非要在泛型类中！

4. 泛型在类中或方法中的使用
  * 泛型类中使用泛型：
    > 成员类型
    > 返回值和参数类型
    > 局部变量的引用上

class A<T> {
  private T bean;//泛型可在成员变量上使用
  public T fun(T t) {}//泛型可以在类中的方法上（返回值和参数类型）使用！

  public void fun2() {//泛型还可以在局部变量的引用类型上使用
    T b = ...
    new T();//不行的！
  }
}

=========================================

5. 泛型的继承和实现

class A<T> {}

class AA extends A<String> {} //不是泛型类，只是它爸爸是泛型类！

5.1 继承泛型类

  * 子类不是泛型类：需要给父类传递类型常量
    > 当给父类传递的类型常量为String时，那么在父类中所有T都会被String替换！
  * 子类是泛型类：可以给父类传递类型常量，也可以传递类型变量

class AA1 extends A<Integer> {}

class AA3<E> extends A<E> {}

=========================================
=========================================
=========================================

泛型的通配符

1. 通配符使用的场景

  方法的形参！

2. 通配符的优点
  使方法更加通用！

3. 通配符分类
  无界通配：?
  子类限定：? extends Object
  父类限定：? super Integer

4. 通配符缺点
  使变量使用上不再方便
  无界：参数和返回值为泛型的方法，不能使用！
  子类：参数为泛型的方法不能使用
  父类：返回值为泛型的方法不能使用

5. 比较通配符
boolean addAll(Collection<E> c)

List<Number> numList = new ArrayList<Number>();
List<Integer> intList = new ArrayList<Integer>();
numList.addAll(intList);//addAll(Collection<Number> c), 传递的是List<Integer>


boolean addAll(Collection<? extends E> c)

List<Number> numList = new ArrayList<Number>();
List<Integer> intList = new ArrayList<Integer>();
numList.addAll(intList);//addAll(Collection<? extends Number> c), 传递的是List<Integer>


代码实践
```java
package cn.itcast;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class Demo2 {
	/**
	 * 数组VS集合
	 */
	
	@Test
	public void fun1() {
		//第一轮：平局
		Object[] objs = new Object[10];//我一个长度为10的数组，啥都能装
		List list = new ArrayList();//我长度不限，啥都能装
		
		//第二轮：平局
		String[] strs = new String[10];//我可以只装最多长度为10的字符串
		List<String> strList = new ArrayList<String>();//我也可以，长度不限
		
		//第三局
		Object[] objArray = new String[10];//我可以用一个Object去引用String
		objArray[0] = new Integer(100);//编译通过，但是最终抛出了数组存储异常。
		
//		List<Object> objList = new ArrayList<String>();//编译不通过，首先败下阵来
//		objList.add(new Integer(100));
//		假如第一句编译通过，泛型擦除（虚拟机不检查）后第一句变为List list = new ArrayList(); 
//		回过头来啥都能存，泛型就不起作用了，你这不糊弄人吗，所以编译器生气了，于是不让他编译通过
		/*
		 *结论：泛型的引用和创建两端，给出的泛型变量必须相同 
		 */	
	}
	
	
	public void fun2() {
		List<Integer> integerList = new ArrayList<Integer>();
		print(integerList);
		
		List<String> stringList = new ArrayList<String>();
		print(stringList);
		
	}
	
	/*
	 *？这就是通配符
	 *通配符只能出现在左边！即不能在new时使用通配符
	 * List<? extends Object> list = new ArrayList<String>();
	 *
	 */
	/*
	 * ?他表示一个不确定的类型，它的值会在调用的时候确定下来
	 */
	public void print(List<?> list) {
		/*
		 * 当使用通配符的时候，使泛型类中参数为泛型的方法不起作用了，方法废掉了
		 */
//		list.add("string");
		
		/*
		 * 当使用通配符时，泛型类中返回值为泛型的方法也废掉了，虽然用Object接受还能用
		 */
		Object s = list.get(0);
		
		/*
		 * 通配符的好处：可以使泛型类型更加通用！尤其是在方法调用时形参使用通配符！
		 */
		
	}
	
	
	public void fun3() {
		List<Integer> integerList = new ArrayList<Integer>();
		print1(integerList);
		
		List<Long> longList = new ArrayList<Long>();
		print1(longList);
		
		List<String> stringList = new ArrayList<String>();
		print1(stringList);
		
	}
	/*
	 * 给通配符添加了限定
	 * 	只能传递Number及其子类型
	 * 	子类通配符对通用性产生了影响，但使形参使用更加灵活
	 */
	public void print1(List<? extends Number> list) {
		/*
		 * 参数为泛型的方法还是不能用
		 */
//		list.add(new Integer(100));
		/*
		 * 但是，返回值为泛型的方法可以使用了！
		 */
		Number n = list.get(0);
		
	}
	
	public void fun4() {
		List<Integer> integerList = new ArrayList<Integer>();
		print2(integerList);
		
		List<Long> longList = new ArrayList<Long>();
		print2(longList);
		
		List<Object> objects = new ArrayList<Object>();
		print2(objects);
		
	}
	/*
	 * 给通配符添加限定
	 * 	只能传递Integer类型及其父类型
	 */
	public void print2(List<? super Integer> list) {
		
		/*
		 *参数为泛型的方法又可以使用了 
		 */
		list.add(new Integer(100));
		/*
		 * 但是返回值为泛型的方法废掉了
		 */
		Object o = list.get(0);
		
	}
}