Capítulo 3: Herencia y Polimorfismo, Interfaces y Clases Abstractas

En este capítulo, profundizaremos en la programación orientada a objetos (POO) en Java, centrándonos en los conceptos de herencia y polimorfismo, además de explorar la importancia de las interfaces y clases abstractas. Estos conceptos son fundamentales para crear jerarquías de clases y construir programas más flexibles y reutilizables.

3.1. Herencia y Polimorfismo

Herencia es un concepto clave en POO que permite que una clase herede atributos y métodos de otra. Esto fomenta la reutilización de código y la creación de una jerarquía de clases. Por otro lado, el polimorfismo permite que objetos de clases derivadas se comporten como objetos de la clase base.

Ejemplo 3.1.1: Herencia y Polimorfismo

class Animal {
    void hacerSonido() {
        System.out.println("El animal hace un sonido");
    }
}

class Perro extends Animal {
    void hacerSonido() {
        System.out.println("El perro ladra");
    }
}

public class ProgramaPrincipal {
    public static void main(String[] args) {
        Animal miAnimal = new Perro(); // Polimorfismo
        miAnimal.hacerSonido(); // Salida: El perro ladra
    }
}

Ejercicio 3.1.1: Herencia y Polimorfismo

Crea una clase llamada Fruta con un método obtenerColor(). Luego, crea clases derivadas como Manzana y Banana que sobrescriban el método obtenerColor(). Crea objetos de cada tipo de fruta y muestra sus colores en la consola.

3.2. Interfaces y Clases Abstractas

Interfaces y clases abstractas son herramientas importantes para la abstracción y el diseño flexible. Las interfaces definen un conjunto de métodos que una clase debe implementar, permitiendo que diferentes clases cumplan con un contrato común. Las clases abstractas son clases parcialmente implementadas que pueden contener métodos abstractos, y las clases concretas deben implementarlos.

Ejemplo 3.2.1: Interfaces y Clases Abstractas

interface Forma {
    double calcularArea();
}

class Circulo implements Forma {
    double radio;
    
    Circulo(double radio) {
        this.radio = radio;
    }
    
    public double calcularArea() {
        return Math.PI * radio * radio;
    }
}

public class ProgramaPrincipal {
    public static void main(String[] args) {
        Forma circulo = new Circulo(5.0);
        System.out.println("Área del círculo: " + circulo.calcularArea());
    }
}

Ejercicio 3.2.1: Interfaces y Clases Abstractas

Crea una interfaz Vehiculo con métodos acelerar() y frenar(). Luego, crea clases como Coche y Moto que implementen la interfaz Vehiculo y proporcionen sus propias implementaciones de acelerar y frenar.

Resumen del Capítulo y Ejercicios

• Resumen de los conceptos clave de este capítulo, incluyendo herencia, polimorfismo, interfaces, clases abstractas y su importancia en la programación orientada a objetos.
• Completa los ejercicios proporcionados para practicar y fortalecer tu comprensión de estos conceptos fundamentales de POO en Java.

Respuesta ejercicio 3.2.1:

Aquí tienes el código y los pasos necesarios para resolver el ejercicio de crear una interfaz Vehiculo con métodos acelerar()y frenar, y luego crear las clases Coche y Moto que implementen la interfaz y proporcionen sus propias implementaciones:

Paso 1: Creación de la Interfaz Vehiculo

Primero, crea la interfaz Vehiculo con los métodos acelerar() y frenar():

interface Vehiculo {
    void acelerar(int velocidad);
    void frenar();
}

Paso 2: Implementación de la Clase Coche

A continuación, crea la clase Coche que implementa la interfaz Vehiculo y proporciona sus propias implementaciones de acelerar() y frenar():

class Coche implements Vehiculo {
    private int velocidad;

    @Override
    public void acelerar(int velocidad) {
        this.velocidad += velocidad;
        System.out.println("El coche aceleró a " + this.velocidad + " km/h.");
    }

    @Override
    public void frenar() {
        this.velocidad = 0;
        System.out.println("El coche frenó por completo.");
    }
}

Paso 3: Implementación de la Clase Moto

Ahora, crea la clase Moto que también implementa la interfaz Vehiculo y proporciona sus propias implementaciones de acelerar() y frenar():

class Moto implements Vehiculo {
    private int velocidad;

    @Override
    public void acelerar(int velocidad) {
        this.velocidad += velocidad;
        System.out.println("La moto aceleró a " + this.velocidad + " km/h.");
    }

    @Override
    public void frenar() {
        this.velocidad = 0;
        System.out.println("La moto frenó por completo.");
    }
}

Paso 4: Uso de las Clases Coche y Moto

Por último, puedes crear objetos de las clases Coche y Moto y llamar a sus métodos para probar su funcionamiento:

public class ProgramaPrincipal {
    public static void main(String[] args) {
        Coche miCoche = new Coche();
        Moto miMoto = new Moto();

        miCoche.acelerar(60);
        miMoto.acelerar(50);

        miCoche.frenar();
        miMoto.frenar();
    }
}

Resultado Esperado:

El coche aceleró a 60 km/h.
La moto aceleró a 50 km/h.
El coche frenó por completo.
La moto frenó por completo.

Este ejercicio demuestra cómo utilizar una interfaz en Java para definir un contrato común (Vehiculo) y cómo las clases concretas (Coche y Moto) implementan ese contrato proporcionando sus propias implementaciones de los métodos.