精华内容
下载资源
问答
  • java泛型上界和下界

    2020-08-25 21:50:53
    package test.generic; import java.util.ArrayList; import java.util.List; public class TestEat<T> { private List<T> list1 = new ArrayList<>();... for (T t: list) .
    package test.generic;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class TestEat<T> {
    
        private List<T> list1 = new ArrayList<>();
    
        public List<T> push(List<? extends T> list) {
    
            for (T t: list) {
                list1.add(t);
            }
            return list1;
    
        }
    
        public void get(List<? super T> list) {
            for (T t:list1) {
                list.add(t);
            }
        }
    
        public List<T> getList1() {
            return list1;
        }
    
        public void setList1(List<T> list1) {
            this.list1 = list1;
        }
    
        public static void main(String[] args) {
            TestEat<IEat> eatTestEat = new TestEat<>();
            Animal animal = new Animal();
            Person person = new Person();
            List<Animal> animals = new ArrayList<>();
            animals.add(animal);
            
            List<Object> people = new ArrayList<>();
            eatTestEat.push(animals);
    
            System.out.println(eatTestEat.getList1());
            eatTestEat.get(people);
    
            System.out.println(people);
        }
    
    }
    

     

    展开全文
  • scala泛型上界 下界

    2019-10-07 16:34:31
    分别使用传统方法和上界的方式来完成,体会上界使用的好处. */ //传统方法 class CompareInt(n1: Int, n2: Int) { //返回较大的值 def greater = if(n1 > n2) n1 else n2 } //使用上界(上限)来完成 //说明 //1....
    
    object UpperBoundsDemo01 {
      def main(args: Array[String]): Unit = {
    
        val compareInt = new CompareInt(10,40)
        println(compareInt.greater) // 40
    
        //第一个用法
        val commonCompare1 = new CommonCompare(Integer.valueOf(10), Integer.valueOf(40))//Int
        println(commonCompare1.greater)
        //第二个用法
        val commonCompare2 = new CommonCompare(java.lang.Float.valueOf(1.1f), java.lang.Float.valueOf(2.1f))//Fl
        println(commonCompare2.greater)
    
        //第3种写法使用了隐式转换
        //implicit def float2Float(x: Float): java.lang.Float         = x.asInstanceOf[java.lang.Float]
        val commonCompare3 = new CommonCompare[java.lang.Float](10.1f, 21.1f)//
        println(commonCompare3.greater)
      }
    
    }
    
    /*
    编写一个通用的类,可以进行Int之间、Float之间、等实现了Comparable接口的值直接的比较.//java.lang.Integer
    分别使用传统方法和上界的方式来完成,体会上界使用的好处.
    
     */
    //传统方法
    class CompareInt(n1: Int, n2: Int) {
      //返回较大的值
      def greater = if(n1 > n2) n1 else n2
    }
    
    //使用上界(上限)来完成
    //说明
    //1. [T <: Comparable[T]] 表示T类型是Comparable 子类型
    //2. 即你传入的T类要继承Comparable接口
    //3. 这样就可以使用compareTo方法
    //4. 这样的写法(使用上界的写法)通用性比传统的好
    class CommonCompare[T <: Comparable[T]](obj1:T,obj2:T) {
      def greater = if (obj1.compareTo(obj2) > 0) obj1 else obj2
    }
    
    
    

    
    //
    //1)和Animal直系的,是Animal父类的还是父类处理,是Animal子类的按照Animal处理(),
    //2)和Animal无关的,一律按照Object处理!
    object LowerBoundsDemo01 {
      def main(args: Array[String]): Unit = {
        println("ok!")
        //满足下界的约束
        biophony(Seq(new Earth, new Earth)).map(_.sound())
        //满足下界的约束
        biophony(Seq(new Animal, new Animal)).map(_.sound())
    
        //这里我们不能使用上界的思路去推导,这里是可以运行
        //1.这里鸟叫声覆盖了动物叫声。如果鸟没有sound这个方法,会调用动物的sound方法
        println("===================")
        biophony(Seq(new Bird, new Bird)).map(_.sound())//
    
        //biophony(Seq(new Moon))
    
      }
      //下界
      def biophony[T >: Animal](things: Seq[T]) = things
    }
    
    
    class Earth { //Earth 类
      def sound(){ //方法
        println("hello !")
      }
    }
    class Animal extends Earth{
      override def sound() ={ //重写了Earth的方法sound()
        println("animal sound")
      }
    }
    class Bird extends Animal{
      override def sound()={ //将Animal的方法重写
        print("bird sounds")
      }
    }
    class Moon {
    //  def sound()={ //将Animal的方法重写
    //    print("bird sounds")
    //  }
    }
    
    
    展开全文
  • 我试图了解下界和上界通配符的行为。在尝试编译以下代码时遇到问题。Collection extends Object> c = new ArrayList();c.add(new Object()); // Compile time error为了解决这个问题,我还简单地尝试了下界通配符...

    本问题已经有最佳答案,请猛点这里访问。

    我试图了解下界和上界通配符的行为。

    在尝试编译以下代码时遇到问题。

    Collection extends Object> c = new ArrayList();

    c.add(new Object()); // Compile time error

    为了解决这个问题,我还简单地尝试了下界通配符。幸运的是,或者不幸的是,代码编译得很好,但是造成了很多混乱。

    Collection super Object> c = new ArrayList();

    c.add(new Object()); // Compiles fine

    有人能解释一下这两个代码片段是如何工作的吗?如果有人能提供更多的示例/链接,那就太好了。

    如果我在上面做了什么错误,请纠正我。

    事先谢谢。

    @Jornverene同意这与PEC有关。

    ?表示"未知类型"。

    Collection extends Object>表示某种对象的集合。这个"某些类型"可以是Object或Object本身的子类的任何类型。哪种类型?编译器不知道。

    当您试图向集合中添加新的Object时,您不能这样做。这是因为集合的类型未知。它可以是一个ArrayList。它可以是一个HashSet。所以编译器说

    "What if the collection is ArrayList? You can't put an Object in there!"

    基本上,编译器过于谨慎,不允许您这样做。

    Collection super Object>表示某种对象的集合。这种"某种类型"可以是任何一种类型,它本身就是Object或Object的超类。这里只有一件事——Object,因为Object没有超类。这就是为什么你可以在收藏中添加一个新的Object。

    即使Object有一个超类,您仍然可以添加new Object()。我们称之为ObjectMyClass的超类。现在,集合可以是MyClass或Object的集合。无论是哪种情况,您都可以在其中添加一个Object。

    我完全理解关于Collection extends Object>的部分,这是有道理的。但是,如果是Collection super Object>,那么接受任何SupersClass或Object类的原因是什么?

    那就是什么?超级物体意味着。如果a扩展b,可以将b添加到a的集合中。这里的情况相同。@ Yahya

    @乔恩弗尼,哦,这是个打字错误。我的意思是你可以把A添加到B的集合中。

    @清洁工谢谢,我明白你的意思了。我认为你的最后一段解释得很好。但在你的脑子里很难看到。

    让我们更改类类型,使其更易于理解。你的第一个例子改为Number。

    Collection extends Number> c = new ArrayList();

    表示存在来自类型Number的?对象。因此,它可以是extends Number的任何对象,例如Integer、Double、Float、BigInteger等,因此您不能保证列表中存在哪种Number对象,因为

    List // only allows Integer

    List // only allows Double

    List // only allows Float

    这就是为什么你不能添加任何东西到extends Number>中的原因,因为它可能是上面的列表之一。

    另一种方法是使用super Number>。这意味着列表中的每个对象都是Number的祖先。在这种情况下,您可以添加Number的父类型/类型中的任何内容。你向? super Number保证里面的东西都是Number。

    但你不能保证的是实际类型,例如

    list.get(0); // is a Number, but could be a Integer

    list.get(1); // is a Number, but could be a Float

    list.get(2); // is a Number, but could be a Double

    tl;dr使用extends进行读取,super进行添加。

    下面是来自docs https://docs.oracle.com/javase/tutorial/java/generics/subtyping.html的图表

    4762cfe51bfb4cf013c1524be3295166.gif

    这是乔恩·斯基特对埃多克斯的解释。

    https://stackoverflow.com/a/8083260/4467208

    关于? super的部分需要工作。大部分都是向后的。如果绑定为? super Number,则无法执行Integer、Float和Double。

    @但这些类型是一个Number。它们不一定需要是超级类型。

    Integer是Number的一个子类。? super Number匹配超类(或Number本身)。Number的唯一超类是Object。

    @约翰克尔曼是的,这些是数字,例如ideone.com/fu5rvt

    展开全文
  • java泛型上界下界

    千次阅读 2019-01-20 22:06:28
    java泛型上界下界的demo。 package java28_reflect; import java.sql.Timestamp; import java.util.ArrayList; import java.util.Date; import java.util.List; /** * 泛型上下界 */ public class ...

    java泛型的上界下界的demo。

    
    import java.sql.Timestamp;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    /**
     * 泛型上下界
     */
    public class UpAndDownGeneric {
    	
    	/**
    	 * 1、上界可以读取成上界类型Date,但是不能存储,因为这个实际类型有可能是子类,而你指定Date不行,Date的下级也不行,依次同理。
    	 */
    	public void upperBound(List<? extends Date> list, Date date){  
    	    Date now = list.get(0);  //这里当然也可以用Object接受。
    	    System.out.println("now==>" + now);  
    	   // list.add(date); //这句话无法编译  
    	    list.add(null); //这句可以编译,null没有类型信息  
    	}
    	
    	/**
    	 * 比如下面这个方法,泛型是Timestamp类型,而add的时Date类型。
    	 * 上界读不能存,因为泛型类型可能无限小,任何参数的类型都不能直接使用。
    	 */
    	public void testUpperBound(){  
    	    List<Timestamp> list = new ArrayList<Timestamp>();  
    	    Date date = new Date();  
    	    upperBound(list,date);  
    	}  
    	
    	/**
    	 * 解决,声明List泛型为T,在方法定义T为Date子类,那么传递的类型永远符合T的类型了。就可以添加了。
    	 */
    	public <T extends Date> void upperBound2(List<T> list, T date){  
    	    T now = list.get(0);  
    	    System.out.println("now==>" + now);  
    	    list.add(date); //这句话无法编译  
    	    list.add(null); //这句可以编译,null没有类型信息  
    	}
    	
    	/**
    	 * 2、下界不能够读,可以写,因为泛型实际类型都大于Timestamp,所以放心的写,而读的话,不知道返回什么类型了。
    	 */
    	public void lowerBound(List<? super Date> list){  
    		Date now = new Date(System.currentTimeMillis());  
    	    list.add(now);
    	    list.add(new Timestamp(System.currentTimeMillis())); //可以添加比Date小的类型。
    	    //Date time = list.get(0); //需要强转成Object,才能读。
    	}  
    	
    	/**
    	 * 比如下面这个:list符合泛型限制,但是添加的是一个Object,所以在lowerBound调用时,get要强转成Object.
    	 */
    	public void testLowerBound(){  
    	    List<Object> list = new ArrayList<>();  
    	    list.add(new Object());  
    	    lowerBound(list);  
    	}
    	
    	//一句话总结:
    	//泛型上界 <? extends 上界类型> 和 泛型下界<? super 下界类型> 
    	//如果是进行读取操作,那么就要能够装的下泛型类型的,即看2种泛型的最大类型,其中上界是上界类型,下界是Object。
    	//如果时写入操作,那么就要看泛型类型的最小的具体类型及其子类,所以上界不可写,下界可以写入下界类型及子类。
    	
    }
    

     

    展开全文
  • 泛型上界下界的定义 泛型上界下界的定义 上界<? extends Fruit> 下界<? super Apple> 上界的list只能get,不能add除null之外的任何对象,包括Object 下界的list只能add,不能get
  • Java 泛型之上界下界通配符Java教程是为JDK 8编写的。本页描述的示例实践没有利用后续版本中引入的改进。通配符子类型如 泛型,继承子类型中所述,泛型类或接口仅仅因为它们的类型之间存在关系而无关。但是,...
  • 是Java泛型中的“通配符(Wildcards)”“边界(Bounds)”的概念。 &lt;? extends T&gt;:是指 “上界通配符(Upper Bounds Wildcards)” &lt;? super T&gt;:是指 “下界通配符(Lower ...
  • 专栏原创出处:github-源笔记文件 ,github-源码 ,欢迎 Star,转载请附上原文出处链接本声明。 Scala 编程语言专栏系列笔记,系统性学习可访问个人复盘笔记-技术博客 Scala 编程语言 什么是泛型泛型类指可以...
  • 文章目录泛型类型约束上下界上界下界视图界定上下文界定 泛型 使用示例 def test={ //应用1 val msg = new IntMessage(1) println(msg) val msg2 = new StringMessage[String]("class") println(msg2) //应用2...
  • day08,我们学习了scala的集合、模式匹配、样本类。今天学习scala的泛型上界下界、隐式转换。
  • :是指 “上界通配符(Upper Bounds Wildcards)” <? super T>:是指 “下界通配符(Lower Bounds Wildcards)” 1 为什么要用通配符边界? 使用泛型的过程中,经常出现一种很别扭的情况 比如我们有...
  • 转载地址
  • 概念:约束数据的 泛型[T]   //约束数组中的元素 ...上界[A&lt;:B]:A必须是B的子类,才能满足泛型的要求 案例:比较两个对象的大小   package com.zzk4 class Person(var name:String,v...
  • scala 泛型 上界

    2018-04-14 18:48:00
    scala的泛型本质上java是一样的,只不过语法不一样。 它有以下几种用法: T,上界,表示T是B的子类 T>:B,下界,表示T是B的老爹 B,viewBound,表示表要转化成A,但要有一个隐式转换函数 B:A,...
  • Kotlin泛型上界与扩展函数

    千次阅读 2018-12-11 14:06:40
    先由我们熟悉的Java说起,有时在使用泛型的时候,会有这样的场景。 比如我们封装一个参数类,里面提供一个放入参数的方法,并且方法返回类型为它自身,以便调用时进行链式调用。
  • Java泛型_上界extends_下界super? 通配符类型 extends T> 表示类型的上界,表示参数化类型的可能是T或是T的子类 super T> 表示类型下界(Java Core中叫超类型限定),表示参数化类型是此类型(T)的超类型(父...
  • 是比较难理解的一部分,这里,我们介绍下 上界和下界。直接给代码,在代码中看注释比较清晰。 首先我们先准备一些类: public class Pair<T> { private T first; private T second; public Pair(T first...
  • java泛型中的super关键字不太常用,也不太好理解,今天又从头看了看java的泛型机制,作一记录。 上界: 上界用extends关键字声明,表示参数化的类型可能是所指定的类型,或者是此类型的子类。如下面的代码: ...
  • java 泛型中的上界(extend)和下界(super)

    万次阅读 多人点赞 2017-01-20 17:27:09
    1. 泛型上界和下界的定义 上界 下界 2.上界和下界的特点 上界的list只能get,不能add(确切地说不能add出除null之外的对象,包括Object) 下界的list只能add,不能get import java.util.ArrayList; import ...
  • 转自:Java泛型中extendssuper的区别? 另,问题来源:Java 泛型 &lt;? super T&gt; 中 super 怎么 理解?与 extends 有何不同?   &lt;? extends T&gt;&lt;? super T&gt;是Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,806
精华内容 1,522
关键字:

泛型的上界和下界