Breaking

Post Top Ad

Your Ad Spot

jueves, 19 de diciembre de 2019

Constructores Java

En este artículo, aprenderá sobre los constructores de Java; cómo crear y usar constructores con la ayuda de ejemplos.

¿Qué es un constructor?

Un constructor es similar a un método (pero en realidad no es un método) que se invoca automáticamente cuando se instancia un objeto.
El compilador de Java distingue entre un método y un constructor por su nombre y tipo de retorno. En Java, un constructor tiene el mismo nombre que el de la clase y no devuelve ningún valor.
prueba de clase {
    Prueba() {
        // cuerpo del constructor
    }
}
Aquí, Test()es un constructor; tiene el mismo nombre que el de la clase y no tiene un tipo de retorno.

prueba de clase {
    Prueba nula () {
        // cuerpo del método
    }
}
Aquí, Test()tiene el mismo nombre que el de la clase. Sin embargo, tiene un tipo de retorno voidPor lo tanto, es un método, no un constructor.
Lectura recomendada:  ¿Por qué los constructores no devuelven valores?

Ejemplo: Constructor Java

  1. class ConsMain {
  2. private int x;
  3. // constructor
  4. private ConsMain(){
  5. System.out.println("Constructor Called");
  6. x = 5;
  7. }
  8. public static void main(String[] args){
  9. ConsMain obj = new ConsMain();
  10. System.out.println("Value of x = " + obj.x);
  11. }
  12. }
Cuando ejecutas el programa, la salida será:
Constructor llamado
Valor de x = 5
Aquí, ConsMain()se llama al constructor cuando se crea una instancia del objeto obj .
Un constructor puede o no aceptar argumentos.

Constructor sin arg

Si un constructor Java no acepta ningún parámetro, es un constructor sin argumentos. Su sintaxis es:
accessModifier ClassName () {
   // cuerpo del constructor
}

Ejemplo de constructor sin argumentos

  1. class NoArgCtor {
  2. int i;
  3. // constructor with no parameter
  4. private NoArgCtor(){
  5. i = 5;
  6. System.out.println("Object created and i = " + i);
  7. }
  8. public static void main(String[] args) {
  9. NoArgCtor obj = new NoArgCtor();
  10. }
  11. }
Cuando ejecutas el programa, la salida será:
Objeto creado e i = 5
Aquí, el NoArgCtor()constructor no acepta ningún parámetro.
¿Notó que el modificador de acceso del constructor NoArgCtor () es privado?
Esto se debe a que el objeto se instancia desde dentro de la misma clase. Por lo tanto, puede acceder al constructor.
Sin embargo, si el objeto se creó fuera de la clase, debe declarar el constructor publicpara acceder a él. Por ejemplo:
  1. class Company {
  2. String domainName;
  3. // object is created in another class
  4. public Company(){
  5. domainName = "programiz.com";
  6. }
  7. }
  8. public class CompanyImplementation {
  9. public static void main(String[] args) {
  10. Company companyObj = new Company();
  11. System.out.println("Domain name = "+ companyObj.domainName);
  12. }
  13. }
Cuando ejecutas el programa, la salida será:
Nombre de dominio = programiz.com

Constructor predeterminado

Si no crea constructores usted mismo, el compilador de Java creará automáticamente un constructor sin argumentos durante el tiempo de ejecución. Este constructor se conoce como constructor predeterminado. El constructor predeterminado inicializa cualquier variable de instancia no inicializada.
TipoValor por defecto
booleanofalso
byte0 0
corto0 0
En t0 0
largo0L
carbonizarse\ u0000
flotador0.0f
doble0.0d
objetoReferencia nula

Ejemplo: Constructor predeterminado

  1. class DefaultConstructor {
  2. int a;
  3. boolean b;
  4. public static void main(String[] args) {
  5. DefaultConstructor obj = new DefaultConstructor();
  6. System.out.println("a = " + obj.a);
  7. System.out.println("b = " + obj.b);
  8. }
  9. }
El programa anterior es equivalente a:
  1. class DefaultConstructor {
  2. int a;
  3. boolean b;
  4. private DefaultConstructor() {
  5. a = 0;
  6. b = false;
  7. }
  8. public static void main(String[] args) {
  9. DefaultConstructor obj = new DefaultConstructor();
  10. System.out.println("a = " + obj.a);
  11. System.out.println("b = " + obj.b);
  12. }
  13. }
Cuando ejecutas el programa, la salida será:
a = 0
b = falso
Lectura recomendada: modificadores de visibilidad de Java

Constructor parametrizado

Un constructor también puede aceptar parámetros. Su sintaxis es:
accessModifier ClassName (arg1, arg2, ..., argn) {
    // cuerpo del constructor
}

Ejemplo: constructor parametrizado

  1. class Vehicle {
  2. int wheels;
  3. private Vehicle(int wheels){
  4. wheels = wheels;
  5. System.out.println(wheels + " wheeler vehicle created.");
  6. }
  7. public static void main(String[] args) {
  8. Vehicle v1 = new Vehicle(2);
  9. Vehicle v2 = new Vehicle(3);
  10. Vehicle v3 = new Vehicle(4);
  11. }
  12. }
Cuando ejecutas el programa, la salida será:
Vehículo de 2 ruedas creado.
Vehículo de 3 ruedas creado.
Vehículo de 4 ruedas creado.
Aquí, hemos pasado un argumento de tipo int(número de ruedas) al constructor durante la creación de instancias de objeto.

Sobrecarga de constructores en Java

Similar a la sobrecarga de métodos , también puede sobrecargar los constructores si dos o más constructores son diferentes en los parámetros. Por ejemplo:
  1. class Company {
  2. String domainName;
  3. public Company(){
  4. this.domainName = "default";
  5. }
  6. public Company(String domainName){
  7. this.domainName = domainName;
  8. }
  9. public void getName(){
  10. System.out.println(this.domainName);
  11. }
  12. public static void main(String[] args) {
  13. Company defaultObj = new Company();
  14. Company programizObj = new Company("programiz.com");
  15. defaultObj.getName();
  16. programizObj.getName();
  17. }
  18. }
Cuando ejecutas el programa, la salida será:
defecto
programiz.com
Lectura recomendada: esta palabra clave en Java

Notas importantes

  • Los constructores se invocan implícitamente cuando se crean instancias de objetos.
  • Las dos reglas para crear un constructor son:
    • Un nombre de constructor Java debe coincidir exactamente con el nombre de la clase (incluido el caso).
    • Un constructor de Java no debe tener un tipo de retorno.
  • Si una clase no tiene un constructor, el compilador de Java crea automáticamente un constructor predeterminado durante el tiempo de ejecución. El constructor predeterminado inicializa las variables de instancia con valores predeterminados. Por ejemplo: la intvariable se inicializará a 0
  • Tipos de constructor:
    • Constructor sin argumentos: un constructor que no acepta ningún argumento
    • Constructor predeterminado: un constructor creado automáticamente por el compilador de Java si no está definido explícitamente.
    • Constructor parametrizado: se utiliza para especificar valores específicos de variables en un objeto
  • Los constructores no pueden ser abstractos, estáticos o finales.
  • El constructor se puede sobrecargar, pero no se puede anular.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas