Herencia en Csharp
C# nos permite diseñar una clase que usa herencia para extender otra ya existente
C# como Java sólo soporta herencia simple
Ejemplo herencia simple:
using System;
class Persona {
protected string nombre, apellido1;
public Persona(string nombre, string apellido1) {
this.nombre = nombre;
this.apellido1 = apellido1;
}
public void Saludar() {
Console.WriteLine("¡Hola " + this.nombre + " " + this.apellido1 + "!");
}
}
Herencia
class Hombre: Persona {
public Hombre(string nombre, string apellido1): base(nombre, apellido1) {}
public new void Saludar() {
Console.WriteLine("¡Hola " + this.apellido1 + "!");
}
}
class Test {
public static void Main() {
Persona p = new Persona("Diego", "Ipiña");
p.Saludar(); // Visualizar ¡Hola Diego Ipiña!
Hombre h = new Hombre("Jon", "Altuna");
h.Saludar(); // Visualizar ¡Hola Altuna!
}
}
Herencia
La herencia representa una relación is-a
Al cambiar la accesibilidad de los campos nombre y apellido a protected, ahora son accesibles en las clases que los derivan
class Hombre: Persona {
…
}
La única diferencia entre Hombre y Persona es la implementación del método Saludar.
La palabra clave base se usa para referenciar al objeto padre
La palabra clave new indica al compilador que queremos sobre-escribir el método Saludar del padre (Persona).
Métodos virtuales
Una de las ventajas de la herencia que podemos usar una clase base para referenciar a una instancia de una clase derivada
Persona p = new Hombre("Diego", "Ipiña");
p.Saludar(); // problema, invoca a Saludar de Persona y no de Hombre
La solución a esto son métodos virtuales a través de las palabras claves virtual (a usarse en el método de la clase padre) y override (a usarse en el método de la clase hijo)
Métodos virtuales
using System;
class Persona {
protected string nombre, apellido1;
public Persona(string nombre, string apellido1) {
this.nombre = nombre;
this.apellido1 = apellido1;
}
public virtual void Saludar() {
Console.WriteLine("¡Hola " + this.nombre + " " + this.apellido1 + "!");
}
}
Métodos virtuales
class Hombre: Persona {
public Hombre(string nombre, string apellido1): base(nombre, apellido1) {}
public override void Saludar() {
Console.WriteLine("¡Hola " + this.apellido1 + "!");
}
}
class Test {
public static void Main() {
Persona p1 = new Hombre("Diego", "Ipiña");
p1.Saludar(); // Visualizar ¡Hola Ipiña!
Persona p2 = new Persona("Jon", "Altuna");
p2.Saludar(); // Visualizar ¡Hola Jon Altuna!
}
}
Clases abstractas
Supongamos que estamos interesados en modelar hombres y mujeres, pero no personas perse ? No queremos permitir la creación de objetos Persona directamente, pero queremos permitir la creación de objetos Hombre y Mujer directamente.
Usamos abstract delante de Persona para evitar que esta clase se pueda instanciar
Usamos abstract en el método Saludar de Persona para indicar que las clases que heredan deben sobreescribirlo
Clases abstractas
using System;
abstract class Persona {
protected string nombre, apellido1;
public Persona(string nombre, string apellido1) {
this.nombre = nombre;
this.apellido1 = apellido1;
}
abstract public void Saludar();
}
Clases abstractas
class Hombre: Persona {
public Hombre(string nombre, string apellido1): base(nombre, apellido1) {}
public override void Saludar() {
Console.WriteLine("¡Hola Señor " + this.apellido1 + "!");
}
}
class Mujer: Persona {
public Mujer(string nombre, string apellido1): base(nombre, apellido1) {}
public override void Saludar() {
Console.WriteLine("¡Hola Señorita " + this.apellido1 + "!");
}
}
Clases abstractas
class Test {
public static void Main() {
Hombre h = new Hombre("Diego", "Ipiña");
h.Saludar(); // Visualizar ¡Hola Señor Ipiña!
Mujer m = new Mujer("Usue", "Artaza");
m.Saludar(); // Visualizar ¡Hola Señorita Artaza!
}
}
Para deshabilitar la herencia se puede marcar una clase como sealed, resultando en un error de compilación si se intenta derivar de ella
sealed class Person {
…
}
Más sobre métodos
Los métodos acceptan parámetros y devuelven un resultado
int Add(int x, int y) {
return x+y;
}
Los parámetros x e y se pasan por valor, se recibe una copia de ellos
Si queremos modificar dentro de una función un parámetro y que el cambio se refleje en el código de invocación de la función, usaremos ref, tanto en la declaración del método como en su invocación:
void Increment(out int i) {
i = 3;
}
…
int i;
Increment(out i); // i == 3
Más sobre métodos
Mientras ref se usa para modificar el valor de una variable, si el método asigna el valor inicial a la variable habrá que usar out:
Para pasar un numero variable de parámetros se usa params:
class Adder {
int Add(params int[] ints) {
int sum=0;
foreach(int i in ints)
sum+=i;
return sum;
}
public static void Main() {
Adder a = new Adder();
int sum = a.Add(1, 2, 3, 4, 5);
System.Console.WriteLine(sum); // visualiza "15"
}
}
Más sobre métodos
Métodos de sobrecarga, es decir, métodos con el mismo nombre, con firmas (número y tipo de parámetros) diferentes:
class Persona {
string nombre, apellido1, apellido2;
public Persona(string nombre, string apellido1) {
this.nombre = nombre;
this.apellido1 = apellido1;
}
public Persona(string nombre, string apellido1, string apellido2) {
this.nombre = nombre;
this.apellido1 = apellido1;
this.apellido2 = apellido2;
}
}
Persona p1 = new Persona("Diego", "Ipiña");
Persona p2 = new Persona("Diego", "Ipiña", "Artaza");
Modificadores de acceso
Los modificadores de acceso controlan la visibilidad de los miembros de una clase
private, sólo código dentro de la misma clase contenedora tiene acceso a un miembro privado. Es el modo de acceso por defecto.
public , visible a todos los usuarios de una clase
protected, miembros accesibles tanto por dentro de la clase como en clases derivadas
internal, miembros accesibles sólo dentro de un assembly
protected internal, permite acceso protected e internal
NDD (Non Deterministic Destruction)
class File: Idisposable {
protected IntPtr Handle = IntPtr.Zero;
public File(string name) {}
~File() {
this.Dispose(false);
}
public void Dispose() {
System.GC.SupressFinalize(this);
this.Dispose(true);
}
protected virtual void Dispose(bool disposing) {
if (disposing) {
// Dispose otros recursos de recursos no gestionados
}
}
public void Close() {
Dispose();
}
}
Excepciones
Modo recomendado para manejar errores excepcionales en C#
Todas las excepciones definidas en la FCL derivan de System.Exception
System.Exception define una serie de propiedades comunes a todas las excepciones:
Message: contiene un mensaje de error indicando que ha ido mal
StackTrace: detalla los detalles de la llamada que produjo la excepción
Para distinguir entre excepciones lanzadas por la framework y excepciones generadas por aplicaciones, estas últimas se recomienda deriven de System.ApplicationException
Página siguiente  |