C# / Interface

Bienvenidos sean a este post, ya hemos visto en algunos posts anteriores que son las clases y objetos pero hoy nos centraremos en una clase particular llamada interface.

La interfaz (interface) es una clase abstracta ya que esta poseera solamente las declaraciones de metodos y propiedades, es decir solamente los nombres de los mismos, esto en otros lenguajes tambien se lo denomina prototipos, veamos un ejemplo de como es la sintaxis de la interfaz y como se la arma:

interface nombre
{
... prototipos ...
}

Es muy parecido a cuando definimos una clase, llevado a la practica se veria asi:

interface IAnimal
{
	string Hablar();
	void Correr();
}

En este caso creamos una interface llamada IAnimal donde tendra una propiedad y dos metodos, observen que solamente los declaramos pero no estan implementados, esto es debido a que su implementacion se hace a traves de otras clases y al igual como sucedia con herencia recibiran a esta interfaz, veamos algunos tips de las interfaces:

• Es una buena practica comenzar los nombres con la I para identificar que es una interfaz, esto tambien es una convencion entre programadores y lo veran asi pero no es obligatorio
• Las interfaces de manera predeterminada son abstractas (abstract) y publicas (public) pero se puede modificar el tipo de acceso que tendra pero siempre seran abstractas
• Las interfaces pueden contener metodos y propiedades pero no campos, es decir variables
• Las interfaces no pueden ser instanciadas por eso se deben crear clases que las implementen

Para entender mejor este concepto vamos a hacer el siguiente ejemplo:

interfaz.cs

using System;
using System.Collections.Generic;

interface IAnimal
{
	string Hablar(string m);
	void Correr();
}

class Perro: IAnimal
{
	string nombre;
	public Perro(string n)
	{
		nombre = n;
	}

	public string Hablar(string mensaje)
	{
		return nombre + " dice " + mensaje;
	}

	public void Correr()
	{
		Console.WriteLine(nombre + " corre!!!");
	}
}

public class Program
{
	static int Main()
	{
		Perro fido = new Perro("Fido");
		fido.Correr();
		Console.WriteLine(fido.Hablar("Guau!!"));
		return 0;
	}
}

Nota: Recuerden que la buena practica recomienda utilizar archivos separados pero aca lo hacemos por practicidad.

Para este codigo tendremos una interfaz llamada IAnimal donde le definiremos dos metodos, uno llamado Hablar que recibira un dato y otro llamado Correr, en ambos casos solo declaramos los metodos y no lo definimos, pasemos al siguiente bloque:

class Perro: IAnimal
{
	string nombre;
	public Perro(string n)
	{
		nombre = n;
	}

	public string Hablar(string mensaje)
	{
		return nombre + " dice " + mensaje;
	}

	public void Correr()
	{
		Console.WriteLine(nombre + " corre!!!");
	}
}

En este caso tendremos una clase llamada Perro, a la cual usaremos para implementar la interfaz antes declarada, a la hora de implementarlo se usa de la misma forma que en herencia, la diferencia va a estar en el cuerpo, ya que en lugar de tener que sobreescribirlo (override) tendremos que si o si definir los metodos, en este post explico herencia y override.

Para esta clase primero definiremos una variable llamada nombre y luego un nuevo contructor donde recibiremos un dato para asignarselo a nombre, despues nos encargaremos de definir los metodos de la interfaz, en el primer caso usamos a Hablar, recuerdan cuando hablamos de sobrecarga que el nombre de las variables en los argumentos no identifican a la funcion sino el tipo de las mismas como vimos en este post, por ende mientras la que definamos sea string puede llevar el nombre que sea, luego le hacemos devolver el nombre con el valor de mensaje, nuestro siguiente metodo solo se encarga de mostrar en pantalla que el valor asignado a nombre corre, veamos el siguiente bloque:

public class Program
{
	static int Main()
	{
		Perro fido = new Perro("Fido");
		fido.Correr();
		Console.WriteLine(fido.Hablar("Guau!!"));
		return 0;
	}
}

Este sera el bloque se encargara de ejecutar el programa, ya que contendra al Main, donde primero crearemos un objeto de la clase Perro al cual llamaremos fido, luego le pediremos a este objeto que ejecute Correr, para despues usar el metodo Hablar donde le pasaremos lo que debe decir, compilemos y veamos su salida:

C:\Users\tinchicus\Documents\Visual Studio 2019>interfaz.exe
Fido corre!!!
Fido dice Guau!!

C:\Users\tinchicus\Documents\Visual Studio 2019>

Como podemos observar nos funciono correctamente, si se preguntan para que puede servir esto? Es para poder crear una estructura de clases con metodos para luego ser definidas de la manera que creamos mas correcta, sin tener la necesidad de tener que andar sobreescribiendo ningun otro metodo.

Al igual que Java, C# no soporta herencias multiples es decir que solamente trabaja con una clase base pero si podemos utilizar multiples interfaces y que sean implementadas por una sola clase, modifiquemos el ejemplo anterior de la siguiente forma:

using System;
using System.Collections.Generic;

interface IAnimal
{
	string Hablar(string m);
	void Correr();
}

interface IMamifero
{
	void Dormir();
	void Comer();
}

class Perro: IAnimal, IMamifero
{
	string nombre;
	public Perro(string n)
	{
		nombre = n;
	}

	public string Hablar(string mensaje)
	{
		return nombre + " dice " + mensaje;
	}

	public void Correr()
	{
		Console.WriteLine(nombre + " corre!!!");
	}

	public void Dormir()
	{
		Console.WriteLine(nombre + " esta durmiendo...Zzzz");
	}

	public void Comer()
	{
		Console.WriteLine(nombre + " esta comiendo");
	}

}

public class Program
{
	static int Main()
	{
		Perro fido = new Perro("Fido");
		fido.Correr();
		Console.WriteLine(fido.Hablar("Guau!!"));
		fido.Dormir();
		fido.Comer();
		return 0;
	}
}

En este nuevo codigo hicimos unas pocas modificaciones, la primera fue agregar esta interfaz:

interface IMamifero
{
	void Dormir();
	void Comer();
}

Nuestra siguiente modificacion fue al momento de crear a Perro:

class Perro: IAnimal, IMamifero

En esta linea simplemente agregamos por medio de una coma la nueva interfaz que implementaremos, tambien dentro del cuerpo de la clase definimos los metodos de la nueva interfaz, con esto solo nos resta una modificacion mas como es llamar a los nuevos metodos por medio del objeto fido, con todas estas modificaciones realizadas podemos compilar y probar:

C:\Users\tinchicus\Documents\Visual Studio 2019>interfaz.exe
Fido corre!!!
Fido dice Guau!!
Fido esta durmiendo...Zzzz
Fido esta comiendo

C:\Users\tinchicus\Documents\Visual Studio 2019>

Para ir cerrando el tema vamos a decir que las interfaces tienen las siguientes caracteristicas:

• Las interfaces no pueden crear objetos
• Podemos declarar metodos y propiedades pero no variables
• Se pueden «heredar» multiples interfaces en una clase
• Lo anterior cubre a la herencia multiple que no posee C#
• Todas las interfaces son abstract y public de manera predeterminada
• Por ende los miembros de la misma tambien
• Estas no poseen constructores
• Brinda mayor seguridad porque oculta ciertos detalles y solo muestra detalles importantes de la misma

Nota: La herencia multiple es lo que en C o C++ se llama Polimorfismo.

En resumen, hoy hemos visto que es la interface o interfaz, que es, para que se usa, como es su sintaxis, como se implementa, que beneficios nos trae su manejo, un ejemplo practico, como nos ayuda a suplantar las herencias multiples, y otras caracteristicas mas, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.