Programación orientada a objetos Tema 7
Clases abstractas e interfaces
Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.
A veces una clase padre sabe qué tienen que hacer sus hijas, pero no cómo. Todos los instrumentos suenan, pero no hay un sonido de «instrumento»: suena una guitarra o suena un piano. Y no tiene sentido crear un «instrumento» a secas, solo guitarras, pianos…
Para eso hay dos herramientas, que sirven para asegurarse de que otras clases cumplen una estructura y no se olvidan de ningún método:
| Clase abstracta | Interfaz | |
|---|---|---|
| Qué es | Una clase base que no está completa | Un contrato: una lista de métodos que hay que tener |
| Se usa con | extends (se hereda) | implements (se implementa) |
| Qué da a las clases hijas | Atributos y métodos ya programados, y la obligación de escribir los abstractos | Solo la obligación de escribir sus métodos |
| Se lee | «es un» | «puede», «sabe hacer» |
Clases abstractas#
Una clase abstracta se marca con abstract y puede tener métodos normales, con su código, y métodos abstractos: sin cuerpo, solo la firma acabada en ;. Cada hija está obligada a escribir los abstractos:
public abstract class Instrumento {
protected String nombre;
public Instrumento(String nombre) {
this.nombre = nombre;
}
// Método normal: el código se hereda tal cual
public void afinar() {
System.out.println("Afinando " + nombre);
}
// Método abstracto: cada instrumento suena a su manera
public abstract void tocar();
}public class Guitarra extends Instrumento {
public Guitarra() {
super("guitarra");
}
@Override
public void tocar() {
System.out.println("Tlan, tlan");
}
}public class Piano extends Instrumento {
public Piano() {
super("piano");
}
@Override
public void tocar() {
System.out.println("Plin, plon");
}
}Instrumento[] orquesta = { new Guitarra(), new Piano() };
for (Instrumento i : orquesta) {
i.afinar();
i.tocar();
}
// Instrumento x = new Instrumento("triángulo"); // error: es abstractaAfinando guitarra
Tlan, tlan
Afinando piano
Plin, plon- De una clase abstracta no se pueden crear objetos:
new Instrumento(...)da error. Sí se pueden tener variables y arrays de su tipo, y es lo habitual: es el polimorfismo del tema anterior. - Si una hija no escribe algún método abstracto, Java no la deja compilar… salvo que la hija también sea
abstract. - Puede tener constructor, aunque no se use con
new: lo llaman las hijas consuper(...).
Interfaces#
Una interfaz es un contrato puro: dice qué métodos tiene que tener una clase, sin decir cómo. Se escribe con interface, y sus métodos van sin cuerpo y sin public (todos lo son):
public interface Mascota {
void jugar();
String getNombre();
}Una clase implementa una interfaz con implements, y está obligada a escribir todos sus métodos, con public:
public class Perro implements Mascota {
private String nombre;
public Perro(String nombre) {
this.nombre = nombre;
}
@Override
public void jugar() {
System.out.println(nombre + " persigue la pelota");
}
@Override
public String getNombre() {
return nombre;
}
}public class Gato implements Mascota {
private String nombre;
public Gato(String nombre) {
this.nombre = nombre;
}
@Override
public void jugar() {
System.out.println(nombre + " juega con un ovillo");
}
@Override
public String getNombre() {
return nombre;
}
}Mascota[] mascotas = { new Perro("Toby"), new Gato("Misi") };
for (Mascota m : mascotas) {
m.jugar();
}Toby persigue la pelota
Misi juega con un ovilloPerro y Gato no tienen nada en común salvo que los dos saben jugar. Una interfaz describe eso: una capacidad, no lo que algo es.
Heredar de una e implementar varias#
Java no tiene herencia múltiple: una clase solo puede hacer extends de una clase. Pero puede implementar todas las interfaces que quiera, a la vez que hereda:
public abstract class Animal {
protected String nombre;
public Animal(String nombre) {
this.nombre = nombre;
}
public void comer() {
System.out.println(nombre + " está comiendo");
}
public abstract void hacerRuido();
}public interface Guardian {
void vigilar();
}public class PerroPastor extends Animal implements Guardian {
public PerroPastor(String nombre) {
super(nombre);
}
@Override
public void hacerRuido() {
System.out.println("¡Guau!");
}
@Override
public void vigilar() {
System.out.println(nombre + " vigila el rebaño");
}
}PerroPastor laika = new PerroPastor("Laika");
laika.comer(); // de Animal: Laika está comiendo
laika.hacerRuido(); // ¡Guau!
laika.vigilar(); // de Guardian: Laika vigila el rebañoSe escribe primero el extends y después el implements, y si hay varias interfaces van separadas por comas: class Pato extends Animal implements Nadador, Volador.
Clases anónimas#
Cuando hace falta un objeto de una clase abstracta o de una interfaz una sola vez, en vez de escribir una clase entera se puede crear al momento, sin nombre, con los métodos que faltan entre llaves:
Instrumento flauta = new Instrumento("flauta") {
@Override
public void tocar() {
System.out.println("Fiuuu");
}
};
flauta.afinar(); // Afinando flauta
flauta.tocar(); // FiuuuParece un new Instrumento(...), pero no lo es: crea un objeto de una clase nueva, sin nombre, que hereda de Instrumento y escribe su tocar(). Se usa mucho con las interfaces gráficas, para decir qué hace un botón al pulsarlo.
Dentro de una clase anónima se pueden usar las variables del método en que se escribe, pero no cambiarlas: Java le da una copia, y la variable tiene que ser final o, al menos, no cambiar nunca (lo que Java llama efectivamente final). Si se intenta, el error es local variables referenced from an inner class must be final or effectively final.
¿Clase abstracta o interfaz?#
| Si… | Usa |
|---|---|
| Las clases comparten atributos o código (todos los animales tienen nombre y comen igual) | Clase abstracta |
| Solo comparten qué saben hacer, y cada una lo hace a su manera | Interfaz |
| Una clase necesita cumplir varios contratos a la vez | Interfaces (una clase puede implementar muchas) |
| Hay una relación «es un» clara | Clase abstracta |
| Es una capacidad que pueden tener clases muy distintas («se puede comparar», «se puede guardar») | Interfaz |
En las dos, recuerda: no se pueden crear objetos de ellas con new, solo de las clases que las heredan o implementan.
Errores frecuentes#
| Mensaje o síntoma | Qué significa | Cómo se arregla |
|---|---|---|
Instrumento is abstract; cannot be instantiated | Haces new de una clase abstracta (o de una interfaz) | Crea un objeto de una clase hija: new Guitarra() |
Guitarra is not abstract and does not override abstract method tocar() in Instrumento | La hija no escribe un método abstracto del padre, o de una interfaz que implementa | Escribe ese método en la hija, con la misma firma |
missing method body, or declare abstract | Un método sin cuerpo en una clase normal | Ponle cuerpo { … }, o márcalo abstract (y la clase también) |
attempting to assign weaker access privileges; was public | Al implementar un método de una interfaz, no le has puesto public | Los métodos de una interfaz se implementan siempre con public |
interface expected here / no interface expected here | Has usado implements con una clase, o extends con una interfaz | Clases con extends; interfaces con implements |