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
