java 泛型复习总结

使用泛型的好处

• 将运行时期的 ClassCastException 转移到了编译时期变成了编译失败
• 避免的类型转换的麻烦

泛型的通配符

• 假定有两个集合实现类 ArrayList 和 HashSet ，他们装载的数据类型不同，如何定义一个方法能同时迭代两个集合？

  public class GenericCollection {
  	public static void main(String[] args) {
  		List<String> list = new ArrayList<String>();
  		list.add("lhg");
  		list.add("abc");
  		
  		Collection<Integer> set = new HashSet<Integer>();
  		set.add(123);
  		set.add(456);
  		iterator(list);
  		iterator(set);
  	}
  	/**
  	 * 定义一个方法，可以同时迭代两个集合
  	 * @param coll 泛型的通配，匹配所有数据类型
  	 */
  	public static void iterator(Collection<?> coll){
  		Iterator<?> it = coll.iterator();
  		while (it.hasNext()) {
  			System.out.println(it.next());
  		}
  	}
  }
  
  

泛型的限定

• 定义一个公共抽象父类

  /*
   *  酒店的员工类
   *    员工共性, 姓名,工号 工作方法
   */
  public abstract class Employee {
  	private String name;
  	private String id;
  	public Employee(){}
  	public Employee(String name,String id){
  		this.name = name;
  		this.id = id;
  	}
  	public abstract void work();
  }
  

• 具体的实现类

  /*
   *  定义厨师类
   *    属于员工一种,具有额外服务功能
   *    继承Employee,实现VIP接口
   */
  public class ChuShi extends Employee{
  	//空参数构造方法
  	public ChuShi(){}
  	//有参数构造方法
  	public ChuShi(String name,String id){
  		super(name,id);
  	}
  	//抽象方法重写
  	public void work(){
  		System.out.println("厨师在炒菜");
  	}
  	public void services(){
  		System.out.println("厨师做菜加量");
  	}
  }
  

  /*
   *  定义厨师类
   *    属于员工一种,具有额外服务功能
   *    继承Employee,实现VIP接口
   */
  public class FuWuYuan extends Employee{
  	//空参数构造方法
  	public FuWuYuan() {
  		super();
  	}
     //满参数构造方法
  	public FuWuYuan(String name, String id) {
  		super(name, id);
  	}
  	//抽象方法重写
  	public void work(){
  		System.out.println("服务员在上菜");
  	}
  	public void services(){
  		System.out.println("服务员给顾客倒酒");
  	}
  }
  

  /*
   *  定义经理类
   *    属于员工一种,没有VIP功能
   *    自己有奖金属性
   */
  public class JingLi extends Employee {
  	//空参数构造方法
  	public JingLi(){}
  	//满参数构造方法
  	public JingLi(String name,String id){
  		super(name, id);
  	}
  	//重写抽象方法
  	public void work(){
  		System.out.println("管理,谁出错我罚谁");
  	}
  }
  

• 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work

  public class GenericTest {
  	public static void main(String[] args) {
  		//创建3个集合对象
  		ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
  		ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
  		ArrayList<JingLi> jl = new ArrayList<JingLi>();
  		
  		//每个集合存储自己的元素
  		cs.add(new ChuShi("张三", "后厨001"));
  		cs.add(new ChuShi("李四", "后厨002"));
  		
  		fwy.add(new FuWuYuan("翠花", "服务部001"));
  		fwy.add(new FuWuYuan("酸菜", "服务部002"));
  		
  		jl.add(new JingLi("小名", "董事会001"));
  		jl.add(new JingLi("小强", "董事会002"));
  		
  		//方法已经进行了限定，如果不是继承自 Employee 类的对象会在编译期报错
  //		ArrayList<String> arrayString = new ArrayList<String>();
  		iterator(jl);
  		iterator(fwy);
  		iterator(cs);
  	}
  	/*
  	 * 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work
  	 * ? 通配符,迭代器it.next()方法取出来的是Object类型,怎么调用work方法
  	 * 强制转换:  it.next()=Object o ==> Employee
  	 * 方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
  	 * 泛型的限定  本案例,父类固定Employee,但是子类可以无限?
  	 *   ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
  	 *   ? super   Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
  	 */
  	public static void iterator(ArrayList<? extends Employee> array){
  		 Iterator<? extends Employee> it = array.iterator();
  		 while(it.hasNext()){
  			 //获取出的next() 数据类型,是什么Employee
  			 Employee e = it.next();
  			 e.work();
  		 }
  	}
  }