Question

我看到,在Schala有两种投射物体的方法:

foo.asInstanceOf[Bar]
(foo: Bar)

在我受审时,我发现<条码>。不使用含蓄的换算,而后者则使用。

这两种方法之间的行为差别如何? 它建议哪里使用一种方法?

Answer 1

<代码>foo.asInstanceOf[Bar]为“cast,主要是一次操作。它说,应当强迫汇编者相信foo为Bar。如果在<代码>foo上被评价为“以外的东西,则可能导致错误(ClassCastException)。 Bar atprtime.
<代码>foo:Bar 是ascription的类型,完全是汇编时间操作。这样做是为了帮助汇编者了解你的法典的含义,同时又不迫使其相信任何可能不真实的东西;不会因为使用字典而造成长期失败。

描述也可用于引发默示转换。例如,你可以界定以下默示转换:

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

之后确保使用:

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

在<代码>上安装<代码>Int至 String通常是一种汇编时的类型错误,但在填写汇编者之前,将寻求现有的含蓄的转换,以便解决问题。在特定情况下将使用的具体默示转换在汇编时间时即为人所知。

不用说,时间错误是不可取的,因此,你可以在多大程度上以e-safe的方式(不使用asInstanceof)具体指明事项,越好! 如果你使用<代码>asInstanceOf发现,你或许应当使用match。

Answer 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:Sting)不汇编,表明说明说明的类型不成文。相比之下,汇编者高兴的前一行,但你例外,因此发现错误的类型。

如果你增加一种方法,你就会有一个无法解决的模棱两可。

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

在这种情况下,第一次和第三次援引oo将不汇编,因为汇编者无法决定你是否希望用单一单一 single来指 f。任何方面,或与两点相比,似乎都同样好 =>你必须使用一种描述来帮助汇编者。

。 Scala的描述的目的是什么?

Answer 3

http://www.ohchr.org。详见第15章——案件类别和模拟。

基本而言,第二种形式可用作“Typed patterns, 提供isInstanceOf和InasstanceOf功能。比较

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

页: 1

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

作者们坚持认为,“is Instance*” 做事的手法是故意使你屈服于形式上。

我不敢确定哪一种模式在不经过测试的情况下对一种简单类型进行更有效的处理。

Answer 4

差异的例子有:

Type cast (asInstanceOf) is a run-time operation with potentially run-time exception.
Ascription is basically just an up-cast performed at compile-time.

例:

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)

友情链接