Introducción a Constructor en Java
Los constructores en Java son tipos especiales de métodos que se utilizan para inicializar los objetos de la clase. Los constructores se llaman en el momento de la creación del objeto de la clase. Al igual que los métodos, aunque contienen un conjunto de líneas de código, son bastante diferentes de ellos. Los constructores tienen el mismo nombre que la clase Java pero no tiene ningún tipo de retorno. En Java, una nueva palabra clave () utilizada para crear un objeto y cada vez que se crea un nuevo objeto y se llama a un constructor. Se llama al constructor después de asignar la memoria al objeto. En el momento de la creación del objeto, los constructores se utilizan para inicializar los valores de las variables de clase a las predeterminadas o las deseadas.
Si el usuario no crea ningún constructor en el programa, Java crea un constructor predeterminado para él y asigna valores predeterminados a los diferentes objetos, como el valor numérico predeterminado es 0, para un carácter ('\ 0') y las variables de referencia como nulas . Al igual que los métodos, los constructores pueden sobrecargarse, es decir, una sola clase puede tener muchos constructores si todos tienen una firma única.
La sintaxis básica de Constructor en Java se da a continuación:
Sintaxis
public class Student() // name of the class
(
. . . .
. . . .
. . . .
Student() // this is Constructor with the same name of class
(
. . .
. . .
)
new Student(); // object creation and value initialization
)
En la sintaxis anterior, Student () es el nombre del constructor que es el mismo que el nombre de la clase y los objetos en Java se crean usando la palabra clave new.
¿Cómo funciona Constructor en Java?
Para comprender el funcionamiento de los constructores en Java, tomemos un ejemplo a continuación:
Código
public class Student()
(
int rollno;
String name;
Student(int rollno, String name)
(
this.rollno = rollno;
this.name = name;
)
public static void main(String() args)
(
Student st = new Student(12, 'Ananya');
System.out.println(“Student name = ”+ st.name + “Student rollno = ”+st.rollno);
)
)
Salida
En el ejemplo anterior, tenemos variables de instancia (variables de clase). Roll no y name and st Es el nombre del objeto creado de la clase Student. Cuando se crea el objeto st, invoca al constructor Estudiante e inicializa las variables de clase con el valor rollno como 12 y el nombre como 'Ananya'; de lo contrario, los valores predeterminados como 0 para rollno y nulo para el nombre se asignarán a las variables. Por lo tanto, después de asignar los valores e imprimirlos, el nombre del alumno se imprime como Ananya y Alumno rollno como 12.
Tipos de constructores en Java
Hay 2 tipos de constructores en Java basados en parámetros:
1. Constructor no parametrizado / sin argumentos
Cuando no pasamos argumentos en el constructor, ese constructor se conoce como un constructor sin parámetros o sin argumentos. Cuando el programador no define ningún constructor en el programa Java, el compilador de Java mismo agrega un constructor en él, conocido como constructor predeterminado que proporciona valores predeterminados al objeto como 0, nulo, etc. El constructor predeterminado no es un tipo especial de constructor pero cae en la categoría de constructor sin argumentos.
Ejemplo (Constructor predeterminado)
Código
public class Hello()
(
String name;
void display() //method to display name the value of variables
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Salida:
En el ejemplo anterior, este no es un constructor definido por el programador, por lo que el compilador tratará este programa como:
Código
public class Hello()
(
String name;
Hello() //default constructor created by compiler
(
name = null
)
void display()
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Ejemplo (constructor no parametrizado)
Código
public DemoProgram() // class
(
DemoProgram() // constructor with no arguments
(
System.out.println(“Hello this is just an example of no-arg constructor”);
)
public static void main(String() args)
(
new DermoProgram();
)
)
Salida:
Como en el ejemplo anterior, para el constructor DemoProgram () no se pasan argumentos, solo se imprime el mensaje y, por lo tanto, se conoce como constructor sin argumentos.
2. Constructor parametrizado
Los constructores parametrizados son aquellos constructores en los que pasamos los argumentos o parámetros. En este constructor, los valores se pasan en el momento de la creación del objeto.
Ejemplo (constructores parametrizados)
Código
public class Animal()
(
int legs;
String sound;
Animal(int legs, String sound) // parameterized constructor
(
this.legs = legs; // values with get initialize of what is passed while object crea-this.sound = sound; // tion, ie (4, “bow bow”)
)
void display() // method to display the values
(
System.out.println(“Legs are ”+legs+“Sound is ”+sound);
)
)
class AnimalPlanet()
(
Public static void main(String() args)
(
Animal an = new Animal(4, “bow bow”);
an.display();
)
)
Salida:
En el ejemplo anterior, el valor 4 se asigna a las patas y la cadena "arco arco" se asigna al sonido en el constructor Animal. Entonces, cuando se llama a la visualización del método, ambos valores se imprimen en la salida.
Puntos importantes para recordar
- Cada clase tiene un constructor, ya sea que el programador lo cree o no.
- El nombre del constructor debe ser el mismo que el nombre de la clase.
- El constructor no tiene ningún tipo de retorno, a diferencia de los métodos.
- this () y la palabra clave super () deben ser la primera instrucción en un constructor.
- Al igual que los métodos, los constructores pueden sobrecargarse.
- Los constructores no pueden ser anulados.
- Un constructor puede invocar a otro constructor de la misma clase usando la palabra clave this ().
- Los especificadores / modificadores de acceso se pueden aplicar antes del nombre del constructor para declarar su alcance en una clase.
- En Java, un constructor nunca puede ser estático, final, abstracto y sincronizado.
Conclusión
Los constructores juegan un papel importante cuando se trata de trabajar con el lenguaje de programación Java. Es necesario comprender los conceptos completos de Constructor, varios tipos de Constructores, Encadenamiento de constructores, la palabra clave super () utilizada para llamar al constructor principal para que funcione de acuerdo con el escenario específico. Aunque trabajar con constructores en Java es muy fácil, como trabajar con métodos, pero hay pocos puntos específicos de los constructores que se deben aprender a fondo.
Artículo recomendado
Esta es una guía para el constructor en java. Aquí discutimos cómo funciona el constructor en Java junto con los tipos y ejemplos con la implementación de código adecuada. También puede consultar nuestros artículos sugeridos para obtener más información.
- Constructor en JavaScript y Tipos
- Introducción a Constructor en Python
- Constructor en C ++ y Tipos
- Constructor en PHP (Ejemplos)