Java泛型知识学习

public class ListErr {

	public static void main(String[] args) {
		//创建一个只想保存字符串的List集合
		List strList = new ArrayList();
		strList.add("Hello World");
		strList.add("Good Morning");
		strList.add("你好");
		//"不小心"把一个Integer对象"丢进"了集合
		strList.add(5);
		for(int i = 0; i < strList.size(); i++){
			//因为List里取出的全部是Object，所以必须强制类型转换
			//最后一个元素将出现ClassCastException异常
			// java.lang.ClassCastException:java.lang.Integer cannot be cast to java.lang.String
			String str = (String) strList.get(i);
		}
	}
}

上面的程序创建了一个List集合，并且只是希望该List对象保存字符串对象，但是我们没有办法添加任何的限制，所以程序中“不小心”丢进了一个Integer对象，这将导致程序发生java.lang.ClassCastException异常。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常，因此导致此类错误编码过程中不易发现。通过上面程序，可以使我们了解到Java集合的两个问题：

public class GenericList {

	public static void main(String[] args) {
		//创建一个只想保存字符串的List集合
		List<String> strList = new ArrayList<String>();
		strList.add("Hello World");
		strList.add("Good Morning");
		strList.add("你好");
		//下面代码将引起编译错误
		strList.add(5);//01
		for(int i = 0; i < strList.size(); i++){
			//下面代码无须强制类型转换
			String str = strList.get(i);//02
		}
	}
}

public interface List<E> extends Collection<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();
  
    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean addAll(int index, Collection<? extends E> c);

    boolean removeAll(Collection<?> c);
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

   
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
	//省略
}

public class Apple<T> {

	private T data;
	public Apple(T data){
		this.data = data;
	}
	
	public void setData(T data){
		this.data = data;
	}
	
	public T getData(){
		return this.data;
	}
	
	public static void main(String[] args) {
		//因为传给T形参的是String类型，所以构造函数只接受String类型
		Apple<String> a1 = new Apple<String>("苹果");
		System.out.println(a1.getData());
		//因为传给T形参的是Double实际类型，所以构造器的参数只能是Double或者double
		Apple<Double> a2 = new Apple<Double>(1.23);
		System.out.println(a2.getData());
	}
}

//定义类继承Apple类，Apple类不能跟类型形参
	public class A extends Apple<T>{}

public class A extends Apple<String>{}

四、类型通配符

//定义一个如此的方法
	public void test(List<Object> ol){
		for(int i = 0; i < ol.size(); i++){
			System.out.println(ol.get(i));
		}
	}

//创建一个List<String>对象
	List<String> strList = new ArrayList<String>();
	//将strList作为参数来调用前面的test方法
	test(strList);//01

The method test(List<Object>) in the type Apple<T> is not applicable for the arguments (List<String>)

List<?> c = new ArrayList<String>();
//下面程序引起编译时错误
c.add(new Object());

public void test(List<?> c){
		for(int i = 0; i < c.size(); i++){
			System.out.println(c.get(i));
		}
	}

public void test(List<? extends Number> c){
		for(int i = 0; i < c.size(); i++){
			System.out.println(c.get(i));
		}
	}

public void test(List<? super Integer> c){
		for(int i = 0; i < c.size(); i++){
			System.out.println(c.get(i));
		}
	}

五、类型的擦除

public class Apple<T extends Number> {

	private T data;
	public Apple(T data){
		this.data = data;
	}
	
	public void setData(T data){
		this.data = data;
	}
	
	public T getData(){
		return this.data;
	}
}

public class TestErasure{
	public static void main(String[] args) {
		Apple<Integer> a = new Apple<Integer>(6);  //01
		//a的getSize方法返回Integer对象
		Integer as = a.getData();
		//把a对象赋给Apple变量，会丢失尖括号里的类型信息
		Apple b = a;   //02
		//b只知道sizede类型是Number
		Number size1 = b.getData();
		//下面代码引起编译错误
		Integer size2 = b.getData();  //03
	}
}

六、话外篇