精华内容
下载资源
问答
  • 泛型通配符
    2021-08-21 19:51:47

    1.泛型通配符:

             - 通配符的基本使用

             - 通配符的高级使用 --> 受限泛型

    2.通配符的基本使用:

    泛型的通配符:

            不知道使用什么类型来接收的时候,此时可以使用【?】
            ? 表示未知通配符
    注意:不能往该集合中存储数据,只能获取数据

    public class Tests {
        public static void main(String[] args) {
    
            // 关系: String类继承Object类
            ArrayList<Object> list1 = new ArrayList<>();
            ArrayList<String> list2 = new ArrayList<>();
            list2.add("donglan");
    
            // 关系: Integer类继承Number    Number类继承Object类
            ArrayList<Integer> list3 = new ArrayList<>();
            ArrayList<Number> list4 = new ArrayList<>();
    
            //method0(list1);
            method0(list2);
            //method0(list3);
            //method0(list4);
    
            method1(list1);
            //method1(list2);   编译报错  因为方法中的形参ArrayList<Object> 只能接收Object
                                            类型的,泛型不存在多态
            //method1(list3);   编译报错  因为方法中的形参ArrayList<Object> 只能接收Object
                                            类型的,泛型不存在多态
            //method1(list4);   编译报错  因为方法中的形参ArrayList<Object> 只能接收Object
                                            类型的,泛型不存在多态
    
            method2(list1);
            method2(list2);
            method2(list3);
            method2(list4);
    
        }
        //定义一个方法,可以接收以上4个集合对象
        public static void method0(ArrayList list){
            Object obj = list.get(0);
            list.add("zhangsan");
            System.out.println("obj   :"+obj);
            System.out.println("list:   "+list);
        }
    
        //定义一个Object的集合对象
        public static void method1(ArrayList<Object> list){
        }
    
        //定义一个通配符的集合对象
        public static void method2(ArrayList<?> list){
            //Object obj = list.get(0);
            //list.add("zhangsan");     编译报错,如果我们使用了通配符泛型,不能往该集合中存储数据,只能获取数据
            //System.out.println("obj:  "+obj);
            list.remove("donglan"); // 可以删除,不能添加
            System.out.println("list:  "+list);
        }
    }

    3.通配符高级使用 --> 受限泛型

    上限:

            <? extends 类名> 只能接收该类类型或者其子类类型
    下限:

             <? super 类名>   只能接收该类类型或者其父类类型

    import java.util.ArrayList;
    
    public class Tests {
        public static void main(String[] args) {
    
            // 关系: String类继承Object类
            ArrayList<Object> list1 = new ArrayList<>();
            ArrayList<String> list2 = new ArrayList<>();
    
            // 关系: Integer类继承Number    Number类继承Object类
            ArrayList<Integer> list3 = new ArrayList<>();
            ArrayList<Number> list4 = new ArrayList<>();
    
            method1(list1);
            method1(list2);
            method1(list3);
            method1(list4);
    
            method2(list1);
            method2(list2);
            method2(list3);
            method2(list4);
    
            //method3(list1); 编译报错,因为方法参数是 上限为Number,
            //method3(list2); 编译报错,因为方法参数是 上限为Number,
            method3(list3);
            method3(list4);
    
            method4(list1);
            //method4(list2);   编译报错,因为方法参数是 下限为Integer
            method4(list3);
            method4(list4);
        }
    
        // 定义一个方法,可以接收以上四种集合对象
        public static void method1(ArrayList list){
        }
    
        //定义一个方法,可以接收以上四种集合对象
        public static void method2(ArrayList<?> list){
        }
    
        // 定义一个方法,只可以接收list3和list4集合对象
        public static void method3(ArrayList<? extends Number> list){
        }
    
        // 定义一个方法,只可以接收list1,list3,list4集合对象
        public static void method4(ArrayList<? super Integer> list){
        }
    }

    更多相关内容
  • 泛型从字面上理解,是指一个类、接口或方法支持多种类型,使之广泛化、一般化和更加通用。通配符只有在修饰一个变量时会用到,使用它可方便地引用包含了多种类型的泛型;下面我们来深入了解一下吧
  • 主要介绍了Java中泛型通配符的使用方法,结合实例形式分析了java中泛型通配符的功能、语法及在泛型类创建泛型对象中的使用方法,需要的朋友可以参考下
  • 主要介绍了java泛型常用通配符实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 泛型通配符的作用,通配符上界,通配符下界,List<?>

    泛型通配符的作用

    为了让大家更好地理解泛型通配符的作用及使用场景,我们先来看一个例子:
    我们假定有一个抽象类Shape,它有一个抽象方法draw,我们规定draw方法将会打印一串描述性的字符串。TriangleRectangleCircleShape的子类,均重写了draw方法()。

    // 超类
    abstract class Shape{
    	/**
    	** draw方法将会打印一串描述性的字符串
    	**/
        abstract protected void draw();
    }
    
    class Triangle extends Shape{
        @Override
        protected void draw() {
            System.out.println("draw a Triangle");
        }
    }
    class Rectangle extends Shape{
        @Override
        protected void draw() {
            System.out.println("draw a Rectangle");
        }
    }
    class Circle extends Shape{
        @Override
        protected void draw() {
            System.out.println("draw a Circle");
        }
    }
    

    我们现在有这样一个需求:我们需要提供一个方法,它能够接受任意一个Shape,然后在方法内部调用它的draw方法。
    我们可以利用方法可以重载这一特性来实现:

        public static void shapeToDraw(Triangle triangle){
            triangle.draw();
        }
    
        public static void shapeToDraw(Rectangle rectangle){
            rectangle.draw();
        }
    
        public static void shapeToDraw(Circle circle){
            circle.draw();
        }	
    
    	// 调用
    	shapeToDraw(new Triangle());	// 打印draw a Triangle
    	shapeToDraw(new Circle());	// 打印draw a Circle
    

    我们可以为每一种具体的子类实现一个特定的方法,所有的方法除了入参以外完全一样。编译器会根据实际传入的参数类型帮我们判断哪一个方法是我们真正需要的。 虽然方法的重载非常有用,但是用在此处却不太合适。想象一下,如果Shape有100个子类,为了兼顾所有的情况,我们需要提供100个对应的方法!

    稍微有一点经验的开发者很容易想到下面的实现:

    	public static void shapeToDraw(Shape shape){
    	    shape.draw();
    	}
    	                                                          
    	// 调用
    	shapeToDraw(new Triangle());	// 打印draw a Triangle
    	shapeToDraw(new Circle());	// 打印draw a Circle
    

    shapeToDraw(Shap shap)方法接收一个抽象的Shape,而不是具体的子类。得益于Java的多态性,该程序可以正常地运行,且具备一定的扩展性。例如,如果后续我们为Shape再添加一个子类Square,该方法不需要做任何修改。

    现在,我们的需求发生了变化: 我们需要提供一个方法,它能够接受任意一个Shape集合,然后在方法内部依次调用集合元素的draw方法。(为了简化问题,我们假定集合特指List)
    有了上面需求的经验,我们可以很容易地得到如下实现:

        public static void shapesToDraw(List<Shape> shapes){
            for (Shape shape : shapes){
                shape.draw();
            }
        }
    

    shapesToDraw方法接受一个List<Shape>,在方法内部迭代调用draw方法。由于List<Shape>里面可以装载Shape的所有子类,因此这个实现看起来似乎是完美的。但是如果使用者传入的是一个List<Circle>呢?该方法还能正常运行吗?答案是不能。该方法不能接收List<Circle>作为入参,原因是:一个List<Circle>并不是一个List<Shape>,这确实让人感到非常费解,因为CircleShape的子类,那么一个Circle就是一个Shape,为什么一个List<Circle>不能是一个List<Shape>呢?
    要想理解这个悖论,我们可以看一下下面这个例子:

    // 先初始化一个 List<Shape> 和一个 List<Circle>
    List<Shape> shapeList;
    List<Circle> circleList = new ArrayList<>();
    // 我们假定一个 List<Circle> 是一个 List<Shape>,那么这样赋值是完全没有问题的
    shapeList = circleList; 	//实际上编译不能通过
    
    // 往List<Shape>中添加一个Triangle,这当然没有任何问题
    shapeList.add(new Triangle());
    // 因为 shapeList 与 circleList 指向同一个List,因此往 shapeList 中添加的元素通过 circleList 当然可以访问到
    // 但是 circleList 是一个 List<Circle>,因此调用get方法应该返回一个Circle ,然而实际上,该位置存放的却是一个Triangle!
    Circle circle = circleList.get(0);		// 转型错误!
    

    由于将一个List<Circle> 当成一个 List<Shape> 会出现上述问题,因此,Java 语言规定, 即使集合之间的元素存在继承关系,也不能认为泛型的集合之间存在继承关系,

    显然这不是我们希望的,因为使用者当然希望程序将一个 List<Circle> 看做是一个 List<Shape>。那么该如何实现呢?答案是:泛型通配符。
    我们只需要将上述程序稍作修改,就能满足现在的需求:

        public static void shapesToDraw(List<? extends Shape> shapes){
            for (Shape shape : shapes){
                shape.draw();
            }
        }
    

    List<? extends Shape>描述了这样一类ListList的泛型类型是Shape的子类(当然也可以是Shape本身)。 这一点是非常重要的,在使用泛型通配符之前,我们只能描述List内部元素的类型,如List<Shape>描述了一个内部元素是Shape子类(因为Shape是一个抽象类)的List。而有了泛型通配符以后,我们拥有了描述泛型类型的能力!

    泛型通配符上界

    基本语法形式:

    List<? extends Shape>
    

    它规定了泛型类型的上界。也就是说,如果使用上述表达式作为某个方法的入参,那么在实际调用方法时,可以传入的泛型类型必须为 Shape的子类。另外还有一点需要特别注意:

    因为我们只知道泛型类型是Shape的子类而不能确定其具体的泛型类型,因此往该List中添加任何元素都是非法的(会引起编译错误)。

    我们可以这样理解这句话:
    我们只知道 List<? extends Shape> 接受的 List 泛型是 Shape 的子类,因此它既可以是List<Circle> 也可以是List<Triangle>,还可以是List<Rectangle>。当我们想要往这个List中添加数据的时候会发生什么?我们根本不知道应该向它传入什么样的数据!!! 我们应该向它传入一个Circle吗?如果调用方法的时候实际传入的参数是一个List<Triangle>怎么办?List<Triangle>并不能装载一个Circle!那我们向它传入一个Triangle?一个Rectangle?都不行!不论我们向它传入什么类型的对象,我们都会遇到前面的问题。最根本的原因是:我们无法确定泛型的类型,因此我们无法确定应该向该List添加什么类型的元素

    当我需要从List<? extends Shape>中取出元素的时候,会发生什么呢?
    因为我们知道List<? extends Shape>实际的泛型类型一定是Shape的子类,那么List中的元素类型也一定是Shape的子类,因此我们使用Shape或者Shape的父类(本例中Shape没有父类)去接收取出的元素一定是安全的。

    泛型通配符下界

    基本语法形式:

    List<? super Triangle>
    

    它规定了泛型类型的下界。也就是说,如果使用上述表达式作为某个方法的入参,那么在实际调用方法时,可以传入的泛型类型必须为 Triangle的父类(当然也包括Triangle本身)。在本例中,传入的参数类型可以是List<Triangle>List<Shape>,当然也可以是List<Object>。另外还有一点需要特别注意:

    因为我们只知道泛型类型是Triangle的父类而不能确定其具体的泛型类型,因此从该List取出元素的时候,我们不能知道该元素的确切类型。但是我们知道,任何一个类都是Object的子类,因此可以使用Object来接收该元素,除此之外的其他任何类型都不行。(但是得到一个Object类型的元素对我们来说似乎没有太大的作用,因为我们使用泛型就是希望能够得到更加确切的数据类型,而不是一个笼统的Object)

    当我们需要往List<? super Triangle>中添加元素的时候,会发生什么呢?
    因为我们知道List<? super Triangle>实际的泛型类型一定是Triangle的父类,那么List中的元素类型也一定是Triangle的父类,因此我们往List中添加Triangle或者Triangle的子类元素一定是安全的。

    基于上述原因,阿里巴巴Java开发手册中规定:
    在这里插入图片描述

    List<?>

    通过上面的分析我们已经知道了List<?>表示List的泛型类型(一定要注意是泛型类型,而不是元素类型)可以为任意类型。也就是说如果一个方法签名的参数是List<?>,那么实际传入的类型可以是List<Shape>List<Circle>List<Object>或者任意一个带泛型的List(甚至可以是不带泛型的List)。
    当我们试图往这个List中插入元素的时候,我们会得到一个编译错误,原因是我们无法得知泛型的确切类型(与上文上界通配符中的解释一致)。
    当我们试图从这个List中取出元素的时候,我们只能得到一个Object(与上文下界通配符中的解释一致)。

    结论

    1. 泛型通配符定义的是泛型的类型,而不是集合元素的类型;
    2. 上界通配符,形如<? extends T>适合频繁往外读取数据的场景;
    3. 下界通配符,形如<? super T>适合频繁插入数据的场景;
    4. 无法往List<?>插入任何数据,只能从List<?>中得到Object类型的元素。
    展开全文
  • 所以,接下来我们将会对泛型通配符的学习--泛型通配符的高级使用! ????泛型通配符 在我们之前的学习泛型的过程当中,在当我们使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>...

    这是我参与11月更文挑战的第7天,活动详情查看:2021最后一次更文挑战」。

    茫茫人海千千万万,感谢这一秒你看到这里。希望我的文章对你的有所帮助!

    愿你在未来的日子,保持热爱,奔赴山海!

    前言:昨天我们终于讲完了泛型通配符的基本使用,

    所以,接下来我们将会对泛型通配符的学习--泛型通配符的高级使用!

    👺泛型通配符

    在我们之前的学习泛型的过程当中,在当我们使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

    😟5.2 通配符高级使用

    之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限下限

    泛型的上限

    • 格式类型名称 <? extends 类 > 对象名称
    • 意义只能接收该类型及其子类

    泛型的下限

    • 格式类型名称 <? super 类 > 对象名称
    • 意义只能接收该类型及其父类型

    比如:现已知Object类,Animal类,Dog类,Cat类,其中Animal是Dog,Cat的父类

    class Animal{}//父类
    ​
    class Dog extends Animal{}//子类
    ​
    class Cat extends Animal{}//子类
    复制代码
    • 首先我们先看下,泛型的上限<? extends 类 >

      //        ArrayList<? extends Animal> list = new ArrayList<Object>();//报错
              ArrayList<? extends Animal> list2 = new ArrayList<Animal>();
              ArrayList<? extends Animal> list3 = new ArrayList<Dog>();
              ArrayList<? extends Animal> list4 = new ArrayList<Cat>();
      复制代码

      可以看出,泛型的上限只能是该类型的类型及其子类。

    • 我们再来看看泛型的下限<? super 类 >

              ArrayList<? super Animal> list5 = new ArrayList<Object>();
              ArrayList<? super Animal> list6 = new ArrayList<Animal>();
      //        ArrayList<? super Animal> list7 = new ArrayList<Dog>();//报错
      //        ArrayList<? super Animal> list8 = new ArrayList<Cat>();//报错
      复制代码

      可以看出,泛型的下限只能是该类型的类型及其父类。

    • 一般泛型的上限和下限也是用来参数的传递:

    • http://www.360doc.com/content/21/1104/07/46403850_1002672849.shtml
      http://www.360doc.com/content/21/1107/21/46403850_1003191175.shtml
      http://www.360doc.com/content/21/1107/21/46403850_1003190908.shtml

      再比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();
        
        getElement(list1);
        getElement(list2);//报错
        getElement(list3);
        getElement(list4);//报错
      
        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
      
    }
    // 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
    复制代码

    学到这里,我们泛型也就学完了!

    🌸总结

    相信各位看官都对泛型有了全部的深入的了解和体验,在平时开发,比较常见使用在泛型的使用有集合框架中的List和Map。当然还有很多的应用,期待你慢慢发现!

    那我们继续期待欢迎期待下一章的到来!

    让我们也一起加油吧!本人不才,如有什么缺漏、错误的地方,也欢迎各位人才大佬评论中批评指正!当然如果这篇文章确定对你有点小小帮助的话,也请亲切可爱的人才大佬们给个点赞、收藏下吧,一键三连,非常感谢!

    https://gitee.com/numerical-control-system
    https://www.thinksaas.cn/user/space/50002/
    https://zhuanlan.zhihu.com/p/430534517
    https://zhuanlan.zhihu.com/p/430536898
    https://zhuanlan.zhihu.com/p/430537972


     

    展开全文
  • 泛型和泛型通配符

    2020-12-03 21:02:18
    泛型 泛型:是一种未知的数据类型,当我们不知道要是用什么样的数据类型的时候,可以使用泛型泛型我们也可以看做是一个变量,用来接收数据类型。 E e:element 元素 T t: type 类型 ArrayList在定义集合的时候,不...

    泛型

    泛型:是一种未知的数据类型,当我们不知道要是用什么样的数据类型的时候,可以使用泛型。泛型我们也可以看做是一个变量,用来接收数据类型。
    E e:element 元素
    T t: type 类型
    ArrayList在定义集合的时候,不知道在集合当中存储什么类型的数据,所以类型使用泛型。E: 未知的数据类型。
    在这里插入图片描述
    概述:可以在类中或方法当中预知的使用未知的数据类型。一般在创建对象的时候,将未知的数据类型确定为具体的数据类型,当没有指定泛型时,默认类型是Object。


    使用泛型的好处

    1. 避免了类型转换的麻烦,存储的是什么样的数据类型,取出的就是什么样的数据类型。
    2. 把运行时异常(代码运行之后会抛出异常)提升到编译器阶段(写代码时就报错)。
      备注:泛型其实也是数据类型的一部分,一般我们将类名与泛型合并在一起看做数据类型。

    泛型的定义和使用

    泛型用来灵活的将数据类型应用到不同的类,方法,接口当中,将书库类型作为参数进行传递。

    定义

    修饰符 class 类名<代表泛型的变量>{
          //  ....
    }
    

    例如

    public class ArrayList<E>{
      public boolean add(E e){
        }
        public E get(int index){ 
        }
        //...
    }
    

    备注: 定义的时候使用未知的泛型的变量,使用的需要确定泛型具体类型。

    定义并使用含有泛型的方法

    定义格式:

    修饰符 <代表泛型的变量> 返回值类型 方法名(泛型参数){}
    

    例如:

    public class GenericMethod{
        //带有泛型的方法
     public <VIP> void show(VIP vip){
      System.out.println(vip);
       }
       //定义一个含有泛型的返回值
       public <VIP> VIP show02(VIP vip){
       //...
       return vip;
       }
    }
    
    public class Test{
    public static void main(String []args){
        //创建对象
        GenericMethod gm=new GenericMethod();
        //调用带有泛型的方法
        gm.show("abc");//VIP vip 形参  String str  str="abc"
        gm.show(123);// VIP--->Integer   vip=123;
      
    }
    
    }
    

    定义并使用泛型的接口

    定义格式:

    修饰符 interface 接口名 <代表泛型的变量>{}
    

    例如:

    public interface Collection<E>{
      public void add(E e);
      public Iterator<E> iterator();
    }
      //自定义一个泛型接口
    public interface AInterface<T>{
        public abstract void add(T t);
        public abstract T get();
        //....
    }
    

    使用格式:
    1.定义实现类是可以确定泛型的类型

    public class Test implements AInterface<String>{
      @ Override
            public void add(T t){
            //....
        }
        @ Override 
            public String get(){
        //.....
        }
    }
    

    备注:此时泛型的值就是String类型

    2.1始终不知道泛型的类型,直到创建对象的时候才可以确定。

    public class MyInterfaceimpl02<T> implements AInterface<T>{
     @ Override
            public void add(T t){
            //....
        }
        @ Override 
            public T get(){
        //.....
        }
    
    }
    

    2.2确定泛型

    /*
    使用泛型
    */
    
    public class Demo04Generic{
        public static void main(String []args){
            MyInterface<String> my=new MyInterfaceImpl<String>();
            my.add("abc");
            
        }
        
    }
    

    泛型的通配符

    当使用泛型类或者泛型接口的时候,传递的数据中,泛型的类型不确定,我们可以通过通配符<?>,一旦使用泛型通配符之后,就只能使用Object类中的共性方法,集合当中元素自身的方法无法使用。

    通配符的基本使用

    当不知道使用什么类型来接收的时候,此时可以使用<?>来表示,代表未知的通配符。此时只能接受数据,不能往该集合中存储数据。

    public static void main(String []args){
        
        //可以存储整数的集合
        Collection<Integer>  list= new ArrayList<>();
        //此时list可以存储整数的数据 
        //展示list集合当中的数据
        
        gerElement(list);
        //存储String字符串的集合
        Collection<String> list2=new ArrayList<>();
        //此时list可以存储字符串的数据 
        
    }
    
    
    public static void gerElement( Collection<> coll){
        //可以接收Integer数据
        //此时? 可以代表任意类型
    }
    

    备注:泛型不存在继承关系。

    通配符的高级用法—受限泛型

    之前使用泛型的时候,实际上是可以直接设置的,只要是类就可以,但是在java的泛型中,还可以指定一个泛型上限和下限。

    泛型的上限

    • 格式: 类型名称<? extends 类名>对象名
    • 意义:只能接收该类型及其子类

    泛型的下限

    • 格式:类型名称<? super 类名>对象名
    • 意义:只能接收该类型及其父类

    比如说:已知顶级父类Object String Integer Number ,Integer是Number的子类。

    public static void main(String []args){
        
          Collection<Integer> list1=new ArrayList<>();
          Collection<String> list2=new ArrayList<>();
          Collection<Number> list3=new ArrayList<>();
          Collection<Object> list4=new ArrayList<>();
        
        
    }
    //定义方法  可以接收任意类型
    public static void getElement(Collection<?> coll){
        //...
    }
        //定义方法,只能接收数字类型   Number类和它的子类
    public static void getElement(Collection <? extends Number> coll){
        //...
    }
        //定义方法,接收Number类型及其以上类型
    public static void getElement(Collection<? super Number> coll){
        //...
    }
    
    展开全文
  • 泛型通配符的使用场景 Java泛型支持通配符,可以单独使用一个“?”表示任意类,也可以使用extends关键字表示某一个类(接口)的子类型,还可以使用super关键字表示某一个类(接口)的父类型,但问题是什么时候该用...
  • 泛型通配符详解

    2020-03-28 10:00:48
    为什么要用通配符呢? 在java中,数组是可以协变的,比如dog extends Animal,那么Animal[] 与dog[]是兼容的。...在学习Java泛型的过程中, 通配符是较难理解的一部分. 主要有以下三类: 1. 无边界的通配符(Unb...
  • Java泛型 通配符详解

    千次阅读 多人点赞 2019-09-15 21:54:35
    对于类型>,编译器将只允许写操作,不允许读操作。即只可以设值(比如set操作),不可以取值(比如...,此时这个形参E就变成了一个涉及了通配符的类型;而不允许的读操作有get函数,因为它的函数签名是E get(int index)
  • 在实例化对象的时候,不确定泛型参数的具体类型时,可以使用通配符进行对象定义 目录 通配符的使用 使用通配符后数据的读取和写入 有限制条件的通配符的使用 通配符的使用 如果类 A 是类 B 的父类,G <A&...
  • 泛型通配符(?)

    2020-12-03 21:37:48
    当使用泛型类或者泛型接口,传递数据中,泛型的类型不确定,可以通过通配符<?>表示。一旦程序当中使用泛型通配符后,只能使用Object类中的共性的方法,集合中元素本身方法无法使用 此时只能接收数据,不能往...
  • 对于不确定或者不关心实际要操作的类型,可以使用无限制通配符(尖括号里一个问号,即 ),表示可以持有任何类型目录:上界通配符 上界: 用 extends 关键字声明,表示参数化的类型可能是所指定的类型,或者是此类型...
  • T和?,首先要区分开两种不同的场景: 声明一个泛型类或泛型方法。 使用泛型类或泛型方法。 类型参数 T 主要用于第一种,声明泛型类或泛型...无界通配符 ?主要用于第二种,使用泛型类或泛型方法 如下图所示 ...
  • 泛型通配符<?> 泛型继承 list1与list2之间根本没有关系,它们是相互独立的. ArrayList<Object> list1 = null; ArrayList<String> list2 = null; list2 = list1; 编译不通过 list1 = list2; ...
  • Java集合框架——泛型通配符
  • 泛型通配符: ?:代表任意的数据类型 使用方式: 不能创建对象使用 只能作为方法的参数使用 */ import java.util.ArrayList; import java.util.Iterator; public class GenericWildcard { public static void...
  • Java泛型通配符和泛型限定

    千次阅读 2018-08-05 13:10:40
    类型通配符 类型通配符一般是使用?代替具体的类型实参(此处是类型实参,而不是类型形参)。当操作类型时不需要使用类型的具体功能时,只使用Object类中的功能,那么可以用 ? 通配符来表未知类型。例如 List&...
  • 关于泛型通配符理解

    2020-07-31 10:44:28
    泛型通配符不能在创建对象时使用 例如: 我们一般是在集合中使用泛型,但是如果在闯创建集合的时候使用,在添加数据时会出现编译报错 泛型通配符的正确使用方式是只能作为方法的参数使用 例如我们创建了多个存放...
  • 1、通配符不能用于泛型定义、不用创建泛型实例。只能用于泛型类的使用:声明变量、方法的参数。 2、? 是万能通配符 ,表示未知类型,类型参数赋予不确定类型、任意类型 list<?> list1 = new ArrayList&...
  • 泛型通配符

    2020-03-07 20:35:52
    泛型通配符 当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。 通配符基本使用 ...
  • 谈Java泛型通配符

    2018-11-08 17:25:57
    泛型通配符详解 为什么要用通配符呢? 在java中,数组是可以协变的,比如dog extends Animal,那么Animal[] 与dog[]是兼容的。而集合是不能协变的,也就是说List&lt;Animal&gt;不是List&lt;dog&gt;...
  • 所以,类型通配符是类型实参,而不是类型形参(泛型标识符)。 类型通配符的上限 ●语法 类/接口<? extends 实参类型> 要求该泛型的类型,只能是实参类型,或实参类型的子类类型 上限不能填充元素 取出的元素...
  • 我们在定义泛型类,泛型方法,泛型接口的时候经常会碰见很多不同的通配符,比如 T,E,K,V ,?等等,这些通配符又都是什么意思呢? ? 表示不确定的 java 类型 T (type) 表示具体的一个java类型 K V (key value) ...
  • 通配符基本使用2. 受限泛型 1. 通配符基本使用 假设有这样的需求:定义一个方法,可以遍历任意数据类型的ArrayList集合。 从前面已经知道,ArrayList 集合和 ArrayList、ArrayList 集合等不存在继承关系,所有方法...
  • Java 泛型通配符详解

    2021-12-16 10:52:32
    Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。 | ...
  • 12. 【强制】泛型通配符<? extends T>来接收返回的数据,此写法的泛型集合不能使用add方法,而<? super T>不能使用get方法, 两者在接口调用赋值的场景中容易出错。 说明:扩展说一下PECS(Producer ...
  • 泛型&泛型通配符

    2021-09-09 15:13:41
    泛型通配符: 数据结构 增强for循环: 泛型: 可以在类,接口,方法中使用,就是一种未知的数据类型,在使用的时候确定其具体数据类型 表达式: <泛型变量> 泛型变量可以是任意字母,一般写E 泛型的好处: 将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,066
精华内容 14,026
关键字:

泛型通配符

友情链接: fylis.rar