Enstringmiento de constructores en Java con ejemplos

El enstringmiento de constructores es el proceso de llamar a un constructor desde otro constructor con respecto al objeto actual. 

Uno de los usos principales del enstringmiento de constructores es evitar códigos duplicados al tener múltiples constructores (mediante la sobrecarga de constructores) y hacer que el código sea más legible.

Prerequisite - Constructors in Java 

El enstringmiento de constructores se puede hacer de dos maneras: 
 

• Dentro de la misma clase : se puede hacer usando la palabra clave this() para constructores en la misma clase
• Desde la clase base: usando la palabra clave super() para llamar al constructor desde la clase base.

El enstringmiento de constructores ocurre a través de la herencia . La tarea del constructor de una subclase es llamar primero al constructor de la superclase. Esto asegura que la creación del objeto de la subclase comience con la inicialización de los miembros de datos de la superclase. Podría haber cualquier número de clases en la string de herencia. Cada constructor llama a la string hasta que se alcanza la clase en la parte superior.

¿Por qué necesitamos el enstringmiento de constructores? 

Este proceso se usa cuando queremos realizar múltiples tareas en un solo constructor en lugar de crear un código para cada tarea en un solo constructor. Creamos un constructor separado para cada tarea y hacemos su string, lo que hace que el programa sea más legible. 
 

Enstringmiento de constructores dentro de la misma clase usando la palabra clave this():

// Java program to illustrate Constructor Chaining
// within same class Using this() keyword
class Temp
{
    // default constructor 1
    // default constructor will call another constructor
    // using this keyword from same class
    Temp()
    {
        // calls constructor 2
        this(5);
        System.out.println("The Default constructor");
    }
 
    // parameterized constructor 2
    Temp(int x)
    {
        // calls constructor 3
        this(5, 15);
        System.out.println(x);
    }
 
    // parameterized constructor 3
    Temp(int x, int y)
    {
        System.out.println(x * y);
    }
 
    public static void main(String args[])
    {
        // invokes default constructor first
        new Temp();
    }
}

Producción:  

75
5
The Default constructor

Reglas del enstringmiento de constructores: 

1. La expresión this() siempre debe ser la primera línea del constructor.
2. Debería haber al menos un constructor sin la palabra clave this() (constructor 3 en el ejemplo anterior).
3. El enstringmiento de constructores se puede lograr en cualquier orden.
    

¿Qué pasa si cambiamos el orden de los constructores?
Nada, el enstringmiento de constructores se puede lograr en cualquier orden

// Java program to illustrate Constructor Chaining
// within same class Using this() keyword
// and changing order of constructors
class Temp
{
    // default constructor 1
    Temp()
    {
        System.out.println("default");
    }
 
    // parameterized constructor 2
    Temp(int x)
    {
        // invokes default constructor
        this();
        System.out.println(x);
    }
 
    // parameterized constructor 3
    Temp(int x, int y)
    {
        // invokes parameterized constructor 2
        this(5);
        System.out.println(x * y);
    }
 
    public static void main(String args[])
    {
        // invokes parameterized constructor 3
        new Temp(8, 10);
    }
}

Producción: 

default
5
80

NOTA: En el ejemplo 1, el constructor predeterminado se invoca al final, pero en el ejemplo 2, el constructor predeterminado se invoca al principio. Por lo tanto, el orden en el enstringmiento de constructores no es importante. 
 

Enstringmiento del constructor a otra clase usando la palabra clave super():

// Java program to illustrate Constructor Chaining to
// other class using super() keyword
class Base
{
    String name;
 
    // constructor 1
    Base()
    {
        this("");
        System.out.println("No-argument constructor of" +
                                           " base class");
    }
 
    // constructor 2
    Base(String name)
    {
        this.name = name;
        System.out.println("Calling parameterized constructor"
                                              + " of base");
    }
}
 
class Derived extends Base
{
    // constructor 3
    Derived()
    {
        System.out.println("No-argument constructor " +
                           "of derived");
    }
 
    // parameterized constructor 4
    Derived(String name)
    {
        // invokes base class constructor 2
        super(name);
        System.out.println("Calling parameterized " +
                           "constructor of derived");
    }
 
    public static void main(String args[])
    {
        // calls parameterized constructor 4
        Derived obj = new Derived("test");
 
        // Calls No-argument constructor
        // Derived obj = new Derived();
    }
}

Producción: 

Calling parameterized constructor of base
Calling parameterized constructor of derived

Nota: similar al enstringmiento de constructores en la misma clase, super() debe ser la primera línea del constructor, ya que el constructor de la superclase se invoca antes que el constructor de la subclase.
Método alternativo: usando el bloque Init : 
Cuando queremos que ciertos recursos comunes sean ejecutados con cada constructor, podemos poner el código en el bloque init . El bloque de inicio siempre se ejecuta antes que cualquier constructor, cada vez que se usa un constructor para crear un nuevo objeto.
Ejemplo 1:

class Temp
{
    // block to be executed before any constructor.
    {
        System.out.println("init block");
    }
 
    // no-arg constructor
    Temp()
    {
        System.out.println("default");
    }
 
    // constructor with one argument.
    Temp(int x)
    {
        System.out.println(x);
    }
 
    public static void main(String[] args)
    {
        // Object creation by calling no-argument
        // constructor.
        new Temp();
 
        // Object creation by calling parameterized
        // constructor with one parameter.
        new Temp(10);
    }
}

Producción: 
 

init block
default
init block
10

NOTA: Si hay más de un bloque, se ejecutan en el orden en que están definidos dentro de la misma clase. Ver el ej. 
Ejemplo :
 

class Temp
{
    // block to be executed first
    {
        System.out.println("init");
    }
    Temp()
    {
        System.out.println("default");
    }
    Temp(int x)
    {
        System.out.println(x);
    }
 
    // block to be executed after the first block
    // which has been defined above.
    {
        System.out.println("second");
    }
    public static void main(String args[])
    {
        new Temp();
        new Temp(10);
    }
}

Producción :  

init
second
default
init
second
10

Este artículo es una contribución de Apoorva singh . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.