Dominar Constructores en Java: Tipos, Uso y Ejemplos Prácticos

Constructores en Java

En este tutorial, aprenderemos sobre los constructores en Java, sus tipos y cómo usarlos con la ayuda de ejemplos.

¿Qué es un Constructor?

Un constructor en Java es similar a un método que se invoca cuando se crea un objeto de la clase.

A diferencia de los métodos de Java, un constructor tiene el mismo nombre que la clase y no tiene tipo de retorno. Por ejemplo,

class Test {
    Test() {
        // cuerpo del constructor
    }
}

Aquí, Test() es un constructor. Tiene el mismo nombre que la clase y no tiene tipo de retorno.

Lectura Recomendada: Por qué los constructores no devuelven valores

---

Ejemplo 1: Constructor en Java

class Main {
    private String name;
    // constructor
    Main() {
        System.out.println("Constructor Called:");
        name = "Programiz";
    }
    public static void main(String[] args) {
        // el constructor se invoca al
        // crear un objeto de la clase Main
        Main obj = new Main();
        System.out.println("The name is " + obj.name);
    }
}

Salida:

Constructor Called:
The name is Programiz

En el ejemplo anterior, hemos creado un constructor llamado Main(). Dentro del constructor, estamos inicializando el valor de la variable name.

Observa la sentencia de creación de un objeto de la clase Main.

Main obj = new Main();

Aquí, cuando se crea el objeto, se llama al constructor Main(). Y el valor de la variable name se inicializa.

Por lo tanto, el programa imprime el valor de la variable name como Programiz.

---

Tipos de Constructor

En Java, los constructores se pueden dividir en 3 tipos:

1. Constructor Sin Argumentos (No-Arg)
2. Constructor Parametrizado
3. Constructor Por Defecto

---

1. Constructores Sin Argumentos (No-Arg) en Java

Similar a los métodos, un constructor de Java puede o no tener parámetros (argumentos).

Si un constructor no acepta ningún parámetro, se conoce como constructor sin argumentos. Por ejemplo,

private Constructor() {
    // cuerpo del constructor
}

---

Ejemplo 2: Constructor Privado Sin Argumentos en Java

class Main {
    int i;
    // constructor sin parámetros
    private Main() {
        i = 5;
        System.out.println("Constructor is called");
    }
    public static void main(String[] args) {
        // llamar al constructor sin ningún parámetro
        Main obj = new Main();
        System.out.println("Value of i: " + obj.i);
    }
}

Salida:

Constructor is called
Value of i: 5

En el ejemplo anterior, hemos creado un constructor Main(). Aquí, el constructor no acepta ningún parámetro. Por lo tanto, se conoce como constructor no-arg.

Observa que hemos declarado el constructor como private.

Una vez que un constructor se declara private, no se puede acceder desde fuera de la clase. Así que crear objetos desde fuera de la clase está prohibido usando el constructor privado.

Aquí, estamos creando el objeto dentro de la misma clase. Por lo tanto, el programa puede acceder al constructor. Para saber más, visita Implementar Constructor Privado en Java.

Sin embargo, si queremos crear objetos fuera de la clase, entonces necesitamos declarar el constructor como public.

Ejemplo 3: Constructores Públicos Sin Argumentos en Java

class Company {
    String name;
    // constructor público
    public Company() {
        name = "Programiz";
    }
}

class Main {
    public static void main(String[] args) {
        // el objeto se crea en otra clase
        Company obj = new Company();
        System.out.println("Company name = " + obj.name);
    }
}

Salida:

Company name = Programiz

Lectura Recomendada: Modificador de Acceso en Java

---

2. Constructor Parametrizado en Java

Un constructor de Java también puede aceptar uno o más parámetros. Dichos constructores se conocen como constructores parametrizados (constructor con parámetros).

Ejemplo 4: Constructor Parametrizado

class Main {
    String languages;
    // constructor aceptando un solo valor
    Main(String lang) {
        languages = lang;
        System.out.println(languages + " Programming Language");
    }
    public static void main(String[] args) {
        // llamar al constructor pasando un solo valor
        Main obj1 = new Main("Java");
        Main obj2 = new Main("Python");
        Main obj3 = new Main("C");
    }
}

Salida:

Java Programming Language
Python Programming Language
C Programming Language

En el ejemplo anterior, hemos creado un constructor llamado Main(). Aquí, el constructor toma un solo parámetro. Observa la expresión,

Main obj1 = new Main("Java");

Aquí, estamos pasando el valor único al constructor. Basado en el argumento pasado, la variable language se inicializa dentro del constructor.

---

3. Constructor Por Defecto en Java

Si no creamos ningún constructor, el compilador de Java crea automáticamente un constructor sin argumentos durante la ejecución del programa. Este constructor se llama constructor por defecto.

Ejemplo 5: Constructor Por Defecto

class Main {
    int a;
    boolean b;
    public static void main(String[] args) {
        // Se llama a un constructor por defecto
        Main obj = new Main();
        System.out.println("Default Value:");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

Salida:

a = 0
b = false

Aquí, no hemos creado ningún constructor. Por lo tanto, el compilador de Java crea automáticamente el constructor por defecto.

El constructor por defecto inicializa cualquier variable de instancia no inicializada con valores por defecto.

Tipo	Valor Por Defecto
boolean	false
byte	0
short	0
int	0
long	0L
char	\u0000
float	0.0f
double	0.0d
object	Referencia null

En el programa anterior, las variables a y b se inicializan con valor por defecto 0 y false respectivamente.

El programa anterior es equivalente a:

class Main {
    int a;
    boolean b;
    // un constructor privado
    private Main() {
        a = 0;
        b = false;
    }
    public static void main(String[] args) {
        // llamar al constructor
        Main obj = new Main();
        System.out.println("Default Value:");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

La salida del programa es la misma que el Ejemplo 5.

---

Notas Importantes sobre Constructores en Java

• Los constructores se invocan implícitamente cuando instancias objetos.
• Las dos reglas para crear un constructor son:
  El nombre del constructor debe ser el mismo que el de la clase.
  Un constructor de Java no debe tener tipo de retorno.
• Si una clase no tiene constructor, el compilador de Java crea automáticamente un constructor por defecto en tiempo de ejecución. El constructor por defecto inicializa las variables de instancia con valores por defecto. Por ejemplo, la variable int se inicializará a 0
• Tipos de constructor:
  Constructor Sin Argumentos - un constructor que no acepta argumentos
  Constructor Parametrizado - un constructor que acepta argumentos
  Constructor Por Defecto - un constructor que se crea automáticamente por el compilador de Java si no se define explícitamente.
• Un constructor no puede ser abstract, static o final.
• Un constructor puede ser sobrecargado pero no puede ser sobrescrito.

---

Sobrecarga de Constructores en Java

Similar a la sobrecarga de métodos en Java, también podemos crear dos o más constructores con diferentes parámetros. Esto se llama sobrecarga de constructores.

Ejemplo 6: Sobrecarga de Constructores en Java

class Main {
    String language;
    // constructor sin parámetros
    Main() {
        this.language = "Java";
    }
    // constructor con un parámetro
    Main(String language) {
        this.language = language;
    }
    public void getName() {
        System.out.println("Programming Language: " + this.language);
    }
    public static void main(String[] args) {
        // llamar al constructor sin parámetros
        Main obj1 = new Main();
        // llamar al constructor con un parámetro
        Main obj2 = new Main("Python");
        obj1.getName();
        obj2.getName();
    }
}

Salida:

Programming Language: Java
Programming Language: Python

En el ejemplo anterior, tenemos dos constructores: Main() y Main(String language). Aquí, ambos constructores inicializan el valor de la variable language con diferentes valores.

Basado en el parámetro pasado durante la creación del objeto, se llaman diferentes constructores y se asignan diferentes valores.

También es posible llamar a un constructor desde otro constructor. Para saber más, visita Llamar a un Constructor desde Otro en Java.

Nota: Hemos usado la palabra clave this para especificar la variable de la clase. Para saber más sobre la palabra clave this, visita Palabra Clave this en Java.