Interfaz vs. Clase Abstracta

Parte de la sección Programación Orientada a Objetos del Journey de C# de Coddy. Lección 26 de 70.

Tanto las interfaces como las clases abstractas permiten definir contratos que otras clases deben seguir, pero tienen propósitos diferentes y capacidades distintas.

Una interfaz define lo que una clase debe hacer, sin ninguna implementación. Es un contrato puro:

public interface IFlyable
{
    void Fly();
}

public class Bird : IFlyable
{
    public void Fly()
    {
        Console.WriteLine("Flapping wings");
    }
}

Una clase abstracta puede proporcionar tanto un contrato como una implementación compartida. Es un plano parcial:

public abstract class Vehicle
{
    public string Brand { get; set; }
    
    public void StartEngine()
    {
        Console.WriteLine("Engine started");
    }
    
    public abstract void Drive();  // Debe ser implementado
}

public class Car : Vehicle
{
    public override void Drive()
    {
        Console.WriteLine("Driving on roads");
    }
}

Las diferencias clave se reducen a las reglas de herencia y al propósito.

Una clase puede implementar varias interfaces, pero heredar solo de una clase abstracta.

Usa una interfaz cuando clases no relacionadas necesiten compartir un comportamiento (como IFlyable para aves y aviones). Usa una clase abstracta cuando clases relacionadas compartan código y estado comunes (como vehículos que comparten un mecanismo de arranque del motor).

Las clases abstractas pueden tener constructores, campos y modificadores de acceso en sus miembros. Tradicionalmente, las interfaces no podían, aunque el C# moderno permite implementaciones predeterminadas.

Cuando tengas dudas, prefiere las interfaces por su flexibilidad; siempre puedes añadir después una clase abstracta si la implementación compartida se vuelve necesaria.

Desafío

Fácil

Construyamos un sistema de reproducción multimedia que demuestre cuándo usar interfaces frente a clases abstractas. Crearás un diseño en el que dispositivos no relacionados compartan el comportamiento de reproducción mediante una interfaz, mientras que tipos de medios relacionados compartan una implementación común mediante una clase abstracta.

Organizarás tu código en cuatro archivos:

IPlayable.cs: Define una interfaz llamada IPlayable en el espacio de nombres Media. Esta interfaz representa el contrato para cualquier elemento que pueda reproducir medios, ya sea un teléfono, un televisor o un reproductor de música dedicado. Debe declarar un único método Play() que devuelva una cadena.
MediaFile.cs: Define una clase abstracta llamada MediaFile en el espacio de nombres Media. Esto representa la base compartida para todos los archivos multimedia. Debe tener una propiedad Title (string) y una propiedad Duration (int, que representa segundos). Incluye un constructor que establezca ambos valores. Añade un método concreto llamado GetInfo() que devuelva "{Title} ({Duration}s)". Declara también un método abstracto GetType() que devuelva una cadena; cada tipo de medio definirá qué tipo de archivo es.
AudioFile.cs: Define una clase AudioFile en el espacio de nombres Media que herede de MediaFile e implemente IPlayable. Añade una propiedad Artist (string). El constructor debe aceptar el título, la duración y el artista. Sobrescribe GetType() para que devuelva "Audio". Implementa Play() para que devuelva "Playing audio: {Title} by {Artist}".
Program.cs: En tu archivo principal, crea un AudioFile usando los valores de entrada. Demuestra ambos aspectos de la clase: llama a GetInfo() y GetType() (heredados de la clase abstracta) y, después, llama a Play() (de la interfaz). Almacena el archivo de audio en una variable IPlayable y vuelve a llamar a Play() para mostrar el polimorfismo de interfaces.

Recibirás tres entradas:

Título de la canción
Duración en segundos
Nombre del artista

Imprime la salida con este formato:

Info: {GetInfo() result}
Type: {GetType() result}
Direct: {Play() result}
Via Interface: {Play() result from IPlayable variable}

Por ejemplo, si las entradas son Bohemian Rhapsody, 354 y Queen, la salida debería ser:

Info: Bohemian Rhapsody (354s)
Type: Audio
Direct: Playing audio: Bohemian Rhapsody by Queen
Via Interface: Playing audio: Bohemian Rhapsody by Queen

Observa cómo AudioFile se beneficia de ambos enfoques: hereda una implementación compartida (GetInfo()) de la clase abstracta y, al mismo tiempo, cumple el contrato de IPlayable. La clase abstracta proporciona reutilización de código para tipos de medios relacionados, mientras que la interfaz permite que cualquier clase no relacionada sea "reproducible" sin compartir una jerarquía de herencia.

Pruébalo tú mismo

using System;
using Media;

class Program
{
    public static void Main(string[] args)
    {
        // Lee los valores de entrada
        string title = Console.ReadLine();
        int duration = Convert.ToInt32(Console.ReadLine());
        string artist = Console.ReadLine();
        
        // TODO: Crea un AudioFile usando los valores de entrada
        
        // TODO: Imprime Info: seguido del resultado de GetInfo()
        
        // TODO: Imprime Type: seguido del resultado de GetType()
        
        // TODO: Imprime Direct: seguido del resultado de Play()
        
        // TODO: Almacena el archivo de audio en una variable IPlayable
        
        // TODO: Imprime Via Interface: seguido del resultado de Play() de la variable IPlayable
    }
}