C# Herencia
La herencia es uno de los conceptos más importantes en la programación orientada a objetos. La herencia nos permite definir una clase basándonos en otra, lo que facilita la creación y el mantenimiento de aplicaciones. También favorece la reutilización de código y ahorra tiempo de desarrollo.
Al crear una clase, el programador no necesita reescribir por completo nuevos miembros de datos y funciones miembro; solo necesita diseñar una nueva clase que herede los miembros de la clase existente. Esta clase existente se denominaclase base, y esta nueva clase se denominaclase derivada。
La idea de la herencia implementa la relación depertenencia (IS-A). Por ejemplo, un mamíferopertenece a (IS-A)un animal, un perropertenece a (IS-A)un mamífero, por lo tanto un perropertenece a (IS-A)un animal.
Clase base y clase derivada
Una clase puede heredar de otra clase, denominándose clase base (clase padre) y clase derivada (clase hija).
C# no admite la herencia múltiple de clases, pero admite la herencia múltiple de interfaces; una clase puede implementar múltiples interfaces.
En resumen:Una clase puede heredar de múltiples interfaces, pero solo puede heredar de una clase.
La sintaxis para crear una clase derivada en C# es la siguiente:
{
...
}
class <clase derivada> : <clase base>
{
...
}
La clase derivada hereda los miembros de la clase base (campos, métodos, propiedades, etc.), a menos que estén marcados explícitamente como privados (private).
La clase derivada puede invocar los constructores y métodos de la clase base mediante la palabra clave base.
Ejemplo
{
public void SomeMethod()
{
// Method implementation
}
}
class DerivedClass : BaseClass
{
public void AnotherMethod()
{
// Accessing base class method
base.SomeMethod();
// Method implementation
}
}
Supongamos que hay una clase base Shape y su clase derivada es Rectangle:
Ejemplo
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
// Clase derivada
class Rectangle: Shape
{
public int getArea()
{
return (width * height);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
Rect.setWidth(5);
Rect.setHeight(7);
// Imprime el área del objeto
Console.WriteLine("Área total: {0}", Rect.getArea());
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
总面积: 35
Inicialización de la clase base
La clase derivada hereda las variables miembro y los métodos miembro de la clase base. Por lo tanto, el objeto de la clase padre debe crearse antes de que se cree el objeto de la clase hija. Puede realizar la inicialización de la clase padre en la lista de inicialización de miembros.
El siguiente programa demuestra esto:
Ejemplo
namespace RectangleApplication
{
class Rectangle
{
// Variables miembro
protected double length;
protected double width;
public Rectangle(double l, double w)
{
length = l;
width = w;
}
public double GetArea()
{
return length * width;
}
public void Display()
{
Console.WriteLine("Longitud: {0}", length);
Console.WriteLine("Ancho: {0}", width);
Console.WriteLine("Área: {0}", GetArea());
}
}//end class Rectangle
class Tabletop : Rectangle
{
private double cost;
public Tabletop(double l, double w) : base(l, w)
{ }
public double GetCost()
{
double cost;
cost = GetArea() * 70;
return cost;
}
public void Display()
{
base.Display();
Console.WriteLine("Costo: {0}", GetCost());
}
}
class ExecuteRectangle
{
static void Main(string[] args)
{
Tabletop t = new Tabletop(4.5, 7.5);
t.Display();
Console.ReadLine();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
长度: 4.5 宽度: 7.5 面积: 33.75 成本: 2362.5
Herencia de interfaces (Interface Inheritance)
Una interfaz puede heredar de una o más interfaces; la interfaz derivada hereda todos los miembros de la interfaz base.
La interfaz derivada puede ampliar la lista de miembros de la interfaz base, pero no puede cambiar sus modificadores de acceso.
Ejemplo
{
void Method1();
}
interface IDerivedInterface : IBaseInterface
{
void Method2();
}
El ejemplo de herencia de interfaces se puede implementar de la siguiente manera:
Ejemplo
// Define una interfaz base
interface IBaseInterface
{
void Method1();
}
// Define una interfaz derivada que hereda de la interfaz base
interface IDerivedInterface : IBaseInterface
{
void Method2();
}
// Clase que implementa la interfaz derivada
class MyClass : IDerivedInterface
{
public void Method1()
{
Console.WriteLine("Method1 implementation");
}
public void Method2()
{
Console.WriteLine("Method2 implementation");
}
}
class Program
{
static void Main(string[] args)
{
// Crea una instancia de la clase MyClass
MyClass obj = new MyClass();
// Llama al método heredado de la interfaz base
obj.Method1();
// Llama al método nuevo de la interfaz derivada
obj.Method2();
}
}
En el ejemplo anterior, la clase MyClass implementa la interfaz IDerivedInterface, por lo que debe proporcionar todos los métodos definidos en IDerivedInterface, incluido el método Method1() heredado de IBaseInterface. En el método Main, creamos una instancia obj de MyClass y llamamos a sus métodos.
El resultado es:
Method1 implementation Method2 implementation
C# Herencia múltiple
La herencia múltiple se refiere a la capacidad de una clase de heredar comportamientos y características de más de una clase padre al mismo tiempo. En contraste con la herencia única, que se refiere a que una clase solo puede heredar de una clase padre.
C# no admite la herencia múltiple. Sin embargo, puede utilizar interfaces para implementar la herencia múltiple. El siguiente programa demuestra esto:
Ejemplo
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
// Clase base PaintCost
public interface PaintCost
{
int getCost(int area);
}
// Clase derivada
class Rectangle : Shape, PaintCost
{
public int getArea()
{
return (width * height);
}
public int getCost(int area)
{
return area * 70;
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
int area;
Rect.setWidth(5);
Rect.setHeight(7);
area = Rect.getArea();
// Imprime el área del objeto
Console.WriteLine("Área total: {0}", Rect.getArea());
Console.WriteLine("Costo total de pintura: ${0}" , Rect.getCost(area));
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
总面积: 35 油漆总成本: $2450Otras extensiones