Las Clases abstractas y los interfaces

Las Clases abstractas y los interfaces son mecanismos que nos ayudan a definir estructuras abstractas, que son especificadas en las clases que las implementan de acuerdo a sus necesidades. Esto habilita al programador de Java a definir un grado de abstracción en sus desarrollos, posibilitando una programación más estructurada y modular, favoreciendo la reutilización del código.

Clases abstractas

Las Clases abstractas nos permiten un mayor nivel de abstracción al definir la estructura de los objetos de nuestro programa. Podemos indicar solamente que comportamiento hay que definir, pero no indicar como. En la práctica esto se traduce en declarar un método, pero no implementarlo. Esto lo indicamos empleando el modificador abstract, que se incluirá tanto en la firma del método como de la Clase que lo contiene.

Actividad: Ejemplo de Clases abstractas

1. Abrimos un nuevo proyecto de Java en nuestro IDE de trabajo.
2. Definimos la superclase abstracta, que incluye el modificador abstract en su declaración.

abstract class Animal {
    public abstract String comer();
}

3. Definimos la subclase que implementa el método abstracto.

class Leon extends Animal{
    public String comer(){
        return "carne";
    }
}

4. Finalmente probamos dicho método desde el programa principal

public class Main {
    public static void main(String[] args) {
        Animal animal = new Leon();
        String comida=animal.comer();
        System.out.println("El Leon come: "+comida);
    }
}

5. El resultado de ejecutar el programa es:

El Leon come: carne

Interfaces

Las interfaces definen un conjunto de métodos abstractos que posteriormente serán implementadas por Clases. Es decir, una interface únicamente contiene la declaración de un conjunto de métodos que no están implementados.

Es un nivel más de abstracción en el que únicamente definimos lo que hay que hacer, aunque no como hay que hacerlo. Empleando interfaces conseguimos que clases muy distintas compartan comportamientos.

Una clase que implemente una interface, lo indica en su declaración añadiendo la palabra clave implements y los nombres de los interfaces que implementa. Y la clase está obligada a definir todos los métodos del interfaz que implementa salvo que sea declarada como abstracta, en cuyo caso, sus subclases tendrán que proporcionar las implementaciones que falten.

Podría entenderse que la clase que implementa una interface hereda los métodos abstractos de este. La ventaja del mecanismo del interface frente a la herencia, es que una clase puede implementar varios interfaces, mientras que sólo puede tener una superclase de la que herede.

Actividad: Implementando interfaces

1. Abrimos un nuevo proyecto de Java en nuestro IDE de trabajo.
2. Definimos nuestra interface, en este caso con dos métodos:

interface Figura {
    double calcularArea();
    double calcularPerimetro();
}

3. Puede verse que ambos métodos están solamente declarados, acabando la declaración con “;” , sin ningún bloque de instrucciones a continuación.
4. Definimos ahora dos clases que representan objetos distintos para las que tendría sentido implementar esta interface: las clases son Circulo y cuadrado.

class Circulo implements Figura {
    private double radio;

    public Circulo(double radio) {
        this.radio = radio;
    }

    @Override
    public double calcularArea() {
        return Math.PI * radio * radio;
    }

    @Override
    public double calcularPerimetro() {
        return 2 * Math.PI * radio;
    }
}

class Cuadrado implements Figura {
    private double lado;

    public Cuadrado(double lado) {
        this.lado = lado;
    }

    @Override
    public double calcularArea() {
        return lado * lado;
    }

    @Override
    public double calcularPerimetro() {
        return 4 * lado;
    }
}

5. Finalmente, instanciamos objetos de ambas clases con los que probamos los métodos implementados.

public class Main {
    public static void main(String[] args) {
        Figura circulo = new Circulo(5.0);
        Figura cuadrado = new Cuadrado (2.0);

        System.out.println("Área del círculo: " + circulo.calcularArea());
        System.out.println("Perímetro del círculo: " + circulo.calcularPerimetro());

        System.out.println("Área del cuadrado: " + cuadrado.calcularArea());
        System.out.println("Perímetro del cuadrado: " + cuadrado.calcularPerimetro());
    }
}

6. Y el resultado de ejecutar nuestro programa es:

Área del círculo: 78.53981633974483
Perímetro del círculo: 31.41592653589793
Área del cuadrado: 4.0
Perímetro del cuadrado: 8.0

NOTA:

Este post es parte de la colección “Java”. Puedes ver el índice de esta colección aquí.