Interfaces y Herencia

Las Interfaces son una forma especial de una clase, aunque la diferencia principal con las clases es que las interfaces no contienen código ejecutable, solo definen los miembros y en el caso de los métodos solo indican si reciben parámetros y de que tipo son.

La interfaz es como un contrato, el papel que juegan es el de solo indicar que es lo que una clase o estructura debe implementar.

Cuando una clase implementa una interfaz está firmando un contrato con el que se compromete a definir todos los miembros que la clase define, de hecho el propio compilador nos obliga a hacerlo.

El siguiente Ejemplo es una aplicación de consola realizada con el Visual Studio 2008 y se mostrará como usar las interfaces de .Net:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  

   6:  namespace Interfaces

   7:  {

   8:      class Program

   9:      {

  10:          static void Main(string[] args)

  11:          {

  12:              Persona objPersona = new Persona();

  13:              objPersona.Mostrar();

  14:              IMiInterface i = objPersona;

  15:              i.Mostrar();

  16:              CaractPersona c = objPersona;

  17:              c.Apellido = "Nuevo Apellido";

  18:  

  19:              objPersona.Mostrar();

  20:              Console.WriteLine(c.ToString());

  21:          }

  22:      }

  23:  

Lo que se muestra hasta aqui es la Clase Program que contiene el método Main, en esta se crea un objeto objPersona, dos variables i y c; del tipo Persona, IMiInterface y CaractPersona respectivamente que se definiran mas adelante.

En la línea 13 y 15 se utiliza el método Mostrar para mostrar por pantalla el Nombre y Apellido de una Persona, y en la línea 20 se utiliza el método ToString como otra forma de mostrar el Apellido y Nombre de la Persona usando los conceptos de Polimorfismo.

La salida es la siguiente:

Ahora veamos la declaración de las Clases e Interfaces, primero definimos una interface IMiInterface, que define los métodos y propiedades, junto con sus métodos get y set, que deberán utilizar las Clases que implementen dicha Interfaz.

Luego definimos una clase CaracPersona en donde definimos la Propiedad Apellido con sus correspondiente get y set.

Cuando hablamos de propiedades el método get devuelve un valor y el método set asigna un valor al atributo, debido a que los atributos son declarados privados y se acceden a ellos a través de métodos.

Luego se define la clase Persona que heredará de la clase CaracPersona e implentará la Interface IMiInterface, es decir se suscribe al contrato de la Interface mencionada. Si en esta clase no coloco todos los métodos que figuran en la Interface el compilador me mostrará error. Por lo tanto esta clase está obligada a implementar todo lo que implemente la interface.

En la línea 47 se muestra como a la Clase Persona se le hace heredar de la Clase y la Interfaz, se debe tener en cuenta el orden en que esto se coloca, sino nos dará error, primero se debe poner que se hereda de las clases y despues de la interface.

Luego se define las propiedades con sus métodos get y set correspondientes. Tambien se define el método Mostrar que tiene la función de imprimir por pantalla y se usa el método ToString definido en la clase Object, que es la clase por defecto que heredan todas las Clases, y se le puede sobreescribir haciendo que imprima el Apellido y Nombre de la Persona.

  24:      interface IMiInterface

  25:      {

  26:          void Mostrar();

  27:          string Nombre { get; set; }

  28:          int Edad { get; }

  29:      }

  30:  

  31:      public class CaractPersona

  32:      {

  33:          private string _Apellido = "Castillo";

  34:          public string Apellido

  35:          {

  36:              get

  37:              {

  38:                  return _Apellido;

  39:              }

  40:              set

  41:              {

  42:                  _Apellido = value;

  43:              }

  44:          }

  45:      }

  46:  

  47:      public class Persona : CaractPersona, IMiInterface

  48:      {

  49:          private string _Nombre = "César";

  50:          public string Nombre

  51:          {

  52:              get

  53:              {

  54:                  return _Nombre;

  55:              }

  56:              set

  57:              {

  58:                  _Nombre = value;

  59:              }

  60:          }       

  61:          

  62:          private int _Edad = 20;

  63:          public int Edad

  64:          {

  65:              get

  66:              {

  67:                  return _Edad;

  68:              }

  69:          }

  70:  

  71:          public void Mostrar()

  72:          {

  73:              Console.WriteLine(Nombre + " " +Apellido);

  74:          }

  75:  

  76:          public override string ToString()

  77:          {

  78:              return Apellido + " " + Nombre;

  79:          }

  80:      }

  81:  }

De esta forma definimos una estructura de clases utilizando Interfaces, espero comentarios y que el ejemplo sirva.