Skip to content

4. Clases, records, interfaces

4.1. Los objetos a través de ejemplos

4.1.1. Descripción general

Ahora exploraremos la programación orientada a objetos mediante ejemplos. Un objeto es una entidad que contiene datos que definen su estado (denominados campos, atributos, etc.) y funciones (denominadas métodos). Un objeto se crea a partir de una plantilla llamada clase. Por ejemplo, una clase llamada [C1] declara dos campos, [Type1 p1;] y [Type2 p2;], y dos métodos, [Type3 m3(...) { ... }] y [Type4 m4(...) { ... }], todo ello encerrado entre las llaves de la declaración [public class C1 { ... }].

A partir de la clase [C1], se pueden crear muchos objetos como [o1], [o2], … Todos tendrán los campos [p1], [p2], … y los métodos [m3], [m4], … Sin embargo, tendrán valores diferentes en sus campos [pi], de modo que cada uno tiene su propio estado. Si [o1] es un objeto de tipo [C1], [o1.p1] designa el campo [p1] de [o1], y [o1.m3(...)] designa la llamada al método [m3] de [o1].

Consideremos un primer modelo de objetos: la clase [Person].

4.1.2. Un programa formado por varios archivos

En los ejemplos del capítulo anterior, un programa cabía en un único archivo fuente. A partir de ahora, un programa puede constar de varios archivos fuente: una clase por archivo, más el programa principal. En Java, una clase pública debe colocarse en un archivo que lleve su nombre: la clase pública [Person] está en el archivo [Person.java]. Guardamos los archivos de un mismo programa en una carpeta; en este caso, la carpeta [Persons] dentro de la carpeta [04-classes]:

1
2
3
Persons/
  Person.java       the Person class
  Main.java         the main program

A partir de Java 22, el lanzador de código fuente, que ya usamos en el capítulo anterior, puede ejecutar un programa formado por varios archivos: el comando [java Main.java], ingresado en la carpeta [Persons], compila en memoria el archivo [Main.java] y, a demanda, los demás archivos de la carpeta que necesita (en este caso, [Person.java]) y ejecuta el programa. No se escribe ningún archivo compilado en el disco. También se pueden compilar los archivos de forma explícita con el compilador [javac], que escribe un archivo [.class] (código intermedio, o "bytecode") por clase, y luego ejecutar el programa con el comando [java], indicando dónde encontrar las clases compiladas (opción [-cp], el "classpath"):

1
2
3
4
5
6
> javac -d classes *.java
> ls classes
Main.class
Person.class
> java -cp classes Main
[Jean, Dupont, 30]

El lanzador de varios archivos es suficiente para los programas de este capítulo, que solo utilizan las clases del JDK. Cuando un programa requiere bibliotecas externas, usaremos un proyecto Maven, como se presentó en el capítulo 2: Maven descarga las bibliotecas, compila el proyecto y lo ejecuta. Los archivos de este capítulo se pueden abrir tal cual en IntelliJ, IDEA o VS Code.

4.1.3. Definición de la clase Person

La definición de la clase [Person] en el archivo fuente [Person.java] será la siguiente:

public class Person {
    // atributos (campos)
    private String firstName = "";
    private String lastName = "";
    private int age;

    // método
    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

    // método
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • Línea 1: la clase es pública ([public]): puede ser utilizada por todas las demás clases. No pertenece a ningún paquete o, más precisamente, pertenece al paquete sin nombre; los paquetes se tratan al final del capítulo;
  • Líneas 3–5: los tres campos de la clase. Las dos cadenas se inicializan con la cadena vacía: de lo contrario, valdrían [null] cuando se crea el objeto (un campo de objeto no inicializado vale [null], un campo numérico vale 0 y un campo booleano vale [false]);
  • líneas 8–12: un método que establece el estado del objeto;
  • líneas 15–17: un método que muestra el estado del objeto. [IO] es la clase de E/S de consola de Java 25 que usamos en el capítulo anterior.

Aquí tenemos la definición de una clase, es decir, de un tipo de datos. Cuando creamos variables de este tipo, las llamamos objetos o instancias de la clase. Una clase es, por lo tanto, una plantilla a partir de la cual se construyen objetos. Por convención, el nombre de una clase comienza con mayúscula ([Person]), mientras que el nombre de un campo o de un método comienza con minúscula ([firstName], [initialize]).

Los miembros de una clase pueden ser datos (campos) o métodos (funciones). Estos miembros pueden ir acompañados de una de las siguientes palabras clave:

Palabra clave
Acceso
[private]
Un miembro privado solo es accesible por los métodos internos de la clase
(ninguna)
Si no se especifica ninguna palabra clave, el miembro es accesible por cualquier método de una clase del mismo paquete. Este es el acceso predeterminado, conocido como "acceso de paquete"
[protected]
Un miembro protegido es accesible por los métodos de las clases del mismo paquete y por los métodos de las clases derivadas (véase más adelante el concepto de herencia)
[public]
Un miembro público es accesible por cualquier método, esté o no definido dentro de la clase

En general, los datos de una clase se declaran privados, mientras que sus métodos se declaran públicos. Esto significa que el usuario de un objeto (el programador):

  • no tendrá acceso directo a los datos privados del objeto;
  • puede llamar a los métodos públicos del objeto, incluidos los que dan acceso a sus datos privados.

El orden en que se declaran los miembros [private], [protected] y [public] es arbitrario. Observe que el acceso predeterminado no es privado: un campo declarado sin palabra clave es visible para todas las clases del paquete. Por lo tanto, hay que recordar escribir [private].

4.1.4. El método initialize

¿Cuál es la función del método [initialize]? Como [lastName], [firstName], y [age] son miembros privados de la clase [Person], una instrucción como [p1.firstName = "Jean";], escrita en el programa principal, no es válida. El compilador la rechaza:

1
2
3
4
5
6
> java Main.java
Main.java:4: error: firstName has private access in Person
    p1.firstName = "Jean";
      ^
1 error
error: compilation failed

El mensaje del compilador está en inglés: el JDK no tiene traducción al francés de sus mensajes. Indica el archivo y el número de línea del error, y luego lo señala con un acento circunflejo. Necesitamos inicializar un objeto de tipo [Person] mediante un método público. Esta es la función del método [initialize]. Escribiremos [p1.initialize("Jean", "Dupont", 30);]. Esta sintaxis es válida porque [initialize] es de acceso público.

4.1.5. El operador new

Sin embargo, todavía falta algo. La declaración [Person p1;] declara [p1] como una referencia a un objeto de tipo [Person]. Este objeto todavía no existe y, por lo tanto, [p1] no está inicializada. Cuando escribimos a continuación [p1.initialize("Jean", "Dupont", 30);], llamamos al método [initialize] del objeto referenciado por [p1]. Sin embargo, este objeto no existe y el compilador informa del error: a la variable local [p1] no se le ha asignado un valor.

1
2
3
4
5
6
> java Main.java
Main.java:4: error: variable p1 might not have been initialized
    p1.initialize("Jean", "Dupont", 30);
    ^
1 error
error: compilation failed

Si escribimos [Person p1 = null;] seguido de [p1.initialize("Jean", "Dupont", 30);], indicamos explícitamente con la palabra clave [null] que la variable [p1] todavía no hace referencia a ningún objeto. El compilador acepta el programa, pero en tiempo de ejecución la llamada al método provoca una excepción [NullPointerException]:

1
2
3
> java Main.java
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Person.initialize(String, String, int)" because "<local1>" is null
    at Main.main(Main.java:4)

A partir de Java 14, el mensaje de la excepción especifica qué operación falló; [<local1>] designa la variable local [p1], cuyo nombre no se conservó en la compilación en memoria. Para que [p1] haga referencia a un objeto, hay que escribir [Person p1 = new Person();].

Esto crea un objeto de tipo [Person] que aún no ha sido inicializado: sus campos tienen sus valores predeterminados; en este caso, la cadena vacía para [lastName] y [firstName], y 0 para [age]. Ahora que [p1] hace referencia a un objeto, la instrucción de inicialización de este objeto, [p1.initialize("Jean", "Dupont", 30);], es válida.

4.1.6. La palabra clave this

Veamos el código del método [initialize]:

    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

La instrucción [this.firstName = p;] significa que al campo [firstName] del objeto actual ([this]) se le asigna el valor [p]. La palabra clave [this] hace referencia al objeto actual: aquel sobre el que se ejecuta el método. ¿Cómo lo sabemos? Veamos cómo se inicializa el objeto referenciado por [p1] en el programa que llama: [p1.initialize("Jean", "Dupont", 30);]. Se llama al método [initialize] del objeto [p1] . Cuando, dentro de este método, se hace referencia al objeto [this], en realidad se hace referencia al objeto [p1].

Cuando un método de un objeto hace referencia a un campo [a] de ese objeto, la notación [this.a] está implícita: el método [initialize] podría haber escrito [firstName = p;] y [lastName = n;]. Hay que usar [this] de forma explícita cuando hay un conflicto de identificadores. Es el caso de la instrucción [this.age = age;] (línea 11), donde [age] designa a la vez un campo del objeto actual y el parámetro [age] recibido por el método. En el método, el nombre [age] por sí solo designa el parámetro; el campo debe designarse como [this.age].

4.1.7. Un programa de prueba

Este es un breve programa de prueba. Está escrito en el archivo fuente [Main.java]:

1
2
3
4
5
6
7
// el programa principal
void main() {
    // un objeto Person
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
}
  • Línea 2: el método [main] es el punto de entrada del programa. Como en el capítulo anterior, está escrito sin una clase envolvente: el archivo [Main.java] es un archivo fuente compacto (véase el párrafo siguiente);
  • línea 4: creación de un objeto [Person] referenciado por [p1]. Como la clase [Person] pertenece al mismo paquete (el paquete sin nombre), se reconoce sin una instrucción import;
  • Línea 5: inicialización del objeto;
  • línea 6: visualización de su estado.

Resultados:

> java Main.java
[Jean, Dupont, 30]

4.1.8. Archivos fuente compactos

Para un ejemplo breve, una carpeta que contiene varios archivos resulta innecesariamente pesada. Como en el capítulo anterior, escribiremos por lo tanto un archivo fuente compacto (Java 25): un archivo que contiene el método [void main()], posiblemente otros métodos y campos, y las clases que necesita el programa. Lo ejecutamos con el lanzador de código fuente: [java Classes01.java].

Es importante comprender cómo procesa el compilador un archivo de este tipo. Lo envuelve en una clase implícita, que lleva el nombre del archivo ([Classes01]): los métodos y campos del archivo pasan a ser miembros de esta clase, y las clases declaradas en el archivo se convierten en clases anidadas de esta clase implícita. La compilación explícita del archivo lo demuestra:

1
2
3
4
> javac -d classes Classes01.java
> ls classes
Classes01$Person.class
Classes01.class

Por lo tanto, el nombre completo de la clase [Person] en el archivo [Classes01.java] es [Classes01$Person]. Esto tiene dos consecuencias que encontraremos en los ejemplos:

  • una clase y las clases que contiene comparten sus miembros privados: el método [main] de un archivo compacto tiene acceso a los campos privados de las clases de ese archivo. Para asegurar que un campo privado sea inaccesible desde fuera de su clase, hay que colocar la clase en su propio archivo, como en la carpeta [Persons];
  • Una clase anidada normal es una clase interna: sus objetos están vinculados a un objeto de la clase envolvente. Esto no se nota mientras los objetos los crean métodos del archivo, pero un método estático (véase la sección sobre los miembros de clase) no puede crearlos. Entonces declaramos la clase anidada [static]. Los records y las interfaces, que se tratan más adelante, son siempre estáticos.

Por último, un archivo compacto importa automáticamente todas las clases públicas del módulo [java.base]: [List], [ArrayList], [BigDecimal], [Objects]… pueden usarse allí sin la cláusula [import]. Este no es el caso de un archivo normal como [Person.java], como veremos.

4.1.9. Otro método initialize: la sobrecarga

Sigamos considerando la clase [Person] y agreguémosle un segundo método: [initialize]. El programa [Classes01.java] es el siguiente:

// sobrecarga del método initialize
void main() {
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person();
    p2.initialize(p1);
    p2.identify();
}

// la clase Person se declara después del método main
class Person {
    // atributos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // inicialización a partir de tres valores
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // inicialización a partir de otra persona
    public void initialize(Person p) {
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidad de la persona
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • líneas 2–9: el programa principal;
  • línea 12: la clase [Person] se declara después del método [main]. No es pública: en un archivo compacto, esto es innecesario;
  • líneas 19–23: el método [initialize] del párrafo anterior;
  • líneas 26–30: un segundo método, [initialize].

Ahora tenemos dos métodos llamados [initialize]: esto es válido siempre que acepten parámetros diferentes (en número o tipo). Se dice que el método [initialize] está sobrecargado. El compilador elige qué método llamar según los parámetros reales: [p1.initialize("Jean", "Dupont", 30)] (línea 4) llama al primero, y [p2.initialize(p1)] (línea 7) llama al segundo. El tipo de retorno por sí solo no basta para distinguir dos métodos: dos métodos con el mismo nombre y los mismos parámetros que solo difieran en su tipo de retorno serían rechazados.

El parámetro del segundo método es una referencia ([p]) a una persona. Los campos de la persona ([p]) se asignan entonces al objeto actual ([this]). Observe que el método [initialize] tiene acceso directo a los campos del objeto [p] aunque sean privados (líneas 27–29). Esto siempre es así: un método de una clase [C] tiene acceso a los miembros privados de todos los objetos de la misma clase [C].

Resultados:

1
2
3
> java Classes01.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Constructores de la clase Person

Un constructor es un método que lleva el nombre de la clase y se llama cuando se crea el objeto. Generalmente sirve para inicializar el objeto. Es un método que puede aceptar parámetros pero no devuelve ningún valor. Su declaración no va precedida de ningún tipo (ni siquiera [void]).

Si una clase [C] tiene un constructor que acepta n parámetros, la declaración y la inicialización de un objeto de esta clase pueden hacerse en la forma [C object = new C(arg1, arg2, ... argn);], o en dos pasos: [C object;], seguido más adelante de [object = new C(arg1, arg2, ... argn);].

Cuando una clase [C] tiene uno o más constructores, se debe usar uno de ellos para crear un objeto de esa clase. Si una clase [C] no tiene constructores, dispone de un constructor predeterminado sin parámetros que no hace nada. Los campos del objeto conservan entonces sus valores iniciales. Esto es lo que ocurría en los programas anteriores, donde habíamos escrito [new Person()].

El programa [Classes02.java] presenta tres constructores para la clase [Person]:

// constructores de la clase Person
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person(p1);
    p2.identify();
    Person p3 = new Person();
    p3.identify();
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // constructor principal
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // constructor de copia: llama al constructor principal
    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // constructor sin parámetros: también llama al constructor principal
    public Person() {
        this("?", "?", 0);
    }

    // identidad de la persona
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • líneas 18–22: el constructor "principal" inicializa los tres campos. Como sus parámetros tienen los mismos nombres que los campos, los campos se distinguen mediante [this];
  • líneas 25–27: el constructor de copia. La instrucción [this(p.firstName, p.lastName, p.age);] llama al constructor de la misma clase que acepta tres parámetros: [String], [String] e [int]. A esto se le llama encadenamiento de constructores. De este modo, el código de inicialización se escribe una sola vez;
  • líneas 30–32: el constructor sin parámetros, que también está encadenado al constructor principal. Como la clase ha declarado constructores, ya no tiene un constructor predeterminado: si se quiere poder escribir [new Person()], hay que declararlo;
  • líneas 13–15: los campos ya no se inicializan en el momento de su declaración; todos los constructores, ya sea directamente o por encadenamiento, les asignan un valor.

La llamada [this(...)] a otro constructor solo puede hacerse dentro de un constructor. Hasta Java 24, debía ser la primera instrucción; desde Java 25, pueden precederla instrucciones que no usen el objeto que se está construyendo (para verificar o preparar parámetros, por ejemplo). También podríamos haber hecho que los constructores llamaran a un método como [initialize]; sin embargo, es preferible el encadenamiento: el código de inicialización está en un único lugar, y un constructor no debe llamar a un método que una clase derivada pueda sobrescribir (veremos por qué).

Resultados:

1
2
3
4
> java Classes02.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. Referencias a objetos

Usamos la clase [Person] del programa anterior, omitiendo su constructor sin parámetros pero incluyendo el método [initialize(String, String, int)] del comienzo del capítulo. El programa de prueba pasa a ser el siguiente [Classes03.java]:

// referencias a objetos
void main() {
    // p1
    Person p1 = new Person("Jean", "Dupont", 30);
    IO.print("p1="); p1.identify();
    // p2 referencia el mismo objeto que p1
    Person p2 = p1;
    IO.print("p2="); p2.identify();
    // p3 referencia un objeto que es una copia del objeto referenciado por p1
    Person p3 = new Person(p1);
    IO.print("p3="); p3.identify();
    // cambiamos el estado del objeto referenciado por p1
    p1.initialize("Micheline", "Benoît", 67);
    IO.print("p1="); p1.identify();
    // como p2 = p1, el objeto referenciado por p2 ha cambiado de estado
    IO.print("p2="); p2.identify();
    // p3 no referencia el mismo objeto que p1: el objeto referenciado por p3 no ha cambiado
    IO.print("p3="); p3.identify();
    // ¿son p1 y p2 la misma referencia? ¿y p1 y p3?
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1 == p3 : " + (p1 == p3));
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // constructores
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // inicialización
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // identidad de la persona
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}

El método [IO.print] (líneas 5, 8, …) escribe su parámetro sin saltar a la línea siguiente. Resultados:

1
2
3
4
5
6
7
8
> java Classes03.java
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 == p2 : true, p1 == p3 : false

Cuando se declara la variable [p1] mediante [Person p1 = new Person("Jean", "Dupont", 30);] (línea 4), [p1] referencia al objeto [Person("Jean", "Dupont", 30)] pero no es el objeto en sí. En C, se denominaría un puntero, es decir, la dirección del objeto creado. Si luego escribimos [p1 = null;], no es el objeto [Person("Jean", "Dupont", 30)] el que se modifica; es la referencia [p1] la que cambia de valor. El objeto se "perderá" si ninguna otra variable lo referencia: la memoria que ocupa será reclamada más tarde por el recolector de basura de la máquina virtual de Java.

Cuando escribimos [Person p2 = p1;] (línea 7), inicializamos la referencia [p2]: "apunta" al mismo objeto (hace referencia al mismo objeto) que la referencia [p1]. Así, si se modifica el objeto "apuntado" (o referenciado) por [p1], también se modifica el objeto referenciado por [p2] (líneas 5–6 de los resultados).

Cuando se escribe [Person p3 = new Person(p1);] (línea 10), se crea un nuevo objeto [Person],. Este nuevo objeto será referenciado por [p3]. Si se modifica el objeto referenciado por [p1], no se modifica el referenciado por [p3] (línea 7 de los resultados).

Por último, en la línea 20, el operador [==], aplicado a dos referencias a objetos, indica si hacen referencia al mismo objeto: [p1] y [p2] hacen referencia al mismo objeto, mientras que [p1] y [p3] hacen referencia a dos objetos distintos, aunque tengan el mismo contenido (línea 8 de los resultados). Veremos más adelante cómo comparar el contenido de dos objetos mediante el método [equals].

4.1.12. Paso de referencias a objetos como parámetros

En el capítulo anterior vimos que Java pasa los parámetros de los métodos por valor: el método recibe una copia del valor del parámetro real. Veamos qué significa esto cuando el parámetro es una referencia a un objeto. Para ello, usaremos la clase [StringBuilder] del JDK. Un objeto [String] no se puede modificar: una operación como [s.toUpperCase()] devuelve un nuevo [String]. En cambio, un objeto [StringBuilder] es una cadena mutable: su método [append] agrega caracteres a la cadena sin crear un nuevo objeto.

El programa [Classes04.java] es el siguiente:

// paso de parámetros de tipo referencia a objeto
void main() {
    StringBuilder sb0 = new StringBuilder("test0"), sb1 = new StringBuilder("test1");
    IO.println("In calling function before call: sb0=" + sb0 + ", sb1=" + sb1);
    StringBuilder sb2 = changeStringBuilder(sb0, sb1);
    IO.println("In calling function after call: sb0=" + sb0 + ", sb1=" + sb1 + ", sb2=" + sb2);
}

// la función llamada
StringBuilder changeStringBuilder(StringBuilder sbf0, StringBuilder sbf1) {
    IO.println("Start of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1);
    // modificamos el objeto referenciado por sbf0
    sbf0.append("*****");
    // sbf1 ahora referencia un nuevo objeto
    sbf1 = new StringBuilder("test1*****");
    // se devuelve un nuevo objeto al llamador
    StringBuilder sbf2 = new StringBuilder("test2*****");
    IO.println("End of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1 + ", sbf2=" + sbf2);
    return sbf2;
}
  • línea 3: dos referencias, [sb0] y [sb1], a objetos de tipo [StringBuilder];
  • línea 5: se pasan al método [changeStringBuilder], cuyo resultado (una tercera referencia) se asigna a [sb2];
  • líneas 10–20: un método del archivo compacto, que tiene los parámetros formales [sbf0] y [sbf1]. Cuando el método comienza, [sbf0] y [sb0] son dos referencias distintas que apuntan al mismo objeto: la referencia [sb0] se copió en [sbf0] (las referencias se pasan por valor). Lo mismo se aplica a [sbf1] y [sb1].

Resultados:

1
2
3
4
5
> java Classes04.java
In calling function before call: sb0=test0, sb1=test1
Start of called function: sbf0=test0, sbf1=test1
End of called function: sbf0=test0*****, sbf1=test1*****, sbf2=test2*****
In calling function after call: sb0=test0*****, sb1=test1, sb2=test2*****

Explicaciones:

  • [sb0] y [sbf0] son dos referencias distintas al mismo objeto. Este objeto se modificó mediante [sbf0] (línea 13). Esta modificación es visible mediante [sb0] (línea 5 de los resultados);
  • [sb1] y [sbf1] son dos referencias distintas al mismo objeto. [sbf1] recibe un nuevo valor en el método y ahora apunta a un nuevo objeto (línea 15). Esto no cambia el valor de [sb1], que sigue apuntando al objeto original, sin modificar;
  • un método de Java no puede, por lo tanto, cambiar el valor de una variable del llamador. Para devolver un nuevo objeto al llamador, lo retorna como resultado (líneas 17 y 19). Cuando hay varios resultados, se agrupan en un objeto, como un record (véase más adelante).

Tenga presente que un método puede modificar el objeto referenciado por un parámetro, pero no la variable del llamador que contiene la referencia. A diferencia de otros lenguajes como C#, Java no admite el paso de parámetros por referencia.

4.1.13. Objetos temporales

En una expresión, se puede llamar explícitamente al constructor de un objeto: el objeto se crea, pero no hay ninguna variable que permita acceder a él posteriormente (para modificarlo, por ejemplo). Este objeto temporal se crea para evaluar la expresión y luego se descarta. El espacio de memoria que ocupaba será reclamado automáticamente más tarde por el recolector de basura, cuya función es reclamar el espacio de memoria ocupado por los objetos que ya no están referenciados por los datos del programa.

Consideremos el siguiente programa, [Classes05.java], en el que los constructores de la clase [Person] muestran un mensaje:

// objetos temporales
void main() {
    new Person(new Person("Jean", "Dupont", 30)).identify();
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // constructores
    public Person(String firstName, String lastName, int age) {
        IO.println("Constructor Person(String, String, int)");
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        IO.println("Constructor Person(Person)");
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidad de la persona
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • Línea 3: el objeto [Person("Jean", *"Dupont", 30)]* se construye y luego se pasa al constructor de copia, que construye un segundo objeto, cuyo método [identify] se llama. Ninguno de los dos objetos está referenciado por una variable.

Resultados:

1
2
3
4
> java Classes05.java
Constructor Person(String, String, int)
Constructor Person(Person)
[Jean, Dupont, 30]

Los resultados muestran la creación sucesiva de los dos objetos temporales.

4.1.14. Accesores y mutadores

Agregamos a la clase [Person] los métodos necesarios para leer o modificar el estado de los campos de los objetos en [Classes06.java]:

// métodos de lectura (getters) y escritura (setters) de atributos privados
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // constructor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // getters
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setters
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  • líneas 23–33: los métodos de lectura, llamados getters;
  • Líneas 36–46: los métodos de escritura, llamados "setters".

Resultados:

1
2
3
> java Classes06.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

Los nombres de estos métodos siguen una convención establecida desde los primeros días de Java, a saber, "JavaBeans": el getter del campo [age] se llama [getAge], y su setter se llama [setAge]; el getter de un campo booleano llamado [active] se llama, en cambio, [isActive]. Muchas bibliotecas (como Jackson para JSON y Hibernate para bases de datos, que usaremos más adelante) se basan en esta convención para obtener los datos de un objeto. A diferencia de otros lenguajes como C#, Java no tiene "propiedades": acceder al estado de un objeto siempre implica métodos o, para los objetos inmutables, records, que veremos más adelante. Los entornos de desarrollo pueden generar getters y setters a partir de los campos (en IntelliJ y IDEA, en el menú "Code / Generate…").

4.1.15. Setters que validan los valores recibidos

La ventaja de los modificadores sobre los campos públicos es la posibilidad de controlar los valores asignados a los campos: un modificador puede verificar la validez del valor recibido y lanzar una excepción si no es válido. Consideremos el programa [Classes07.java]:

// setters que verifican la validez de los valores recibidos
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // constructor sin parámetros y luego llamadas a los setters
    Person p2 = new Person();
    p2.setAge(7);
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    IO.println("p2=(" + p2.getFirstName() + "," + p2.getLastName() + "," + p2.getAge() + ")");
    try {
        Person p3 = new Person();
        p3.setFirstName("Paul");
        p3.setLastName(" ");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
}

class Person {
    // atributos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // constructores
    public Person(String firstName, String lastName, int age) {
        // pasamos por los setters para aprovechar sus verificaciones
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
    }

    public Person() {
    }

    // getters
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setters: se declaran final porque el constructor los llama
    public final void setFirstName(String firstName) {
        // ¿nombre válido?
        if (firstName == null || firstName.isBlank()) {
            throw new IllegalArgumentException("first name (" + firstName + ") invalid");
        }
        this.firstName = firstName;
    }

    public final void setLastName(String lastName) {
        // ¿apellido válido?
        if (lastName == null || lastName.isBlank()) {
            throw new IllegalArgumentException("last name (" + lastName + ") invalid");
        }
        this.lastName = lastName;
    }

    public final void setAge(int age) {
        // ¿edad válida?
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }
}

Los tres modificadores validan el valor recibido (líneas 60–62, 68–70, 76–78).

  • Líneas 60–62: el método [isBlank] (Java 11) devuelve [true] si la cadena está vacía o consta únicamente de espacios. La prueba [firstName == null] se realiza primero: si [firstName] es igual a [null], el operador [||] no evalúa su segundo operando, lo que provocaría una excepción [NullPointerException]. La excepción lanzada es de tipo [IllegalArgumentException], la excepción que proporciona Java para señalar un parámetro no válido. Es una excepción no verificada: el método no necesita declararla con [throws];
  • líneas 34–39: el constructor inicializa el objeto mediante los accesores en lugar de los campos. Esto le permite aprovechar las validaciones realizadas por los accesores, que se escriben en un solo lugar;
  • líneas 58, 66, 74: los modificadores se declaran como [final]. Veremos con la herencia que una clase derivada puede sobrescribir los métodos de su clase padre; la palabra clave [final] lo impide. Sin ella, una clase derivada podría redefinir [setAge], y el constructor de [Person] llamaría a esta nueva versión incluso antes de que se haya ejecutado el constructor de la clase derivada. El compilador, con la opción [-Xlint:all], señala este riesgo (advertencia [this-escape]) para una clase pública escrita en su propio archivo;
  • líneas 41–42: un constructor sin parámetros, que deja los campos en sus valores iniciales.

Resultados:

1
2
3
4
5
6
> java Classes07.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
age (-4) invalid
p2=(Arthur,Martin,7)
last name ( ) invalid

La línea 4 de los resultados muestra que la llamada a [p.setAge(-4)] (línea 8) fue rechazada por el modificador. Líneas 13–16: se crea una instancia con el constructor sin parámetros y luego se inicializa mediante sus setters. Líneas 19–21: el nombre que contiene un espacio es rechazado (línea 6 de los resultados).

A diferencia de otros lenguajes, Java no tiene un inicializador de objetos, una sintaxis que permitiría establecer varios campos dentro de la propia expresión [new]: en su lugar, como se muestra aquí, encadenamos las llamadas al constructor y a los setters, o escribimos un constructor que recibe todos los valores. Veremos otras dos soluciones: los modificadores "fluidos" y los records.

4.1.16. Campos final y parámetros obligatorios

A un campo declarado como [final] se le debe asignar un valor exactamente una vez, ya sea en la declaración o dentro de cada constructor, y no puede modificarse después. El compilador hace cumplir esta regla. Combinado con la ausencia de modificadores, esto permite crear datos de solo lectura. El programa [Classes08.java] demuestra varios casos:

// campos final, de solo lectura, parámetros obligatorios
void main() {
    Person p = new Person("Jean", "Dupont", 30, "Angers");
    IO.println(p.getIdentity());
    // el nombre es de lectura / escritura
    p.setFirstName("Jacques");
    // la edad solo puede modificarse dentro de la clase
    p.growOlder();
    IO.println(p.getIdentity());
    // el compilador rechaza las líneas siguientes
    // p.setLastName("Durand"); // no hay setter para el apellido
    // p.setAge(40);         // no hay setter para la edad
    // p.city = "Paris";     // el campo city es final

    // un parámetro obligatorio
    Contact c = new Contact("jean.dupont@example.com");
    IO.println("Contact: " + c.getEmail() + ", " + c.getPhone());
    try {
        Contact c2 = new Contact(null);
        IO.println("Contact: " + c2.getEmail());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

class Person {
    // campos
    private String firstName;
    // campos final: reciben su valor una sola vez en el constructor
    private final String lastName;
    private final String city;
    private int age;

    // constructor
    public Person(String firstName, String lastName, int age, String city) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.city = city;
    }

    // nombre de lectura / escritura
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    // apellido, edad y ciudad de solo lectura
    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    // un valor calculado
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + ", " + city + "]";
    }

    // la edad solo la modifican los métodos de la clase
    public void growOlder() {
        age++;
    }
}

class Contact {
    // el email es obligatorio, el teléfono opcional
    private final String email;
    private final String phone;

    // constructor con ambos valores
    public Contact(String email, String phone) {
        this.email = Objects.requireNonNull(email, "the email is mandatory");
        this.phone = phone;
    }

    // constructor sin el teléfono: valor por defecto
    public Contact(String email) {
        this(email, "unknown");
    }

    public String getEmail() {
        return email;
    }

    public String getPhone() {
        return phone;
    }
}
  • líneas 28 y 43–49: el nombre es a la vez de solo lectura y modificable; tiene un getter y un setter;
  • líneas 30–31: el apellido y la ciudad son campos [final]. El constructor les asigna un valor (líneas 37 y 39), que no puede cambiarse después;
  • línea 32 y líneas 56–58: la edad puede ser leída por cualquiera pero no tiene un setter público; solo pueden modificarla los métodos de la clase, como [growOlder] (líneas 70–72);
  • líneas 65–67: el método [getIdentity] devuelve un valor calculado a partir de los campos. Para el usuario de la clase, es indistinguible de un accesor;
  • líneas 11–13: tres instrucciones que el compilador rechaza, por las razones indicadas en los comentarios. Para la tercera, el mensaje del compilador es: [cannot assign a value to final variable city];
  • Líneas 75–98: la clase [Contact] tiene un campo obligatorio (el correo electrónico) y uno opcional (el teléfono). El campo obligatorio se impone mediante el constructor: no se puede crear un objeto [Contact] sin una dirección de correo electrónico. El método [Objects.requireNonNull(value, message)] (línea 82) devuelve su primer parámetro si no es [null] y, en caso contrario, lanza una excepción [NullPointerException] con el mensaje especificado: una dirección de correo electrónico de la forma [null] es rechazada (líneas 18–23);
  • líneas 87–89: el carácter opcional del número de teléfono se expresa mediante un segundo constructor, que proporciona un valor predeterminado. Java no tiene parámetros opcionales: sobrecargamos el constructor.

Observe que en un archivo compacto el método [main] tiene acceso a los campos privados de las clases del archivo: por eso los comentarios de las líneas 11–13 no se basan en el carácter privado de los campos, sino en la ausencia de un modificador y en la palabra clave [final].

Resultados:

1
2
3
4
5
> java Classes08.java
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact: jean.dupont@example.com, unknown
Error: the email is mandatory

4.1.17. Modificadores fluidos

Cuando un objeto tiene muchos campos opcionales, el número de constructores aumenta y las llamadas a modificadores se vuelven más largas. Una técnica común consiste en hacer que cada modificador devuelva el objeto actual ([this]): las llamadas pueden entonces encadenarse; se habla de métodos "fluidos". El programa [Classes09.java] lo ilustra:

// setters "fluidos": devuelven el objeto actual
void main() {
    Person p = new Person().setFirstName("  jean ").setLastName("Dupont").setAge(30);
    IO.println(p.getIdentity());
    try {
        p.setLastName("");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    IO.println(p.getIdentity());
}

class Person {
    // campos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // setters fluidos: cada uno devuelve el objeto actual (this)
    public Person setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
        return this;
    }

    public Person setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
        return this;
    }

    public Person setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
        return this;
    }

    // identidad
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // verificación de una cadena obligatoria: se devuelve sin espacios iniciales ni finales
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}
  • líneas 25–28: el modificador [setFirstName] verifica el valor recibido, lo asigna al campo y devuelve el objeto actual. Su tipo de retorno es, por lo tanto, [Person];
  • línea 3: las llamadas se encadenan: [new Person()] devuelve una persona, sobre la que se llama a [setFirstName], que devuelve la misma persona, sobre la que se llama a [setLastName], y así sucesivamente. La sintaxis se parece a un inicializador de objetos;
  • Líneas 49–54: las verificaciones del nombre y del apellido, que son idénticas, se factorizan en el método privado [check]. Se declara como [static] porque no utiliza ningún campo del objeto (los miembros estáticos se tratan en el párrafo siguiente). El método [strip] (Java 11) elimina los espacios iniciales y finales de la cadena.

Resultados:

1
2
3
4
5
> java Classes09.java
[jean, Dupont, 30]
last name () invalid
age (-4) invalid
[jean, Dupont, 30]

El nombre "jean", proporcionado con espacios a ambos lados (línea 3), se almacenó sin ellos (línea 2 de los resultados). Los modificadores fluidos no siguen la convención JavaBeans, según la cual un modificador no devuelve nada ([void]): algunas bibliotecas no los reconocen. Para construir objetos complejos, también se utiliza el patrón de diseño "Builder": una clase auxiliar, dotada de métodos fluidos, recopila los valores y luego construye el objeto final, que puede ser inmutable.

4.1.18. Métodos y atributos de clase

Supongamos que queremos contar el número de objetos [Person] creados en una aplicación. Podríamos gestionar un contador nosotros mismos, pero corremos el riesgo de pasar por alto objetos temporales que se crean aquí y allá. Parece más seguro incluir una instrucción en los constructores de la clase [Person] que incremente un contador. Este contador no puede ser un campo ordinario, ya que cada objeto tiene sus propios campos: es un campo de la propia clase y no de una instancia particular de esa clase. Se declara con la palabra clave [static]: [private static long nbPersons;].

Para referirnos a él, escribimos [Person.nbPersons] para indicar que es un campo de la clase [Person] misma. Aquí hemos creado un campo privado al que no se puede acceder directamente desde fuera de la clase. Por lo tanto, creamos un accesor público para dar acceso al campo de clase [nbPersons]. Para obtener el valor de [nbPersons], este accesor no necesita un [Person] objeto específico; por eso también lo declaramos como *[static]. Desde el exterior, se llamará con la sintaxis [Person.getNbPersons()]. Aquí hay un ejemplo de [Classes10.java]*:

// miembros de clase (static)
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    Person p2 = new Person(p1);
    new Person(p1);
    IO.println("Number of persons created: " + Person.getNbPersons());
    // un método de clase
    Person p3 = Person.unknown();
    p3.identify();
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// clase anidada estática: véanse las explicaciones
static class Person {
    // atributo de clase
    private static long nbPersons;

    // getter de clase
    public static long getNbPersons() {
        return nbPersons;
    }

    // método de clase
    public static Person unknown() {
        return new Person("?", "?", 0);
    }

    // atributos de instancia
    private String firstName;
    private String lastName;
    private int age;

    // constructores
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        nbPersons++;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // identidad de la persona
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • línea 16: el campo de clase. Como cualquier campo numérico, se inicializa en 0;
  • líneas 19–21: el accesor de clase;
  • líneas 24–26: un método de clase. Se llama mediante el nombre de la clase: [Person.unknown()] (línea 8). Un método de clase no tiene objeto actual: la palabra clave [this] no tiene sentido allí, y solo puede usar directamente los miembros [static] de la clase. Un método estático que crea y devuelve un objeto de su propia clase, como este, se denomina fábrica estática;
  • línea 38: el constructor principal incrementa el contador. Por lo tanto, el constructor de copia, que está encadenado al constructor principal, también lo incrementa;
  • Línea 14: La clase [Person] se declara como [static]. Como se explicó en la sección sobre archivos compactos: una clase declarada en un archivo compacto es una clase anidada de la clase implícita. Sin la palabra clave [static], es una clase interna, en la que cada objeto está vinculado a un objeto de la clase envolvente; el método estático [unknown], que no tiene objeto actual, no podría crear uno, y el compilador informaría el error [non-static variable this cannot be referenced from a static context]. Una clase escrita en su propio archivo no presenta este problema.

Resultados:

1
2
3
4
> java Classes10.java
Number of persons created: 3
[?, ?, 0]
Number of persons created: 4

El programa contó correctamente el objeto temporal creado en la línea 5. Hemos usado miembros de clase desde el principio: [IO.println], [Integer.parseInt], [Math.sqrt] son métodos [static], y [Math.PI] es un campo [static]. La clase [Math] contiene solo miembros estáticos: se declara como [final], y su único constructor es privado, lo que impide la creación de instancias. Esta es la forma en que Java escribe una clase de utilidades.

4.1.19. Un arreglo de personas

Un objeto es un dato como cualquier otro y, como tal, se pueden agrupar varios objetos en un arreglo [Classes11.java]:

// un arreglo de personas
void main() {
    Person[] friends = new Person[3];
    friends[0] = new Person("Jean", "Dupont", 30);
    friends[1] = new Person("Sylvie", "Vartan", 52);
    friends[2] = new Person("Neil", "Armstrong", 66);
    // visualización
    for (Person friend : friends) {
        friend.identify();
    }
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // constructor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // identidad de la persona
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • Línea 3: crea un arreglo de 3 elementos de tipo [Person]. Estos 3 elementos se inicializan aquí con el valor [null], es decir, no hacen referencia a ningún objeto. Técnicamente se habla de un “arreglo de objetos”, aunque en realidad es solo un arreglo de referencias a objetos. La creación del arreglo —que es en sí mismo un objeto (como lo indica [new])— no crea ningún objeto del mismo tipo que sus elementos; esto debe hacerse posteriormente;
  • líneas 4–6: creación de los 3 objetos de tipo [Person];
  • líneas 8–10: muestran el contenido del arreglo [friends].

Resultados:

1
2
3
4
> java Classes11.java
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

4.1.20. Inferencia de tipos e inicialización de arreglos

El programa [Classes12.java] presenta dos construcciones que simplifican la creación de objetos y arreglos:

// inferencia de tipo con var e inicialización de arreglos
void main() {
    // el tipo de la variable se deduce de la expresión que la inicializa
    var p1 = new Person("Jean", "Dupont", 30);
    var p2 = new Person();
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    p2.setAge(7);
    // un arreglo creado e inicializado con una lista de valores entre llaves
    Person[] friends = {
        p1,
        p2,
        new Person("Sylvie", "Vartan", 52),
        new Person("Neil", "Armstrong", 66),
    };
    for (var friend : friends) {
        IO.println(friend.getIdentity());
    }
    // un arreglo anónimo pasado como parámetro
    display(new Person[] { new Person("Pauline", "Leduc", 12), p1 });
}

// un método que recibe un arreglo de personas
void display(Person[] persons) {
    for (Person p : persons) {
        IO.println("Display: " + p.getIdentity());
    }
}

class Person {
    // campos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // constructores
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person() {
    }

    // setters
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // identidad
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • Línea 4: Con la palabra clave [var] (Java 10), el tipo de la variable local se infiere de la expresión que la inicializa, en este caso [Person]. No obstante, la variable tiene tipo: [p1] es de tipo [Person] y solo puede hacer referencia a una persona. [var] solo puede usarse para variables locales inicializadas en la declaración, no para campos ni parámetros;
  • líneas 10–15: un arreglo creado y llenado con una lista de valores entre llaves y separados por comas. El tamaño del arreglo es el número de valores. Se permite una coma final (línea 14): facilita agregar un elemento. Esta sintaxis solo se permite en la declaración del arreglo;
  • línea 16: [var] dentro de un bucle [for];
  • línea 20: fuera de una declaración de arreglo, un arreglo inicializado se crea especificando su tipo: [new Person[] { ... }]. Esto se denomina arreglo anónimo: no está referenciado por ninguna variable en el método [main];
  • Líneas 24–28: Un método del archivo compacto que recibe un arreglo de personas.

Resultados:

1
2
3
4
5
6
7
> java Classes12.java
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display: [Pauline, Leduc, 12]
Display: [Jean, Dupont, 30]

4.2. La herencia a través de un ejemplo

4.2.1. Descripción general

Aquí presentamos el concepto de herencia. El propósito de la herencia es “personalizar” una clase existente para que satisfaga nuestras necesidades. Supongamos que queremos crear una clase [Teacher]: un profesor es un tipo específico de persona. Tiene atributos que otras personas no tienen: por ejemplo, la materia que enseña. Pero también tiene los atributos comunes a todas las personas: nombre, apellido y edad. Por lo tanto, un profesor es un miembro de pleno derecho de la clase [Person], pero tiene atributos adicionales. En lugar de crear una clase [Teacher] desde cero, preferimos construir a partir de la clase existente [Person] y adaptarla a las características específicas de los profesores. Esto es posible gracias al concepto de herencia.

Para indicar que la clase [Teacher] hereda de la clase [Person], escribimos [public class Teacher extends Person].

[Person] se denomina clase padre (o clase base, o superclase), y [Teacher] se denomina clase derivada (o clase hija, o subclase). Un objeto [Teacher] tiene todas las propiedades de un objeto [Person]: tiene los mismos campos y métodos. Estos campos y métodos de la clase padre no se repiten en la definición de la clase hija; simplemente se especifican los campos y métodos que agrega la clase hija. Una clase Java puede heredar de una sola clase padre.

Los ejemplos de este apartado son dos programas de varios archivos, ubicados en las carpetas [Inheritance1] e [Inheritance2] . En la carpeta [Inheritance1], la clase [Person] se define de la siguiente manera: [Person.java]:

public class Person {
    // campo de clase: el número de personas creadas
    private static long nbPersons;

    // campos de instancia
    private String firstName;
    private String lastName;
    private int age;

    // constructor
    public Person(String firstName, String lastName, int age) {
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
        nbPersons++;
        IO.println("Constructor Person(String, String, int)");
    }

    // número de personas creadas
    public static long getNbPersons() {
        return nbPersons;
    }

    // getters
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setters
    public final void setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
    }

    public final void setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
    }

    public final void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }

    // identidad de la persona
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // verificación de una cadena obligatoria
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value;
    }
}
  • línea 3: el contador de personas del apartado anterior;
  • líneas 11–17: el constructor inicializa el objeto mediante sus modificadores, incrementa el contador y muestra un mensaje de seguimiento;
  • líneas 38–51: tres modificadores que validan sus valores. Las validaciones del nombre y del apellido, que son idénticas, se factorizan en el método de clase privado [check] (líneas 59–64). Los modificadores se declaran como [final] porque el constructor los llama (véase el programa [Classes07.java]);
  • líneas 54–56: el método [identify] de los ejemplos anteriores se ha reemplazado por el método [getIdentity], que devuelve la identidad de la persona en lugar de mostrarla.

Creamos una clase llamada [Teacher] que hereda de la clase [Person]: [Teacher.java]:

public class Teacher extends Person {
    // campo específico de la clase Teacher
    private int section;

    // constructor
    public Teacher(String firstName, String lastName, int age, int section) {
        // construcción de la parte Person del objeto
        super(firstName, lastName, age);
        // almacenamos la sección
        this.section = section;
        // seguimiento
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // getter y setter de la sección
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }
}

La clase [Teacher] agrega a los campos y métodos de la clase [Person]:

  • línea 1: la clase [Teacher] deriva de la clase [Person];
  • línea 3: un campo [section], que es el número de la sección a la que pertenece el profesor dentro del cuerpo docente (aproximadamente una sección por materia);
  • líneas 6–13: un constructor que sirve para inicializar todos los campos de un profesor;
  • líneas 16–22: el getter y el setter del campo [section].

4.2.2. Creación de un objeto Teacher

Una clase hija no hereda los constructores de su clase padre. Debe definir sus propios constructores. El constructor de la clase [Teacher] es el siguiente:

1
2
3
4
5
6
7
8
    public Teacher(String firstName, String lastName, int age, int section) {
        // construcción de la parte Person del objeto
        super(firstName, lastName, age);
        // almacenamos la sección
        this.section = section;
        // seguimiento
        IO.println("Constructor Teacher(String, String, int, int)");
    }

El constructor recibe cuatro parámetros ([firstName], [lastName], [age], [section]) y pasa tres ([firstName], [lastName], [age]) a su clase padre —en este caso, la clase [Person]— mediante la instrucción [super(firstName, lastName, age);] (línea 3). Sabemos que esta clase tiene un constructor, [Person(String, String, int)], que se usará para crear una persona con los parámetros pasados. Una vez completada la construcción de la parte [Person], la construcción del objeto [Teacher] continúa ejecutando el resto del constructor (líneas 5–7).

En resumen, el constructor de una clase derivada:

  • pasa a su clase padre, mediante [super(...)], los parámetros que la clase padre necesita para construirse;
  • usa los demás parámetros para inicializar sus propios campos.

Podríamos haber optado por inicializar los campos [firstName], [lastName] y [age] directamente en el constructor de la clase [Teacher], con instrucciones como [this.firstName = firstName;]. Esto es imposible por dos razones. En primer lugar, los campos privados [firstName], [lastName] y [age] solo son accesibles para los métodos de la clase [Person]. Todos los demás objetos, incluidos los objetos de clases derivadas como en este caso, deben acceder a ellos a través de miembros públicos (o protegidos). Habría sido distinto si la clase [Person] hubiera declarado estos campos como protegidos (*[protected]*): entonces habría permitido que las clases derivadas accedieran a ellos directamente. Además, la parte [Person] del objeto debe construirse en todo caso mediante un constructor de la clase [Person]: si no hay una llamada a [super(...)], el compilador inserta una llamada a [super()]—el constructor sin parámetros de la clase padre. Sin embargo, la clase [Person] no tiene uno. Si se elimina la instrucción [super(firstName, lastName, age);], el compilador informa el siguiente error:

1
2
3
4
5
6
7
8
9
> java Main.java
.../Inheritance1/Teacher.java:6: error: constructor Person in class Person cannot be applied to given types;
    public Teacher(String firstName, String lastName, int age, int section) {
                                                                            ^
  required: String,String,int
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error
error: compilation failed

Por lo tanto, usar el constructor de la clase padre es la solución correcta y el enfoque estándar: al construir un objeto hijo, primero se llama al constructor del objeto padre y luego se completan las inicializaciones específicas del objeto hijo ([section] en nuestro ejemplo). Al igual que con [this(...)], solo pueden preceder a la llamada a [super(...)] las instrucciones que no usen el objeto en construcción (desde Java 25; antes, [super(...)] tenía que ser la primera instrucción).

4.2.3. Métodos heredados

La clase [Teacher] no define un método llamado [getIdentity]. La expresión [e.getIdentity()], donde [e] es un profesor, hace referencia por lo tanto al método [getIdentity] heredado de la clase [Person]: es público y, por herencia, se convierte en un método público de la clase [Teacher]. El programa de prueba [Main.java] de la carpeta [Inheritance1] es el siguiente:

void main() {
    // un profesor
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    // el método getIdentity heredado de la clase Person
    IO.println(e.getIdentity());
    // el método getSection específico de la clase Teacher
    IO.println("section=" + e.getSection());
    // una persona
    Person p = new Person("Jean", "Dupont", 30);
    // el método display recibe una Person o un objeto de una clase derivada
    display(e);
    display(p);
    // el método toString heredado de la clase Object
    IO.println(e.toString());
    IO.println(p.toString());
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// muestra la identidad de p
void display(Person p) {
    IO.println(p.getIdentity());
}
  • línea 3: crea un profesor;
  • línea 5: muestra la identidad del profesor, obtenida mediante el método [getIdentity] heredado de la clase [Person];
  • línea 7: el método [getSection], específico de la clase [Teacher];
  • líneas 11–12: llamada al método [display] (líneas 20–22) con un profesor y luego con una persona. Volveremos sobre esto en el siguiente apartado;
  • líneas 14–15: llamada al método [toString] para ambos objetos. También volveremos sobre esto.

Resultados:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
[Lucile, Dumas, 56]
section=61
Constructor Person(String, String, int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
Teacher@70325e14
Person@37ceb1df
Number of persons created: 2

Podemos ver que:

  • un objeto [Person] (línea 2 de los resultados) se construyó antes que el objeto [Teacher] (línea 3);
  • [e.getIdentity()] proporcionó la identidad de la parte [Person] del profesor, sin su sección (línea 4);
  • el contador de personas también cuenta al profesor (línea 11): un profesor es una persona.

Para obtener la identidad completa de un profesor, la clase [Teacher] debe definir su propio método [getIdentity]. Esto es lo que hace la carpeta [Inheritance2].

4.2.4. Polimorfismo

Consideremos una jerarquía de clases: C0 ← C1 ← C2 ← … ← Cn, donde Ci ← Cj indica que la clase Cj deriva de la clase Ci. Esto implica que la clase Cj tiene todas las características de la clase Ci más otras adicionales. Sean Oi objetos de tipo Ci. Es válido escribir [Oi = Oj] con j > i. En efecto, por herencia, la clase Cj tiene todas las características de la clase Ci más otras adicionales. Por lo tanto, un objeto Oj de tipo Cj contiene un objeto de tipo Ci. La operación [Oi = Oj] hace que la variable Oi, de tipo Ci, haga referencia al objeto Oj: a través de ella solo se puede acceder a los miembros definidos en la clase Ci.

El hecho de que una variable Oi de clase Ci pueda hacer referencia no solo a un objeto de clase Ci sino a cualquier objeto derivado de la clase Ci se denomina polimorfismo: la capacidad de una variable de hacer referencia a diferentes tipos de objetos.

Veamos un ejemplo y consideremos el método [display] del programa anterior:

1
2
3
void display(Person p) {
    IO.println(p.getIdentity());
}

Podemos pasarle un [Person] o un [Teacher]: En este último caso, el parámetro formal [p], que es de tipo [Person], recibe un valor de tipo [Teacher]. Dado que el tipo [Teacher] deriva del tipo [Person], esto es válido. La instrucción [p.getIdentity()] ejecutó aquí el método [getIdentity] de la clase [Person], el único que existe en el programa: para el profesor (línea 7 de los resultados), solo obtenemos la identidad de su parte “Person”. Veamos qué sucede cuando la clase [Teacher] tiene su propio método [getIdentity].

4.2.5. Redefinición de métodos y enlace dinámico

En la carpeta [Inheritance2], la clase [Person] es la misma que la de la carpeta [Inheritance1] con una adición:

    // identidad de la persona: método redefinido en la clase Teacher
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // redefinición del método toString de la clase Object
    @Override
    public String toString() {
        return getIdentity();
    }
  • líneas 6–10: una redefinición del método [toString], que se trata en el apartado siguiente.

En la clase [Teacher], el método [getIdentity] se redefine de la siguiente manera:

// una clase final: no se puede derivar de ella
public final class Teacher extends Person {
    // campo específico de la clase Teacher
    private int section;

    // constructor
    public Teacher(String firstName, String lastName, int age, int section) {
        super(firstName, lastName, age);
        this.section = section;
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // getter y setter de la sección
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }

    // el método getIdentity redefine el de la clase padre
    @Override
    public String getIdentity() {
        return "Teacher[" + super.getIdentity() + "," + section + "]";
    }
}
  • Líneas 23–26: El método [getIdentity] redefine el de la clase padre; tiene el mismo nombre, los mismos parámetros y el mismo tipo de retorno. Se apoya en el método [getIdentity] de su clase padre, al que se hace referencia como [super.getIdentity()], para recuperar la parte “Person”, y luego lo complementa con la sección específica de la clase [Teacher];
  • Línea 23: La anotación [@Override] le indica al compilador que el método pretende redefinir un método de la clase padre. No es obligatoria, pero se recomienda enfáticamente: si el método no redefiniera nada (por un error tipográfico en el nombre o por parámetros diferentes), el compilador informaría el error en lugar de crear silenciosamente un método nuevo;
  • Línea 2: La clase es final ([final]), lo que explicaremos con más detalle más adelante.

Consideremos un objeto profesor [E]. Este objeto contiene en su interior un objeto [Person]:

Image

El método [getIdentity] está definido tanto en la clase [Teacher] como en su clase padre [Person]. En Java, todos los métodos de instancia que no son privados ni finales pueden redefinirse, y la elección del método que ejecuta [p.getIdentity()] se hace en tiempo de ejecución, según el tipo real del objeto al que hace referencia [p], y no en tiempo de compilación según el tipo declarado de la variable. Esto se conoce como enlace dinámico. Para ejecutar [o.m()], la máquina virtual busca un método llamado [m] en el siguiente orden:

  • en la clase del objeto [o];
  • en su clase padre, si la tiene;
  • en la clase padre de su clase padre, si existe;
  • y así sucesivamente.

Por lo tanto, la herencia permite redefinir en la clase hija métodos que tienen la misma firma que los de la clase padre. Esto es lo que permite adaptar la clase hija a sus propias necesidades. El programa [Main.java] de la carpeta [Inheritance2] es el siguiente:

void main() {
    // un profesor
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    display(e);
    // una persona
    Person p = new Person("Jean", "Dupont", 30);
    display(p);
    // visto como Person, el profesor sigue siendo un profesor
    Person pe = e;
    IO.println(pe.getIdentity());
    IO.println(((Person) e).getIdentity());
    // IO.println(Object) muestra el resultado del método toString del objeto
    IO.println(e);
    IO.println(p);
    // un arreglo de personas de diferentes tipos
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }
}

// muestra la identidad de p
void display(Person p) {
    IO.println(p.getIdentity());
}

Resultados:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(String, String, int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

Esta vez, en la línea 4 de los resultados, el método [display] mostró correctamente el nombre completo del profesor. Las líneas 9–11 del programa muestran que, ya sea visto a través de una variable de tipo [Person] o convertido a [Person] mediante el operador [(Person)], el profesor sigue siendo un profesor: sigue siendo el método [getIdentity] de la clase [Teacher] el que se ejecuta (líneas 7–8 de los resultados). La conversión cambia el tipo de la referencia, no el del objeto. A diferencia de otros lenguajes como C#, donde un método solo puede redefinirse si se declara virtual, los métodos de Java son “virtuales” por defecto; no existe tal cosa como la redefinición de un método de instancia.

4.2.6. La clase Object y el método toString

La clase [java.lang.Object] es la clase “padre” de todas las clases de Java. Así, cuando se escribe [public class Person], se está escribiendo implícitamente [public class Person extends Object].

La clase [Object] define varios métodos que todos los objetos heredan:

  • [String toString()]: devuelve una representación textual del objeto. Por defecto, es el nombre de la clase del objeto, seguido del carácter [@] y de un código hash escrito en hexadecimal;
  • [boolean equals(Object o)]: indica si el objeto es “igual” al objeto [o]. Por defecto, solo es igual a sí mismo: el método compara referencias, como el operador [==];
  • [int hashCode()]: devuelve un código hash del objeto, usado por los diccionarios y los conjuntos (véase el próximo capítulo). Los métodos [equals] y [hashCode] se tratan más adelante;
  • [Class<?> getClass()]: devuelve la descripción de la clase real del objeto. El método [getSimpleName] de esta descripción devuelve el nombre de la clase, mientras que [getName] devuelve su nombre completo.

Es el método [toString] de la clase [Object] el que usaron las llamadas [e.toString()] y [p.toString()] en la carpeta [Inheritance1]: [Teacher@70325e14] y [Person@37ceb1df] (líneas 9–10 de los resultados; los números varían de una ejecución a otra). Aunque no redefinimos el método [toString] en las clases [Person] y [Teacher], el método [toString] de la clase [Object] pudo mostrar el nombre real de la clase del objeto.

En la carpeta [Inheritance2], la clase [Person] redefine el método [toString] (véase más arriba). Volvamos al programa [Main.java] de la carpeta [Inheritance2]:

1
2
3
4
5
6
7
8
    // IO.println(Object) muestra el resultado del método toString del objeto
    IO.println(e);
    IO.println(p);
    // un arreglo de personas de diferentes tipos
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }

Línea 2: El método [IO.println(Object)] acepta un parámetro de tipo [Object]; por lo tanto, dado que [Object] es la superclase de todas las clases, se puede pasar cualquier objeto —en este caso, un [Teacher]—. Imprime en la consola el resultado del método [toString] del objeto. Como el enlace es dinámico, se usa el método [toString] del objeto real —en este caso, el heredado de la clase [Person]. Este devuelve [getIdentity()], un método redefinido: para el profesor [e], se ejecuta por lo tanto el método [getIdentity] de la clase [Teacher], como se muestra en la línea 9 de los resultados. Por lo tanto, no es necesario redefinir [toString] en la clase [Teacher].

El mismo mecanismo se aplica a la concatenación de una cadena y un objeto: en [" : " + person] (línea 7), el objeto [person] se convierte en cadena mediante su método [toString]. El bucle de las líneas 6–8 recorre un arreglo de referencias [Person] que en realidad apuntan a objetos de tipos diferentes: [getClass().getSimpleName()] devuelve el nombre real de la clase de cada objeto (líneas 11–12 de los resultados).

4.2.7. Clases finales y clases selladas

La clase [Teacher] del paquete [Inheritance2] se declara como [public final class Teacher extends Person]. La palabra clave [final] impide derivar clases de la clase [Teacher]: la declaración [class TeacherResearcher extends Teacher] sería rechazada por el compilador. Una clase se marca como final cuando no está destinada a ser derivada. Hemos visto que la palabra clave también se aplica a los métodos: un método [final] no puede ser redefinido por las clases derivadas, sin que ello prohíba derivar de esa clase. Por ejemplo, la clase [String], derivada del JDK, es final.

Entre una clase abierta a todas las derivaciones y una clase final, Java 17 agregó una opción intermedia: la clase sellada ([sealed]), que proporciona una lista exhaustiva de sus clases derivadas directas. El programa [Classes13.java] lo ilustra:

// clases final y clases selladas (Java 17)
void main() {
    Person[] persons = {
        new Teacher("Lucile", "Dumas", 61),
        new Student("Paul", "Martin", "computer science"),
        new Adjunct("Marc", "Petit"),
        new Consultant("Lise", "Morel", "Airbus"),
    };
    for (Person p : persons) {
        IO.println(p.getClass().getSimpleName() + " : " + p.getIdentity());
    }
    // las subclases directas permitidas de la clase sellada Person
    IO.println("Person is sealed: " + Person.class.isSealed());
    for (Class<?> c : Person.class.getPermittedSubclasses()) {
        IO.println("permitted subclass: " + c.getSimpleName());
    }
}

// una clase sellada: solo las clases listadas después de permits pueden derivar de ella
abstract sealed class Person permits Teacher, Student, Adjunct {
    private final String firstName;
    private final String lastName;

    protected Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getIdentity() {
        return "[" + firstName + ", " + lastName + "]";
    }
}

// una clase derivada de una clase sellada debe ser final, sealed o non-sealed
final class Teacher extends Person {
    private final int section;

    public Teacher(String firstName, String lastName, int section) {
        super(firstName, lastName);
        this.section = section;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", section " + section;
    }
}

final class Student extends Person {
    private final String major;

    public Student(String firstName, String lastName, String major) {
        super(firstName, lastName);
        this.major = major;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", major " + major;
    }
}

// non-sealed: la jerarquía vuelve a ser abierta a partir de esta clase
non-sealed class Adjunct extends Person {
    public Adjunct(String firstName, String lastName) {
        super(firstName, lastName);
    }
}

// una clase derivada de Adjunct: permitida, ya que Adjunct no es sellada
class Consultant extends Adjunct {
    private final String company;

    public Consultant(String firstName, String lastName, String company) {
        super(firstName, lastName);
        this.company = company;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", company " + company;
    }
}

// rechazado por el compilador: Artist no figura en la cláusula permits de Person
// final class Artist extends Person { ... }
  • Línea 20: La clase abstracta (véase más adelante: no se pueden crear objetos de esta clase, solo de sus clases derivadas) [Person] es sellada. Solo las clases [Teacher], [Student], y [Adjunct], enumeradas después de la palabra clave [permits], pueden derivar de ella. Cuando las clases derivadas se declaran en el mismo archivo, como aquí, la cláusula [permits] puede omitirse: las clases autorizadas son entonces las del archivo que derivan directamente de ella. En un programa más grande, las clases autorizadas deben pertenecer al mismo paquete que la clase sellada (o al mismo módulo si la clase sellada pertenece a un módulo con nombre);
  • línea 24: el constructor es protegido ([protected]): está destinado únicamente a las clases derivadas;
  • Líneas 35 y 49: Una clase derivada de una clase sellada debe especificar cómo puede ser derivada a su vez. Las clases [Teacher] y [Student] son finales;
  • línea 64: la clase [Adjunct] se declara como [non-sealed]: esto reabre la jerarquía y permite que cualquier clase derive de ella. Una tercera opción es declararla a su vez como [sealed], con su propia lista de clases permitidas;
  • líneas 71–83: La clase [Consultant] deriva de [Adjunct], lo cual está permitido;
  • líneas 85–86: una clase [Artist] derivada de [Person] sería rechazada;
  • Líneas 13–16: La descripción de una clase ([Person.class]) indica si es sellada ([isSealed]) y enumera sus clases derivadas directas autorizadas ([getPermittedSubclasses]).

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes13.java
Teacher : [Lucile, Dumas], section 61
Student : [Paul, Martin], major computer science
Adjunct : [Marc, Petit]
Consultant : [Lise, Morel], company Airbus
Person is sealed: true
permitted subclass: Teacher
permitted subclass: Student
permitted subclass: Adjunct

Si se quita el comentario de la clase [Artist] (dotándola de un constructor), el compilador informa:

1
2
3
4
5
6
> java Classes13.java
Classes13.java:86: error: class is not allowed to extend sealed class: Classes13.Person (as it is not listed in its 'permits' clause)
final class Artist extends Person { Artist() { super("a", "b"); } }
      ^
1 error
error: compilation failed

¿Cuál es el propósito de una clase sellada? Permite que el autor de una jerarquía de clases mantenga el control sobre ella: el autor sabe que cualquier [Person] es un [Teacher], un [Student], o un [Adjunct]. El compilador también lo sabe y lo aprovecha en el filtrado por patrones, que se trata al final del capítulo: un [switch] que maneja los tres casos es completo. El mecanismo también se aplica a las interfaces ([sealed interface]), que se tratan más adelante.

4.3. Sin sobrecarga de operadores: equals, compareTo…

Algunos lenguajes, como C# o C++, permiten redefinir el significado de los operadores ([+], [==], [<]…) para una clase. Java no lo permite: los operadores siempre tienen el significado que les asigna el lenguaje. La única excepción es el operador [+] aplicado a una cadena, que realiza una concatenación y para ello usa el método [toString] del objeto concatenado. En lugar de operadores, escribimos métodos que siguen convenciones bien establecidas:

Operación
Método de Java
Ejemplo
Igualdad de contenido ([==] compara referencias)
[boolean equals(Object o)], heredado de [Object]
[s1.equals(s2)]
Comparación ([<], [>]…)
[int compareTo(T other)] de la interfaz [Comparable<T>]: resultado negativo, nulo o positivo
[s1.compareTo(s2) < 0]
operaciones aritméticas
métodos con nombre explícito
[a.add(b)], [a.multiply(b)] para [BigDecimal]
Adición a una colección ([+=])
[add]
[list.add(p)]

4.3.1. Un ejemplo

La carpeta [Lists] contiene una clase [ListOfPersons], una lista de personas, cuyos métodos actúan como los operadores [+] y [+=]. Las clases [Person] y [Teacher] de esta carpeta son versiones simplificadas de las de la carpeta [Inheritance2]: los campos son [final] y no tienen modificadores; ya no hay mensajes de seguimiento ni contadores. Las personas se organizan en una lista genérica [List<Person>] (las clases genéricas se tratan más adelante en este capítulo; las listas se tratan en el próximo capítulo). En lugar de hacer que la clase [ListOfPersons] herede de una clase de lista derivada del JDK, colocamos la lista en un campo privado de la clase. Esto se conoce como usar composición en lugar de herencia: de este modo, la clase [ListOfPersons] expone solo las operaciones que ha elegido. De la interfaz [List<Person>], usamos únicamente los siguientes elementos:

  • el método [l.add(p)], que agrega la persona [p] a la lista [l], y el método [l.addAll(l2)], que le agrega todos los elementos de la lista [l2];
  • el método [l.size()], que devuelve el número de elementos de la lista [l];
  • los métodos [l.get(i)] y [l.set(i, p)], que leen y modifican el elemento número i de la lista [l].

La definición de la clase [ListOfPersons] es la siguiente: [ListOfPersons.java]:

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

public class ListOfPersons {
    // las personas de la lista
    private final List<Person> persons = new ArrayList<>();

    // número de personas de la lista
    public int size() {
        return persons.size();
    }

    // el equivalente de un operador +: devuelve una nueva lista que contiene las personas
    // de la lista actual y la persona p
    public ListOfPersons plus(Person p) {
        ListOfPersons result = new ListOfPersons();
        result.persons.addAll(persons);
        result.persons.add(p);
        return result;
    }

    // el equivalente de un operador +=: agrega p a la lista actual, que se devuelve
    public ListOfPersons add(Person p) {
        persons.add(p);
        return this;
    }

    // el equivalente de un indexador: lectura y escritura del elemento n.º i
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // posición de la persona con el apellido dado, -1 si no existe
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }

    // toString: devuelve (person1,person2,...)
    @Override
    public String toString() {
        StringJoiner joiner = new StringJoiner(",", "(", ")");
        for (Person p : persons) {
            joiner.add(p.toString());
        }
        return joiner.toString();
    }
}
  • líneas 1–3: A diferencia del archivo compacto [Main.java], un archivo normal no importa automáticamente las clases del módulo [java.base]: debe importar las que usa (excepto las del paquete [java.lang], como [String], que siempre son conocidas). Las cláusulas [import] se proporcionan con los paquetes;
  • línea 7: la lista de personas. La palabra clave [final] indica que el campo siempre hará referencia a la misma lista; el contenido de la lista sí puede cambiar. [new ArrayList<>()] crea una lista vacía; el operador “diamante” [<>] permite que el compilador infiera el tipo de los elementos, [Person], a partir del tipo del campo;
  • líneas 10–12: el número de personas;
  • líneas 16–21: el método [plus] actúa como un operador [+] para la operación [l.plus(p)], donde [l] es de tipo [ListOfPersons] y [p] es de tipo [Person] o un derivado de este. Crea una nueva lista (línea 17), copia en ella las personas de la lista actual (línea 18) y luego agrega la persona [p] (línea 19). Al igual que con el operador [+] para números o cadenas, los operandos no se modifican. Dado que la lista [result] es de la misma clase, el método tiene acceso a su campo privado [result.persons]. La lista devuelta es de tipo [ListOfPersons], lo que permite llamadas encadenadas como en [l.plus(p1).plus(p2)];
  • líneas 24–27: el método [add] actúa como un operador [+=]: modifica la lista actual agregándole la persona [p] y devuelve esa misma lista, lo que también permite llamadas encadenadas;
  • Líneas 49–56: Redefinimos el método [toString] para mostrar una lista de personas con la forma (persona1, persona2, ...), donde personai es a su vez el resultado del método [toString] de la persona. Un objeto [StringJoiner] (línea 51) construye una cadena a partir de elementos sucesivos ([add], línea 53), separándolos con el separador especificado (en este caso, una coma) y encerrándolos con un prefijo y un sufijo (en este caso, paréntesis).

Observe que la clase [ListOfPersons] no tiene constructor. Por lo tanto, usa el constructor por defecto, que no recibe parámetros y no hace más que inicializar el campo [persons] con el valor especificado en su declaración. Las líneas 29–46 se tratan en la sección siguiente.

El programa de prueba [Main.java] comienza así:

void main() {
    // - métodos en lugar de operadores
    String s1 = "jean";
    String s2 = new StringBuilder("je").append("an").toString();
    IO.println("s1 == s2 : " + (s1 == s2) + ", s1.equals(s2) : " + s1.equals(s2));
    IO.println("s1.compareTo(\"paul\") : " + s1.compareTo("paul"));
    BigDecimal a = new BigDecimal("0.10"), b = new BigDecimal("0.20");
    IO.println("a + b = " + a.add(b) + ", a < b : " + (a.compareTo(b) < 0));

    // - el método plus
    // una lista de personas
    ListOfPersons l = new ListOfPersons();
    // agregar personas
    l = l.plus(new Person("jean", "martin", 10)).plus(new Person("pauline", "leduc", 12));
    // visualización
    IO.println("l=" + l);
    // l.plus(p) devuelve una nueva lista: l no se modifica
    ListOfPersons l2 = l.plus(new Person("louis", "durand", 8));
    IO.println("l=" + l);
    IO.println("l2=" + l2);

    // - el método add
    ListOfPersons l3 = l;
    // add modifica la lista referenciada por l, sin crear una nueva lista
    l.add(new Teacher("camille", "germain", 27, 60));
    IO.println("l=" + l);
    // l y l3 siguen referenciando el mismo objeto
    IO.println("l3 == l : " + (l3 == l));
  • Líneas 3–5: dos cadenas con el mismo contenido pero distintas: la cadena [s2] se construye en tiempo de ejecución. El operador [==] compara las referencias, mientras que el método [equals] compara los contenidos. Para comparar dos cadenas, siempre se debe usar [equals];
  • línea 6: el método [compareTo] devuelve un número negativo porque “jean” va antes que “paul” en el orden de los códigos de caracteres;
  • Líneas 7–8: La clase [BigDecimal] (números decimales exactos, que usaremos para los montos) reemplaza los operadores [+] y [<] por los métodos [add] y [compareTo];
  • línea 12: creación de una lista vacía de personas [l];
  • línea 14: se agregan dos personas mediante el método [plus];
  • línea 18: [l.plus(p)] crea una nueva lista, [l2]; la lista [l] permanece sin cambios;
  • línea 25: agrega un profesor mediante el método [add];
  • líneas 16–20: la concatenación de una cadena y un objeto usa el método [toString], que está redefinido en la clase [ListOfPersons].

Resultados (inicio):

1
2
3
4
5
6
7
8
9
> java Main.java
s1 == s2 : false, s1.equals(s2) : true
s1.compareTo("paul") : -6
a + b = 0.30, a < b : true
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3 == l : true

¿Por qué hay dos métodos, si [l = l.plus(p)] produce el mismo resultado que [l.add(p)]? El método [plus] crea una nueva lista, copia en ella todas las personas de [l] y luego [l] hace referencia a esta nueva lista, mientras que la antigua es descartada por el recolector de basura. El método [add] agrega la persona a la lista existente sin copiarla. La línea 23 almacena una segunda referencia, [l3], a la lista [l]; tras la llamada a [l.add(...)], ambas referencias siguen apuntando al mismo objeto (línea 9 de los resultados), lo que prueba que la lista no se volvió a crear. Para una lista grande, o dentro de un bucle, la diferencia de rendimiento es significativa. La elección entre los dos estilos es evidente en el JDK: los objetos inmutables [String] y [BigDecimal] devuelven objetos nuevos; las listas y [StringBuilder] se modifican.

4.4. Sin indexadores: métodos get y set

Aquí seguimos usando la clase [ListOfPersons]. Si [l] es un objeto [ListOfPersons], queremos poder referirnos a la persona que está en el índice i de la lista [l] tanto para leerla como para escribirla. Algunos lenguajes permiten definir un “indexador” para este fin, que permite usar la notación [l[i]] sobre un objeto. Java no lo permite: la notación [[i]] está reservada para los arreglos. Por convención, escribimos los métodos [get(int i)] y [set(int i, value)], tal como lo hacen las listas del JDK:

    // el equivalente de un indexador: lectura y escritura del elemento n.º i
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // posición de la persona con el apellido dado, -1 si no existe
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }
  • líneas 2–4: el método [get] devuelve la persona número i de la lista privada [persons];
  • líneas 6–8: el método [set] le asigna la persona [p];
  • líneas 11–18: También queremos poder obtener la posición en la lista de la persona con un nombre dado, o -1 si esa persona no está en la lista. El nombre [indexOf] es el del método equivalente de las listas y las cadenas del JDK. Los nombres se comparan mediante [equals] (línea 13).

El programa de prueba continúa así:

    // - los métodos get, set e indexOf en lugar de indexadores
    // cambio del elemento n.º 1
    l.set(1, new Person("franck", "gallon", 5));
    // visualización del elemento n.º 1
    IO.println("l.get(1)=" + l.get(1));
    // visualización de la lista l
    IO.println("l=" + l);
    // búsqueda de personas por su apellido
    String[] lastNames = { "martin", "germain", "xx" };
    for (String lastName : lastNames) {
        int index = l.indexOf(lastName);
        if (index != -1) {
            IO.println("Person(" + lastName + ")=" + l.get(index));
        } else {
            IO.println("Person(" + lastName + ") does not exist");
        }
    }
  • línea 3: llamada al método [set];
  • línea 5: llamada al método [get];
  • línea 11: llamada al método [indexOf];
  • línea 13: llamada al método [get].

Resultados (final):

1
2
3
4
5
6
...
l.get(1)=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist

4.5. Sin estructuras: tipos primitivos y registros

4.5.1. Valor y referencia

Otros lenguajes, como C o C#, ofrecen estructuras además de clases: tipos cuyas variables contienen directamente los datos, en lugar de una referencia a un objeto. Java no las tiene. Distingue dos familias de tipos:

  • los ocho tipos primitivos ([byte], [short], [int], [long], [float], [double], [char], [boolean]): una variable de un tipo primitivo contiene el valor mismo;
  • los tipos de referencia: clases (incluida [String]), interfaces, arreglos, registros, etc. Una variable de un tipo de referencia contiene una referencia a un objeto, como [null].

El programa [Classes14.java] ilustra la diferencia:

// tipos primitivos y tipos referencia: copia de valor, copia de referencia
void main() {
    // dos variables de tipo primitivo
    int age1 = 10;
    int age2 = age1;
    IO.println("age1=" + age1 + ", age2=" + age2);
    // age2 se modifica
    age2 = 30;
    // verificación de age1 y age2
    IO.println("age1=" + age1 + ", age2=" + age2);

    // un objeto op1
    CPerson op1 = new CPerson();
    op1.name = "paul";
    op1.age = 10;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    // un objeto op2
    CPerson op2 = op1;
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");
    // op2 se modifica
    op2.name = "nicole";
    op2.age = 30;
    // verificación de op1 y op2
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");

    // una copia explícita del objeto
    CPerson op3 = new CPerson();
    op3.name = op1.name;
    op3.age = op1.age;
    op3.age = 50;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op3=CPerson(" + op3.name + "," + op3.age + ")");
}

// clase CPerson
class CPerson {
    String name = "";
    int age;
}
  • Líneas 37–40: una clase con dos campos accesibles desde el paquete: [name], [age]. Los campos no privados —que en general se desaconsejan— facilitan aquí la lectura del ejemplo.

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes14.java
age1=10, age2=10
age1=10, age2=30
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)
op1=CPerson(nicole,30)
op3=CPerson(nicole,50)

La declaración [int age1 = 10;] (línea 4) reserva una ubicación de memoria que contiene el entero 10: el valor de [age1] es el entero mismo. En el caso de la clase, el objeto ([name], [age]) se crea explícitamente mediante el operador [new] (línea 13). El objeto se coloca en un área de memoria administrada por el recolector de basura, el heap, y el valor de [op1] es la dirección (la referencia) de este objeto.

Cuando se escribe [int age2 = age1;] en el programa (línea 5), el valor de [age1] —el entero 10— se copia en [age2]: es una copia de valor. Modificar [age2] no modifica [age1] (línea 3 de los resultados). Consideremos ahora la instrucción [CPerson op2 = op1;] (línea 18). El valor de [op1] se copia en [op2], pero como este valor es la dirección del objeto, el objeto en sí no se duplica: [op1] y [op2] hacen referencia al mismo objeto. Si se modifica el objeto al que apunta [op2], también se modifica el objeto al que apunta [op1] , ya que son el mismo (líneas 6–7 de los resultados). Para obtener un segundo objeto, hay que crearlo y copiar en él los campos del primero (líneas 28–30): modificar la copia no modifica el original (líneas 8–9 de los resultados).

Image

De estas explicaciones podemos concluir que:

  • el valor de una variable de un tipo primitivo es el dato mismo;
  • el valor de una variable de tipo de referencia es la dirección del objeto al que apunta;
  • la asignación y el paso de parámetros siempre copian el valor de la variable: el dato mismo en el caso de un tipo primitivo, la referencia en el caso de un objeto.

Cada tipo primitivo corresponde a una clase denominada “envoltorio” (wrapper) en el paquete [java.lang]: [Integer] para [int], [Double] para [double], [Boolean] para [boolean], y así sucesivamente. El compilador convierte automáticamente un valor primitivo en un objeto envoltorio y viceversa (“autoboxing” y “unboxing”): lo necesitaremos con los genéricos, que solo aceptan tipos de referencia. Una variable [Integer] puede ser igual a [null], pero una variable [int] nunca puede serlo.

Para representar un pequeño dato compuesto (un punto, un color, una fecha, un monto) que se trata como un valor, Java usa clases inmutables: sus objetos no pueden modificarse después de creados. Compartir una referencia a un objeto inmutable es seguro: nadie puede modificarlo, y el objeto se comporta entonces como un valor. Dos herramientas completan este sistema: el método *[equals]*, que compara dos objetos según su contenido, y los registros, que declaran una clase inmutable en una sola línea. Este es el tema de los dos apartados siguientes.

4.5.2. Igualdad de dos objetos: equals y hashCode

Como hemos visto, el operador [==] aplicado a dos referencias indica si hacen referencia al mismo objeto, y el método [equals], heredado de [Object], hace lo mismo. Para que dos objetos distintos con el mismo contenido se consideren iguales, una clase debe redefinir el método [equals] y, necesariamente junto con él, el método [hashCode]. El programa [Classes15.java] lo demuestra:

// igualdad de dos objetos: equals y hashCode
void main() {
    Person p1 = new Person("paul", 10);
    Person p2 = new Person("paul", 10);
    Person p3 = new Person("nicole", 30);
    // == compara las referencias, equals compara los valores
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1.equals(p2) : " + p1.equals(p2)
            + ", p1.equals(p3) : " + p1.equals(p3));
    // dos objetos iguales tienen el mismo código hash
    IO.println("p1.hashCode() == p2.hashCode() : " + (p1.hashCode() == p2.hashCode()));
    // un conjunto (Set) no contiene dos objetos iguales
    Set<Person> persons = new HashSet<>();
    persons.add(p1);
    persons.add(p2);
    persons.add(p3);
    IO.println("size of the set: " + persons.size());
    IO.println("the set contains (paul,10): " + persons.contains(new Person("paul", 10)));
}

class Person {
    // campos
    private final String name;
    private final int age;

    // constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // dos personas son iguales si tienen el mismo nombre y la misma edad
    @Override
    public boolean equals(Object o) {
        // ¿mismo objeto?
        if (this == o) {
            return true;
        }
        // ¿es o una Person (y no null)?
        if (!(o instanceof Person other)) {
            return false;
        }
        // comparación de los campos
        return age == other.age && Objects.equals(name, other.name);
    }

    // código hash coherente con equals
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person(" + name + "," + age + ")";
    }
}
  • líneas 32–44: El método [equals] redefine el de la clase [Object]. Su parámetro es de tipo [Object]: una persona puede compararse con cualquier objeto. El método sigue un patrón estándar:
    • líneas 35–37: un objeto es igual a sí mismo;
    • líneas 39–41: la expresión [o instanceof Person other] (Java 16) es verdadera si [o] hace referencia a un objeto de tipo [Person] (o de una clase derivada), y falsa en caso contrario, en particular si [o] es igual a [null]. Cuando es verdadera, la variable [other], de tipo [Person], hace referencia al objeto [o]: pueden usarse sus campos. Este “patrón de tipo” se explica en detalle al final del capítulo;
    • línea 43: se comparan los campos. El método [Objects.equals(a, b)] compara dos objetos con [equals] manejando el caso en que uno de ellos es [null];
  • líneas 47–50: El método [hashCode] devuelve un entero calculado a partir de los mismos campos, en este caso mediante el método [Objects.hash]. La regla es obligatoria: dos objetos que son iguales en el sentido de [equals] deben tener el mismo código hash. Los diccionarios y conjuntos del JDK (próximo capítulo) clasifican los objetos según este código y dejarían de funcionar si no se respetara la regla;
  • líneas 12–17: Un conjunto [HashSet] nunca contiene dos objetos iguales: agregar [p2], que es igual a [p1], no tiene efecto, y la búsqueda de una nueva persona ([paul, 10]) tiene éxito.

Resultados:

1
2
3
4
5
> java Classes15.java
p1 == p2 : false, p1.equals(p2) : true, p1.equals(p3) : false
p1.hashCode() == p2.hashCode() : true
size of the set: 2
the set contains (paul,10): true

Escribir [equals] y [hashCode] a mano es tedioso y propenso a errores; los entornos de desarrollo pueden generarlos. Los registros, en cambio, los proporcionan automáticamente.

4.5.3. Objetos inmutables

El programa [Classes16.java] demuestra dos formas de definir datos inmutables:

// objetos inmutables: una clase inmutable y un record
void main() {
    Point a = new Point(1, 2);
    // a.x = 5;   // rechazado: el campo x es final
    Point b = a.move(3, 4);
    IO.println("a=" + a + ", b=" + b);

    // un record: constructor, accesores, toString, equals y hashCode se generan automáticamente
    Color red = new Color(255, 0, 0);
    Color red2 = new Color(255, 0, 0);
    IO.println("red=" + red + ", r=" + red.r());
    IO.println("red.equals(red2) : " + red.equals(red2) + ", red == red2 : " + (red == red2));
    // una copia modificada, creada con métodos escritos a mano
    Color pink = red.withG(128).withB(128);
    IO.println("red=" + red + ", pink=" + pink);
}

// una clase inmutable: final, campos privados y final, sin setter
final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    // no modificamos el punto: devolvemos uno nuevo
    public Point move(int dx, int dy) {
        return new Point(x + dx, y + dy);
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
}

// un record: una clase inmutable declarada en una línea... o casi
record Color(int r, int g, int b) {
    // métodos que devuelven una copia modificada del record
    public Color withG(int g) {
        return new Color(r, g, b);
    }

    public Color withB(int b) {
        return new Color(r, g, b);
    }
}
  • líneas 19–45: una clase inmutable escrita manualmente. Es final, para que ninguna clase derivada pueda agregarle un estado mutable; sus campos son privados y [final]; no tiene modificadores. Para “mover” un punto, el método [move] devuelve un nuevo punto (líneas 37–39);
  • Línea 48: un registro (Java 16). El encabezado [record Color(int r, int g, int b)] declara una clase final con tres campos privados —[final], conocidos como los componentes del registro—, un constructor de tres parámetros y tres accesores: [r()], [g()], [b()], y los métodos [toString], [equals] y [hashCode], todos los cuales usan los componentes;
  • Líneas 50–56: Se pueden agregar métodos a un registro. Como un registro es inmutable, no puede modificarse: en su lugar, se crea una copia en la que se ha cambiado un componente. Estos métodos se denominan “withers” (del inglés “with”); otros lenguajes ofrecen una expresión para este fin, [with], que no existe en Java 25;
  • línea 11: Un accesor de un componente se nombra como el componente, sin el prefijo [get];
  • línea 12: dos registros con los mismos componentes son iguales en el sentido de [equals], aunque sean distintos;
  • línea 14: los métodos “wither” se encadenan.

Resultados:

1
2
3
4
5
> java Classes16.java
a=(1,2), b=(4,6)
red=Color[r=255, g=0, b=0], r=255
red.equals(red2) : true, red == red2 : false
red=Color[r=255, g=0, b=0], pink=Color[r=255, g=128, b=128]

El método [toString] generado muestra el nombre del registro y sus componentes (línea 3 de los resultados). Observe aquí que un registro es la forma más concisa de declarar un pequeño dato inmutable: este es el tipo que usaremos para los tramos del impuesto en la aplicación de ejemplo de este capítulo. Los registros se tratan en detalle más adelante.

4.6. Interfaces

4.6.1. Un primer ejemplo

Una interfaz es un conjunto de declaraciones de métodos que forma un contrato. Una clase que decide implementar una interfaz se compromete a proporcionar una implementación de todos los métodos abstractos definidos en la interfaz. El compilador verifica esta implementación.

Por ejemplo, esta es la definición (simplificada) de la interfaz [java.util.Iterator<E>] del JDK, que permite recorrer los elementos de una colección: [public interface Iterator<E> { boolean hasNext(); E next(); }]. Los métodos de la interfaz se definen solo mediante sus firmas, seguidas de un punto y coma: no tienen código y son implícitamente públicos y abstractos. Son las clases que implementan la interfaz las que proporcionan el código de sus métodos. Una clase llamada [C] declara que implementa la interfaz mediante la palabra clave [implements]: [public class C implements Iterator<String>], y entonces debe definir los dos métodos públicos [public boolean hasNext() { ... }] y [public String next() { ... }].

Una convención habitual (aunque no universal; el JDK no la sigue) es comenzar el nombre de una interfaz con la letra I. Los ejemplos siguientes forman la carpeta [Statistics]. Consideremos la siguiente interfaz, [IStats.java]:

1
2
3
4
5
6
7
public interface IStats {
    // promedio de una serie de valores
    double average();

    // desviación estándar de la serie
    double standardDeviation();
}

La interfaz [IStats] contiene:

  • un método [average]: para calcular la media de una serie de valores;
  • un método [standardDeviation]: para calcular la desviación estándar.

Observe que en ningún lugar se especifica a qué conjunto de valores se refiere. Podrían ser las notas promedio de una clase, las ventas mensuales promedio de un producto determinado, la temperatura promedio en un lugar dado… Este es el principio de las interfaces: se supone la existencia de métodos en el objeto, pero no la de datos específicos. Los métodos no tienen el prefijo [get]: son cálculos y no accesos a campos, y esta elección permitirá que un registro implemente la interfaz.

Una primera clase que implemente la interfaz [IStats] podría ser una clase que sirva para almacenar las notas de los estudiantes de una clase en una materia determinada. Un estudiante se caracteriza por el siguiente registro [Student], [Student.java]:

1
2
3
// un estudiante
public record Student(String firstName, String lastName) {
}

El estudiante se identifica por su nombre y apellido. El registro mostrado en el apartado anterior lo hace en una sola línea. Una nota se representa mediante el siguiente registro, [Grade], que sigue: [Grade.java]:

1
2
3
4
5
6
7
// la nota de un estudiante
public record Grade(Student student, double value) {
    @Override
    public String toString() {
        return "[" + student.firstName() + "," + student.lastName() + "," + value + "]";
    }
}

La nota se define por el estudiante evaluado y la nota en sí. El registro redefine el método [toString] generado por el compilador para mostrar una nota con la forma [firstName,lastName,value].

Las notas de todos los estudiantes en una materia determinada se agrupan en la siguiente clase [ArrayOfGrades]: [ArrayOfGrades.java]:

import java.util.Arrays;

public class ArrayOfGrades implements IStats {
    // campos
    private final String subject;
    private final Grade[] grades;
    private final double average;
    private final double standardDeviation;

    // constructor
    public ArrayOfGrades(String subject, Grade[] grades) {
        // almacenamiento de los datos
        this.subject = subject;
        this.grades = grades;
        // cálculo del promedio de las notas
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        average = grades.length != 0 ? sum / grades.length : -1;
        // cálculo de la desviación estándar
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - average, 2);
        }
        standardDeviation = grades.length != 0 ? Math.sqrt(squares / grades.length) : -1;
    }

    // getters
    public String getSubject() {
        return subject;
    }

    public Grade[] getGrades() {
        return grades;
    }

    // implementación de los métodos de la interfaz IStats
    @Override
    public double average() {
        return average;
    }

    @Override
    public double standardDeviation() {
        return standardDeviation;
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + Arrays.toString(grades);
    }
}
  • Línea 3: La clase [ArrayOfGrades] implementa la interfaz [IStats]. Por lo tanto, debe implementar los métodos [average] y [standardDeviation]. Estos se implementan en las líneas 39–47. La anotación [@Override] también se usa para implementar un método de una interfaz;
  • líneas 5–8: cuatro campos [final]: la materia para la cual el objeto almacena notas, el arreglo de notas, la media y la desviación estándar de las notas;
  • líneas 11–27: el constructor. Aquí suponemos que las notas pasadas al constructor no cambiarán después. Por lo tanto, usamos el constructor para calcular de inmediato la media y la desviación estándar de estas notas y almacenarlas. Un campo [final], como [average], puede recibir un valor en el constructor (línea 20); no se le puede asignar un valor después. Las expresiones [condition ? value1 : value2] fijan en -1 la media y la desviación estándar de un arreglo vacío. [Math.pow(x, 2)] calcula x², y [Math.sqrt] calcula la raíz cuadrada;
  • líneas 50–53: el método [toString] usa el método estático [Arrays.toString], que devuelve los elementos de un arreglo entre corchetes, separados por comas, cada uno convertido en cadena mediante su método [toString], en este caso, el del registro [Grade].

En la clase anterior, las notas se almacenaban en un arreglo. No era posible agregar una nueva nota después de crear el objeto [ArrayOfGrades]. Ahora proponemos una segunda implementación de la interfaz [IStats], llamada [ListOfGrades], en la que esta vez las notas se almacenan en una lista [List<Grade>], con la posibilidad de agregar notas después de la creación inicial del objeto [ListOfGrades]: [ListOfGrades.java]:

import java.util.List;

public class ListOfGrades implements IStats {
    // campos
    private final String subject;
    private final List<Grade> grades;
    // promedio y desviación estándar almacenados (null: aún no calculados)
    private Double average;
    private Double standardDeviation;

    // constructor
    public ListOfGrades(String subject, List<Grade> grades) {
        this.subject = subject;
        this.grades = grades;
    }

    // getters
    public String getSubject() {
        return subject;
    }

    public List<Grade> getGrades() {
        return grades;
    }

    // agregar una nota
    public void add(Grade grade) {
        grades.add(grade);
        // el promedio y la desviación estándar tendrán que recalcularse
        average = null;
        standardDeviation = null;
    }

    // promedio de las notas: se calcula en la primera solicitud
    @Override
    public double average() {
        if (average == null) {
            average = computeAverage();
        }
        return average;
    }

    // desviación estándar de las notas: se calcula en la primera solicitud
    @Override
    public double standardDeviation() {
        if (standardDeviation == null) {
            standardDeviation = computeStandardDeviation();
        }
        return standardDeviation;
    }

    private double computeAverage() {
        if (grades.isEmpty()) {
            return -1;
        }
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        return sum / grades.size();
    }

    private double computeStandardDeviation() {
        if (grades.isEmpty()) {
            return -1;
        }
        double m = average();
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - m, 2);
        }
        return Math.sqrt(squares / grades.size());
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + grades;
    }
}
  • línea 3: la clase [ListOfGrades] implementa la interfaz [IStats];
  • línea 6: Las notas ahora se almacenan en una lista en lugar de un arreglo;
  • líneas 27–32: Ahora se puede agregar una nota a las ya almacenadas. La media y la desviación estándar ya no se calculan en el constructor sino bajo demanda, dentro de los propios métodos de la interfaz: [average] (líneas 35–41) y [standardDeviation] (líneas 44–50). Una vez calculados, estos valores se almacenan para no recalcularlos en cada solicitud: se dice que se guardan en caché. Agregar una nota invalida la caché;
  • líneas 8–9: la caché. El tipo [Double] es la clase envoltorio del tipo primitivo [double]: a diferencia de una variable [double], una variable [Double] puede tener el valor [null], que aquí significa “aún no calculado”. Los campos no inicializados se fijan en [null] cuando se construye el objeto;
  • líneas 38 y 40: el compilador convierte automáticamente el [double] devuelto por [computeAverage] en el objeto [Double] (“autoboxing”), y el objeto [Double] en [double] para el valor de retorno del método (“unboxing”).

Un programa de prueba podría ser el siguiente [Main.java]:

void main() {
    // algunos estudiantes y sus notas de inglés
    Student[] students = {
        new Student("Paul", "Martin"), new Student("Maxime", "Germain"), new Student("Berthine", "Samin")
    };
    Grade[] grades = { new Grade(students[0], 14), new Grade(students[1], 16), new Grade(students[2], 18) };
    // que se almacenan en un objeto ArrayOfGrades
    ArrayOfGrades english = new ArrayOfGrades("english", grades);
    // visualización del promedio y la desviación estándar
    displayStats(english);
    // las mismas notas en un objeto ListOfGrades
    ListOfGrades french = new ListOfGrades("french", new ArrayList<>(List.of(grades)));
    displayStats(french);
    // agregamos una nota
    french.add(new Grade(new Student("Jérôme", "Jaric"), 10));
    displayStats(french);
    // una variable puede tener una interfaz como tipo
    IStats stats = english;
    IO.println("English average: " + stats.average());
    stats = french;
    IO.println("French average: " + stats.average());
}

// visualización del promedio y la desviación estándar de un objeto que implementa IStats
void displayStats(IStats values) {
    IO.println(values + ", Average=" + values.average() + ", Standard deviation=" + values.standardDeviation());
}
  • líneas 3–5: creación de un arreglo de estudiantes;
  • línea 6: creación de un arreglo de notas;
  • línea 8: un objeto [ArrayOfGrades] cuya media y desviación estándar se muestran en la línea 10;
  • línea 12: un objeto [ListOfGrades], cuya media y desviación estándar se muestran en la línea 13. [List.of(grades)] devuelve una lista de solo lectura con los elementos del arreglo; el constructor de la clase [ArrayList] la convierte en una lista modificable a la que se pueden agregar notas;
  • línea 15: se agrega una nueva nota, seguida de una actualización de la visualización;
  • Líneas 25–27: El método [displayStats] recibe como parámetro un tipo *[IStats] , que es un tipo de interfaz. Esto significa que el parámetro real puede ser cualquier objeto que implemente la interfaz *[IStats] . Al usar un objeto de datos de un tipo de interfaz, solo se usan los métodos de la interfaz que implementa el objeto. Los demás se ignoran. Esta propiedad es similar al polimorfismo tratado para las clases. Si un conjunto de clases Ci que no están relacionadas entre sí por herencia (y que, por lo tanto, no pueden usar el polimorfismo basado en herencia) comparten un conjunto de métodos con la misma firma, puede ser útil agrupar estos métodos en una interfaz I que implementarían todas las clases en cuestión. Las instancias de estas clases Ci pueden entonces usarse como parámetros reales de métodos que aceptan un parámetro formal de tipo I; es decir, métodos que usan solo los métodos de los objetos Ci definidos en la interfaz I, y no los campos y métodos específicos de las diversas clases Ci;
  • líneas 18–21: Una variable puede ser del tipo de una interfaz. Puede entonces hacer referencia a cualquier objeto de una clase que implemente la interfaz. El compilador solo permite el acceso a los métodos de la interfaz (y a los de la clase [Object], como [toString]).

Resultados:

1
2
3
4
5
6
> java Main.java
subject=english, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0], [Jérôme,Jaric,10.0]], Average=14.5, Standard deviation=2.958039891549808
English average: 16.0
French average: 14.5

Concatenar un número ([double]) con una cadena usa el método [Double.toString], que siempre escribe el número con un punto decimal y al menos un decimal (16.0), independientemente de la configuración de idioma de la estación de trabajo. Para una presentación al estilo francés, use [String.format("%.2f", x)], como en el siguiente ejemplo.

Por último, observe que las interfaces pueden implementarse varias veces; es decir, se puede escribir [public class DerivedClass extends BaseClass implements I1, I2, ..., In], donde las Ij son interfaces: una clase hereda de una sola clase, pero puede implementar tantas interfaces como desee. Una interfaz puede a su vez extender una o varias interfaces: [interface I3 extends I1, I2].

4.6.2. Métodos default, estáticos y privados de las interfaces

Desde Java 8, una interfaz puede proporcionar una implementación por defecto para algunos de sus métodos, declarada con la palabra clave [default]. Una clase que implemente la interfaz puede entonces usar esta implementación o proporcionar la suya. Esto permite, en particular, agregar un método a una interfaz ya publicada sin obligar a modificar todas las clases que la implementan: así se han ampliado las colecciones del JDK a lo largo de las sucesivas versiones. Una interfaz también puede contener métodos estáticos (Java 8) y métodos privados (Java 9). El programa [Classes17.java] proporciona un ejemplo:

// métodos de interfaz default (Java 8), static (Java 8) y private (Java 9)
void main() {
    IShape[] shapes = { new Square(2), new Circle(1), IShape.unitSquare() };
    for (IShape shape : shapes) {
        IO.println(shape.description());
    }
    // la clase Square hereda el método default
    Square square = new Square(3);
    IO.println(square.description());
}

interface IShape {
    // método abstracto: debe implementarse
    double area();

    // método con una implementación por defecto
    default String description() {
        return getClass().getSimpleName() + " with area " + format(area());
    }

    // método estático: se llama con el nombre de la interfaz
    static IShape unitSquare() {
        return new Square(1);
    }

    // método privado: solo utilizable por los métodos de la interfaz
    private String format(double value) {
        return String.format("%.2f", value);
    }
}

// Square usa la implementación por defecto de description
// (clase estática porque la interfaz crea cuadrados: véase Classes10)
static class Square implements IShape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

// Circle proporciona su propia implementación de description
class Circle implements IShape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public String description() {
        return String.format("Circle with radius %s and area %.2f", radius, area());
    }
}
  • líneas 12–30: la interfaz [IShape]:
    • línea 14: un método abstracto [area], que debe implementarse;
    • líneas 17–19: un método [description] con una implementación por defecto. Este método puede usar los demás métodos de la interfaz ([area], [format]) y los de [Object] ([getClass]);
    • líneas 22–24: un método estático, que se llama mediante el nombre de la interfaz: [IShape.unitSquare()] (línea 3). Es un método de fábrica estático;
    • líneas 27–29: un método privado, accesible solo para los métodos de la interfaz. [String.format("%.2f", value)] da formato al número con dos decimales, siguiendo las convenciones de la configuración regional del sistema —en este caso, la coma decimal francesa—;
  • líneas 34–45: la clase [Square] implementa solo [area]; usa el método [description] por defecto. Se declara como [static] porque el método estático [unitSquare] de la interfaz crea cuadrados (véase [Classes10.java]);
  • líneas 48–64: La clase [Circle] proporciona su propio método, [description]. El formato [%s] inserta el radio convertido en cadena mediante [Double.toString] (“1.0”), y el formato [%.2f] inserta el área con dos decimales;
  • Línea 9: La clase [Square] hereda el método por defecto igual que cualquier otro método: puede llamarse sobre una variable de tipo [Square].

Resultados:

1
2
3
4
5
> java Classes17.java
Square with area 4,00
Circle with radius 1.0 and area 3,14
Square with area 1,00
Square with area 9,00

Una clase puede implementar dos interfaces, cada una de las cuales proporciona un método por defecto con la misma firma: el compilador exige entonces que la clase redefina el método, aunque sea para llamar a una de las dos versiones mediante [I1.super.method()]. A diferencia de una clase abstracta, una interfaz no tiene estado: no puede declarar campos de instancia, solo constantes ([static final], de forma implícita).

4.7. Clases abstractas

Una clase abstracta es una clase que no puede instanciarse. Hay que crear clases derivadas, que sí pueden instanciarse. Las clases abstractas permiten refactorizar el código de una jerarquía de clases. Examinemos el siguiente ejemplo, que forma la carpeta [Users] [User.java]:

public abstract class User {
    // campos
    private final String login;
    private final String password;
    private final String role;

    // constructor
    @SuppressWarnings("this-escape")
    protected User(String login, String password) throws UnknownUserException {
        // almacenamos la información
        this.login = login;
        this.password = password;
        // identificamos al usuario
        String role = identify();
        // ¿identificado?
        if (role == null) {
            throw new UnknownUserException("[" + login + "," + password + "]");
        }
        this.role = role;
    }

    // toString
    @Override
    public String toString() {
        return "User[" + login + "," + password + "," + role + "]";
    }

    // identificación: devuelve el rol del usuario o null si no se lo reconoce
    protected abstract String identify();
}
  • línea 1: la clase se declara abstracta mediante la palabra clave [abstract];
  • Líneas 9–20: el constructor de la clase [User]. Esta clase almacena información sobre el usuario de una aplicación web. La aplicación tiene varios tipos de usuarios autenticados por un nombre de usuario y una contraseña (líneas 3–4). Estos dos datos se verifican contra un directorio (LDAP) para algunos usuarios, contra una base de datos para otros, etc. El constructor es [protected]: está destinado a los constructores de las clases derivadas;
  • líneas 11–12: se almacena la información de autenticación;
  • línea 14: se verifica mediante un método [identify]. Como el método de identificación no se conoce en este nivel, se declara abstracto (línea 29) con la palabra clave [abstract]. Un método abstracto no tiene cuerpo: las clases derivadas proporcionarán uno. Una clase que tiene un método abstracto debe declararse a su vez abstracta. El método [identify] devuelve una cadena que especifica el rol del usuario (básicamente, lo que está autorizado a hacer), o [null] si el usuario no es reconocido;
  • líneas 16–18: si el usuario no es reconocido, se lanza una excepción. La excepción [UnknownUserException] es una excepción comprobada (véase más adelante): el constructor debe declararla mediante la cláusula [throws UnknownUserException] (línea 9);
  • líneas 23–26: el método [toString], que identifica una instancia de la clase.

Aquí suponemos que el desarrollador quiere controlar la creación de instancias de la clase [User] y de sus clases derivadas, quizá porque desea asegurarse de que se lance una excepción de cierto tipo si el usuario no es reconocido. Las clases derivadas pueden apoyarse en este constructor. Para ello, deben proporcionar el método [identify]. Observe que el constructor llama aquí a un método redefinido por las clases derivadas, aunque estas aún no hayan ejecutado sus propios constructores: por lo tanto, el método [identify] no debe usar ningún campo de la clase derivada, ya que aún no han sido inicializados. Es una práctica que debe usarse con precaución, y el compilador la señala al compilar con la opción [-Xlint:all], que habilita todas las advertencias (aquí sin la anotación de la línea 8, de ahí el número de línea 13 en el mensaje):

1
2
3
4
5
> javac -Xlint:all -d classes *.java
User.java:13: warning: [this-escape] possible 'this' escape before subclass is fully initialized
        String role = identify();
                              ^
1 warning

La advertencia [this-escape] (Java 21) indica que el objeto en construcción ([this]) “se escapa” del constructor antes de estar completamente inicializado. En este caso, es intencional e inofensivo, ya que los métodos [identify] de las clases derivadas no usan ningún campo. Tras verificarlo, la advertencia se suprime —solo para este constructor— mediante la anotación [@SuppressWarnings("this-escape")] (línea 8). El lanzador de código fuente ([java Main.java]) no habilita estas advertencias: es una buena idea compilar los programas regularmente con [javac -Xlint:all], que es lo que hemos hecho con todos los programas de este curso.

La clase [UnknownUserException] es la siguiente:

1
2
3
4
5
6
7
8
public class UnknownUserException extends Exception {
    // número de versión de la clase (véanse las explicaciones)
    private static final long serialVersionUID = 1L;

    public UnknownUserException(String message) {
        super(message);
    }
}
  • Línea 1: Deriva de la clase [Exception]. Por lo tanto, es una excepción comprobada: el compilador verifica que todo método que pueda lanzarla la declare mediante una cláusula [throws], y que todo código que llame a dicho método la capture o la declare a su vez. Una excepción derivada de [RuntimeException], como [IllegalArgumentException], no es una excepción comprobada;
  • línea 3: Las excepciones son objetos “serializables” (convertibles en una secuencia de bytes); el compilador, con la opción [-Xlint:all], exige que una clase serializable declare un número de versión [serialVersionUID]. Simplemente usamos el valor 1;
  • Líneas 5–7: Tiene un único constructor que recibe como parámetro un mensaje de error. Este se pasa a la clase padre, que tiene el mismo constructor.

Ahora derivamos la clase hija [Administrator] de la clase [User]:

public class Administrator extends User {
    // constructor
    public Administrator(String login, String password) throws UnknownUserException {
        super(login, password);
    }

    // identificación
    @Override
    protected String identify() {
        // identificación LDAP
        // ...
        return "admin";
    }
}
  • líneas 3–5: El constructor simplemente pasa a su clase padre los parámetros que recibe. También declara la excepción que el constructor padre puede lanzar;
  • líneas 8–13: el método [identify] de la clase [Administrator]. Suponemos que un administrador se identifica mediante un directorio LDAP. Este método implementa el método abstracto [identify] de su clase padre. Conserva el nivel de acceso [protected] del método que redefine (un método redefinido puede ampliar el acceso, pero no restringirlo).

Las clases [Observer] y [Unknown] también derivan de la clase [User]. Se diferencian de la clase [Administrator] solo en su método [identify]. El método de la clase [Observer] supone que un observador se identifica mediante una base de datos y devuelve el rol “observer”:

1
2
3
4
5
6
7
    // identificación
    @Override
    protected String identify() {
        // identificación mediante una base de datos
        // ...
        return "observer";
    }

El método de la clase [Unknown] devuelve la referencia [null] para indicar que el usuario no fue reconocido:

1
2
3
4
5
6
7
    // identificación
    @Override
    protected String identify() {
        // usuario desconocido
        // ...
        return null;
    }

En definitiva, los objetos [Administrator], [Observer], y [Unknown] se inicializan con el mismo constructor: el de la clase padre [User]. Este constructor usa el método [identify] proporcionado por estas clases. Un programa de prueba para [Main.java] podría ser el siguiente:

void main() {
    try {
        IO.println(new Observer("observer", "pwd1"));
        IO.println(new Administrator("admin", "pwd2"));
        IO.println(new Unknown("xx", "yy"));
    } catch (UnknownUserException e) {
        IO.println("Unknown user: " + e.getMessage());
    }
    // User u = new User("x", "y");   // rechazado: la clase User es abstracta
}

Observe que en las líneas 3 y 4, el método [User.toString()] es usado por el método *[println]. En la línea 5, el constructor lanza una excepción [UnknownUserException], que se captura en la línea 6: el objeto no se crea y [println] no muestra nada. Las tres creaciones de objetos se colocan dentro de un bloque [try], porque el compilador exige que se capture la excepción comprobada. La línea 9, si se le quita el comentario, es rechazada por el compilador ([User is abstract; cannot be instantiated]*): no se puede crear un objeto de una clase abstracta.

Resultados:

1
2
3
4
> java Main.java
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

Una clase abstracta se parece a una interfaz: ambas declaran métodos que otras clases deben implementar. Sin embargo, una clase abstracta puede tener campos, constructores y código común a sus clases derivadas; en cambio, una clase puede derivar de una sola clase abstracta, mientras que puede implementar varias interfaces. Con frecuencia se combinan: una interfaz define el contrato y una clase abstracta que la implementa factoriza el código común a varias implementaciones. Esto es lo que hará la aplicación de ejemplo de este capítulo.

4.8. Clases, interfaces y métodos genéricos

4.8.1. Clases y métodos genéricos

Supongamos que queremos escribir una clase [IntPair] que almacene dos enteros y pueda intercambiarlos: dos campos, [int first] y [int second], y un método, [swap()], que intercambie sus valores mediante una variable temporal, [int temp]. Si luego quisiéramos un par de cadenas, y después un par de personas, escribiríamos dos clases más, [StringPair] y [PersonPair], idénticas a la anterior salvo por el tipo: [String] o [Person] en lugar de [int].

Las clases, interfaces y métodos genéricos responden a la necesidad de código que difiere solo en el tipo de ciertos datos. Se introdujeron con Java 5 (2004): antes se usaba el tipo [Object], que aceptaba cualquier cosa, al costo de conversiones de tipo explícitas y de errores detectados solo en tiempo de ejecución. Observe que Java no admite el paso de parámetros por referencia: un método no puede intercambiar los valores de dos variables del llamador, pero sí puede intercambiar dos elementos de un objeto, un par o un arreglo.

El programa [Classes18.java] presenta una clase genérica, un método genérico y una segunda clase genérica:

// clases y métodos genéricos
void main() {
    // - una clase genérica Pair<T>
    // Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    pi.swap();
    IO.println("pi=" + pi);
    // String
    Pair<String> ps = new Pair<>("s1", "s2");
    ps.swap();
    IO.println("ps=" + ps);
    // Person
    Person p1 = new Person("jean", "clu", 20), p2 = new Person("pauline", "dard", 55);
    Pair<Person> pp = new Pair<>(p1, p2);
    pp.swap();
    IO.println("pp=" + pp);
    // el primer elemento es de tipo Person: sin conversión
    Person first = pp.getFirst();
    IO.println("first element: " + first);

    // - un método genérico Generic2.swap<T>
    Integer[] integers = { 1, 2, 3 };
    Generic2.<Integer>swap(integers, 0, 2);
    IO.println("integers=" + Arrays.toString(integers));
    // el compilador deduce T a partir del tipo de los parámetros reales
    Person[] persons = { p1, p2 };
    Generic2.swap(persons, 0, 1);
    IO.println("persons=" + Arrays.toString(persons));

    // - una clase genérica con estado: una pila de elementos de tipo T
    MyStack<Person> stack = new MyStack<>();
    stack.push(p1);
    stack.push(p2);
    IO.println("The stack contains " + stack.size() + " persons");
    Person top = stack.pop();
    IO.println("Popped person: " + top + ", " + stack.size() + " left");
    // stack.push("x");   // rechazado: la pila solo acepta objetos Person
}

// una clase genérica: un par de dos elementos de tipo T
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    // los dos elementos se intercambian
    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// una clase no genérica con un método genérico
class Generic2 {
    // intercambia los elementos n.º i y j de un arreglo de elementos de tipo T
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

// una pila de elementos de tipo T
class MyStack<T> {
    // los elementos de la pila
    private final List<T> elements = new ArrayList<>();

    // número de elementos
    public int size() {
        return elements.size();
    }

    // agregar un elemento en la cima de la pila
    public void push(T element) {
        elements.add(element);
    }

    // quitar el elemento de la cima de la pila
    public T pop() {
        if (elements.isEmpty()) {
            throw new IllegalStateException("empty stack");
        }
        return elements.removeLast();
    }
}

// una persona
record Person(String firstName, String lastName, int age) {
    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • líneas 41–69: La clase [Pair] está parametrizada por un tipo denotado *[T], entre corchetes angulares después del nombre de la clase. Se puede nombrar como se quiera; por convención, es una letra mayúscula ([T] para tipo, [E] para elemento, [K] y [V] para clave y valor). Este tipo, [T], se usa luego en la clase igual que cualquier otro tipo: para los dos campos, los parámetros del constructor, los resultados de los accesores y la variable temporal [temp]* (línea 60). Se dice que la clase [Pair] es una clase genérica;
  • Línea 5: Al usar una clase genérica parametrizada por los tipos T1, T2, …, estos tipos deben especificarse. Aquí, [Pair<Integer>] es un par de objetos [Integer]. Un parámetro genérico solo puede ser un tipo de referencia: escribimos [Pair<Integer>], no [Pair<int>]. Los enteros 1 y 2 se convierten automáticamente en objetos [Integer] (“autoboxing”). A la derecha, el operador “diamante” [new Pair<>(...)] permite que el compilador infiera el tipo [Integer] a partir del de la variable. Líneas 9 y 14: lo mismo se aplica a los tipos [String] y [Person];
  • Línea 18: El método [getFirst] de un [Pair<Person>] devuelve un objeto de tipo [Person], sin conversión;
  • líneas 72–79: la clase [Generic2] no es genérica, pero su método estático [swap] sí lo es: el parámetro de tipo [<T>] se declara antes del tipo de retorno (línea 74). El método intercambia los elementos i y j de un arreglo de elementos de tipo [T];
  • línea 23: se llama al método [swap] especificando el tipo *[T] entre ***[<>]. En realidad, el compilador es capaz de inferir [T] a partir del tipo de los parámetros reales. Por lo tanto, la notación de la línea 27 es válida, y es la que se usa en la práctica;
  • líneas 82–103: una clase genérica con estado: una pila de elementos de tipo [T]. Los elementos se apilan en la cima de la pila y se desapilan desde la cima. Los elementos se almacenan en una lista genérica de tipo [List<T>] (línea 84), que a su vez está parametrizada por el tipo [T] de la pila. El método [removeLast] (Java 21) extrae y devuelve el último elemento de la lista. Una pila vacía lanza una excepción [IllegalStateException], la excepción definida por Java para una operación solicitada a un objeto que no está en el estado esperado;
  • línea 31: una pila de personas. El compilador garantiza que solo contendrá personas: la instrucción de la línea 37 sería rechazada. El método [pop] devuelve un objeto de tipo [Person], sin conversión;
  • líneas 106–111: la persona es un record cuyo método [toString] ha sido redefinido.

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes18.java
pi=(2,1)
ps=(s2,s1)
pp=([pauline, dard, 55],[jean, clu, 20])
first element: [pauline, dard, 55]
integers=[3, 2, 1]
persons=[[pauline, dard, 55], [jean, clu, 20]]
The stack contains 2 persons
Popped person: [pauline, dard, 55], 1 left

4.8.2. Restricciones de los parámetros genéricos

En la clase [Pair<T>] el compilador no sabe nada del tipo [T]: solo permite invocar los métodos de la clase [Object] sobre objetos de tipo [T]. Para poder usar otros métodos, restringimos el parámetro genérico con la palabra clave [extends]:

Restricción
Significado
[<T extends BaseClass>]
T debe ser la clase indicada o una clase derivada
[<T extends Interface>]
T debe implementar la interfaz indicada (se escribe con [extends], no con [implements])
[<T extends BaseClass & I1 & I2>]
Varias restricciones: como máximo una clase, indicada primero, seguida de interfaces
[<T extends Comparable<T>>]
Una restricción que usa el propio T: T debe ser comparable con T

No existe ninguna restricción que exija que T sea un tipo de referencia (siempre lo es) ni que tenga un constructor sin parámetros: no se puede escribir [new T()] en una clase genérica (véase el borrado de tipos más adelante). El programa [Classes19.java] usa una restricción:

// los límites de los parámetros genéricos
void main() {
    // - T siempre es un tipo objeto: int se reemplaza por Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    // Pair<int> pe = new Pair<>(1, 2);   // error: int es un tipo primitivo
    IO.println("pi=" + pi);

    // - el límite T extends IValue
    // ordenamiento de pares de objetos de tipo RandomValue
    for (int i = 0; i < 5; i++) {
        Pair<RandomValue> pair = new Pair<>(new RandomValue(), new RandomValue());
        IO.print("Before --> " + pair);
        Generic4.order(pair);
        IO.println("   After --> " + pair);
    }
    // ordenamiento de un par de objetos de tipo StringValue
    Pair<StringValue> strings = new Pair<>(new StringValue("xxxxxxxxxxxxxx"), new StringValue("xx"));
    IO.println("Before --> " + strings);
    Generic4.order(strings);
    IO.println("After --> " + strings);
    // Generic4.order(pi);   // error: Integer no implementa IValue
}

// un par de dos elementos de tipo T
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// el tipo T debe implementar IValue
class Generic4 {
    public static <T extends IValue> void order(Pair<T> pair) {
        // si el 1.er elemento es mayor que el 2.º, los elementos se intercambian
        if (pair.getFirst().value() > pair.getSecond().value()) {
            pair.swap();
        }
    }
}

// un objeto que tiene un valor entero
interface IValue {
    int value();
}

// un objeto que tiene un valor aleatorio
class RandomValue implements IValue {
    // generador de números aleatorios compartido por todas las instancias
    // (inicializado con una semilla fija para que los resultados sean reproducibles)
    private static final Random generator = new Random(2026);
    // valor del objeto
    private final int value = generator.nextInt(100);

    @Override
    public int value() {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

// un objeto cuyo valor es la longitud de una cadena
class StringValue implements IValue {
    private final String s;

    public StringValue(String s) {
        this.s = s;
    }

    @Override
    public int value() {
        return s.length();
    }

    @Override
    public String toString() {
        return s;
    }
}
  • línea 5: si se quita el comentario de esta línea, el compilador informa un error porque el tipo *[int]* es un tipo primitivo;
  • Líneas 55–62: el método genérico [order] exige que el tipo [T] implemente la interfaz [IValue] (líneas 65–67). Esta interfaz tiene un método llamado [value], usado en la línea 58, que devuelve el valor del objeto de tipo [T]. Sin la restricción, el compilador rechazaría la llamada a [pair.getFirst().value()]: un tipo [T] cualquiera no tiene un método [value]. Los dos elementos del par se intercambian solo si el valor del primero es mayor que el del segundo: el método [order] ordena los dos elementos en orden ascendente según su valor;
  • líneas 70–86: la clase [RandomValue] implementa la interfaz [IValue]. El valor de una instancia es un número aleatorio entre 0 y 99 (línea 75), proporcionado por un generador de números aleatorios de la clase [Random] compartido por todas las instancias (línea 73). Este generador se inicializa con una “semilla” fija: por lo tanto, siempre produce la misma secuencia de números, lo que hace los resultados reproducibles. Si no se requiere reproducibilidad, se usa el generador creado por [new Random()]; para fines de seguridad, se usa en su lugar la clase [SecureRandom];
  • líneas 89–105: la clase [StringValue] también implementa la interfaz [IValue]: el valor de una instancia es la longitud de la cadena de caracteres pasada al constructor;
  • líneas 10–15: se ordenan pares de objetos de tipo [RandomValue] ;
  • líneas 17–20: se ordena un par de objetos de tipo [StringValue] ;
  • línea 21: si se quita el comentario de esta línea, el compilador informa que el tipo [Integer] no cumple la restricción.

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes19.java
pi=(1,2)
Before --> (99,50)   After --> (50,99)
Before --> (97,30)   After --> (30,97)
Before --> (49,38)   After --> (38,49)
Before --> (73,36)   After --> (36,73)
Before --> (34,78)   After --> (34,78)
Before --> (xxxxxxxxxxxxxx,xx)
After --> (xx,xxxxxxxxxxxxxx)

Estos son los errores obtenidos al ejecutar el programa después de quitar el comentario de las líneas 5 y 21:

> java Classes19.java
Classes19.java:5: error: unexpected type
    Pair<int> pe = new Pair<>(1, 2);   // error: int is a primitive type
         ^
  required: reference
  found:    int
Classes19.java:21: error: method order in class Classes19.Generic4 cannot be applied to given types;
    Generic4.order(pi);   // error: Integer does not implement IValue
            ^
  required: Classes19.Pair<T>
  found:    Classes19.Pair<Integer>
  reason: inference variable T has incompatible bounds
    equality constraints: Integer
    upper bounds: IValue
  where T is a type-variable:
    T extends IValue declared in method <T>order(Classes19.Pair<T>)
2 errors
error: compilation failed

El segundo mensaje es típico de los errores relacionados con genéricos: el compilador intentó inferir el tipo [T]; la restricción del par exige que [T] = [Integer] (“restricciones de igualdad”), la restricción del límite exige que [T] implemente [IValue] (“límites superiores”); las dos restricciones son incompatibles.

4.8.3. Interfaces genéricas: Comparable<T> y Comparator<T>

Para ilustrar el concepto de interfaz genérica, ordenaremos un arreglo de personas según distintos criterios. El método que permite ordenar un arreglo es el método estático [sort] de la clase [java.util.Arrays]. Está sobrecargado; usaremos dos variantes:

  • [Arrays.sort(Object[] array)] ordena el arreglo según el orden natural de sus elementos: estos elementos deben implementar la interfaz [Comparable<T>], cuyo único método, [int compareTo(T other)], compara el objeto actual con el objeto [other];
  • [Arrays.sort(T[] array, Comparator<? super T> comparator)] ordena el arreglo según el orden definido por un objeto comparador, que implementa la interfaz [Comparator<T>], cuyo método [int compare(T x, T y)] compara dos objetos (el tipo [? super T] se explica en el párrafo siguiente).

Los métodos [compareTo] y [compare] siguen la misma regla: devuelven un número positivo si x > y, 0 si x == y, y un número negativo si x < y. Corresponde al desarrollador definir el significado de los operadores <, == y >. Por ejemplo, si [p1] y [p2] son dos objetos [Person], podemos decir que p1 > p2 si el nombre de [p1] va después del nombre de [p2] en orden alfabético. Esto producirá un ordenamiento ascendente según los nombres de las personas. Si queremos ordenar por edad, diremos que p1 > p2 si la edad de [p1] es mayor que la edad de [p2]. Para ordenar en orden descendente, basta con invertir los signos de los resultados.

Ya sabemos lo suficiente para ordenar un arreglo de personas. El programa [Classes20.java] es el siguiente:

// las interfaces genéricas Comparable<T> y Comparator<T>: ordenamiento de un arreglo de personas
void main() {
    Person[] persons = {
        new Person("claude", "pollon", 25),
        new Person("valentine", "germain", 35),
        new Person("paul", "germain", 32),
    };
    // visualización
    display("Array to sort", persons);
    // ordenamiento según el orden natural de las personas (Comparable): la edad
    Arrays.sort(persons);
    display("Array after sorting by age", persons);
    // ordenamiento por apellido y nombre (Comparator)
    Arrays.sort(persons, new CompareNames());
    display("Array after sorting by last and first names", persons);
    // ordenamiento por edad descendente, con una clase anónima
    Arrays.sort(persons, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            return Integer.compare(p2.getAge(), p1.getAge());
        }
    });
    display("Array after sorting by descending age", persons);
}

// visualización de un arreglo de personas
void display(String text, Person[] persons) {
    IO.println(text + "-".repeat(50 - text.length()));
    for (Person p : persons) {
        IO.println(p);
    }
}

// una persona, comparable con otra persona
class Person implements Comparable<Person> {
    private final String firstName;
    private final String lastName;
    private final int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // el orden natural de las personas: el orden de las edades
    @Override
    public int compareTo(Person other) {
        return Integer.compare(age, other.age);
    }

    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}

// comparación del apellido y el nombre de dos personas
class CompareNames implements Comparator<Person> {
    // comparación de cadenas según las reglas del idioma francés
    private final Collator collator = Collator.getInstance(Locale.FRENCH);

    @Override
    public int compare(Person p1, Person p2) {
        // comparamos los apellidos
        int i = collator.compare(p1.getLastName(), p2.getLastName());
        if (i != 0) {
            return i;
        }
        // apellidos iguales: comparamos los nombres
        return collator.compare(p1.getFirstName(), p2.getFirstName());
    }
}
  • líneas 3–7: el arreglo de personas;
  • líneas 35–68: la clase [Person] implementa la interfaz genérica [Comparable<Person>]: sus objetos son comparables con otras personas. Su método [compareTo] (líneas 59–62) define el orden natural de las personas, en este caso por edad. El método estático [Integer.compare(a, b)] devuelve un número negativo, cero o positivo según [a] sea menor, igual o mayor que [b]: esto es exactamente lo que espera el método [compareTo];
  • línea 11: ordenamiento en orden natural;
  • línea 14: ordena el arreglo de personas por apellido y nombre. El segundo parámetro del método [sort] es una instancia de la clase [CompareNames], que implementa la interfaz genérica [Comparator<Person>];
  • líneas 71–85: la clase [CompareNames]. Su método [compare] implementa el método [int compare(T x, T y)] de la interfaz [Comparator<T>], donde [T] = [Person]. Las cadenas no se comparan con su método [compareTo], que sigue el orden de los códigos de caracteres (las mayúsculas antes que las minúsculas, las letras con tilde después de la “z”), sino con un objeto [Collator] (línea 73) que aplica las reglas de ordenamiento del idioma francés;
  • líneas 17–22: ordenamiento por edad en orden descendente. Esta vez el comparador es una instancia de una clase anónima: la expresión [new Comparator<Person>() { ... }] declara una clase sin nombre que implementa la interfaz [Comparator<Person>] y crea de inmediato una instancia de esa clase. El cuerpo de la clase (líneas 18–21) proporciona el método [compare]. Una clase anónima evita tener que declarar una clase que se usa una sola vez;
  • línea 28: el método [repeat] (Java 11) rellena una cadena: la línea del título se rellena con guiones hasta 50 caracteres.

Resultados:

> java Classes20.java
Array to sort-------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
Array after sorting by age------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
Array after sorting by last and first names-------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
Array after sorting by descending age-------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]

Ya hemos visto tres tipos de clases declaradas dentro de otra: las clases anidadas estáticas ([static class]), las clases internas (sin [static], que están asociadas a un objeto de la clase envolvente) y las clases anónimas. En el capítulo 7 veremos que, para una interfaz con un solo método abstracto, como [Comparator], se puede usar una alternativa aún más corta que una clase anónima: una lambda, [Arrays.sort(persons, (p1, p2) -> Integer.compare(p2.getAge(), p1.getAge()));], o una referencia a un método, [Arrays.sort(persons, Comparator.comparing(Person::getLastName));].

4.8.4. Comodines y borrado de tipos

Una [List<Integer>] no es una [List<Number>], aunque [Integer] derive de [Number]: si lo fuera, podríamos agregar un [Double] a una lista de enteros mediante una variable de tipo [List<Number>]. Un método que acepta una [List<Number>] rechaza, por lo tanto, una [List<Integer>]. Para escribir métodos que acepten listas de elementos de tipos relacionados, Java utiliza comodines:

Tipo
Significado
Uso
[List<? extends Number>]
una lista de elementos de un tipo desconocido derivado de [Number]
Se pueden leer [Number] de ella, pero no se pueden agregar elementos
[List<? super Integer>]
Una lista de elementos de un tipo desconocido del cual deriva [Integer] ([Integer], [Number], [Object])
[Integer] se pueden agregar a esta lista
[List<?>]
una lista de elementos de un tipo desconocido
Se pueden leer [Object]

El programa [Classes21.java] ilustra los comodines y una particularidad de los genéricos de Java: el borrado de tipos:

// comodines, límites y borrado de tipos
void main() {
    List<Integer> integers = List.of(1, 2, 3);
    List<Double> reals = List.of(1.5, 2.25);
    // ? extends Number: una lista de elementos de un tipo derivado de Number
    IO.println("Sum of integers: " + sum(integers));
    IO.println("Sum of reals: " + sum(reals));
    // ? super Integer: una lista que puede recibir Integers
    List<Number> numbers = new ArrayList<>();
    addIntegers(numbers, 3);
    numbers.add(2.5);
    IO.println("numbers=" + numbers + ", sum=" + sum(numbers));
    // un límite recursivo: T debe ser comparable consigo mismo
    IO.println("max : " + max(List.of("paul", "jean", "valentine")) + ", " + max(integers));
    // borrado de tipos: en tiempo de ejecución, una lista es una lista
    List<String> l1 = new ArrayList<>();
    List<Integer> l2 = new ArrayList<>();
    IO.println("same class: " + (l1.getClass() == l2.getClass()) + " (" + l1.getClass().getName() + ")");
}

// suma de los elementos de una lista de números
double sum(List<? extends Number> values) {
    double sum = 0;
    for (Number value : values) {
        sum += value.doubleValue();
    }
    // values.add(1);   // rechazado: se desconoce el tipo exacto de los elementos
    return sum;
}

// agregar los enteros 1, 2, ..., n a una lista capaz de recibir Integers
void addIntegers(List<? super Integer> list, int n) {
    for (int i = 1; i <= n; i++) {
        list.add(i);
    }
}

// el mayor elemento de una lista no vacía
<T extends Comparable<? super T>> T max(List<T> elements) {
    T max = elements.getFirst();
    for (T element : elements) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}
  • Líneas 22–29: el método [sum] acepta una lista de elementos de cualquier tipo derivado de [Number]: [Integer], [Double], [BigDecimal]… Trata los elementos como [Number] y usa su método [doubleValue]. Java no admite la aritmética genérica: no se puede escribir [a + b] para dos objetos de tipo [T], de ahí la necesidad de usar [double]. Se rechaza agregar un elemento a la lista (línea 27): el compilador no sabe si es una lista de [Integer] o de [Double];
  • líneas 6–7: el mismo método concatena una lista de [Integer] con una lista de [Double]. [List.of(...)] crea una lista de solo lectura;
  • líneas 32–36: el método [addIntegers] acepta cualquier lista capaz de contener entradas [Integer], en este caso una [List<Number>] (línea 10). Seguimos la regla “productor: [extends], consumidor: [super]”: una lista cuyos elementos se leen se escribe con [extends], y una lista que se llena se escribe con [super];
  • Líneas 39–47: el método genérico *[max] devuelve el mayor elemento de una lista. La restricción [T extends Comparable<? super T>] exige que los elementos sean comparables entre sí; se aplica tanto a cadenas como a enteros (línea 14). El método [getFirst]* (Java 21) devuelve el primer elemento de la lista;
  • líneas 16–18: en tiempo de ejecución, una ***[List<String>] y una ***[List<Integer>] son dos objetos de la misma clase, *[ArrayList]*. El compilador verifica los tipos genéricos y luego los borra: el código compilado solo conoce [ArrayList] y [Object], y se insertan conversiones donde es necesario. Este “borrado de tipos”, adoptado en 2004 para garantizar que el código genérico siga siendo compatible con el código existente, explica varias limitaciones: no se puede escribir [new T()] ni [new T[10]], ni probar [o instanceof List<String>], ni usar un tipo primitivo como parámetro genérico.

Resultados:

1
2
3
4
5
6
> java Classes21.java
Sum of integers: 6.0
Sum of reals: 3.75
numbers=[1, 2, 3, 2.5], sum=8.5
max : valentine, 3
same class: true (java.util.ArrayList)

A diferencia de otros lenguajes como C#, en los que las interfaces pueden declarar miembros estáticos abstractos para implementar cálculos genéricos, Java no permite exigir que un tipo como [T] tenga un método estático: los métodos estáticos de una interfaz se invocan con el nombre de la interfaz y no son heredados por las clases que la implementan.

4.9. Paquetes

Para escribir una línea en la pantalla, usamos la instrucción [IO.println(...)]. Si consultamos la definición de la clase [IO] en la documentación del JDK, vemos que forma parte del paquete [java.lang]. Esto significa que su nombre completo es [java.lang.IO] y que podríamos escribir [java.lang.IO.println(...)]. Las clases del paquete [java.lang] ([String], [Object], [Math], [Integer]…) siempre se designan por su nombre simple. Para las demás, se usa una cláusula [import] colocada al comienzo del archivo:

  • [import java.util.List;] importa la clase [List] del paquete [java.util];
  • [import java.util.*;] importa bajo demanda todas las clases públicas del paquete [java.util];
  • [import module java.base;] (Java 25) importa todas las clases públicas de los paquetes exportados por el módulo [java.base] (véase más adelante). Esto es lo que hace implícitamente un archivo compacto;
  • [import static java.lang.Math.sqrt;] importa un miembro estático de una clase, que luego se puede usar sin especificar el nombre de la clase: [sqrt(2)].

Cuando el compilador encuentra el nombre corto de una clase, lo busca en el paquete actual y entre las clases importadas. Una cláusula [import] no agrega nada al programa: solo evita tener que escribir los nombres completos.

Al crear una clase, se la coloca en un paquete. El propósito de los paquetes es evitar conflictos de nombres entre clases, por ejemplo, cuando se distribuyen. Consideremos dos empresas, E1 y E2, que distribuyen clases empaquetadas en los archivos [e1.jar] y [e2.jar], respectivamente. Supongamos que un cliente C compra estos dos conjuntos de clases, en los que ambas empresas han definido una clase llamada [Person]. Si la empresa E1 crea sus clases en un paquete llamado [e1] y la empresa E2 crea las suyas en un paquete llamado [e2], las dos clases [Person] se llamarán entonces [e1.Person] y [e2.Person]. El cliente puede importar una de ellas y referirse a la otra por su nombre completo. El paquete resuelve esta ambigüedad. Por convención, los nombres de los paquetes se escriben en minúsculas y comienzan con el nombre de dominio invertido de la organización que los publica ([com.mysql.cj.jdbc], [org.hibernate]…); para nuestros ejemplos usaremos nombres cortos.

Para colocar una clase en un paquete, se escribe la declaración [package name;] al comienzo de su archivo. A diferencia de otros lenguajes, Java exige una correspondencia uno a uno entre paquetes y directorios: los archivos fuente del paquete [e1] se almacenan en una carpeta llamada [e1], y los del paquete [tax.dao] se almacenan en una carpeta llamada [tax/dao], a partir de la raíz del directorio de código fuente. La carpeta [Namespaces] ilustra estos conceptos:

1
2
3
4
5
6
Namespaces/
  Main.java             the main program (unnamed package)
  e1/
    Person.java         the class e1.Person
  e2/
    Person.java         the class e2.Person

La primera clase, [Person] [e1/Person.java]:

// las clases de este archivo pertenecen al paquete e1
package e1;

public class Person {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "e1.Person[" + firstName + ", " + lastName + "]";
    }
}

La segunda: [e2/Person.java]:

// las clases de este archivo pertenecen al paquete e2
package e2;

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "e2.Person[" + name + "]";
    }
}

Ambas clases son públicas: una clase sin la palabra clave [public] solo es accesible para las clases de su propio paquete. El programa principal [Main.java] es el siguiente:

// importación de una clase de un paquete
import e1.Person;
// importación estática de un miembro estático de una clase
import static java.lang.Math.sqrt;

void main() {
    // Person designa e1.Person, que fue importada
    Person p1 = new Person("Jean", "Dupont");
    // el nombre completo de una clase elimina cualquier ambigüedad
    e2.Person p2 = new e2.Person("Durand");
    IO.println(p1 + " " + p2);
    // nombre completo y paquete de una clase
    IO.println(Person.class.getName() + ", " + e2.Person.class.getName());
    IO.println("package of the Person class: " + Person.class.getPackageName());
    // el módulo que contiene una clase
    IO.println("e1.Person is in a named module: " + Person.class.getModule().isNamed());
    IO.println(String.class.getName() + " is in the module " + String.class.getModule().getName());
    // StringBuilder se conoce gracias a la importación automática del módulo java.base
    StringBuilder sb = new StringBuilder("abc");
    IO.println(sb.append("def"));
    // sqrt se conoce gracias a la importación estática
    IO.println("sqrt(2)=" + sqrt(2));
}
  • línea 2: importación de la clase [e1.Person];
  • línea 4: importación estática del método [sqrt] de la clase [Math];
  • Línea 8: [Person] se refiere a la clase [e1.Person], que fue importada;
  • Línea 10: el nombre completo de la clase [e2.Person] elimina cualquier ambigüedad. Java no admite alias de tipos: no se puede dar a una clase un nombre diferente;
  • Líneas 13–14: el método [getName] de la descripción de la clase devuelve su nombre completo, precedido por su paquete; [getPackageName] devuelve el nombre del paquete;
  • líneas 16–17: el método [getModule] devuelve el módulo que contiene la clase (véase más adelante);
  • líneas 19–20: la clase [java.lang.StringBuilder] se reconoce sin importación;
  • línea 22: uso de la importación estática.

El lanzador de código fuente encuentra automáticamente las clases en las subcarpetas: el comando [java Main.java], ingresado en la carpeta [Namespaces], compila los archivos [e1/Person.java] y [e2/Person.java] bajo demanda. Resultados:

1
2
3
4
5
6
7
8
> java Main.java
e1.Person[Jean, Dupont] e2.Person[Durand]
e1.Person, e2.Person
package of the Person class: e1
e1.Person is in a named module: false
java.lang.String is in the module java.base
abcdef
sqrt(2)=1.4142135623730951

Si reemplazamos la importación de la línea 2 por las dos importaciones bajo demanda [import e1.*;] y [import e2.*;], el nombre [Person] se vuelve ambiguo y el compilador lo rechaza:

1
2
3
4
5
6
> java Main.java
Main.java:9: error: reference to Person is ambiguous
    Person p1 = new Person("Jean", "Dupont");
    ^
  both class e2.Person in e2 and class e1.Person in e1 match
...

4.9.1. Módulos

A partir de Java 9, los paquetes se agrupan a su vez en módulos (“Java Platform Module System”, JPMS). El JDK está dividido en módulos: [java.base] contiene los paquetes fundamentales ([java.lang], [java.util], [java.math], [java.io]…), [java.sql] proporciona acceso a bases de datos, [java.net.http] es el cliente HTTP, etc. Un módulo declara, en un archivo llamado [module-info.java] ubicado en la raíz de su código fuente, su nombre, los módulos que requiere ([requires java.sql;]) y los paquetes que pone a disposición de otros módulos ([exports tax.business;]): un paquete no exportado es invisible desde el exterior, incluso para sus clases públicas. Las clases de una aplicación que no declara un módulo —como la nuestra— pertenecen al módulo sin nombre (línea 5 de los resultados), que tiene acceso a todos los módulos. Este es el caso de la mayoría de las aplicaciones y de todas las de este curso: los módulos interesan principalmente a los autores de bibliotecas y al propio JDK.

4.10. Records

Muchas clases sirven únicamente para transportar datos: una persona, una nota, un tramo de impuestos… Para ellas, siempre escribimos el mismo código: campos privados y [final], un constructor que copia sus parámetros en los campos, accesores, un método [toString] que muestra los campos, y los métodos [equals] y [hashCode]. Java 16 introdujo los records: el compilador genera este código a partir de una declaración de una sola línea. Ya los vimos en la sección sobre objetos inmutables; el programa [Classes22.java] los muestra con más detalle:

// records (Java 16)
void main() {
    Person r1 = new Person("Jean", "Dupont", 30);
    Person r2 = new Person("Jean", "Dupont", 30);
    // toString generado por el compilador
    IO.println(r1);
    // los accesores tienen el nombre de los componentes
    IO.println("first name=" + r1.firstName() + ", identity=" + r1.identity());
    // igualdad por valor: r1 y r2 son dos objetos distintos pero iguales
    IO.println("r1.equals(r2) : " + r1.equals(r2) + ", r1 == r2 : " + (r1 == r2));
    // los componentes son de solo lectura
    // r1.age = 31;   // rechazado: el campo age es final
    // una copia modificada, con un método "wither"
    Person r3 = r1.withAge(31);
    IO.println(r3);
    IO.println("r1.equals(r3) : " + r1.equals(r3));
    // deconstrucción en variables con un patrón de record (Java 21)
    if (r1 instanceof Person(String firstName, String lastName, int age)) {
        IO.println("first name=" + firstName + ", last name=" + lastName + ", age=" + age);
    }

    // lo mismo con una clase
    PersonC c1 = new PersonC("Jean", "Dupont", 30);
    PersonC c2 = new PersonC("Jean", "Dupont", 30);
    IO.println(c1);
    IO.println("c1.equals(c2) : " + c1.equals(c2));

    // dos records que implementan la misma interfaz
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    IO.println(e);
    IO.println(e.identity());
    // la igualdad tiene en cuenta el tipo: una Person no es igual a un Teacher
    Person pe = new Person("Lucile", "Dumas", 56);
    IO.println("pe.equals(e) : " + pe.equals(e));
    // el tipo común: la interfaz HasIdentity
    HasIdentity[] identities = { pe, e };
    for (HasIdentity i : identities) {
        IO.println(i.identity());
    }
}

// una interfaz implementada por los records
interface HasIdentity {
    String identity();
}

// un record: firstName, lastName, age son sus componentes
record Person(String firstName, String lastName, int age) implements HasIdentity {
    // se pueden agregar métodos
    @Override
    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // un método "wither": una copia en la que ha cambiado un componente
    public Person withAge(int age) {
        return new Person(firstName, lastName, age);
    }
}

// un record no puede derivar de otro record
record Teacher(String firstName, String lastName, int age, int section) implements HasIdentity {
    @Override
    public String identity() {
        return "Teacher[[" + firstName + ", " + lastName + ", " + age + "]," + section + "]";
    }
}

// una clase equivalente... o casi
final class PersonC {
    private final String firstName;
    private final String lastName;
    private final int age;

    public PersonC(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String firstName() {
        return firstName;
    }

    public String lastName() {
        return lastName;
    }

    public int age() {
        return age;
    }
}
  • líneas 48–59: el record [Person]. La declaración [record Person(String firstName, String lastName, int age)] genera:
    • tres campos privados [final], [firstName], [lastName] y [age], que son los componentes del record;
    • un constructor de tres parámetros, llamado constructor canónico;
    • tres accesores públicos: [firstName()], [lastName()] y [age()] (línea 8);
    • un método [toString] que muestra el nombre del tipo y sus componentes (línea 6);
    • los métodos [equals] y [hashCode], que comparan los valores de los componentes en lugar de las referencias;
  • líneas 51–53 y 56–58: un record, como una clase, puede tener métodos adicionales e implementar interfaces (línea 48);
  • línea 10: [r1] y [r2] son dos objetos distintos ([==] es igual a [false]) pero son iguales según [equals] porque sus componentes tienen los mismos valores. En una clase ordinaria, [equals] compara referencias (línea 26);
  • línea 14: como un record es inmutable, no se puede modificar (línea 12): el método “wither” [withAge] crea una copia de [r1] cuya edad ha cambiado;
  • líneas 18–20: un patrón de record (Java 21): si [r1] es un [Person], sus componentes se extraen en las variables [firstName], [lastName], y [age]. A esto se le llama descomposición de records. Volveremos a encontrar estos patrones al filtrar por patrón;
  • líneas 62–67: un record es implícitamente final y deriva implícitamente de la clase [java.lang.Record]; no puede derivar de otra clase o record, ni se puede derivar de él. Para dar a los records [Person] y [Teacher] un tipo común, hacemos que implementen la misma interfaz, en este caso [HasIdentity] (líneas 43–45). Por lo tanto, el record [Teacher] contiene los componentes de la persona;
  • línea 34: la igualdad de records tiene en cuenta el tipo real de los objetos: un [Person] nunca es igual a un [Teacher], aunque sus componentes comunes sean iguales;
  • líneas 36–39: la interfaz común permite manejar ambos records de forma polimórfica;
  • líneas 70–92: una clase que se asemeja al record [Person] … salvo que hubo que escribir los campos, el constructor y los accesores, y que la igualdad por valor y [toString] no se proporcionan.

Resultados:

> java Classes22.java
Person[firstName=Jean, lastName=Dupont, age=30]
first name=Jean, identity=[Jean, Dupont, 30]
r1.equals(r2) : true, r1 == r2 : false
Person[firstName=Jean, lastName=Dupont, age=31]
r1.equals(r3) : false
first name=Jean, last name=Dupont, age=30
Classes22$PersonC@206a70ef
c1.equals(c2) : false
Teacher[firstName=Lucile, lastName=Dumas, age=56, section=61]
Teacher[[Lucile, Dumas, 56],61]
pe.equals(e) : false
[Lucile, Dumas, 56]
Teacher[[Lucile, Dumas, 56],61]

Observe que el método [toString] de la clase [PersonC] es el mismo que el de la clase [Object] (línea 8 de los resultados) y que la igualdad de los dos objetos [PersonC] es falsa (línea 9).

Resumamos las diferencias entre una clase y un record:

 
Clase
Record
Igualdad mediante [equals]
el mismo objeto (salvo que se redefina)
los mismos valores de componentes, el mismo tipo
[toString]
nombre de la clase y código hash
nombre del record y componentes
campos, constructor, accesores
por escribir
generados por la declaración
estado
modificable o no
inmutable (campos [final]), sin otros campos de instancia
copia modificada
por escribir
por escribir (mediante métodos "wither")
herencia
de una clase, de varias interfaces
de ninguna clase, de varias interfaces; un record siempre es final

Un record se usa para datos definidos por su valor (una persona obtenida de una base de datos, un mensaje intercambiado por una red, un tramo de impuestos), y una clase se usa para un objeto con identidad y comportamiento (un servicio de cálculo, una conexión, una lista mutable). Nota: un record es inmutable “superficialmente”: si un componente hace referencia a un objeto mutable, como una lista, el contenido de esa lista sigue siendo mutable. En esos casos se usan listas inmutables ([List.copyOf]).

4.11. Constructores de records

El constructor canónico de un record simplemente copia sus parámetros en los campos. Sin embargo, puede ser conveniente validar o normalizar esos parámetros. Java proporciona para ello el constructor compacto, así como la posibilidad de agregar otros constructores. El programa [Classes23.java] lo ilustra:

// constructores de record: constructor compacto, otros constructores
void main() {
    Person p = new Person("  Jean ", "Dupont", 30);
    IO.println(p.identity());
    // un record es inmutable: growOlder devuelve una nueva persona
    Person p2 = p.growOlder();
    IO.println(p.identity() + " -> " + p2.identity());
    // otro constructor
    Person unknown = new Person("Martin");
    IO.println(unknown.identity());
    // las verificaciones del constructor compacto
    try {
        new Person("Paul", " ", 20);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        new Person("Paul", "Martin", -4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // un record con un método y una fábrica estática
    Point pt = new Point(3, 4);
    IO.println("pt=" + pt + ", distance to the origin: " + pt.distance() + ", origin=" + Point.origin());
}

record Person(String firstName, String lastName, int age) {
    // constructor compacto: verifica y normaliza los parámetros,
    // luego los campos se inicializan automáticamente
    Person {
        firstName = check(firstName, "first name");
        lastName = check(lastName, "last name");
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
    }

    // cualquier otro constructor debe llamar al constructor canónico
    Person(String lastName) {
        this("?", lastName, 0);
    }

    // un método que devuelve una nueva persona
    public Person growOlder() {
        return new Person(firstName, lastName, age + 1);
    }

    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // un método estático de verificación
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}

record Point(double x, double y) {
    // se permite un campo estático, no un campo de instancia
    private static final Point ORIGIN = new Point(0, 0);

    public static Point origin() {
        return ORIGIN;
    }

    public double distance() {
        return Math.sqrt(x * x + y * y);
    }
}
  • Líneas 30–36: el constructor compacto. Se escribe sin lista de parámetros; sus parámetros son, implícitamente, los del constructor canónico ([firstName], [lastName], [age]). Su código se ejecuta primero; luego los campos se inicializan automáticamente con los valores —que pueden haber sido modificados— de los parámetros. Aquí, el nombre y el apellido se validan y se les quitan los espacios iniciales y finales (líneas 31–32), y se rechaza una edad negativa (líneas 33–35). En un constructor compacto no se pueden asignar valores a los campos ([this.firstName = ...] se rechaza): se modifican los parámetros;
  • líneas 39–41: un record puede tener otros constructores, pero estos deben llamar al constructor canónico con [this(...)]: toda creación de un [Person] pasa así por las validaciones del constructor compacto;
  • líneas 44–46: un record es inmutable; hacerlo envejecer significa crear una nueva instancia;
  • líneas 53–58: un método estático privado de validación;
  • líneas 61–72: un record puede tener campos estáticos (línea 63) y métodos estáticos (líneas 65–67), como la fábrica estática [origin], pero ningún campo de instancia además de sus componentes.

Resultados:

1
2
3
4
5
6
7
> java Classes23.java
[Jean, Dupont, 30]
[Jean, Dupont, 30] -> [Jean, Dupont, 31]
[?, Martin, 0]
last name ( ) invalid
age (-4) invalid
pt=Point[x=3.0, y=4.0], distance to the origin: 5.0, origin=Point[x=0.0, y=0.0]

El nombre, proporcionado rodeado de espacios (línea 3), se almacenó sin ellos (línea 2 de los resultados). El constructor compacto es la forma idiomática de garantizar que un record sea siempre válido: no hay manera de crear un [Person] sin pasar por él.

4.12. Sin métodos de extensión: métodos de utilidad estáticos

¿Cómo se agrega un método a una clase que no se puede modificar, como la clase [String] del JDK? Algunos lenguajes, como C# o Kotlin, ofrecen “métodos de extensión”: métodos estáticos que se usan como métodos de instancia del tipo extendido. Java no los tiene. En su lugar, escribimos métodos estáticos, agrupados en una clase de utilidad, y los invocamos con el nombre de su clase, pasando el objeto como parámetro. El JDK está repleto de ellos: [Arrays], [Collections], [Objects], [Math]… El programa [Classes24.java] lo ilustra:

// no hay métodos de extensión en Java: métodos de utilidad estáticos
import static java.lang.Character.toUpperCase;

void main() {
    Person p = new Person("jean", "dupont", 30);
    // los métodos de utilidad se llaman con el nombre de su clase
    IO.println(Tools.initials(p));
    IO.println(Tools.firstUpper("jean"));
    IO.println(Tools.fullName(p) + " is an adult: " + Tools.isAdult(p));
    IO.println("\"it is sunny\" has " + Tools.nbWords("it is sunny") + " words");
    // un método estático del propio record
    Person unknown = Person.unknown();
    IO.println(Tools.fullName(unknown) + " is an adult: " + Tools.isAdult(unknown));
}

// una persona
record Person(String firstName, String lastName, int age) {
    // fábrica estática: una persona desconocida
    static Person unknown() {
        return new Person("?", "?", 0);
    }
}

// una clase de utilidad: final, constructor privado, métodos estáticos
final class Tools {
    private Tools() {
    }

    static String initials(Person p) {
        return toUpperCase(p.firstName().charAt(0)) + "." + toUpperCase(p.lastName().charAt(0)) + ".";
    }

    static String firstUpper(String s) {
        return s.isEmpty() ? s : toUpperCase(s.charAt(0)) + s.substring(1);
    }

    static boolean isAdult(Person p) {
        return p.age() >= 18;
    }

    static String fullName(Person p) {
        return firstUpper(p.firstName()) + " " + p.lastName().toUpperCase();
    }

    static int nbWords(String s) {
        return s.isBlank() ? 0 : s.strip().split("\\s+").length;
    }
}
  • líneas 25–48: la clase de utilidad [Tools]. Es final y su único constructor es privado (líneas 26–27): no se puede derivar de ella ni instanciarla. Todos sus métodos son estáticos;
  • líneas 29–31: el método [initials] recibe la persona como parámetro. Como una clase de utilidad escrita en otro archivo, usa solo los miembros públicos del record [Person], en este caso sus accesores (en un archivo compacto, en cambio, tendría acceso a los campos privados); [charAt(0)] devuelve el primer carácter de una cadena;
  • línea 2: la importación estática del método [Character.toUpperCase], que convierte un carácter a mayúscula, permite invocarlo sin el nombre de su clase (líneas 30 y 34);
  • líneas 45–47: el método [nbWords] divide la cadena con el método [split], cuyo parámetro es una expresión regular: ["\\s+"] coincide con una secuencia de uno o más caracteres de espacio en blanco;
  • líneas 7–10: los métodos de utilidad se invocan con el nombre de la clase: [Tools.initials(p)], no [p.initials()];
  • líneas 19–21: cuando el tipo se puede modificar, sus métodos se colocan naturalmente en él: la fábrica estática [unknown] es un método del record [Person] (línea 12).

Resultados:

1
2
3
4
5
6
> java Classes24.java
J.D.
Jean
Jean DUPONT is an adult: true
"it is sunny" has 3 words
? ? is an adult: false

Con una importación estática ([import static tools.Tools.*;] si la clase estuviera en un paquete llamado [tools]), se podría escribir [initials(p)] sin el nombre de la clase. Para que un método de utilidad sea utilizable, su clase debe ser accesible y, si está en otro paquete, estar importada.

4.13. Coincidencia de patrones con objetos

La instrucción [switch] y la coincidencia de patrones no se limitan a valores simples (números, cadenas); también se aplican a objetos. Se puede probar el tipo de un objeto, deconstruir un record, agregar una condición y obtener el objeto convertido al tipo correcto, todo en una sola expresión. El programa [Classes25.java] usa una interfaz sellada y tres records que la implementan:

// coincidencia de patrones en objetos
void main() {
    Object[] objects = {
        new Individual("Jean", "Dupont", 30),
        new Individual("Lise", "Morel", 12),
        new Teacher("Lucile", "Dumas", 56, 61),
        new Teacher("Marc", "Petit", 44, 27),
        new Student("Paul", "Martin", 19, "computer science"),
        "a string",
        42,
        null,
    };

    // 1 - el patrón de tipo: instanceof Tipo variable (Java 16)
    for (Object o : objects) {
        if (o instanceof Person p) {
            // aquí p es una Person
            IO.println(p.firstName() + " is of type " + p.getClass().getSimpleName());
        }
    }

    // 2 - el patrón de tipo seguido de una condición
    for (Object o : objects) {
        if (o instanceof Person p && p.age() >= 18) {
            IO.println(p.firstName() + " is an adult");
        }
    }

    // 3 - el switch sobre el tipo del objeto, con guardas y patrones de record (Java 21)
    for (Object o : objects) {
        IO.println(describe(o));
    }

    // 4 - un switch exhaustivo sobre una interfaz sellada
    for (Object o : objects) {
        if (o instanceof Person p) {
            IO.println(p.firstName() + " : " + category(p));
        }
    }
}

String describe(Object o) {
    return switch (o) {
        case Teacher e when e.section() == 27 -> e.firstName() + " teaches computer science";
        case Teacher e -> e.firstName() + " teaches in section " + e.section();
        case Student(var firstName, _, _, var major) -> firstName + " studies " + major;
        case Person p when p.age() < 18 -> p.firstName() + " is a minor";
        case Person p -> p.firstName() + " is " + p.age() + " years old";
        case String s -> "a string of " + s.length() + " characters";
        case Integer n when n > 0 -> "the positive integer " + n;
        case null -> "the null reference";
        default -> "an unknown object";
    };
}

// sin default: el compilador sabe que los tres casos cubren todas las personas
String category(Person p) {
    return switch (p) {
        case Individual _ -> "individual";
        case Teacher _ -> "teacher";
        case Student _ -> "student";
    };
}

// una interfaz sellada y los tres records que la implementan
sealed interface Person permits Individual, Teacher, Student {
    String firstName();
    String lastName();
    int age();
}

record Individual(String firstName, String lastName, int age) implements Person {
}

record Teacher(String firstName, String lastName, int age, int section) implements Person {
}

record Student(String firstName, String lastName, int age, String major) implements Person {
}
  • Líneas 66–79: una interfaz sellada [Person], implementada por tres records: [Individual], [Teacher] y [Student]. La interfaz declara los métodos [firstName], [lastName] y [age]: los records los implementan automáticamente mediante sus accesores, ya que tienen componentes con los mismos nombres. Como un record es final, puede implementar una interfaz sellada sin más especificaciones;
  • líneas 3–12: un arreglo de objetos de diversos tipos, entre ellos un entero (convertido automáticamente a *[Integer]) y la referencia *[null];
  • línea 16: el patrón de tipo [o instanceof Person p] (Java 16) es verdadero si [o] hace referencia a un objeto de tipo [Person]; en ese caso, la variable [p], de tipo [Person], hace referencia a ese objeto. Esto evita la secuencia usada en Java antes de la versión 16: probar el tipo con [instanceof] y luego convertir con [(Person) o]. El patrón es falso si [o] es igual a [null];
  • línea 24: la variable de patrón [p] se puede usar en el resto de la condición, después de [&&]: Java no tiene patrones de propiedades; los valores de los campos se prueban mediante una condición;
  • líneas 42–54: la expresión [switch] sobre un objeto (Java 21) prueba los patrones en orden y devuelve el valor asociado al primero que coincide:
    • línea 44: un profesor de la sección 27. La cláusula [when] agrega una condición, llamada guardia, al patrón de tipo;
    • línea 45: cualquier otro profesor. El orden es importante: si este patrón se colocara antes del anterior, lo habría vuelto inalcanzable, lo cual el compilador habría informado como un error;
    • línea 46: un patrón de record: extrae los componentes del record [Student] en el orden en que fueron declarados; [var] permite que el compilador infiera su tipo, y el carácter [_] (Java 22) ignora un componente;
    • líneas 47–48: un menor de edad, seguido de cualquier otra persona;
    • línea 50: un entero positivo;
    • línea 51: el caso [null]. Sin él, un [switch] sobre una referencia nula lanza una excepción [NullPointerException];
    • línea 52: el caso [default] se encarga de todo lo demás. Sin él, el compilador informaría que la expresión [switch] no cubre todos los casos: un [switch] sobre un objeto debe ser exhaustivo;
  • líneas 57–63: un [switch] sobre una [Person], sin [default]. Sin embargo, es exhaustivo: como la interfaz es sellada, el compilador sabe que una persona es un [Individual], un [Teacher] o un [Student]. El patrón [Individual _] prueba el tipo sin declarar una variable.

Resultados:

> java Classes25.java
Jean is of type Individual
Lise is of type Individual
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference
Jean : individual
Lise : individual
Lucile : teacher
Marc : teacher
Paul : student

Si se elimina el caso [Student] del método [category], el compilador informa un error:

1
2
3
4
5
6
> java Classes25.java
Classes25.java:58: error: the switch expression does not cover all possible input values
    return switch (p) {
           ^
1 error
error: compilation failed

Esta es la gran ventaja de combinar tipos sellados con la coincidencia de patrones: si se agrega un cuarto record a la jerarquía, el compilador identifica todos los [switch] que deben completarse. Observe también que el patrón de tipo corresponde a los tipos que implementan la interfaz: el bucle de patrones de tipo (líneas 15–20) seleccionó los tres tipos de personas. La coincidencia de patrones es una alternativa útil a las instrucciones [if (o instanceof ...)] en cascada; sin embargo, no debe reemplazar al polimorfismo: cuando el comportamiento depende del tipo del objeto y la jerarquía de clases está bien definida, un método redefinido en cada clase suele seguir siendo la solución orientada a objetos. La coincidencia de patrones es adecuada para jerarquías de datos (records) sobre las que se desea escribir una lógica de procesamiento externa a esos datos.

4.14. Manejo del valor null

Toda variable de un tipo de referencia puede tener el valor [null], y usar una referencia nula provoca la excepción [NullPointerException], el error de ejecución más común en Java. A diferencia de otros lenguajes como C# o Kotlin, el compilador de Java no distingue entre los tipos que pueden ser [null] y los que no. Sin embargo, el JDK y las bibliotecas ofrecen varias herramientas para mitigar este riesgo:

  • la clase [Optional<T>] (Java 8), el tipo de retorno de un método que puede no devolver nada;
  • los métodos de la clase [Objects]: [requireNonNull] para rechazar [null] en el punto de entrada de un método o constructor, y [requireNonNullElse] para proporcionar un valor predeterminado;
  • anotaciones que documentan la intención y son verificadas por ciertas herramientas de análisis. Las más recientes, propuestas por un grupo de proveedores (Google, JetBrains, Spring…), son las de la biblioteca JSpecify: [@Nullable] sobre un tipo que puede ser [null], y [@NullMarked] sobre una clase o paquete para indicar que los demás tipos no pueden serlo. Spring Framework 7, que usaremos, las emplea. Requieren una biblioteca, por lo que no las usaremos en este capítulo.

El programa [Classes26.java] demuestra las dos primeras:

// manejo del valor null: Optional, Objects.requireNonNull...
void main() {
    Person jean = new Person("Jean", "Dupont");
    jean.setMiddleName("Marie");
    Person[] persons = { jean, new Person("Paul", "Martin") };
    for (Person p : persons) {
        // un valor por defecto cuando la referencia es null
        String middle = Objects.requireNonNullElse(p.getMiddleName(), "(none)");
        // una prueba explícita
        String length = p.getMiddleName() == null ? "null" : String.valueOf(p.getMiddleName().length());
        IO.println(p.getFirstName() + " : middle name=" + middle + ", length=" + length);
    }

    // un método que puede no encontrar nada: devuelve un Optional<Person>
    Optional<Person> found = find(persons, "Durand");
    IO.println("Durand found: " + found.isPresent());
    IO.println(found.map(Person::getFirstName).orElse("Durand: person not found"));
    // probamos la presencia de un valor antes de usarlo
    found = find(persons, "Martin");
    if (found.isPresent()) {
        IO.println("Martin : " + found.get().getFirstName());
    }
    // ifPresent: la acción solo se realiza si hay un valor presente
    find(persons, "Dupont").ifPresent(p -> p.setMiddleName("Louise"));
    find(persons, "Durand").ifPresent(p -> p.setMiddleName("Louise"));
    IO.println(jean.getMiddleName());
    // orElseThrow: afirmamos que el valor está presente; de lo contrario se lanza una excepción
    Person martin = find(persons, "Martin").orElseThrow();
    IO.println(martin.getFirstName());

    // Objects.requireNonNull: un parámetro obligatorio
    try {
        new Person(null, "Morel");
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
    // la excepción NullPointerException y su mensaje detallado (Java 14)
    try {
        Person lise = new Person("Lise", "Morel");
        IO.println(lise.getMiddleName().length());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

// búsqueda de una persona por apellido
Optional<Person> find(Person[] persons, String lastName) {
    for (Person p : persons) {
        if (p.getLastName().equals(lastName)) {
            return Optional.of(p);
        }
    }
    return Optional.empty();
}

class Person {
    // campos obligatorios: nunca deben ser null
    private final String firstName;
    private final String lastName;
    // campo opcional: null significa "sin segundo nombre"
    private String middleName;

    public Person(String firstName, String lastName) {
        this.firstName = Objects.requireNonNull(firstName, "the first name is mandatory");
        this.lastName = Objects.requireNonNull(lastName, "the last name is mandatory");
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }
}
  • líneas 56–83: la clase [Person] tiene dos campos obligatorios, inicializados por el constructor, y un campo opcional, [middleName]: [null] significa “sin segundo nombre”. El constructor rechaza un nombre o un apellido igual a [null] usando [Objects.requireNonNull] (líneas 64–65): el error se detecta cuando se crea el objeto y no mucho después, cuando se usa el campo;
  • línea 8: [Objects.requireNonNullElse(value, defaultValue)] (Java 9) devuelve [value] si no es igual a [null]; de lo contrario, devuelve [defaultValue];
  • línea 10: una verificación explícita suele ser el enfoque más simple;
  • líneas 47–54: el método [find] devuelve la persona buscada envuelta en un objeto [Optional], o un [Optional] vacío: su tipo de retorno, [Optional<Person>], advierte al llamador que el resultado puede faltar, y le exige manejar este caso para obtener la persona. [Optional.of(p)] crea un [Optional] que contiene [p], [Optional.empty()], y un [Optional] vacío;
  • línea 16: [isPresent] indica si [Optional] contiene un valor;
  • línea 17: [map(Person::getFirstName)] convierte a cualquier persona presente en su nombre; [orElse(value)] devuelve el valor presente o, si no hay ninguno, el valor especificado. La notación [Person::getFirstName] es una referencia a un método, que examinaremos en el capítulo 7; aquí significa “el método [getFirstName] de la persona”;
  • líneas 20–22: [get] devuelve el valor presente; solo se invoca después de verificar su presencia;
  • líneas 24–25: [ifPresent] ejecuta la acción especificada solo si hay un valor presente. La acción es una lambda (capítulo 7): [p -> p.setMiddleName("Louise")] se lee “para la persona p, establecer su segundo nombre”. Dupont existe y se le asigna un nuevo segundo nombre; Durand no existe, y la instrucción no hace nada;
  • Línea 28: [orElseThrow] devuelve el valor si está presente, o lanza una excepción [NoSuchElementException] si [Optional] está vacío. Se usa cuando se tiene la certeza de que el valor está presente;
  • líneas 32–36: el constructor rechaza a una persona sin nombre;
  • líneas 38–43: usar una referencia nula lanza la excepción [NullPointerException]. Desde Java 14, su mensaje identifica específicamente la expresión nula.

Resultados:

> java Classes26.java
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand found: false
Durand: person not found
Martin : Paul
Louise
Paul
Error: the first name is mandatory
Error: Cannot invoke "String.length()" because the return value of "Classes26$Person.getMiddleName()" is null

[Optional] está pensado para los valores de retorno de los métodos; no se usa para campos ni parámetros. En este curso, documentamos si un valor es opcional, verificamos los parámetros obligatorios con [Objects.requireNonNull] y preferimos los objetos siempre completos (construidos con todos sus valores obligatorios) a los objetos que se completan de forma incremental.

4.15. Aplicación de ejemplo - V2

Retomaremos el cálculo de impuestos ya tratado en el capítulo anterior (versión 1) y ahora lo implementaremos con clases e interfaces. Repasemos el problema. Queremos escribir un programa que calcule el impuesto de un contribuyente. Consideraremos el caso simplificado de un contribuyente que solo tiene su salario que declarar (el baremo de 2004 para los ingresos de 2003, usado tal cual: es un ejercicio):

  • calculamos el número de partes del empleado: partes = nbChildren / 2 + 1 si no está casado, nbChildren / 2 + 2 si está casado, donde nbChildren es el número de sus hijos;
  • si tiene al menos tres hijos, recibe media parte adicional;
  • su ingreso imponible R se calcula como R = 0.72 × S, donde S es su salario anual;
  • su cociente familiar se calcula como QF = R / partes;
  • su impuesto I se calcula con la tabla siguiente:
límite
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada fila tiene tres campos. Para calcular el impuesto I, se busca la primera fila donde QF ≤ el límite. Por ejemplo, si QF = 5,000, se encontrará la fila (8,382; 0.068; 291.09). El impuesto I es entonces igual a 0.068 × R - 291.09 × partes. Si QF es tal que la condición QF ≤ límite nunca se cumple, se usan los coeficientes de la última fila, con lo que el impuesto I = 0.481 × R - 9,505.54 × partes.

La aplicación genera el archivo [TaxV2]. Las clases de cálculo están organizadas en un paquete llamado [tax]:

1
2
3
4
5
6
7
TaxV2/
  Main.java                 the program that dialogues with the user
  tax/
    TaxBracket.java         a bracket of the tax scale
    ITax.java               the tax calculation interface
    AbstractTax.java        an abstract class implementing ITax
    HardwiredTax.java       a derived class, with hard-coded data

Primero, definimos un tipo capaz de encapsular una fila de la tabla anterior [TaxBracket.java]:

1
2
3
4
5
6
7
package tax;

import java.math.BigDecimal;

// un tramo del baremo del impuesto
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

Usamos un record:

  • porque un tramo es un pequeño dato sin identidad, definido únicamente por su valor, y no hay motivo para modificarlo una vez creado: un record es inmutable;
  • porque el compilador genera el constructor, los accesores, [toString], y el operador de igualdad a partir de una sola línea.

Los componentes son de tipo [BigDecimal] (paquete [java.math], de ahí la importación en la línea 3). Los tipos [float] y [double] representan números en binario: un número decimal como 0.068 no tiene una representación exacta en ellos, y los cálculos acumulan pequeños errores de redondeo. La clase [BigDecimal] representa números decimales de manera exacta: este es el tipo que debe usarse para los montos. Su inconveniente es la falta de operadores: escribimos [a.add(b)], [a.multiply(b)], [a.compareTo(b)].

A continuación, definimos una interfaz [ITax] capaz de calcular el impuesto [ITax.java]:

1
2
3
4
5
6
package tax;

public interface ITax {
    // cálculo del impuesto de un contribuyente
    int calculate(boolean married, int nbChildren, int salary);
}
  • Línea 5: el método para calcular el impuesto a partir de tres datos: el estado civil del contribuyente, el número de hijos y el salario anual. Redondea el impuesto hacia abajo al euro más cercano.

A continuación, definimos una clase abstracta que implementa esta interfaz [AbstractTax.java]:

package tax;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

public abstract class AbstractTax implements ITax {
    // los tramos del impuesto necesarios para el cálculo provienen de una fuente externa
    // que solo conocen las clases derivadas
    protected abstract List<TaxBracket> getTaxBrackets();

    // cálculo del impuesto
    @Override
    public int calculate(boolean married, int nbChildren, int salary) {
        // cálculo del número de partes
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // cálculo del ingreso gravable y del cociente familiar
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal quotient = income.divide(shares, MathContext.DECIMAL128);
        // búsqueda del tramo del impuesto: se usa el último si ningún límite encaja
        List<TaxBracket> brackets = getTaxBrackets();
        TaxBracket bracket = brackets.getLast();
        for (int i = 0; i < brackets.size() - 1; i++) {
            if (quotient.compareTo(brackets.get(i).limit()) <= 0) {
                bracket = brackets.get(i);
                break;
            }
        }
        // cálculo del impuesto
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • Línea 1: la clase pertenece al paquete [tax]; por lo tanto, su archivo está en la carpeta [tax];
  • Línea 7: la clase [AbstractTax] implementa la interfaz [ITax];
  • Línea 10: los datos del baremo, proporcionados por un método abstracto protegido. La clase [AbstractTax] no sabe de dónde provienen estos datos (escritos en el código, leídos de un archivo, de una base de datos, etc.). Eso se lo deja a las clases derivadas. Por eso se declara abstracta, lo que impide instanciarla. El método abstracto obliga a las clases derivadas a proporcionar los tramos; el compilador lo verifica;
  • líneas 13–35: la implementación del método [calculate] de la interfaz [ITax]. Las clases derivadas no necesitarán reescribir este método. La clase [AbstractTax] sirve así como clase de factorización para las clases derivadas: contiene lo que es común a todas ellas;
  • líneas 16–17: el número de partes. [BigDecimal.valueOf(n)] convierte un entero en [BigDecimal]; la división entre [BigDecimal.TWO] es exacta (3 / 2 = 1.5), a diferencia de la división entera entre [nbChildren / 2] (3 / 2 = 1). La expresión [married ? 2 : 1] es igual a 2 para un contribuyente casado, y 1 en caso contrario;
  • líneas 18–20: la media parte adicional. Un [BigDecimal] es inmutable: [add] devuelve un nuevo objeto, que debe asignarse a la variable;
  • líneas 22–23: el ingreso imponible y el cociente familiar. Las constantes decimales se crean a partir de cadenas ([new BigDecimal("0.72")]) para garantizar que sean exactas. Dividir un [BigDecimal] puede dar como resultado un número infinito de decimales (1 / 3): especificamos la precisión deseada, en este caso [MathContext.DECIMAL128] (34 dígitos significativos);
  • líneas 25–32: búsqueda del tramo. De manera predeterminada, es el último tramo ([brackets.getLast()], línea 26). El bucle recorre todos los tramos excepto el último y se detiene ([break]) en el primer tramo cuyo límite es mayor o igual que el cociente familiar, según lo evalúa [compareTo(...) <= 0];
  • línea 34: el cálculo del impuesto. El método [intValue] trunca el resultado a su parte entera.

Una clase que implementa la interfaz [ITax] puede crearse derivándola de la clase [AbstractTax]. Es lo que hacemos ahora con [HardwiredTax.java]:

package tax;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class HardwiredTax extends AbstractTax {
    // datos del cálculo del impuesto (baremo de 2004 sobre ingresos de 2003), "fijos en el código"
    private static final double[] LIMITS = { 4962, 8382, 14753, 23888, 38868, 47932, 0 };
    private static final double[] COEFF_R = { 0, 0.068, 0.191, 0.283, 0.374, 0.426, 0.481 };
    private static final double[] COEFF_N = { 0, 291.09, 1322.92, 2668.39, 4846.98, 6883.66, 9505.54 };

    // los tramos del impuesto
    private final List<TaxBracket> taxBrackets;

    // constructor
    public HardwiredTax() {
        // creación y llenado de la lista de tramos del impuesto
        List<TaxBracket> brackets = new ArrayList<>();
        for (int i = 0; i < LIMITS.length; i++) {
            brackets.add(new TaxBracket(BigDecimal.valueOf(LIMITS[i]),
                    BigDecimal.valueOf(COEFF_R[i]), BigDecimal.valueOf(COEFF_N[i])));
        }
        // la lista almacenada no es modificable
        taxBrackets = List.copyOf(brackets);
    }

    // implementación del método abstracto de la clase padre
    @Override
    protected List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }
}
  • Líneas 9–11: la clase [HardwiredTax] codifica de forma fija los datos necesarios para calcular el impuesto. Son campos de clase ([static]) [final]: son compartidos por todas las instancias y no pueden reemplazarse por otros arreglos. Por convención, los nombres de las constantes ([static final]) se escriben en mayúsculas;
  • líneas 17–26: el constructor usa estos datos para construir la lista de tramos del impuesto. [BigDecimal.valueOf(double)] (líneas 21–22) convierte un [double] en un [BigDecimal] mediante su representación decimal más corta: [BigDecimal.valueOf(0.068)] es exactamente 0.068. No debe usarse el constructor [new BigDecimal(0.068)], que reproduce todos los decimales del valor binario aproximado (0.068000000000000004884981308350688…);
  • línea 25: [List.copyOf] devuelve una copia de solo lectura de la lista: ninguna clase podrá modificar el baremo;
  • líneas 29–32: se implementa el método abstracto de la clase padre: devuelve la lista de tramos.

El próximo capítulo agregará otras clases derivadas de [AbstractTax], que leerán los tramos desde un archivo de texto o desde JSON: solo necesitarán proporcionar el método [getTaxBrackets].

Un programa de prueba podría ser el siguiente [Main.java]:

// programa interactivo de cálculo del impuesto
// el usuario escribe tres datos en el teclado: married nbChildren salary
// luego el programa muestra el impuesto a pagar
import tax.HardwiredTax;
import tax.ITax;

static final String SYNTAX = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros""";

void main() {
    // creación de un objeto ITax
    ITax tax = new HardwiredTax();

    // bucle de entrada
    while (true) {
        // pedimos los parámetros del cálculo del impuesto
        String parameters = IO.readln("Tax calculation parameters in the format: "
                + "Married (y/n) NbChildren Salary, or nothing to stop: ");
        // fin de la entrada estándar o línea vacía: nos detenemos
        if (parameters == null || parameters.isBlank()) {
            break;
        }
        // verificación del número de campos de la línea escrita
        String[] fields = parameters.strip().split("\\s+");
        if (fields.length != 3) {
            IO.println(SYNTAX);
            continue;
        }
        // verificación de la validez de los parámetros
        // married
        String married = fields[0].toLowerCase();
        if (!married.equals("y") && !married.equals("n")) {
            IO.println(SYNTAX + "\nIncorrect married argument: type y or n");
            continue;
        }
        // nbChildren
        int nbChildren = positiveInteger(fields[1]);
        if (nbChildren < 0) {
            IO.println(SYNTAX + "\nIncorrect NbChildren argument: type a positive or zero integer");
            continue;
        }
        // salary
        int salary = positiveInteger(fields[2]);
        if (salary < 0) {
            IO.println(SYNTAX + "\nIncorrect salary argument: type a positive or zero integer");
            continue;
        }
        // los parámetros son correctos: calculamos el impuesto
        IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
    }
}

// devuelve el entero positivo o cero representado por la cadena, -1 si la cadena no representa uno
int positiveInteger(String input) {
    try {
        int value = Integer.parseInt(input);
        return value >= 0 ? value : -1;
    } catch (NumberFormatException ex) {
        return -1;
    }
}

El programa anterior permite al usuario realizar simulaciones repetidas del cálculo de impuestos.

  • Líneas 4–5: el programa principal está en el paquete sin nombre; importa los dos tipos que necesita del paquete [tax]. Estos tipos deben ser públicos;
  • Líneas 7–11: el mensaje de ayuda es una constante de la clase implícita, escrita como un bloque de texto (Java 15) delimitado por tres comillas: la cadena puede abarcar varias líneas, y se elimina la sangría común de las líneas. Como las comillas de cierre se colocan al final de la última línea, la cadena no termina con un salto de línea;
  • línea 15: creación de un objeto [tax] que implementa la interfaz [ITax]. Este objeto se obtiene instanciando un tipo [HardwiredTax], un tipo que implementa la interfaz [ITax]. Observe que a la variable [tax] no se le asignó el tipo [HardwiredTax] sino el tipo [ITax]. Al escribirlo así, indicamos que solo nos interesa el método [calculate] del objeto [tax] y no el resto. Para usar datos de un archivo, basta con cambiar esta única línea;
  • líneas 18–53: el bucle de simulaciones del cálculo de impuestos;
  • líneas 20–21: los tres parámetros necesarios para el método [calculate] se solicitan en una sola línea ingresada por teclado. [IO.readln(message)] muestra el mensaje y luego lee una línea; devuelve [null] si la entrada estándar está cerrada: la verificación de la línea 23 termina entonces el programa, igual que lo haría una línea vacía;
  • línea 27: el método [split] divide la línea —sin los espacios iniciales y finales— en palabras separadas por uno o más espacios (expresión regular ["\\s+"]);
  • Líneas 40 y 46: el método [positiveInteger] (líneas 57–64) verifica que los dos últimos campos sean enteros positivos o cero. [Integer.parseInt] lanza una excepción [NumberFormatException] si la cadena no representa un entero: el método la captura y devuelve -1, lo que indica un error;
  • línea 52: llamada al método [calculate] del objeto [tax] que implementa la interfaz [ITax].

Este es un ejemplo de ejecución del programa, lanzado desde la carpeta [TaxV2]:

> java Main.java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Los montos de impuestos se calculan correctamente: 4,282 euros para un contribuyente casado con dos hijos y un salario anual de 60,000 euros (línea 26), y 2,959 euros con tres hijos (línea 28). Un contribuyente soltero sin hijos paga 11,519 euros por el mismo salario (línea 30).

En comparación con la versión 1, el cálculo ahora está encapsulado en clases detrás de una interfaz: el programa de diálogo solo conoce la interfaz [ITax]. Las versiones siguientes aprovecharán esta separación: la versión 3 (próximo capítulo) cambiará el origen de los datos derivando nuevas clases de [AbstractTax], y luego la aplicación se organizará en capas (capítulo 6).