El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Introducción

En Java, un constructor es un bloque de código especial que se utiliza para inicializar un objeto. Un constructor se llama automáticamente cuando se crea una instancia de una clase. Los constructores tienen el mismo nombre que la clase y no tienen un tipo de retorno, ni siquiera void.

Tipos de Constructores

Constructor por Defecto: Es un constructor sin parámetros que Java proporciona automáticamente si no se define ningún constructor en la clase.
Constructor Parametrizado: Es un constructor que acepta uno o más parámetros para inicializar el objeto con valores específicos.

Sintaxis de un Constructor

class NombreDeLaClase {
    // Constructor por defecto
    NombreDeLaClase() {
        // Código de inicialización
    }

    // Constructor parametrizado
    NombreDeLaClase(tipo parametro1, tipo parametro2) {
        // Código de inicialización
    }
}

Ejemplo Práctico

Constructor por Defecto

public class Persona {
    String nombre;
    int edad;

    // Constructor por defecto
    public Persona() {
        nombre = "Desconocido";
        edad = 0;
    }

    public void mostrarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Edad: " + edad);
    }

    public static void main(String[] args) {
        Persona persona = new Persona();
        persona.mostrarInformacion();
    }
}

Explicación:

En este ejemplo, la clase Persona tiene un constructor por defecto que inicializa el nombre a "Desconocido" y la edad a 0.
Cuando se crea una instancia de Persona usando new Persona(), el constructor por defecto se llama automáticamente.

Constructor Parametrizado

public class Persona {
    String nombre;
    int edad;

    // Constructor parametrizado
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public void mostrarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Edad: " + edad);
    }

    public static void main(String[] args) {
        Persona persona = new Persona("Juan", 25);
        persona.mostrarInformacion();
    }
}

Explicación:

En este ejemplo, la clase Persona tiene un constructor parametrizado que acepta dos parámetros: nombre y edad.
Cuando se crea una instancia de Persona usando new Persona("Juan", 25), el constructor parametrizado se llama automáticamente y los valores "Juan" y 25 se asignan a los atributos nombre y edad respectivamente.

Sobrecarga de Constructores

Java permite tener múltiples constructores en una clase, siempre y cuando tengan diferentes listas de parámetros. Esto se conoce como sobrecarga de constructores.

Ejemplo de Sobrecarga de Constructores

public class Persona {
    String nombre;
    int edad;

    // Constructor por defecto
    public Persona() {
        nombre = "Desconocido";
        edad = 0;
    }

    // Constructor parametrizado
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    // Otro constructor parametrizado
    public Persona(String nombre) {
        this.nombre = nombre;
        this.edad = 0;
    }

    public void mostrarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Edad: " + edad);
    }

    public static void main(String[] args) {
        Persona persona1 = new Persona();
        Persona persona2 = new Persona("Juan", 25);
        Persona persona3 = new Persona("Ana");

        persona1.mostrarInformacion();
        persona2.mostrarInformacion();
        persona3.mostrarInformacion();
    }
}

Explicación:

La clase Persona tiene tres constructores: uno por defecto, uno que acepta dos parámetros (nombre y edad), y otro que acepta solo el nombre.
Dependiendo de cómo se cree la instancia de Persona, se llamará al constructor correspondiente.

Ejercicios Prácticos

Ejercicio 1: Constructor por Defecto

Instrucciones:

Crea una clase Coche con los atributos marca y modelo.
Define un constructor por defecto que inicialice marca a "Desconocida" y modelo a "Desconocido".
Crea un método mostrarInformacion que imprima los valores de marca y modelo.
En el método main, crea una instancia de Coche y llama al método mostrarInformacion.

Solución:

public class Coche {
    String marca;
    String modelo;

    // Constructor por defecto
    public Coche() {
        marca = "Desconocida";
        modelo = "Desconocido";
    }

    public void mostrarInformacion() {
        System.out.println("Marca: " + marca);
        System.out.println("Modelo: " + modelo);
    }

    public static void main(String[] args) {
        Coche coche = new Coche();
        coche.mostrarInformacion();
    }
}

Ejercicio 2: Constructor Parametrizado

Instrucciones:

Crea una clase Libro con los atributos titulo y autor.
Define un constructor parametrizado que acepte titulo y autor.
Crea un método mostrarInformacion que imprima los valores de titulo y autor.
En el método main, crea una instancia de Libro con valores específicos y llama al método mostrarInformacion.

Solución:

public class Libro {
    String titulo;
    String autor;

    // Constructor parametrizado
    public Libro(String titulo, String autor) {
        this.titulo = titulo;
        this.autor = autor;
    }

    public void mostrarInformacion() {
        System.out.println("Título: " + titulo);
        System.out.println("Autor: " + autor);
    }

    public static void main(String[] args) {
        Libro libro = new Libro("1984", "George Orwell");
        libro.mostrarInformacion();
    }
}

Ejercicio 3: Sobrecarga de Constructores

Instrucciones:

Crea una clase Producto con los atributos nombre y precio.
Define un constructor por defecto que inicialice nombre a "Desconocido" y precio a 0.0.
Define un constructor parametrizado que acepte nombre y precio.
Define otro constructor parametrizado que acepte solo nombre y establezca precio a 0.0.
Crea un método mostrarInformacion que imprima los valores de nombre y precio.
En el método main, crea instancias de Producto usando los diferentes constructores y llama al método mostrarInformacion.

Solución:

public class Producto {
    String nombre;
    double precio;

    // Constructor por defecto
    public Producto() {
        nombre = "Desconocido";
        precio = 0.0;
    }

    // Constructor parametrizado
    public Producto(String nombre, double precio) {
        this.nombre = nombre;
        this.precio = precio;
    }

    // Otro constructor parametrizado
    public Producto(String nombre) {
        this.nombre = nombre;
        this.precio = 0.0;
    }

    public void mostrarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Precio: " + precio);
    }

    public static void main(String[] args) {
        Producto producto1 = new Producto();
        Producto producto2 = new Producto("Laptop", 1500.0);
        Producto producto3 = new Producto("Tablet");

        producto1.mostrarInformacion();
        producto2.mostrarInformacion();
        producto3.mostrarInformacion();
    }
}

Conclusión

En esta sección, hemos aprendido sobre los constructores en Java, incluyendo los constructores por defecto y parametrizados, así como la sobrecarga de constructores. Los constructores son fundamentales para inicializar objetos y asegurar que los atributos tengan valores válidos desde el momento de la creación del objeto. Con esta base, estamos preparados para explorar más a fondo la Programación Orientada a Objetos en Java.

Constructores

Introducción

Tipos de Constructores

Sintaxis de un Constructor

Ejemplo Práctico

Constructor por Defecto

Constructor Parametrizado

Sobrecarga de Constructores

Ejemplo de Sobrecarga de Constructores

Ejercicios Prácticos

Ejercicio 1: Constructor por Defecto

Ejercicio 2: Constructor Parametrizado

Ejercicio 3: Sobrecarga de Constructores

Conclusión

Curso de Programación en Java

Módulo 1: Introducción a Java

Módulo 2: Flujo de Control

Módulo 3: Programación Orientada a Objetos

Módulo 4: Programación Orientada a Objetos Avanzada

Módulo 5: Estructuras de Datos y Colecciones

Módulo 6: Manejo de Excepciones

Módulo 7: Entrada/Salida de Archivos

Módulo 8: Multihilo y Concurrencia

Módulo 9: Redes

Módulo 10: Temas Avanzados

Módulo 11: Frameworks y Librerías de Java

Módulo 12: Construcción de Aplicaciones del Mundo Real