java泛型通配符示例

package com.zte.itp.generic;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
/*
 * 泛型的使用
 * 1.在集合中使用泛型(掌握)
 * 2.自定义泛型类、泛型接口、泛型方法（理解 --->使用）
 * 3.泛型与继承的关系
 * 4.通配符
 * 
 * 特点：
 * 	1.对象实例化时不指定泛型，默认为：Object。
	2.泛型不同的引用不能相互赋值。
	3.加入集合中的对象类型必须与指定的泛型类型一致。
	4.静态方法中不能使用类的泛型。
	6.不能在catch中使用泛型
	7.从泛型类派生子类，泛型类型需具体化
	8.方法，也可以被泛型化，不管此时定义在其中的类是不是泛型化的。
	在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。没有指定默认是Object


 */
public class TestGeneric {

	/*
	 * 通配符的使用
	 * 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
	 * 写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中添加对象。
	 * 唯一的例外是null，它是所有类型的成员。
	 */
	@Test
	public void test7(){
		List<String> list = new ArrayList<String>();
		list.add("AA");
		list.add("BB");
		List<?> list1 = list;
		//可以读取声明为通配符的集合类的对象
		Iterator<?> iterator = list1.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		//不允许向声明为通配符的集合类中写入对象。唯一例外的是null
//		list1.add("CC");
//		list1.add(123);//编译时错误,因为我们不知道c的元素类型，我们不能向其中添加对象。

		list1.add(null);
	}
	
	/*
	 * 通配符 ?
	 * List<A>、List<B>、。。。。都是List<?>的子类
	 * 
	 * ? extends A :可以存放A及其子类
	 * ? super A:可以存放A及其父类
	 */
	@Test
	public void test6(){
		List<?> list = null;
		List<Object> list1 = new ArrayList<Object>();
		List<String> list2 = new ArrayList<String>();
		list = list1;
		list = list2;
		
		show(list1);
//		show(list2);
		show1(list1);
		show1(list2);
		
		List<? extends Number> list3 = null;
		List<Integer> list4 = null;
		list3 = list4;
//		list3 = list1;
		List<? super Number> list5 = null;
		list5 = list1;
	}
	
	public void show(List<Object> list){
		
	}
	public void show1(List<?> list){
		
	}
	
	/*
	 * 泛型与继承的关系:
	 * 如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G<B>并不是G<A>的子类型！
	 * 比如：String是Object的子类，但是List<String >并不是List<Object>的子类。
	 */
	@Test
	public void test5(){
		Object obj = null;
		String str = "AA";
		obj = str;
		
		Object[] obj1 = null;
		String[] str1 = new String[]{"AA","BB","CC"};
		obj1 = str1;
		
		List<Object> list = null;
		List<String> list1 = new ArrayList<String>();
//		list = list1;//如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G<B>并不是G<A>的子类型！
		//假设list = list1满足
		//list.add(123);
		//String str = list1.get(0);//出现问题，所以假设不满足
	}
	
	//自定义泛型类的使用
	@Test
	public void test4(){
		//1.当实例化泛型类的对象时，指明泛型的类型。
		//指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
		//2.如果我们自定义了泛型类，但是在实例化时没有使用，那么默认类型是Object类的
		Order<Boolean> order = new Order<Boolean>();
//		order.getT();
		order.setT(true);
		System.out.println(order.getT());
		order.add();
		List<Boolean> list = order.list;
		System.out.println(list);
		
		SubOrder o = new SubOrder();
		o.setT(100);
		o.add();
		List<Integer> list1 = o.list;
		
		System.out.println(list1);
		//当通过对象调泛型方法时，指明泛型方法的类型。
		Integer i = order.getE(34);
		Double d = order.getE(2.3);
		
		//在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
		Integer[] in = new Integer[]{1,2,3};
		List<Integer> list2 = new ArrayList<>();
		List<Integer> list3 = order.fromArrayToList(in);
		System.out.println(list3);
		
		//没有指定默认是Object
		List<Object> objs = order.getEList();
		System.out.println(objs);
	}
	
	@Test
	public void test3(){
		Map<String,Integer> map = new HashMap<>();
		map.put("AA", 78);
		map.put("BB", 87);
		map.put("DD", 98);
		
		Set<Map.Entry<String,Integer>> set = map.entrySet();
		for(Map.Entry<String,Integer> o : set){
			System.out.println(o.getKey() + "--->" + o.getValue());
		}
	}
	
	// 2.在集合中使用泛型
	@Test
	public void test2() {
		List<Integer> list = new ArrayList<Integer>();
		list.add(78);
		list.add(87);
		// list.add("AA");

		// for(int i = 0;i < list.size();i++){
		// int score = list.get(i);
		// System.out.println(score);
		// }
		Iterator<Integer> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}

	// 1.在集合中没有使用泛型的情况下
	@Test
	public void test1() {
		List list = new ArrayList();
		list.add(89);
		list.add(87);
		list.add(67);
		// 1.没有使用泛型，任何Object及其子类的对象都可以添加进来
		list.add(new String("AA"));

		for (int i = 0; i < list.size(); i++) {
			// 2.强转为int型时，可能报ClassCastException的异常
			int score = (Integer) list.get(i);
			System.out.println(score);
		}
	}
}