Herencia en C#. Concepto y ejemplos

Como todo lenguaje de programación actual, C# es un lenguaje orientado a objetos y soporta todas las características propias del paradigma de programación orientada a objetos: encapsulación, herencia y polimorfismo.

En este post trataré de explicar de la forma más sencilla posible, lo que es la herencia en programación, y pondré algunos ejemplos al final para ver si se llevan la idea, aunque seguro se quedan con algunas dudas, ya que es un concepto fácil de entender, pero difícil de aplicar en programación… después hablaremos entonces de lo que es la encapsulación y el polimorfismo

Por definición, la herencia no es más que la capacidad de un objeto de heredar las características de otro. Bueno, en programación, la herencia es la capacidad de una clase de heredar los métodos, las variables y las propiedades de otra (los constructores no se heredan). Esto permite ahorrar código, ya que varias funcionalidades no tendríamos que implementarlas nuevamente.

Una clase que herede de otra, puede usar los métodos, las propiedades o las variables de la clase padre. También se puede redefinir o modificar los métodos y propiedades, usando algunas palabras reservadas para esto, creando así un nuevo comportamiento del objeto. Una condición necesaria para que una clase herede de otra, es que la clase hija (la que hereda), debe poder usarse donde se use la clase padre (de la cual va a heredar). Si hay al menos un caso donde se puede usar la clase padre, y no se puede usar la clase hija, la herencia no tiene sentido.

En C#, una clase solo puede heredar de otra (por algunas razones difíciles de explicar). O sea, una clase no puede heredar de varias clases a la vez. Para que una clase herede de otra nada más hay que ponerle ‘:‘ después de su declaración, y seguido poner el nombre de la clase de la que se quiere heredar.

Ejemplo:

class Circulo: Figura {     // Implementación de la clase }

Si una clase hija tiene un constructor que recibe los mismos parámetros que un constructor de la clase padre, y este constructor cumple las mismas funciones, que en la clase padre, el de la clase padre puede ser llamado desde la clase hija poniendo después de la declaración del constructor en la clase hija : y después la palabra reservada base. Dentro de los paréntesis van los parámetros del constructor base, (también veremos un ejemplo).

También es importante saber que si una clase hereda de otra, que a su vez hereda de otra, esta clase hereda también de la clase más arriba.

Por ejemplo, si un cuadrilátero es una figura y un paralelogramo es un cuadrilátero, entonces un paralelogramo es una figura…

Para que una clase padre permita que uno de sus métodos sea redefinido por sus clases herederas (las que heredan de ella) este método debe ser declarado usando la palabra reservada virtual, y cuando la clase hija vaya a redefinirlo, debe declararlo usando la palabra reservada override.

Ejemplo:

public <strong>virtualstrong> void Método() //declaración del método en la clase Padre { //aquí va el codigo }   public override void Método() //declaración del método en la clase Hijo { //nuevas instrucciones }

Si una clase hijo quiere redefinir un método de una clase padre, y este no fue declaradovirtual en la clase padre, entonces hay que poner la palabra reservada new en la declaración del método.

Ejemplo:

public void Método() //declaración del método en la clase Padre {    //aquí va el codigo }   public new void Método() //declaración del método en la clase Hijo {    //nuevas instrucciones }

Ejemplo de herencia:

public class Hijo:Padre {   //la clase Hijo hereda de la clase Padre public Hijo(int n):base(n){} }

El constructor de la clase Hijo que recibe como parámetros un entero llama al constructor de la clase Padre que recibe un entero pasándoselo como parámetro.

Ahora veremos un ejemplo real donde se vea la importancia de este importante mecanismo. Imaginen, que queremos tener algunas figuras geométricas, poder calcular el area, perimetro, moverlas en un plano, etc. Pero nos damos cuenta enseguida, que todas las figuras tienen area y perímetro, solo que se calculan de diferentes formas. Todas se pueden ocultar, mostrar y mover de igual forma, no? Veamos ya el código, para que sigan esta idea:

Antes de pasar al código, hay que definir que una jerarquía de clases es un grupo de clases, que heredan unas de otras, donde existe una clase base de la cual heredan todos los integrantes de la jerarquía, en este caso, la clase base es la clase figura.

//Declaramos la clase padre, de la que todas las figuras heredarán //Es abstracta porque tendrá algunos metodos abstractos   public abstract class Figura { //Usamos protected, para que solo tengan acceso //a estas variables, las clases que heredan de ella protected int x,y; protected Control control; protected Pen myPen; protected bool visible;   //Un constructor por defecto para todas las figuras public Figura(int x, int y, Color color, Control control) { //Validar parametros this.x = x; this.y = y; this.control = control; myPen = new Pen(color,4);   } public abstract void Muestra(); public abstract int Area(); public virtual void Oculta() { Color temp = myPen.Color; myPen.Color = control.BackColor; Muestra(); myPen.Color = temp; visible = false; } public virtual void Traslada(int plusX, int plusY) {    if(visible)    {       Oculta();       x += plusX;       y += plusY;       Muestra();    }    else    {       x += plusX;       y += plusY;    }

Ahora veremos el código de otras dos figuras en concreto que heredarán de la clase figura, un circulo y un rectángulo.

public class Circulo:Figura { //Vemos que en esta clase solo hay que declarar //una variable protected int radio; //Este constructor tendrá todos los parámetros //por defecto y un radio porque es un circulo public Circulo(int x, int y, Color miColor, Control miControl,  int radio) :base(x,y,miColor,miControl) {    //Validacion    this.radio = radio; } //Ahora hay que programar como se mostrará la figura public override void Muestra() {    Graphics g = control.CreateGraphics();    g.DrawEllipse(myPen,x-radio,y-radio,radio*2,radio*2);    visible = true; }   //Decimos como se calcula el area en este caso public override int Area() {    return Math.PI * Math.PI * radio; }   //Le podemos añadir otro método independiente public int Perimetro() {     return 2 * Math.PI * radio; } }   //Esta clase también heredará de figura public class Rectangulo:Figura {    protected int ancho,alto;   public Rectangulo(int x, int y, Color miColor, Control miControl, int ancho, int alto) :base(x,y,miColor,miControl) {    //Validar    this.ancho = ancho;    this.alto = alto; } //Redefinimos como mostrar la figura public override void Muestra() {    Graphics g = control.CreateGraphics();    g.DrawRectangle(myPen,x,y,ancho,alto);    visible = true; } //Redefinimos como calcular el area public override int Area() {    return alto * ancho; } }

Bueno, hasta aquí este pequeño tutorial sobre herencia en C#, próximamente estaremos hablando sobre polimorfismo, y después de encapsulación. Cualquier duda en los comentarios. Hasta la próxima