F-有界多态Java中的返回类型
是指在Java中使用泛型来限制方法的返回类型。在Java中，可以使用泛型来定义一个方法，使其返回的类型在一定范围内。这个范围可以是一个具体的类，也可以是一个接口。
有界多态的概念是指在泛型中使用extends关键字来限制类型参数的范围。在F-有界多态Java中，可以使用extends关键字来限制返回类型必须是某个类或接口的子类或实现类。
有界多态的优势是可以提供更加灵活和安全的类型检查。通过限制返回类型的范围，可以在编译时检查类型的正确性，避免在运行时出现类型转换错误。
有界多态的应用场景包括但不限于以下几个方面：
- 在集合类中使用有界多态可以限制集合中元素的类型范围，提高代码的可读性和安全性。
- 在接口中使用有界多态可以限制实现类的类型范围，确保实现类满足特定的条件。
- 在方法中使用有界多态可以限制返回类型的范围，提供更加灵活的方法调用方式。
腾讯云提供了一系列与Java开发相关的产品和服务，包括但不限于：
- 云服务器（CVM）：提供弹性计算能力，支持Java应用的部署和运行。链接地址：https://cloud.tencent.com/product/cvm
- 云数据库MySQL版（CDB）：提供高可用、可扩展的MySQL数据库服务，适用于Java应用的数据存储。链接地址：https://cloud.tencent.com/product/cdb_mysql
- 云函数（SCF）：提供无服务器的函数计算服务，可以用于Java函数的编写和执行。链接地址：https://cloud.tencent.com/product/scf
- 云监控（Cloud Monitor）：提供全方位的监控和告警服务，可以监控Java应用的性能和运行状态。链接地址：https://cloud.tencent.com/product/monitor
以上是腾讯云提供的一些与Java开发相关的产品和服务，可以根据具体需求选择适合的产品来支持Java开发和部署。
相关·内容
2回答
我已经搜索了一下，但我没有找到这样一个结构的例子：
Person[P <: Person[P]]
这是以我理解的方式解释的。
这是如何解决的？对我来说，这看起来像是一个无休止的递归，但似乎我的结论是错误的。
浏览 2提问于2013-02-18得票数 5
回答已采纳
1回答
在Scala中引用特征中的子类型
、、、、
由于Scala对泛型的广泛支持，在Command[A, C]中的C是自身的子类型(即UserCommand或SystemCommand)的情况下，实现以下循环参数界限的最佳方式是什么？
注意:我省略了C的类型下限/上限-正如问题所暗示的，我不确定如何用编译的方式来表达它，或者我是否在Scala中缺少了一个专门用于解决这种循环问题的功能。
trait CommandPrerequisite[-A, +C] {
val command: C
def isValid(aggregate: A): Boolean
}
trait Command[A, C] {
def prereq
浏览 1提问于2013-06-13得票数 0
1回答
假设有以下情况：
scala> trait Bip[T]
defined trait Bip
scala> trait Bop[R <: Bip[R]]
defined trait Bop
我的理解是R的上限是Bip[R]类型。如果是这样的话，我不清楚什么类型可以满足这个约束。
例如，如果我想创建一个Bop[Int]，那么下面的least upper bound不会解析为Any吗
scala> import scala.reflect.runtime.universe._
import scala.reflect.runtime.universe._
scala&
浏览 2提问于2015-06-30得票数 0
作为练习，我应该实现一个特征PartialOrderedT。
trait PartialOrdered[T] {
def below(that: T): Boolean
def < (that: T): Boolean = (this below that) && !(that below this)
/* followed by other relations <=, >, >=, ==, .. */
}
扩展此特征的类K应在下面实现，以便
a.below(b: K) = { true if a <= b,
浏览 3提问于2013-05-04得票数 1
回答已采纳
我有一个F有界类型，我的目标是创建一个类型参数化方法，以便能够重用它。下面是示例代码：
trait FType {
type ThisType <: FType
def deepCopy(): ThisType
}
class ConcreteType extends FType {
override type ThisType = ConcreteType
override def deepCopy(): ConcreteType = this
}
class ConcreteType2 extends FType {
override type T
浏览 5提问于2018-11-26得票数 2
我需要一个定义clone()成员的IClonable接口，该接口返回实现它的类的一个实例。
如果可能，我如何才能指明clone()的返回类型将与调用它的类相同？
interface IClonable {
clone(): ???
}
我知道我可以使用下面这样的泛型来做这件事，但这似乎过于冗长
interface IClonable<T> {
clone(): T
}
浏览 0提问于2016-04-20得票数 19
回答已采纳
5回答
例如，Num a => a。
我假设它们只是被称为“受约束的类型”，但是Googling没有找到这个术语的很多用法，所以我很好奇它们是不是用了其他的名字。
浏览 0提问于2012-07-14得票数 8
回答已采纳
假设我们想实现数据类型层次结构，应该使用哪种类型？
interface Collection<T> {
map(f: (v: T) => T): ???
}
interface Array<T> extends Collection<T> {
map(f: (v: T) => T): ??? { return new Array<T>() }
}
interface LinkedList<T> extends Collection<T> {
map(f: (v: T) => T): ???
浏览 1提问于2019-02-11得票数 2
1回答
Scala类型参数作为内射映射
、、、、
有一些类型T和抽象类X[T]，要点是，对于每个具体的类型T，如果定义了的话，只有一个X[T]的子类，例如，IntX extends X[Int]，它是X[T]的唯一一个带有T = Int的子类。也就是说，从理论上讲，对于某些类型集，我们有一个内射映射T -> X[T]。
让我们看一下两个简单的定义：
trait Context[T] {
type XType <: X[T]
}
abstract class X[T] extends Context[T] {
def plus1(that: XType): XType = ??? /* doesn't ma
浏览 51提问于2018-06-12得票数 1
当我在scala和我写
val data: java.util.List[java.util.List[Double]] = new java.util.ArrayList[java.util.ArrayList[Double]]()
我知道错误了
类型util.ArrayList[util.ArrayListDouble]的表达式不符合预期的util.List[util.ListDouble]类型
我做错了什么？
浏览 3提问于2017-11-15得票数 1
回答已采纳
我刚开始研究一个特性，然后我发现这个语法我不懂
trait Holder[H <: service.SealedHolder[H]] {
val personId: String //ID.03
}
我想这可能是一个泛型声明，但仍然对scala语法Holder[H <: service.SealedHolder[H]]感到困惑。
浏览 1提问于2019-04-04得票数 0
回答已采纳
我指的是这样的情况：
class Foo {
constructor(public n: number) {}
get value(): number { return this.n; }
addTwo(): Foo {
this.n += 2;
return this;
}
}
class Bar extends Foo {
// Can I avoid the code below, and type addTwo() in a way
// that returns type Bar for a Bar instance?
//
浏览 1提问于2021-02-17得票数 0
回答已采纳
2回答
短暂的搜索并没有帮助我找到答案，所以我开始怀疑它的存在。问题很简单。我想创建一个多态函数，如下所示：
f :: String -> String
f s = show (length s)
f :: Int -> String
f i = show i
对于不同的数据类型定义不同的函数是指。有可能吗？如果是，是如何实现的？
浏览 0提问于2012-09-15得票数 10
回答已采纳
2回答
如果我有一个抽象类Location和两个子类，如下所示
abstract class Location[L <: Location[L]]
case class Loc1(name: String) extends Location[Loc1]
case class Loc2(name: String) extends Location[Loc2]
def getLoc[L <: Location[L]](x: Boolean): L =
if (x) Loc1("1")
else Loc2("2")
对getLoc的调用将导致类型不匹配
浏览 0提问于2018-06-08得票数 2
回答已采纳
1回答
Java F-按接口绑定
、、、
注释：Inter是接口；Abs[N]是一个抽象类。
以下代码在Java中运行良好，没有问题：
public class Impl<T extends Abs1<T>> extends Abs2<T> {...}
但是，如果您想在T上引入另一个受接口约束的方法，那么我还没有找到任何简单的方法来实现它，即：
public class Impl<T extends Inter & Abs1<T>> extends Abs2<T> {...}
不能工作，因为Abs1作为抽象类不能用作边界参数。最简单，但很丑(是不是很丑？)
浏览 3提问于2017-02-16得票数 1
回答已采纳
1回答
对于Haskell的类型类，它似乎支持即席多态，但它的函数声明似乎是参数多态。我是不是混淆了我对不同事物的理解？
浏览 1提问于2011-04-15得票数 26
回答已采纳
3回答
我在许多文章中读到过关于堆栈溢出的文章，当使用指针(用于参数或返回值)并允许使用nullptr (使其成为可选的)时，通常使用std::optional会更好。
但是，如果指针引用了多态类型呢？最好是使用std::optional还是一个指针？
浏览 1提问于2016-05-22得票数 8
1回答
我正在开发一个基于ReactiveMongo的ORM样式库。目前，我试图实现一个嵌套的文档表示--然而，我一直在为我的类使用Scala的类型推断。我是Scala的新手，所以欢迎任何帮助。
这是我的尝试：
trait MongoDocument[T <: MongoDocument[T]] {
self: T =>
val db: DefaultDB
val collection: String
var fields: List[MongoField[T,_]] = List.empty
def apply(doc: TraversableBSONDocume
浏览 3提问于2013-03-12得票数 3
2回答
通常不鼓励在Java中的返回参数中使用泛型通配符类型。例如，有效的Java，第28项指出：
不使用通配符类型作为返回类型。不是为用户提供额外的灵活性，而是强制用户在客户端代码中使用通配符类型。
如果使用得当，类的用户几乎看不到通配符类型。它们导致方法接受它们应该接受的参数，并拒绝它们应该拒绝的参数。如果类的用户必须考虑通配符类型，那么类的API.可能有问题。
然而，在某些情况下，这似乎是最理想的选择，例如在下面的代码中：
import java.util.*;
import java.lang.*;
import java.io.*;
class Container
{
pr
浏览 3提问于2016-01-06得票数 8
什么是Smalltalk中的“无界动态多态性”？有人能举个例子吗？
在这个C++模板中提到了它:完整的指南，第238页。
浏览 7提问于2012-02-15得票数 2
回答已采纳
在Java中，参数化类型的变化取决于它的使用方式：
<A extends B,B> void store(ArrayList<B> list, A elem) {
list.add(elem);
}
而在Scala中，它是在类声明中用+或-表示的。
我想知道的是，既然Scala已经存在了一段时间了，人们将方差作为这类属性的经验是什么？对于你想要做的事情，它是否具有足够的灵活性？知道你现在知道些什么，你是否会采取不同的做法呢？
浏览 0提问于2011-08-25得票数 4
将通用类型Num a => a分配给2而不是缺省为某个特定类型(如Int或Integer )背后的基本原理是什么
其次，我在很多地方都读到过2是一个多态的值，但是多态的定义不允许使用约束变量。那么2在Haskell中是多态的吗？
浏览 0提问于2016-11-13得票数 1
我有以下问题:我希望有一个‘实例’(参数化特征)和‘配置’，而后者是由实例类型参数化的：
trait Kind
trait Kind1 extends Kind
trait Kind2 extends Kind
trait Instance[T <: Kind] {
def configuration: InstanceConfiguration[Instance[_]]
}
trait InstanceConfiguration[+T <: Instance[_]] {
}
class AInstance extends Instance[Kind1] {
over
浏览 5提问于2014-04-01得票数 1
回答已采纳
1回答
Scala特征Haskell类型类和C++0x概念有什么不同？
就像下面这个例子，观察者声明了一个抽象成员，receiveUpdate观察者实际上是一个“匿名”类型或结构类型。
package observer
trait Subject {
type Observer = { def receiveUpdate(subject: Any) }
private var observers = List[Observer]()
def addObserver(observer:Observer) = observers ::= observer
def notifyObs
浏览 3提问于2010-06-24得票数 3
回答已采纳
2回答
class Foo(protected[this] val s: Iterator[String]) {
def apply(it: Iterator[String]): Foo = new Foo(it ++ s)
}
class Bar(s: Iterator[String]) extends Foo(s) {
}
问题：如何让Bar.apply()返回new Bar而不是new Foo？我不想推翻。
浏览 3提问于2014-04-24得票数 1
回答已采纳
4回答
的问题经常在StackOverflow上被问到。就是一个这样的例子。通常的答案似乎是或模式解决方案。奥德斯基在“”中建议
F-界确实增加了相当大的复杂性。我希望能摆脱它们，用更好的亚型代替它们。
而tpolecat (链接的作者)则建议
一个更好的策略是使用一个类型，它能很好地解决问题，并且几乎没有担心的余地。事实上，在这种情况下，完全放弃子类型多态性是值得考虑的。
其中标识了以下
F限制多态性将类型参数化为其自己的子类型，这是一个比用户通常想要的更弱的约束，这是一种表示“my type”的方式，您无法通过子类型精确地表示它。不过，打字员可以直接表达这个想法，所以我要教初学者
浏览 10提问于2020-01-19得票数 10
回答已采纳
1回答
语用专业化的误区
、、
SPECIALIZE实用化的目的是创建更具体的函数版本。
我有个功能
adaptBlocks :: Int -> BlocksField a -> Maybe (BlocksField a)
我的专业如下：
{-# SPECIALIZE NOINLINE
adaptBlocks :: Int -> BlocksField Element -> Maybe (BlocksField Element) #-}
但是编译器给了我这个令人困惑的警告：
SPECIALISE pragma for non-overloaded function ‘adaptBlocks’
浏览 4提问于2017-11-02得票数 8
回答已采纳
我正在使用GWT库。有一个名为Widget的基类，所有小部件都是从它继承的。有些小部件实现某些接口(例如HasText)，而另一些则不实现。有时，我希望保证传递给函数的参数属于某个类，并实现了某个接口。
例如，我希望有一个带有参数X的函数，其中X是类类型的Widget，接口类型是HasText。我希望有这种行为，因为只有小部件可以添加到布局容器中，而HasText指定了我实际上需要从上述Widget获得的完整行为集。
在伪码形式下，它可能是：
public void fx(I_AM_A_Widget_AND_IMPLEMENT_INTERFACE_HasText x){
//do s
浏览 1提问于2010-02-19得票数 5
回答已采纳
我想用that类型编写redux，但是我有一些关于如何做到这一点的问题。
流型剩馀
type ActionType =
| 'A'
| 'B'
;
// A generic type conforming to Flux Standard Action
type ActionT<A, P> = {|
type: A,
payload?: P | Error,
error?: boolean,
meta?: mixed
|};
type Action =
| ActionT<'A', strin
浏览 3提问于2017-04-11得票数 2
回答已采纳
1回答
我想澄清一下，我是否有权定义这两种多态情况：
首先：
class Operations
trait ExpAlg {
type Opr <: Operations
def lit(x: Int): Opr
}
trait Eval extends Operations {
def eval(): Int
}
trait EvalExpAlg extends ExpAlg {
type Opr = Eval
def lit(x: Int) = new Eval() {
def eval() = x
}
}
它是否使用子类型多态与边界和特征？
第二：
tr
浏览 1提问于2016-01-10得票数 2
1回答
VarHandle显示以下错误-
Exception in thread "main" java.lang.NoSuchMethodError: VarHandle.compareAndSet(VarHandleExample,int,int)void
at java.base/java.lang.invoke.MethodHandleNatives.newNoSuchMethodErrorOnVarHandle(MethodHandleNatives.java:492)
at java.base/java.lang.invoke.MethodHandleNat
浏览 5提问于2018-10-24得票数 8
例如，我有一个名为Foo的类
abstract class Foo {
def f(): ??? = { ... }
}
class Bar extends Foo {
...
}
class Baz extends Foo {
...
}
我想让f在被Bar调用时返回一个Bar，在被Baz调用时返回一个Baz。Bar和Baz都有相同的构造函数，所以f中的代码两次都是相同的，除了我是否必须指定new Bar(...)或新的Baz(...)。有没有办法说新的TypeOfWhateverClassIsCallingMe(...)？
浏览 1提问于2016-08-30得票数 2
回答已采纳
3回答
泛型还是通用接口？
、、、
我不记得上次写泛型课是什么时候。每次我认为我需要它后，我做了一个结论，我不需要。
这个问题的第二个答案让我要求澄清(因为我还不能发表评论，我提出了一个新的问题)。
因此，让我们以给定的代码为例，说明需要泛型的情况：
public class Repository<T> where T : class, IBusinessOBject
{
T Get(int id)
void Save(T obj);
void Delete(T obj);
}
它具有类型约束：IBusinessObject
我通常的想法是:类受限于使用IBusinessObject，使用此Reposit
浏览 0提问于2015-11-22得票数 27
我刚刚读到了，以及如何将它用于可扩展记录和多态变体。
然而，Ocaml对多态变体使用子类型。为什么？它是否比行多态性更强大？
浏览 2提问于2013-05-27得票数 6
回答已采纳
我试着阅读维基百科( wikipedia )，但它在多态性(特别是与Java相关)这一主题上非常密集。我的理解是子类型多态性与子类型有关，参数多态性与跨不同对象/类的方法有关吗？我遗漏了什么？
浏览 6提问于2014-05-06得票数 9
回答已采纳
1回答
我使用的是jax-RPCServer5.0.1，并使用JBoss编写了一个web服务客户端。当我运行它时，我得到了以下异常。由于jax- JBoss web服务不接受传入/传出jax-rpc的用户定义的Java，因此我将所有的Java对象转换为字符串、字符串数组和原始数据类型。所以我从我的客户端调用web服务，但是当我尝试调用我的web服务时，它抛出以下异常。请帮帮我。
17:27:09,537 ERROR [ServiceProxy] Service error
javax.xml.rpc.ServiceException: Cannot create proxy
at or
浏览 0提问于2012-07-18得票数 0
回答已采纳
1回答
我正在使用RXJava的改进来调用我的API，我试图将我的调用结果映射到密封的类成功和失败部分，
我做了映射部分，但我总是得到错误java.lang.RuntimeException:未能调用私有结果()而没有args
这是我的代码：
改装接口
@POST("$/Test")
fun UpdateProfile(@Body testBody: TestBody): Single<Result<TestResult>>
结果密封类
sealed class Result<T> {
data class Success<T>(val
浏览 2提问于2021-10-03得票数 0
回答已采纳
Flow说，下面voidnullify返回的类型是不兼容的。我想我漏掉了什么？
import faker from 'faker'
type P =
| string
| number
| boolean
function voidnullify(func: () => P): ?P {
const random: number = faker.random.number({
min: 1,
max: 10
})
const result = func()
if (random <= 7) return resu
浏览 2提问于2017-04-13得票数 0
回答已采纳
5回答
Haskell的TypeClasses和Go的接口有什么相似之处和不同之处？这两种方法的优缺点是什么？
浏览 1提问于2010-06-06得票数 30
我正在查看来自Oracle的Java，特别是作为java.util.Arrays类的一部分的这个方法：
public static <T> List<T> asList(T... a)
但是，当这个方法显然是一个接口时，它怎么可能返回一个列表对象呢？
浏览 5提问于2015-04-13得票数 2
回答已采纳
1回答
如何将多个关系配置为同一个实体的多个关系？
考虑两类男孩和玩具。它们看起来如下所示
class Boy {
@OneToMany(mappedBy='ownedBy',fetch=FetchType.EAGER, cascade=CascadeType.ALL)
private List<Toy> bikes;
...
@OneToMany(mappedBy='ownedBy',fetch=FetchType.EAGER, cascade=CascadeType.ALL)
private List<Toy
浏览 4提问于2012-06-23得票数 0
4回答
泛型与约束多态性与亚型
、、、、
在Haskell类的这个中，幻灯片#54有这样的问题：
开放式问题：
在具有泛型和受限多态性的语言中，您也需要子类型吗？
我的问题是：
泛型和受限的多态性如何使子类型变得不必要？
如果泛型和受限的多态性使得子类型变得不必要，为什么Scala有子类型？
浏览 3提问于2010-04-25得票数 18
回答已采纳
1回答
正如我了解RTTI是如何在各种C++编译器(例如GCC)中实现的，指向type_info数据的指针存储在每个类的vtable数据中。
同时，还提到了类型可能没有一个vtable。
但是，如果POD类型可能没有vtable，那么指向type_info的指针存储在哪里？我知道它是特定于实现的，但是最好知道C++编译器(比如GCC)的内部结构。
浏览 3提问于2016-02-11得票数 5
回答已采纳
2回答
通过示例考虑以下简单的Python函数：
def quantize(data, nlevels, quantizer=lambda x, d: int(floor(x/d))):
llim = min(data)
delta = (max(data) - llim)/(nlevels - 1) # last level x == max(data) only
y = type(data)
if delta == 0:
return y([0] * len(data))
else:
return y([quantizer(x
浏览 3提问于2011-08-02得票数 3
1回答
我是一个Java用户，我正在使用C++，在Java语言中，它允许类显示可迭代类型，这样客户端就可以遍历某个实例的数据集合。有什么方法可以在C++中获得此功能吗？这是我试图用c++实现的一个示例。 public Iterable<String> keys() {
Queue<String> queue = new Queue<String>();
collect(root, new StringBuilder(), queue);
return queue;
浏览 19提问于2021-03-24得票数 1
回答已采纳
1回答
我刚从java开始。只是为了确保我能正确地解释这一点，并理解术语。看起来，子类型多态性将由两个组件组成，多态对象和多态方法。
我的问题是，所以Animal a = new Dog();将是多态对象，而重写多态方法的方法是多态方法吗？
浏览 3提问于2016-10-05得票数 1
回答已采纳
所以，我在Head First Java上学习，在那里我读到-
重载方法只是一个不同的方法，恰好具有相同的方法名称，它与继承和多态性无关。
然而，我有另一本名为的著名著作-- Herbert的“完整参考”，在这本书中，我读到：
方法重载是Java支持多态性的方式之一。方法重载支持多态性，因为它是Java实现“一个接口、多个方法”范例的一种方式。
哪一个是对的？
浏览 3提问于2017-08-14得票数 0
回答已采纳
在App中，根据，getTypeRank方法具有以下签名：
public static int getTypeRank(java.lang.Class<? extends java.lang.Comparable> datastoreType)
在方法签名中，尖括号内有一个问号：
<? extends java.lang.Comparable>
这意味着什么？
浏览 5提问于2010-02-28得票数 14
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
