Clases abstractas en Java

Una clase abstracta en Java es una clase que no se puede instanciar directamente, pero que se puede utilizar como base para otras clases. Las clases abstractas pueden contener métodos abstractos, que son métodos sin implementación, y métodos concretos con implementación.

Implementación

Para definir una clase abstracta en Java, se utiliza la palabra clave abstract antes de la declaración de la clase. Por ejemplo:

public abstract class ClaseAbstracta {
   // Métodos y campos de la clase abstracta
}

Una clase abstracta puede tener métodos abstractos y métodos concretos (métodos ya implementados). Los métodos abstractos se definen sin implementación, utilizando el modificador abstract. Por ejemplo:

public abstract class ClaseAbstracta {
    public abstract void metodoAbstracto();

    public void metodoConcreto() {
        // Implementación del método concreto
    }
}

Las clases que extienden una clase abstracta deben implementar todos los métodos abstractos de la clase base. Esto se logra proporcionando una implementación concreta para cada método abstracto.

Usos y Ventajas

Las clases abstractas se utilizan comúnmente en situaciones donde se desea crear una clase base que proporcione una implementación parcial o predeterminada para algunas funcionalidades, pero que permita a las subclases proporcionar implementaciones específicas para otras funcionalidades.

Algunas ventajas de utilizar clases abstractas son:

1. Reutilización de código: Permiten reutilizar código común en múltiples subclases.
2. Polimorfismo: Permiten el polimorfismo, lo que significa que se pueden tratar instancias de diferentes subclases como objetos de la clase base.
3. Estructura de diseño: Pueden proporcionar una estructura y un conjunto de operaciones comunes que las subclases deben implementar.

Desventajas

Algunas desventajas de utilizar clases abstractas son:

1. Acoplamiento: Las subclases están fuertemente acopladas a la clase abstracta, lo que puede dificultar cambios futuros en la jerarquía de clases.
2. Complejidad: En sistemas grandes, las jerarquías de clases abstractas pueden volverse complejas y difíciles de mantener.
3. Limitaciones de herencia: En Java, una clase solo puede extender una clase base, lo que puede limitar la reutilización de código en algunos casos.

Ejemplo: Sistema de Figuras Geométricas

Supongamos que queremos crear un sistema para manejar diferentes figuras geométricas y calcular sus áreas y perímetros. Podemos utilizar una clase abstracta FiguraGeometrica como base para todas las figuras específicas.

public abstract class FiguraGeometrica {
    private String nombre;

    public FiguraGeometrica(String nombre) {
        this.nombre = nombre;
    }

    public String getNombre() {
        return nombre;
    }

    // Método abstracto para calcular el área
    public abstract double calcularArea();

    // Método abstracto para calcular el perímetro
    public abstract double calcularPerimetro();

    @Override
    public String toString() {
        return "Figura Geométrica: " + nombre;
    }
}

La clase FiguraGeometrica define dos métodos abstractos: calcularArea() y calcularPerimetro(). Estas operaciones serán implementadas por las subclases concretas para cada tipo de figura geométrica.

Ahora, podemos crear subclases concretas para representar figuras específicas, como Rectangulo y Circulo:

public class Rectangulo extends FiguraGeometrica {
    private double base;
    private double altura;

    public Rectangulo(String nombre, double base, double altura) {
        super(nombre);
        this.base = base;
        this.altura = altura;
    }

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

    @Override
    public double calcularPerimetro() {
        return 2 * (base + altura);
    }
}

public class Circulo extends FiguraGeometrica {
    private double radio;

    public Circulo(String nombre, double radio) {
        super(nombre);
        this.radio = radio;
    }

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

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

Cada subclase implementa los métodos abstractos calcularArea() y calcularPerimetro() de acuerdo con las fórmulas correspondientes para cada figura.

Podemos crear instancias de estas clases y utilizar el polimorfismo para trabajar con ellas a través de la clase base FiguraGeometrica:

public class Main {
    public static void main(String[] args) {
        FiguraGeometrica rectangulo = new Rectangulo("Rectángulo", 4, 6);
        FiguraGeometrica circulo = new Circulo("Círculo", 3);

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

        System.out.println();

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