Métodos y constructores

En Java, los métodos y constructores son fundamentales para definir el comportamiento de las clases y la manera en que sus objetos son creados y utilizados. A continuación, se detalla en qué consisten, cómo se definen y las diferencias entre ambos.

---

1. Métodos en Java

Un método en Java es una función que define un comportamiento o acción que un objeto puede ejecutar. Los métodos son utilizados para manipular el estado del objeto o para realizar ciertas operaciones.

Componentes de un Método:

• Modificadores de acceso: Define la visibilidad del método (e.g., public, private).
• Tipo de retorno: El tipo de valor que el método devolverá (e.g., int, String, void si no devuelve nada).
• Nombre del método: El nombre de la función (debe ser único dentro de la clase).
• Parámetros (opcional): Una lista de parámetros que el método puede aceptar.
• Cuerpo del método: El bloque de código que define la operación del método.

Sintaxis básica de un método:

modificadoresDeAcceso tipoDeRetorno nombreDelMetodo(parámetros) {
    // Cuerpo del método
    // Código que realiza la acción
}

Ejemplo de un método en Java:

public class Coche {
    String marca;
    String modelo;

    // Constructor
    public Coche(String marca, String modelo) {
        this.marca = marca;
        this.modelo = modelo;
    }

    // Método sin valor de retorno (void)
    public void mostrarInformacion() {
        System.out.println("Marca: " + marca + ", Modelo: " + modelo);
    }

    // Método con valor de retorno
    public String obtenerMarca() {
        return marca;
    }

    public String obtenerModelo() {
        return modelo;
    }
}

En este ejemplo:

• mostrarInformacion(): Es un método void, lo que significa que no devuelve ningún valor. Simplemente imprime los valores de los atributos marca y modelo.
• obtenerMarca() y obtenerModelo(): Son métodos que devuelven un valor (en este caso, String), que devuelve la marca o el modelo del coche.

Llamada a un Método:

Para llamar a un método, primero necesitas crear un objeto de la clase y luego utilizar la notación de punto (.) para acceder al método del objeto.

public class Main {
    public static void main(String[] args) {
        Coche miCoche = new Coche("Toyota", "Corolla");

        // Llamar al método sin retorno
        miCoche.mostrarInformacion();

        // Llamar a los métodos con retorno y almacenar el valor
        String marca = miCoche.obtenerMarca();
        String modelo = miCoche.obtenerModelo();

        System.out.println("Marca: " + marca);
        System.out.println("Modelo: " + modelo);
    }
}

Salida esperada:

Marca: Toyota, Modelo: Corolla
Marca: Toyota
Modelo: Corolla

Sobrecarga de Métodos (Method Overloading):

La sobrecarga de métodos permite definir varios métodos con el mismo nombre pero con diferentes tipos o números de parámetros. Esto es útil cuando deseas realizar la misma operación con diferentes tipos de datos o diferentes cantidades de datos.

public class Calculadora {
    public int sumar(int a, int b) {
        return a + b;
    }

    public double sumar(double a, double b) {
        return a + b;
    }

    public int sumar(int a, int b, int c) {
        return a + b + c;
    }
}

En este ejemplo, el método sumar() está sobrecargado, lo que significa que puedes sumarle dos enteros, dos decimales o tres enteros.

---

2. Constructores en Java

Un constructor es un tipo especial de método que se utiliza para crear e inicializar objetos a partir de una clase. Los constructores se ejecutan automáticamente cuando se crea un nuevo objeto y permiten establecer valores iniciales para los atributos del objeto.

Características de los Constructores:

• Nombre del constructor: El nombre del constructor siempre debe ser el mismo que el de la clase.
• No tiene tipo de retorno: Los constructores no especifican un tipo de retorno, ni siquiera void.
• Puede aceptar parámetros: Al igual que los métodos, los constructores pueden tener parámetros que permiten inicializar los atributos del objeto al momento de su creación.

Sintaxis básica de un Constructor:

public class NombreDeLaClase {
    // Atributos
    tipo atributo;

    // Constructor
    public NombreDeLaClase(parámetros) {
        // Inicializar atributos
        this.atributo = valor;
    }
}

Ejemplo de un Constructor:

public class Coche {
    String marca;
    String modelo;
    int año;

    // Constructor de la clase Coche
    public Coche(String marca, String modelo, int año) {
        this.marca = marca;  // Inicializa el atributo marca con el valor recibido
        this.modelo = modelo; // Inicializa el atributo modelo
        this.año = año; // Inicializa el atributo año
    }
}

En este ejemplo, el constructor Coche(String marca, String modelo, int año) inicializa los atributos marca, modelo y año con los valores proporcionados al momento de crear un objeto de tipo Coche.

Llamada al Constructor:

Cuando creas un objeto de una clase, el constructor se llama automáticamente para inicializar el objeto:

public class Main {
    public static void main(String[] args) {
        // Crear un objeto de tipo Coche usando el constructor
        Coche miCoche = new Coche("Toyota", "Corolla", 2020);

        // Acceder a los atributos del objeto
        System.out.println("Marca: " + miCoche.marca);
        System.out.println("Modelo: " + miCoche.modelo);
        System.out.println("Año: " + miCoche.año);
    }
}

Salida esperada:

Marca: Toyota
Modelo: Corolla
Año: 2020

Constructores por Defecto (Default Constructor):

Si no defines un constructor explícitamente en tu clase, Java crea un constructor por defecto que no toma ningún parámetro y simplemente inicializa los atributos con los valores predeterminados (0 para los tipos numéricos, null para los objetos, etc.).

Si deseas proporcionar valores específicos desde el inicio, debes definir tu propio constructor.

Ejemplo de Constructor por Defecto:

public class Coche {
    String marca;
    String modelo;

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

Si creas un objeto sin parámetros, se usará este constructor por defecto:

Coche miCoche = new Coche();  // Usa el constructor por defecto
System.out.println("Marca: " + miCoche.marca);
System.out.println("Modelo: " + miCoche.modelo);

Salida esperada:

Marca: Desconocida
Modelo: Desconocido

---

Diferencia entre Métodos y Constructores

Característica	Métodos	Constructores
Propósito	Realizar una acción o devolver un valor.	Crear e inicializar un objeto.
Nombre	El nombre puede ser cualquier nombre válido	El nombre debe ser el mismo que el de la clase.
Valor de Retorno	Puede devolver un valor o void.	No tiene valor de retorno.
Llamada	Se invoca explícitamente.	Se llama automáticamente al crear un objeto.
Parámetros	Puede tener parámetros opcionales.	Puede aceptar parámetros para inicializar el objeto.
Cantidad de invocaciones	Se pueden invocar múltiples veces.	Se invoca una sola vez al crear el objeto.