精华内容
下载资源
问答
  • Java泛型的上限和下限

    千次阅读 2017-04-06 21:17:48
    原文博客:Java泛型4—泛型的上限和下限 在写程序的时候,我们希望某一个函数接收的参数,有一个范围的限制,这时候我们就可以考虑使用泛型的上限和下限去解决。class Point { private T x; private T y; public ...

    原文博客:Java泛型4—泛型的上限和下限
    在写程序的时候,我们希望某一个函数接收的参数,有一个范围的限制,这时候我们就可以考虑使用泛型的上限和下限去解决。

    class Point<T>
    {
        private T x;
        private T y;
    
        public T getX() {
            return x;
        }
    
        public void setX(T x) {
            this.x = x;
        }
    
        public T getY() {
            return y;
        }
    
        public void setY(T y) {
            this.y = y;
        }
    }
    
    public class Demo2 {
        static void show(Point<? extends Number> p)//此时这个函数只能接收Number及其子类 此时show(p2)会报错
        //static void show(Point<? super String> p)//此时这个函数只能接收String及其父类  此时show(p1)会报错
        {
            System.out.println(p.getX());
            System.out.println(p.getY());
        }
        public static void main(String[] args)
        {
            Point<Integer> p1 = new Point<Integer>();
            p1.setX(2);
            p1.setY(4);
            Point<String> p2 = new Point<String>();
            p2.setX("东经43度");
            p2.setY("北纬34度");
            show(p1);
            //show(p2);
        }
    }

    在这段程序中我们定义了一个函数show,我们在参数的后面使用的Point < ? > 这里的问号,表示的通配符,代表接收的实际参数的类型。
    我们可以看出来在程序中我先注释了entends的一行代码。这个表示参数的上限,接收的参数必须是Number或者是其子类,如果使用这个的时候,我们调用show方法的时候,传递p2会报错,因为p2不是Number或者其子类。
    同样的,我们使用super关键字,这个表示参数的上限,程序中表示接收的参数只能是String或者其父类,这时候show方法的参数是p1会报错,不满足下限的要求。

    展开全文
  • Java泛型4—泛型的上限和下限

    千次阅读 多人点赞 2011-11-27 20:37:58
    在写程序的时候,我们希望某一个函数接收的参数,有一个范围的限制,这时候我们就可以考虑使用泛型的上限和下限去解决。我们先看一段代码,然后再去详细解释。 class Point { private T x; private T y; ...

    【作者:孟祥月  博客:http://blog.csdn.net/mengxiangyue

    在写程序的时候,我们希望某一个函数接收的参数,有一个范围的限制,这时候我们就可以考虑使用泛型的上限和下限去解决。我们先看一段代码,然后再去详细解释。

    class Point<T>
    {
    	private T x;
    	private T y;
    	public T getX()
    	{
    		return x;
    	}
    	public void setX(T x)
    	{
    		this.x = x;
    	}
    	public T getY()
    	{
    		return y;
    	}
    	public void setY(T y)
    	{
    		this.y = y;
    	}
    }
    public class Demo2
    {
    //	static void show(Point<? extends Number> p)//此时这个函数只能接收Number及其子类 此时show(p2)会报错
    	static void show(Point<? super String> p)//此时这个函数只能接收String及其父类  此时show(p1)会报错
    	{
    		System.out.println(p.getX());
    		System.out.println(p.getY());
    	}
    	public static void main(String[] args)
    	{
    		Point<Integer> p1 = new Point<Integer>();
    		p1.setX(2);
    		p1.setY(4);
    		Point<String> p2 = new Point<String>();
    		p2.setX("东经43度");
    		p2.setY("北纬34度");
    		show(p1);
    		show(p2);
    	}
    }
    在这段程序中我们定义了一个函数show,我们在参数的后面使用的<? .....>这里的问号,表示的通配符,代表接收的实际参数的类型。我们可以看出来在程序中我先注释了entends的一行代码。这个表示参数的上限,接收的参数必须是Number或者是其子类,如果使用这个的时候,我们调用show方法的时候,传递p2会报错,因为p2不是Number或者其子类。同样的,我们使用super关键字,这个表示参数的上限,程序中表示接收的参数只能是String或者其父类,这时候show方法的参数是p1会报错,不满足下限的要求。

    对于上限和下限基本的使用就是这样,希望对你有帮助。

    如果哪里写错了,还请指出。

    展开全文
  • 从前面已经知道,ArrayList 集合 ArrayList、ArrayList 集合等不存在继承关系,所有方法形参不能使用ArrayList,那么该如何实现呢? 方式一:不使用泛型: public class WildcardTest { public static void ...

    1. 通配符基本使用

    假设有这样的需求:定义一个方法,可以遍历任意数据类型的ArrayList集合。

    从前面已经知道,ArrayList 集合和 ArrayList、ArrayList 集合等不存在继承关系,所有方法的形参不能使用ArrayList,那么该如何实现呢?

    方式一:不使用泛型:

    public class WildcardTest {
        public static void main(String[] args) {
            ArrayList<String> list1 = new ArrayList<>();
            list1.add("aaa");
            list1.add("bbb");
            list1.add("ccc");
            getElement(list1);
    
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(1);
            list2.add(2);
            list2.add(3);
            getElement(list2);
    
        }
    
        static <E> void getElement(ArrayList list) {
            Iterator iterator = list.iterator();
            while (iterator.hasNext()) {
                Object o = iterator.next();
                System.out.println(o);
            }
        }
    }
    

    集合元素都会转为Object类型

    方式二:使用泛型方法

    public class WildcardTest {
        public static void main(String[] args) {
            ArrayList<String> list1 = new ArrayList<>();
            list1.add("aaa");
            list1.add("bbb");
            list1.add("ccc");
            getElement(list1);
    
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(1);
            list2.add(2);
            list2.add(3);
            getElement(list2);
    
        }
    
        static <E> void getElement(ArrayList<E> list) {
            Iterator<E> iterator = list.iterator();
            while (iterator.hasNext()) {
                E e = iterator.next();
                System.out.println(e);
            }
        }
    }
    

    这种方法需要声明泛型形参 T

    方式三:使用类型通配符

    public class WildcardTest {
        public static void main(String[] args) {
            ArrayList<String> list1 = new ArrayList<>();
            list1.add("aaa");
            list1.add("bbb");
            list1.add("ccc");
            getElement(list1);
    
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(1);
            list2.add(2);
            list2.add(3);
            getElement(list2);
    
        }
    
        static void getElement(ArrayList<?> list) {
            Iterator<?> iterator = list.iterator();
            while (iterator.hasNext()) {
                Object o = iterator.next();
                System.out.println(o);
            }
        }
    }
    

    为了表示各种泛型List的子类,可以使用类型通配符,类型通配符是一个问号 ?,将一个问号作为类型实参传给List集合,写作:List<?>,List<?>是List<String>List<Object> 等各种泛型List的父类。

    用List<?> 声明的变量可以接收List集合的任意泛型对象,只要在创建List集合子类对象时,<>中写一个引用类型都是可以的。

    List<?> list = new ArrayList<Object>();//合法
    list = new ArrayList<Integer>(); //合法
    list = new ArrayList<String>(); //合法
    

    一旦使用了类型通配符 ?,只能接收数据不能往该集合中存储数据, 唯一的例外是null

    代码示例:

    ArrayList<?> list = new ArrayList<String>();
    list.add(null);
    list.add("aaa"); //编译不通过
    

    使用注意点

    • 注意点1:不能用在泛型方法声明上,返回值类型前面<>不能使用?
    //编译不通过
    public <?> void test(ArrayList<?> list) {
    
    }
    
    • 注意点2:不能用在泛型类的声明上
    //编译不通过
    class GenericClass<?> {
        
    }
    
    • 注意点3:不能用在创建对象上,右边属于创建集合对象,左边是声明泛型集合的引用
    //编译不通过
    Collection<?> collection = new ArrayList<?>();
    

    2. 受限泛型

    在 Java 中默认可以使用任何类型来实例化一个泛型类对象,也可以对泛型类实例的类型进行限制。

    泛型的上限

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

    泛型的下限

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

    比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类

    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<>();
        
        getElement1(list1);
        getElement1(list2);//报错
        getElement1(list3);
        getElement1(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){}
    

    受限泛型集合数据的读取和写入

    public class WildcardTest {
        public static void main(String[] args) {
            ArrayList<Integer> list1 = new ArrayList<>();
            list1.add(5);
            list1.add(12);
            test1(list1);
    
            ArrayList<Number> list2 = new ArrayList<>();
            list2.add(2.5);
            list2.add(1.5f);
            list2.add(10);
            test2(list2);
        }
    
        static void test1(ArrayList<? extends Number> list) {
            list.add(null);
            //list.add(10); //报错
            for (Number number : list) {
                System.out.println(number);
            }
        }
    
        static void test2(ArrayList<? super Number> list) {
            list.add(12.5);
            list.add(20);
            for (Object o : list) {
                System.out.println(o);
            }
        }
    }
    

    <? extends T> 只能用来读取数据,不能向集合中存储数据,不能使用 add 方法;<? super T> 既能读取数据(需声明为 Object 类型),也能存储数据。

    频繁往外读取内容的,适合用 <? extends T > ;经常往集合里插入数据的,适合用 <? super T>

    展开全文
  • 具体内容1.1匹配任意类型的通配符在开发中对象的引用传递(向上向下传递)是最常见的,但是,在泛型的操作中,在进行引用传递的时候泛型类型必须匹配才可以传递,否则不能传递。例如,如下没有进行泛型类型匹配,一个...

    掌握通配符“?”的使用。

    掌握受限泛型的设置。

    掌握泛型与子类继承的限制。

    具体内容

    1.1匹配任意类型的通配符

    在开发中对象的引用传递(向上向下传递)是最常见的,但是,在泛型的操作中,在进行引用传递的时候泛型类型必须匹配才可以传递,否则不能传递。

    例如,如下没有进行泛型类型匹配,一个是String,一个是Object类型。

    packageThread1;class Info{private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ // 直接打印

    return this.var.toString() ;

    }

    };public classdemo1{public static voidmain(String args[]){

    Info i = new Info() ; // 使用String为泛型类型

    i.setVar("MLDN") ; //设置内容

    fun(i) ;                    //把String泛型类型的i对象传递给Object泛型类型的temp。

    }public static void fun(Info temp){ // 接收Object泛型类型的Info对象

    System.out.println("内容:" +temp) ;

    }

    };

    编译发生错误。

    Exception in thread "main"java.lang.Error: Unresolved compilation problem:

    The method fun(Info) in the type demo1 is not applicable for the arguments (Info)

    at Thread1.demo1.main(demo1.java:18)

    泛型对象进行引用传递的时候,类型必须一致,如果非要传递,则可以将fun方法中Info参数的泛型取消掉(变成 voidfun(Info temp))。、

    以上确实改进了功能,但是似乎不是很妥当,毕竟之前指定过泛型。

    以上程序在fun()方法中使用"Info>"的代码形式,表示可以使用任意的泛型类型对象,这样的话fun()方法定义就合理了,但是使用以上方法也有需要注意的地方,

    即:如果使用“?“接收泛型对象的时候,则不能设置被泛型指定的内容。

    class Info{private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ //直接打印

    return this.var.toString() ;

    }

    };public classGenericsDemo14{public static voidmain(String args[]){

    Info i = new Info() ; //使用String为泛型类型

    i.setVar("MLDN") ; //设置内容

    fun(i) ;

    }public static void fun(Info> temp){ //可以接收任意的泛型对象

    System.out.println("内容:" +temp) ;

    }

    };

    如果使用”?“意味着可以接收任意的内容,但是此内容无法直接使得用”?“修饰的泛型的对象进行修改。如下就会出问题:

    packageThread1;class Info{private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ //直接打印

    return this.var.toString() ;

    }

    };public classdemo1{public static voidmain(String args[]){

    Info> i = new Info() ; //使用String为泛型类型

    i.setVar("MLDN") ; // 设置内容,这里会出错,因为”?“通配符修饰的对象只能接收,不能修改,也就是不能设置。

    }

    };

    运行结果:

    Exception in thread "main"java.lang.Error: Unresolved compilation problem:

    The method setVar(capture#1-of ?) in the type Info is not applicable forthe arguments (String)

    at Thread1.demo1.main(demo1.java:17)

    在使用”?“只能接收,不能修改。

    1.2受限泛型

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

    12f6db44c7087f256f419abfb9e86cae.png

    设置上限

    class Info{private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ //直接打印

    return this.var.toString() ;

    }

    };public classGenericsDemo17{public static voidmain(String args[]){

    Info i1 = new Info() ; //声明Integer的泛型对象

    Info i2 = new Info() ; //声明Float的泛型对象

    i1.setVar(30) ; //设置整数,自动装箱

    i2.setVar(30.1f) ; //设置小数,自动装箱

    fun(i1) ;

    fun(i2) ;

    }public static void fun(Info extends Number> temp){ // 只能接收Number及其Number的子类

    System.out.print(temp + "、") ;

    }

    };

    运行成功。但是,如果传人的泛型类型为String的话就不行,因为String不是Number子类。

    在类中使用泛型上限。

    packageThread1;class Info{ //此处泛型只能是数字类型

    private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ //直接打印

    return this.var.toString() ;

    }

    };public classdemo1{public static voidmain(String args[]){

    Info i1 = new Info() ; //声明Integer的泛型对象

    }

    };

    如果在使用Info的时候设置成String类型,则编译的时候将会出现错误(String不是Number子类):

    设置下限

    class Info{private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ //直接打印

    return this.var.toString() ;

    }

    };public classGenericsDemo21{public static voidmain(String args[]){

    Info i1 = new Info() ; //声明String的泛型对象

    Info i2 = new Info() ; //声明Object的泛型对象

    i1.setVar("hello") ;

    i2.setVar(newObject()) ;

    fun(i1) ;

    fun(i2) ;

    }public static void fun(Info super String> temp){ // 只能接收String或Object类型的泛型,String类的父类只有Object类

    System.out.print(temp + "、") ;

    }

    };

    Object类和String类都是String的父类,所有运行成功,但是如果此时用Integer则会出错,因为integer并不是String父类。

    1.3解释:泛型与子类继承的限制。

    一个类的子类可以通过对象多态性,为其父类实例化,但是在泛型操作中,子类的泛型类型是无法使用父类的泛型类型接收的。例如:Info不能使用Info

    接收。

    例如,以下肯定出错。

    class Info{private T var ; //定义泛型变量

    public voidsetVar(T var){this.var =var ;

    }publicT getVar(){return this.var ;

    }public String toString(){ //直接打印

    return this.var.toString() ;

    }

    };public classGenericsDemo23{public static voidmain(String args[]){

    Info i1 = new Info() ; //泛型类型为String

    Info i2 = null;

    i2=i1 ;                  //这里因为对象泛型类型不同,而出错。

    }

    };

    Object肯定比String大。

    8be83d73470d3b13ad4833661aa63ea4.png

    总结

    1)使用?可以接收任意泛型对象。

    2)泛型的上限:?extends 类型。

    3)泛型的下限:?super 类型。相对了解一些就可。

    4)了解为什么泛型子类之间的继承无法直接转换的原因。

    展开全文
  • extends T>...表示一个未知类,而T是一个具体类,在实际使用时候T需要替换成一个具体类,表示实例化时候泛型参数要是T子类。举个例子我们有一个水果类/*** 水果类*/public abstract class Fr...
  • import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import cn.itcast.p2.bean.Person; import cn.itcast.p2.bean.Student; import cn.itcast.p2.bean.Worker; public class ...
  • Main Class package Comparator.Bean;...import java.math.BigDecimal; import java.util.List; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /** * ? ex...
  • 泛型限定中的上限和下限两个不同的概念,用法完全不同。上限package com.heihei.test8;import java.util.*;public class GenericTest {public static void main(String[] args) {ArrayList list1 = new ArrayList<...
  • Java的泛型中,通配符可以设置上限和下限。上限: extends T> ?是T和T子类下限: super T> ?是T和T父类怎么看待这个上限和下限呢 首先应该想 其实对于Java来说 extends T> super T> 是两个确定...
  • Java的泛型中,通配符可以设置上限和下限。 上限:<? extends T> ?是T和T子类 下限:<? super T> ?是T和T父类 怎么看待这个上限和下限呢 首先应该想 其实对于Java来说 <? extends T> <?...
  • 为了表示各种泛型List父类,可以使用类型通配符 类型通配符: <?> List<?>:表示元素类型末知List,它元素可以匹配任何类型; 这种带通配符List仅表示它是各种泛型List父类,并不能把...
  • 注意,你可以指定一个有上限的通配符,或者指定一个有下限的通配符,但是不能两个限制同时指定。假设你需要一个方法,方法中接受 Integer 类型 List。为了使方法更加灵活,你可能需要方法同时适用于List、 List、 ...
  • 可以通过泛型上限和下限的配置实现更加严格的类范围定义。 【类或方法】设置泛型的上限(? extends 类):只能够使用当前类或当前类的子类设置泛型类型。例如:? extends Number可以设置Number或Number子类(如:...
  • 定义使用含有泛型的类 /* 说明:泛型是一个未知的数据类型,当我们不确定使用什么数据类型的时候,可以使用泛型; 简单来说,就是在定义类或类的成员变量的类型的时候不把类型写死了。在创建对象的时候,想用啥...
  • java泛型上、下限

    千次阅读 2011-09-13 00:08:04
    写了点代码,试了一下java泛型上限和下限的问题。经验不足,讲不好地方轻拍。 1.Toy类 view sourceprint? package fanxing;
  • 了解概念:限制上限【可以返回值】和下限【可以添加值】和PECS原则【限制了数据放入和取出。】1、什么叫上限?2、什么叫下限?二、通配符<?>和类型参数T、K、V区别?三、PECS原则四、上代码: 一、适用...
  • java泛型上限和下限的简单示例
  • 是T和T父类怎么看待这个上限和下限呢 首先应该想 其实对于Java来说 extends T> super T> 是两个确定类型,因为它不可能由你赋值完了再确定吧。所以,对于 extends T> 来说,集合里元素应该是什么...
  • java泛型

    2019-02-17 21:50:55
    java泛型: 泛型和集合的区别是什么 泛型的上限和下限有什么作用 泛型是什么    
  • 泛型限行上限和下限

    2016-07-18 22:04:50
    泛型的作用是给我们用来判断类型的, java代码 无泛型。 定义了两个javabean类。里面有String name public class Demo{ List list = new LinkedList(); public static void main(String[] args){ lis
  • 列:使用泛型不使用泛型的区别练习 类使用泛型 列:类使用泛型 方法使用泛型 列:方法使用泛型练习 接口使用泛型 泛型通配符 列:泛型通配符练习 通配符高级使用----受限泛型 列:泛型上限下限的练习 ...
  • 怎么看待这个上限和下限呢 首先应该想 其实对于Java来说 <? extends T> <? super T> 是两个确定类型,因为它不可能由你赋值完了再确定吧。所以,对于<? extends T> 来说,集合里元素应该...
  • 泛型的上限:此时的 泛型?必须是 E的本身或者E的子类 ? extends E 泛型的下限:此时的泛型?必须是E的本身或者父类 ? supper E 如demo: publice static void getElement1(Collection<? extends Number&...
  • Java的泛型中,通配符可以设置上限和下限。 上限 上限:<? extends T> ?是T和T子类 首先要知道<? extends T> <? super T> 是两个确定类型。 对于<? extends T> 来说,集合里元素应该...
  • 泛型的限定: 1、 ? extends E:可以接收E类型或者E的子类型, 上限。 2、 ? super E:可以接收E类型或者E的父类型。 下限。 */ import java.util.ArrayList; import java.util.Iterator; public class ...

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

java泛型的上限和下限

java 订阅