标签：java System println add 详解 泛型 new 中泛 out

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。