Escala | Constructor primario

Los constructores se utilizan para inicializar el estado del objeto. Al igual que los métodos, un constructor también contiene una colección de sentencias (es decir, instrucciones). Las sentencias se ejecutan en el momento de la creación del objeto. Cuando nuestro programa Scala contiene solo un constructor, ese constructor se llama constructor primario . 

El constructor primario y la clase comparten el mismo cuerpo, lo que significa que no necesitamos crear un constructor explícitamente.

Sintaxis: 

class class_name(Parameter_list) {
// Statements...
}

Algunos puntos importantes sobre el constructor primario en Scala:  

• El constructor primario puede tener cero o más parámetros.
• Los parámetros de la lista de parámetros se declaran usando var dentro del constructor, entonces el valor podría cambiar. Scala también genera métodos getter y setter para ese campo.
• Los parámetros de la lista de parámetros se declaran usando val dentro del constructor, entonces el valor no puede cambiar Y Scala también genera solo un método getter para ese campo.
• Los parámetros de la lista de parámetros se declaran sin usar val o var en el constructor, por lo que la visibilidad del campo es muy compacta y Scala no genera ningún método getter y setter para ese campo.
• Los parámetros de la lista de parámetros se declaran utilizando private val o var en el constructor, lo que evita que se generen métodos getter y setter para ese campo. Por lo tanto, los miembros de esa clase pueden acceder a estos campos.
• En Scala, solo un constructor principal puede invocar un constructor de superclase.

Vamos a entenderlo mejor con algunos ejemplos.

Ejemplo #1: Un constructor primario con lista de parámetros  

// Scala program to illustrate the
// concept of primary constructor
 
// Creating a primary constructor
// with parameter-list
class GFG(Lname: String, Tname: String, article: Int)
{
    def show()
    {
        println("Language name: " + Lname);
        println("Topic name: " + Tname);
        println("Total published articles:" + article);
    }
}
 
// Creating object
object Main
{
    // Main method
    def main(args: Array[String])
    {
         
        // Creating and initializing
        // object of GFG class
        var obj = new GFG("Scala", "Constructors", 14);
        obj.show();
    }
}

Producción: 

Language name: Scala
Topic name: Constructors
Total published articles:14

En el ejemplo anterior, Lname, Tname y article son el parámetro del constructor principal y display es la función para imprimir valores. 
  
Ejemplo #2: Un constructor primario con lista de parámetros.

// Scala program to illustrate the
// concept of default primary constructor
 
class GFG
{
    def show()
    {
        println("Welcome to Geeksforgeeks");
    }
}
 
// Creating object
object Main
{
    // Main method
    def main(args: Array[String])
    {
         
        // Creating object of GFG class
        var obj = new GFG();
        obj.show();
    }
}

Producción: 

Welcome to Geeksforgeeks

En el ejemplo anterior, podemos ver que el compilador creará automáticamente un constructor primario cuando creamos un objeto de nuestra clase, este constructor se conoce como constructor primario predeterminado. 
  
Ejemplo #3: constructor principal con valores predeterminados

// Scala program to illustrate the
// concept of primary constructor
 
// Creating primary constructor with default values
class GFG(val Lname: String = "Scala",
        val Tname: String = "Constructors")
{
    def show()
    {
        println("Language name: " + Lname);
        println("Topic name: " + Tname);
         
    }
}
 
// Creating object
object Main
{
    // Main method
    def main(args: Array[String])
    {
        // Creating object of GFG class
        var obj = new GFG();
        obj.show();
    }
}

Producción: 
 

Language name: Scala
Topic name: Constructors

Ejemplo n.º 4: constructor principal privado mediante una palabra clave privada. 

// Scala program to illustrate the
// concept of primary constructor
// by using private keyword
class GFG private
{
    // Define method
    override def toString = "Welcome to GeeksForGeeks."
}
 
// Creating object of class GFG
object GFG
{
    // Creating object   
    val gfg = new GFG
    def getObject = gfg
}
 
object SingletonTest extends App
{
 
  // this won't compile
  // val gfg = new GFG
  // this works
  val gfg = GFG.getObject
  println(gfg)
}

Producción: 

Welcome to GeeksForGeeks.

Como podemos ver en el ejemplo anterior, la palabra clave privada se usa entre el nombre de la clase y la lista de parámetros del constructor. val gfg = new GFG (esta línea de código) ni siquiera se compilará porque el constructor principal es privado.