hpe实训课（泛型相关）

一.泛型：

*  1.泛型是JDK1.5出现的安全机制
*  2.避免了强制类型转化
*  3.限制了数据类型，保护了数据类型的安全
*  4.将运行期间引发的异常转到了编译期间。

二.什么时候使用泛型？

*  1.当操作的引用类型不确定的时候就要使用泛型<T|E>
*  2.其中<>就是一个用于接收具体数据类型的代表。(明确传入的具体引用数据类型)

三.使用泛型执行的流程

* 	在编译时，通过<>可以确保类型的安全，在运行时，会将泛型移除，因为兼容运行时类的加载器(ClassLoader)

四.泛型类

*     ①.泛型类定义和声明：在类名后面通过<>指定一个或者多个类型参数，同时还可以对类型参数取值范围进行限制，多个类型之间使用逗号分隔 public class Person<T,E>
* 	  ②.当实例化泛型类对象时，指定泛型的类型，指定后对应类的所有使用泛型的位置就已经确定为实例化中指定的类型
* 	  ③.如果自定义了泛型类，但是在实例化的时候没有使用，那么默认类型都是Object类型

五.泛型方法

*    ①.泛型方法的定义：在方法访问修饰符后面通过<>指定泛型方法的类型参数。
*    ②.泛型方法定义和所在的类是不是泛型类没有关系。

六.泛型接口(了解)

七.通配符

* 	  ①.?
* 	  ②.? extend A (向下限定)
*	  ③.? super A  (向下限定)    

具体实现例子

package com.hpe.generic;

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

import org.junit.Test;

public class TestGeneric {
	// 1.在没有使用泛型的情况
	@Test
	public void test1() {
		List list = new ArrayList();
		// 装箱
		list.add(95);
		list.add(87);
		list.add(78);
		// 没有使用泛型，任何Object及其子类对象都可以添加
		list.add(new String("pdd"));
		for (int i = 0; i < list.size(); i++) {
			// 在强制转化为int类型时，会引发类型转化异常：ClassCastException异常
			// 拆箱
			int obj = (int)list.get(i);
			System.out.println(obj);
		}
	}
	
	// 在集合中使用泛型
	@Test
	public void test2() {
		List<Integer> list = new ArrayList<Integer>();
		list.add(78);
		list.add(88);
		list.add(99);
		// 使用for循环遍历集合
		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());
			
		}
	}
	
	@Test
	public void test3() {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("张三", 80);
		map.put("李四", 88);
		map.put("王五", 90);
		// 方式一
		Set<String> set = map.keySet();
		for (String str : set) {
			// key = str value = map.get(key)
			System.out.println(str+"-"+map.get(str));
			
		}
		// 方式二
		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);
		}
		// 方式三
		for(Entry<String,Integer> entry : map.entrySet()) {
			System.out.println(entry.getKey()+"-"+entry.getValue());
		}
	}
	
	@Test
	public void test4() {
		List<Student> students = new ArrayList<Student>();
		students.add(new Student("张三", 20));
		students.add(new Student("李四", 21));
		students.add(new Student("王五", 22));
		
		for (Student student : students) {
			System.out.println(student);
		}
	}
	
	// 泛型类，泛型方法
	@Test
	public void test5() {
		// 创建一个泛型类
		Worker<String> worker = new Worker<String>();
		// 设置成员属性
		worker.setT("tom");
		// 调用成员方法
		worker.sayHello("jack");
		// 调用泛型方法
		worker.print(new Student("张三", 20));
		
		// 没有指定泛型的情况创建对象
		Worker w = new Worker();
		w.setT(true);
		System.out.println(w.getT());
		
		// 创建一个数组
		Integer[] in = new Integer[] {1,2,3};
		List<Integer> list = new ArrayList<Integer>();
		List<Integer> copyArrayToList = worker.copyArrayToList(in, list);
		System.out.println(copyArrayToList);
	}
	
	// 泛型接口
	@Test
	public void test6() {
		Dao<User> useDao = new UserDao();
		List<User> list = useDao.getList();
		for (User user : list) {
			System.out.println(user);
		}
		
		Dao<Admin> adminDao = new AdiminDao();
	}
	
	// 通配符
	@Test
	public void test7() {
		// ? extend A  :可以是A或者A的字类
		// ? super A   :可以是A或者父类
		List<String> list1 = new ArrayList<String>();
		List<Integer> list2 = new ArrayList<Integer>();
		List<Student> list3 = new ArrayList<Student>();
		List<Object> list4 = new ArrayList<Object>();
		List<Person> list5 = new ArrayList<Person>();
		show1(list3);
		show2(list4);
	}
	
	public void show(List<?> list) {
		System.out.println(list);
	}
	public void show1(List<? extends Person> list) {
		
	}
	public void show2(List<? super Student> list) {
		
	}
	
	// 对泛型集合中的数据进行排序
	@Test
	public void test8() {
		List<Person> list = new ArrayList<Person>();
		list.add(new Person("tom", 20));
		list.add(new Person("lim", 20));
		list.add(new Person("jack", 21));
		list.add(new Person("eric", 21));
		list.add(new Person("tina", 20));
		
		Collections.sort(list);
		
		for (Person person : list) {
			System.out.println(person);
		}
	}
	
}