El uso de interfaces

By Valeriano Tortola28. agosto 2007 12:12

ltimamente me estoy viendo ms en la necesidad de usar interfaces y genricos para crear clases
ms reusables y tipadas. En mis inicios con C# y .NET... aunque la idea de los genricos me gust...
a las interfaces ... no les veia demasiada utilidad. A da de hoy soy consciente de la tremenda
simbiosis que tienen estos dos elementos para crear cdigo reusable.
Una interfaz, es como la carcasa que envuelve a un dispositivo, la carcasa no tiene funcionalidad
en si, pero representa la funcionalidad que que tiene el dispositivo que en ella encaja (pensad en
un acople funcional y no fsico :P).
Por ejemplo, la carcasa de un mvil tiene (entre otras cosas) un agujero para un micrfono, otro
para el altavoz, un teclado y una pantalla, define entonces la funcionalidad de un dispositivo con el
que se puede hablar, escuchar, escribir y ver. Al acoplar a la carcasa el dispositivo mvil,
podrmos llamar y enviar SMSs a travs de estos elementos en dicho dispositivo mvil, pero, si
tuviesemos una PDA que tuviese definidas las funcionalidades de hablar, escuchar, escribir y ver ...
podramos acoplarla a esta carcasa y utilizar dichas funcionalidades con ella tambin, es ms, si el
fabricante sacase posteriormente un nuevo dispositivo con las mismas funcionalidades podramos
acoplarlo y usarlo sin tener que actualizar nuestra carcasa, y si sacase uno con ms
funcionalidades (por ejemplo una cmara) pero tampoco quisisemos actualizarla... podramos
usarlo tambin pero solo las funcionalidades que expone la nuestra, quedando el resto
ocultas. Exacto, nos brinda una funcionalidad similar a la abstracin de clases, pero con ventajas
adicionales, como que esa PDA podra al mismo tiempo tener definidas funcionaliades para
acoplarse a otras carcasas, como a la de dispositivo GPS, a la de dispositivo de pantalla tctil ...
incluso a una super-carcasa que fuese la suma de todas las dems.
Una interfaz:

Es un contrato que asegura que la instancia que la implementa tiene definidos una serie
de mtodos y propiedades.
Es como una clase abstracta pero donde todos sus miembros son abstractos y pblicos.
No tiene campos porque no puede tener ningn tipo de estado, nicamente se pueden
definir propiedades.
No tiene implementacin, solo las definiciones de los mtodos.
No puede heredar de una clase, pero si de una de mltiples interfaces (multiherencia).
No tiene ni constructores ni destructores.
Pueden ser especializadas por estructuras.

Una interfaz se declara:

interface IMovil
{
// Propiedades de
Botones Teclado {
Microfono Micro {
Altavoz Auricular

solo lectura
get;}
get;}
{ get;}

// Propiedades de lectura/escritura

ManosLibres MLBluethoot { get; set;}

// Metodos
void Hablar(Stream Voz);
Stream Oir();
void Teclear(char pulsacion);
}

Y se implementa como la herencia:

class NokiaN70 : IMovil
{
public Botones Teclado
{
}
public Microfono Micro
{
}
public Altavoz Auricular
{
}
public ManosLibres MLBluethoot
{
get
{
}
set
{
}
}
public void Hablar(Stream Voz)
{
}
public Stream Oir()
{
}
public void Teclear(char pulsacion)
{
}
}

Para implementar varias se separan por comas:

interface IMovil3G
{
void EnviarDatos(byte[] Datos);
byte[] RecibirDatos();

class NokiaN70 : IMovil, IMovil3G

{
public Botones Teclado
{
}
public Microfono Micro
{
}
public Altavoz Auricular
{
}
public ManosLibres MLBluethoot
{
get
{
}
set
{
}
}
public void Hablar(Stream Voz)
{
}
public Stream Oir()
{
}
public void Teclear(char pulsacion)
{
}
public void EnviarDatos(byte[] Datos)
{
}
public byte[] RecibirDatos()
{
}
}

A una variable de tipo interfaz se le puede asignar una instancia que cumpla dicha interfaz y usar
los mtodos y propiedades definidos por ella.
NokiaN70 MiMovil = new NokiaN70();
byte[] b1 = MiMovil.RecibirDatos();
IMovil im = MiMovil;
im.Teclear('K');
byte[] b2 = im.RecibirDatos(); // Error de compilacin

Se puede comprobar si una instancia cumple una interfaz con el operador 'is':
object MiMovil = new NokiaN70();
if (MiMovil is IMovil3G)
{
IMovil3G im3g = MiMovil;
byte[] b =im3g.RecibirDatos();
}

No hay ambiguedad en la implementacin de una interfaz, es decir, si dos interfaces definen un

mtodo del mismo nombre y firma no hay ambiguedad, pues simplemente se esta requiriendo
que la instancia tenga ese mtodo definido:
interface INavegadorGPS
{
PantallaTactil Pantalla { get;}
Stream Oir();
}
class NokiaN70 : IMovil, INavegadorGPS
{
public Botones Teclado
{
}
public Microfono Micro
{
}
public Altavoz Auricular
{
}
public ManosLibres MLBluethoot
{
get
{
}
set
{
}
}
public void Hablar(Stream Voz)
{
}
public Stream Oir()
{
}
public void Teclear(char pulsacion)
{
}
// Solo se implementa este miembro, ya que ya existe un Oir()
public PantallaTactil Pantalla
{
}
}

Si la posible ambiguedad es en una reimplementacin, pervalece el miembro de la interfaz

derivada, aunque Visual Studio producir un 'Warning' para que le pongamos el operador 'new',
pero simplemente es indicatorio:
class NokiaN70v2 : NokiaN70, INavegadorGPS
{
new PantallaTactil Pantalla
{
}
new Stream Oir()
{
}
}

Al implementar la interfaz, es posible declarar miembros de forma explcita, esto es, que solo
sern accesibles si usamos la instancia a travs de una variable de ese tipo de interfaz, no desde el
tipo derivado:
class NokiaN70 : INavegadorGPS
{
// Miembro declarado explicitamente
Stream INavegadorGPS.Oir()
{
}
// Miembro delcarado normalmente
public PantallaTactil Pantalla
{
}
}
class Program
{
static void Main(string[] args)
{
NokiaN70 M = new NokiaN70();
Console.WriteLine(M.Pantalla.ToString());
// Asi no
Console.WriteLine(M.Oir().ToString());
// Asi si
INavegadorGPS gps = M;
Console.WriteLine(gps.Oir().ToString());
}
}

Tambin se pueden usar para enmascarar instancias, ocultando los miembros que no queramos
mostrar:
class NokiaN70 : INavegadorGPS, IMovil3G, IMovil
{
// Implementacin obviada.
static public INavegadorGPS GetGPS()
{
return new NokiaN70();
}
}
class Program
{
static void Main(string[] args)
{
INavegadorGPS gps = NokiaN70.GetGPS();
gps.Oir();
// Error
gps.Teclear('K');
}
}

Espero haber sido medianamente claro :P En un prximo artculo hablar de los genricos y como
con las interfaces podemos hacer an ms tipados nuestras clases y mtodos genricos.