Un resumen de Scala for the Impatient, parte 13

Campos privados 

En scala (como en java o c++) los métodos pueden acceder a campos privados para todos los objetos de la misma clase:

class Counter {
      private var value = 0
      def increment() { value += 1 }
      def isLess(other : Counter) = value < other.value
      //Puede acceder a metodo privado de un objeto de su misma clase.
}

La expresión other.value es valida porque es el mismo tipo que la clase que contiene le método isLess

Scala permite mayor cantidad de restricciones, con private[this] con este modificador el campo es privado en serio, es decir no es publico para otras instancia de la misma clase.

private[this] var value = 0 // no permite acceso a otra instancia del mismo tipo.

Bean Properties

Como se vio en las secciones anteriores, Scala proporciona métodos getter y setter para los campos que se definen. Sin embargo, los nombres de estos métodos no son lo que las herramientas Java esperan. La especificación JavaBeans (www.oracle.com/technetwork/java/javase/tech/index-jsp-138795.html) define una propiedad Java como un par de métodos getFoo / setFoo (o simplemente un método getFoo para una propiedad de sólo lectura ).

Muchas herramientas Java se basan en esta convención de nomenclatura.

Cuando anote un campo Scala con @BeanProperty, estos métodos son generada automáticamente. Por ejemplo:

import scala.reflect.BeanProperty

class Person {
       @BeanProperty var name: String = _
}

esto genera 4 metodos:
1. name: String
2. name_=(newValue: String): Unit
3. getName(): String
4. setName(newValue: String): Unit

Constructores auxiliares.

Como java y c++, scala permite que los objetos tengan más de un constructor. Sin embargo, una clase Scala tiene un constructor que es más importante que todos los demás, llamado el constructor primario. Además, una clase puede tener cualquier número de constructores auxiliares.

Los constructores auxiliares son muy similares a los constructores en Java o C ++, con sólo dos diferencias:
A los constructores auxiliares se les llama this. (En Java o C ++, los constructores tienen el mismo nombre que la clase, lo cual no es tan conveniente si cambia el nombre de la clase.)
Cada constructor auxiliar debe comenzar con una llamada a un constructor auxiliar previamente definido o al constructor primario.

Aquí hay una clase con dos constructores auxiliares:

class Person {
   private var name = ""
   private var age = 0
 
   def this(name: String) { // Un constructor auxiliar
       this() // Llama al constructor principal
       this.name = name
   }

   def this(name: String, age: Int) { // Otro constructor auxiliar
       this(name) // Llama al otro constructor
       this.age = age
   }
}

Como se puede ver esta clase tiene 3 constructor. El primer constructor es el contructor principal y no espera parametros y luego tenemos 2 constructores auxiliares. De esta forma podemos instanciar esta clase así:

val p1 = new Person // Primary constructor
val p2 = new Person("Fred") // First auxiliary constructor
val p3 = new Person("Fred", 42) // Second auxiliary constructor