泛型

泛型的使用

1、jdk5.0新特性 2、在集合中使用泛型 总结： ①集合接口或集合类在jdk5.0时都修改为带泛型的结构。 ②在实例化集合类时，可以指明具体的泛型类型 ③指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法、构造器、属性等)使用到类的泛型的位置， 都指定为实例化时的泛型类型 比如：add(E e) ---> 实例化以后：add(Integer e) ④注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换 ⑤如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型 3、如何自定义泛型结构：泛型类、泛型接口、泛型方法 见GenericTest1

​
    @Test
   public void test2(){
//        在集合中的使用 :以HashMap为例
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("simple", 23);
        map.put("kenys", 25);
        map.put("niko", 30);
//        map.put(90,30);
//        泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry1 = iterator.next();
            String key = entry1.getKey();
            Integer value = entry1.getValue();
            System.out.println(key + "--->" + value);
​
​
        }
    }
​
    @Test
    public  void test1(){
        //在集合中的使用
        ArrayList<Integer> list=new ArrayList<>();
        list.add(78);
        list.add(76);
        list.add(34);
        list.add(216);
//        编译时，就会进行类型检查，保证数据的安全
//      list.add("hjj");
        for(Integer score:list){
            //避免了强转操作
            int stuScor=score;
            System.out.println(stuScor);
        }
​
    }

 

如何自定义泛型结构

@Test
public void test1(){
    //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
    //要求：如果大家定义的类是带泛型的，建议在实例化时要指明类的泛型
    Order order=new Order();
    order.setOrderT(123);
    order.setOrderT("Tom");
​
    //建议：实例化时指明类的泛型
    Order<String> order1=new Order<String>("ord",1001,"qwe");
    order1.setOrderT("ttt");
}
​
​
@Test
public void test2(){
    SubOrder sub1 = new SubOrder();
    //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
    sub1.setOrderT(1122);
​
}

 

自定义泛型类

public class Order<T> {
    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 static <E> List<E> copyFromArraytoList(E[] arr) {
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }
​
    //测试泛型方法
    @Test
    public void test3(){
        Order<String> order=new Order<>();
        Integer[] arr=new Integer[]{1,2,4,6};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArraytoList(arr);
        System.out.println(list);
    }
}

 

泛型在继承方面的表现

虽然类A是类B的父类，但是G<A>和G<B>二者不具备子父类关系 补充：类A是类B的父类，A<G>和B<G>也具有父子关系

通配符的使用 通配符：？ 类A和类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

 

有限制条件的通配符的使用 ? extends A: G<? extends A>可以作为G<A>和G<B>的父类，其中B是A的子类 ? super A: G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类

   @Test
    public void test1(){
​
        Object obj=null;
        String str=null;
        obj=str;
​
        Object[] arr1=null;
        String[] arr2=null;
        arr1=arr2;
        //编译不通过
//        Date date = new Date();
//        str=date;
        List<Object> list1=null;
        List<String> list2=null;
        //此时的List1和List2的类型不具有子父类关系
        //编译不通过
//        list1=list2;
        /*
        反证法：
        假设list1=list2；
        list1.add(123);导致混入非String的数据，出错
         */
​
    }
​
​
    @Test
    public void test2(){
        AbstractList<String> list1=null;
        List<String> list2=null;
        ArrayList<String> list3=null;
​
        list1=list3;
        list2=list3;
​
        List<String> list4=new ArrayList<>();
    }
​
        /*
    通配符的使用
       通配符：？
       类A和类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
     */
​
        @Test
        public void test3(){
            List<Object> list1=null;
            List<String> list2=null;
​
            List<?> list=null;
​
            list=list1;
            list=list2;
​
            List<String> list3=new ArrayList<>();
            list3.add("AA");
            list3.add("BB");
            list3.add("CC");
            list=list3;
            //添加：对于List<?>就不能向其内部添加数据
            //除了添加null之外
//            list.add("DD");
//            list.add(123);
​
            list.add(null);
            //获取(读取)：允许读取数据，读取的数据类型为Object
            Object o=list.get(0);
            System.out.println(o);//AA
​
​
        }
​
        public void print(List<?> list){
            Iterator<?> iterator = list.iterator();
            while (iterator.hasNext()){
                Object obj=iterator.next();
            }
        }
​
        /*
            3、有限制条件的通配符的使用
            ? extends A:
                      G<? extends A>可以作为G<A>和G<B>的父类，其中B是A的子类
​
            ? super A:
                      G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类
         */
        @Test
        public void test4() {
            List<? extends Person> list1 = null;
            List<? super Person> list2 = null;
​
            List<Student> list3 = new ArrayList<>();
            List<Person> list4 = new ArrayList<>();
            List<Object> list5 = new ArrayList<>();
​
            list1 = list3;
            list1 = list4;
//          list1=list5;
​
//          list2=list3;
            list2 = list4;
            list2 = list5;
​
            //读取数据
            list1=list3;
            Person p=list1.get(0);
            //编译不通过
//            Student s=list1.get(0);
​
            list2=list4;
            Object obj=list2.get(0);
//            Person obj=list2.get(0);
​
//            写入数据
//            编译不通过
//            list1.add(new Student());
​
//          编译通过
            list2.add(new Person());
            list2.add(new Student());
        }

 

自定义一个泛型类

定义一个泛型类DAO<T>，在其中定义一个Mao 成员变量，Map的键为String 类型，值为T类型。

分别创建以下方法： public void save(String id,T entity):保存T类型的对象到Map成员变量中 public T get(String id):从Map中获取id对应的对象 public void update(String id,T entity):替换map中Key为id的内容，改为entity对象 public List<T> list():返回map中存放的所有T对象 public void delete(String id):删除指定id对象

public class DAO<T> {
    private Map<String, T> map=new HashMap<>();
​
    //    保存T类型的对象到Map成员变量中
    public void save(String id, T entity) {
        map.put(id,entity);
    }
​
    //    从Map中获取id对应的对象
    public T get(String id) {
       return map.get(id);
​
    }
​
    //    替换map中Key为id的内容，改为entity对象
    public void update(String id, T entity) {
            if(map.containsKey(id)){
                map.put(id,entity);
            }
    }
​
    //    返回map中存放的所有T对象
    public List<T> list() {
        List<T> list=new ArrayList<>();
        Collection<T> values=map.values();
        for (T t:values){
            list.add(t);
        }
        return list;
    }
​
    //    删除指定id对象
    public void delete(String id) {
        map.remove(id);
    }
}

 

public class DAOTest {
    public static void main(String[] args) {
        DAO<User> dao = new DAO<>();
        dao.save("1001",new User(1001,34,"周杰伦"));
        dao.save("1002",new User(1002,30,"昆凌"));
        dao.save("1003",new User(1003,44,"蔡依林"));
​
        dao.update("1003",new User(1003,20,"方文山"));
​
        dao.delete("1002");
​
        List<User> list = dao.list();
//        System.out.println(list);
        list.forEach(System.out::println);// java8 新特性
    }
​
}