Herencia.
Es un pilar del paradigma orientado a objetos que tiene como
fin reutilizar componentes entre clases, como también tener una mejor
clasificación de objetos y así poder representar en código una parte del mundo
real.
Les dejo un link donde pueden leer una definición mucho mas
completa de lo que es la herencia:
El
objetivo de este post es representar los conceptos básicos de la herencia a través
del código de una manera digerible y simple
Comencemos:
Implementación de herencia.
public class BaseClass
{
public BaseClass()
{
Console.WriteLine("No message of my BaseClass");
}
public
BaseClass(string valueOfBaseClass)
{
Console.WriteLine("Constructor of BaseClass with value: {0}",
valueOfBaseClass);
}
public void MyBaseMethod()
{
Console.WriteLine("my method of my base class");
}
}
En este ejemplo creamos una clase base, como pueden
notar, no es una clase abstracta, este tópico se explicara más adelante.
Como podrán observar, esta clase tiene dos
constructores, uno con parámetro y el otro sin parámetros, esto es con el fin
de identificar ciertas propiedades de herencia al momento de trabajar con este
pilar de la programación orientada a objetos.
Tenemos un método público, no es ni virtual ni
abstract, esto también se explicara más adelante.
Esto con el fin de hacer más didáctico el ejemplo.
Ahora construiremos una clase concreta que herede
las características de nuestra clase anterior.
public
class ConcreteClass:BaseClass
{
public
ConcreteClass()
{
Console.WriteLine("No message of my ConcreteClass");
}
public
ConcreteClass(string valueOfConcreteClass)
{
Console.WriteLine("Constructor of ConcreteClass with value: {0}",
valueOfConcreteClass);
}
public
ConcreteClass(string valueOfConcreteClass, string valueOfBaseClass):base(valueOfBaseClass)
{
Console.WriteLine("Constructor of ConcreteClass with value: {0}",
valueOfConcreteClass);
}
public void MyConcreteMethod()
{
Console.WriteLine("My method of my concrete class");
}
}
Como verán, la diferencia entre saber aplicar herencia o no
saber, está a dos puntos de distancia
La sintaxis es la siguiente:
public class ConcreteClass:BaseClass
{
}
A diferencia de la clase anterior, aquí tenemos 3
constructores:
Uno sin parámetros, uno con dos parámetros y otro con solo
un parámetro.
Con la herencia, podemos mandar parámetros directamente al
constructor base de nuestra clase base, con el fin de que cumpla funcionamiento
especifico.
Para pasar argumentos, es necesario usar la palabra
reservada base, como esta en el constructor que toma dos parámetros:
public ConcreteClass(string
valueOfConcreteClass, string valueOfBaseClass):base(valueOfBaseClass)
La clase concreta tiene un metodo que solo ella puede
utilisar, pero la diferencia es que nuestra clase concreta puede usar todos los
metodos publicos, propiedades y los atributos (que esten como protected o
internal) de una clase base.
Ahora veamos la implementación de nuestras clases.
using
System;
namespace
herenciaYpolimorfismo
{
using
System.Threading;
class Program
{
static void Main(string[]
args)
{
ConcreteClass
myConcreteClass = new ConcreteClass();
Console.ReadKey();
ConcreteClass
myConcreteClass2 = new ConcreteClass("My Message For My Concrete Class");
Console.ReadKey();
ConcreteClass
myConcreteClass3 = new ConcreteClass("My Message For My ConcreteClass", "My message for my base class");
Console.ReadKey();
myConcreteClass.MyBaseMethod();
myConcreteClass.MyConcreteMethod();
Console.ReadKey();
}
}
}
Al hacer una instancia de una clase concreta, lo primero que
se va a instanciar es la clase base, lo podrán ver a continuación.
pueden ver tambien este post sobre los objetos y su instancia a una clase:
Ya por ultimo les dejo todo el código complete para que lo
puedan correr en sus máquinas y les puedan quedar más claros los conceptos.
using System;
namespace
herenciaYpolimorfismo
{
using System.Threading;
class Program
{
static void Main(string[] args)
{
ConcreteClass myConcreteClass = new
ConcreteClass();
Console.ReadKey();
Console.WriteLine("-----------------------------------------------------------");
ConcreteClass myConcreteClass2 = new
ConcreteClass("My Message For My Concrete
Class");
Console.ReadKey();
Console.WriteLine("-----------------------------------------------------------");
ConcreteClass myConcreteClass3 = new
ConcreteClass("My Message For My
ConcreteClass", "My message for my
base class");
Console.ReadKey();
Console.WriteLine("-----------------------------------------------------------");
myConcreteClass.MyBaseMethod();
myConcreteClass.MyConcreteMethod();
Console.WriteLine("-----------------------------------------------------------");
Console.ReadKey();
}
}
}
public class BaseClass
{
public BaseClass()
{
Console.WriteLine("No
message of my BaseClass");
}
public BaseClass(string
valueOfBaseClass)
{
Console.WriteLine("Constructor
of BaseClass with value: {0}", valueOfBaseClass);
}
public void
MyBaseMethod()
{
Console.WriteLine("my
method of my base class");
}
}
public class ConcreteClass:BaseClass
{
public ConcreteClass()
{
Console.WriteLine("No
message of my ConcreteClass");
}
public ConcreteClass(string
valueOfConcreteClass)
{
Console.WriteLine("Constructor
of ConcreteClass with value: {0}", valueOfConcreteClass);
}
public ConcreteClass(string
valueOfConcreteClass, string valueOfBaseClass):base(valueOfBaseClass)
{
Console.WriteLine("Constructor
of ConcreteClass with value: {0}", valueOfConcreteClass);
}
public void
MyConcreteMethod()
{
Console.WriteLine("My
method of my concrete class");
}
}
Y bueno, esto seria todo.
Espero que este material resulte didactico y
practico para todos aquellos que quieran conocer los conecptos de la
programacion orientada a objetos.
Toda opinion y retroalimentación es bienvenida,
mientras mas aportemos mejor.
Que pasen buen dia.
