Polimorfismo en Java

En Java hay un concepto que a veces reulta algo confuso: ¿cual es la diferencia entre una clase abstracta y una interface? ¿qué es un polimorfismo y en qué se diferencia de una interface? ?¿?!?

Leyendo y buscando por ahí voy a intentar que quede todo claro con este post.

Polimorfismo

Característica de Java que permite tomar como algo igual a un nivel superior dos cosas que son diferentes a

un nivel más bajo. Ejemplo: animal, gato y perro. Los dos son animales a un nivel alto de abstracción (animal) pero diferentes a un nivel inferior. El polimorfismo básicamente permite olvidarse de ciertas carcterísticas específicas de varios objetos para centrarse en lo que tengan en común, en lo que los haga iguales.

Java logra ofrecer esta habilidad gracias a dos cosas: las clases y métodos abstractos y las interfaces. Por lo tanto estas dos características hacen posible el polimorfismo en Java. Pero aquí surge una duda: ¿entonces en qué se diferencia una clase abstracta de una interface? ¿qué los hace diferentes? al fin y al cabo los métodos abstractos no tienen cuerpo, y los de una interface tampoco. Parecen lo mismo, pero no lo son.

Abstract Classes versus Interfaces

Unlike interfaces, abstract classes can contain fields that are not static and final, and they can contain implemented methods. Such abstract classes are similar to interfaces, except that they provide a partial implementation, leaving it to subclasses to complete the implementation. If an abstract class contains only abstract method declarations, it should be declared as an interface instead.

Multiple interfaces can be implemented by classes anywhere in the class hierarchy, whether or not they are related to one another in any way. Think of Comparable or Cloneable, for example.

By comparison, abstract classes are most commonly subclassed to share pieces of implementation. A single abstract class is subclassed by similar classes that have a lot in common (the implemented parts of the abstract class), but also have some differences (the abstract methods).

Por lo tanto, se puede decir que lo que diferencia una interface de una clase abstracta es que estas últimas pueden implementar métodos completos o partes de ellos que luego heredarán sus subclases, además de poder definir atributos. Es decir, una clase abstracta puede definir más concretamente la forma de sus futuras subclases, y una interface nunca puede definir nada acerca de la forma de las clases que la implementen, sólo los servicios que éstas deberán implementar, y no puede definir atributos (sólo statics y finals).

Si una clase implementa un método abstracto, esta clase debe ser declarada abstracta y no se podrá instanciar. Sus subclases heredarán todo extendiéndola, y a su vez, se da la posibilidad también de que éstas sean clases abstractas que definan más métodos abstractos.

Un ejemplo del uso de clases abstractas:

First, you declare an abstract class, GraphicObject, to provide member variables and methods that are wholly shared by all subclasses, such as the current position and the moveTo method. GraphicObject also declares abstract methods for methods, such as draw or resize, that need to be implemented by all subclasses but must be implemented in different ways. The GraphicObject class can look something like this:

abstract class GraphicObject {
    int x, y;
    ...
    void moveTo(int newX, int newY) {
        ...
    }
    abstract void draw();
    abstract void resize();
}

Each non-abstract subclass of GraphicObject, such as Circle and Rectangle, must provide implementations for the drawand resize methods:

class Circle extends GraphicObject {
    void draw() {
        ...
    }
    void resize() {
        ...
    }
}
class Rectangle extends GraphicObject {
    void draw() {
        ...
    }
    void resize() {
        ...
    }
}

En este ejemplo se puede ver como GraphicObject implementa al 100% el método que define cómo se moverán estos objetos y sus variables, pero no la forma en la que se pintan o redimensionan, ya que es específica para cada subclase.

¿Ya se diferencia? Pues…¿qué pasa cuando una clase abstracta implementa una interface?

When an Abstract Class Implements an Interface

In the section on Interfaces , it was noted that a class that implements an interface must implement all of the interface’s methods. It is possible, however, to define a class that does not implement all of the interface methods, provided that the class is declared to be abstract. For example,

abstract class X implements Y {
  // implements all but one method of Y
}

class XX extends X {
  // implements the remaining method in Y
}

In this case, class X must be abstract because it does not fully implement Y, but class XX does, in fact, implement Y

Por lo tanto una clase abstracta que implemente una interface se puede permitir el lujo de no implementar todos sus métodos, sólo los comunes a sus futuras subclases. Sus subclases, estarán obligadas a implementar todos los metodos abstractos definidos en la clase abstracta, mas todos los definidos por la interface que no estén implementados en la clase abstracta.

Todo en:

http://java.sun.com/docs/books/tutorial/java/IandI/abstract.html