Sobreescritura

Introducción

Vamos a ver un concepto muy ligado a Herencia y es la sobreescritura de métodos. Esto nos ayudará a crear arquitecturas más complejas y aprovechar la herencia de manera más optima. La sobreescritura de métodos constituye la base de uno de los conceptos más potentes de Java: la selección dinámica de métodos, que es un mecanismo mediante el cual la llamada a un método sobrescrito se resuelve durante el tiempo de ejecución y no en el de compilación.

Definición

Se produce cuando en una jerarquía de clase, un método escrito en una subclase tiene el mismo tipo de retorno y la misma firma que un método de la superclase.

Firma: la firma de un método es el nombre del método junto a los valores de entrada (número, orden y tipo).

En una jerarquía de clases, cuando un método de una subclase tiene el mismo nombre y tipo que un método de su superclase, se dice que el método de la subclase sobreescribe el método de la superclase. Cuando se llama a un método sobrescrito desde una subclase, ésta siempre se refiere a la versión del método definida en la subclase.

El ejemlo más sencillos donde habéis utilizado la sobreescritura es con toString, ya que usamos métodos de la clase suprema Object. Pero hay más como equals(), hashCode() etc…

También lo podéis ver la sobreescritura cuando aparece la etiqueta @override.

Se llama ligadura dinámica al uso de la herencia y la sobreescritura, aspecto que veremos más adelante con Polimorfismo.

Ejemplo:

class A {
    int i, j;
    A(int a, int b) {
        y = a;
        j = b;
    }

    // Se imprimen i y j.

    void show() {
        System.out.println("i y j:" + y + "" + j);
    }
}

class B extends A {
    int k;
    B (int a, int b, int c) {
        super (a, b);
        k = c;
    }

    // Se imprime k sobreescribiendo el método () en A.

    void show() {
        System.out.println("k:" + k);
    }
}

class Override {
    public static void main (String args[]) {
        B subOb = new B (1, 2, 3);
        subOb.show(); // llamada a show () en B.
    }
}

La sobreescritura de métodos sólo se da cuando los nombres y los tipos de dos métodos son idénticos, sino lo son, entonces los métodos simplemente están sobrecargados.

Sobrecarga

Se parecen los dos conceptos pero no es lo mismo. La sobrecarga es: generar una nueva versión de un método(o constructor). La nueva versión debe de tener una firma diferente a las existentes. Se tiene en cuenta la firma del método pero no lo que devuelve el método.

Diferencia entre Sobrecarga y Sobreescritura

public class Main{
	public static void main(String[] args) {
		Hijo.sobreEscritura("Se bienvenido ", "Pablo");
		Hijo.sobreCarga( 3 );
	}
}
class Papa{
	public static void sobreEscritura(String txtBienvenida, String nombre){
		System.out.println(txtBienvenida + nombre);
	}
	public static void sobreCarga(String txtDespedida, String nombre){
		System.out.println(txtDespedida + nombre);
	}
}
class Hijo extends Papa {
	//El tipo devuelto no debe cambiar.
	//los parámetros de entrada no deben cambiar
	//La accesibilidad no será más restrictiva que la del método original.
	//Si el método original es static, el método que hace el override, tambień debe serlo.
	public static void sobreEscritura(String txtBienvenida, String nombre){
		System.out.println(txtBienvenida + "......" + nombre);
	}
	//El tipo de dato devuelto puede cambiar.
	//Los parámetros de entrada deben cambiar.
	//La accesibilidad puede ser más restrictiva que la del método original.
	protected static int sobreCarga(int codigoDespedida){
		System.out.println(codigoDespedida);
		return 4;
	}
	
}

Uso del Super

Como ya vimos en anteriores ejemplos, se puede usar super para invocar miembros de la superclase “ocultados”. Si lo que queremos es que mostrar() imprima todos los atributos de B incluyendo los heredados, podemos hacer:

class A{
 int i,j;
 A(int a, int b){
    i=a;
    j=b;
 }
 void mostrar(){
    System.out.println("i y j son: "+ i +" y "+ j);
 }
}

class B extends A{
 int k;
 B(int a, int b, int c){
    super(a,b);
    k=c;
 }
  void mostrar(){
    super.mostrar();
    System.out.println("k es: "+k);
 }
}

class Unidad4{
 public static void main(String[] args) {
    B obj_b=new B(1,2,3);
    obj_b.mostrar();
 }
}

Ejercicio 1

Crea un programa con una superclase Figura que almacena las dimensiones (2). También define un método area que calcula el área del objeto (versión no definida). El programa deriva dos subclases de Figura, Rectángulo y Triángulo. Cada una de las subclases sobrescribe area para devolver el área del rectángulo y del triángulo.

class Figura {
    double dim1;
    double dim2;
}

Ejercicio 2

Distinguir entre composición o herencia

• Clase Persona y clase Empleado
  Solución

  Herencia, un empleado es una persona.

• Clase Persona y clase Domicilio
  Solución

  Composición, una persona tiene un domicilio.

• Clase Lista y clase Nodo de lista
  Solución

  Composición, una lista tiene un puntero de tipo nodo al nodo.

• Clase Empresa, Empleado, y Jefe de grupo
  Solución

  Herencia entre empleado y jefe, y composición entre empresa y empleado.

Ejercicio 3

Necesitamos gestionar un hotel para perros. El capacidad del hotel es de 10 perros. Perso siempre necesitaremos conocer el número de perros registrados. Al registrar un perro le pedimos nombre, peso y color.
También necesitamos alimentarlos, todos a la vez. Al alimentarlos se les da 500 gr. de pienso, y engordan medio kilo.
Al sacarlos al patio media hora, adelgazan medio kilo. Debemos tener siempre actualizado el peso de los perros.

Algunos clientes se han quejado, de que a todos los perros les damos la misma cantidad de comida. Necesitaremos que algunos perros se le suministre una cantidad específica. Y va a depender del peso que tengan.

Crea funcionalidades básicas, como mostrar todos los perros, número de perros en el hotel, alimentar, sacarlos, registrar perros etc…