Fernando Berzal Galiano & Francisco Cortijo Bon classes.xml classes2.xml ConceptoHerencia El mecanismo de herencia es uno de los pilares fundamentales en los que se basa la programación orientada a objetos. Es un mecanismo que permite definir nuevas clases a partir de otras ya definidas. Si en la definición de una clase indicamos que ésta deriva de otra, entonces la primera -a la que se le suele llamar clase hija o clase derivada- será tratada por el compilador automáticamente como si su definición incluyese la definición de la segunda -a la que se le suele llamar clase padre o clase base. Las clases que derivan de otras se definen usando la siguiente sintaxis: : { } ]]> A los miembros definidos en la clase hija se le añadirán los que hubiésemos definido en la clase padre: la clase derivada "hereda" de la clase base. La palabra clave base se utiliza para obtener acceso a los miembros de la clase base desde una clase derivada. C# sólo permite herencia simple. Los objetos de una clase derivada contarán con los mismos miembros que los objetos de la clase base y además incorporarán nuevos campos y/o métodos. El constructor de una clase derivada puede emplear el constructor de la clase base para inicializar los campos heredados de la clase padre con la construcción base. En realidad se trata de una llamada al constructor de la clase base con los parámetros adecuados. ) ]]> Si no se incluye el compilador consideraría que vale :base(), lo que provocaría un error si la clase base carece de constructor sin parámetros. public class B { private int h; // Campo public B () { // Constructor sin parámetros this.h = -1; } public B (int h) // Constructor con parámetro { this.h = h; } public int H // Propiedad { get { return h; } set { h = value; } } } // class B public class D : B // "D" hereda de "B" { private int i; // Campo public D () : this(-1) {} // Constructor sin parámetros public D (int i) { // Constructor con un parámetro this.i = i; } public D (int h, int i) : base(h) { // Constructor con this.i = i; // dos parámetros } public int I // Propiedad { get { return i; } set { i = value; } } } // class D ...... B varB1 = new B(); // Const. sin parámetros de B B varB2 = new B(5); // Const. con 1 parámetro de B Console.WriteLine("varB1 : (H={0})", varB1.H); Console.WriteLine("varB2 : (H={0})\n", varB2.H); D varD1 = new D(); // Const. sin parámetros de D D varD2 = new D(15); // Const. con 1 parámetro de D D varD3 = new D(25, 11); // Const. con 2 parámetros de D Console.WriteLine("varD1 : (I={0},H={1})", varD1.I, varD1.H); Console.WriteLine("varD2 : (I={0},H={1})", varD2.I, varD2.H); Console.WriteLine("varD3 : (I={0},H={1})", varD3.I, varD3.H); Console.ReadLine(); ...... image/out-Clases3.gif En el siguiente ejemplo se muestra cómo puede extenderse la clase CocheSimple vista anteriormente para construir, a partir de ella, la clase Taxi. Observar como se emplea la construcción base para referenciar a un constructor de la clase base y que cuando actúa el constructor sin parámetros de la clase Taxi se llama implícitamente al constructor sin parámetros de la clase CocheSimple. image/out-Clases4.gif Siempre que se redefine un método que aparece en la clase base, hay que utilizar explícitamente la palabra reservada override y, de esta forma, se evitan redefiniciones accidentales (una fuente de errores en lenguajes como Java o C++). Sabemos que todos los objetos (incluidas las variables de los tipos predefinidos) derivan, en última instancia, de la clase Object. Esta clase proporciona el método ToString que crea una cadena de texto legible para el usuario que describe una instancia de la clase. Si dejamos sin redefinir este método y empleando la clase CocheSimple las siguientes instrucciones: producen el siguiente resultado: lo que nos invita a redefinir el método ToString en la clase CocheSimple: class CocheSimple { ... public override string ToString() { return (this.Marca + " " + this.Modelo + " (" + this.VelocMax + " Km/h)"); } ... } Las dos instrucciones siguientes son equivalentes: Console.WriteLine ("Mi coche: " + MiCoche.ToString()); Console.WriteLine ("Mi coche: " + MiCoche); por lo que podemos sutituir las instrucciones que muestran los datos de los objetos CocheSimple por: Console.WriteLine ("Mi coche: " + MiCoche); Console.WriteLine ("El tuyo: " + TuCoche); Console.WriteLine ("Un coche sin identificar: " + UnCoche); y eliminamos el (innecesario) método MuestraCoche, el resultado de la ejecución del programa anterior es: image/out-Clases5.gif La palabra reservada base sirve para hacer referencia a los miembros de la clase base que quedan ocultos por otros miembros de la clase actual. Por ejemplo, podríamos redefinir también el método ToString de la clase Taxi empleando el método redefinido ToString de la clase base CocheSencillo: class CocheSimple { ... public override string ToString() { return (this.Marca + " " + this.Modelo + " (" + this.VelocMax + " Km/h)"); } ... } class Taxi : CocheSimple { ... public override string ToString() { return (base.ToString() + "\n Licencia: " + this.Licencia); } ... } ...... Taxi ElTaxiDesconocido = new Taxi (); Console.WriteLine ("Un taxi sin identificar: " + ElTaxiDesconocido); Taxi NuevoTaxi= new Taxi ("Citröen", "C5", 250, "GR1234"); Console.WriteLine ("Un taxi nuevo: " + NuevoTaxi); ...... y el resultado es: image/out-Clases6.gif En la sección dedicada a la classes.xml#Sobrecargasobrecarga de operadores introdujimos la clase Point. No había ningún método que mostrara los datos de interés de un objeto de tipo Point. Podemos sobreescribir el método ToString de manera que fuera: public class Point { ... public override string ToString() { return ("["+this.X+", "+this.Y+"]"); } ... } Ahora las instrucciones de escritura se convierten en llamadas a este método, por ejemplo: Console.WriteLine ("p1 es: " + p1); // Console.WriteLine ("p1 es: " + p1.ToString() El resultado de la ejecución de ese programa será: image/out-Over3.gif Un método es virtual si puede redefinirse en una clase derivada. Los métodos son no virtuales por defecto. Los métodos no virtuales no son polimórficos (no pueden reemplazarse) ni pueden ser abstractos. Los métodos virtuales se definen en una clase base (empleando la palabra reservada virtual) y pueden ser reemplazados (empleando la palabra reservada override) en las subclases (éstas proporcionan su propia -específica- implementación). Generalmente, contendrán una implementación por defecto del método (si no, se deberían utilizar métodos abstractos). class Shape // Clase base { // "Draw" es un método virtual public virtual void Draw() { ... } } class Box : Shape { // Reemplaza al método Draw de la clase base public override void Draw() { ... } } class Sphere : Shape { // Reemplaza al método Draw de la clase base public override void Draw() { ... } } void HandleShape(Shape s) { ... s.Draw(); // Polimorfismo ... } HandleShape(new Box()); HandleShape(new Sphere()); HandleShape(new Shape()); NOTA: Propiedades, indexadores y eventos también pueden ser virtuales. ClasesAbstractas Una clase abstracta es una clase que no puede ser instanciada. Se declara empelando la palabra reservada abstract. Permiten incluir métodos abstractos y métodos no abstractos cuya implementación hace que sirvan de clases base (herencia de implementación). Como es lógico, no pueden estar "selladas". Un método abstracto es un método sin implementación que debe pertenecer a una clase abstracta. Lógicamente se trata de un método virtual forzoso y su implementación se realizará en una clase derivada. abstract class Shape // Clase base abstracta { public abstract void Draw(); // Método abstracto } class Box : Shape { public override void Draw() { ... } } class Sphere : Shape { public override void Draw() { ... } } void HandleShape(Shape s) { ... s.Draw(); ... } HandleShape(new Box()); HandleShape(new Sphere()); HandleShape(new Shape()); // Error !!! SealedClasses Una clase sellada (sealed), es una clase de la que no pueden derivarse otras clases (esto es, no puede utilizarse como clase base). Obviamente, no puede ser una clase abstracta. Los struct en C# son implícitamente clases selladas. ¿Para qué sirve sellar clases? Para evitar que se puedan crear subclases y optimizar el código (ya que las llamadas a las funciones de una clase sellada pueden resolverse en tiempo de compilación). TiposAnidados C# permite declarar tipos anidados, esto es, tipos definidos en el ámbito de otro tipo. El anidamiento nos permite que el tipo anidado pueda acceder a todos los miembros del tipo que lo engloba (independientemente de los modificadores de acceso) y que el tipo esté oculto de cara al exterior (salvo que queramos que sea visible, en cuyo caso habrá que especificar el nombre del tipo que lo engloba para poder acceder a él). OperadoresEspeciales Se utiliza para comprobar dinámicamente si el tipo de un objeto es compatible con un tipo especificado (instanceof en Java). No conviene abusar de este operador (es preferible diseñar correctamente una jerarquía de tipos). static void DoSomething(object o) { if (o is Car) ((Car)o).Drive(); } Intenta convertir de tipo una variable (al estilo de los casts dinámicos de C++). Si la conversión de tipo no es posible, el resultado es null. Es más eficiente que el operador is, si bien tampoco es conveniente abusar del operador as. static void DoSomething(object o) { Car c = o as Car; if (c != null) c.Drive(); } El operador typeof devuelve el objeto derivado de System.Type correspondiente al tipo especificado. De esta forma se puede hacer reflexión para obtener dinámicamente información sobre los tipos (como en Java). ... Console.WriteLine(typeof(int).FullName); Console.WriteLine(typeof(System.Int).Name); Console.WriteLine(typeof(float).Module); Console.WriteLine(typeof(double).IsPublic); Console.WriteLine(typeof(Point).MemberType); ... image/out-Over4.gif