Scala：在泛型类后面隐藏两个类

我有两个不同的scala类，我们可以称之为ClassA和ClassB

也就是说，我必须使用doSomething（ClassA）和doSomething（ClassB）函数

我想创建一个新类ClassC，它可以从ClassA或ClassB构造，并实现一个函数doSomething

我的问题是我对Scala构造函数不太熟悉（我更像是一个Java开发人员），我觉得我所做的并不正确。以下是我的尝试：

class ClassC(obj:Object,tmp:Integer) {

  def this(classA: ClassA){
    this(classA,0)
  }

  def this(classB: ClassB){
    this(classB,0)
  }

  def doSomething(){
    if(obj.getClass.getName == "ClassA"){
          // do something with obj
    }else if(obj.getClass.getName == "ClassB"){
          // do something with obj
    }
  }
}

---

您可以使用任意一种方法使其工作

class ClassA {
  def operation = "Child1"
}
class ClassB  {
  def operation = "Child2"
}

class Op1(l: Either[ClassA, ClassB]) {
  def operation(): String = {
    l.fold(_.operation,_.operation)
  }
}

new Op1(Left(new ClassA)).operation()
new Op1(Right(new ClassB)).operation()

---

您可以使用任意一种方法使其工作

class ClassA {
  def operation = "Child1"
}
class ClassB  {
  def operation = "Child2"
}

class Op1(l: Either[ClassA, ClassB]) {
  def operation(): String = {
    l.fold(_.operation,_.operation)
  }
}

new Op1(Left(new ClassA)).operation()
new Op1(Right(new ClassB)).operation()

---

使用

或
并捕获这两种情况

class A {
  def foo: Int = 1
}

class B {
  def foo: Int = 2
}

假设A和B不能更改，并且可以从某些库中获得

创建类
Delegator

case class Delegator(delegations: Either[A, B]) {
 def foo: Int = delegations.fold(_.foo, _.foo)
}

Scala REPL
使用
apply
方法，语法会变得更好

case class Delegator(delegations: Either[A, B]) {
 def apply(): Int = delegations.fold(_.foo, _.foo)
}

Scala REPL
使用
或
并捕获这两种情况

class A {
  def foo: Int = 1
}

class B {
  def foo: Int = 2
}

假设A和B不能更改，并且可以从某些库中获得

创建类
Delegator

case class Delegator(delegations: Either[A, B]) {
 def foo: Int = delegations.fold(_.foo, _.foo)
}

Scala REPL
使用
apply
方法，语法会变得更好

case class Delegator(delegations: Either[A, B]) {
 def apply(): Int = delegations.fold(_.foo, _.foo)
}

Scala REPL
通常的方法是创建一个公共特征/抽象类和两个扩展它的类，其中一个可以从
ClassA
构建，另一个可以从
ClassB
构建：

trait TraitC {
  def doSomething(): Unit
}
object TraitC {
  def apply(x: ClassA) = ClassCA(x)
  def apply(x: ClassB) = ClassCB(x)
}

class ClassCA(x: ClassA) extends TraitC {
  def doSomething() = doSomething(x)
}
class ClassCB(x: ClassB) extends TraitC {
  def doSomething() = doSomething(x)
}

使用
obj.getClass.getName
比使用任何东西都要好得多正常的方法是创建一个公共特征/抽象类和两个扩展它的类，其中一个可以从
ClassA
构建，另一个可以从
ClassB
构建：

trait TraitC {
  def doSomething(): Unit
}
object TraitC {
  def apply(x: ClassA) = ClassCA(x)
  def apply(x: ClassB) = ClassCB(x)
}

class ClassCA(x: ClassA) extends TraitC {
  def doSomething() = doSomething(x)
}
class ClassCB(x: ClassB) extends TraitC {
  def doSomething() = doSomething(x)
}

使用
obj.getClass.getName
比使用任何东西都要好得多，您是否可以更改
ClassA
和
ClassB
？使用
if-else
选择动作类似于标记的反模式。可能有一个
trait C{def doSomething（arg:Integer）}
，
ClassA
和
ClassB
都实现了
trait C{def doSomething（arg:Integer）}
，而不需要将它们包装到
ClassC
中。不，我不允许更改ClassA和ClassB，因为它们来自外部库。您可以更改
ClassA
和
ClassB
？使用
if-else
选择动作类似于标记的反模式。可能存在一个
特性C{def doSomething（arg:Integer）}
，它是
ClassA
和
ClassB
实现的，而不需要将它们包装到
ClassC
中。不，我不允许更改ClassA和ClassB，因为它们来自外部LIB。我不允许更改ClassA和ClassB，因为它们来自外部LIB，所以我不能使用此解决方案。我不允许更改ClassA和ClassB，因为它们来自外部LIB，所以我不能使用此解决方案。