Clases abstractas, sobrescritura y polimorfismo

¿Cuándo conviene especializar una clase?

En «La Viñeta» tenemos Producto, Cliente, Venta y DetalleVenta. Hasta ahora un producto tiene código, nombre, precio y stock. Supongamos que la tienda empieza a vender dos tipos de artículos con maneras distintas de calcular su precio final.

¿Qué es una clase abstracta?

Una clase abstracta representa una base común para otras clases. Puede declarar atributos, constructores y métodos con código, pero también métodos abstractos, que no tienen implementación en esa clase.

public abstract class Producto {
    private long codigo;
    private String nombre;
    private double precioBase;
    private int stock;

    public Producto(long codigo, String nombre,
                    double precioBase, int stock) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.precioBase = precioBase;
        this.stock = stock;
    }

    public String getNombre() { return nombre; }
    public double getPrecioBase() { return precioBase; }
    public long getCodigo() { return codigo; }
    public int getStock() { return stock; }

    public abstract double calcularPrecioFinal();
}

La palabra abstract impide crear directamente un objeto de Producto. Sí podremos declarar variables de tipo Producto para guardar referencias a objetos de clases concretas.

La misma operación, dos implementaciones

Cuando una subclase da su propia implementación de un método heredado hablamos de sobrescritura (override). Usamos @Override para pedirle al compilador que compruebe que realmente estamos sobrescribiendo un método.

public class Comic extends Producto {
    private double recargoEdicion;

    public Comic(long codigo, String nombre, double precioBase,
                 int stock, double recargoEdicion) {
        super(codigo, nombre, precioBase, stock);
        this.recargoEdicion = recargoEdicion;
    }

    @Override
    public double calcularPrecioFinal() {
        return getPrecioBase() + recargoEdicion;
    }
}

public class FiguraColeccionable extends Producto {
    private double costoProteccion;

    public FiguraColeccionable(long codigo, String nombre,
                               double precioBase, int stock,
                               double costoProteccion) {
        super(codigo, nombre, precioBase, stock);
        this.costoProteccion = costoProteccion;
    }

    @Override
    public double calcularPrecioFinal() {
        return getPrecioBase() + costoProteccion;
    }
}

Ambas clases son productos y comparten estado y operaciones. Pero calculan el precio final de manera distinta. En esta simplificación, los recargos son importes fijos en pesos uruguayos.

super() no es lo mismo que super.metodo()

Para observar super.metodo(), supongamos que agregamos a Producto un método concreto:

public String descripcion() {
    return getCodigo() + " - " + getNombre();
}

@Override
public String descripcion() {
    return super.descripcion() + " (cómic)";
}

Polimorfismo por herencia

Una variable de tipo Producto puede contener una referencia a un Comic o una FiguraColeccionable. Cuando llamamos a un método sobrescrito, Java ejecuta la implementación del objeto real (despacho dinámico).

public class Main {
    public static void main(String[] args) {
        Producto a = new Comic(101, "Mafalda especial", 450, 5, 50);
        Producto b = new FiguraColeccionable(
                202, "Figura robot", 1200, 3, 180);

        System.out.println(a.calcularPrecioFinal()); // 500.0
        System.out.println(b.calcularPrecioFinal()); // 1380.0
    }
}

Una lista de productos de diferentes tipos

El SCORM 04 presentó List, ArrayList y polimorfismo por interfaces. Ahora combinamos esos conocimientos con polimorfismo por herencia.

import java.util.ArrayList;
import java.util.List;

public class CatalogoDemo {
    public static void main(String[] args) {
        List<Producto> catalogo = new ArrayList<>();
        catalogo.add(new Comic(101, "Mafalda", 450, 5, 50));
        catalogo.add(new FiguraColeccionable(
                202, "Figura robot", 1200, 3, 180));

        for (Producto producto : catalogo) {
            System.out.println(producto.getNombre() + " : $"
                    + producto.calcularPrecioFinal());
        }
    }
}

La lista admite ambos objetos porque ambos son subtipos de Producto. El recorrido no necesita conocer las clases concretas para calcular y mostrar el precio final.

Clase abstracta e interfaz: ¿cuál utilizamos?

En «La Viñeta», una clase abstracta Producto podría reunir estado y operaciones comunes a tipos de productos. Una interfaz como List define operaciones disponibles para distintas estructuras de datos.

¿Qué hemos aprendido?

Cierre de la unidad: pasamos de analizar entidades y responsabilidades a construir objetos, relacionarlos, organizarlos en colecciones y aprovechar herencia y polimorfismo. Ya tenemos una base para comprender Swing y la futura arquitectura de la aplicación.