泛型

1. 解决元素存储的安全性问题

2. 解决获取数据元素时，需要类型强转的问题

	@Test
	public void test1() {
		List list = new ArrayList();
		list.add(60);
		list.add(20);
		list.add(new String("A"));
		//在使用泛型之前，任何Object及其子类对象都可以添加进来
		for (int i = 0; i < list.size(); i++) {
			//强制类型转换int类型会出现转化异常ClassCaseException
			int score = (Integer)list.get(i);
			System.out.println(score);
		}
	}

/*
 * 为什么使用泛型
 * 1.泛型实现了类的安全操作
 * 2.避免了大量类型转换
 * 泛型应用
 * 1.在集合中使用泛型
 * 2.自定义泛型类，泛型接口，方法
 * 3.泛型与类的关系
 * 4.通配符
 */
    //2.在集合中使用泛型
	//指定集合的类型约束
	@Test
	public void test2() {
		List<Integer> list = new ArrayList<Integer>();
		list.add(20);
		list.add(50);
		for (int i = 0; i < list.size(); i++) {
			int score = list.get(i);
			System.out.println(score);
		}
		//迭代器遍历
		Iterator<Integer> iterator = list.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}

Map泛型使用

	//3.Map的泛型使用
	@Test
	public void test3() {
		Map<String, Integer> map = new HashMap();
		map.put("jack", 66);
		map.put("Mark", 90);
		map.put("Mary", 98);
		
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for(Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key+":"+value);
		}
	}
	
	@Test
	public void test4() {
		Map<String, String> map = new HashMap();
		map.put("zhangsan", "USA");
		map.put("lisi", "China");
		for(Entry<String, String> entry : map.entrySet()) {
			System.out.println(entry.getKey()+":"+entry.getValue());
			System.out.println(entry);
		}
	}

1.泛型的声明   

 interface List<T> 和 class Test<K,V>     

其中，T,K,V不代表值，而是表示类型。这里使            

用任意字母都可以。常用T表示，是Type的缩写。     

2.泛型的实例化：    

 一定要在类名后面指定类型参数的值（类型）。如：          

List<String> strList = new ArrayList<String>();        

Iterator<Customer> iterator = customers.iterator();

T只能是类，不能用基本数据类型填充。

自定义泛型

	//自定义泛型
	@Test
	public void test5() {
		/*
		 * 1.实例化泛型类型对象时，指明泛型的类型，指明以后，对应的类中所有使用泛型的位置，都变成实例化中指定泛型
		 * 的类型
		 * 2.如果自定义泛型类，但在实例化没有使用，那么默认都是Object类型
		 */
		Order<Boolean> order = new Order<>();
		order.setT(true);
		System.out.println(order.getT());
		
		Order<String> order2 = new Order<>();
		order2.setT("Find X");
		System.out.println(order2.getT());
		
		order2.add();
		List<String> list = order2.list;
		System.out.println(list);
		
		//调用泛型方法，指明泛型方法的类
		Integer params = 32;
		Integer i = order.getE(params); 
		
		String[] strs = {"tom", "jack", "eric"};
		List<String> list1 = new ArrayList<>();
		List<String> list2 = order.copyToList(strs, list1);
		for(String value : list2) {
			System.out.println(value);
		}
	}
	
	//泛型与继承关系
	//若类A是B的子类，但List<A>不是List<B>子接口
	@Test
	public void test6() {
		Object obj = null;
		String str = "A";
		obj = str;
		Object[] obj1 = null;
		String[] str1 = new String[] {"A","B","c"};
		obj1 = str1;
		for(Object obj2 : obj1) {
			System.out.println(obj2);
		}
		List<Object> list = null;
		List<String> list1 = new ArrayList<>();
	}