java中泛型的详解

package com.day13.json;

import java.util.*;

/**
 * Author: Json
 * Date: 2021/10/5
 **/
public class TestJson {
    public static void main(String[] args) {
        System.out.println("泛型");
        //什么是泛型？
        // 泛型：标签
        //指明集合里装的东西 别的东西不让装 声明泛型后
        //使用泛型后 这个集合只能装你声明的类型
        //使用泛型后 取数据也不用转换数据类型
        //以ArrayList为例
        ArrayList list=new ArrayList();

        //存放数据
        list.add(123);
        list.add(123213);
        list.add(15423);
        list.add(167623);
        list.add(127653);


        //<Integer>  不能使用基本数据类型
        ArrayList<Integer> list1 =new ArrayList<Integer>();
        list1.add(23);
        list1.add(231);
        list1.add(232);
        list1.add(2332);
        //方式一
//        for (Integer integer:list1){
//            System.out.println(integer);
//        }

        //方式二  迭代器
//        Iterator<Integer> integer=list1.iterator();
//        while (integer.hasNext()){
//            System.out.println(integer.next());
//        }



        //在集合中使用泛型 HashMap为例
        //泛型标准写法
        Map<String,Integer> map=new HashMap<String, Integer>();
        //jdk7中 新特性：类型推断  后面可以省略
        //  Map<String,Integer> map=new HashMap<>();
        map.put("json",123);
        map.put("js32on",123213);
        map.put("js321on",1213);

        //一. 不使用泛型的遍历所有的key-value
        //entrySet();
//        Set set1=map.entrySet();
//        Iterator iterator1= set1.iterator();
//        while (iterator1.hasNext()){
//            Object obj=iterator1.next();
//            //entrySet 集合中元素都是entry  map 内部接口
//            Map.Entry entry=(Map.Entry) obj;
//            System.out.println(entry.getKey()+"===>"+entry.getValue());
//        }

        //二. 使用泛型的遍历所有的key-value
        //泛型的嵌套 Map.Entry支持泛型
        //Set<Map.Entry<String,Integer>>
        //解释 Set<定义Map.Entry类型<再Map.Entry中的数据key声明为String,Map.Entry中的数据key声明为Integer>>
        //Set 接收 map的entrySet()的值
       Set<Map.Entry<String,Integer>> set= map.entrySet();
       //迭代器 里 嵌套泛型 和 Set嵌套一个性质
       Iterator<Map.Entry<String,Integer>> iterator=set.iterator();
       //判断下一个 是否有数据
       while (iterator.hasNext()){
           //用Map.Entry 接口 泛型 接 迭代器数据
           Map.Entry<String,Integer> e=iterator.next();
           //取数据中的key
           String key=e.getKey();
           //取数据中的value
           Integer value=e.getValue();
           System.out.println(key+"===>"+value);
       }

       //方式二
        for (Map.Entry<String, Integer> stringIntegerEntry : map.entrySet()) {
            System.out.println(stringIntegerEntry.getKey()+"===>"+stringIntegerEntry.getValue());
        };



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


        //3. 自定义泛型结构 ：泛型类 泛型接口 泛型方法
        //如果定义了泛型类 实例化没有指明类的泛型 则认为此泛型类为Object类型
        //要求 ： 如果定义了类是带泛型的，建议在实例化时 指明类的泛型
        Order<Integer> o=new Order<>();
        o.setOrderNumber(1123);
        System.out.println(o.getOrderNumber());

        //泛型类 继承
        //第一种方式
        //public class SubOrder extends Order<Integer> {}  //子类不是泛型类
        SubOrder subOrder=new SubOrder();
        //由于子类在继承带泛型的父类时 指明了泛型类型
        //子类在实例化的时候 不在需要指明泛型
        subOrder.setOrderNumber(231231);
        System.out.println(subOrder.getOrderNumber());

        //第二种方式
       // public class SubOrder1<T> extends Order<T>{}  //子类还是泛型类
        SubOrder1<Integer> subOrder1=new SubOrder1<>();
        subOrder1.setOrderNumber(321231);
        System.out.println(subOrder1.getOrderNumber());

        //泛型个人理解 就是 以前变量或返回值 都需要指定数据类型
        // 泛型就是 把变量的数据类型  变成一个形参 传进来什么类型 这个变量就是什么类型
        //例子:  String name; //声明变量
        // T name; T 传什么name就是什么类型

        //泛型不同的引用不能相互赋值
        ArrayList<String> arrayList=null;
        ArrayList<Integer> arrayList1=null;
        //类型不同 不能相互赋值
      //  arrayList=arrayList1;

        //泛型要么都用 要么都不用

        //在静态方法中不能使用类的泛型
        // 异常类不能声明泛型类

        //不能这样声明
        //T[] arr=new T[10];
        //测试泛型方法
        List<Integer> list2= new TestJson().copyName(new Integer[]{1,23,432});
        System.out.println(list2);

        //通配符的使用
        // ?
//        List<Object> list3=null;
//        List<String> list4=null;
//        List<?> list5=null;
//        list5=list3;
//        list5=list4;

        //有限制条件的通配符使用
        //<? extends Number> 无穷小 Number
        //只允许泛型为Number及Number子类的引用调用

        //<? super Number> Number 无限大
        //只允许泛型为Number及Number父类的引用调用

        //<? extends Comparable>
        //只允许泛型为实现Comparable接口的实现类的引用调用



    }


    //通配符 形参
    public void testArr(List<?> arr){
        Iterator iterator =arr.iterator();
        while (iterator.hasNext()){
            Object obj= iterator.next();
            System.out.println(obj);
        }
    }
    //声明泛型方法
    //在方法中出现了泛型结构  泛型参数与类的泛型参数没有任何关系
    //<E> List<E> copyName(E[] arr)
    //第一个E 表明下面两个E 是个类型 不是一个对象
    //第二个E 返回值类型 为E
    //第三个E 传入的类型 为E
    public <E> List<E> copyName(E[] arr){
        ArrayList<E> list=new ArrayList<>();
        for (E e:arr){
            list.add(e);
        }
        return  list;
    }

}

标签：java,System,println,add,详解,泛型,new,中泛,out
来源： https://blog.csdn.net/Drug_/article/details/120619789