Introducción a Java

• Polimorfismo
• Sobrecarga de métodos

Polimorfismo

En muchas ocasiones, cuando utilizamos herencia podemos terminar teniendo una familia de clases que comparten un interfaz común. Por ejemplo, si creamos un nuevo fichero que contenga a Mamifero y Gato le añadimos:

class Perro extends Mamifero {
  int numero_patas;
  public void mover() {
    System.out.println("Ahora es un perro el que se mueve");
  }
}

public class Polimorfismo {
  public static void muevete(Mamifero m) {
    m.mover();
  }
  public static void main(String[] args) {
    Gato bisho = new Gato();
    Perro feo = new Perro();
    muevete(bisho);
    muevete(feo);
  }
}

Vemos que el método muevete llama al método mover de un mamífero. El no sabe con qué clase de mamífero trata, pero la cosa funciona y se llama al método correspondiente al objeto específico que lo llama (es decir, primero un gato y luego un perro). Y esto no sólo se aplica a los métodos. Por ejemplo, podemos reescribir el código del procedimiento principal:

public static void main(String[] args) {
  Mamifero bisho = new Gato();
  muevete(bisho);
  bisho = new Perro();
  muevete(bisho);
}

Y vemos que funciona exactamente igual. El polimorfismo consiste en que toda referencia a un objeto de una clase específica puede tomar la forma de una referencia a un objeto de una clase heredada a la suya.

 Sobrecarga de métodos

El concepto de polimorfismo, en cuanto a cambio de forma, se puede extender a los métodos. Java permite que varios métodos dentro de una clase se llamen igual, siempre y cuando su lista de parámetros sea distinta. Por ejemplo, si tuviéramos un método que sirviera para sumar números pero sin indicar de qué tipo:

/** Diversos modos de sumar */
public class Sumar {
  public float suma(float a, float b) {
    System.out.println("Estoy sumando reales");
    return a+b;
  }
  public int suma(int a, int b) {
    System.out.println("Estoy sumando enteros");
    return a+b;
  }
  public static void main(String[] args) {
    float x = 1, float y = 2;
    int v = 3, int w = 5;
    System.out.println(suma(x,y));
    System.out.println(suma(v,w));
  }
}

Esto también se aplica a los constructores. De hecho, es la aplicación más habitual de la sobrecarga:

/** Calcula el area de un rectangulo
 */
public class Rectangulo {
  private float x1,y1,x2,y2;
  public Rectangulo(float ex1, float ey1, float ex2, float ey2) {
    x1 = ex1;
    x2 = ex2;
    y1 = ey1;
    y2 = ey2;
  }
  public Rectangulo() {
    x1 = 0;
    x2 = 0;
    y1 = 1;
    y2 = 1;
  }
  public float calcularArea() {
    return (x2-x1) * (y2-y1);
  }
  public static void main(String[] args) {
    Rectangulo prueba1 = new Rectangulo(1,4,7,6);
    Rectangulo prueba2 = new Rectangulo();
    System.out.println(prueba1.calcularArea());
    System.out.println(prueba2.calcularArea());
  }
}