Redefinición de Métodos en clases derivadas

Redefinicion de las clases derivadas

El lenguaje java permite redefinir miembros de la clase base en las clases derivadas, pero el compilador emite una advertencia cuando detecta una redefinición. Una advertencia (warning) es un mensaje del compilador acerca de un posible problema. Sin embargo, en este caso sí se genera código ejecutable (a diferencia del mensaje de error). Redefinición de campos. El siguiente ejemplo muestra cómo reutilizar los identificadores de los campos de la clase base en una clase derivada.

Ejemplo de redefinición de las clases derivadas

// Redef.cs : Ejemplifica la redefinición de campos en clases derivadas.

class Punto{

public int x;

public int y;

}

class Punto3D : Punto{

public int x ;

public int y ;

public int z ;

}

class Principal{

public static void Main( ) {

Punto a = new Punto( ); Punto3D b = new Punto3D( );

a.x = 100 ;

a.y = 200 ;

b.x = 300 ;

b.y = 400 ;

b.z = 500 ;

}

}

Referencia al objeto de la clase base

La jerarquía de clases que describen las figuras planas

Consideremos las figuras planas cerradas como el rectángulo, y el círculo. Tales figuras comparten características comunes como es la posición de la figura, de su centro, y el área de la figura, aunque el procedimiento para calcular dicha área sea completamente distinto. Podemos por tanto, diseñar una jerarquía de clases, tal que la clase base denominada Figura, tenga las características comunes y cada clase derivada las específicas. La relación jerárquica se muestra en la figura

La clase Figura es la que contiene las características comunes a dichas figuras concretas por tanto, no tiene forma ni tiene área. Esto lo expresamos declarando Figura como una clase abstracta, declarando la función miembro area abstract.

Las clases abstractas solamente se pueden usar como clases base para otras clases. No se pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar variables de dichas clases.

En el juego del ajedrez podemos definir una clase base denominada Pieza, con las características comunes a todas las piezas, como es su posición en el tablero, y derivar de ella las características específicas de cada pieza particular. Así pues, la clase Pieza será una clase abstracta con una funciónabstract denominada mover, y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero.

·                     La clase Figura

La definición de la clase abstracta Figura, contiene la posición x e y de la figura particular, de su centro, y la función area, que se va a definir en las clases derivadas para calcular el área de cada figura en particular.

public abstract class Figura {     protected int x;     protected int y;     public Figura(int x, int y) {         this.x=x;         this.y=y;     }     public abstract double area(); }

·                     La clase Rectangulo

Las clases derivadas heredan los miembros dato x e y de la clase base, y definen la función area, declarada abstract en la clase base Figura, ya que cada figura particular tiene una fórmula distinta para calcular su área. Por ejemplo, la clase derivada Rectangulo, tiene como datos, aparte de su posición (x, y) en el plano, sus dimensiones, es decir, su anchura ancho y altura alto.

class Rectangulo extends Figura{     protected double ancho, alto;     public Rectangulo(int x, int y, double ancho, double alto){         super(x,y);         this.ancho=ancho;         this.alto=alto;     }     public double area(){         return ancho*alto;     } }

La primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base, para ello se emplea la palabra reservada super. El constructor de la clase derivada llama al constructor de la clase base y le pasa las coordenadas del punto x e y. Después inicializa sus miembros datoancho y alto.

En la definición de la función area, se calcula el área del rectángulo como producto de la anchura por la altura, y se devuelve el resultado

·                     La clase Circulo

class Circulo extends Figura{     protected double radio;     public Circulo(int x, int y, double radio){         super(x,y);         this.radio=radio;     }     public double area(){         return Math.PI*radio*radio;     } }

Como vemos, la primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base empleando la palabara reservadasuper. Posteriormente, se inicializa el miembro dato radio, de la clase derivada Circulo.

En la definición de la función area, se calcula el área del círculo mediante la conocida fórmula r², o bien *r*r. La constante Math.PI es una aproximación decimal del número irracional .

Uso de la jerarquía de clases

Creamos un objeto c de la clase Circulo situado en el punto (0, 0) y de 5.5 unidades de radio. Calculamos y mostramos el valor de su área.

        Circulo c=new Circulo(0, 0, 5.5);

        System.out.println("Area del círculo "+c.area());

Creamos un objeto r de la clase Rectangulo situado en el punto (0, 0) y de dimensiones 5.5 de anchura y 2 unidades de largo. Calculamos y mostramos el valor de su área.

        Rectangulo r=new Rectangulo(0, 0, 5.5, 2.0);

        System.out.println("Area del rectángulo "+r.area());

Veamos ahora, una forma alternativa, guardamos el valor devuelto por newal crear objetos de las clases derivadas en una variable f del tipo Figura(clase base).

        Figura f=new Circulo(0, 0, 5.5);

        System.out.println("Area del círculo "+f.area());

        f=new Rectangulo(0, 0, 5.5, 2.0);

        System.out.println("Area del rectángulo "+f.area());

Reutilización de miembros heredados

La re utilización de código se refiere al comportamiento y a las técnicas que garantizan que una parte o la totalidad de un programa informático existente se pueda emplear en la construcción de otro programa. De esta forma se aprovecha el trabajo anterior, se economiza tiempo, y se reduce la redundancia.

La manera más fácil de reutilizar código es copiarlo total o parcialmente desde el programa antiguo al programa en desarrollo. Pero es trabajoso mantener múltiples copias del mismo código, por lo que en general se elimina la redundancia dejando el código reusable en un único lugar, y llamándolo desde los diferentes programas. Este proceso se conoce como abstracción. La abstracción puede verse claramente en las bibliotecas de software, en las que se agrupan varias operaciones comunes a cierto dominio para facilitar el desarrollo de programas nuevos. Hay bibliotecas para convertir información entre diferentes formatos conocidos, acceder a dispositivos de almacenamiento externos, proporcionar una interfaz con otros programas, manipular información de manera conocida (como números, fechas, o cadenas de texto).

Para que el código existente se pueda reutilizar, debe definir alguna forma de comunicación o interfaz. Esto se puede dar por llamadas a una subrutina, a un objeto, o a una clase.

Como se ha comentado anteriormente la clase descendiente puede añadir sus propios atributos y métodos pero también puede sustituir u ocultar los heredados. En concreto:

1. Se puede declarar un nuevo atributo con el mismo identificador que uno heredado, quedando este atributo oculto. Esta técnica no es recomendable.

2. Se puede declarar un nuevo método de instancia con la misma cabecera que el de la clase ascendiente, lo que supone su sobreescritura. Por lo tanto, la sobreescritura o redefinición consiste en que métodos adicionales declarados en la clase descendiente con el mismo nombre, tipo de dato devuelto y número y tipo de parámetros sustituyen a los heredados.

3. Se puede declarar un nuevo método de clase con la misma cabecera que el de la clase ascendiente, lo que hace que éste quede oculto. Por lo tanto, los métodos de clase o estáticos (declarados como static) no pueden ser redefinidos.

4. Un método declarado con el modificador final tampoco puede ser redefinido por una clase derivada.

5. Se puede declarar un constructor de la subclase que llame al de la superclase de forma implícita o de mediante la palabra reservada super.

6. En general puede accederse a los métodos de la clase ascendiente que han sido redefinidos empleando la palabra reservada super delante del identificador del método. Este mecanismo sólo permite acceder al metodo perteneciente a la clase en el nivel inmediatamente superior de la jerarquía de clases.

Construyamos la clase Taxista.java con el siguiente código:

public class Taxista extends Persona {

private int nLicencia;

public void setNLicencia(int num){

nLicencia = num;

}

public int getLicencia(){

return nLicencia;

}

}

Y construyamos ArranqueTaxista.java:

public class ArranqueTaxista {

public static void main (String arg[]){

Taxista tax1 = new Taxista();

tax1.setNombre("Luis");

tax1.setEdad(50);

System.out.println( tax1.getNombre());

System.out.println(tax1.getEdad());

}

}

Ahora intentemos usar el constructor que existía en la clase Persona que recibia el nombre de la persona y vamos a usarlo para la clase Taxista. Para ello construyamos la clase ArranqueTaxista2.java:

public class ArranqueTaxista2 {

public static void main (String arg[]){

Taxista tax1 = new Taxista("Jose");

tax1.setEdad(50);

System.out.println( tax1.getNombre());

System.out.println(tax1.getEdad());

System.out.println(tax1.getNLicencia());

}

}

Se genera un error de compilación, debido a que los constructores no se heredan, sino que hay que definir nuestros propios constructores. Agreguemos en la clase Taxista los siguientes constructores:

public Taxista(int licencia){

super();

nLicencia = licencia;

}

public Taxista(String nombre,int licencia){

super(nombre);

nLicencia = licencia;

}

Ahora si podremos compilar y ejecutar la clase ArranqueTaxista2. La llamada al método super indica que estamos llamando a un constructor de la clase base (pensemos que un Taxista antes que Taxista es Persona y por tanto tiene sentido llamar al constructor de Persona antes que al de Taxista). Además gracias al número de parámetros de la llamada a super podemos especificar cuál de los constructores de la clase base queremos llamar.

En java se pueden emplear dos palabras clave: this y super. Como vimos en la unidad 1, this hace alusión a todo el objeto y super hace alusión a la parte heredada, por ello empleamos super para referenciar al constructor de la clase base.

Ahora vamos a agregar la función getNombre dentro de la clase Taxista, es decir, tenemos la misma función en Persona y en Taxista:

public String getNombre() {

return "Soy un taxista y me llamo: " + super.getNombre();

}

Compilamos Taxista y ejecutamos ArranqueTaxista2. Veremos que el mensaje que aparece en pantalla demuestra que la función getNombre llamada es la de del tipo real del objeto construido, en este caso la de la clase derivada que es Taxista.

Tambien apreciamos que para acceder al atributo nombre es necesario acceder al método getNombre de la clase base (y por ello emplear super).

En java los atributos y métodos de la clase base pueden cambiar su modificador de visibilidad dentro de la clase derivada, la siguiente tabla recoge dichos cambios:

Modificadores en la clase base:

public

private

protected

paquete

En la clase derivada se transforman en:

public

inaccesible

protected

paquete

Inaccesible significa que, a pesar de haber sido heredado, no hay permisos en la clase derivada para poder acceder a dicho elemento inaccesible, pero aún así, se pueden llamar a métodos de la clase base que si pueden acceder y modificar al elemento.

Recordemos que protected significa que es private, pero que al heredar no se hace inaccesible, es decir que desde la clase derivada se puede acceder.

Clase base y Clase derivada

Las clases pueden heredar de otra clase. Para conseguir esto, se coloca un signo de dos puntos después del nombre de la clase al declarar la clase y se denomina la clase de la cual se hereda (la clase base) después del signo de dos puntos, del modo siguiente:

public class A
{
    public A() { }
}
 
public class B : A
{
    public B() { }
}

La nueva clase (la clase derivada) obtiene todos los datos no privados y el comportamiento de la clase base, además de todos los demás datos y comportamientos que define para sí misma. La nueva clase tiene dos tipos efectivos: el tipo de la nueva clase y el tipo de la clase que hereda.

En el ejemplo anterior, la clase B es claramente B y A. Cuando se tiene acceso a un objeto B, se puede utilizar la operación de conversión de tipos para convertirlo en un objeto A. La conversión de tipos no cambia el objeto B, pero la vista del objeto B se restringe a los datos y comportamientos de A. Después de convertir un objeto B en un objeto A, es posible volver a convertir ese objeto A en un objeto B. No todas las instancias de A se pueden convertir en B, sólo aquellas que son realmente instancias de B. Si se tiene acceso a la clase B como tipo B, se obtienen los datos y comportamientos tanto de la clase A como de la clase B. La capacidad que tiene un objeto de representar más de un tipo se denomina polimorfismo.

Las estructuras no pueden heredar de otras estructuras o clases. Tanto las clases como las estructuras pueden heredar de una o más interfaces.

La palabra clave base se utiliza para obtener acceso a los miembros de la clase base desde una clase derivada:

1. Realice una llamada a un método de la clase base reemplazada por otro método.
2. Especifique a qué constructor de la clase base se debe llamar para crear instancias de la clase derivada.

El acceso a una clase base sólo se permite en un constructor, en un método de instancia o en un descriptor de acceso a una propiedad de instancia.

Es incorrecto utilizar la palabra clave base desde dentro de un método estático.

En este ejemplo, tanto la clase base, Person, como la clase derivada, Employee, poseen un método denominado Getinfo. Mediante la palabra clave base, se puede realizar una llamada al método Getinfo de la clase base desde la clase derivada.

// keywords_base.cs
// Accessing base class members
using System;
public class Person
{
    protected string ssn = "444-55-6666";
    protected string name = "John L. Malgraine";
 
    public virtual void GetInfo()
    {
        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("SSN: {0}", ssn);
    }
}
class Employee : Person
{
    public string id = "ABC567EFG";
    public override void GetInfo()
    {
        // Calling the base class GetInfo method:
        base.GetInfo();
        Console.WriteLine("Employee ID: {0}", id);
    }
}
 
class TestClass
{
    static void Main()
    {
        Employee E = new Employee();
        E.GetInfo();
    }
}

Este ejemplo muestra cómo especificar el constructor de la clase base al que se realiza la llamada cuando se crean instancias de una clase derivada.

Cuando se crean instancias de una clase derivada.

// keywords_base2.cs
using System;
public class BaseClass
{
    int num;
 
    public BaseClass()
    {
        Console.WriteLine("in BaseClass()");
    }
 
    public BaseClass(int i)
    {
        num = i;
        Console.WriteLine("in BaseClass(int i)");
    }
 
    public int GetNum()
    {
        return num;
    }
}
 
public class DerivedClass : BaseClass
{
    // This constructor will call BaseClass.BaseClass()
    public DerivedClass() : base()
    {
    }
 
    // This constructor will call BaseClass.BaseClass(int i)
    public DerivedClass(int i) : base(i)
    {
    }
 
    static void Main()
    {
        DerivedClass md = new DerivedClass();
        DerivedClass md1 = new DerivedClass(1);
    }
}

Constructores y Destructores

Funciones Constructoras y Destructoras 

En los programas hay partes que requieren inicialización. Esta necesidad de inicialización es incluso más común cuando se está trabajando con objetos. Para tratar esta situación, C++ permite incluir una función constructora. A estas funciones se las llama automáticamente cada vez que se crea un objeto de esa clase. 

La función constructora debe tener el mismo nombre que la clase de la que es parte, no tienen tipo devuelto, es ilegal que un constructor tenga un tipo devuelto. Pero si es posible pasarle valores a modo de parámetros. 

Prototipo de la función: 

nombre_fucion(parámetros); 

Desarrollo de la función: 

nombre_calse::nombre_funcion(parámetros){ 

cuerpo; 

} 

El complemento de un constructor es la función destructora. A esta función se la llama automáticamente cuando se destruye el objeto. El nombre de las funciones destructoras debe ser el mismo que el de la clase a la que pertenece precedido del carácter ~ (alt+126). Los objetos de destruyen cuando se salen de ámbito cuando son locales y al salir del programa si son globales. Las funciones destructoras no devuelve tipo y tampoco pueden recibir parámetros. 

Técnicamente un constructor y un destructor se utilizan para inicializar y destruir los objetos, pero también se pueden utilizar para realizar cualquier otra operación. Sin embargo esto se considera un estilo de programación pobre. 

PROTOTIPO DE LA FUNCIÓN: 

~nombre_funcion(parámetros); 

DESARROLLO DE LA FUNCION: 

nombre_clase::nombre_funcion(){ 

cuerpo; 

} 

explicando un poco mas el constructor y el destructor

Herencia Multiple

Herencia múltiple hace referencia a una característica de los lenguajes de programación orientada a objetos en la que una clase puede heredar comportamientos y características de más de una superclase. Esto contrasta con la herencia simple, donde una clase sólo puede heredar de una superclase. 
Lenguajes que soportan herencia múltiple en su mayor parte son: C++, Centura SQL Windows, CLOS, Eiffel, Object REXX, Perl y Python. 

La herencia múltiple permite a una clase tomar funcionalidades de otras clases, como permitir a una clase llamada MusicoEstudiante heredar de una clase llamada Persona, una clase llamada Músico, y una clase llamada Trabajador. Esto puede ser abreviado como MusicoEstudiante : Persona, Músico, Trabajador. 
Ambigüedades 
En la herencia múltiple aparecen ambigüedades, como en el ejemplo de encima: si la clase Músico heredaba de Persona y Trabajador, y la clase Trabajador heredaba de Persona. Existirían las siguientes reglas:: 
• MusicoEstudiante : Persona, Músico, Trabajador 
• Músico : Persona, Trabajador 
• Trabajador: Persona 
Si un compilador está mirando la clase MusicoEstudiante necesita saber si debe juntar las características iguales o si deben estar separadas. Por ejemplo, tendría sentido unir las características "Edad" de Persona para MusicoEstudiante. La edad de una persona no cambia si le consideras una Persona, un Trabajador o un Músico. Sin embargo, tendría sentido separar la característica "Nombre" de Persona y Músico si los músicos usan un nombre artístico diferente de su nombre real. Las opciones de juntar y separar son válidas según el contexto, y sólo el programador sabe qué opción es correcta para la clase que está diseñando. 
Cada lenguaje de programación trata estos problemas de herencia repetida de diferente forma: 
• C++ requiere que el programador establezca de qué clase padre vendrá la característica a usar. Por ejemplo con "Trabajador::Persona.Edad". C++ no soporta herencia repetida explícita porque no habría forma de indicar qué superclase usar. 
• CLOS permite al programador control total del método de combinación, y si no es suficiente, el protocolo de metaobjetos ofrece al programador formas de modificar la herencia, envío de métodos, instanciación de clases, y otros mecanismos internos sin afectar a la estabilidad del sistema. 
• Eiffel permite al programador explicitar si junta o separa características que son heredadas de superclases. Eiffel juntará características automáticamente si tienen el mismo nombre e implementación. El programador tiene la opción de renombrar las características para separarlas. Eiffel también permite explicitar herencia repetida como A: B, B. 
• Logtalk soporta tanto interfaces como multi-herencia de implementación, permitiendo declarar alias de métodos que ofrecen renombrar y acceder a métodos que quedarían ocultados por el mecanismo de resolución de conflictos convencional. 
• Perl usa la lista de clases para heredar de una lista ordenada. El compilador usa el primer método que encuentra mediante búsqueda en profundidad por la lista de superclases. 
Java, Nemerle, Delphi, C# y Objective-C no permiten herencia múltiple; esto hace que no haya ambigüedad. Sin embargo, permiten a las clases implementar múltiples interfaces

video acerca de la herencia multiple