将isInstanceOf类设置为变量

Question

鉴于扩展了MyAbstractClass的MyClass1和MyClass2，我需要实现一种逻辑，其中isInstanceOf中使用的类型是可变的（请参见下面的myFunction）。这可行吗？

abstract class MyAbstractClass {
  val a: Int
  val b: Int
}

class MyClass1 extends MyAbstractClass {
  val c: String
}

class MyClass2 extends MyAbstractClass {
  val d: Int
}



object HelloScala extends App {


    def myFunction(indicator: Int) = {

      val MyClass = if (indicator  == 1) MyClass1 else MyClass2

      if (someObject.isInstanceOf[MyClass])
          // do something
      else
          // do something else

    }

}

Answer 1

  

我正在寻找在isInstanceOf的方括号之间的值中使用变量，例如我问题中的变量MyClass是isInstanceOf使用的变量。我的问题中的代码无法编译，我正在寻求解决。

您无法从字面上做到这一点，但是您可以使用Scala通过classOf及其isInstance方法为您提供的实际Class值来实现：

val myClass = if (indicator == 1) classOf[MyClass1] else classOf[MyClass2]
if (myClass.isInstance(someObject)) ...

Answer 2

使用模式匹配代替isInstanceOf

def myFunction(indicator: Int) = {

  someObject match {
    case x: MyClass1 if indicator == 1 => doSomething()
    case x: MyClass2 if indicator != 1 => doSomething()
    case _ => doSomethingElse()
  }


}

简单版本

 (someObject, indicator) match {
    case (_: MyClass1, 1) | (_: MyClass2, y) if y != 1  => doSomething()
    case _ => doSomethingElse()
  }

使用isInstanceOf

if (someObject.isInstanceOf[MyClass1] && indicator == 1)
      // do something
else if (someObject.isInstanceOf[MyClass2] && indicator != 1)
      // do something
else // do Something else

Answer 3

说实话，我认为您的方向错误。 Scala允许面向对象的程序设计（与FP一起使用，这是与纯FP语言相比的主要优势之一）。那为什么不在这里使用典型的继承呢？

abstract class MyAbstractClass {

  def logic();
}

class MyClass1 extends MyAbstractClass {
  val c: String

  def logic() {
    ...
  }
}

class MyClass2 extends MyAbstractClass {
  val d: Int

  def logic() {
    ...
  }
}

object HelloScala extends App {


    def myFunction(indicator: Int) = {

      val obj: MyClass = if (indicator  == 1) new MyClass1() else new MyClass2()

      obj.logic()


    }

}

Answer 4

如果您不需要该对象：

    (indicator, someObjectIDontWantToUse) match {
       case (1, _: MyClass1) | (_, _: MyClass2) => doSomething()
       case _ => doSomethingElse()
    }

如果您需要它：

    (indicator, someObjectIWantToUse) match {
       case (1, someObject: MyClass1) => doSomethingWith(someObject)
       case (_, someObject: MyClass2) => doSomethingWith(someObject)
       case _ => doSomethingElseWith(someObject)
    }