Un interfaz en es una colección de definiciones de métodos, propiedades, eventos o indexadores que una clase o una estructura puede implementar.
A diferencia de las clases, los interfaces no contienen implementaciones de métodos (solo definen los miembros que deben ser implementados por las clases o estructuras que los implementan).
Las interfaces son fundamentales en la programación orientada a objetos porque permiten definir funcionalidades y comportamiento que pueden ser implementadas por diferentes clases, favoreciendo la mantenibilidad y la reutilización del código.
Si quieres aprender más sobre Interface
consulta el Curso de Programación Orientada a Objetos leer más ⯈
Interfaces en C#
La declaración de una interfaz se realiza utilizando la palabra clave interface
.
[modificador] interface NombreDeLaInterfaz
{
// Definición de métodos
tipoDeDato NombreDelMetodo(parametros);
// Definición de propiedades
tipoDeDato NombreDeLaPropiedad { get; set; }
}
NombreDeLaInterfaz
: Es el nombre único que se le da a la interfaz.Modificador
: Puede serpublic
ointernal
para definir el nivel de acceso de la interfaz.tipoDeDato
: Especifica el tipo de datos de las propiedades y métodos.NombreDelMetodo
,NombreDeLaPropiedad
: Son los identificadores únicos de los métodos, propiedades y eventos respectivamente.parametros
: Son las variables que se utilizan para pasar información al método cuando se llama.
Implementación de Interfaces
Para implementar un interfaz en una clase, se utiliza la sintaxis de dos puntos (:
) seguida del nombre del interfaz. La clase debe proporcionar implementaciones para todos los miembros definidos en el interfaz.
Aquí hay un ejemplo de cómo definir e implementar una interfaz en C#:
public interface IConducible
{
string Matricula { get; set; }
// Métodos
void Conducir();
void Frenar();
}
public class Coche : IConducible
{
// Implementación de propiedades
public string Matricula { get; set; }
// Implementación de métodos
public void Conducir()
{
Console.WriteLine("El coche está en marcha.");
}
public void Frenar()
{
Console.WriteLine("El coche se ha detenido.");
}
}
En este ejemplo:
- Se define una interfaz
IVehiculo
con una propiedad (Matricula
) y dos métodos (Conducir
yFrenar
). - La clase
Coche
implementa la interfazIVehiculo
y proporciona la implementación de todas sus propiedades y métodos.
Polimorfismo con interfaces
Una de las características más importantes de los interfaces es su capacidad para soportar el polimorfismo. Esto permite que una instancia de una clase que implementa un interfaz sea tratada como una instancia de ese interfaz.
Supongamos que tengamos otra clase que implementa IConducible
llamara Bicicleta
public class Bicicleta : IConducible
{
// implementación
}
Ahora podemos definir una variable de tipo IConducible
, y asignar variables de tipo Coche
o Bicicleta
.
IConducible vehiculo;
vehiculo = new Coche();
vehiculo.Arrancar(); // Salida: El coche ha arrancado.
vehiculo.Detener(); // Salida: El coche se ha detenido.
vehiculo = new Bicicleta();
vehiculo.Arrancar(); // Salida: La bicicleta ha comenzado a moverse.
vehiculo.Detener(); // Salida: La bicicleta se ha detenido.
Implementar múltiples interfaces
C# no soporta la herencia múltiple directa (una clase derivada de múltiples clases base). Sin embargo, una clase puede implementar múltiples interfaces, lo que proporciona una forma de lograr un comportamientos similar a la herencia múltiple.
Por ejemplo, en este ejemplo, la clase Pato
implementa los interfaces IVolador
e INadador
.
public interface IVolador
{
void Volar();
}
public interface INadador
{
void Nadar();
}
public class Pato : IVolador, INadador
{
public void Volar()
{
Console.WriteLine("El pato está volando.");
}
public void Nadar()
{
Console.WriteLine("El pato está nadando.");
}
}
Implementación explícita
C# permite la implementación explícita de miembros de interfaces. Esto es útil cuando una clase implementa múltiples interfaces que pueden tener métodos con el mismo nombre, o cuando se desea proporcionar implementaciones específicas que no sean accesibles directamente a través de la clase.
En este ejemplo, la clase Multifuncional
implementa los interfaces IImprimible
e IEscaneable
. Pero ambos interface declaran un método Imprimir()
. Podemos declarar explícitamente los interfaces para resolver el conflicto de nombres.
public interface IImprimible
{
void Imprimir();
}
public interface IEscaneable
{
void Imprimir();
}
public class Multifuncional : IImprimible, IEscaneable
{
void IImprimible.Imprimir()
{
Console.WriteLine("Imprimiendo...");
}
void IEscaneable.Imprimir()
{
Console.WriteLine("Escaneando...");
}
}
// Uso
IImprimible impresora = new Multifuncional();
impresora.Imprimir(); // Salida: Imprimiendo...
IEscaneable escaner = new Multifuncional();
escaner.Imprimir(); // Salida: Escaneando...
Ejemplos prácticos
Representación de un dispositivo electrónico
Esta interfaz IEncendible
define los métodos que un dispositivo electrónico debe tener. La clase Telefono
implementa esta interfaz:
public interface IEncendible
{
// Métodos
void Encender();
void Apagar();
void Reiniciar();
}
public class Telefono : IEncendible
{
// Implementación de métodos
public void Encender()
{
Console.WriteLine("El teléfono se está encendiendo.");
}
public void Apagar()
{
Console.WriteLine("El teléfono se está apagando.");
}
public void Reiniciar()
{
Console.WriteLine("El teléfono se está reiniciando.");
}
}
Comportamiento de Comunicación
Esta interfaz IComunicador
define los métodos que un dispositivo de comunicación debe tener. La clase Telefono
implementa esta interfaz, mientras que mantiene IEndendible
public interface IComunicador
{
// Métodos
void Llamar(string numero);
void EnviarMensaje(string numero, string mensaje);
}
public class Telefono : IComunicador, IEncendible
{
// ... codigo de IEncendible del ejemplo anterior ... //
// Implementación de métodos IComunicador
public void Llamar(string numero)
{
Console.WriteLine($"Llamando al número {numero}.");
}
public void EnviarMensaje(string numero, string mensaje)
{
Console.WriteLine($"Enviando mensaje al número {numero}: {mensaje}");
}
}
Comportamiento de Pagos
Esta interfaz IPagos
define los métodos que un sistema de pagos debe tener. La clase PagoElectronico
implementa esta interfaz:
public interface IPagos
{
// Métodos
void ProcesarPago(decimal monto);
void ReembolsarPago(decimal monto);
}
public class PagoElectronico : IPagos
{
// Implementación de métodos
public void ProcesarPago(decimal monto)
{
Console.WriteLine($"Procesando pago de {monto}.");
}
public void ReembolsarPago(decimal monto)
{
Console.WriteLine($"Reembolsando pago de {monto}.");
}
}