El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Interfaces

Siguiente ►
►

Introducción

En C#, una interfaz es un contrato que define un conjunto de métodos y propiedades que una clase debe implementar. Las interfaces son fundamentales para la programación orientada a objetos, ya que permiten definir comportamientos que pueden ser implementados por cualquier clase, independientemente de su posición en la jerarquía de herencia.

Conceptos Clave

  • Definición de una Interfaz: Una interfaz se define utilizando la palabra clave interface.
  • Implementación de una Interfaz: Una clase o estructura que implementa una interfaz debe proporcionar una implementación para todos los miembros de la interfaz.
  • Polimorfismo: Las interfaces permiten el polimorfismo, lo que significa que una clase puede ser tratada como una instancia de una interfaz que implementa.

Definición de una Interfaz

Para definir una interfaz en C#, se utiliza la palabra clave interface seguida del nombre de la interfaz. Los nombres de las interfaces suelen comenzar con una "I" mayúscula por convención.

public interface IAnimal
{
    void MakeSound();
    void Move();
}

En este ejemplo, IAnimal es una interfaz que define dos métodos: MakeSound y Move.

Implementación de una Interfaz

Una clase que implementa una interfaz debe proporcionar una implementación para todos los métodos y propiedades definidos en la interfaz.

public class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Woof!");
    }

    public void Move()
    {
        Console.WriteLine("The dog runs.");
    }
}

En este ejemplo, la clase Dog implementa la interfaz IAnimal y proporciona implementaciones para los métodos MakeSound y Move.

Ejemplo Práctico

Vamos a crear un ejemplo más completo que incluya varias interfaces y clases que las implementen.

Definición de Interfaces

public interface IAnimal
{
    void MakeSound();
    void Move();
}

public interface IPet
{
    string Name { get; set; }
    void Play();
}

Implementación de Interfaces

public class Dog : IAnimal, IPet
{
    public string Name { get; set; }

    public void MakeSound()
    {
        Console.WriteLine("Woof!");
    }

    public void Move()
    {
        Console.WriteLine("The dog runs.");
    }

    public void Play()
    {
        Console.WriteLine($"{Name} is playing with a ball.");
    }
}

public class Cat : IAnimal, IPet
{
    public string Name { get; set; }

    public void MakeSound()
    {
        Console.WriteLine("Meow!");
    }

    public void Move()
    {
        Console.WriteLine("The cat walks gracefully.");
    }

    public void Play()
    {
        Console.WriteLine($"{Name} is playing with a string.");
    }
}

Uso de Interfaces

public class Program
{
    public static void Main()
    {
        IPet myDog = new Dog { Name = "Buddy" };
        IPet myCat = new Cat { Name = "Whiskers" };

        myDog.Play();
        myCat.Play();

        IAnimal animalDog = myDog as IAnimal;
        IAnimal animalCat = myCat as IAnimal;

        animalDog.MakeSound();
        animalCat.MakeSound();
    }
}

Explicación del Código

  1. Definición de Interfaces:

    • IAnimal define dos métodos: MakeSound y Move.
    • IPet define una propiedad Name y un método Play.

  2. Implementación de Interfaces:

    • Dog y Cat implementan ambas interfaces (IAnimal y IPet).
    • Cada clase proporciona su propia implementación de los métodos y propiedades.

  3. Uso de Interfaces:

    • Se crean instancias de Dog y Cat y se asignan a variables de tipo IPet.
    • Se llama al método Play en ambas instancias.
    • Se utiliza el operador as para convertir las instancias a IAnimal y se llama a los métodos MakeSound.

Ejercicio Práctico

Ejercicio

  1. Define una interfaz IVehicle con los siguientes miembros:

    • Un método Start().
    • Un método Stop().
    • Una propiedad Speed de tipo int.

  2. Crea dos clases Car y Bicycle que implementen la interfaz IVehicle.

    • Car debe tener una propiedad adicional FuelLevel de tipo int.
    • Bicycle debe tener una propiedad adicional Gear de tipo int.

  3. Implementa los métodos y propiedades en ambas clases.

  4. En el método Main, crea instancias de Car y Bicycle, y llama a los métodos definidos en la interfaz IVehicle.

Solución

public interface IVehicle
{
    void Start();
    void Stop();
    int Speed { get; set; }
}

public class Car : IVehicle
{
    public int Speed { get; set; }
    public int FuelLevel { get; set; }

    public void Start()
    {
        Console.WriteLine("Car is starting.");
    }

    public void Stop()
    {
        Console.WriteLine("Car is stopping.");
    }
}

public class Bicycle : IVehicle
{
    public int Speed { get; set; }
    public int Gear { get; set; }

    public void Start()
    {
        Console.WriteLine("Bicycle is starting.");
    }

    public void Stop()
    {
        Console.WriteLine("Bicycle is stopping.");
    }
}

public class Program
{
    public static void Main()
    {
        IVehicle myCar = new Car { Speed = 100, FuelLevel = 50 };
        IVehicle myBicycle = new Bicycle { Speed = 20, Gear = 5 };

        myCar.Start();
        myCar.Stop();

        myBicycle.Start();
        myBicycle.Stop();
    }
}

Explicación de la Solución

  1. Definición de la Interfaz IVehicle:

    • Se define la interfaz con los métodos Start y Stop, y la propiedad Speed.

  2. Implementación de la Interfaz en Car y Bicycle:

    • Ambas clases implementan los métodos y la propiedad de la interfaz.
    • Car tiene una propiedad adicional FuelLevel.
    • Bicycle tiene una propiedad adicional Gear.

  3. Uso de las Clases en el Método Main:

    • Se crean instancias de Car y Bicycle.
    • Se llaman a los métodos Start y Stop en ambas instancias.

Conclusión

Las interfaces en C# son una herramienta poderosa para definir contratos que las clases deben cumplir. Permiten la implementación de polimorfismo y ayudan a diseñar sistemas más flexibles y mantenibles. En este módulo, hemos aprendido a definir e implementar interfaces, y hemos visto cómo utilizarlas en ejemplos prácticos. En el siguiente tema, exploraremos los delegados y eventos, que son fundamentales para la programación basada en eventos en C#.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados