如何使用泛型从Scala方法返回

我有两个特点

trait TResponseData extends Serializable {} //all response data
trait TRequestData extends Serializable {} //all request

现在我有了Response类，它包含数据和请求

case class Response[A <: TResponseData, B <: TRequestData](data: A, request: B = null){}

为了生成响应的实例，我创建了helper方法：

def generateResponse[A <: TResponseData, B <: TRequestData] (data: A, request: B, passRequestInResponse: Boolean): Response[A, B] = {
    if (passRequestInResponse) 
        return Response(data, request)
    return Response(data, null)
}

---

如何实现相同的目标（使请求在generateResponse方法中成为可选）

您可以修改

generateResponse（）

返回类型

def generateResponse[A <: TResponseData, B <: TRequestData] (data: A
                                                            ,request: B
                                                            ,passRequestInResponse: Boolean
                                                            ): Response[A, _] = 
  if (passRequestInResponse) Response(data, request)
  else                       Response(data, null)

（但不要使用

return

。这不是惯用的Scala。）

---

一般来说，我根本不明白为什么需要

generatereresponse（）

。

响应

构造函数仍将有一个

B

或没有，因此它应该是一个默认为

None的
选项[B]
。（惯用Scala避免了
null
）
您可以修改
generatereresponse（）
返回类型

def generateResponse[A <: TResponseData, B <: TRequestData] (data: A
                                                            ,request: B
                                                            ,passRequestInResponse: Boolean
                                                            ): Response[A, _] = 
  if (passRequestInResponse) Response(data, request)
  else                       Response(data, null)

（但不要使用
return
。这不是惯用的Scala。）

一般来说，我根本不明白为什么需要
generatereresponse（）
。
响应
构造函数仍将有一个
B
或没有，因此它应该是一个默认为
None的
选项[B]
。（惯用的Scala避免了
null
）
使用
null
是个坏主意（正如
return
一样），因此最好使用
选项
：

trait TResponseData extends Serializable //all response data
trait TRequestData extends Serializable //all request

case class Response[A <: TResponseData, B <: TRequestData](data: A, request: Option[B]=None)

def generateResponse[A <: TResponseData, B <: TRequestData] (data: A, request: B, passRequestInResponse: Boolean): Response[A, B] =
  if (passRequestInResponse) {
    Response(data, Some(request))
  } else {
    Response(data)
  }

此公式的优点是，如果
请求
为
空
，它将起作用，并将此情况视为
passRequestInResponse
为
假

更新
正如@jwvh所指出的，
generatereresponse
函数是否有用还不清楚，因为您可以根据需要调用
Response（data，Some（request））
或
Response（data）
。如果您不喜欢第一个版本中的
Some
，请使用自定义
apply
方法创建类对象：

object Response {
  def apply[A <: TResponseData, B <: TRequestData](data: A, request: B): Response[A, B]
    = Response(data, Option(request))
}

对象响应{
def apply[A使用
null
是一个坏主意（正如
返回
），因此最好使用
选项：

trait TResponseData extends Serializable //all response data
trait TRequestData extends Serializable //all request

case class Response[A <: TResponseData, B <: TRequestData](data: A, request: Option[B]=None)

def generateResponse[A <: TResponseData, B <: TRequestData] (data: A, request: B, passRequestInResponse: Boolean): Response[A, B] =
  if (passRequestInResponse) {
    Response(data, Some(request))
  } else {
    Response(data)
  }

此公式的优点是，如果
请求
为
空
，它将起作用，并将此情况视为
passRequestInResponse
为
假

更新
正如@jwvh所指出的，
generatereresponse
函数是否有用还不清楚，因为您可以根据需要调用
Response（data，Some（request））
或
Response（data）
。如果您不喜欢第一个版本中的
Some
，则使用自定义的
apply
方法创建一个类对象：

object Response {
  def apply[A <: TResponseData, B <: TRequestData](data: A, request: B): Response[A, B]
    = Response(data, Option(request))
}

对象响应{
def apply[A错误的原因是Scala中的所有类型都有一个底部类型Nothing。Nothing不能接受“null”值，因此类型定义有问题，因为B可以是Nothing

要解决此问题，可以添加一个下限：

 def generateResponse[A <: TResponseData, B >: Null <: TRequestData ] (data: A, request: B,
                                                           passRequestInResponse: Boolean): Response[A, B] = {

因为这将给出值。Return实际上是一个控制流中断（它是在异常情况下实现的），可能会产生意外的后果。例如，请参见。错误的原因是Scala中的所有类型的底部类型都为Nothing。Nothing不能接受“null”值，因此类型定义是有问题的，因为B可以是空的

要解决此问题，可以添加一个下限：

 def generateResponse[A <: TResponseData, B >: Null <: TRequestData ] (data: A, request: B,
                                                           passRequestInResponse: Boolean): Response[A, B] = {

因为这将给出值。Return实际上是一个控制流中断（它是通过异常实现的）并且可能会产生意外后果。例如，请参见
谢谢回复。我将使用generateResponse，因为我正在其中执行更多操作。谢谢回复。我将使用generateResponse，因为我正在其中执行更多操作。
if (passRequestInResponse) {
  Response(data, Some(request))
} else {
  Response(data)
}