Saltar al contenido

Qué y ejemplos de programas

¿Qué es un constructor en Java?

CONSTRUCCIÓN es un método especial que se utiliza para iniciar un objeto recién creado y se proporciona inmediatamente después de que la memoria se asigna al objeto. Se puede utilizar para inicializar los objetos a los valores deseados o valores predeterminados cuando se han creado objetos. No es obligatorio que el codificador escriba un constructor para una clase.

Si no se proporciona un constructor definido por el usuario para una clase, el compilador inicia las variables miembro con sus valores predeterminados.

  • los tipos de datos numéricos se establecen en 0
  • los tipos de datos char se establecen mediante un carácter nulo (‘ 0’)
  • se decide anular las variables de referencia

En este tutorial, aprenderá:

Reglas para crear Java Builder

  1. Es el mismo nombre como la clase
  2. Ni siquiera debería devolver valor vacío

Ejemplo 1: Cree su primer constructor en Java

Paso 1) Escriba el siguiente programa de construcción en el editor de Java.

class Demo{
      int  value1;
      int  value2;
      Demo(){
         value1 = 10;
         value2 = 20;
         System.out.println("Inside Constructor");
     }
 
     public void display(){
        System.out.println("Value1 === "+value1);
        System.out.println("Value2 === "+value2);
    }
 
   public static void main(String args[]){
       Demo d1 = new Demo();
      d1.display();
  }
}

Paso 2) Guarde, ejecute y compile el programa de construcción en Java y vea el resultado.

Producción:


Inside Constructor
Value1 === 10
Value2 === 20

Generador de sobrecargas en Java

La sobrecarga de Java Constructor es una técnica en la que la clase de cualquier número de constructores puede diferir en la lista de parámetros. El compilador diferencia estos constructores teniendo en cuenta el número de parámetros de la lista y su tipo.

Ejemplos de constructores válidos para la cuenta de clase

Account(int a);
Account (int a,int b);
Account (String a,int b);

Ejemplo 2: Comprender la sobrecarga de constructores en Java

Paso 1) Escriba el código en el editor.

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

Paso 2) Guarde, compile y ejecute el código.

Paso 3) Error =?. Intente depurar el error antes de continuar con el siguiente paso de la sobrecarga del constructor de Java

Paso 4) Cada clase en Java tiene un generador predeterminado. Sobrecarga predeterminada del constructor Java para Demostración en el aula es Exposición (). En caso de que no proporcione este constructor, el compilador lo crea por usted e inicia las variables con los valores predeterminados. Puede optar por anular este constructor predeterminado e iniciar variables en los valores que necesita, como se muestra en el Ejemplo 1.

Pero si especifica un constructor de parámetros como Demo (int a) y desea utilizar el constructor Java Demo () predeterminado, es obligatorio que lo especifique.

Es decir, en caso de que se infrinja su generador de sobrecarga en Java y desee utilizar el generador de Java predeterminado, es necesario especificarlo.

Paso 5) Descomente en línea # 4-8. Guarde, compile y ejecute el código.

Constructor de cadenas

Considere una situación en la que un niño de primaria se estira. Siempre que se crea un objeto de la clase secundaria, primero se invoca al constructor de la clase principal. Se llama Constructor de cadenas.

Ejemplo 3: Entender a un constructor de cadenas

Paso 1) Copie el siguiente código en el editor.

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

Paso 2) Ejecute el código. Debido al encadenamiento del constructor, cuando se crea el objeto de clase hijo DemoChild, primero se invoca el constructor Demo () de la clase padre y luego se crea el constructor hijo DemoChild (). Rendimiento esperado

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

Paso 3) Puede observar al constructor de la clase principal de demostración violada. ¿Qué sucede si desea llamar al constructor Demo (int a) predeterminado en lugar del constructor Demo () predeterminado cuando se crea el objeto de su hijo?

En tales casos, puede utilizar la palabra clave “excelente” llamar a los infractores constructores de la clase padre.

Proporción: –

super();
--or--
super(parameter list);

Ejemplo: Si como tu constructor Pantalla (nombre de cadena, int a) tu específicas super (“Java”, 5) Si se usa, la palabra clave super debe estar en la primera línea de código en el constructor de clases secundarias.

Paso 4) Descomente en línea # 26 y ejecute el código. Mira la salida.

Producción:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *