java---泛型

泛型：指明了集合存储数据的类型<数据类型>

泛型中的类

ArrayList<String> list = new ArrayList<String>();
  此时，变量E的值就是String类型
  class ArrayList<String>{ 
    public boolean add(String e){ }
    public String get(int index){  }
  }

  例如，ArrayList<Integer> list = new ArrayList<Integer>();
  此时，变量E的值就是Integer类型
  class ArrayList<Integer>{ 
       public boolean add(Integer e){ }
       public Integer get(int index){  }
  }

泛型方法

泛型的方法 :
定义格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
泛型方法的使用:
1:例如，API中的ArrayList集合中的方法：
public T[] toArray(T[] a){ }
//该方法，用来把集合元素存储到指定数据类型的数组中，返回已存储集合元素的数组
使用格式：
调用方法时，确定泛型的类型

例:
      ArrayList<String> list = new ArrayList<String>();
      String[] arr = new String[100];
      String[] result = list.toArray(arr);
   此时，变量T的值就是String类型。变量T，可以与定义集合的泛型不同
   public <String> String[] toArray(String[] a){  } 


  例如:
      ArrayList<String> list = new ArrayList<String>();
      Integer[] arr = new Integer[100];
      Integer [] result = list.toArray(arr);

  此时，变量T的值就是Integer类型。变量T，可以与定义集合的泛型不同
  public <Integer> Integer[] toArray(Integer[] a){  } 

泛型的接口

/*
      *  带有泛型的接口
      *  
      *  public interface List <E>{
      *    abstract boolean add(E e);
      *  }
      * 
      *  实现类,先实现接口,不理会泛型
      *  public class ArrayList<E> implements List<E>{
      *  }
      *  调用者 : new ArrayList<String>() 后期创建集合对象的时候,指定数据类型
      *  
      *  
      *  实现类,实现接口的同时,也指定了数据类型
      *  public class XXX implements List<String>{
      *  }
      *  new XXX()
      */
     public class GenericDemo2 {
      
     }

泛型的限定

   /*
    *  将的酒店员工,厨师,服务员,经理,分别存储到3个集合中
    *  定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法
    */
   import java.util.ArrayList;
   import java.util.Iterator;
   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", 123456789.32));
      jl.add(new JingLi("小强", "董事会002", 123456789.33));
      
   //   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();
       }
    }
   }