Curso C# con Mono – Interfaces

Si la última vez que hablamos de C#, estuvimos comentando la herencia, hoy hablaremos de las interfaces.

Interfaces en lenguajes de programación orientados a objetos

Todos conoceréis las interfaces gráficas de usuario. Son el mecanismo software que nos permite interactuar de manera más o menos intuitiva con unas funcionalidades que nos provee el programa. Es decir, es un mecanismo de comunicar distintos niveles, ocultando los detalles de la implementación.

Eso mismo son las interfaces en lenguajes de programación orientados a objetos como son C# o Java. Se trata de un conjunto de métodos, delegados o eventos, que no tienen implementación. El desarrollo de la funcionalidad de los mismos, se hace en la clase que implementa la interfaz. Es un concepto similar a los prototipos de funciones en lenguajes como C.

Declaración

Siguiendo con el ejemplo de los motores, comentado en la entrega anterior dedicada a la herencia, vamos a crear un interfaz IMotor, a la que luego haremos referencia desde la implementación de la clase. He incluido un método más para que se vean más claras las posibilidades.

interface IMotor
{
 // declaración de propiedades
 int Potencia
 {
        get;
        set;
  }
 decimal Par
   {
        get;
        set;
    }

 // declaración de métodos
 void printInfo();
 // declaración de eventos
}
public class Motor : IMotor
{
 int potencia;
 decimal par;
 public int Potencia {
  get { return this.potencia; }
  set { potencia = value; }
 }
 public decimal Par {
  get { return this.par; }
  set { par = value; }
 }
 public void printInfo()
 {
  Console.WriteLine("La potencia es " + Potencia.ToString() + "
                y el par: " + Par.ToString());
 }
}

Como podéis apreciar, la declaración de los interfaces es muy similar a la de una clase, incluyendo la palabra clave Interface. La llamada al interfaz desde la clase que lo implementa se realiza como si de una herencia se tratara.

Los interfaces también soportan herencia por si mismos. El único detalle a recordar, es que en caso de conflicto por duplicidad de nombres (un interfaz hereda de otros interfaces en los que hay un método con el mismo nombre en los dos), hay que hacer referencia explícita a cuál se está llamando:

• interfazA.método()
• interfazB.método()

¿Para qué sirven?

Más que para qué sirven voy a comentar para qué los uso en mis desarrollos. Aunque para clases pequeñas no tenga mucho sentido hacerlo, cuando los objetos cogen cierto tamaño, las interfaces facilitan enormemente la comprobación de errores. Por ejemplo, si se nos ha olvidado definir un método o si hay conflictos de tipos de datos, el compilador nos avisa. Recordad lo cómodo e inmediato que es declarar interfaces, en lugar de las clases directamente, con todo el desarrollo que conlleva.

Al fin y al cabo, es otra forma más de crear un mayor grado de abstracción y poder explotar mejor las posibilidades que nos ofrecen la orientación a objetos.

Entregas anteriores

• Curso C# con Mono – Tratamiento de excepciones
• Curso C# con Mono – Conversión de tipos e información cultural
• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!
• Curso C# con Mono – Interfaces