Interfaces y Clases Abstractas

En este ejercicio aprenderás las diferencias fundamentales entre **interfaces** y **clases abstractas** en Java. Ambas son herramientas clave en la **programación orientada a objetos** que permiten la abstracción y la creación de estructuras flexibles y reutilizables. A través de ejemplos prácticos, descubrirás cómo usar **interfaces** para definir métodos que deben ser implementados por clases y cómo **clases abstractas** permiten definir métodos parcialmente implementados. Este ejercicio te ayudará a entender cómo aplicar estos conceptos para crear aplicaciones más eficientes y fáciles de mantener en Java.

Tema

Programación Orientada a Objetos (POO)

Ejercicio Java

En este ejercicio, crearás un programa en Java que demuestre el uso de **interfaces** y **clases abstractas**. Primero, definirás una **interfaz** llamada Vehiculo que tendrá un método abstracto llamado mover(). Luego, crearás una **clase abstracta** llamada Automovil que implementará parte del comportamiento de los vehículos y tendrá un método abstracto llamado detalles(). Finalmente, crearás una clase concreta llamada Coche que implementará ambos métodos, mover() y detalles(), demostrando cómo las interfaces y las clases abstractas se combinan para crear una estructura sólida y flexible en tu programa.

Instrucciones:

  1. Crea una **interfaz** llamada Vehiculo con el método abstracto mover().
  2. Crea una **clase abstracta** llamada Automovil que implemente la interfaz Vehiculo y declare un método abstracto detalles().
  3. Crea una clase concreta llamada Coche que implemente los métodos mover() y detalles().
  4. En el método principal, crea un objeto de tipo Coche y llama a los métodos para demostrar el uso de interfaces y clases abstractas.

Este ejercicio te ayudará a comprender cómo las **interfaces** y las **clases abstractas** se utilizan para definir y organizar comportamientos comunes en las aplicaciones Java, mejorando su estructura y mantenibilidad.


interface Vehiculo {
    void mover(); // Método abstracto para mover el vehículo
}

abstract class Automovil implements Vehiculo {
    // Método parcialmente implementado
    public void mover() {
        System.out.println("El automóvil está en movimiento.");
    }

    // Método abstracto
    public abstract void detalles();
}

class Coche extends Automovil {
    // Implementación del método abstracto detalles
    @Override
    public void detalles() {
        System.out.println("Este es un coche deportivo.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Crear un objeto de tipo Coche
        Coche coche = new Coche();
        
        // Llamar a los métodos
        coche.mover();       // Salida: "El automóvil está en movimiento."
        coche.detalles();    // Salida: "Este es un coche deportivo."
    }
}

 Salida:

El automóvil está en movimiento.
Este es un coche deportivo.

Este programa demuestra cómo las **interfaces** y **clases abstractas** permiten crear un diseño más flexible y reutilizable. La clase Coche implementa el comportamiento definido en la interfaz Vehiculo y completa el comportamiento adicional en la clase abstracta Automovil, lo que resulta en un programa bien estructurado.


 Comparte este ejercicio JAVA