Vericode
Entrar

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 abstractaInterfaz
Qué esUna clase base que no está completaUn contrato: una lista de métodos que hay que tener
Se usa conextends (se hereda)implements (se implementa)
Qué da a las clases hijasAtributos y métodos ya programados, y la obligación de escribir los abstractosSolo 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:

Java
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();
}
Java
public class Guitarra extends Instrumento {
    public Guitarra() {
        super("guitarra");
    }

    @Override
    public void tocar() {
        System.out.println("Tlan, tlan");
    }
}
Java
public class Piano extends Instrumento {
    public Piano() {
        super("piano");
    }

    @Override
    public void tocar() {
        System.out.println("Plin, plon");
    }
}
Java
Instrumento[] orquesta = { new Guitarra(), new Piano() };
for (Instrumento i : orquesta) {
    i.afinar();
    i.tocar();
}
// Instrumento x = new Instrumento("triángulo");   // error: es abstracta
Salida
Afinando 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 con super(...).

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):

Java
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:

Java
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;
    }
}
Java
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;
    }
}
Java
Mascota[] mascotas = { new Perro("Toby"), new Gato("Misi") };
for (Mascota m : mascotas) {
    m.jugar();
}
Salida
Toby persigue la pelota
Misi juega con un ovillo

Perro 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:

Java
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();
}
Java
public interface Guardian {
    void vigilar();
}
Java
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");
    }
}
Java
PerroPastor laika = new PerroPastor("Laika");
laika.comer();       // de Animal: Laika está comiendo
laika.hacerRuido();  // ¡Guau!
laika.vigilar();     // de Guardian: Laika vigila el rebaño

Se 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:

Java
Instrumento flauta = new Instrumento("flauta") {
    @Override
    public void tocar() {
        System.out.println("Fiuuu");
    }
};
flauta.afinar();   // Afinando flauta
flauta.tocar();    // Fiuuu

Parece 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 maneraInterfaz
Una clase necesita cumplir varios contratos a la vezInterfaces (una clase puede implementar muchas)
Hay una relación «es un» claraClase 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íntomaQué significaCómo se arregla
Instrumento is abstract; cannot be instantiatedHaces 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 InstrumentoLa hija no escribe un método abstracto del padre, o de una interfaz que implementaEscribe ese método en la hija, con la misma firma
missing method body, or declare abstractUn método sin cuerpo en una clase normalPonle cuerpo { … }, o márcalo abstract (y la clase también)
attempting to assign weaker access privileges; was publicAl implementar un método de una interfaz, no le has puesto publicLos métodos de una interfaz se implementan siempre con public
interface expected here / no interface expected hereHas usado implements con una clase, o extends con una interfazClases con extends; interfaces con implements