En Scala, todas clases tienen un constructor primario. Y se debe tener en cuenta los siguientes puntos:
1. El constructor principar se representa como los parámetros que van luego del nombre de la clase :
class Person(val name: String, val age: Int) {
// Parameters of primary constructor in (…)
…
}
Los parámetros del primer constructor son campos que son inicializados en el constructor. En el ejemplo nombre y edad son campos de la persona. El constructor siempre se debe llamar (al menos) con los dos parámetros, esto es equivalente en Java a :
public class Person { // This is Java
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String name() { return this.name; }
public int age() { return this.age; }
…
}
El constructor primario ejecuta todas las sentencias en la definición de clase. Por ejemplo:
class Person(val name: String, val age: Int) {
println("Just constructed another person")
def description = name + " is " + age + " years old"
}
El método println se va a ejecutar cuando el objeto se cree. Esto es útil para cuando se necesita inicializar un campo. Por ejemplo:
class MyProg {
private val props = new Properties
props.load(new FileReader("myprog.properties"))
// The statement above is a part of the primary constructor
...
}
Podemos eliminar constructores auxiliares usando parámetros por defecto:
class Person(val name: String = "", val age: Int = 0)
El constructor primario puede recibir variables mutables, inmutables, privadas, publicas …
class Person(val name: String, private var age: Int)
Esto es como declarar los campos de la siguiente manera:
val name: String
private var age: Int
Los parámetros del constructor también pueden ser parámetros de métodos regulares, sin val o var. La forma en que se procesan estos parámetros depende de su uso dentro de la clase.
Si se utiliza un parámetro sin val o var dentro de al menos un método, se convierte en un campo. Por ejemplo:
class Person(name: String, age: Int) {
def description = name + " is " + age + " years old"
}
Como podemos ver se declara e inicializa los campos inmutables nombre y edad que son privados en el objeto. Esto es equivalente a private[this]
De lo contrario, el parámetro no se guarda como un campo. Es sólo un parámetro regular al que se puede acceder en el código del constructor principal. (Estrictamente hablando, esto es una optimización específica de la implementación.)
Tengamos en cuenta a la hora de definir los parámetros que :
- sin modificador : Va ser un campo privado si se utiliza en un metodo, de lo contrarío no se va guardar, es decir va vivir solo en el contructor de la clase. Ejemplo: name: String
- con modificador private: Va ser privado y se van a generar getters y setters privados
- con val o var: campos privados y getters y setters publicos
- con @BeanProperty y val o var: campo privado y getters y setters públicos, y también con forma que entienda java.
