Каковы различия между asInstanceOf [T] и (o: T) в Scala?

Ответ 1

• foo.asInstanceOf[Bar] - это тип cast, который в основном является операцией во время выполнения. В нем говорится, что компилятор должен быть убежден в том, что foo является Bar. Это может привести к ошибке (a ClassCastException), если и когда foo оценивается как нечто отличное от Bar во время выполнения.

• foo:Bar - это тип ascription, который полностью является операцией во время компиляции. Это дает компилятору помощь в понимании смысла вашего кода, не заставляя его верить всему, что может быть неверным; никакие ошибки выполнения не могут возникнуть в результате использования тиков.

Атрибуты типов также могут использоваться для запуска неявных преобразований. Например, вы можете определить следующее неявное преобразование:

implicit def foo(s:String):Int = s.length

а затем обеспечить его использование следующим образом:

scala> "hi":Int                                 
res29: Int = 2

Тип записи Int до String обычно является ошибкой типа времени компиляции, но перед отказом компилятор будет искать доступные неявные преобразования, чтобы проблема исчезла. Конкретное неявное преобразование, которое будет использоваться в данном контексте, известно во время компиляции.

Излишне говорить, что ошибки времени выполнения нежелательны, поэтому степень, в которой вы можете указать вещи безопасным способом (без использования asInstanceof), тем лучше! Если вы обнаружите, что используете asInstanceof, скорее всего, вы должны использовать match.

Ответ 2

Ответ на Pelotom охватывает теорию довольно неплохо, вот несколько примеров, чтобы сделать ее более ясной:

def foo(x: Any) {
  println("any")
}

def foo(x: String) {
  println("string")
}


def main(args: Array[String]) {
  val a: Any = new Object
  val s = "string"

  foo(a)                       // any
  foo(s)                       // string
  foo(s: Any)                  // any
  foo(a.asInstanceOf[String])  // compiles, but ClassCastException during runtime
  foo(a: String)               // does not compile, type mismatch
}

Как вы можете видеть, тип апликации может использоваться для устранения неоднозначности. Иногда они могут быть неразрешимы компилятором (см. Ниже), в котором сообщается об ошибке, и вы должны ее решить. В других случаях (например, в примере) он просто использует "неправильный" метод, а не тот, который вы хотите. foo(a: String) не компилируется, показывая, что тип присваивания не является литой. Сравните его с предыдущей строкой, где компилятор счастлив, но вы получаете исключение, поэтому ошибка обнаруживается тогда с типом присваивания.

Вы получите неразрешимую двусмысленность, если вы также добавите метод

def foo(xs: Any*) {
  println("vararg")
}

В этом случае первый и третий вызов foo не будут компилироваться, так как компилятор не может решить, хотите ли вы вызвать foo с одним параметром Any или с varargs, так как оба они кажутся одинаково хорошими = > вы должны использовать типу типа, чтобы помочь компилятору.

Изменить см. также Что такое назначение типа в Scala?

Ответ 3

Программирование в Scala подробно описано в главе 15 - Классы классов и сопоставление образцов.

В основном вторая форма может использоваться как "типизированный шаблон" в совпадении шаблонов, предоставляя функции isInstanceOf и asInstanceOf. Сравнить

if (x.isInstanceOf[String]) {
  val s = x.asInstanceOf[String]
  s.length
} else ...

против.

def checkFoo(x: Any) = x match {
  case s: String => s.length
  case m: Int => m
  case _ => 0
}

Авторы намекают, что многословие isInstance* делает вещи намеренно подталкивать вас к стилю соответствия шаблону.

Я не уверен, какой шаблон более эффективен для простого типа без проверки.

Ответ 4

Есть пример разницы:

• Тип cast (asInstanceOf) - это операция времени выполнения с потенциальным исключением во время выполнения.
• Атрибут - это в основном просто аксиоматика, выполняемая во время компиляции.

Пример:

class Parent() { def method() {} }
class Child1 extends Parent() { def method1() {} }
class Child2 extends Parent() { def method2() {} }

// we return Parent type
def getChild1() : Parent = new Child1()
def getChild2() : Parent = new Child2()
def getChild()  : Child1 = new Child1()

(getChild1().asInstanceOf[Child1]).method1() // OK
(getChild1().asInstanceOf[Child2]).method2() // runtime ClassCastException

(getChild1() : Child2).method2() // compile-time error
(getChild2() : Child2).method2() // compile-time error
(getChild() : Parent).method1() // compile-time error
(getChild()).method()  // OK

// with asInstanceOf, we can cast to anything without compile-time error
getChild1().asInstanceOf[String] // runtime ClassCastException
getChild1().asInstanceOf[Int] // runtime ClassCastException

Мы также можем вызвать метод с использованием множественной отправки:

def prt(p: Parent) = println("parent")
def prt(ch: Child1) = println("child")

prt(new Parent()) // prints "parent"
prt((new Child1()) : Parent) // prints "parent"
prt(new Child1()) // prints "child"

prt(new Parent().asInstanceOf[Child1]) // runtime ClassCastException
prt(new Child1().asInstanceOf[Parent]) // prints "parent"

Мы можем определить неявное преобразование:

// after definition of implicit conversions
implicit def toChild1(p: Parent) : Child1 = new Child1()
implicit def toChild2(p: Parent) : Child2 = new Child2()

(getChild1() : Child2).method2() // OK - implicit conversion to Child2 in ascription
(getChild2() : Child2).method2() // OK - implicit conversion to Child2 in ascription
(getChild2()).method1() // OK - implicit conversion to Child1 when calling method1()
(getChild2()).method2() // OK - implicit conversion to Child2 when calling method2()
(getChild2() : Parent).method() // OK - no implicit conversion
(getChild() : Parent).method1() // OK - implicit conversion to Child1 when calling method()

getChild1().asInstanceOf[Int] // still runtime ClassCastException (no implicit conversion)