Sobrecarga de constructores en Java

Requisito previo: constructor , sobrecarga en Java

Además de sobrecargar métodos, también podemos sobrecargar constructores en java. El constructor sobrecargado se llama en función de los parámetros especificados cuando se ejecuta new .

¿Cuándo necesitamos la sobrecarga de constructores?

A veces existe la necesidad de inicializar un objeto de diferentes maneras. Esto se puede hacer mediante la sobrecarga del constructor. Por ejemplo, la clase Thread tiene 8 tipos de constructores. Si no queremos especificar nada sobre un subproceso, simplemente podemos usar el constructor predeterminado de la clase Subproceso; sin embargo, si necesitamos especificar el nombre del subproceso, podemos llamar al constructor parametrizado de la clase Subproceso con argumentos de string como este:

Thread t= new Thread (" MyThread "); 

Tomemos un ejemplo para comprender la necesidad de sobrecarga del constructor. Considere la siguiente implementación de una clase Box con un solo constructor que toma tres argumentos.

// An example class to understand need of
// constructor overloading.
class Box
{
    double width, height,depth;

    // constructor used when all dimensions
    // specified
    Box(double w, double h, double d)
    {
        width = w;
        height = h;
        depth = d;
    }

    // compute and return volume
    double volume()
    {
        return width * height * depth;
    }
}

Como podemos ver, el constructor Box() requiere tres parámetros. Esto significa que todas las declaraciones de objetos Box deben pasar tres argumentos al constructor Box(). Por ejemplo, la siguiente declaración no es válida actualmente:

Box ob = new Box();

Dado que Box() requiere tres argumentos, es un error llamarlo sin ellos. Supongamos que simplemente queremos un objeto de caja sin dimensión inicial, o queremos inicializar un cubo especificando solo un valor que se usaría para las tres dimensiones. A partir de la implementación anterior de la clase Box, estas opciones no están disponibles para nosotros.

Este tipo de problemas de diferentes formas de inicializar un objeto se pueden resolver mediante la sobrecarga del constructor. A continuación se muestra la versión mejorada de la clase Box con sobrecarga del constructor.

// Java program to illustrate
// Constructor Overloading
class Box
{
    double width, height, depth;
  
    // constructor used when all dimensions
    // specified
    Box(double w, double h, double d)
    {
        width = w;
        height = h;
        depth = d;
    }
  
    // constructor used when no dimensions
    // specified
    Box()
    {
        width = height = depth = 0;
    }
  
    // constructor used when cube is created
    Box(double len)
    {
        width = height = depth = len;
    }
  
    // compute and return volume
    double volume()
    {
        return width * height * depth;
    }
}
  
// Driver code
public class Test
{
    public static void main(String args[])
    {
        // create boxes using the various
        // constructors
        Box mybox1 = new Box(10, 20, 15);
        Box mybox2 = new Box();
        Box mycube = new Box(7);
  
        double vol;
  
        // get volume of first box
        vol = mybox1.volume();
        System.out.println(" Volume of mybox1 is " + vol);
  
        // get volume of second box
        vol = mybox2.volume();
        System.out.println(" Volume of mybox2 is " + vol);
  
        // get volume of cube
        vol = mycube.volume();
        System.out.println(" Volume of mycube is " + vol);
    }
}

Producción:

Volume of mybox1 is 3000.0
Volume of mybox2 is 0.0
Volume of mycube is 343.0

Usando this() en la sobrecarga del constructor

Esta referencia() se puede usar durante la sobrecarga del constructor para llamar implícitamente al constructor predeterminado desde el constructor parametrizado. Tenga en cuenta que this() debe ser la primera declaración dentro de un constructor.

// Java program to illustrate role of this() in
// Constructor Overloading
class Box
{
    double width, height, depth;
    int boxNo;
  
    // constructor used when all dimensions and
    // boxNo specified
    Box(double w, double h, double d, int num)
    {
        width = w;
        height = h;
        depth = d;
        boxNo = num;
    }
  
    // constructor used when no dimensions specified
    Box()
    {
        // an empty box
        width = height = depth = 0;
    }
  
    // constructor used when only boxNo specified
    Box(int num)
    {
        // this() is used for calling the default
        // constructor from parameterized constructor
        this();
  
        boxNo = num;
    }
  
    public static void main(String[] args)
    {
        // create box using only boxNo
        Box box1 = new Box(1);
  
        // getting initial width of box1
        System.out.println(box1.width);
    }
}

Producción:

0.0

Como podemos ver en el programa anterior, llamamos al constructor Box(int ​​num) durante la creación del objeto usando solo el número de caja. Al usar esta declaración() dentro de él, el constructor predeterminado (Box()) se llama implícitamente desde él, lo que inicializará la dimensión de Box con 0.

Nota: la llamada del constructor debe ser la primera declaración en el cuerpo del constructor. Por ejemplo, el siguiente fragmento no es válido y arroja un error de tiempo de compilación.

Box(int num)
{
    boxNo = num;

    /* Constructor call must be the first
       statement in a constructor */
    this();  /*ERROR*/
}

Puntos importantes a tener en cuenta al realizar la sobrecarga de constructores:

• La llamada al constructor debe ser la primera declaración del constructor en Java.
• Si hemos definido un constructor parametrizado, el compilador no creará un constructor predeterminado. y viceversa, si no definimos ningún constructor, el compilador crea el constructor predeterminado (también conocido como constructor sin argumentos) de forma predeterminada durante la compilación
• La llamada al constructor recursivo no es válida en java.

Sobrecarga de constructores vs sobrecarga de métodos

Estrictamente hablando, la sobrecarga de constructores es algo similar a la sobrecarga de métodos. Si queremos tener diferentes formas de inicializar un objeto usando un número diferente de parámetros, entonces debemos sobrecargar el constructor como lo hacemos con la sobrecarga de métodos cuando queremos diferentes definiciones de un método basadas en diferentes parámetros.

Este artículo es una contribución de Gaurav Miglani . 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.