Constructores de Java o constructores en Java es una terminología que se utiliza para construir algo en nuestros programas. Un constructor en Java es un método especial que se utiliza para inicializar objetos. Se llama al constructor cuando se crea un objeto de una clase. Se puede utilizar para establecer valores iniciales para los atributos del objeto.

¿Qué son los constructores en Java?

En Java, un constructor es un bloque de códigos similar al método. Se llama cuando se crea una instancia de la clase. En el momento de llamar al constructor, se asigna memoria para el objeto en la memoria. Es un tipo especial de método que se utiliza para inicializar el objeto. Cada vez que se crea un objeto usando la palabra clave new(), se llama al menos a un constructor.

Ejemplo de constructor Java

A continuación se muestra la implementación de los constructores de Java:

// Java Program to demonstrate // Constructor import java.io.*; // Driver Class class Geeks {    // Constructor  Geeks()  {  super();  System.out.println('Constructor Called');  }  // main function  public static void main(String[] args)  {  Geeks geek = new Geeks();  } }>

Constructor Called>

Nota: No es necesario escribir un constructor para una clase. Esto se debe a que el compilador de Java crea un constructor predeterminado (constructor sin argumentos) si su clase no tiene ninguno.

¿En qué se diferencian los constructores de Java de los métodos de Java?

• Los constructores deben tener el mismo nombre que la clase dentro de la cual está definido; no es necesario para el método en Java.
• Los constructores no devuelven ningún tipo mientras que los métodos tienen el tipo de retorno o vacío si no devuelve ningún valor.
• Los constructores se llaman solo una vez en el momento de la creación del objeto, mientras que los métodos se pueden llamar cualquier número de veces.

Ahora veamos la sintaxis del constructor que se invoca en el momento de la creación del objeto o instancia.

quien inventó la escuela

class Geek {   .......  // A Constructor  Geek() {  }  ....... } // We can create an object of the above class // using the below statement. This statement // calls above constructor. Geek obj = new Geek();>

La primera línea de un constructor es una llamada a super() o this() (una llamada a un constructor de una superclase o un constructor sobrecargado), si no escribes la llamada a super en tu constructor, El compilador le proporcionará una llamada sin argumentos a super en la primera línea de su código, se debe llamar al superconstructor para crear un objeto:

Si cree que su clase no es una subclase, en realidad lo es, cada clase en Java es la subclase de una clase. objeto incluso si no dices extiende objeto en tu definición de clase.

agregando cadenas java

Necesidad de constructores en Java

Piense en una caja. Si hablamos de una clase de caja, entonces tendrá algunas variables de clase (por ejemplo, largo, ancho y alto). Pero cuando se trata de crear su objeto (es decir, Box ahora existirá en la memoria de la computadora), ¿puede haber una caja allí sin un valor definido para sus dimensiones? La respuesta es N. oh .
Por lo tanto, los constructores se utilizan para asignar valores a las variables de clase en el momento de la creación del objeto, ya sea explícitamente por el programador o por el propio Java (constructor predeterminado).

¿Cuándo se llama al Constructor Java?

Cada vez que se crea un objeto usando un nuevo() palabra clave, se invoca al menos un constructor (podría ser el constructor predeterminado) para asignar valores iniciales al miembros de datos de la misma clase. Las reglas para escribir constructores son las siguientes:

• Los constructores de una clase deben tener el mismo nombre que el nombre de la clase en la que reside.
• Un constructor en Java no puede ser abstracto, final, estático o sincronizado.
• Los modificadores de acceso se pueden usar en la declaración del constructor para controlar su acceso, es decir, qué otra clase puede llamar al constructor.

Hasta ahora, hemos aprendido que los constructores se utilizan para inicializar el estado del objeto. Como 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.

Tipos de constructores en Java

Ahora es el momento correcto para discutir los tipos de constructores, por lo que principalmente hay tres tipos de constructores en Java que se mencionan a continuación:

• Constructor predeterminado
• Constructor parametrizado
• Constructor de copias

1. Constructor predeterminado en Java

Un constructor que no tiene parámetros se conoce como constructor predeterminado. Un constructor predeterminado es invisible. Y si escribimos un constructor sin argumentos, el compilador no crea un constructor predeterminado. Está sacado. Se está sobrecargando y se le llama constructor parametrizado. El constructor predeterminado cambió al constructor parametrizado. Pero el constructor parametrizado no puede cambiar el constructor predeterminado. El constructor predeterminado puede ser implícito o explícito. Si no lo definimos explícitamente, obtenemos un constructor predeterminado implícito. Si escribimos manualmente un constructor, se anula el implícito.

Ejemplo:

lista de matrices en java

// Java Program to demonstrate // Default Constructor import java.io.*; // Driver class class GFG {  // Default Constructor  GFG() { System.out.println('Default constructor'); }  // Driver function  public static void main(String[] args)  {  GFG hello = new GFG();  } }>

Default constructor>

Nota: El constructor predeterminado proporciona los valores predeterminados al objeto como 0, nulo, etc., según el tipo.

2. Constructor parametrizado en Java

Un constructor que tiene parámetros se conoce como constructor parametrizado. Si queremos inicializar campos de la clase con nuestros propios valores, entonces usamos un constructor parametrizado.

Ejemplo:

dependencia parcial

// Java Program for Parameterized Constructor import java.io.*; class Geek {  // data members of the class.  String name;  int id;  Geek(String name, int id)  {  this.name = name;  this.id = id;  } } class GFG {  public static void main(String[] args)  {  // This would invoke the parameterized constructor.  Geek geek1 = new Geek('Avinash', 68);  System.out.println('GeekName :' + geek1.name  + ' and GeekId :' + geek1.id);  } }>

GeekName :Avinash and GeekId :68>

Recuerde: ¿el constructor devuelve algún valor?

No hay declaraciones de valor de retorno en el constructor, pero el constructor devuelve la instancia de clase actual. Podemos escribir 'retorno' dentro de un constructor.

Ahora el tema más importante que entra en juego es la fuerte incorporación de OOPS con constructores conocida como sobrecarga de constructores. Al igual que los métodos, podemos sobrecargar los constructores para crear objetos de diferentes maneras. El compilador diferencia los constructores según la cantidad de parámetros, los tipos de parámetros y el orden de los parámetros.

Ejemplo:

// Java Program to illustrate constructor overloading // using same task (addition operation ) for different // types of arguments. import java.io.*; class Geek {  // constructor with one argument  Geek(String name)  {  System.out.println('Constructor with one '  + 'argument - String : ' + name);  }  // constructor with two arguments  Geek(String name, int age)  {  System.out.println(  'Constructor with two arguments : '  + ' String and Integer : ' + name + ' ' + age);  }  // Constructor with one argument but with different  // type than previous..  Geek(long id)  {  System.out.println(  'Constructor with one argument : '  + 'Long : ' + id);  } } class GFG {  public static void main(String[] args)  {  // Creating the objects of the class named 'Geek'  // by passing different arguments  // Invoke the constructor with one argument of  // type 'String'.  Geek geek2 = new Geek('Shikhar');  // Invoke the constructor with two arguments  Geek geek3 = new Geek('Dharmesh', 26);  // Invoke the constructor with one argument of  // type 'Long'.  Geek geek4 = new Geek(325614567);  } }>

Constructor with one argument - String : Shikhar Constructor with two arguments : String and Integer : Dharmesh 26 Constructor with one argument : Long : 325614567>

3. Copiar constructor en Java

A diferencia de otros constructores, el constructor de copia se pasa con otro objeto que copia los datos disponibles del objeto pasado al objeto recién creado.

Nota: En Java, no existe un constructor de copia incorporado disponible como en otros lenguajes de programación como C++; en cambio, podemos crear nuestro propio constructor de copia pasando el objeto de la misma clase a la otra instancia (objeto) de la clase.

¿Qué es Mac OS?

Ejemplo:

// Java Program for Copy Constructor import java.io.*; class Geek {  // data members of the class.  String name;  int id;  // Parameterized Constructor  Geek(String name, int id)  {  this.name = name;  this.id = id;  }  // Copy Constructor  Geek(Geek obj2)  {  this.name = obj2.name;  this.id = obj2.id;  } } class GFG {  public static void main(String[] args)  {  // This would invoke the parameterized constructor.  System.out.println('First Object');  Geek geek1 = new Geek('Avinash', 68);  System.out.println('GeekName :' + geek1.name  + ' and GeekId :' + geek1.id);  System.out.println();  // This would invoke the copy constructor.  Geek geek2 = new Geek(geek1);  System.out.println(  'Copy Constructor used Second Object');  System.out.println('GeekName :' + geek2.name  + ' and GeekId :' + geek2.id);  } }>

First Object GeekName :Avinash and GeekId :68 Copy Constructor used Second Object GeekName :Avinash and GeekId :68>

Para conocer en profundidad a los constructores existen dos conceptos muy utilizados que se enumeran a continuación:

• Encadenamiento de constructores
• Constructor de copias

Preguntas frecuentes sobre constructores de Java

1. ¿Qué es un constructor en Java?

Un constructor en Java es un método especial Se utiliza para inicializar objetos.

2. ¿Puede un constructor de Java ser privado?

Sí, un constructor puede declararse privado. Se utiliza un constructor privado para restringir la creación de objetos.