精华内容
下载资源
问答
  • 2019-09-28 16:01:17

    1、上界与下界:Upper bound,lower bound
            
            作用:规定泛型的取值范围
            
            Int x 
                    100  <= x <= 200
                    下界        上界
                    
            (*)规定泛型的取值范围
                举例:定义一个泛型:T
                    类的继承关系   A---->B----->C----->D  箭头指向子类
                    可以规定T的取值范围    D  <:  T   <:  B
                    T 的取值范围只能是 B C D
                    
                    <:  就是上下界表示方法
                    
            (*)定义:
                上界  s <: T 规定了S的类型必须是T的子类或本身
                下界  u >: T 规定了U的类型必须是T的父类或本身
                
            scala> def addTwoString[T<:String](x:T,y:T) = x + " **** " + y
            addTwoString: [T <: String](x: T, y: T)String

            scala> addTwoString("Hello","123")
            res9: String = Hello **** 123

            scala> addTwoString(1,2)
            <console>:14: error: inferred type arguments [Int] do not conform to method addTwoString's type parameter bounds [T <: String]
                   addTwoString(1,2)
                   ^
            <console>:14: error: type mismatch;
             found   : Int(1)
             required: T
                   addTwoString(1,2)
                                ^
            <console>:14: error: type mismatch;
             found   : Int(2)
             required: T
                   addTwoString(1,2)
                   
            报错原因:Int不是String类型。
            
            解决:1和2转换成字符串再调用
            scala> addTwoString(1.toString,2.toString)
            res11: String = 1 **** 2
            
            另外:可以使用 视图界定 来解决这个问题。
            
        2、视图界定:View bound
        
            是上界和下界的一种扩展
            
            除了可以接收上界和下界规定的类型之外,还可以接收能够通过隐式转换过去的类型
            
            用法 : %
            def addTwoString[T<%String](x:T,y:T) = x + " **** " + y
            含义:
            1、可以接收String及其子类
            2、可以接收能够转换成String的其他类型
            
            scala> def addTwoString[T<%String](x:T,y:T) = x + " **** " + y
            addTwoString: [T](x: T, y: T)(implicit evidence$1: T => String)String

            scala> addTwoString(1,2)
            <console>:14: error: No implicit view available from Int => String.
                   addTwoString(1,2)
                   
            报错解决:定义隐式转换函数,把int转换成String
        
            scala> implicit def int2String(n:Int):String=n.toString
            warning: there was one feature warning; re-run with -feature for details
            int2String: (n: Int)String

            scala> addTwoString(1,2)
            res13: String = 1 **** 2
            
            分析执行过程:
            1、调用 int2String 方法,把Int转换成String(scala在后台调用,不需要显示调用)
            2、调用addTwoString方法,拼接字符串
            
            隐式转换函数,不需要显示调用它,它就能被调用。
            
            scala> implicit def int2String2(n:Int):String="hehe"
            warning: there was one feature warning; re-run with -feature for details
            int2String2: (n: Int)String

            scala> addTwoString(1,2)
            <console>:16: error: ambiguous implicit values:
             both method int2String of type (n: Int)String
             and method int2String2 of type (n: Int)String
             match expected type Int => String
                   addTwoString(1,2)
        
        3、协变与逆变
            了解概念即可
            
            概念:
            协变:泛型变量的值可以是本身类型或者其子类型
            逆变:泛型变量的值可以是本身类型或者其父类型
            
            表示:
            协变 +
            逆变 -

    更多相关内容
  • 【离散数学】偏序关系上界下界

    万次阅读 多人点赞 2021-01-19 10:46:10
    一直没搞懂这个上界下界的关系

    前提提要

    一直没搞懂这个上界和下界的关系

    在这里插入图片描述
    从上图可以发现,每个链上端都是分开的

    1. 所以该哈斯图没有最大值 最小值为1
    2. 但是极大值是每个链的最大值所以 存在 11、9、12、8、10、7 这几个极大值、极小值为1
    3. 上界为所有比 粉色的点还大的最大值。因为蓝色集合并没有最大值、所以无法确定2、3处的最大值。所以上界只有6 、12
    4. 下界很明显为1
    5. 上确界 为上界最小的 所以为6
    6. 下确接 为下界最大的 是1
    展开全文
  • c++算法的上界下界

    2020-12-09 15:38:40
    整 取下界(向量<整>&大,整 值){//最后两位表区间,即比值刚好>=的东西. 整 i=0,j=大.大小(),o,k,c=j-i; 当(c>0){// k=c/2;o=大[i+k];//k=1 如(o<值){i+=k+1;c-=k+1;}异 c=k; } 中 i; }//...
    整 取下界(向量<>&,整 值){//最后两位表区间,即比值刚好>=的东西.
        整 i=0,j=.大小(),o,k,c=j-i;(c>0){//
            k=c/2;o=[i+k];//k=1(o<){i+=k+1;c-=k+1;}异 c=k;
        }
        中 i;
    }//向量<T>是从小到大排好序的.上界,取>的首个.
    整 取上界(向量<>&,整 值){//下界,取>=的首个
        整 i=0,j=.大小(),o,k,c=j-i;(c>0){//与下界的差别只有一个地方
            k=c/2;o=[i+k];//k=1(o<=){i+=k+1;c-=k+1;}异 c=k;
        }
        中 i;
    }
    //上界与下界的区别只有一个等号.上界,要求是大于才算.而下界是大于等于就算.
    
    
    空 主(){
        向量<>m{25,54,66,98,100,117};
        整 t=取上界(m,99);打印(t);
        t=取上界(m,98);打印(t);
        t=取上界(m,97);打印(t);
        打印(m);
    }
    
    
    展开全文
  • java-泛型及上界下界详解

    千次阅读 2021-03-08 01:25:00
    4、关于上界下界 上界的list只能get,不能add(确切地说不能add出除null之外的对象,包括Object) 下界的list只能add,不能get add和get涉及到具体的数据类型了: add方法是先给预添加的对象创建一个引用,再让这个...

    Java 泛型

    Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。

    泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

    假定我们有这样一个需求:写一个排序方法,能够对整型数组、字符串数组甚至其他任何类型的数组进行排序,该如何实现?

    答案是可以使用 Java 泛型。

    使用 Java 泛型的概念,我们可以写一个泛型方法来对一个对象数组排序。然后,调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

    泛型方法

    你可以写一个泛型方法,该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用。

    下面是定义泛型方法的规则:

    所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前(在下面例子中的)。

    每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。

    类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。

    泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)。

    实例

    下面的例子演示了如何使用泛型方法打印不同字符串的元素:

    public classGenericMethodTest

    {//泛型方法 printArray

    public static < E > voidprintArray( E[] inputArray )

    {//输出数组元素

    for( E element : inputArray ){

    System.out.printf("%s ", element );

    }

    System.out.println();

    }public static voidmain( String args[] )

    {//创建不同类型数组: Integer, Double 和 Character

    Integer[] intArray = { 1, 2, 3, 4, 5};

    Double[] doubleArray= { 1.1, 2.2, 3.3, 4.4};

    Character[] charArray= { 'H', 'E', 'L', 'L', 'O'};

    System.out.println("整型数组元素为:");

    printArray( intArray );//传递一个整型数组

    System.out.println("\n双精度型数组元素为:");

    printArray( doubleArray );//传递一个双精度型数组

    System.out.println("\n字符型数组元素为:");

    printArray( charArray );//传递一个字符型数组

    }

    }

    编译以上代码,运行结果如下所示:

    整型数组元素为:1 2 3 4 5​

    双精度型数组元素为:1.1 2.2 3.3 4.4​

    字符型数组元素为:

    H E L L O

    有界的类型参数

    可能有时候,你会想限制那些被允许传递到一个类型参数的类型种类范围。例如,一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

    要声明一个有界的类型参数,首先列出类型参数的名称,后跟extends关键字,最后紧跟它的上界。

    实例

    下面的例子演示了"extends"如何使用在一般意义上的意思"extends"(类)或者"implements"(接口)。该例子中的泛型方法返回三个可比较对象的最大值。

    public classMaximumTest

    {//比较三个值并返回最大值

    public static >T maximum(T x, T y, T z)

    {

    T max= x; //假设x是初始最大值

    if ( y.compareTo( max ) > 0){

    max= y; //y 更大

    }if ( z.compareTo( max ) > 0){

    max= z; //现在 z 更大

    }return max; //返回最大对象

    }public static voidmain( String args[] )

    {

    System.out.printf("%d, %d 和 %d 中最大的数为 %d\n\n",3, 4, 5, maximum( 3, 4, 5) );

    System.out.printf("%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7) );

    System.out.printf("%s, %s 和 %s 中最大的数为 %s\n","pear","apple", "orange", maximum( "pear", "apple", "orange") );

    }

    }

    编译以上代码,运行结果如下所示:

    3, 4 和 5 中最大的数为 5​6.6, 8.8 和 7.7 中最大的数为 8.8​

    pear, apple 和 orange 中最大的数为 pear

    不同的参数类型有相似的方法

    泛型类

    泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。

    和泛型方法一样,泛型类的类型参数声明部分也包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数,这些类被称为参数化的类或参数化的类型。

    实例

    如下实例演示了我们如何定义一个泛型类:

    public class Box{privateT t;public voidadd(T t) {this.t =t;

    }publicT get() {returnt;

    }public static voidmain(String[] args) {//添加修饰

    Box integerBox = new Box();

    Box stringBox = new Box();

    integerBox.add(new Integer(10));

    stringBox.add(new String("字符"));

    System.out.printf("整型值为 :%d\n\n", integerBox.get());

    System.out.printf("字符串为 :%s\n", stringBox.get());

    }

    }

    编译以上代码,运行结果如下所示:

    整型值为 :10​

    字符串为 :字符

    不同类有相似的参数和相似的方法

    类型通配符

    1、类型通配符一般是使用?代替具体的类型参数。例如 List在逻辑上是List,List等所有List的父类。

    实例1

    ublic classCommonSingle {public static void printer(List> data) {//普通的

    System.out.print(data);

    }public static void getUperNumber(List extends Number> data) {//给通配符划分了范围

    System.out.println("data :" +data);

    }

    }

    List name = new ArrayList();

    List age = new ArrayList();

    List number = new ArrayList();

    name.add("icon");

    age.add(18);

    number.add(314);

    CommonSingle.printer(name);

    CommonSingle.printer(age);

    CommonSingle.printer(number);

    输出结果为:

    data :icon

    data :18data :314

    解析:

    1、因为getData()方法的参数是List类型的,所以name,age,number都可以作为这个方法的实参,这就是通配符的作用

    2、类型通配符上限通过形如List来定义,如此定义就是通配符泛型值接受Number及其下层子类类型。

    3、与第一个泛型方法类似,事根据参数类型选择不同的方法,只是这个参数类型被List包裹。

    实例2

    继续使用上面声明的类CommonSingle

    List name = new ArrayList();

    List age = new ArrayList();

    List number = new ArrayList();

    name.add("icon");

    age.add(18);

    number.add(314);

    CommonSingle.getUperNumber(name);//报错:因为S不在Number的范围内

    CommonSingle.getUperNumber(age);

    CommonSingle.getUperNumber(number);

    输出结果:

    data :18data :314

    解析:

    1、在(//1)处会出现错误,因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number,所以泛型为String是不在这个范围之内,所以会报错

    2、类型通配符下限通过形如 List来定义,表示类型只能接受Number及其三层父类类型,如 Object 类型的实例。

    3、关于上限,? extends Number,Number类的子类如下:

    java.lang.Byte,

    java.lang.Double,

    java.lang.Float,

    java.lang.Long,

    java.lang.Short

    这就是?参数范围。

    4、关于上界下界

    上界的list只能get,不能add(确切地说不能add出除null之外的对象,包括Object)

    下界的list只能add,不能get

    add和get涉及到具体的数据类型了:

    add方法是先给预添加的对象创建一个引用,再让这个引用指向具体的父类或子类对象;

    get方法是返回具体的类(假设为类型1),必须有一个类型1或类型1的父类引用去指向它;

    规定了上界:如果add添加对象,java不知道要为哪一个具体的类添加引用,但java不会自动选择;如果get对象,却可以(人为地)使用上界类创建引用了(因为代码中规定了上界,一看便知)。

    规定了下界:如果add添加对象,java不知道要为哪一个具体的类添加引用,这里就可以(人为地)添加下界类的子类对象了(因为代码中规定了下界,一看便知);如果get对象,只能用预获取的类的‘同类’或父类创建引用,但程序员不知道get出来的是哪个类。

    图解:

    c5c189291f8ee600f7c0d5a225ef4e2b.png

    13b1cf122f2246c378cab461b768e33b.png

    示例代码:

    importjava.util.ArrayList;importjava.util.List;classFruit {}class Apple extendsFruit {}class Jonathan extendsApple {}class Orange extendsFruit {}public classCovariantArrays {public static voidmain(String[] args) {//上界

    List extends Fruit> flistTop = new ArrayList();

    flistTop.add(null);//add Fruit对象会报错//flist.add(new Fruit());

    Fruit fruit1 = flistTop.get(0);//下界

    List super Apple> flistBottem = new ArrayList();

    flistBottem.add(newApple());

    flistBottem.add(newJonathan());//get Apple对象会报错//Apple apple = flistBottem.get(0);

    }

    }

    展开全文
  • scala 的上界下界

    2019-10-30 19:21:50
    二、上界下界 (1)介绍 (2)示例 1)上界示例 2)下界示例 一、泛型 总结:T <: Comparable[T] 表示T比Comparable年龄小,所以T必须为Comparable的子类。相反,T >: Son,T为Son的父类。 (1)泛.....
  • 泛型中上界下界定义 泛型中上界下界定义 上界<? extends Fruit> 下界<? super Apple> 上界的list只能get,不能add除null之外的任何对象,包括Object 下界的list只能add,不能get
  • 目录示例极小元与极大元最小元与最大元上界下界最小上界(上确界)和最大下界(下确界) 示例 示例是整除关系,C表示全集{1,2,3,6,12,24,36}。为方便理解,由下往上分为5行。 极小元与极大元 定义: 判断标准:列出...
  • 泛型中上界下界定义上界 extend Fruit>下界 super Apple>上界下界的特点上界的list只能get,不能add(确切地说不能add出除null之外的对象,包括Object)下界的list只能add,不能getimport java.util....
  • 展开全部有上界的32313133353236313431303231363533e58685e5aeb931333433663034最小元素称为最小上界下界的最大值元素称为最大下界;就像这幅图一样,如果你想找到b和d上的最小上界,你必须找到b和d上的上界,而b...
  • 1、泛型中的上界下界定义 上界<? extends animal> 下界<? extends bird> 2、上界下界的特点 上界的list只能get,不能add(确切地说不能add出除null之外的对象,包括Object) 下界的list只能add,...
  • 文章目录泛型类型约束上下界上界下界视图界定上下文界定 泛型 使用示例 def test={ //应用1 val msg = new IntMessage(1) println(msg) val msg2 = new StringMessage[String]("class") println(msg2) //应用2...
  • ? 通配符类型 ... 表示类型下界,? 表示参数化类型是此 T 类型的超类型 (父类型),直至 Object 上界<? extends T>不能往里存,只能往外取 比如,我们现在定义:List<? extends T>首先你...
  • Scala的协变和逆变上界下界1. 引子:为了弄懂scala中协变和逆变这两个概念,查阅了不少资料,但是还是要自己总结一下,会记得比较深刻。那就从java和scala的对比说起吧。java中:如果你很理解java的泛型,就会知道...
  • 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 ...
  • 展开全部上界的最小元就叫最小上界下界的最大元叫最大下界;就像在这个图中e68a843231313335323631343130323136353331333431346431,如果找b,d的最小上界,就要先找到b,d的上界,b,d上界的点只有f。上界中的...
  • 前言 在指定泛型类型是,有时需要界定泛型类型的范围,而不是接收任意类型。比如,要求某个泛型类型,必须是某个类的子类,这样在程序...1. 上下届定义 注意:Scala中泛型使用A,B,C…Z表示,比如A就是所有类的子类...
  • 题主说的&lt;? extends T&gt;和&lt;...:是指 “上界通配符(Upper Bounds Wildcards)” &lt;? super T&gt;:是指 “下界通配符(Lower Bounds Wildcards)” 1. 为什么...
  • 二、Ω记号(渐近下界记号) 定义2-2 设有函数f(n)和g(n)是定义在非负整数集合上的正函数,如果存在两个正常数 c和n0,使得当n≥n0时,有f(n)≥c g(n),则记做f(n) = Ω (g(n)),称为Ω记号(omega notation)。 注...
  • 下确界和上确界

    千次阅读 2016-09-02 16:01:00
    下确界:infimum,简写为 inf(注意和 infinity(无穷)的区别),最大下界,floor:地板的顶; 上确界:supremum,最小上界,ceiling:天花板的底; 0. (集合)最大数最小数 集合 B={x∣∣0≤x<1} 中没有...
  • 1. 定义 定义: 设<A,≼ >是偏序集, B是A的任何一个子集, 若存在元素 b∈ B, 使得 对任意 x∈ B,都有 x≼ b, 则称b 为B的最大元; 对任意x∈ B, 都有 b≼ x,则称b为B的最小元。 看一个例题: 设A = {2,3,...
  • 注意:B的最大(小)元素和极大(小)元素都必须是子集B的元素,而B的上界(下界)和最小上界(最大下界)可以是也可以不是B的元素。在定义中并没有保证这些元素的存在。在许多情况下他们是不存在的。 上界下界: ...
  • 首先我说一下协变,所谓协变,白话文就是说让你的能够使用比原始定义类型的子类。不要懵逼,光看字我本人也看不懂,那么我们来通过实际的例子来讲解一下,首先上代码: /** * Created by mahuichao on 16/8/4.
  • 算法中的上下界,等阶

    千次阅读 2012-09-16 15:50:39
    算法中的渐近符号含义: 低和顶的定义
  • Java泛型进阶篇: 无界通配符、上界通配符和以及下界通配符 Java泛型(三): 类型擦除 文章目录前言1. 无界通配符使用方法List<?>与List应用场景2. 上界通配符使用方法基本写法指定泛型标识多重上界特点应用...
  • 目录 [−] ...综合协变,逆变,上界下界 View Bound Context Bound 参考文档 Scala中的协变逆变和Java中的协变逆变不一样,看起来更复杂。 本文对Scala中的这些概念做一总结。 首先看几个
  • 先做一个简化的List定义,List对象由head(第一个元素)和tail(除了第一个元素以外所有后续元素组成的List)组成。Nil是空List对象,由于不论List的泛型类型是什么,空List的含义和行为都没有区别,因此全局只需要存在...
  • 当我们定义一个协变类型List[A+]时,List[Child]可以是List[Parent]的子类型。当我们定义一个逆变类型List[-A]时,List[Child]可以是List[Parent]的父类型。Scala的协变看下面的例子:classAnimal{}classBird...
  • 一、泛型擦除、 二、泛型的上界通配符 、 三、泛型的下界通配符 、
  • 四、下界上界 1、下界  下界使用符合 >: 表示,比如下面这段代码中表示类型 U 是类型 T 的父类,即此处的类型 U 最少为 T ,不能比 T 的类型更低。 def enqueue[ U >: T ]( x: U ) = new Queue[ U ]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,727
精华内容 7,090
关键字:

上界下界定义

友情链接: Get_HW_INFO.zip