JAVA泛型

public void test1(){
    ArrayList list = new ArrayList();

    list.add(78);
    list.add(76);
    list.add(77);
    list.add(99);
    //问题一：类型不安全
    list.add("sss");
    for (Object score:list){
        //问题二：强制转换时会出异常：ClassCastException
        int stuScore = (int) score;
        System.out.print(stuScore+"   ");
    }//78   76   77   99 
}

• 使用泛型之后：（泛型不能用基本数据类型）

    public void test2() {
        ArrayList list = new ArrayList();

        list.add(78);
        list.add(76);
        list.add(77);
        list.add(99);
        //编译时就会进行类型检查，保证数据安全
        //list.add("sss");//此处会报错
        for (Integer score : list) {
            int stuScore = score;
            System.out.print(stuScore + "   ");
        }
        System.out.println();
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.print(stuScore + "   ");
        }
    }

• Map中的泛型

  public void test3() {
      HashMap map = new HashMap();
      map.put("Meiko",99);
      map.put("Scout",80);
      map.put("Viper",80);
      map.put("Flandre",88);
      map.put("Jiejie",90);
      //map.put(11,"1esa");//报错
  
      Set> entry = map.entrySet();
      Iterator> iterator = entry.iterator();
      while (iterator.hasNext()){
          Map.Entry entry1 = iterator.next();
          String key = entry1.getKey();
          Integer value = entry1.getValue();
          System.out.print(key+ " = " + value + "    ");
      }
  }
  

• Order泛型类

  public class Order  {
      String orderName;
      int orderId;
      //类的内部结构就可以使用类的泛型
      T orderT;
      public Order() {
      }
  
      public Order(String orderName, int orderId, T orderT) {
          this.orderName = orderName;
          this.orderId = orderId;
          this.orderT = orderT;
      }
  
      public T getOrderT() {
          return orderT;
      }
  
      public void setOrderT(T orderT) {
          this.orderT = orderT;
      }
  
      @Override
      public String toString() {
          return "Order{" +
                  "orderName='" + orderName + ''' +
                  ", orderId=" + orderId +
                  ", orderT=" + orderT +
                  '}';
      }
  }
  

• 测试

  public void test4() {
      //如果定义了泛型类，实例化没有指明类的泛型，则认为泛型的典型类型为Object类型
      Order order = new Order("AA",001,"333");
      System.out.println(order);
      //Order{orderName='AA', orderId=1, orderT=333}
  
  
  }
  

• 子类继承父类

  public class SubOrder extends Order{
  
  }
  

  public class SubOrder1 extends Order{
  
  }
  

• 测试

  public void test5() {
      SubOrder subOrder = new SubOrder();
      //由于子类在继承带泛型的父类时，指明了泛型类型，则实例化时不需要指明泛型
      //如：public class SubOrder extends Order
      subOrder.setOrderT(1122);
      //subOrder.setOrderId("12321");//此处会报错
  
      //如果不指名泛型类型则需要指明
      //如：public class SubOrder1 extends Order
      SubOrder1 subOrder1 = new SubOrder1<>();
      subOrder1.setOrderT("123");
      //subOrder1.setOrderT(123);//会报错
  
  
  }
  

• 注意事项

在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系

即泛型方法所属的类是不是泛型类都没有关系

• 定义示例：可以是静态方法

  原因：泛型方法中的泛型参数是在调用方法时确定的，并非是实例化时确定的，所以可以是静态方法

  public static  List copyFromArrayToList(E[] arr){    //将此方法加在之前Order类的里面，可以是静态方法    ArrayList list = new ArrayList<>();    for(E e:arr){        list.add(e);    }    return  list;}
  

• 调用示例：泛型方法调用时，指明泛型参数的类型

  //测试泛型方法public void test5() {    Order order = new Order<>();    Integer[] arr  = new Integer[]{1,2,3,4};    List list = order.copyFromArrayToList(arr);    System.out.println(list);//[1, 2, 3, 4]}
  

• DAO: data(base) access object 数据访问对象

import java.util.List;public class DAO {    //添加一条记录    public void add(T t){    }    //删除一条记录    public boolean remove(int index){        return false;    }    //修改一条记录    public void update(int index,T t){    }    //查询一条记录    public T getIndex(int index){        return null;    }    //查询多条记录    public List getForList(int index){        return null;    }}

• Customer类（相当于一个表）

public class Customer {//此类对应数据库中的一个表}

• CustomerDAO类：指定该类只能对Customer进行相关操作

  public class CustomerDAO extends DAO{}
  

• Student类：相当于另一个表

  public class Student {}
  

• StudentDAO类：指定该类只能对Student进行相关操作

  public class StudentDAO extends DAO{}
  

• 泛型方法

  //泛型方法//举例：获取表中一共有多条记录？获取最大的员工入职时间public  E getValue(){    return null;}
  

• 虽然类A是类B的父类，但是G 和G 二者不具备父子关系，二者是并列关系

  public void test1(){
      Object obj = null;
      String str = null;
  
      obj = str;//多态，子类可以赋值给父类
  
      Object[] arr1 = null;
      String[] arr2 = null;
      arr1 = arr2;//多态，子类可以赋值给父类
  
      List