Herencia, interfaces y polimorfismo en Java

La herencia crea una subclase a partir de una superclase existente. En class Student extends Person, todo estudiante es una persona. Un objeto estudiante contiene su estado de persona y su estado adicional de estudiante juntos en un solo objeto.

Añade las partes específicas del estudiante

Aquí tienes una pequeña superclase y una subclase:

class Person {
    private String name;
    public Person(String name) { this.name = name; }
    public String getName() { return name; }
}

class Student extends Person {
    private int credits;
    public Student(String name) { super(name); }
    public void study() { credits += 5; }
    public int getCredits() { return credits; }
}

Student hereda getName(). Añade un campo de créditos y dos métodos. Después de Student s = new Student("Ada Lovelace");, el campo de créditos comienza en 0. Dos llamadas a s.study() lo aumentan primero a 5 y luego a 10. s.getName() sigue devolviendo «Ada Lovelace»: el método heredado lee el campo privado declarado en Person.

La sentencia super(name) pasa el nombre al constructor de Person. Los constructores no se heredan, por lo que Student declara su propio constructor. Una subclase puede añadir métodos y sobrescribir el comportamiento heredado, pero no puede eliminar un método público heredado de su interfaz pública.

Identifica a qué miembros se puede acceder

Los miembros privados no se heredan. El campo privado name sigue existiendo dentro de cada estudiante, pero Student no puede leerlo directamente. Mantener el campo privado y proporcionar un método de acceso permite que Person controle sus propios datos. Entre paquetes, el acceso a instancias protected tiene una restricción adicional: el código de la subclase accede al miembro a través de sí mismo o de una referencia de su propio tipo de subclase, no a través de una referencia arbitraria de la superclase.

Comprueba la relación antes de extender

Java permite una superclase directa por clase. Una cadena como GraduateStudent extends Student y Student extends Person es válida; extends Student, Teacher no lo es. Una clase sin superclase explícita extiende Object. El propio Object no tiene superclase.

Utiliza la prueba de «es un»: ¿puede utilizarse cada objeto de la subclase donde se espere la superclase? Un camión es un vehículo. Un cliente tiene una dirección, pero un cliente no es una dirección. Para esa segunda relación, utiliza la composición:

class Customer {
    private Address address;
}

Aquí Address es otra clase. El campo permite que un cliente utilice una dirección sin afirmar que es una. Extender una clase solo para aprovechar un método útil también hereda todo su contrato público. Por último, una clase final no puede extenderse. Como String es final, class ShortString extends String no compila.

Un constructor de subclase debe organizar la construcción de la parte de la superclase del mismo objeto. Puede llamar a un constructor de la superclase con super(...) o delegar en otro constructor de su propia clase con this(...).

Elige el constructor de la superclase

class Person {
    private final String name;
    Person(String name) { this.name = name; }
}
class Student extends Person {
    private final String studentId;
    Student(String name, String studentId) {
        super(name);
        this.studentId = studentId;
    }
    Student(String name) {
        this(name, "no id yet");
    }
}

El constructor de dos argumentos pasa el nombre a Person y almacena él mismo el identificador. El constructor de un argumento delega en él. Un constructor contiene como máximo una invocación explícita de constructor: this(...) o super(...). Al seguir la cadena de this(...) se llega finalmente a un constructor que invoca super(...).

Si no se escribe ninguna de las dos, Java inserta super(). Aquí falla porque Person solo tiene un constructor que requiere un nombre. Declarar cualquier constructor impide que Java proporcione un constructor predeterminado sin argumentos. Una clase sin constructores declarados recibe uno predeterminado que llama a super().

Escribir new Person(name) dentro de Student hace otra cosa: construye un objeto independiente. No inicializa el estado de persona del estudiante actual ni sustituye la llamada obligatoria al constructor de la superclase.

Sigue la inicialización en orden

class Base {
    Base() { System.out.println("Base ready"); }
}
class Middle extends Base {
    Middle() { System.out.println("Middle ready"); }
}
class Top extends Middle {
    Top() { super(); System.out.println("Top ready"); }
}

new Top() entra en la cadena de constructores hasta llegar a Object. A medida que retornan las llamadas, la salida es «Base ready», «Middle ready» y luego «Top ready». Los inicializadores de campos de cada clase se ejecutan después de que retorne el constructor de su superclase y antes del resto del cuerpo del constructor de esa clase.

Un método sobrescribible llamado por un constructor de la superclase ya puede ejecutar una sobrescritura de la subclase. Si esa sobrescritura lee un campo de referencia de la subclase cuya asignación aún no se ha ejecutado, encuentra null, incluso si el campo tiene un inicializador en su declaración. Limita el trabajo de los constructores a inicializar el estado; evita llamar a métodos que las subclases puedan sobrescribir.

Reconoce el cambio de Java 25

En Java 25, un constructor puede validar parámetros antes de su invocación explícita de constructor:

Student(String name, String studentId, int credits) {
    if (credits < 0) {
        throw new IllegalArgumentException("negative credits");
    }
    super(name);
    this.studentId = studentId;
}

Java 25 también permite asignaciones simples anticipadas a campos declarados en la clase actual sin inicializadores en su declaración. Sigue prohibiendo leer los campos del objeto actual, llamar a sus métodos de instancia o pasar this antes de la invocación. Para los niveles estándar del lenguaje anteriores a Java 25, mantén super(...) o this(...) en primer lugar. Java 22–24 ofrecía formas anteriores como funciones de vista previa.

Una sobrescritura proporciona a una subclase su propia implementación de un método de instancia heredado. Su nombre y los tipos de sus parámetros coinciden con los del método original, por lo que quienes lo llaman pueden seguir utilizando la misma operación.

Amplía un método que funciona

Supón que el salario anual de un empleado equivale a doce pagos mensuales. Un gerente también recibe una bonificación anual:

class Employee {
    private final double monthlySalary;
    Employee(double monthlySalary) {
        this.monthlySalary = monthlySalary;
    }
    public double yearlyPay() { return 12 * monthlySalary; }
}
class Manager extends Employee {
    private final double bonus;
    Manager(double monthlySalary, double bonus) {
        super(monthlySalary);
        this.bonus = bonus;
    }
    @Override
    public double yearlyPay() {
        return super.yearlyPay() + bonus;
    }
}

Para new Manager(3000.0, 5000.0), la llamada a la superclase devuelve 36 000,0. Al sumar 5000,0 se obtiene 41 000,0. super.yearlyPay() selecciona deliberadamente la implementación de la superclase. El método de la superclase sigue disponible dentro de la subclase, aunque las llamadas ordinarias sobre el gerente ejecutan la sobrescritura.

Escribir return yearlyPay() + bonus; vuelve a llamar al propio método del gerente. Ninguna llamada termina, por lo que la ejecución acaba fallando con StackOverflowError. La ausencia de super. cambia el significado de la llamada.

Deja que el compilador compruebe la firma

Pon @Override encima de cada método que sobrescriba otro. Un error de escritura como yearlypay() o un parámetro adicional provoca entonces un error de compilación. Sin la anotación, Java puede aceptar un método nuevo que quienes llaman al método nunca utilizan.

Una sobrescritura válida sigue estas reglas:

• Sus tipos de parámetros coinciden exactamente.
• Su tipo de retorno es el mismo o un subtipo cuando devuelve un tipo de objeto. Esa reducción permitida es un tipo de retorno covariante.
• Su acceso es al menos tan abierto como el del método heredado.
• No añade excepciones comprobadas que la declaración heredada prohíba.

Por ejemplo, public String toString() no puede sustituirse por String toString() con acceso de paquete. Quienes ya lo llaman deben conservar el acceso.

Distingue la sobrescritura de la sobrecarga y la ocultación

role() y role(String language) son métodos sobrecargados; el segundo no sustituye al primero. La elección de la sobrecarga utiliza los tipos declarados de los argumentos en tiempo de compilación. Los métodos estáticos también se seleccionan a partir del tipo utilizado en tiempo de compilación, por lo que no se sobrescriben dinámicamente.

Un método privado no se hereda; un método de la subclase con el mismo nombre es independiente. Un método final no puede sobrescribirse y los constructores no pueden sobrescribirse. Además de compilar, el método debe seguir cumpliendo su propósito original. Una sobrescritura de gerente que devolviera el salario mensual haría fallar el código que suma salarios anuales, aunque su firma fuera correcta.

Toda clase de Java extiende Object directa o indirectamente. Los arreglos también son objetos. Esta raíz común proporciona métodos como toString(), equals(Object), hashCode() y getClass(), incluso cuando una clase no declara ninguno de ellos.

Sustituye la descripción impresa predeterminada

El método heredado Object.toString() produce un nombre de clase, @ y el código hash del objeto en hexadecimal. Un texto como «school.Person@1b6d3586» identifica la clase, pero no explica los datos de la persona. El número puede cambiar entre ejecuciones y Java no garantiza que sea una dirección de memoria.

Una sobrescritura útil muestra los campos que necesitan quienes leen la salida. Aquí un estudiante ha heredado getName() y almacena un campo credits:

@Override
public String toString() {
    return getName() + " (" + credits + " credits)";
}

Para un estudiante llamado Ada Lovelace con 10 créditos, System.out.println(s) imprime «Ada Lovelace (10 credits)». La llamada de impresión obtiene automáticamente el texto del objeto. La concatenación de cadenas también lo hace: "Student: " + s incluye la misma descripción.

Para una referencia nula, la impresión y la concatenación producen «null». Una llamada explícita s.toString() cuando s es null lanza una NullPointerException, porque no hay ningún objeto que reciba esa llamada.

Si Person.toString() ya devuelve el nombre de la persona, una subclase puede basarse en él:

@Override
public String toString() {
    return super.toString() + ", student id " + studentId;
}

Para el identificador «S-17», eso produce «Ada Lovelace, student id S-17». La utilidad de super.toString() depende de lo que devuelva realmente la superclase. Si sigue utilizando la versión de Object, aporta el texto predeterminado de clase y hash.

Distingue la identidad de la información sobre la clase

Object.equals(Object) compara la identidad: devuelve verdadero cuando ambas referencias hacen referencia al mismo objeto. Dos objetos new Person("Ada") independientes no son iguales según esa implementación heredada, aunque tengan el mismo nombre. Clases como String, Integer y ArrayList proporcionan sobrescrituras basadas en valores.

getClass() indica la clase real en tiempo de ejecución:

Person p = new Student("Ada Lovelace");
System.out.println(p.getClass().getSimpleName());

Esto imprime «Student» cuando Student tiene el constructor mostrado. El tipo declarado de la variable no altera la clase del objeto. getClass() es final y no puede sobrescribirse.

hashCode() da soporte a las colecciones basadas en hash. Otros métodos de Object incluyen el protegido clone() y los métodos de coordinación de hilos wait(), notify() y notifyAll().

Comprueba la escritura exacta

Java distingue toString() de tostring(). Un método toString(String prefix) es una sobrecarga, por lo que la impresión no lo llama. @Override detecta ambos errores. Una representación textual tampoco define la igualdad: dos objetos pueden imprimir el mismo texto y aun así compararse como desiguales.

Dos objetos pueden representar el mismo valor sin ser el mismo objeto. Un catálogo de libros puede considerar iguales dos objetos libro cuando coinciden su código de catálogo y su edición. Define esa regla sobrescribiendo equals(Object) y mantén el código hash coherente con ella.

Compara los campos que definen el valor

import java.util.Objects;

final class Book {
    private final String code;
    private final int edition;
    Book(String code, int edition) {
        this.code = code;
        this.edition = edition;
    }
    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof Book b)) return false;
        return edition == b.edition && Objects.equals(code, b.code);
    }
    @Override
    public int hashCode() {
        return Objects.hash(code, edition);
    }
}

La comprobación de identidad acepta rápidamente el mismo objeto. La comprobación de tipo rechaza un objeto no relacionado o null y luego introduce b como un Book. Las ediciones primitivas utilizan ==; Objects.equals compara los códigos de forma segura incluso cuando un código es null. Dos libros con el código «B-1042» y la edición 2 se comparan como iguales. La edición 3 constituye un valor diferente.

El parámetro debe ser Object. Escribir equals(Book other) añade una sobrecarga; deja intacto el equals(Object) heredado. El código de biblioteca que llame a esa firma seguiría comparando la identidad. @Override hace que la declaración incorrecta falle en tiempo de compilación.

Cumple los compromisos de igualdad

Para referencias no nulas, la igualdad debe ser:

• Reflexiva: un objeto es igual a sí mismo.
• Simétrica: intercambiar los dos objetos da la misma respuesta.
• Transitiva: si uno es igual a un segundo y el segundo es igual a un tercero, el primero es igual al tercero.
• Consistente: las comparaciones repetidas coinciden mientras los datos comparados no cambien.

Un objeto también debe compararse como desigual a null. Los objetos iguales deben devolver códigos hash iguales. Los objetos desiguales pueden compartir un código hash: una colisión de hash no establece la igualdad. Deriva el hash de los mismos campos que la igualdad, como hace aquí Objects.hash(code, edition).

Una colección basada en hash utiliza el hash para localizar candidatos antes de comprobar la igualdad. Sobrescribir solo equals puede hacer que un conjunto conserve libros iguales independientes o que un mapa no encuentre una clave igual. Cambiar un campo utilizado en el cálculo del hash mientras su objeto está almacenado como clave puede dejar ese objeto guardado según su hash anterior.

Protege la simetría entre subclases

Supón que un Book extensible acepta cualquier instanceof Book, mientras que Ebook añade el tamaño del archivo a la igualdad y solo acepta libros electrónicos. Un libro puede aceptar un libro electrónico con el mismo código y edición, pero el libro electrónico rechaza el libro. La comparación ha perdido la simetría.

Una opción exige que las clases en tiempo de ejecución coincidan y comprueba null antes de getClass(). Otra hace que la igualdad de la superclase sea final para que las subclases no puedan ampliar la regla de igualdad. Una clase de valor final, como la anterior, evita por completo la igualdad entre subclases. Los registros generan la igualdad y los códigos hash a partir de sus componentes; las constantes de enumeración ya tienen una igualdad basada en la identidad adecuada para sus valores fijos.

Una clase abstracta es una clase base que no puede instanciarse directamente. Puede contener campos comunes y métodos funcionales, y dejar determinadas operaciones para que las subclases las completen.

Deja abstracta una operación requerida

abstract class Shape {
    private final String name;
    Shape(String name) { this.name = name; }
    public abstract double area();
    public String describe() {
        return name + " with area " + area();
    }
}
class Rectangle extends Shape {
    private final double width;
    private final double height;
    Rectangle(double width, double height) {
        super("rectangle");
        this.width = width;
        this.height = height;
    }
    @Override
    public double area() { return width * height; }
}

area() tiene una firma y un punto y coma, sin cuerpo. Indica lo que debe proporcionar cada figura concreta. Como Shape contiene un método abstracto, la clase también debe ser abstracta. Rectangle proporciona la implementación que falta y puede instanciarse.

Para new Rectangle(3.0, 4.0), el constructor de la superclase almacena «rectangle». El constructor de la subclase almacena las dimensiones. Su área es de 12,0 metros cuadrados cuando las dimensiones están en metros. Llamar a describe() devuelve «rectangle with area 12.0». La llamada a area() del método heredado ejecuta la implementación del rectángulo.

Utiliza constructores y métodos concretos normalmente

Una clase abstracta puede tener campos, constructores y métodos con cuerpo, con los niveles de acceso habituales. Su constructor se ejecuta como parte de la creación de un objeto de subclase. new Shape() está prohibido incluso si existe un constructor correspondiente; new Rectangle(3.0, 4.0) es válido.

Una segunda subclase puede utilizar la misma descripción heredada mientras calcula el área de otra manera. Una implementación de círculo devuelve Math.PI * radius * radius. Para un radio de 1,5 m, el cálculo es π por 2,25, aproximadamente 7,07 metros cuadrados. El método compartido describe() no necesita una rama específica para el círculo.

Una variable puede seguir teniendo el tipo abstracto: Shape s = new Rectangle(3.0, 4.0);. Java prohíbe construir la clase abstracta, no hacer referencia a un objeto concreto a través de ella.

Haz que el trabajo pendiente produzca un error de compilación

Toda subclase concreta debe proporcionar o heredar implementaciones de todos los métodos abstractos. Una subclase que deja algunos sin terminar también debe declararse abstracta. Devolver 0 desde un area() provisional permitiría que una subclase concreta incompleta compilara y diera resultados incorrectos sin avisar. Declarar area() abstracto hace que el trabajo pendiente sea visible para el compilador.

Los métodos abstractos no pueden ser privados, estáticos ni final: cada uno impediría la sobrescritura de la subclase que proporciona la operación. Una clase abstracta puede no contener métodos abstractos; entonces el modificador solo impide la construcción directa. Utiliza este tipo de clase base cuando sus subclases superen la prueba de «es un» y se beneficien de compartir estado o código.

Una interfaz da nombre a una capacidad que varias clases pueden proporcionar. Establece los métodos disponibles mediante esa capacidad sin exigir que las clases compartan los mismos campos de instancia o la misma superclase.

Declara e implementa los métodos

interface Chargeable {
    int batteryPercent();
    void charge(int minutes);
}
class Phone implements Chargeable {
    private int battery;
    Phone(int battery) { this.battery = battery; }
    @Override
    public int batteryPercent() { return battery; }
    @Override
    public void charge(int minutes) {
        battery = Math.min(100, battery + 2 * minutes);
    }
}

Los métodos abstractos de la interfaz son implícitamente públicos. Los métodos que los implementan deben ser explícitamente públicos; omitir ese modificador reduciría el acceso y haría fallar la compilación. Una clase concreta debe proporcionar o heredar implementaciones públicas adecuadas de todos los métodos abstractos. Una clase abstracta que implemente la interfaz puede dejar algunos para sus subclases.

Para un teléfono al 35 %, charge(20) añade 40 puntos porcentuales y lo deja al 75 %. Otros 20 minutos lo llevarían a 115 antes de aplicar el límite, por lo que Math.min almacena 100. Un ElectricScooter puede implementar la misma interfaz y añadir solo un punto por minuto: si empieza al 50 %, alcanza el 70 después de 20 minutos. La interfaz establece la operación disponible, mientras que la clase proporciona su comportamiento.

Utiliza la interfaz como tipo

Chargeable device = new Phone(35);
device.charge(20);
System.out.println(device.batteryPercent());

Esto imprime 75. El código que llama puede utilizar los métodos de la interfaz y los métodos públicos disponibles en todos los objetos. Las operaciones exclusivas del teléfono no están disponibles a través de device, salvo que la interfaz declarada las exponga.

Las interfaces también pueden ser tipos de parámetros, valores de retorno y elementos de listas. Un método que acepta Chargeable puede trabajar con un teléfono o un patinete sin conocer la disposición de sus campos. La biblioteca de Java utiliza el mismo enfoque: List tiene implementaciones como ArrayList y LinkedList; Runnable declara run(); Comparable declara la comparación según el orden natural.

Combina más de una capacidad

Una clase extiende una clase y puede implementar varias interfaces. El orden es class Phone extends Device implements Chargeable, Connectable. Una interfaz puede extender varias interfaces: interface SmartDevice extends Chargeable, Connectable. Quienes la implementen deben entonces proporcionar todas las operaciones abstractas heredadas.

Una interfaz no tiene constructores ni campos de instancia. new Chargeable() no compila. Un campo declarado como int FULL = 100; es implícitamente una constante public static final, a la que se accede como Chargeable.FULL.

Un método abstracto de interfaz no aporta código funcional. Su implementación puede proceder de la propia clase o de un método público heredado de la superclase. Los métodos predeterminados son los métodos de interfaz que pueden proporcionar comportamiento de instancia heredado.

Las interfaces pueden proporcionar código funcional además de declaraciones de métodos abstractos. El modificador del método determina si los objetos que implementan la interfaz lo heredan, si se utiliza mediante el nombre de la interfaz o si solo puede utilizarlo el código dentro de ella.

Construye comportamiento predeterminado a partir del contrato

interface Chargeable {
    int batteryPercent();
    void charge(int minutes);
    default boolean needsCharge() {
        return batteryPercent() < 20;
    }
    static int clamp(int percent) {
        return Math.max(0, Math.min(100, percent));
    }
}

Un método predeterminado es un método público de instancia con cuerpo. Un teléfono que indica un 15 % hereda needsCharge() y devuelve verdadero. Al 20 % devuelve falso. El método predeterminado llama a la operación abstracta batteryPercent(); no lee un campo privado del teléfono. Una clase puede sobrescribir el método con su propia implementación pública.

Un método estático de interfaz pertenece a la interfaz: Chargeable.clamp(130) devuelve 100 y Chargeable.clamp(-5) devuelve 0. Las clases que implementan la interfaz no lo heredan, por lo que Phone.clamp(130) no es una llamada válida a este método. Los métodos predeterminados y estáticos de interfaz se introdujeron en Java 8.

Desde Java 9, una interfaz también puede declarar métodos privados para compartir código auxiliar entre sus propios métodos. Un método auxiliar privado de instancia sirve de apoyo a los métodos predeterminados; uno estático privado también puede servir de apoyo a los métodos estáticos. Las clases que implementan la interfaz no pueden llamar directamente a estos métodos auxiliares.

Resuelve conflictos entre métodos predeterminados

Dos interfaces no relacionadas pueden proporcionar la misma firma:

interface Lamp {
    default String describe() { return "lamp"; }
}
interface Speaker {
    default String describe() { return "speaker"; }
}
class SmartLamp implements Lamp, Speaker {
    @Override
    public String describe() {
        return Lamp.super.describe() + " and "
             + Speaker.super.describe();
    }
}

Sin la sobrescritura, SmartLamp tiene un conflicto y no compila. Las llamadas cualificadas InterfaceName.super.method() seleccionan los métodos predeterminados individuales de sus superinterfaces directas. Esta implementación devuelve «lamp and speaker».

Una declaración abstracta de la superclase también puede exigir que una subclase concreta implemente el método; un método predeterminado de interfaz no elimina esa obligación.

Ten en cuenta las clases que ya implementan la interfaz

Añadir un método abstracto exige que cada clase concreta que implementa la interfaz proporcione o herede una implementación correspondiente. Un método predeterminado suele evitar ese cambio al proporcionar comportamiento funcional, pero puede introducir un conflicto con otro método heredado. Los métodos predeterminados ayudan a que una interfaz evolucione; las reglas de herencia siguen determinando si las clases resultantes compilan.

Tanto una clase abstracta como una interfaz pueden definir métodos obligatorios. La elección depende de la relación entre los objetos y de si su implementación necesita estado de instancia compartido.

Compara lo que proporciona cada una

Los campos de interfaz son constantes public static final, no datos de cada objeto. Los métodos auxiliares privados de una interfaz sirven de apoyo a sus propios métodos funcionales; no crean estado privado para cada objeto que la implementa.

Coloca el estado estrechamente relacionado en una clase abstracta

Un programa de dibujo tiene círculos, rectángulos y triángulos. Cada figura almacena un nombre y una posición, y cada una calcula su área de forma diferente. Una Shape abstracta puede mantener los campos comunes y el constructor, proporcionar métodos funcionales de movimiento o descripción y declarar area() como abstracto.

Todas las figuras concretas son tipos de Shape, por lo que otro código puede pedir una figura y recibir cualquiera de ellas. Del mismo modo, una Enemy abstracta podría tener puntos de salud y un método compartido takeDamage(int points), mientras deja el movimiento a las clases de enemigos concretas. El estado compartido da a estas clases base una función útil.

Coloca una capacidad transversal en una interfaz

El mismo programa de dibujo puede exportar figuras, etiquetas de texto e imágenes. Exportar no convierte una etiqueta de texto en una figura, y estos objetos pueden necesitar ya superclases diferentes. Una interfaz Exportable puede declarar String exportText(). Cada clase implementa la operación utilizando sus propios datos.

Una clase puede combinar las dos funciones: class Circle extends Shape implements Exportable. La superclase proporciona el estado de la figura y el código compartido; la interfaz permite utilizar el círculo desde el código de exportación. Una clase que implementa varias interfaces se compromete a ofrecer varias capacidades sin heredar campos de instancia de ellas.

Combina un contrato con una implementación parcial

Una clase abstracta puede implementar una interfaz y completar solo algunos métodos. Las subclases concretas terminan las operaciones restantes. List y AbstractList de Java utilizan esta organización; ArrayList extiende AbstractList. El código que llama puede depender de la interfaz, mientras que quienes la implementan reutilizan una clase base cuando resulta adecuada.

Por ejemplo, List<String> names = new ArrayList<>(); permite añadir, leer y eliminar nombres mediante List. Sustituir el inicializador por new LinkedList<>() conserva esas llamadas. Un parámetro declarado como ArrayList<String> rechazaría un LinkedList<String> aunque solo necesite operaciones de lista.

Una clase abstracta que solo contiene métodos abstractos sigue ocupando la única posición de superclase de la subclase. No es intercambiable con una interfaz. Elige la interfaz cuando solo se necesite el contrato común y añade una clase base cuando las implementaciones relacionadas se beneficien de compartir estado o código.

El polimorfismo permite que una referencia de un tipo general apunte a objetos de distintos subtipos. El objeto conserva todo su estado y comportamiento; la referencia ofrece a quienes la utilizan una vista concreta de las operaciones disponibles.

Identifica los dos tipos

Person p = new Student("Ada Lovelace", "S-17");

El tipo declarado, también llamado tipo estático, es Person: aparece en la declaración de la variable. El tipo real, o tipo en tiempo de ejecución, es Student: esa es la clase instanciada por new. La clase real del objeto no cambia después de su construcción.

Asignar una referencia de estudiante a una referencia de persona es una conversión ascendente. Es automática y segura porque todo estudiante es una persona. También se puede hacer referencia al mismo estudiante mediante una variable Object. Un objeto que implementa una interfaz puede convertirse de forma ascendente a esa interfaz, como en Chargeable c = new Phone(35);.

La asignación no elimina ningún dato del estudiante. Sigue habiendo un solo objeto estudiante con su identificador, los datos de persona heredados y los métodos sobrescritos. Darle una referencia más general cambia aquello a lo que el compilador permite acceder mediante esa referencia.

Comprueba las llamadas según el tipo declarado

Si Person declara getName(), entonces p.getName() compila. Si solo Student declara getStudentId(), entonces p.getStudentId() no compila. El compilador comprueba la interfaz pública de Person incluso cuando el inicializador crea claramente un estudiante.

La asignación inversa Student s = p; no se acepta sin una conversión explícita. Una referencia de persona podría apuntar a una persona que no sea estudiante. Esa restricción impide que el código trate un objeto como un subtipo al que no pertenece.

Permite que los parámetros y las listas acepten varios subtipos

Un método static void printCard(Person person) puede recibir un objeto Person, Student o Teacher, suponiendo que los dos últimos extiendan Person. Su código puede apoyarse en el contrato de persona. Un tipo de retorno también puede ser general, por ejemplo, un método que devuelve un Shape.

Una lista con un tipo general de elemento puede almacenar distintas clases de figuras:

List<Shape> shapes = new ArrayList<>();
shapes.add(new Circle(1.5));
shapes.add(new Rectangle(3.0, 4.0));
for (Shape shape : shapes) {
    System.out.println(shape.area());
}

Aquí List y ArrayList proceden de java.util, y cada figura concreta proporciona area(). El bucle utiliza únicamente esa operación común.

Una List<Circle> no es una List<Shape>. Si lo fuera, el código que la recibiera como lista de figuras podría añadir un rectángulo a una lista que debe contener solo círculos. Cuando un método requiera List<Shape>, crea la lista con ese tipo de elemento desde el principio.

Una llamada a un método se resuelve en dos etapas. En tiempo de compilación, Java comprueba los tipos declarados y elige una firma de método. En tiempo de ejecución, el enlace dinámico elige la implementación sobrescrita del método de instancia para la clase real del objeto.

Sigue una llamada dentro de un método heredado

class A {
    String who() { return "A"; }
    String hello() { return "Hello from " + who(); }
}
class B extends A {
    @Override String who() { return "B"; }
}
class C extends B { }

Para A x = new C();, x.hello() está permitido porque A declara hello(). La clase C no sobrescribe hello(), y B tampoco, por lo que Java ejecuta la implementación de A.

Dentro de ese método, who() significa this.who(). El objeto receptor sigue siendo el objeto C. Java busca desde C y encuentra la implementación más cercana de who() en B. El resultado es «Hello from B». Entrar en un método heredado no convierte el objeto receptor en un objeto de la superclase.

Elige una sobrecarga antes de elegir una sobrescritura

static String kind(Object value) { return "object"; }
static String kind(String value) { return "string"; }

Dentro de una clase que contiene estos métodos, Object value = "hi"; kind(value) selecciona kind(Object) y devuelve «object». El tipo declarado de la variable es Object; Java no vuelve a considerar las sobrecargas utilizando la cadena real en tiempo de ejecución.

Para una llamada de instancia, el despacho en tiempo de ejecución todavía puede elegir una sobrescritura de la firma ya seleccionada. No puede cambiar a otra sobrecarga que simplemente parezca más específica para el argumento real. Identifica primero la firma y después busca su sobrescritura.

Reconoce las llamadas y los miembros que no se despachan de esta manera

Si P declara String label = "P"; y Q extends P declara su propio String label = "Q";, entonces P p = new Q(); p.label lee «P». Los campos se ocultan, no se sobrescriben. Ambos campos existen en el objeto. Evita reutilizar nombres de campos heredados porque el tipo de referencia puede hacer que accesos de aspecto idéntico lean estados diferentes.

super.method() selecciona la implementación de la superclase, incluida una que esa superclase herede. Si el propio método seleccionado hace una llamada ordinaria sobre this, esa llamada interna todavía puede despacharse a una sobrescritura de la subclase.

Una referencia general a veces necesita acceder a una operación que solo pertenece a un subtipo. Una conversión descendente indica al compilador que trate la referencia como ese subtipo. En tiempo de ejecución, Java comprueba si el objeto ya tiene ese tipo.

Comprende qué cambia una conversión explícita

Supón que Person p hace referencia a un estudiante. Student s = (Student) p; permite llamar a s.getStudentId(). Ambas variables siguen haciendo referencia al mismo objeto. La conversión no lo copia, no cambia su clase real ni añade campos de estudiante a una persona que no lo sea.

Si p hace referencia en realidad a new Person("Grace Hopper"), esa conversión lanza una ClassCastException. El compilador acepta la posible relación entre persona y estudiante, pero el objeto en tiempo de ejecución debe cumplirla. Una conversión entre clases que no pueden estar relacionadas, como una referencia Person convertida explícitamente a la clase final Integer, falla en tiempo de compilación.

Esto difiere de una conversión primitiva: (int) 3.9 crea el valor entero 3. Una conversión explícita de referencia solo comprueba y cambia el tipo a través del cual se utiliza una referencia existente.

Combina la comprobación y la variable nueva

Desde Java 16, la coincidencia de patrones hace que el caso seguro sea compacto:

static void showStudentId(Person person) {
    if (person instanceof Student student) {
        System.out.println(student.getStudentId());
    }
}

La comprobación es verdadera para un estudiante o una subclase de estudiante. La variable student está disponible dentro del bloque, donde se sabe que la comprobación ha tenido éxito. Una persona que no sea estudiante omite el bloque. Una referencia nula también hace que la comprobación sea falsa, por lo que el bloque nunca intenta llamar a un método sobre null.

La forma anterior comprueba person instanceof Student y luego declara Student student = (Student) person; dentro de la rama donde la comprobación tuvo éxito. Ambas formas protegen la conversión. Comprobar otro objeto en otro lugar no protege una conversión de person; la comprobación y la conversión deben referirse a la misma referencia.

Una conversión ascendente no necesita una conversión explícita. Person person = student; ya compila y no puede fallar por incompatibilidad de tipos. Una conversión explícita de null a un tipo de referencia compatible produce null; utilizar ese resultado para llamar a un método de instancia sigue fallando con una NullPointerException.

Decide si se necesita una comprobación de tipo

Las comprobaciones de tipo son adecuadas para código que recibe un Object, como equals(Object other), o necesita una operación exclusiva de un subtipo, como un identificador de estudiante. También pueden ayudar al trabajar con clases que no pueden modificarse.

Una cadena repetida de comprobaciones de tipo para una operación compartida es un problema diferente. Si el código comprueba cada clase de figura para calcular su área, cada figura añadida requiere otra rama. Declarar area() en Shape y dejar que las subclases lo implementen permite llamar a shape.area().

Una conversión explícita no puede hacer que una operación común ausente esté disponible en todos los subtipos. Coloca el comportamiento compartido en el contrato común y reserva la comprobación de subtipo para el trabajo que realmente requiera ese subtipo concreto.

Un método sigue siendo útil con clases nuevas cuando su parámetro expone exactamente las operaciones que necesita. Quien llama proporciona los objetos; el enlace dinámico proporciona su comportamiento individual.

Suma áreas sin ramas específicas de clase

static double totalArea(List<Shape> shapes) {
    double total = 0;
    for (Shape shape : shapes) {
        total += shape.area();
    }
    return total;
}

Con un círculo de radio 1,5 m, un rectángulo de dimensiones 3,0 m y 4,0 m, y un triángulo de base 4,0 m y altura 2,5 m, las áreas son aproximadamente 7,06858, 12,0 y 5,0 metros cuadrados. Al sumar el área del círculo sin redondear se obtienen aproximadamente 24,07 metros cuadrados. Cada objeto proporciona su propio area().

Añadir una clase Triangle no requiere modificar el bucle. La nueva clase implementa la operación existente de las figuras. Un resultado negativo incumpliría el contrato del área aunque la sobrescritura compilara; el código general depende tanto del significado de la operación como de su firma.

El mismo enfoque funciona con una interfaz. Un método chargeAll(List<Chargeable> devices, int minutes) recorre los dispositivos y llama a device.charge(minutes). Durante 20 minutos, el teléfono que empieza al 35 % alcanza el 75 % y el patinete que empieza al 50 % alcanza el 70 %. El bucle nunca selecciona por sí mismo una regla de carga.

Deja que quien llama elija una implementación de lista

Un parámetro List<Shape> acepta tanto un ArrayList<Shape> como un LinkedList<Shape>. Un parámetro ArrayList<Shape> rechaza la lista enlazada aunque solo necesite operaciones de lista. Utiliza el tipo más general que proporcione los métodos requeridos; declarar todo como Object sería demasiado general porque carece de area() y de operaciones de lista.

Haz que los objetos puedan ordenarse con Comparable

Comparable<T> define el orden natural de un objeto. Su resultado de compareTo es negativo cuando este objeto va antes que el otro, cero cuando hay un empate en la ordenación y positivo cuando va después. Importa el signo del resultado; no tiene que ser exactamente −1 o 1.

record Runner(String name, int seconds)
        implements Comparable<Runner> {
    @Override
    public int compareTo(Runner other) {
        return Integer.compare(seconds, other.seconds);
    }
}

Una lista modificable con Mia en 3605 s, Ken en 3490 s y Ana en 3720 s pasa a ser Ken, Mia, Ana después de Collections.sort(runners). list.sort(null) también utiliza el orden natural. Construye una lista modificable con new ArrayList<>(List.of(...)); intentar ordenar el resultado no modificable de List.of(...) lanza una UnsupportedOperationException.

Utiliza Integer.compare en lugar de restar los valores. La resta puede desbordarse para valores grandes de signos opuestos y devolver el signo incorrecto. La misma idea se aplica a Double.compare para campos decimales. En este ejemplo de corredores, los tiempos iguales empatan en la ordenación aunque los nombres sean diferentes, por lo que un empate en la comparación y la igualdad de objetos no tienen por qué significar lo mismo. Prefiere un orden natural cuyo resultado cero concuerde con la igualdad; documenta cualquier diferencia intencionada.

Una enumeración da un tipo propio a un conjunto fijo de opciones con nombre. enum Size { SMALL, MEDIUM, LARGE } permite Size size = Size.MEDIUM;. Impide que se pase la cadena mal escrita «MEDUIM» o el entero 7 a un método que requiere Size.

Utiliza nombres, constantes y switch

Cada constante de enumeración es un único objeto, por lo que size == Size.LARGE es una comparación adecuada. Una variable de enumeración también puede ser null. Size.values() devuelve todas las constantes en el orden de declaración; Size.valueOf("LARGE") encuentra el nombre exacto. La búsqueda distingue mayúsculas de minúsculas: «large» provoca una IllegalArgumentException.

name() devuelve el nombre declarado. ordinal() devuelve la posición contando desde cero, por lo que Size.MEDIUM.ordinal() es 1. Insertar una constante cambia las posiciones posteriores, así que una posición ordinal es una mala opción como código almacenado o valor de negocio. Por defecto, toString() también devuelve el nombre.

Una expresión switch, estándar desde Java 14, puede devolver un valor:

String label = switch (size) {
    case SMALL -> "S";
    case MEDIUM -> "M";
    case LARGE -> "L";
};

Nombrar todas las constantes hace que la expresión sea exhaustiva sin una rama predeterminada. Estos casos suponen que size no es null; enumerar las constantes no gestiona null.

Dota a cada constante de datos significativos

enum CupSize {
    SMALL(250), MEDIUM(350), LARGE(500);
    private final int milliliters;
    CupSize(int milliliters) { this.milliliters = milliliters; }
    public int milliliters() { return milliliters; }
}

El punto y coma separa la lista de constantes de los miembros. El constructor se ejecuta una vez por cada constante cuando se inicializa la enumeración. Es implícitamente privado y no se pueden crear constantes nuevas con new CupSize(400).

Dos vasos grandes y uno pequeño contienen 1250 mL, o 1,25 L. Ese cálculo utiliza el campo milliliters, no las posiciones de las constantes. Recorrer CupSize.values() e imprimir cada constante y su capacidad da «SMALL: 250 mL», «MEDIUM: 350 mL» y «LARGE: 500 mL».

Dota a las constantes de su propio comportamiento

Una enumeración puede implementar una interfaz y puede dar a cada constante un cuerpo de método diferente:

enum Operation {
    ADD { int apply(int a, int b) { return a + b; } },
    MULTIPLY { int apply(int a, int b) { return a * b; } };
    abstract int apply(int a, int b);
}

Operation.MULTIPLY.apply(6, 7) devuelve 42. Cada constante completa la operación abstracta. Las enumeraciones extienden implícitamente java.lang.Enum; no pueden extender otra clase y las clases ordinarias no pueden extenderlas.

Utiliza una enumeración para opciones fijas al escribir el programa, como direcciones o estados de un pedido. La lista cambiante de productos de una tienda pertenece a los datos: añadir productos no debería requerir reescribir y recompilar una declaración de enumeración.

Un registro es una clase de datos concisa, estándar desde Java 16. Su cabecera enumera los valores, llamados componentes, que definen cada instancia: record Point(int x, int y) { }.

Utiliza los miembros generados

El compilador proporciona un campo privado final para cada componente, un constructor canónico con esos componentes en orden y métodos de acceso públicos con sus nombres. También proporciona equals, hashCode y toString basados en los componentes.

Point a = new Point(3, 4);
Point b = new Point(3, 4);
System.out.println(a.x());
System.out.println(a.equals(b));
System.out.println(a == b);

Esto imprime 3, true y false en líneas separadas. Los valores coincidentes de los componentes hacen que los registros sean iguales, pero las dos expresiones new crean objetos independientes. Los registros iguales tienen códigos hash iguales. Su texto generado útil incluye los nombres del registro y de los componentes; los JDK actuales muestran «Point[x=3, y=4]». Ese formato de texto exacto no está garantizado, así que no lo analices como formato de datos.

Los métodos de acceso son x() e y(), no getX() y getY(). Un método modificador que asigna this.x = x no compila porque el campo del componente es final. En su lugar, un método puede devolver un valor nuevo: Point moveRight(int dx) { return new Point(x + dx, y); }.

Valida en un constructor compacto

record Temperature(double celsius) {
    Temperature {
        if (celsius < -273.15) {
            throw new IllegalArgumentException("below absolute zero");
        }
    }
}

Un constructor compacto repite el nombre del registro sin una lista de parámetros. Comprueba o normaliza los parámetros recibidos; Java asigna los campos de los componentes después de su cuerpo. Esta comprobación rechaza −300 °C y acepta 21,5 °C. Un componente de texto podría normalizarse con name = name.trim(); antes de la asignación automática.

Un registro público necesita un constructor compacto público. Los registros también pueden declarar campos estáticos, métodos estáticos y métodos de instancia. Un constructor adicional delega en el constructor canónico con this(...). Se prohíben los campos de instancia adicionales a los componentes.

Protege los objetos mutables de los componentes

Los campos final de los componentes hacen que la inmutabilidad sea superficial. Un registro que contiene una lista mutable sigue haciendo referencia a esa lista:

record Team(String name, List<String> members) {
    Team {
        members = List.copyOf(members);
    }
}

Con java.util.List importada, esto almacena una copia no modificable. Las adiciones posteriores a la lista original no afectan a la pertenencia al equipo, y team.members().add("Lee") lanza una UnsupportedOperationException. La copia protege la estructura de la lista; no hace profundamente inmutables los objetos mutables de sus elementos.

Los registros extienden implícitamente java.lang.Record y son final. No pueden extender otra clase ni ser extendidos, pero pueden implementar interfaces como Comparable. Utilízalos para datos definidos por sus valores; utiliza una clase ordinaria para estado cambiante, campos de instancia ocultos adicionales o una jerarquía de clases extensible.