"nouveau" mot clé en Scala

Question

J'ai une question très simple: quand devrions-nous appliquer le nouveau mot clé lors de la création d'objets dans Scala? Est-ce lorsque nous essayons d'instancier uniquement des objets Java?

Answer 1

Utiliser l' new mot-clé si vous voulez faire référence à un class's propre constructeur:

class Foo { }

val f = new Foo

Omettre new si vous faites référence à la compagne de l'objet apply méthode:

class Foo { }
object Foo {
    def apply() = new Foo
}

// Both of these are legal
val f = Foo()
val f2 = new Foo

Si vous avez fait une classe de cas:

case class Foo()

Scala secrètement crée un compagnon objet pour vous, en le transformant en ceci:

class Foo { }
object Foo {
    def apply() = new Foo
}

De sorte que vous pouvez faire

f = Foo()

Enfin, gardez à l'esprit qu'il n'y a aucune règle qui dit que le compagnon apply la méthode doit être un proxy pour le constructeur:

class Foo { }
object Foo {
    def apply() = 7
}

// These do different things
> println(new Foo)
test@5c79cc94
> println(Foo())
7

Et, puisque vous avez mentionné des classes Java: oui-classes Java rarement compagnon d'objets avec un apply méthode, vous devez utiliser new et le réel constructeur de la classe.

Answer 2

Est-il lorsque nous essayons d'instancier des objets java uniquement?

Pas du tout. Il y a deux cas généraux lorsque vous omettre new en scala. Avec les objets singleton (qui sont souvent utilisés pour stocker des fonctions statiques et comme une sorte de tissus que vous avez peut-vu en java):

scala> object LonelyGuy { def mood = "sad" }
defined module LonelyGuy

scala> LonelyGuy
res0: LonelyGuy.type = LonelyGuy$@3449a8

scala> LonelyGuy.mood
res4: java.lang.String = sad

Avec une des classes de cas (en fait, en dessous il y a la classe + objet = compagnon motif, par exemple, avoir de la classe et de l'objet avec le même nom):

scala> case class Foo(bar: String) 
defined class Foo


scala> Foo("baz")
res2: Foo = Foo(baz)

Ainsi, lorsque vous travaillez avec un simple, les classes, les règles sont les mêmes qu'avec Java.

scala> class Foo(val bar: String) 
defined class Foo

scala> new Foo("baz")
res0: Foo = Foo@2ad6a0

// will be a error 
scala> Foo("baz")
<console>:8: error: not found: value Foo
       Foo("baz")

Bonus, il y a un anonyme classes scala, qui peut être construit comme ceci:

scala> new { val bar = "baz" }
res2: java.lang.Object{val bar: java.lang.String} = $anon$1@10ee5b8

scala> res2.bar
res3: java.lang.String = baz