12.泛型

1.为什么要有泛型？

ArrayList<String> strings = new ArrayList<>();
        strings.add("123");//只能添加字符串

@Test
    public void test(){
        ArrayList arrayList = new ArrayList();
        //存放学生的成绩
        arrayList.add(123);
        arrayList.add(214);
        arrayList.add(187);
        arrayList.add(1877);
        arrayList.add(1321);
        arrayList.add(12311);       
        //问题一:类型不安全
        arrayList.add("Tom");
        for (Object object : arrayList){
            //问题二:强转时可能出错  java.lang.ClassCastException
            int stuScore = (Integer)object;
            System.out.println(stuScore);
        }
    }

//z在集合中使用泛型的情况
    @Test
    public void test2(){
        ArrayList<Integer> ints = new ArrayList<Integer>();
        //ints.add("dsd");编译不通过
        ints.add(123);
        ints.add(123);
        ints.add(123);
        ints.add(123);
        ints.add(123);
        Iterator<Integer> iterator = ints.iterator();
        while (iterator.hasNext()){
            //避免了强转操作
            System.out.println(iterator.next());
        }
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("tom",15);
        map.put("tom2",15);
        map.put("tom3",15);
        map.put("tom4",15);
        //Map.put(123,123)
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Map.Entry<String, Integer> next = iterator1.next();
            String key = next.getKey();
            Integer value = next.getValue();
            System.out.println(key + "  " + value);
        }
    }

map循环

HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
        hashMap.put("sd",12);
        hashMap.put("sd1",12);
        hashMap.put("sd2",12);
        hashMap.put("sd3",12);
        hashMap.put("sd4",12);
        hashMap.put("sd5",12);
        Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> next = iterator.next();
            String key = next.getKey();
            Integer value = next.getValue();
            System.out.println(key);
            System.out.println(value);
        }

2.在集合中使用泛型


3 自定义泛型结构
 自定义泛型类
 自定义泛型接口
 自定义泛型方法

@Test
    public void test(){
        //如果定义了泛型类,实例化没有指明泛型类型,则认为此泛型类为object类型
        //要求:如果大家定义的类时带泛型的,建议在实例化时指明类的泛型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("dsd000");

        //建议:实例化时指明泛型;
        Order<String> stringOrder = new Order<>();
        //stringOrder.setOrderT(123);编译错误
        stringOrder.setOrderT("AA");
        stringOrder.setOrderT("CC");
        stringOrder.setOrderT("DD");
        stringOrder.getOrderT();
        SubOrder subOrder = new SubOrder();
        subOrder.setOrderT(123);//由于子类在继承带泛型的父类时,指明了泛型类型,则实例化子类对象时,不再需要指明泛型
//        subOrder.setOrderT(123);
        SubOrder1<String> subOrder1 = new SubOrder1();
        subOrder1.setOrderT("123");
        //subOrder1.setOrderT(123);
    }

@Test
    public void test2(){
        //泛型不同的引用不能相互赋值
        ArrayList<String> arr = new ArrayList<>();
        ArrayList<Integer> arr1 = new ArrayList<>();
        //arr = arr1;
        //arr.addAll(arr1);
    }

//泛型方法:在方法中出现了泛型结构,泛型参数与类的泛型参数没有任何关系
    public static <E> List<E> copyFromArrayToList(E[] arr){//可以使用静态static,因为它不需要类的泛型确定,而是调用方法时确认;
    //第一个<E> 是方法中参数的泛型
    //第二个是List<E>返回类型list是带泛型的
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr){
            list.add(e);
        }
        return list;

    }
    //下面方法不是泛型方法
    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

@Test
    public void test3(){
        Order<String> objectOrder = new Order<String>();
        ArrayList<Integer> integerss = new ArrayList<>();
        integerss.add(223);
        integerss.add(223);
        integerss.add(223);
        integerss.add(223);

        Integer[] integers = new Integer[]{1, 2, 3, 4};
        int[] arr = new int[10];
        List<Integer> integers1 =objectOrder.copyFromArrayToList(integers);
        System.out.println(integers1);
//        System.out.println(integers12);
    }

creature没有继承Person，不能作为参数

4 泛型在继承上的体现



5 通配符的使用








第一个extends 必须是object或者是他的子类：上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
第二个super必须是本类或者是他的父类：使用时指定的类型不能小于操作的类，即>=

6 泛型应用举例

/**
 * describe:
 *
 * DAO: data(base) access object
 * @author suoliang
 * @create 2021-04-17:16
 */
public class DAO<T>//操作表的共性操作dao
{
    //添加一条记录;
    //....
    public void addC(T t){

    }

    //删除一条记录;
    //....
    public void remove(){}

    //修改一条记录;
    //....

    public void replace(){}
    //查询一条记录;
    //....
    public T getIndex(int index){
        return null;
    }

    //查询多条记录;
    //泛型方法:
    //举例:获取表中一共有多少条记录?long  获取最大员工入职时间:Date

    public <E> E getValue(){
        return null;
    }
}
class Customer{
    //此类对应数据库中的customers表

}
class CustomerDAO extends DAO<Customer>{//只能操作一个表的dao

}
class DAOTest{
    @Test
    public void test(){
        CustomerDAO customerDAO = new CustomerDAO();
        customerDAO.addC(new Customer());
    }
}

/**
 * describe:
 * 自定义泛型类
 *
 * @author suoliang
 * @create 2021-04-0:21
 */
public class Order<T> {
    String orderName;
    int orderid;

    //T类的内部结构就可以使用类的泛型
    T orderT;

    public Order(){
        T[] arr = (T[])new Object[10];//编译通过
    }


    public Order(String orderName,int orderid, T orderT){
        this.orderName = orderName;
        this.orderid = orderid;
        this.orderT = orderT;
    }
    //泛型方法:在方法中出现了泛型结构,泛型参数与类的泛型参数没有任何关系
    public static <E>List<E> copyFromArrayToList(E[] arr){//可以使用静态static,因为它不需要类的泛型确定,而是调用方法时确认;
        //第一个<E> 是方法中参数的泛型
        //第二个是List<E>返回类型list是带泛型的
        ArrayList<E> list = new ArrayList<>();

        for (E e : arr){
            list.add(e);
        }
        return list;

    }
    //下面方法不是泛型方法
    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 static void show(){  错误:因为静态方法,可以不new对象直接创建;但是没有
//        System.out.println(orderT);
//    }
}
class SubOrder extends Order<Integer>{//suborder不是泛型
    //子类继承带泛型的父类时,指明了泛型的类型,则在实例化子类对象时,不再需要指明泛型
}
class SubOrder1<T> extends Order<T>{}
class Creature{}
class Person extends Creature{}
class Man extends Person{}
class PersonTest {
    public static <T extends Person> void test(T t){
        System.out.println(t);
    }
    public void printCollection1(Collection c) {
        Iterator i = c.iterator();
        for (int k = 0; k < c.size(); k++) {
            System.out.println(i.next());
        } }
    public void printCollection(Collection<Object> c) {
        for (Object e : c) {
            System.out.println(e);
        } }
    public static void main(String[] args) {
        test(new Person());
        test(new Man());
        ArrayList arrayList = new ArrayList();
        arrayList.add(1);
        arrayList.add(1);
        arrayList.add(1);
        new PersonTest().printCollection(arrayList);

//The method test(T) in the type PersonTest is not
//applicable for the arguments (Creature)
        //test(new Creature());//
    }
    public static void addStr(List<? super Object> list){
        list.add(1);
        list.add(2);
        list.add(1);
    }
}