Scala Constructores

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 declaraciones (es decir, instrucciones) que se ejecutan en el momento de la creación del Objeto . 
Scala admite dos tipos de constructores: 

Constructor principal

Cuando nuestro programa Scala contiene solo un constructor, ese constructor se conoce como 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...
}

Puntos importantes:  

• En la sintaxis anterior, el constructor principal y la clase comparten el mismo cuerpo , por lo que cualquier cosa definida en el cuerpo de la clase, excepto la declaración del método, es parte del constructor principal. 
  Ejemplo: 

// Scala program to illustrate the
// concept of primary constructor
 
// Creating a primary constructor
// with parameter-list
class GFG(Aname: String, Cname: String, Particle: Int)
{
    def display()
    {
        println("Author name: " + Aname);
        println("Chapter name: " + Cname);
        println("Total published articles:" + Particle);
    }
}
 
object Main
{
    def main(args: Array[String])
    {
         
        // Creating and initializing
        // object of GFG class
        var obj = new GFG("Ankita", "Constructors", 145);
        obj.display();
    }
}

Producción: 

Author name: Ankita
Chapter name: Constructors
Total published articles:145

• El constructor primario puede contener cero o más parámetros.
• Si no creamos un constructor en nuestro programa Scala, entonces el compilador creará automáticamente un constructor primario cuando creamos un objeto de su clase, este constructor se conoce como constructor primario predeterminado. No contiene ningún parámetro. 
  Ejemplo: 

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

Producción: 

Welcome to Geeksforgeeks

• Si los parámetros en la lista de parámetros del constructor se declaran usando var, entonces el valor de los campos puede cambiar. Y Scala también genera métodos getter y setter para ese campo. 
   
• Si los parámetros en la lista de parámetros del constructor se declaran usando val, entonces el valor de los campos no puede cambiar. Y Scala también genera un método getter para ese campo.
   
• Si los parámetros en la lista de parámetros del constructor se declaran sin usar val o var, entonces la visibilidad del campo es muy restringida. Y Scala no genera ningún método getter y setter para ese campo.
   
• Si los parámetros en la lista de parámetros del constructor se declaran usando private val o var, entonces 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.
• En Scala, podemos hacer que un constructor principal sea privado mediante el uso de una palabra clave privada entre el nombre de la clase y la lista de parámetros del constructor. 
  Sintaxis: 

// private constructor with two argument
class GFG private(name: String, class:Int){
// code..
}

// private constructor without argument
class GFG private{
// code...
}

• En Scala, podemos dar valores predeterminados en la declaración del constructor. 
  Ejemplo: 

// Scala program to illustrate the
// concept of primary constructor
 
// Creating primary constructor with default values
class GFG(val Aname: String = "Ankita",
          val Cname: String = "Constructors")
{
    def display()
    {
        println("Author name: " + Aname);
        println("Chapter name: " + Cname);
         
    }
}
 
object Main
{
    def main(args: Array[String])
    {
        // Creating object of GFG class
        var obj = new GFG();
        obj.display();
    }
}

Producción: 

Author name: Ankita
Chapter name: Constructors 

Constructor auxiliar

En un programa de Scala, los constructores que no sean el constructor principal se conocen como constructores auxiliares. se nos permite crear cualquier número de constructores auxiliares en nuestro programa, pero un programa contiene solo un constructor principal. 

Sintaxis:  

def this(......)

Puntos importantes:  

• En un solo programa, podemos crear múltiples constructores auxiliares, pero tienen diferentes firmas o listas de parámetros.
• Cada constructor auxiliar debe llamar a uno de los constructores definidos anteriormente.
• El constructor de invocación puede ser un constructor primario o auxiliar que viene textualmente antes del constructor de llamada.
• La primera instrucción del constructor auxiliar debe contener la llamada al constructor usando this .

Ejemplo:  

// Scala program to illustrate the
// concept of Auxiliary Constructor
 
// Primary constructor
class GFG( Aname: String, Cname: String)
{
    var no: Int = 0;;
    def display()
    {
        println("Author name: " + Aname);
        println("Chapter name: " + Cname);
        println("Total number of articles: " + no);
         
    }
     
    // Auxiliary Constructor
    def this(Aname: String, Cname: String, no:Int)
    {
         
        // Invoking primary constructor
        this(Aname, Cname)
        this.no=no
    }
}
 
object Main
{
    def main(args: Array[String])
    {
         
        // Creating object of GFG class
        var obj = new GFG("Anya", "Constructor", 34);
        obj.display();
    }
}

Producción: 

Author name: Anya
Chapter name: Constructor
Total number of articles: 34