Java – constructor parametrizado con ejemplo

Un constructor con argumentos (o puede decir parámetros) se conoce como constructor parametrizado. Como comentamos en el tutorial de Java Constructor, un constructor es un tipo especial de método que inicializa el objeto recién creado.

Ejemplo de constructor parametrizado

Podemos tener cualquier número de constructores parametrizados en nuestra clase. En este ejemplo, he implementado cuatro constructores: uno es el constructor predeterminado y otros tres están parametrizados.

Durante la creación del objeto, los parámetros que pasamos determinan qué constructor debe invocarse para la inicialización del objeto. Por ejemplo, cuando creamos el objeto así MyClass obj = new MyClass(123, "Hi"); luego, la nueva palabra clave llama al constructor parametrizado con los parámetros int y string (MyClass (int, String)) después de que se crea el objeto.

class Example{
   //Default constructor
   Example(){
      System.out.println("Default constructor");
   }
   /* Parameterized constructor with 
    * two integer arguments
    */
   Example(int i, int j){
      System.out.println("constructor with Two parameters");
   }
   /* Parameterized constructor with 
    * three integer arguments
    */
   Example(int i, int j, int k){
      System.out.println("constructor with Three parameters");	      
   }
	   
   /* Parameterized constructor with 
    * two arguments, int and String
    */
   Example(int i, String name){
      System.out.println("constructor with int and String param");
   }
   public static void main(String args[]){
      //This will invoke default constructor
      Example obj = new Example();

      /* This will invoke the constructor 
       * with two int parameters
       */
      Example obj2 = new Example(12, 12);

      /* This will invoke the constructor 
       * with three int parameters
       */
      Example obj3 = new Example(1, 2, 13);
	
      /* This will invoke the constructor 
       * with int and String parameters
       */
      Example obj4 = new Example(1,"BeginnersBook");
   }
}

Producción:

Default constructor
constructor with Two parameters
constructor with Three parameters
constructor with int and String param

Ejemplo 2: Constructor parametrizado – Un extraño error de compilación

Al discutir el constructor predeterminado, vimos que cuando no creamos un constructor predeterminado, el compilador de Java inserta el constructor predeterminado en el código en nuestro nombre. Sin embargo, este no es siempre el caso. Mira el ejemplo de abajo:

class Example{
   Example(int i, int j){
      System.out.print("parameterized constructor");
   }
   Example(int i, int j, int k){
      System.out.print("parameterized constructor");
   }
   public static void main(String args[]){
      Example obj = new Example();
   }
}

Producción:

Exception in thread "main" java.lang.Error: Unresolved compilation 
problem: The constructor Example() is undefined

El programa genera un error de compilación porque la declaración Example obj = new Example(); está intentando invocar el constructor sin argumentos (constructor sin argumentos) que no tenemos en nuestro programa. No obtiene este error si elimina los constructores parametrizados del código anterior. Esto se debe a que si no tiene ningún constructor en su clase, el compilador de Java inserta el constructor predeterminado en su código en su nombre; sin embargo, si implementa un constructor, ya no recibirá un constructor predeterminado.