Les parameters du constructeur de scala sont-ils définis par défaut sur private val?

J’ai essayé:

class Foo(bar: Int) 

contre:

 class Foo(private val bar: Int) 

et ils semblent se comporter de la même manière bien que je ne puisse trouver nulle part disant que (bar: Int) développe en (private val bar: Int) alors ma question est la suivante: sont-ils identiques / similaires?

Sur une note de côté, j’ai essayé d’utiliser -Xprint:typer sur ces morceaux de code et ils produisent le même code à l’exception d’une ligne supplémentaire dans la seconde. Comment lire cette ligne supplémentaire?

 .. class Foo extends scala.AnyRef {  private[this] val bar: Int = _; def (bar: Int): this.Foo = { Foo.super.(); () } } .. .. class Foo extends scala.AnyRef {  private[this] val bar: Int = _;    private def bar: Int = Foo.this.bar; def (bar: Int): this.Foo = { Foo.super.(); () } } .. 

bar: Int

C’est à peine un paramètre constructeur. Si cette variable n’est utilisée nulle part sauf le constructeur, elle rest là. Aucun champ n’est généré. Sinon, private val bar champ de bar de valeurs private val bar est créé et la valeur du paramètre de bar est affectée. Aucun getter n’est créé.

private val bar: Int

Une telle déclaration de paramètre créera private val bar champ de private val bar de valeur privé avec un getter privé. Ce comportement est le même que ci-dessus, peu importe si le paramètre a été utilisé à côté du constructeur (par exemple, dans toSsortingng() ou non).

val bar: Int

Comme ci-dessus, mais le getter de type Scala est public

bar: Int dans les classes de cas

Lorsque des classes de cas sont impliquées, chaque paramètre a par défaut un modificateur de valeur.

Dans le premier cas, bar est uniquement un paramètre constructeur. Comme le constructeur principal est le contenu de la classe elle-même, elle y est accessible, mais uniquement à partir de cette instance. Donc, c’est presque équivalent à:

 class Foo(private[this] val bar:Int) 

Par contre, dans la deuxième cas, la bar est un champ privé normal , elle est donc accessible à cette instance et aux autres instances de Foo . Par exemple, cela comstack bien:

 class Foo(private val bar: Int) { def otherBar(f: Foo) { println(f.bar) // access bar of another foo } } 

Et court:

 scala> val a = new Foo(1) a: Foo = Foo@7a99d0af scala> a.otherBar(new Foo(3)) 3 

Mais ce n’est pas le cas:

 class Foo(bar: Int) { def otherBar(f: Foo) { println(f.bar) // error! cannot access bar of another foo } }