Skip to content

3. Los fundamentos del lenguaje Java

3.1. Introducción

Comenzaremos tratando Java como un lenguaje de programación tradicional. Veremos las clases en el próximo capítulo. Un programa consta de dos cosas:

  • datos;
  • las instrucciones que los manipulan.

Generalmente se procura separar los datos de las instrucciones:

Image

Todos los ejemplos de este capítulo son archivos fuente compactos: un único archivo llamado [.java], sin proyecto Maven, que se ejecuta con el comando [java Basics01.java]. El lanzador [java] compila entonces el archivo en memoria y lo ejecuta, sin producir un archivo [.class]. Esta capacidad se presentó en el capítulo 2, “Configuración del entorno de desarrollo”. Los ejemplos se encuentran en la carpeta [03-basics] del código del curso. Se ejecutan con el idioma y las convenciones del francés (la “configuración regional” fr-FR), tal como lo harían en una máquina con Windows en francés. Veremos que esto solo afecta a los números y las fechas con un formato específico: la conversión simple de un número de punto flotante a una cadena siempre usa el punto decimal.

3.2. El programa mínimo

3.2.1. El archivo fuente compacto

El programa [Basics01.java] es el siguiente:

// programa mínimo escrito como archivo fuente compacto (Java 25)
// sin declaración de clase, sin las palabras clave public y static: solo un método main
void main() {
    IO.println("Hello world!");
    // la forma histórica: el campo out de la clase System, luego su método println
    System.out.println("Hello world!");
    // List (paquete java.util) se puede usar sin import en un archivo compacto
    List<String> words = List.of("Hello", "the", "world");
    IO.println(words);
}

Resultados:

1
2
3
4
> java Basics01.java
Hello world!
Hello world!
[Hello, the, world]

Comentarios:

  • El archivo no contiene ninguna declaración de clase, solo un método llamado [main]. Se trata de un archivo fuente compacto (Java 25). El propio compilador envuelve el contenido del archivo en una clase declarada implícitamente que lleva el nombre del archivo: [Basics01]. Esta característica se introdujo como preview en Java 21 hasta Java 24 antes de ser definitiva en Java 25;
  • Línea 3: el método [main] es el punto de entrada del programa: es este método el que ejecuta el lanzador [java] . A partir de Java 25, puede escribirse simplemente como [void main()], sin las palabras clave [public] y [static] y sin ningún parámetro. El cuerpo del método se encierra entre llaves;
  • línea 4: el método [println] de la clase [IO] (Java 25) escribe una línea en la pantalla;
  • Línea 6: la forma tradicional de la misma operación. [System] es una clase, [out] es uno de sus campos, que representa la salida estándar (la pantalla), y [println] es un método de este objeto. [IO.println(x)] es simplemente un atajo para [System.out.println(x)]. Usaremos [IO.println] en los archivos compactos y [System.out.println] en las clases normales, donde aparece en todo el código Java existente;
  • línea 8: [List] es una lista de cadenas de caracteres; las listas se tratarán en el capítulo 5. [List] pertenece al paquete [java.util]: un paquete agrupa clases relacionadas, igual que una carpeta agrupa archivos. El nombre completo de la clase es [java.util.List]. Puede usarse sin una instrucción import porque el archivo es un archivo compacto (véase más adelante);
  • línea 9: una lista se muestra con sus elementos entre corchetes;
  • cada instrucción termina con un punto y coma; las líneas que comienzan con // son comentarios, que el compilador ignora.

Con dos argumentos de línea de comandos (colocados después del nombre del archivo):

1
2
3
4
> java Basics01.java a0 a1
Hello world!
Hello world!
[Hello, the, world]

Los argumentos se ignoran porque el método [void main()] no tiene parámetros para recibirlos. Para usarlos, declárelo como [void main(String[] args)]: el arreglo de cadenas [args] contiene entonces los argumentos de la línea de comandos. Volveremos sobre esto en la sección “Argumentos del programa principal”.

3.2.2. La forma clásica con una clase y un método main

Hasta Java 24, el mismo programa debía escribirse de la siguiente manera: [Basics02.java]:

// la forma clásica del programa (la única forma estándar hasta Java 24)
import java.util.Arrays;

public class Basics02 {
    // el método main es el punto de entrada del programa
    public static void main(String[] args) {
        System.out.println("Hello world!");
        System.out.println("Number of arguments received: " + args.length);
        // Arrays (paquete java.util) debe importarse en una clase ordinaria
        System.out.println("Arguments: " + Arrays.toString(args));
    }
}

Resultados:

1
2
3
4
> java Basics02.java a0 a1
Hello world!
Number of arguments received: 2
Arguments: [a0, a1]

Comentarios:

  • Línea 2: la directiva [import] importa la clase [Arrays] del paquete [java.util]. Entonces puede escribir [Arrays] en lugar de [java.util.Arrays]. En una clase normal, solo las clases del paquete [java.lang] ([System], [String], [Math], [Integer], [IO]...) pueden usarse sin importarlas;
  • línea 4: en Java, todo el código pertenece a una clase. Aquí la clase se llama [Basics02]. Una clase declarada como [public] debe estar en un archivo con ese nombre: [Basics02.java];
  • línea 6: el método [main] es el punto de entrada del programa. Es [public] (accesible desde fuera de la clase, en particular mediante el lanzador [java]), [static] (se ejecuta sin necesidad de crear un objeto de la clase), no devuelve ningún resultado ([void]) y recibe los argumentos de la línea de comandos en el arreglo [args];
  • línea 8: el número de elementos del arreglo [args] es [args.length]. Aquí el operador + concatena una cadena y un número: el número se convierte primero en cadena;
  • Línea 10: el método [Arrays.toString] construye una cadena a partir de los elementos de un arreglo.

Un archivo que contiene una clase normal también puede ejecutarse directamente con el lanzador ([java Basics02.java]). También puede compilarlo primero con el compilador [javac], que produce un archivo [Basics02.class] con el código intermedio (“bytecode”) de la clase, y luego ejecutar esa clase con el comando [java] seguido del nombre de la clase (sin la extensión). Esto es lo que hacen Maven y los entornos de desarrollo en segundo plano:

1
2
3
4
5
6
7
> javac Basics02.java
> ls
Basics02.class  Basics02.java
> java Basics02 a0 a1
Hello world!
Number of arguments received: 2
Arguments: [a0, a1]

Los dos programas [Basics01.java] y [Basics02.java] son de naturaleza similar. Cuando encuentra un archivo compacto, el propio compilador genera una clase [final] con el nombre del archivo, cuyos métodos y campos son los escritos en el archivo. El archivo compacto es, por lo tanto, simplemente una versión abreviada de la forma estándar. Es adecuado para los programas pequeños de este capítulo; la forma estándar se vuelve necesaria en cuanto un programa contiene varias clases, lo que ocurrirá a partir del capítulo 4.

Desde Java 25, el método [main] puede adoptar cuatro formas: [static void main(String[] args)], [static void main()], [void main(String[] args)], y [void main()]; si una clase contiene varias de ellas, el lanzador prefiere la que tiene el parámetro [String[]]. Las dos últimas formas son métodos de instancia: el lanzador crea primero un objeto de la clase y luego llama a su método [main]. La palabra clave [public] ya no es obligatoria.

3.2.3. Importación automática del módulo java.base

El programa [Basics01.java] usa la clase [List] sin la directiva [import java.util.List;]. Esto es posible porque el compilador agrega automáticamente la siguiente directiva a todo archivo compacto (Java 25):

import module java.base;

Las clases de la biblioteca estándar de Java están organizadas en paquetes, que a su vez se agrupan en módulos. El módulo [java.base] es el módulo central: contiene los paquetes de uso más frecuente. La directiva [import module java.base;] importa de una sola vez todas las clases públicas de todos los paquetes exportados por este módulo, lo que equivale, entre otras cosas, a las siguientes directivas:

import java.io.*;
import java.math.*;
import java.net.*;
import java.nio.file.*;
import java.text.*;
import java.time.*;
import java.time.format.*;
import java.util.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
...

En un archivo compacto, usted tiene acceso, sin escribir una sola línea de código, a las listas y los diccionarios ([java.util]), los archivos ([java.io], [java.nio.file]), los números grandes ([java.math]), las fechas ([java.time]), etc. Una clase de otro módulo, como las clases JDBC del módulo [java.sql], siempre debe importarse explícitamente. En una clase normal, no se importa nada automáticamente fuera del paquete [java.lang]: se escribe una directiva por clase ([import java.util.Arrays;]), una directiva por paquete ([import java.util.*;]) o, desde Java 25, una directiva por módulo ([import module java.base;]). La clase [IO] forma parte del paquete [java.lang]: puede usarse en cualquier lugar.

3.3. Los datos de Java

Java utiliza los siguientes tipos de datos:

  • enteros;
  • números reales;
  • números decimales;
  • caracteres y cadenas de caracteres;
  • booleanos;
  • objetos.

3.3.1. Tipos de datos predefinidos

Tipo de Java
Clase envoltorio
Datos representados
Sufijo del literal
Codificación
Rango de valores
[char]
[Character]
carácter
 
2 bytes
Carácter Unicode (UTF-16), de '\u0000' a '\uffff'
[byte]
[Byte]
entero
 
1 byte
[-2⁷, 2⁷-1], o [-128, 127]
[short]
[Short]
entero
 
2 bytes
[-2¹⁵, 2¹⁵-1] o [-32768, 32767]
[int]
[Integer]
entero
 
4 bytes
[-2³¹, 2³¹-1] o [-2147483648, 2147483647]
[long]
[Long]
entero
L
8 bytes
[-2⁶³, 2⁶³-1] o [-9223372036854775808, 9223372036854775807]
[float]
[Float]
número real
F
4 bytes
[1.4 10⁻⁴⁵, 3.4 10³⁸] en valor absoluto, 7 dígitos significativos
[double]
[Double]
número real
D (opcional)
8 bytes
[4.9 10⁻³²⁴, 1.8 10³⁰⁸] en valor absoluto, de 15 a 16 dígitos significativos
[boolean]
[Boolean]
booleano
 
Indefinido
[true], [false]
[String] (clase)
 
cadena de caracteres
  
referencia a una secuencia de caracteres Unicode
[BigDecimal] (clase)
 
número decimal
 
variable
número decimal exacto, de precisión arbitraria
[Object] (clase)
 
referencia a un objeto
  
referencia a un objeto de cualquier tipo

Los primeros ocho tipos de la tabla, cuyos nombres se escriben en minúsculas, son los tipos primitivos de Java. Todos los demás tipos son tipos de referencia: clases ([String], [BigDecimal], [Object]...), así como arreglos, enumeraciones, interfaces y records, que veremos más adelante. La diferencia es fundamental:

  • una variable de un tipo primitivo contiene directamente su valor;
  • una variable de un tipo de referencia contiene la dirección del objeto (su referencia), y el propio objeto se almacena en otra parte de la memoria.

Un valor de un tipo primitivo no es un objeto: no tiene ni campos ni métodos. Sin embargo, cada tipo primitivo corresponde a una “clase envoltorio” del paquete [java.lang]: [Integer] para [int], [Double] para [double], [Character] para [char], y así sucesivamente. Un objeto [Integer] envuelve un valor [int]. Estas clases también ofrecen constantes y métodos útiles: [Integer.MAX_VALUE], [Integer.BYTES], [Integer.parseInt]... Desde Java 5, el compilador convierte automáticamente un tipo primitivo en su clase envoltorio (boxing) y viceversa (unboxing). Así, podemos escribir:

String typeName = Integer.valueOf(3).getClass().getName();

El literal 3 es de tipo [int]. Como no tiene métodos, no podemos escribir [3.getClass()]: primero debemos envolverlo en un objeto [Integer] mediante [Integer.valueOf(3)]. Todo objeto tiene un método [getClass()] que devuelve un objeto que describe su clase; el método [getName()] de ese objeto devuelve el nombre completo de la clase, en este caso [java.lang.Integer].

Java no tiene enteros sin signo, salvo el tipo [char] (16 bits). En cambio, las clases envoltorio ofrecen métodos que interpretan los bits de un entero como los de un número sin signo: [Integer.toUnsignedString], [Integer.parseUnsignedInt], [Integer.compareUnsigned], [Byte.toUnsignedInt]... Tampoco tiene un tipo decimal primitivo: los importes se calculan con la clase [BigDecimal] del paquete [java.math], de la que hablaremos un poco más adelante.

El programa [Basics03.java] ilustra estos diversos puntos:

// los tipos primitivos: clase envoltorio y tamaño en bytes
void main() {
    int integer = 2;
    float fl = 10.5F;
    double d = -4.6;
    String s = "test";
    long l = 1000;
    byte aByte = 5;
    short sh = -4;
    char c = 'A';
    boolean b = true;
    BigDecimal dec = new BigDecimal("10.67");
    // %s se reemplaza por el valor convertido a cadena, %d por un entero
    IO.println("Type of integer[%s] : [%s,%d]".formatted(integer, typeName(integer), Integer.BYTES));
    IO.println("Type of fl[%s] : [%s,%d]".formatted(fl, typeName(fl), Float.BYTES));
    IO.println("Type of d[%s] : [%s,%d]".formatted(d, typeName(d), Double.BYTES));
    IO.println("Type of s[%s] : [%s]".formatted(s, typeName(s)));
    IO.println("Type of l[%s] : [%s,%d]".formatted(l, typeName(l), Long.BYTES));
    IO.println("Type of aByte[%s] : [%s,%d]".formatted(aByte, typeName(aByte), Byte.BYTES));
    IO.println("Type of sh[%s] : [%s,%d]".formatted(sh, typeName(sh), Short.BYTES));
    IO.println("Type of c[%s] : [%s,%d]".formatted(c, typeName(c), Character.BYTES));
    IO.println("Type of b[%s] : [%s]".formatted(b, typeName(b)));
    IO.println("Type of dec[%s] : [%s]".formatted(dec, typeName(dec)));
    // el literal 3 no es un objeto: debe encapsularse en un Integer
    IO.println("Type of the boxed literal 3: " + Integer.valueOf(3).getClass().getName());
    // valores extremos
    IO.println("int : [" + Integer.MIN_VALUE + ", " + Integer.MAX_VALUE + "]");
    IO.println("long : [" + Long.MIN_VALUE + ", " + Long.MAX_VALUE + "]");
    IO.println("double : [" + Double.MIN_VALUE + ", " + Double.MAX_VALUE + "]");
    // sin enteros sin signo, pero con métodos que interpretan los bits como sin signo
    int minusOne = -1;
    IO.println("-1 read as an unsigned integer: " + Integer.toUnsignedString(minusOne));
}

// devuelve el nombre completo de la clase del objeto recibido
String typeName(Object o) {
    return o.getClass().getName();
}

Resultados:

> java Basics03.java
Type of integer[2] : [java.lang.Integer,4]
Type of fl[10.5] : [java.lang.Float,4]
Type of d[-4.6] : [java.lang.Double,8]
Type of s[test] : [java.lang.String]
Type of l[1000] : [java.lang.Long,8]
Type of aByte[5] : [java.lang.Byte,1]
Type of sh[-4] : [java.lang.Short,2]
Type of c[A] : [java.lang.Character,2]
Type of b[true] : [java.lang.Boolean]
Type of dec[10.67] : [java.math.BigDecimal]
Type of the boxed literal 3: java.lang.Integer
int : [-2147483648, 2147483647]
long : [-9223372036854775808, 9223372036854775807]
double : [4.9E-324, 1.7976931348623157E308]
-1 read as an unsigned integer: 4294967295

Comentarios:

  • línea 3: declaración de un entero [integer] inicializado en 2;
  • línea 4: el sufijo F es obligatorio: el literal 10.5 es de tipo [double], y el compilador rechaza [float fl = 10.5;], que implicaría una pérdida de precisión;
  • línea 7: el literal 1000 es de tipo [int]; se convierte automáticamente a [long];
  • línea 12: un número [BigDecimal] es un objeto; aquí se crea a partir de una cadena, lo que garantiza un valor exacto;
  • línea 14: el método [formatted] (Java 15) se aplica a una cadena con formato: cada marcador %s se reemplaza por el valor del siguiente parámetro convertido en cadena, y cada %d por el valor de un entero. Los parámetros se toman en orden. Hablaremos de los formatos en la siguiente sección;
  • línea 14: el método [typeName] (líneas 36–38) espera un parámetro de tipo [Object]. La variable [integer], de tipo [int], se envuelve automáticamente en un objeto [Integer], cuya clase es [java.lang.Integer]: por eso la salida muestra las clases envoltorio en lugar de los nombres de los tipos primitivos. [Integer.BYTES] (Java 8) es el tamaño en bytes de un [int];
  • línea 17: [String] es una clase, no un tipo primitivo: el tamaño en memoria de un objeto no es accesible en Java;
  • línea 22: el tamaño de un [boolean] no está definido por la especificación de Java: la clase [Boolean] no tiene una constante [BYTES];
  • línea 25: el literal 3 se envuelve explícitamente en un [Integer];
  • líneas 27–29: las constantes [MIN_VALUE] y [MAX_VALUE] de las clases envoltorio definen los límites del rango de valores. Atención: para los números reales, [Double.MIN_VALUE] es el menor valor estrictamente positivo (4.9 × 10⁻³²⁴) y no el mayor número negativo, que es [-Double.MAX_VALUE];
  • líneas 31–32: -1 se codifica como 32 bits en 1; interpretados como un entero sin signo, estos 32 bits equivalen a 2³²–1;
  • líneas 36–38: un método del archivo compacto. Devuelve ([return]) una cadena de caracteres ([String]). Los métodos se describen en la sección “Paso de parámetros a una función”.

Observe que los números reales se muestran con punto decimal (10.5, -4.6), aunque el programa se ejecuta en francés. La conversión de un número a cadena mediante concatenación, con [String.valueOf], [toString] o con el especificador %s, no depende del idioma del usuario: siempre produce un punto decimal. Solo los formatos numéricos como %f, de los que hablaremos, siguen las convenciones del idioma.

3.3.2. Notación de los datos literales

Datos
Ejemplos de literales
entero [int] (32 bits)
145, -7, 0xFF (hexadecimal), 0b1010_1010 (binario)
Entero [long] (64 bits), sufijo L
100000L, 1_000_000_000_000L
real de punto flotante [double], sufijo D opcional
134.789, -45E-18 (-45 × 10⁻¹⁸), 10D
real [float], sufijo F
134.789F, -45E-18F
número decimal [BigDecimal]
sin literal: [new BigDecimal("100000.50")]
carácter [char]
'A', 'b', '\n', '\u00e9'
cadena [String]
"today", "c:\\chap1", bloque de texto """..."""
booleano [boolean]
[true], [false]
fecha
[LocalDate.of(1954, 10, 13)] (año, mes, día) para el 13/10/1954

En el código fuente, los números de punto flotante siempre se escriben con punto decimal. Desde Java 7, los enteros pueden escribirse en binario (con el prefijo [0b]) y los grupos de dígitos pueden separarse con el carácter _ para mejorar la legibilidad: [1_000_000] es el entero un millón. El sufijo L puede escribirse en minúscula, pero la l se parece demasiado al dígito 1. Por último, cuidado con una trampa heredada del lenguaje C: un entero escrito con un 0 inicial se interpreta como octal (base 8): 017 es igual a 15.

Un literal de cadena puede contener secuencias de escape introducidas por el carácter \: "\n" representa el carácter de fin de línea y no la secuencia de los dos caracteres \ y n, "\t" representa una tabulación, "\"" representa unas comillas dobles y "\\" representa el propio carácter \. Para escribir la ruta de Windows c:\chap1\paragraph3, por lo tanto, debe escribir "c:\\chap1\\paragraph3". Java no tiene una cadena “sin procesar” (raw) en la que el carácter \ se interprete tal cual; sin embargo, las clases de archivos de Java también aceptan el separador / en Windows: "c:/chap1/paragraph3" designa el mismo archivo.

Para construir una cadena a partir de varios valores, Java ofrece dos métodos:

  • la concatenación con el operador +: en cuanto uno de los dos operandos es una cadena, el otro se convierte en cadena;
  • los formatos: [String.format(format, value1, value2, ...)], o de forma equivalente [format.formatted(value1, value2, ...)] (Java 15), y para mostrar directamente, [System.out.printf(format, value1, ...)]. La cadena de formato contiene marcadores de posición que se reemplazan en orden por los valores siguientes: %s (cualquier valor convertido en cadena), %d (un entero), %f (un número de punto flotante), %.2f (un número de punto flotante con dos decimales), %x o %X (un entero en hexadecimal), %,d (un entero con separador de miles), %e (notación científica), %n (un salto de línea), %10s (una cadena alineada a la derecha en 10 caracteres), %-10s (alineada a la izquierda)... Los formatos numéricos siguen las convenciones del idioma del usuario.

Java no admite las cadenas “interpoladas” que contienen expresiones entre llaves: una característica así (conocida como “string templates”) se propuso como preview en Java 21 y 22, pero luego se eliminó. La concatenación y el formato siguen siendo las únicas opciones.

Desde Java 15, se puede escribir una cadena en varias líneas mediante un “bloque de texto”: comienza con tres comillas seguidas de un salto de línea y termina con tres comillas. Puede contener comillas sin escapar. Se elimina el espacio en blanco inicial común a todas las líneas (incluida la línea que contiene las comillas de cierre), lo que permite sangrar el texto junto con el código. Sin embargo, las secuencias de escape se interpretan igual que en una cadena normal: siempre se debe escribir \\ para obtener \. Los bloques de texto son muy útiles para escribir JSON, SQL o HTML.

El programa [Basics04.java] muestra estas diferentes notaciones:

// la notación de los datos literales
void main() {
    // enteros: decimal, hexadecimal (0x), binario (0b), separador _
    int i1 = 145, i2 = -7, i3 = 0xFF, i4 = 0b1010_1010;
    long l1 = 100000L, l2 = 1_000_000_000_000L;
    IO.println("integers: " + i1 + " " + i2 + " " + i3 + " " + i4 + " " + l1 + " " + l2);
    // reales
    double d1 = 134.789, d2 = -45E-18, d3 = 10D;
    float f1 = 134.789F;
    BigDecimal m1 = new BigDecimal("100000.50");
    IO.println("reals: " + d1 + " " + d2 + " " + d3 + " " + f1 + " " + m1);
    // caracteres y booleanos
    char c1 = 'A', c2 = '\u00e9';
    boolean b1 = true;
    IO.println("characters: " + c1 + " " + c2 + ", boolean: " + b1);
    // una fecha: (año, mes, día)
    LocalDate birth = LocalDate.of(1954, 10, 13);
    IO.println("date: " + birth);

    // el carácter \ introduce una secuencia de escape
    String path = "c:\\chap1\\paragraph3";
    IO.println(path);
    IO.println("line 1\nline 2\t[tab]");

    // construcción de una cadena: concatenación o format
    String name = "dupont";
    int age = 23;
    IO.println(name + " is " + age + " years old, in 10 years he will be " + (age + 10) + " years old");
    IO.println(String.format("%s is %d years old, in 10 years he will be %d years old", name, age, age + 10));
    // el método formatted (Java 15) se aplica a la propia cadena de formato
    IO.println("d1=%.1f, i3 in hexadecimal=%X, l2=%,d".formatted(d1, i3, l2));
    IO.println("i4 in binary=" + Integer.toBinaryString(i4));
    IO.println("date=" + birth.format(DateTimeFormatter.ofPattern("EEEE d MMMM yyyy")));

    // bloque de texto (Java 15): las comillas dobles se escriben sin escape
    String json = """
        {
          "name": "dupont",
          "path": "c:\\chap1"
        }
        """;
    IO.print(json);
    // un bloque de texto es una cadena como cualquier otra: acepta formatted
    String json2 = """
        { "name": "%s", "age": %d }""".formatted(name, age);
    IO.println(json2);
}

Resultados:

> java Basics04.java
integers: 145 -7 255 170 100000 1000000000000
reals: 134.789 -4.5E-17 10.0 134.789 100000.50
characters: A é, boolean: true
date: 1954-10-13
c:\chap1\paragraph3
line 1
line 2 [tab]
dupont is 23 years old, in 10 years he will be 33 years old
dupont is 23 years old, in 10 years he will be 33 years old
d1=134,8, i3 in hexadecimal=FF, l2=1 000 000 000 000
i4 in binary=10101010
date=mercredi 13 octobre 1954
{
  "name": "dupont",
  "path": "c:\chap1"
}
{ "name": "dupont", "age": 23 }

Comentarios:

  • línea 4: [0xFF] es 255 y [0b1010_1010] es 170;
  • línea 5: el sufijo L es obligatorio para un literal que excede el rango de [int]. Sin él, el compilador rechaza la línea con el mensaje [error: integer number too large];
  • línea 8: -45E-18 se muestra como -4.5E-17: es el mismo valor, normalizado. El número de punto flotante 10D se muestra como 10.0: la conversión de un [double] a cadena siempre produce al menos un decimal;
  • línea 10: un [BigDecimal] conserva el número de decimales con el que se escribió: 100000.50, no 100000.5;
  • línea 13: la secuencia \u00e9 designa el carácter Unicode con código hexadecimal 00E9, es decir, é;
  • línea 17: una fecha. La clase [LocalDate] (paquete [java.time], Java 8) representa una fecha sin hora. Su conversión a cadena usa el formato internacional ISO 8601 (año-mes-día), independientemente del idioma. Veremos las fechas en el capítulo 5;
  • línea 21: cada \\ representa un único carácter \;
  • línea 23: un salto de línea y una tabulación;
  • línea 28: una concatenación. Los paréntesis de [(age + 10)] son esenciales: sin ellos, los operadores + se evaluarían de izquierda a derecha, la cadena recibiría primero 23 y luego 10, y el resultado sería “tendrá 2310 años”;
  • línea 29: el mismo texto construido con un formato;
  • línea 31: algunos especificadores de formato: %.1f (un decimal), %X (hexadecimal en mayúsculas), %,d (separador de miles). Estos formatos siguen las convenciones francesas: una coma decimal y, como separador de miles, un espacio fino sin salto;
  • línea 32: no hay un especificador para binario; el método [Integer.toBinaryString] realiza la conversión;
  • línea 33: un formato de fecha personalizado: día de la semana (EEEE), día (d), mes en letras (MMMM), año (yyyy). Los nombres de los días y de los meses están en francés, el idioma del usuario;
  • líneas 36–41: un bloque de texto de varias líneas. Las comillas se escriben tal cual. Se han eliminado los ocho espacios comunes a todas las líneas. La secuencia \\ dio como resultado un único \. Como las comillas de cierre están solas en su línea, el bloque termina con un salto de línea: por eso se muestra con [IO.print], que no pasa a la línea siguiente;
  • líneas 44–45: un bloque de texto en el que las comillas de cierre siguen al texto; no termina con un salto de línea. El método [formatted] reemplaza %s y %d por los valores de [name] y [age]: esta es la forma en Java de insertar valores en un texto.

3.3.3. Declaración de datos

3.3.3.1. Función de las declaraciones

Un programa manipula datos caracterizados por un nombre y un tipo. Estos datos se almacenan en memoria. Cuando se compila el programa, el compilador asigna a cada dato una ubicación de memoria caracterizada por una dirección y un tamaño. Lo hace a partir de las declaraciones realizadas por el programador. Además, estas declaraciones permiten al compilador detectar errores de programación. Así, la operación [x = x * 2;] se señalará como un error si [x] es una cadena.

3.3.3.2. Declaración de constantes

En Java, una constante es una variable declarada con la palabra clave [final]: solo se le puede asignar un valor una vez. La sintaxis es la siguiente:

final type name = value;

Una constante utilizada en todo el programa se declara fuera de los métodos, como un campo [static final] de la clase. Por ejemplo:

static final double VAT_RATE = 0.2;

¿Por qué declarar constantes?

  • El programa es más fácil de leer si a la constante se le da un nombre significativo;
  • es más fácil modificar el programa si hay que cambiar la “constante”. Así, si la tasa de IVA cambia a 0.25, la única modificación necesaria será en la instrucción que define su valor: [static final double VAT_RATE = 0.25;]. Si se hubiera usado 0.2 explícitamente en el programa, habría que modificar numerosas instrucciones.

Por convención, en Java, el nombre de una constante [static final] se escribe en mayúsculas, con las palabras separadas por el carácter _: [VAT_RATE], [MAX_VALUE]. Una variable local también puede declararse como [final]; en ese caso, conserva un nombre normal. La palabra [const] está reservada en Java, pero no se utiliza.

3.3.3.3. Declaración de variables

Una variable se identifica por un nombre y se asocia a un tipo de datos. Java distingue entre mayúsculas y minúsculas: las variables [END] y [end] son diferentes. Por convención, el nombre de una variable comienza con minúscula, y cada palabra siguiente comienza con mayúscula: [priceExclTax], [nbChildren].

Las variables pueden inicializarse al declararlas. La sintaxis para declarar una o varias variables es:

type variable1 = value1, variable2 = value2, ...;

donde [type] es un tipo predefinido o un tipo definido por el programador. La inicialización es opcional; sin embargo, Java no permite usar una variable local a la que aún no se le ha asignado un valor (mensaje de error [variable x might not have been initialized]).

Desde Java 10, también se puede omitir el tipo de una variable local usando la palabra clave [var] en lugar del tipo:

var variable1 = value1;

El término [var] no significa que la variable no tenga un tipo específico: tiene el tipo del valor que se le asigna, determinado por el compilador. Aquí la inicialización es obligatoria para que el compilador pueda inferir el tipo. [var] solo puede usarse para variables locales (no para campos ni parámetros de métodos). Se usa cuando el tipo es evidente a partir del valor, en particular cuando el nombre de la variable es largo.

El programa [Basics05.java] es el siguiente:

// constantes y variables
// una constante de clase: static final, nombre en mayúsculas
static final double VAT_RATE = 0.2;

void main() {
    // una constante local: final
    final String currency = "euros";
    double priceExclTax = 100;
    IO.println("Price incl. tax: " + priceExclTax * (1 + VAT_RATE) + " " + currency);

    // un dato con tipo explícito
    int i = 2;
    IO.println("Type of int i=2: " + typeName(i));
    // dato con tipo implícito mediante var (Java 10)
    var j = 3;
    IO.println("Type of var j=3: " + typeName(j));
    var today = LocalDateTime.now();
    IO.println("Type of var today: " + typeName(today));
    var x = 3.5;
    var y = 3.5F;
    var z = 10L;
    var name = "dupont";
    IO.println("x : " + typeName(x) + ", y : " + typeName(y));
    IO.println("z : " + typeName(z) + ", name : " + typeName(name));
    // varias variables declaradas en la misma línea
    int a = 1, b, c = 3;
    b = a + c;
    IO.println("a=" + a + ", b=" + b + ", c=" + c);
}

// devuelve el nombre corto y el nombre completo de la clase del objeto recibido
String typeName(Object o) {
    return o.getClass().getSimpleName() + "," + o.getClass().getName();
}

Resultados:

1
2
3
4
5
6
7
8
> java Basics05.java
Price incl. tax: 120.0 euros
Type of int i=2: Integer,java.lang.Integer
Type of var j=3: Integer,java.lang.Integer
Type of var today: LocalDateTime,java.time.LocalDateTime
x : Double,java.lang.Double, y : Float,java.lang.Float
z : Long,java.lang.Long, name : String,java.lang.String
a=1, b=4, c=3

Comentarios:

  • línea 3: una constante de clase. En un archivo compacto, una variable declarada fuera de los métodos es un campo de la clase implícita;
  • línea 7: una constante local;
  • línea 9: el resultado es un [double], que se muestra con al menos un decimal: 120.0;
  • línea 12: un valor con tipo explícito;
  • línea 13: [getSimpleName()] (línea 33) es el nombre corto de la clase; [getName()] es su nombre completo. Como en el programa anterior, [int] se envuelve en un [Integer] para pasarlo a [typeName];
  • línea 15: un valor con tipo implícito. Como 3 es de tipo [int], [j] será de tipo [int]. La salida muestra [Integer] por la misma razón que en la línea 13;
  • línea 17: como [LocalDateTime.now()] (la fecha y hora actuales) es de tipo [LocalDateTime], [today] será de tipo [LocalDateTime];
  • líneas 19–22: el tipo inferido depende de cómo se escribe el literal: 3.5 es un [double], 3.5F es un [float] y 10L es un [long];
  • línea 26: tres variables declaradas en la misma línea; solo [a] y [c] se inicializan. A [b] se le asigna un valor en la línea siguiente.

Una variable con tipo implícito mediante [var] no puede cambiar de tipo después. Así, tras la línea 17, la instrucción [today = "today";] es rechazada por el compilador:

error: incompatible types: String cannot be converted to LocalDateTime

3.3.4. Valores ausentes: null, clases envoltorio y Optional

Una variable de un tipo primitivo, como [int], siempre contiene un valor. A veces es útil poder expresar la ausencia de un valor: una edad desconocida, un campo vacío en una base de datos. En esos casos se usa la clase envoltorio: una variable de tipo [Integer] es una referencia, que puede ser [null], es decir, “ningún objeto”.

Cualquier variable de un tipo de referencia puede, de hecho, tener el valor [null]: en ese caso, no referencia ningún objeto. Intentar usar un miembro de esa variable, por ejemplo su método [length()], provoca un error en tiempo de ejecución, una [NullPointerException]: es el error más común en Java. Desde Java 15, el mensaje de error indica exactamente qué expresión se evaluó como [null]. El compilador de Java no distingue entre una referencia que puede valer [null] y una que no; las anotaciones como las del proyecto JSpecify ([@Nullable], [@NonNull]), que utilizan las herramientas de análisis, ayudan a paliar esta deficiencia, pero no las usaremos.

Para indicar que un método puede no devolver nada, Java 8 agregó la clase [Optional<T>]: un objeto [Optional<String>] es una “caja” que contiene una cadena o está vacía. Se crea con [Optional.of(value)], [Optional.empty()], o [Optional.ofNullable(valueOrNull)]; se consulta con [isPresent()], [isEmpty()] (Java 11), [get()], [orElse(defaultValue)]... Las clases [OptionalInt], [OptionalLong], y [OptionalDouble] cumplen el mismo propósito para los tipos primitivos.

Nos encontraremos con el valor [null] desde los primeros ejemplos, porque el método [IO.readln()], que lee una línea escrita en el teclado, devuelve [null] cuando ya no queda nada por leer (fin del flujo de entrada). El programa [Basics06.java] es el siguiente:

// valores ausentes: null, clases envoltorio y Optional
void main() {
    // un int siempre tiene un valor; un Integer puede ser null
    Integer age = null;
    IO.println("age is null: " + (age == null));
    // encapsulamiento automático (autoboxing): el int 23 se convierte en un Integer
    age = 23;
    IO.println("age=" + age);
    // desencapsulamiento automático (unboxing): el Integer se convierte en un int
    int n = age;
    IO.println("n=" + n);
    // desencapsular un Integer que es null lanza una NullPointerException
    Integer unknown = null;
    try {
        int m = unknown;
        IO.println("m=" + m);
    } catch (NullPointerException e) {
        IO.println("Unboxing null: " + e.getClass().getName());
    }

    // una referencia a un objeto puede ser null: entonces no designa ningún objeto
    String firstName = null;
    IO.println("firstName is null: " + (firstName == null));
    // Optional (Java 8): una caja que contiene un valor o está vacía
    Optional<String> name = Optional.of("dupont");
    Optional<String> nickname = Optional.empty();
    IO.println("name present: " + name.isPresent() + ", name has " + name.get().length() + " characters");
    IO.println("nickname present: " + nickname.isPresent() + ", nickname: " + nickname.orElse("none"));

    // IO.readln (Java 25) devuelve null si el flujo de entrada está agotado
    String line = IO.readln("Type a line: ");
    if (line == null) {
        IO.println();
        IO.println("No line: the input stream is closed");
    } else {
        IO.println("You typed [" + line + "]: " + line.length() + " character(s)");
    }
}

Resultados al escribir desde el teclado:

> java Basics06.java
age is null: true
age=23
n=23
Unboxing null: java.lang.NullPointerException
firstName is null: true
name present: true, name has 6 characters
nickname present: false, nickname: none
Type a line: hello
You typed [hello]: 5 character(s)

Resultados cuando el usuario presiona Ctrl-D (Ctrl-Z seguido de Enter en Windows), lo que cierra el flujo de entrada:

> java Basics06.java
age is null: true
age=23
n=23
Unboxing null: java.lang.NullPointerException
firstName is null: true
name present: true, name has 6 characters
nickname present: false, nickname: none
Type a line: 
No line: the input stream is closed

Comentarios:

  • línea 4: [age] no referencia ningún objeto;
  • línea 7: el [int] 23 se envuelve automáticamente: el compilador generó [age = Integer.valueOf(23);] por nosotros;
  • línea 10: el [Integer] se desenvuelve automáticamente: el compilador escribió [int n = age.intValue();];
  • líneas 13–19: desenvolver un *[Integer]* que es igual a [null] equivale a llamar a *[intValue()] sobre una referencia nula: se lanza una *[NullPointerException] . La trampa es aún más insidiosa porque no se ve ninguna llamada a un método en la línea 15. La estructura [try / catch], que intercepta el error, se presenta más adelante; aquí se muestra el nombre completo de la clase de la excepción;
  • línea 22: una cadena que no referencia ningún objeto;
  • línea 25: un [Optional] que contiene la cadena "dupont". El método [get()] (línea 27) devuelve su contenido; aplicado a un [Optional] vacío, lanzaría una excepción [NoSuchElementException];
  • línea 26: un [Optional] vacío;
  • línea 28: [orElse] devuelve el contenido del [Optional], o el valor de reemplazo pasado como parámetro si está vacío;
  • línea 31: [IO.readln(prompt)] (Java 25) muestra el mensaje de entrada sin pasar a la línea siguiente y luego lee la línea escrita en el teclado. Devuelve [null] si el flujo de entrada está cerrado;
  • línea 32: se comprueba el valor [null];
  • línea 36: en la rama [else], [line] no es igual a [null]: [line.length()] puede usarse sin riesgo.

3.3.5. Conversiones entre números y cadenas

Conversión
Método
número -> cadena
[String.valueOf(number)], [Integer.toString(number)], ["" + number], o un formato como [String.format("%d", number)]
cadena -> int
[Integer.parseInt(string)]
cadena -> long
[Long.parseLong(string)]
cadena -> double
[Double.parseDouble(string)]
cadena -> float
[Float.parseFloat(string)]
cadena -> BigDecimal
[new BigDecimal(string)]
cadena -> boolean
[Boolean.parseBoolean(string)]

La conversión de una cadena a un número puede fallar si la cadena no representa un número válido. El método de conversión genera entonces un error llamado excepción, en este caso de tipo [NumberFormatException], que termina el programa si no se maneja. Este error puede manejarse con la siguiente cláusula [try / catch]:

1
2
3
4
5
6
try {
    call the method likely to throw the exception
} catch (NumberFormatException e) {
    handle the exception e
}
next statement

Si el método no genera una excepción, el programa pasa a la siguiente instrucción; de lo contrario, entra en el cuerpo de la cláusula [catch] y luego pasa a la siguiente instrucción. Volveremos sobre el manejo de excepciones en la sección dedicada a este tema.

Los métodos [parseInt], [parseDouble]... aceptan un signo + o - inicial, pero no espacios ni separadores de miles: use el método [trim()] de la clase [String] para eliminar los espacios iniciales y finales de una entrada antes de convertirla. La biblioteca de Java no tiene un método que intente una conversión y devuelva un indicador de éxito en lugar de lanzar una excepción; es fácil escribir uno que devuelva un [OptionalInt] vacío en caso de fallo: eso es lo que hace el método [tryParseInt] del siguiente programa.

El programa [Basics07.java] muestra algunas técnicas para convertir entre números y cadenas. El método [display] de ese programa imprime en pantalla el valor de su parámetro:

// conversiones entre números y cadenas de caracteres
void main() {
    // datos
    final int i = 10;
    final long l = 100000;
    final float f = 45.78F;
    double d = -14.98;

    // número -> cadena
    display(String.valueOf(i));
    display(Long.toString(l));
    display(String.valueOf(f));
    display("" + d);

    // booleano -> cadena
    final boolean b = false;
    display(String.valueOf(b));

    // cadena -> int
    int i1 = Integer.parseInt("10");
    display(String.valueOf(i1));
    try {
        i1 = Integer.parseInt("10.67");
        display(String.valueOf(i1));
    } catch (NumberFormatException e) {
        display("Error: " + e.getMessage());
    }

    // cadena -> long
    long l1 = Long.parseLong("100");
    display(String.valueOf(l1));
    try {
        l1 = Long.parseLong("10.675");
        display(String.valueOf(l1));
    } catch (NumberFormatException e) {
        display("Error: " + e.getMessage());
    }

    // cadena -> double: el separador decimal es siempre el punto
    double d1 = Double.parseDouble("100.87");
    display(String.valueOf(d1));
    try {
        d1 = Double.parseDouble("abcd");
        display(String.valueOf(d1));
    } catch (NumberFormatException e) {
        display("Error: " + e.getMessage());
    }

    // cadena -> float
    float f1 = Float.parseFloat("100.87");
    display(String.valueOf(f1));
    try {
        f1 = Float.parseFloat("100,87");
        display(String.valueOf(f1));
    } catch (NumberFormatException e) {
        display("Error: " + e.getMessage());
    }

    // cadena -> BigDecimal
    BigDecimal m1 = new BigDecimal("100.87");
    display(m1.toString());

    // una conversión sin excepción: nuestro método devuelve un OptionalInt
    OptionalInt i2 = tryParseInt("123");
    if (i2.isPresent()) {
        display("tryParseInt(\"123\") succeeded: " + i2.getAsInt());
    }
    OptionalInt i3 = tryParseInt("12x");
    if (i3.isEmpty()) {
        display("tryParseInt(\"12x\") failed");
    }

    // el idioma del usuario (la "configuración regional") solo importa en los formatos
    display("Current locale: " + Locale.getDefault().toLanguageTag());
    display(String.format("%.2f", d1));
    display(String.format(Locale.ROOT, "%.2f", d1));
    // lectura de un número escrito a la francesa: la clase NumberFormat
    try {
        Number number = NumberFormat.getInstance(Locale.FRANCE).parse("100,87");
        display("NumberFormat : " + number.doubleValue());
    } catch (ParseException e) {
        display("Error: " + e.getMessage());
    }
}

// un método que muestra su parámetro
void display(String s) {
    IO.println("S=" + s);
}

// convierte una cadena en un entero sin lanzar una excepción
OptionalInt tryParseInt(String text) {
    try {
        return OptionalInt.of(Integer.parseInt(text));
    } catch (NumberFormatException _) {
        return OptionalInt.empty();
    }
}

Resultados:

> java Basics07.java
S=10
S=100000
S=45.78
S=-14.98
S=false
S=10
S=Error: For input string: "10.67"
S=100
S=Error: For input string: "10.675"
S=100.87
S=Error: For input string: "abcd"
S=100.87
S=Error: For input string: "100,87"
S=100.87
S=tryParseInt("123") succeeded: 123
S=tryParseInt("12x") failed
S=Current locale: fr-FR
S=100,87
S=100.87
S=NumberFormat : 100.87

Comentarios:

  • líneas 4–7: los datos que se van a convertir;
  • líneas 10–13: cuatro maneras de convertir un número en cadena. La última concatena una cadena vacía y el número;
  • línea 17: se muestra un valor booleano:[true] o [false];
  • líneas 22–27: maneja la excepción que [Integer.parseInt] puede lanzar. [e.getMessage()] es el mensaje de error asociado con la excepción [e]. Los mensajes de excepción del JDK están en inglés: no se traducen;
  • línea 40: [Double.parseDouble] siempre espera un punto decimal, sin importar el idioma del usuario: la cadena “100.87” se interpreta de la misma manera en todas las máquinas. Esta es la forma correcta de leer números desde archivos o en intercambios entre programas;
  • línea 53: en consecuencia, se rechaza la coma decimal;
  • línea 60: conversión de una cadena mediante [BigDecimal]; este método también espera un punto decimal;
  • líneas 64–71: el método [tryParseInt] (líneas 92–98) devuelve un [OptionalInt] que contiene el entero si la conversión tuvo éxito y está vacío en caso contrario. [getAsInt()] devuelve el entero contenido;
  • línea 74: [Locale.getDefault()] devuelve la configuración regional (locale) del programa, es decir, el idioma y el país del usuario, según se determinan a partir de la configuración del sistema: en este caso, fr-FR;
  • línea 75: un formato usa la configuración regional actual: el número de punto flotante se escribe con coma decimal;
  • línea 76: [Locale.ROOT] es una configuración regional neutra que usa el punto como separador decimal, sin importar la máquina. Se utiliza para escribir números con formato en archivos o en intercambios entre programas, que no deben depender del idioma del usuario;
  • línea 79: para leer un número escrito según las convenciones francesas, se usa un objeto [NumberFormat] (paquete [java.text]) obtenido para la configuración regional [Locale.FRANCE]. Su método [parse] devuelve un objeto [Number] y puede lanzar una excepción [ParseException]. Se trata de una excepción verificada (checked): el compilador exige que se maneje, lo cual explicaremos en la sección sobre excepciones;
  • líneas 87–89: un método del archivo compacto. Los métodos pueden escribirse en cualquier orden, antes o después de [main];
  • líneas 92–98: el método [tryParseInt]. La variable de la cláusula [catch] se llama _: desde Java 22, este carácter designa una variable anónima, que se declara porque la sintaxis lo exige pero en realidad no se usa.

Tenga en cuenta que los métodos [parseXXX] y [toString] ignoran el idioma del usuario (punto decimal), mientras que los formatos y la clase [NumberFormat] sí lo respetan. Un programa que lee números siempre debe saber qué convenciones se usaron para escribirlos.

3.3.6. Arreglos de datos

Un arreglo de Java es un objeto que permite agrupar datos del mismo tipo bajo un único identificador. Se declara de la siguiente manera:

Type[] array = new Type[n];

[n] es el número de elementos de datos que puede contener el arreglo. La sintaxis [array[i]] hace referencia al elemento de datos número i, donde i pertenece al intervalo [0, n-1]. Cualquier referencia al elemento [array[i]] donde i no esté en el rango [0, n-1] provoca una excepción [ArrayIndexOutOfBoundsException]. Al crearse, a cada elemento del arreglo se le asigna el valor predeterminado de su tipo: 0 para los números, [false] para los booleanos y [null] para los tipos de referencia. Un arreglo puede inicializarse al mismo tiempo que se declara:

    int[] integers = new int[]{0, 10, 20, 30};

o, de forma más simple, en una declaración:

    int[] values = {0, 10, 20, 30, 40};

Los arreglos tienen un campo [length] (sin paréntesis) que representa el número de elementos. Un arreglo no puede cambiar de tamaño después de crearse: para una colección que crece, se usa una lista (Capítulo 5). También se encuentra la notación [int integers[]], heredada del lenguaje C: se acepta, pero no se recomienda.

Java no tiene verdaderos arreglos de dos dimensiones: un arreglo con dos índices es un arreglo de arreglos. La declaración

Type[][] array = new Type[n][m];

crea un arreglo de [n] elementos, cada uno de los cuales es una referencia a un arreglo de [m] elementos: [n] filas y [m] columnas. La sintaxis [array[i][j]] hace referencia al elemento j de la fila i. [array.length] es el número de filas, y [array[i].length] es el número de elementos de la fila i. El arreglo también puede inicializarse al mismo tiempo que se declara:

    double[][] reals = {{0.5, 1.7}, {8.4, -6}};

Como cada fila es un arreglo independiente, las filas pueden tener longitudes distintas (esto se conoce como un arreglo "escalonado"). La declaración

Type[][] array = new Type[n][];

crea un arreglo de n elementos, cada uno de los cuales es una referencia a un arreglo unidimensional. Estas referencias no se inicializan con la declaración anterior: tienen el valor [null].

Java no ofrece índices contados desde el final del arreglo ni una notación para extraer un rango de elementos. El último elemento se escribe como [array[array.length - 1]], y el método [Arrays.copyOfRange(array, start, end)] devuelve un nuevo arreglo formado por los elementos con índices desde [start] (inclusive) hasta [end] (exclusive). La clase [java.util.Arrays] ofrece muchos otros métodos de utilidad: [toString], [deepToString], [sort], [fill], [equals], [copyOf]... Las listas, que son más flexibles, tienen los métodos [getFirst()] y [getLast()] desde Java 21.

El programa [Basics08.java] combina estos diferentes arreglos:

// arreglos
void main() {
    // un arreglo unidimensional inicializado
    int[] integers = new int[]{0, 10, 20, 30};
    for (int i = 0; i < integers.length; i++) {
        IO.println("integers[" + i + "]=" + integers[i]);
    }

    // un arreglo bidimensional: un arreglo de arreglos de la misma longitud
    double[][] reals = {{0.5, 1.7}, {8.4, -6}};
    for (int i = 0; i < reals.length; i++) {
        for (int j = 0; j < reals[i].length; j++) {
            IO.println("reals[" + i + "][" + j + "]=" + reals[i][j]);
        }
    }
    IO.println("reals=" + Arrays.deepToString(reals));

    // un arreglo de arreglos de longitudes diferentes (arreglo irregular)
    String[][] names = new String[3][];
    for (int i = 0; i < names.length; i++) {
        names[i] = new String[i + 1];
    }
    // inicialización
    for (int i = 0; i < names.length; i++) {
        for (int j = 0; j < names[i].length; j++) {
            names[i][j] = "name" + i + j;
        }
    }
    // visualización
    for (int i = 0; i < names.length; i++) {
        for (int j = 0; j < names[i].length; j++) {
            IO.println("names[" + i + "][" + j + "]=" + names[i][j]);
        }
    }

    // un arreglo creado sin valores iniciales: elementos con el valor por defecto del tipo
    boolean[] flags = new boolean[3];
    String[] strings = new String[2];
    IO.println("flags[0]=" + flags[0] + ", strings[0] is null: " + (strings[0] == null));

    // la forma abreviada de inicialización
    int[] values = {0, 10, 20, 30, 40};
    // Arrays.toString construye una cadena con los elementos del arreglo
    IO.println("values=" + Arrays.toString(values));
    // el último y el penúltimo elemento
    IO.println("last=" + values[values.length - 1] + ", second-to-last=" + values[values.length - 2]);
    // parte del arreglo: los elementos en los índices 1 y 2 (el límite final se excluye)
    int[] slice = Arrays.copyOfRange(values, 1, 3);
    IO.println("copyOfRange(values, 1, 3)=" + Arrays.toString(slice));
    int[] end = Arrays.copyOfRange(values, 2, values.length);
    IO.println("copyOfRange(values, 2, length)=" + Arrays.toString(end));
    // el fragmento es una copia: el arreglo original no se modifica
    slice[0] = 100;
    IO.println("slice[0]=" + slice[0] + ", values[1]=" + values[1]);
    // una lista (capítulo 5) ofrece getFirst y getLast (Java 21)
    List<String> friends = List.of("paul", "hélène", "jacques");
    IO.println("first friend=" + friends.getFirst() + ", last friend=" + friends.getLast());
}

Resultados:

> java Basics08.java
integers[0]=0
integers[1]=10
integers[2]=20
integers[3]=30
reals[0][0]=0.5
reals[0][1]=1.7
reals[1][0]=8.4
reals[1][1]=-6.0
reals=[[0.5, 1.7], [8.4, -6.0]]
names[0][0]=name00
names[1][0]=name10
names[1][1]=name11
names[2][0]=name20
names[2][1]=name21
names[2][2]=name22
flags[0]=false, strings[0] is null: true
values=[0, 10, 20, 30, 40]
last=40, second-to-last=30
copyOfRange(values, 1, 3)=[10, 20]
copyOfRange(values, 2, length)=[20, 30, 40]
slice[0]=100, values[1]=10
first friend=paul, last friend=jacques

Comentarios:

  • línea 4: se inicializa un arreglo unidimensional;
  • línea 5: un bucle [for] recorre los índices de 0 a [integers.length - 1]. El bucle [for] se presenta más adelante;
  • línea 10: un arreglo bidimensional (2 filas, 2 columnas). El entero -6 se convierte en el número de punto flotante -6.0;
  • líneas 11–12: [reals.length] es el número de filas, y [reals[i].length] es el número de columnas de la fila i;
  • línea 16: [Arrays.deepToString] muestra un arreglo de arreglos;
  • línea 19: un arreglo [names] de 3 elementos. Cada elemento es una referencia a un arreglo de tipo [String[]], actualmente [null];
  • línea 21: se inicializan los 3 elementos del arreglo [names] . [names[i]] ahora hace referencia a un arreglo de i+1 cadenas;
  • línea 26: [names[i][j]] es el elemento j del arreglo al que hace referencia [names[i]]. La expresión "name" + i + j se evalúa de izquierda a derecha: "name" + i produce una cadena, a la cual se concatena j;
  • líneas 37–38: arreglos creados sin valores iniciales: sus elementos tienen el valor predeterminado de su tipo;
  • línea 42: la forma abreviada de inicialización;
  • línea 44: el método [Arrays.toString] construye una cadena con los elementos del arreglo. Mostrar el arreglo directamente ([IO.println(values)]) produciría un texto como [I@6328d34a (el tipo del arreglo y un código numérico), en lugar de su contenido;
  • línea 46: el último y el penúltimo elemento;
  • línea 48: los elementos de los índices 1 y 2;
  • línea 50: los elementos desde el índice 2 hasta el final;
  • líneas 53–54: [copyOfRange] crea una copia: modificar [slice] no modifica [values];
  • líneas 56–57: una lista no modificable creada con [List.of], y sus métodos [getFirst()] y [getLast()] (Java 21).

3.4. Instrucciones básicas de Java

Hay dos tipos:

  • instrucciones básicas ejecutadas por la computadora;
  • instrucciones que controlan el flujo del programa.

Las instrucciones básicas se entienden mejor al considerar la estructura de una microcomputadora y sus periféricos:

Image

  • 1: lectura de información desde el teclado;
  • 2: procesamiento de la información;
  • 3: escritura de información en la pantalla.

3.4.1. Escritura en la pantalla

Hay varias instrucciones para escribir en la pantalla:

1
2
3
System.out.println(expression);
System.err.println(expression);
IO.println(expression);

donde [expression] es cualquier dato que pueda convertirse en una cadena de caracteres para mostrarse en la pantalla. Todos los objetos Java tienen un método [toString()] que se usa para realizar esta conversión; los valores de tipos primitivos se convierten mediante [String.valueOf]. El método [print] hace lo mismo que [println] sin saltar a la línea siguiente, y el método [printf(format, value1, ...)] escribe el resultado con un formato específico.

La clase [System] da acceso a dos flujos de escritura, sus campos estáticos [out] y [err], de tipo [PrintStream]:

  • [System.out.println()] escribe en el flujo [out], la salida estándar, que normalmente está asociada con la pantalla;
  • [System.err.println()] escribe en el flujo [err], la salida de errores, que normalmente también está asociada con la pantalla.

La clase [IO] (Java 25) ofrece los métodos [println] y [print], que escriben en [System.out]. Los flujos [out] y [err] pueden redirigirse a archivos en tiempo de ejecución, como veremos en breve.

3.4.2. Lectura de datos ingresados desde el teclado

El flujo de datos del teclado se identifica mediante el campo [System.in], de tipo [InputStream]. Es un flujo de bytes, que no resulta muy cómodo de usar directamente. Durante mucho tiempo, para leer una línea de texto era necesario envolverlo en otros objetos:

BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));
String line = keyboard.readLine();

o utilizar la clase [Scanner] (Java 5). A partir de Java 25, la clase [IO] ofrece un método mucho más simple, [readln], en dos formas:

String line = IO.readln();
String line = IO.readln("prompt: ");

La línea escrita en el teclado, sin el carácter de fin de línea, se almacena en la variable [line] y luego puede ser procesada por el programa. La segunda forma muestra primero un mensaje de solicitud, sin saltar a la línea siguiente. Como hemos visto, [readln] devuelve [null] cuando el flujo de entrada se agota. El flujo [System.in] puede redirigirse a un archivo, igual que los flujos [out] y [err]. Por último, observe la clase [Console], obtenida a partir de [System.console()], cuyo método [readPassword] lee una contraseña sin mostrarla.

3.4.3. Ejemplo de entrada/salida

El programa [Basics09.java] ilustra operaciones de entrada/salida con el teclado y la pantalla:

// entrada-salida por teclado / pantalla
void main() {
    // escritura en el flujo System.out
    Object obj = new Object();
    System.out.println(obj);

    // escritura en el flujo System.err
    int i = 10;
    System.err.println("i=" + i);
    System.err.printf("i=%d%n", i);

    // lectura de una línea escrita en el teclado, tras mostrar un mensaje
    String line = IO.readln("Type a line: ");
    IO.println("line=" + line);
}

Resultados:

1
2
3
4
5
6
> java Basics09.java
java.lang.Object@32464a14
i=10
i=10
Type a line: here I am
line=here I am

Comentarios:

  • línea 4: [obj] es una referencia a un objeto;
  • línea 5: se muestra [obj] en la pantalla. Se llama al método [obj.toString()] para obtener el texto que se mostrará;
  • línea 9: se escriben datos en el flujo [err];
  • línea 10: lo mismo, pero con un formato. El primer parámetro, "i=%d%n,", es el formato de visualización; los demás parámetros son los valores que se mostrarán: %d se reemplaza por el valor de [i], y %n por el carácter de fin de línea del sistema (\r\n en Windows, \n en Linux y macOS);
  • línea 13: se muestra un mensaje de solicitud sin saltar a la línea siguiente y luego se lee la línea escrita en el teclado;
  • línea 14: si [line] fuera igual a [null], la concatenación produciría la cadena "null".

En los resultados:

  • línea 2: la salida generada por la línea 5 del código. El método [toString()] de la clase [Object] devuelve el nombre completo de la clase del objeto, seguido del carácter @ y un código numérico hexadecimal (su “código hash”), que puede variar de una ejecución o máquina a otra. Las clases suelen sobrescribir este método para mostrar algo más útil, como haremos en el Capítulo 4;
  • líneas 3–4: las dos escrituras en el flujo [err] aparecen en la pantalla igual que las del flujo [out].

3.4.4. Redirección de entrada/salida

Windows, Linux y macOS reconocen tres dispositivos estándar:

  • el dispositivo de entrada estándar, que por defecto corresponde al teclado y está numerado como 0;
  • el dispositivo de salida estándar, que por defecto corresponde a la pantalla y está numerado como 1;
  • el dispositivo de error estándar, que por defecto corresponde a la pantalla y está numerado como 2.

En Java, el flujo de escritura [System.out] escribe en el dispositivo 1, el flujo de escritura [System.err] escribe en el dispositivo 2, y el flujo de lectura [System.in] lee datos del dispositivo 0.

Cuando se ejecuta un programa en una ventana de comandos, se puede especificar qué dispositivos serán el 0, el 1 y el 2 para el programa que se ejecuta. Después de los argumentos del programa, se pueden redirigir los dispositivos estándar de entrada y salida a archivos:

Redirección
Significado
0<in.txt o <in.txt
El flujo de entrada estándar n.º 0 se redirige al archivo in.txt. En el programa, el flujo [System.in] leerá por tanto sus datos del archivo in.txt
1>out.txt o >out.txt
redirige la salida n.º 1 al archivo out.txt. En el programa, el flujo [System.out] escribirá por tanto sus datos en el archivo out.txt
1>>out.txt o >>out.txt
Igual que lo anterior, pero los datos escritos se agregan al contenido actual del archivo out.txt
2>err.txt
redirige la salida n.º 2 al archivo err.txt. En el programa, el flujo [System.err] escribirá por tanto sus datos en el archivo err.txt
2>>err.txt
Igual que lo anterior, pero los datos escritos se agregan al contenido actual del archivo err.txt
1>out.txt 2>err.txt
Los dispositivos 1 y 2 se redirigen ambos a archivos

Observe que, para redirigir a archivos los flujos de entrada/salida de un programa, no es necesario modificarlo: el sistema operativo determina la naturaleza de los dispositivos 0, 1 y 2. Considere el siguiente programa, [Basics10.java]:

1
2
3
4
5
6
7
8
9
// redirecciones de los flujos de entrada-salida
void main() {
    // lectura del flujo System.in
    String data = IO.readln();
    // escritura del flujo System.out
    System.out.println("writing to the out stream: " + data);
    // escritura del flujo System.err
    System.err.println("writing to the err stream: " + data);
}

Las redirecciones se aplican al programa lanzado por el comando [java]. Esta es una sesión en una terminal de Linux (bash):

> echo test > in.txt
> cat in.txt
test
> java Basics10.java < in.txt > out.txt 2> err.txt
> cat out.txt
writing to the out stream: test
> cat err.txt
writing to the err stream: test
> java Basics10.java < in.txt 2> err.txt
writing to the out stream: test
> java Basics10.java < in.txt > out.txt
writing to the err stream: test

Comentarios:

  • línea 1: se coloca la cadena "test" en el archivo in.txt;
  • línea 2: se muestra el contenido del archivo in.txt para verificarlo;
  • línea 4: se ejecuta el programa. El flujo [System.in] se redirige al archivo in.txt, el flujo [System.out] al archivo out.txt y el flujo [System.err] al archivo err.txt. La ejecución no produce ninguna salida;
  • líneas 5–6: el contenido del archivo out.txt muestra que se leyó el archivo in.txt y que la escritura en el flujo [out] se redirigió a out.txt;
  • líneas 7–8: verificación similar para el archivo err.txt;
  • líneas 9–10: solo el flujo [err] se redirige: la pantalla muestra únicamente la operación de escritura en el flujo [out];
  • líneas 11–12: solo el flujo [out] se redirige: la pantalla muestra únicamente la operación de escritura en el flujo [err].

Es evidente que los flujos [out] y [err] no escriben en los mismos dispositivos, ya que pudieron redirigirse por separado. El flujo [err] está destinado a los mensajes de error: esto permite redirigir la salida de un programa a un archivo y, al mismo tiempo, seguir viendo sus mensajes de error en la pantalla.

Los operadores >, >> y 2> se escriben igual en el símbolo del sistema de Windows ([cmd]), en PowerShell y en bash. El operador < es reconocido por [cmd] y bash, pero no por PowerShell, que lo reserva para uso futuro: en PowerShell, se usa una canalización (|) para enviar un archivo a la entrada estándar de un programa. Los siguientes comandos, que se proporcionan con fines ilustrativos (no se ejecutaron para este curso), hacen en Windows lo que hace la sesión de bash anterior:

rem Windows command prompt (cmd)
echo test>in.txt
java Basics10.java <in.txt >out.txt 2>err.txt
type out.txt
type err.txt

# PowerShell
"test" > in.txt
Get-Content in.txt | java Basics10.java > out.txt 2> err.txt
Get-Content out.txt
Get-Content err.txt

3.4.5. Asignación del valor de una expresión a una variable

Aquí nos interesa la operación [variable = expression;]. La expresión puede ser aritmética, relacional, booleana, de cadena, etc.

3.4.5.1. Interpretación de la operación de asignación

La operación [variable = expression;] es en sí misma una expresión que se evalúa de la siguiente manera:

  • se evalúa el lado derecho de la asignación: el resultado es un valor V;
  • el valor V se asigna a la variable;
  • el valor V es también el valor de la asignación, vista esta vez como una expresión.

Por eso la operación [V1 = V2 = expression] es válida. Como el operador = se evalúa de derecha a izquierda, obtenemos [V1 = (V2 = expression)]. Se evalúa la expresión [V2 = expression] y su valor es V. Su evaluación provocó que V se asignara a V2. A continuación se evalúa el siguiente operador = como [V1 = V]. El valor de esta expresión sigue siendo V; su evaluación hace que V se asigne a V1. Así, la operación [V1 = V2 = expression] es una expresión cuya evaluación:

  • hace que el valor de [expression] se asigne a las variables V1 y V2;
  • devuelve el valor de [expression].

Esto puede generalizarse a una expresión de la forma [V1 = V2 = ... = Vn = expression].

3.4.5.2. Expresiones aritméticas

Los operadores utilizados en las expresiones aritméticas son los siguientes:

Operador
Descripción
+
suma
-
resta
*
multiplicación
/
división: el resultado es el cociente exacto si al menos uno de los operandos es un número real. Si ambos operandos son enteros, el resultado es el cociente entero. Así, 5/2 es igual a 2 y 5.0/2 es igual a 2.5
%
resto de la división (módulo), sea cual sea la naturaleza de los operandos. El resto tiene el mismo signo que el dividendo: -5 % 2 es igual a -1. El método [Math.floorMod(-5, 2)] devuelve el resto en el sentido matemático, con el mismo signo que el divisor: 1

Hay diversas funciones matemáticas. Estas son algunas:

Función
Descripción
[double sqrt(double x)]
raíz cuadrada
[double cos(double x)], [sin], [tan]
coseno, seno, tangente (ángulo en radianes)
[double pow(double x, double y)]
x elevado a la potencia y
[double exp(double x)]
exponencial
[double log(double x)], [log10]
logaritmo natural, decimal
[abs(x)], [max(x, y)], [min(x, y)]
valor absoluto, máximo, mínimo (para los tipos int, long, float y double)
[double floor(double x)], [ceil]
parte entera inferior, parte entera superior
[long round(double x)], [double rint(double x)]
redondeado al entero más cercano
[clamp(value, min, max)]
valor ajustado al intervalo [min, max] (Java 21)
[Math.PI], [Math.E]
las constantes π y e

Todas estas funciones son métodos estáticos de una clase de Java llamada [Math] (paquete [java.lang]). Al utilizarlas, debe anteponerles el nombre de la clase en la que están definidas. Así, se escribiría:

    double x, y = 4;
    x = Math.sqrt(y);

La descripción completa de la clase [Math] se encuentra en la documentación en línea de Java, docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/Math.html.

Los números reales de tipo [double] se codifican en binario: la mayoría de los números decimales, como 0.1, solo tienen un valor aproximado en esta representación. Esto carece de importancia en los cálculos científicos, pero es inaceptable para montos monetarios. En cambio, la clase [BigDecimal] (en el paquete [java.math]) representa un número decimal con exactitud, con tantos dígitos como sea necesario. Como Java no permite redefinir los operadores, los cálculos se realizan mediante métodos: [add], [subtract], [multiply], [divide], [compareTo]... Un [BigDecimal] es inmutable: una operación no modifica el objeto al que se aplica; en su lugar, devuelve un nuevo objeto.

El programa [Basics11.java] es el siguiente:

// expresiones aritméticas
void main() {
    // división entera y división real
    IO.println("5 / 2 = " + 5 / 2 + ", 5.0 / 2 = " + 5.0 / 2 + ", 5 / 2.0 = " + 5 / 2.0);
    // resto de la división (módulo)
    IO.println("5 % 2 = " + 5 % 2 + ", -5 % 2 = " + -5 % 2 + ", 5.5 % 2 = " + 5.5 % 2);
    IO.println("Math.floorMod(-5, 2) = " + Math.floorMod(-5, 2));
    // división real entre cero: sin error, infinito o NaN (Not a Number)
    double zero = 0;
    IO.println("1 / 0.0 = " + 1 / zero + ", 0 / 0.0 = " + 0 / zero);
    // división entera entre cero: una excepción
    int integerZero = 0;
    try {
        IO.println(1 / integerZero);
    } catch (ArithmeticException e) {
        IO.println("1 / 0 : " + e.getClass().getSimpleName() + " - " + e.getMessage());
    }

    // algunos métodos de la clase Math
    double x, y = 4;
    x = Math.sqrt(y);
    IO.println("Math.sqrt(4) = " + x);
    IO.println("Math.pow(2, 10) = " + Math.pow(2, 10));
    IO.println("Math.abs(-3.5) = " + Math.abs(-3.5) + ", Math.max(3, 7) = " + Math.max(3, 7));
    IO.println("Math.PI = " + Math.PI + ", Math.cos(Math.PI) = " + Math.cos(Math.PI));
    IO.println("Math.exp(1) = " + Math.exp(1) + ", Math.log(Math.E) = " + Math.log(Math.E));
    IO.println("Math.floor(-2.5) = " + Math.floor(-2.5) + ", Math.ceil(-2.5) = " + Math.ceil(-2.5));
    // Math.round redondea al entero más cercano, los medios hacia arriba; devuelve un long
    IO.println("Math.round(2.5) = " + Math.round(2.5) + ", Math.round(-2.5) = " + Math.round(-2.5));
    // Math.rint redondea los medios al número par más cercano
    IO.println("Math.rint(2.5) = " + Math.rint(2.5) + ", Math.rint(3.5) = " + Math.rint(3.5));
    // Math.clamp (Java 21) devuelve un valor a un intervalo
    IO.println("Math.clamp(150, 0, 100) = " + Math.clamp(150, 0, 100));

    // prioridades: * / % antes que + -
    IO.println("2 + 3 * 4 = " + (2 + 3 * 4) + ", (2 + 3) * 4 = " + (2 + 3) * 4);
    IO.println("10 - 4 - 3 = " + (10 - 4 - 3) + ", \"x\" + 1 + 2 = " + "x" + 1 + 2);

    // la asignación es una expresión: asignación múltiple
    int v1, v2;
    v1 = v2 = 7 * 6;
    IO.println("v1=" + v1 + ", v2=" + v2);

    // los reales double son aproximaciones binarias
    IO.println("0.1 + 0.2 = " + (0.1 + 0.2));
    // BigDecimal calcula con exactitud en base 10
    BigDecimal a = new BigDecimal("0.1"), b = new BigDecimal("0.2");
    IO.println("BigDecimal : 0.1 + 0.2 = " + a.add(b));
    BigDecimal price = new BigDecimal("19.99");
    BigDecimal total = price.multiply(BigDecimal.valueOf(3));
    IO.println("3 x 19.99 = " + total + ", with VAT = " + total.multiply(new BigDecimal("1.2")));
    // redondeo a 2 decimales, medios hacia arriba (redondeo comercial)
    IO.println("2.565 rounded = " + new BigDecimal("2.565").setScale(2, RoundingMode.HALF_UP));
    // una división que no resulta exacta requiere una precisión
    IO.println("10 / 3 = " + BigDecimal.TEN.divide(BigDecimal.valueOf(3), MathContext.DECIMAL64));
}

Resultados:

> java Basics11.java
5 / 2 = 2, 5.0 / 2 = 2.5, 5 / 2.0 = 2.5
5 % 2 = 1, -5 % 2 = -1, 5.5 % 2 = 1.5
Math.floorMod(-5, 2) = 1
1 / 0.0 = Infinity, 0 / 0.0 = NaN
1 / 0 : ArithmeticException - / by zero
Math.sqrt(4) = 2.0
Math.pow(2, 10) = 1024.0
Math.abs(-3.5) = 3.5, Math.max(3, 7) = 7
Math.PI = 3.141592653589793, Math.cos(Math.PI) = -1.0
Math.exp(1) = 2.718281828459045, Math.log(Math.E) = 1.0
Math.floor(-2.5) = -3.0, Math.ceil(-2.5) = -2.0
Math.round(2.5) = 3, Math.round(-2.5) = -2
Math.rint(2.5) = 2.0, Math.rint(3.5) = 4.0
Math.clamp(150, 0, 100) = 100
2 + 3 * 4 = 14, (2 + 3) * 4 = 20
10 - 4 - 3 = 3, "x" + 1 + 2 = x12
v1=42, v2=42
0.1 + 0.2 = 0.30000000000000004
BigDecimal : 0.1 + 0.2 = 0.3
3 x 19.99 = 59.97, with VAT = 71.964
2.565 rounded = 2.57
10 / 3 = 3.333333333333333

Comentarios:

  • línea 4: la división de dos enteros es una división entera. En esta concatenación, las divisiones se realizan antes que los operadores + porque el operador / tiene mayor precedencia (véase más adelante);
  • línea 6: el resto tiene el mismo signo que el dividendo; el operador % también se aplica a números reales;
  • línea 7: [Math.floorMod] devuelve un resto con el mismo signo que el divisor;
  • línea 10: dividir un número real entre cero no provoca un error; devuelve infinito ([Infinity]) o el valor especial [NaN] (“Not a Number”) para 0/0;
  • líneas 12–17: en cambio, dividir un entero entre cero lanza una excepción [ArithmeticException];
  • líneas 20–21: el ejemplo anterior. [Math.sqrt] se convierte a [double]: 2.0;
  • línea 27: [floor] redondea hacia abajo, [ceil] redondea hacia arriba. Para truncar un número real hacia cero, se convierte a entero, como veremos más adelante;
  • línea 29: [Math.round] redondea al entero más cercano; un valor exactamente a la mitad entre dos enteros se redondea hacia arriba: 2.5 se convierte en 3 y -2.5 en -2. El resultado es un [long];
  • línea 31: [Math.rint] redondea un valor situado exactamente a la mitad hacia el entero par más cercano (redondeo “bancario”): 2.5 se convierte en 2 y 3.5 en 4. El resultado es [double];
  • línea 33: [Math.clamp] (Java 21) lleva 150 de vuelta al rango [0, 100];
  • línea 36: precedencia de operadores, como se muestra a continuación;
  • línea 37: "x" + 1 + 2 se evalúa de izquierda a derecha: "x" + 1 produce la cadena "x1", a la que se concatena 2. Para realizar primero la suma, hay que escribir "x" + (1 + 2);
  • línea 41: una asignación múltiple;
  • línea 45: 0.1 y 0.2 no tienen representaciones binarias exactas: su suma no es exactamente 0.3;
  • línea 47: dos objetos [BigDecimal] creados a partir de cadenas. No escriba [new BigDecimal(0.1)]: el parámetro sería el [double] 0.1, cuyo valor exacto es 0.1000000000000000055511151231257827021181583404541015625. En cambio, [BigDecimal.valueOf(0.1)], que usa la cadena "0.1", funciona correctamente;
  • línea 48: la suma exacta;
  • líneas 49–51: [BigDecimal.valueOf(3)] convierte un entero. Un producto tiene tantos decimales como la suma de los de sus dos factores: 59.97 × 1.2 = 71.964;
  • línea 53: [setScale(2, RoundingMode.HALF_UP)] redondea a dos decimales, y los valores situados a la mitad entre dos dígitos se redondean alejándose de cero: es el redondeo comercial;
  • línea 55: 10/3 no tiene una representación decimal finita. Por eso el método [divide] requiere una precisión, indicada aquí como [MathContext.DECIMAL64] (16 dígitos significativos). Sin ella, la división produciría una [ArithmeticException]: [Non-terminating decimal expansion; no exact representable decimal result.]

3.4.5.3. Orden de las operaciones al evaluar expresiones aritméticas

El orden de precedencia de los operadores al evaluar una expresión aritmética es el siguiente (de mayor a menor):

[functions], [( )], [*, /, %], [+, -]

Los operadores dentro del mismo bloque [ ] tienen la misma prioridad. Cuando las prioridades son iguales, la evaluación se realiza de izquierda a derecha: 10 - 4 - 3 se evalúa como (10 - 4) - 3 = 3.

3.4.5.4. Expresiones relacionales

Los operadores son los siguientes: <, <=, ==, !=, >, >=. Su precedencia es:

  • >, >=, <, <=;
  • ==, !=.

El resultado de una expresión relacional es el booleano [false] si la expresión es falsa y [true] en caso contrario.

    int x = 5;
    boolean end = x > 4;

Comparación de dos caracteres

Sean C1 y C2 dos caracteres. Pueden compararse mediante los operadores <, <=, ==, !=, >, >=. Se comparan sus códigos Unicode, que son números. Según el orden de Unicode, se cumplen las siguientes relaciones:

space < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z' < .. < 'é'

Comparación de dos cadenas

Se comparan carácter por carácter. La primera desigualdad encontrada entre dos caracteres produce una desigualdad del mismo sentido entre las cadenas. Consideremos la comparación de las cadenas "Cart" y "Cat":

1
2
3
4
5
"Cart"    "Cat"
---------------------
'C'   =   'C'
'a'   =   'a'
'r'   <   't'

Esta última desigualdad permite concluir que "Cart" < "Cat". Consideremos ahora la comparación de las cadenas "Cat" y "Catkin". Son iguales hasta que se agota la cadena "Cat". En este caso, la cadena agotada se declara la “menor”. Por lo tanto, se cumple la relación "Cat" < "Catkin".

Métodos para comparar dos cadenas

Advertencia: este es un error clásico en Java. Cuando se aplican a dos cadenas (o a cualquier par de objetos), los operadores == y != comparan referencias, no contenidos. [s1 == s2] es verdadero si las dos variables hacen referencia al mismo objeto en memoria, no si las dos cadenas contienen los mismos caracteres. Para comprobar si dos cadenas son iguales, use el método [equals] de la clase [String], o bien [equalsIgnoreCase] para ignorar las diferencias entre mayúsculas y minúsculas. Los operadores <, <=, > y >= no se aplican a cadenas: debe usarse el método [compareTo] (o [compareToIgnoreCase]). Este devuelve un entero:

  • cero si las dos cadenas son iguales;
  • positivo si la cadena n.º 1 es mayor que la cadena n.º 2;
  • negativo si la cadena n.º 1 es menor que la cadena n.º 2.

[compareTo] compara los códigos Unicode carácter por carácter: el resultado es la diferencia entre los códigos de los dos primeros caracteres distintos, o la diferencia de longitud si una de las cadenas es el comienzo de la otra. Este no es el orden del diccionario: como el código de 'é' (233) es mayor que el de 'f' (102), "élan" va después de "face". Para ordenar texto destinado a los usuarios, se usa el objeto [Collator] (paquete [java.text]), que aplica las reglas de ordenación de un idioma específico. [compareTo] sigue siendo el método correcto para identificadores, palabras clave y nombres de archivo.

El programa [Basics12.java] es el siguiente:

// expresiones relacionales y comparación de cadenas
void main() {
    int x = 5;
    boolean end = x > 4;
    IO.println("x > 4 : " + end + ", x == 5 : " + (x == 5) + ", x != 5 : " + (x != 5));

    // comparación de caracteres: se comparan sus códigos Unicode
    IO.println("'a' < 'b' : " + ('a' < 'b') + ", 'Z' < 'a' : " + ('Z' < 'a')
            + ", '9' < 'A' : " + ('9' < 'A'));
    IO.println("codes: 'A'=" + (int) 'A' + ", 'a'=" + (int) 'a' + ", 'é'=" + (int) 'é');

    // comparación de cadenas con equals y compareTo
    String string1 = "cat", string2 = "dog";
    int n = string1.compareTo(string2);
    boolean equal = string1.equals(string2);
    IO.println("n=" + n + ", equal=" + equal);
    IO.println("\"Cat\".compareTo(\"Catkin\") : " + "Cat".compareTo("Catkin"));

    // == compara las referencias, no el contenido de las cadenas
    String string3 = "ca".concat("t");
    IO.println("string3=" + string3 + ", string1 == string3 : " + (string1 == string3)
            + ", string1.equals(string3) : " + string1.equals(string3));

    // compareTo compara los códigos Unicode, carácter por carácter
    IO.println("\"élan\".compareTo(\"face\") : " + "élan".compareTo("face"));
    IO.println("\"Cat\".compareTo(\"cat\") : " + "Cat".compareTo("cat"));
    // sin distinguir mayúsculas de minúsculas
    IO.println("\"Cat\".compareToIgnoreCase(\"cat\") : " + "Cat".compareToIgnoreCase("cat"));
    IO.println("\"Cat\".equals(\"cat\") : " + "Cat".equals("cat"));
    IO.println("\"Cat\".equalsIgnoreCase(\"cat\") : " + "Cat".equalsIgnoreCase("cat"));
    // un Collator compara según las reglas de ordenación de un idioma
    Collator collator = Collator.getInstance(Locale.FRENCH);
    IO.println("collator.compare(\"élan\", \"face\") : " + collator.compare("élan", "face"));
    IO.println("collator.compare(\"Cat\", \"cat\") : " + collator.compare("Cat", "cat"));
}

Resultados:

> java Basics12.java
x > 4 : true, x == 5 : true, x != 5 : false
'a' < 'b' : true, 'Z' < 'a' : true, '9' < 'A' : true
codes: 'A'=65, 'a'=97, 'é'=233
n=-1, equal=false
"Cat".compareTo("Catkin") : -3
string3=cat, string1 == string3 : false, string1.equals(string3) : true
"élan".compareTo("face") : 131
"Cat".compareTo("cat") : -32
"Cat".compareToIgnoreCase("cat") : 0
"Cat".equals("cat") : false
"Cat".equalsIgnoreCase("cat") : true
collator.compare("élan", "face") : -1
collator.compare("Cat", "cat") : 1

Comentarios:

  • línea 4: una expresión relacional;
  • líneas 8–9: comparación de caracteres;
  • línea 10: la conversión [(int)] de un carácter devuelve su código Unicode;
  • línea 14: a la variable [n] se le asigna un entero negativo porque "cat" < "dog": la diferencia entre los códigos de 'c' (99) y 'd' (100);
  • línea 15: la variable [equal] tiene el valor [true] si las dos cadenas son iguales y [false] en caso contrario;
  • línea 17: la cadena que se agota primero es la más corta; el resultado es la diferencia de longitudes: 3 - 6. En un literal de cadena, \" representa unas comillas;
  • línea 20: el método [concat] construye, en tiempo de ejecución, un nuevo objeto de cadena que contiene "cat";
  • líneas 21–22: [string1] y [string3] tienen el mismo contenido pero hacen referencia a dos objetos distintos: == devuelve [false], [equals] devuelve [true]. La trampa es aún más insidiosa porque dos literales de cadena idénticos se almacenan una sola vez en memoria, de modo que ["cat" == "cat"] es verdadero: una prueba con == puede parecer funcionar durante las pruebas. Siempre usaremos [equals];
  • línea 25: 233 - 102 = 131: para [compareTo], “élan” va después de “face”;
  • línea 26: 'C' (67) - 'c' (99) = -32;
  • líneas 28–30: sin distinguir mayúsculas de minúsculas, “Cat” y “cat” son iguales;
  • líneas 32–34: un [Collator] para francés: “élan” precede a “face” y “Cat” sigue a “cat” (cuando las letras son las mismas, la minúscula va antes que la mayúscula). El método [compare] devuelve un entero negativo, cero o positivo, igual que [compareTo].

3.4.5.5. Expresiones booleanas

Los operadores que se pueden usar son AND (&&), OR (||) y NOT (!). El resultado de una expresión booleana es un valor booleano. Precedencia de los operadores:

  • ! ;
  • && ;
  • ||.
    double x = 3.5;
    boolean valid = x > 2 && x < 4;

Los operadores relacionales tienen precedencia sobre los operadores && y ||. Estos dos operadores evalúan su operando derecho solo si es necesario: en [a && b], b no se evalúa si a es falso; en [a || b], b no se evalúa si a es verdadero. Esto se denomina “evaluación en cortocircuito”. Por lo tanto, es seguro escribir [text != null && text.length() > 0]. Los operadores & y |, cuando se aplican a dos booleanos, realizan el mismo cálculo pero siempre evalúan ambos operandos.

3.4.5.6. Operaciones bit a bit

Sean [i] y [j] dos enteros:

Operación
Descripción
i << n
Desplaza i n bits a la izquierda. Los bits que entran son ceros
i >> n
Desplaza i n bits a la derecha. Se conserva el bit de signo
i >>> n
desplazamiento a la derecha sin signo: los bits que entran son ceros, incluso si i es negativo
i & j
realiza el AND lógico bit a bit de i y j
i|j
realiza el OR lógico bit a bit de i y j
~i
complementa i a 1
i ^ j
realiza la operación OR EXCLUSIVO entre i y j bit a bit

El programa [Basics13.java] es el siguiente:

// manipulación de bits
void main() {
    short i = 100, j = -13;
    // char es el único tipo entero sin signo de Java (16 bits)
    char k = 0xF123;
    IO.println(String.format("i=0x%04x, j=0x%04x, k=0x%04x", i, j, (int) k));
    IO.println(String.format("i<<4=0x%04x, i>>4=0x%04x, k>>4=0x%04x", i << 4, i >> 4, k >> 4));
    IO.println(String.format("i&j=0x%04x, i|j=0x%04x, i^j=0x%04x, ~i=0x%04x",
            (short) (i & j), (short) (i | j), (short) (i ^ j), (short) ~i));
    IO.println(String.format("j<<2=0x%04x, j>>2=0x%04x", (short) (j << 2), (short) (j >> 2)));
    // los mismos valores en binario
    IO.println("i=" + binary(i, 16) + ", j=" + binary(j, 16) + ", i&j=" + binary(i & j, 16));
    // desplazamiento a la derecha sin signo >>>: los bits que entran son ceros
    int m = -16;
    IO.println("m=" + binary(m, 32) + ", m>>2=" + binary(m >> 2, 32) + ", m>>>2=" + binary(m >>> 2, 32));
}

// los n bits menos significativos de value, como cadena de 0 y 1
String binary(int value, int n) {
    StringBuilder bits = new StringBuilder();
    for (int rank = n - 1; rank >= 0; rank--) {
        bits.append((value >>> rank) & 1);
    }
    return bits.toString();
}

Resultados:

1
2
3
4
5
6
7
> java Basics13.java
i=0x0064, j=0xfff3, k=0xf123
i<<4=0x0640, i>>4=0x0006, k>>4=0x0f12
i&j=0x0060, i|j=0xfff7, i^j=0xff97, ~i=0xff9b
j<<2=0xffcc, j>>2=0xfffc
i=0000000001100100, j=1111111111110011, i&j=0000000001100000
m=11111111111111111111111111110000, m>>2=11111111111111111111111111111100, m>>>2=00111111111111111111111111111100

Comentarios:

  • línea 3: dos enteros [short];
  • línea 5: el valor 0xF123 (61731) no cabe en un [short], cuyo máximo es 32767. El tipo [char], un entero sin signo de 16 bits, sí puede contenerlo;
  • línea 6: el especificador %04x muestra un entero de 4 dígitos hexadecimales (x) rellenado con ceros (04). Aplicado a un [short], muestra sus 16 bits: -13 se convierte en fff3. El especificador %x no acepta un [char]: se convierte a [int];
  • línea 7: las operaciones con [short] o [char] se realizan con [int]: los operandos se convierten primero a [int] (esto se llama promoción), y el resultado es un [int];
  • línea 9: los resultados se convierten de nuevo a [short] para mostrar 4 dígitos hexadecimales. Sin la conversión, ~i se mostraría con 8 dígitos (ffffff9b);
  • línea 12: el método [binary] (líneas 19–25) muestra los n bits menos significativos de un entero. Verificamos el AND lógico de i y j bit a bit;
  • línea 15: el desplazamiento [>>] conserva el bit de signo de m, que es negativo; el desplazamiento [>>>] rellena con ceros;
  • línea 22: [(value >>> rank) & 1] lleva el bit n.º [rank] a la posición 0 y luego lo aísla de los demás. La clase [StringBuilder], presentada en el Capítulo 5, construye una cadena mediante adiciones sucesivas.

3.4.5.7. Combinación de operadores

[a = a + b] puede escribirse como [a += b]; [a = a - b] puede escribirse como [a -= b]. Lo mismo se aplica a los operadores /, %, *, <<, >>, >>>, &, |, ^. Así, [a = a / 2;] puede escribirse como [a /= 2;]. Hay una pequeña diferencia: el operador combinado incluye una conversión implícita al tipo de la variable. Si [s] es un [short], [s = s + 1;] se rechaza (el resultado de la suma es un [int]), mientras que [s += 1;] se acepta.

3.4.5.8. Operadores de incremento y decremento

La notación [variable++] significa [variable = variable + 1] o [variable += 1]. La notación [variable--] significa [variable = variable - 1] o [variable -= 1]. Cuando se usan en una expresión, estos operadores tienen dos formas:

  • [i++] (posfijo): el valor de la expresión es el valor de i antes del incremento;
  • [++i] (prefijo): el valor de la expresión es el valor de i después del incremento.

3.4.5.9. El operador ternario ?

La expresión [expr_cond ? expr1 : expr2] se evalúa de la siguiente manera:

  • Se evalúa la expresión [expr_cond] . Es una expresión booleana;
  • si es verdadera, el valor de la expresión es el de [expr1], y [expr2] no se evalúa;
  • si es falsa, ocurre lo contrario: el valor de la expresión es el de [expr2], y [expr1] no se evalúa.

La operación [i = (j > 4 ? j + 1 : j - 1);] asignará el valor j+1 a la variable i si j > 4, y j-1 en caso contrario. Es lo mismo que escribir [if (j > 4) i = j + 1; else i = j - 1;], pero más conciso.

3.4.5.10. Valores nulos: sin operadores especializados

A diferencia de otros lenguajes como C# o Kotlin, Java no tiene operadores dedicados para el valor [null] (valor de reemplazo, acceso condicional a un miembro). En su lugar, usamos:

  • el operador ternario, [a != null ? a : b], o el método [Objects.requireNonNullElse(a, b)] (Java 9), que devuelve a si no es igual a [null], y b en caso contrario. Se usa para asignar un valor de respaldo: [String name = Objects.requireNonNullElse(IO.readln(), "");];
  • una prueba simple, [if (a == null) a = b;], para asignar un valor a una variable solo si es igual a [null];
  • la clase *[Optional] y su método *[map] para acceder a un miembro solo si el objeto existe: [Optional.ofNullable(text).map(String::length)] devuelve un [Optional] vacío si [text] es igual a [null], y un [Optional] que contiene la longitud del texto en caso contrario.

El programa [Basics14.java] combina estos diversos operadores:

// otros operadores
void main() {
    // expresiones booleanas
    double x = 3.5;
    boolean valid = x > 2 && x < 4;
    IO.println("valid=" + valid + ", !valid=" + !valid + ", valid || x > 10 : " + (valid || x > 10));

    // operadores compuestos
    int a = 10;
    a += 5;
    IO.print("a += 5 : " + a);
    a *= 2;
    IO.print(", a *= 2 : " + a);
    a /= 4;
    IO.print(", a /= 4 : " + a);
    a %= 4;
    IO.print(", a %= 4 : " + a);
    a <<= 2;
    IO.println(", a <<= 2 : " + a);

    // incremento y decremento
    int i = 5;
    int j = i++;    // j recibe el valor anterior de i, luego i se incrementa
    int k = ++i;    // i se incrementa, luego k recibe el nuevo valor de i
    IO.println("i=" + i + ", j=" + j + ", k=" + k);
    i--;
    IO.println("i=" + i);

    // operador ternario
    int n = 5;
    int p = n > 4 ? n + 1 : n - 1;
    String parity = n % 2 == 0 ? "even" : "odd";
    IO.println("p=" + p + ", " + n + " is " + parity);

    // valor de reemplazo si una referencia es null
    String input = null;
    String name = Objects.requireNonNullElse(input, "unknown");
    Integer age = null;
    int displayedAge = age != null ? age : -1;
    IO.println("name=" + name + ", displayedAge=" + displayedAge);
    // asignación solo si la variable es null
    String title = null;
    if (title == null) {
        title = "Untitled";
    }
    IO.println("title=" + title);
    // acceso a un miembro solo si el objeto no es null: Optional y map
    String text = null;
    Optional<Integer> length = Optional.ofNullable(text).map(String::length);
    IO.println("length=" + length.map(String::valueOf).orElse("null"));
    text = "hello";
    IO.println("length=" + Optional.ofNullable(text).map(String::length).orElse(-1));
}

Resultados:

> java Basics14.java
valid=true, !valid=false, valid || x > 10 : true
a += 5 : 15, a *= 2 : 30, a /= 4 : 7, a %= 4 : 3, a <<= 2 : 12
i=7, j=5, k=7
i=6
p=6, 5 is odd
name=unknown, displayedAge=-1
title=Untitled
length=null
length=5

Comentarios:

  • línea 5: una expresión booleana;
  • líneas 9–19: operadores combinados: 10+5=15, 15*2=30, 30/4=7 (división entera), 7%4=3, 3<<2=12;
  • línea 23: a [j] se le asigna 5 y luego [i] se establece en 6;
  • línea 24: [i] cambia a 7 y luego [k] recibe 7;
  • líneas 31–32: dos operadores ternarios;
  • línea 37: [input] es igual a [null]: [name] se asigna "unknown";
  • línea 39: el operador ternario permite pasar de un [Integer] a un [int] sin riesgo de una excepción: [age] se desempaqueta solo si no es igual a [null];
  • líneas 43–45: la asignación ocurre solo si [title] es igual a [null];
  • línea 49: [text] es igual a [null]: [Optional.ofNullable(text)] está vacío, y [map] devuelve un [Optional] vacío sin llamar a [length()]. La notación [String::length] es una referencia a método: hace referencia al método [length] de la clase [String]. Lo estudiaremos en el Capítulo 7;
  • línea 50: si [length] está vacío, se muestra la cadena "null";
  • línea 52: [text] es "hello": [map] aplica [length()], y el resultado es 5.

3.4.5.11. Precedencia general de los operadores

La siguiente tabla enumera la precedencia de los operadores, de mayor a menor:

Operadores
Asociatividad
[x.y] [f(x)] [a[i]] [x++] [x--] [new]
lr
[+x] [-x] [!x] [~x] [++x] [--x] [(T)x] (cambio de tipo)
rl
[*] [/] [%]
lr
[+] [-]
lr
[<<] [>>] [>>>]
lr
[<] [<=] [>] [>=] [instanceof]
lr
[==] [!=]
lr
[&]
lr
[^]
lr
[|]
lr
[&&]
lr
[||]
lr
[? :] (ternario)
rl
[=] [+=] [-=] etc., [->] (lambda)
rl

lr indica que, cuando los operadores tienen igual precedencia, se aplica el orden de izquierda a derecha: cuando una expresión contiene operadores de la misma precedencia, se evalúa primero el operador situado más a la izquierda. rl indica el orden de derecha a izquierda. En caso de duda, no dude en usar paréntesis: también hacen que la expresión sea más legible.

3.4.5.12. Conversión de tipos

Es posible, dentro de una expresión, cambiar temporalmente la representación de un valor. Esto se denomina conversión de tipo (type casting). La sintaxis para cambiar el tipo de un valor en una expresión es la siguiente:

(type) value

El valor adopta entonces el tipo especificado. Esto produce un cambio en la representación del valor. Se distinguen:

  • las conversiones "de ampliación" (widening), realizadas automáticamente por el compilador: [byte] a [short], [short] a [int], [char] a [int], [int] a [long], [long] a [float] o [double], [float] a [double]... Conservan el orden de magnitud del valor. Las que pasan de un [int] a un [float], o de un [long] a un [float] o a un [double], pueden, sin embargo, perder precisión: un [float] tiene solo 7 dígitos significativos, mientras que un [double] tiene de 15 a 16;
  • las conversiones de reducción (narrowing), que pueden producir una pérdida de información y que el programador debe solicitar explícitamente mediante la notación (tipo): de un [double] a un [int] (se pierde la parte decimal), de un [long] a un [int] (se pierden los bits más significativos), etc.

Un desbordamiento en un cálculo con enteros o en una conversión entre enteros nunca se notifica: el resultado simplemente es incorrecto. Java no tiene una palabra clave para solicitar una verificación. Cuando existe este riesgo, se usan los métodos [addExact], [subtractExact], [multiplyExact], [incrementExact], [toIntExact]... de la clase [Math] (Java 8), que lanzan una excepción [ArithmeticException] si se excede el límite.

El programa [Basics15.java] es el siguiente:

// cambios de tipo
void main() {
    int i = 3, j = 4;
    float f1 = i / j;
    float f2 = (float) i / j;
    IO.println("f1=" + f1 + ", f2=" + f2);

    // conversiones implícitas (ampliación): sin pérdida de información
    long l = i;
    double d = l;
    IO.println("l=" + l + ", d=" + d);

    // conversiones explícitas (casting): posible pérdida de información
    double real = 3.99;
    int truncated = (int) real;
    int rounded = (int) Math.round(real);
    IO.println("(int) 3.99=" + truncated + ", (int) Math.round(3.99)=" + rounded);
    long large = 3_000_000_000L;
    int overflowed = (int) large;
    IO.println("(int) 3000000000L=" + overflowed);
    // un real demasiado grande se reduce al mayor valor entero
    IO.println("(int) 1e10=" + (int) 1e10 + ", (int) Double.NaN=" + (int) Double.NaN);

    // caracteres y enteros
    char c = (char) 65;
    int code = 'é';
    IO.println("(char) 65=" + c + ", code of 'é'=" + code);

    // desbordamiento de capacidad: silencioso
    int max = Integer.MAX_VALUE;
    int next = max + 1;
    IO.println("Integer.MAX_VALUE + 1 = " + next);
    // los métodos ...Exact de Math señalan el desbordamiento con una excepción
    try {
        int verified = Math.addExact(max, 1);
        IO.println("verified=" + verified);
    } catch (ArithmeticException e) {
        IO.println("Math.addExact(max, 1) : " + e.getClass().getSimpleName() + " - " + e.getMessage());
    }
    try {
        int conversion = Math.toIntExact(large);
        IO.println("conversion=" + conversion);
    } catch (ArithmeticException e) {
        IO.println("Math.toIntExact(large) : " + e.getClass().getSimpleName() + " - " + e.getMessage());
    }
}

Resultados:

> java Basics15.java
f1=0.0, f2=0.75
l=3, d=3.0
(int) 3.99=3, (int) Math.round(3.99)=4
(int) 3000000000L=-1294967296
(int) 1e10=2147483647, (int) Double.NaN=0
(char) 65=A, code of 'é'=233
Integer.MAX_VALUE + 1 = -2147483648
Math.addExact(max, 1) : ArithmeticException - integer overflow
Math.toIntExact(large) : ArithmeticException - integer overflow

Comentarios:

  • línea 4: [f1] tendrá el valor 0.0. La división 3/4 es una división entera porque ambos operandos son de tipo [int]; su resultado, 0, se convierte luego a [float];
  • línea 5: [(float) i] es el valor de [i] convertido a [float]. Ahora tenemos una división entre un número real de tipo [float] y un entero de tipo [int]: el valor de [j] también se transforma en [float], y luego se dividen los dos números reales. [f2] tiene un valor de 0.75. En la operación [(float) i], [i] es un valor codificado exactamente en 4 bytes, mientras que [(float) i] es el mismo valor codificado de forma aproximada como número real en 4 bytes. Esta transcodificación ocurre solo durante el cálculo: la variable [i] conserva siempre su tipo [int];
  • líneas 9–10: conversiones de ampliación;
  • línea 15: convertir un número real a entero trunca la parte decimal (hacia cero);
  • línea 16: para redondear el número, se usa [Math.round], que produce un [long], y luego se convierte a [int];
  • línea 18: el sufijo L es indispensable: 3 mil millones exceden el rango de [int];
  • línea 19: 3 mil millones no caben en un [int]: solo se conservan los 32 bits menos significativos y el resultado deja de tener sentido;
  • línea 22: un número real demasiado grande para un [int] se reduce a [Integer.MAX_VALUE]; el valor [NaN] se convierte en 0;
  • líneas 25–26: conversiones entre caracteres y códigos Unicode; la segunda es implícita;
  • línea 31: el desbordamiento de capacidad pasa inadvertido: se obtiene el menor valor de [int];
  • línea 35: con [Math.addExact], el desbordamiento provoca una excepción [ArithmeticException];
  • línea 41: [Math.toIntExact] convierte un [long] a [int] y también lanza una excepción si el valor no cabe en un [int].

Incluso cuando el desbordamiento ocurre en una expresión formada únicamente por constantes, como [Integer.MAX_VALUE + 1], el compilador la acepta sin una advertencia: calcula el valor por sí mismo, -2147483648.

3.5. Instrucciones de control del flujo del programa

3.5.1. Detención

El método [exit] de la clase [System] permite detener la ejecución del programa:

System.exit(int status);

[exit] finaliza el proceso actual y devuelve el control al proceso que lo invocó, normalmente el intérprete de comandos. El valor de [status], conocido como código de retorno, puede ser utilizado por el intérprete de comandos. Por convención, 0 indica que el programa se ejecutó correctamente, mientras que cualquier otro valor señala un error. En Windows, el código de retorno está disponible en la variable [%ERRORLEVEL%] en el símbolo del sistema y en la variable [$LASTEXITCODE] en PowerShell; en Linux y macOS, en la variable [$?] del shell. Así, [System.exit(0);] finalizará la ejecución del programa con un código de retorno 0.

Sin una llamada a [System.exit], un programa termina con un código de retorno 0 cuando finaliza su método [main], posiblemente con una instrucción [return]. Si termina a causa de una excepción que nadie capturó, muestra esa excepción y finaliza con un código de retorno 1. En Java, el método [main] no puede devolver un entero: [System.exit] es la única forma de especificar el código de retorno.

El programa [Basics16.java] recibe su código de retorno como argumento:

// detener el programa con un código de salida
void main(String[] args) {
    IO.println("Start of the program");
    // el código de salida se pasa como argumento (véase la sección sobre los argumentos del programa)
    int code;
    try {
        // sin argumento, se convierte la cadena vacía, lo cual falla
        code = Integer.parseInt(args.length > 0 ? args[0] : "");
    } catch (NumberFormatException e) {
        System.err.println("Syntax: java Basics16.java exit_code");
        System.exit(1);
        return;
    }
    IO.println("Stopping with the exit code " + code);
    System.exit(code);
    IO.println("This line is never executed");
}

Resultados en una terminal bash:

> java Basics16.java 3
Start of the program
Stopping with the exit code 3
> echo $?
3
> java Basics16.java
Start of the program
Syntax: java Basics16.java exit_code
> echo $?
1

Comentarios:

  • línea 2: el método [main] recibe los argumentos de la línea de comandos en el arreglo [args]. Los argumentos del programa se describen más adelante;
  • línea 8: si hay al menos un argumento, el primero se convierte a entero; de lo contrario, se convierte la cadena vacía, lo que falla. Así, la ausencia de argumento y un argumento no numérico se manejan con la misma cláusula [catch];
  • línea 11: el programa termina con un código de retorno 1;
  • línea 12: esta instrucción nunca se ejecutará, pero el compilador no sabe que [System.exit] nunca devuelve el control. Sin ella, el compilador supondría que se podría llegar a la línea 14 con la variable [code] sin inicializar y rechazaría el programa: [error: variable code might not have been initialized];
  • línea 15: salida con el código de retorno pasado como argumento. La línea siguiente no se ejecuta;
  • líneas 4–5 y 9–10 de los resultados: el comando [echo $?] muestra el código de retorno del último programa ejecutado: 3 y luego 1.

3.5.2. Estructura de decisión simple

1
2
3
4
5
if (condition) {
    actions_condition_true;
} else {
    actions_condition_false;
}

Notas:

  • La condición se escribe entre paréntesis. Debe ser de tipo [boolean]: a diferencia del lenguaje C, Java rechaza [if (n)] cuando [n] es un entero;
  • cada acción termina con un punto y coma;
  • las llaves no van seguidas de punto y coma;
  • las llaves son obligatorias solo si hay más de una acción; sin embargo, a menudo se usan incluso para una sola acción, por legibilidad y para evitar errores al agregar una acción. En Java, es costumbre colocar la llave de apertura al final de la línea;
  • la cláusula [else] puede omitirse;
  • no existe la palabra clave [then].

El equivalente algorítmico de esta estructura es la estructura si...entonces...sino:

1
2
3
4
if condition
    then actions_condition_true
    else actions_condition_false
endif

Ejemplo:

if (x > 0) { nx = nx + 1; sx = sx + x; } else dx = dx - x;

Las estructuras de decisión pueden anidarse. Esto lleva a veces al problema que ilustra el programa [Basics17.java]:

// estructura de decisión simple if
void main() {
    int n = 5;
    // un else siempre se relaciona con el if más cercano
    if (n > 1)
        if (n > 6)
            IO.println(">6");
        else
            IO.println("<=6");

    // con llaves, el else se asocia al primer if
    int n2 = 0;
    if (n2 > 1) {
        if (n2 > 6) {
            IO.println(">6");
        }
    } else {
        IO.println("<=1");
    }

    // una secuencia de decisiones: else if
    int grade = 13;
    String honours;
    if (grade < 10) {
        honours = "failed";
    } else if (grade < 12) {
        honours = "pass";
    } else if (grade < 14) {
        honours = "fairly good";
    } else {
        honours = "good";
    }
    IO.println("grade=" + grade + ", honours=" + honours);
}

Resultados:

1
2
3
4
> java Basics17.java
<=6
<=1
grade=13, honours=fairly good

Comentarios:

  • líneas 5–9: ¿a qué [if] se refiere el [else] de la línea 8? La regla es que un [else] siempre se refiere al [if] más cercano: [if (n > 6)], línea 6. La sangría del código, que no tiene efecto en el compilador, se eligió para ilustrarlo;
  • líneas 13–19: aquí se quiso colocar un [else] junto a [if (n2 > 1)], y no un [else] junto a [if (n2 > 6)]. Por la regla anterior, nos vemos obligados a encerrar [if (n2 > 1) { ... }] entre llaves;
  • líneas 24–32: una secuencia de opciones mutuamente excluyentes se escribe mediante instrucciones [else if] sucesivas. Las condiciones se prueban en orden; la primera que se evalúa como verdadera determina la acción que se ejecuta. El compilador verifica que a la variable [honours], declarada sin valor en la línea 23, se le asigne un valor en todas las ramas antes de usarla en la línea 33.

3.5.3. Estructura de casos

3.5.3.1. La instrucción switch

La sintaxis histórica es la siguiente:

switch (expression) {
    case v1:
        actions1;
        break;
    case v2:
        actions2;
        break;
    ...
    default:
        actions_otherwise;
        break;
}

Notas:

  • El valor de la expresión de control de [switch] puede ser un entero ([int], [short], [byte], [char], o sus clases envoltorio), una cadena (Java 7), un valor de enumeración y, desde Java 21, cualquier objeto (véase el filtrado por patrones más adelante). Los tipos [long], [float], [double], y [boolean] no se aceptan;
  • la expresión de control se escribe entre paréntesis;
  • la cláusula [default] puede omitirse;
  • los valores vi son los valores posibles de la expresión. Si la expresión se evalúa como vi, se ejecutan las acciones que siguen a la cláusula [case vi] . A partir de Java 14, una cláusula puede enumerar varios valores: [case "saturday", "sunday":];
  • La instrucción [break] sale de la estructura de casos. Atención: si se omite, la ejecución continúa con las acciones de la cláusula [case] siguiente (“fall-through”). El compilador lo acepta; con la opción [-Xlint:all], emite únicamente la advertencia [warning: [fallthrough] possible fall-through into case]. Esta omisión es un error común, que la forma con flecha que se muestra a continuación evita.

Ejemplo en algoritmia:

depending on the value of choice
    case 0
        end of the module
    case 1
        execute module M1
    case 2
        execute module M2
    otherwise
        error <- true
endcase

3.5.3.2. La forma con flecha y la expresión switch

Java 14 introdujo una segunda forma de la cláusula, [case v1, v2 -> action], donde la flecha va seguida de una sola instrucción o de un bloque entre llaves. Solo se ejecuta la acción de la cláusula seleccionada: no es necesario escribir un [break], ni hay encadenamiento de una cláusula con la siguiente.

Muy a menudo, una estructura de casos se usa únicamente para seleccionar un valor. En este caso, [switch] puede usarse como una expresión (Java 14):

1
2
3
4
5
6
result = switch (expression) {
    case v1 -> value1;
    case v2, v3 -> value2;
    ...
    default -> value_otherwise;
};

La expresión switch debe ser exhaustiva: debe proporcionar un valor para todos los valores posibles de la expresión de control, lo que generalmente requiere una cláusula [default]. Cuando una cláusula requiere varias instrucciones, se escribe un bloque, que devuelve su valor mediante la instrucción [yield].

Desde Java 21, una cláusula [case] puede contener un patrón en lugar de una constante. Un patrón de tipo, [case Integer i], coincide si el objeto examinado es del tipo [Integer]; el objeto queda entonces disponible, con ese tipo, en la variable [i]. Una guarda [when condition] agrega una condición: [case Integer i when i > 0] solo se selecciona para un entero positivo. Una cláusula [case null] procesa el valor [null], que de otro modo provocaría una [NullPointerException]. Las cláusulas se evalúan en orden: se selecciona la primera que coincide. El mismo filtrado se aplica al operador [instanceof] (Java 16): [if (o instanceof String s && s.length() > 3)].

Java 25 todavía no permite escribir tales patrones para tipos primitivos ([case int i when i > 0]): esta característica está disponible en una versión preliminar, que no usaremos. Para clasificar un [int] con guardas, aplicamos el [switch] a un [Integer].

El programa [Basics18.java] es el siguiente:

// estructura de casos: instrucción switch y expresión switch
void main() {
    int choice = 2;
    boolean error = false;
    switch (choice) {
        case 0:
            return;
        case 1:
            m1();
            break;
        case 2:
            m2();
            break;
        default:
            error = true;
            break;
    }
    IO.println("error=" + error);

    // varios valores para el mismo case, expresión de tipo String
    String day = "saturday";
    switch (day) {
        case "saturday", "sunday":
            IO.println(day + " : weekend");
            break;
        default:
            IO.println(day + " : week");
            break;
    }
    // la forma de flecha (Java 14): sin break, sin continuación entre casos
    switch (day) {
        case "saturday", "sunday" -> IO.println(day + " : weekend");
        default -> IO.println(day + " : week");
    }

    // expresión switch (Java 14): devuelve un valor
    String dayType = switch (day) {
        case "saturday", "sunday" -> "weekend";
        case "monday", "tuesday", "wednesday", "thursday", "friday" -> "week";
        default -> "unknown day";
    };
    IO.println(day + " : " + dayType);
    // un bloque de instrucciones devuelve su valor con yield
    int nbHours = switch (day) {
        case "saturday" -> 4;
        case "sunday" -> 0;
        default -> {
            int hours = 7;
            yield hours + 1;
        }
    };
    IO.println(day + " : " + nbHours + " opening hour(s)");

    // coincidencia de patrones con guardas when (Java 21)
    IO.println("-5 : " + classify(-5));
    IO.println("0 : " + classify(0));
    IO.println("7 : " + classify(7));
    IO.println("42 : " + classify(42));
    IO.println("1000 : " + classify(1000));
    // coincidencia según el tipo del objeto
    Object[] objects = {12, -3, "java", 2.5, null};
    for (Object o : objects) {
        IO.println(o + " : " + describe(o));
    }
}

// métodos usados arriba
void m1() {
    IO.println("M1");
}

void m2() {
    IO.println("M2");
}

String classify(Integer n) {
    return switch (n) {
        case Integer i when i < 0 -> "negative";
        case 0 -> "zero";
        case Integer i when i <= 10 -> "small";
        case Integer i when i < 100 -> "medium";
        default -> "large";
    };
}

String describe(Object o) {
    return switch (o) {
        case null -> "no object";
        case Integer i when i > 0 -> "positive integer";
        case Integer i -> "negative or zero integer";
        case String s -> "string of " + s.length() + " characters";
        default -> "object of type " + o.getClass().getSimpleName();
    };
}

Resultados:

> java Basics18.java
M2
error=false
saturday : weekend
saturday : weekend
saturday : weekend
saturday : 4 opening hour(s)
-5 : negative
0 : zero
7 : small
42 : medium
1000 : large
12 : positive integer
-3 : negative or zero integer
java : string of 4 characters
2.5 : object of type Double
null : no object

Comentarios:

  • líneas 5–17: la implementación en Java del algoritmo anterior;
  • línea 7: [return] termina el método [main] y, por lo tanto, el programa;
  • línea 23: dos valores para las mismas acciones. Antes de Java 14, habríamos escrito dos cláusulas sucesivas, [case "saturday":] y [case "sunday":], con la primera, que está vacía, “cayendo” en la segunda;
  • líneas 31–34: la misma estructura de casos con flechas; ya no hay [break];
  • líneas 37–41: una expresión switch sobre una cadena. Termina con un punto y coma, como cualquier instrucción de asignación. La cláusula *[default]* la hace exhaustiva;
  • líneas 44–51: una cláusula cuya acción es un bloque: la instrucción [yield] (línea 49) evalúa la expresión;
  • líneas 76–84: el método [classify]. Su parámetro [Integer] recibe los enteros -5, 0, 7… envueltos automáticamente (líneas 55–59). Las guardas [when] clasifican el entero, y la constante 0 está incluida en los patrones. La cláusula [default] maneja los valores restantes, en este caso los enteros mayores o iguales que 100;
  • línea 61: un arreglo de objetos de diferentes tipos: los números 12, -3 y 2.5 se envuelven en [Integer] y [Double];
  • líneas 86–94: el método [describe] selecciona según el tipo del objeto. En la línea 91, la variable [s] es de tipo [String]: su método [length()] puede llamarse sin conversión. La cláusula sin guarda, [case Integer i] (línea 90), debe colocarse después de la cláusula con guarda (línea 89), a la que de otro modo ocultaría: el compilador rechazaría el programa;
  • líneas 68–74: dos métodos llamados por el primero, [switch].

3.5.4. Estructuras de repetición

3.5.4.1. Número conocido de repeticiones

Estructura "for"

La sintaxis es la siguiente:

1
2
3
for (i = id; i <= if; i = i + ip) {
    actions;
}

Notas:

  • Los tres argumentos de [for] se escriben entre paréntesis y se separan con punto y coma;
  • cada acción de [for] termina con un punto y coma;
  • las llaves solo son necesarias si hay más de una acción;
  • la llave no va seguida de punto y coma.

El equivalente algorítmico es la estructura para:

1
2
3
for i varying from id to if in steps of ip
    actions
endfor

que puede traducirse a una estructura mientras:

1
2
3
4
5
i <- id
while i <= if
    actions
    i <- i + ip
endwhile

Estructura for-each

La sintaxis es la siguiente:

1
2
3
for (Type variable : collection) {
    instructions;
}

Notas:

  • [collection] es un arreglo o una colección iterable de objetos (que implementa la interfaz [Iterable]). Estudiaremos las colecciones ([List], [Set], [Map]...) en el Capítulo 5;
  • [Type] es el tipo de los elementos de la colección. Para un arreglo, sería el tipo de los elementos del arreglo. Puede escribirse [var] en su lugar;
  • [variable] es una variable local del bucle que tomará sucesivamente todos los valores de la colección. Asignarle un valor distinto dentro del bucle no modifica la colección; puede declararla como [final] para evitarlo.

3.5.4.2. Número desconocido de iteraciones

Bucle while

1
2
3
while (condition) {
    actions;
}

El bucle continúa mientras la condición sea verdadera. Es posible que el bucle nunca se ejecute. Las notas son las mismas que para [for]. La estructura algorítmica correspondiente es la estructura mientras:

1
2
3
while condition
    actions
endwhile

Bucle "do while"

La sintaxis es la siguiente:

1
2
3
do {
    instructions;
} while (condition);

El bucle continúa hasta que la condición se vuelve falsa. Aquí, el bucle se ejecuta al menos una vez. La estructura algorítmica correspondiente es la estructura “repetir … hasta que”:

1
2
3
repeat
    actions
until not condition

Estructura general de bucle (for)

La sintaxis es la siguiente:

1
2
3
for (start_instructions; condition; end_of_loop_instructions) {
    instructions;
}

El bucle continúa mientras la condición sea verdadera (se evalúa antes de cada iteración). Las instrucciones [start_instructions] se ejecutan antes de entrar en el bucle por primera vez. Las instrucciones [end_of_loop_instructions] se ejecutan después de cada iteración del bucle. Las diversas instrucciones de [start_instructions] y de [end_of_loop_instructions] se separan con comas. La estructura algorítmica correspondiente es la siguiente:

1
2
3
4
5
start_instructions
while condition
    actions
    end_of_loop_instructions
endwhile

3.5.4.3. Instrucciones de control de bucles

Instrucción
Descripción
[break]
Sale del bucle [for], [while], [do ... while]
[continue]
pasa a la siguiente iteración de los bucles [for], [while], [do ... while]
[break label]
sale del bucle precedido por la etiqueta [label:], incluso si la instrucción está dentro de un bucle anidado
[continue label]
pasa a la siguiente iteración del bucle precedido por la etiqueta [label:]

3.5.4.4. Ejemplos

El programa [Basics19.java] es el siguiente:

// estructuras de repetición
void main() {
    // cuatro formas de calcular la suma de los 10 primeros enteros
    int i, sum, n = 10;
    for (i = 1, sum = 0; i <= n; i = i + 1) {
        sum = sum + i;
    }
    IO.println("for (1) : sum=" + sum);

    for (i = 1, sum = 0; i <= n; sum = sum + i, i = i + 1) {
    }
    IO.println("for (2) : sum=" + sum);

    i = 1;
    sum = 0;
    while (i <= n) {
        sum += i;
        i++;
    }
    IO.println("while : sum=" + sum);

    i = 1;
    sum = 0;
    do {
        sum += i++;
    } while (i <= n);
    IO.println("do while : sum=" + sum);

    // la variable del bucle puede declararse en el for: solo existe dentro del bucle
    int product = 1;
    for (int k = 1; k <= 5; k++) {
        product *= k;
    }
    IO.println("5! = " + product);

    // for-each: recorrer todos los elementos de un arreglo o una colección
    String[] friends = {"paul", "hélène", "jacques", "sylvie"};
    for (String name : friends) {
        IO.println(name);
    }

    // break y continue
    for (int k = 1; k <= 10; k++) {
        // los números pares se omiten
        if (k % 2 == 0) {
            continue;
        }
        // nos detenemos después de 7
        if (k > 7) {
            break;
        }
        IO.print(k + " ");
    }
    IO.println();

    // bucle infinito que se abandona con break: el primer múltiplo de 7 mayor que 50
    int multiple = 50;
    while (true) {
        multiple++;
        if (multiple % 7 == 0) {
            break;
        }
    }
    IO.println("first multiple of 7 greater than 50: " + multiple);

    // break con etiqueta: salimos de ambos bucles a la vez
    int[][] grid = {{1, 2, 3}, {4, -5, 6}, {7, 8, 9}};
    search:
    for (int row = 0; row < grid.length; row++) {
        for (int column = 0; column < grid[row].length; column++) {
            if (grid[row][column] < 0) {
                IO.println("first negative at [" + row + "][" + column + "]");
                break search;
            }
        }
    }
}

Resultados:

> java Basics19.java
for (1) : sum=55
for (2) : sum=55
while : sum=55
do while : sum=55
5! = 120
paul
hélène
jacques
sylvie
1 3 5 7 
first multiple of 7 greater than 50: 56
first negative at [1][1]

Comentarios:

  • líneas 3–27: cuatro maneras de calcular la suma de los primeros 10 enteros;
  • líneas 5–7: un [for] estándar;
  • líneas 10–11: todo el trabajo se hace en las instrucciones de fin de bucle; el cuerpo del bucle está vacío. Java también acepta la sintaxis [for (...);], sin cuerpo, pero un punto y coma colocado por error después de un [for] es un error clásico y difícil de detectar. Un bloque vacío { } expresa lo mismo sin ambigüedad;
  • línea 25: [i++] devuelve el valor de [i] antes de incrementarlo: [i] se suma a [sum], y luego [i] se incrementa;
  • línea 31: la forma más común de [for]: la variable del bucle se declara en el [for] y existe solo dentro del bucle;
  • líneas 38–40: el bucle for-each recorre los elementos del arreglo [friends];
  • líneas 43–53: [continue] pasa a la siguiente iteración para los números pares; [break] termina el bucle en cuanto [k] supera 7;
  • líneas 58–63: un bucle infinito [while (true)], del que se sale mediante [break]. Esta forma es conveniente cuando la condición de terminación se calcula en medio del bucle. La usaremos para la entrada por teclado;
  • líneas 67–76: búsqueda del primer número negativo en un arreglo bidimensional. La etiqueta [search:] (línea 68) nombra el bucle externo; la instrucción [break search;] (línea 73) sale de ambos bucles a la vez. Un simple [break] saldría solo del bucle interno. Java no tiene una instrucción [goto] (la palabra clave está reservada pero no se usa): las etiquetas cumplen esta función en este caso específico.

3.6. Manejo de excepciones

Muchos métodos de Java pueden lanzar excepciones, es decir, errores. Cuando un método puede lanzar una excepción, el programador debe manejarla para crear programas más tolerantes a errores: siempre se debe evitar la terminación abrupta de una aplicación.

3.6.1. La estructura try/catch/finally

El manejo de excepciones sigue este patrón:

1
2
3
4
5
6
try {
    code likely to throw an exception
} catch (Exception e) {
    handle the exception e
}
next statement

Si el código del bloque [try] no lanza una excepción, la ejecución continúa con la siguiente instrucción; de lo contrario, la ejecución pasa al cuerpo del bloque [catch] y luego a la siguiente instrucción. Observe los siguientes puntos:

  • [e] es un objeto de tipo [Exception] o de un tipo derivado. Hay muchos tipos de excepciones: [ArrayIndexOutOfBoundsException], [NumberFormatException], [ArithmeticException], [IllegalArgumentException], [NullPointerException], [IOException], etc. Al escribir [catch (Exception e)], se indica que se desea manejar todos los tipos de excepciones. Si el código de la cláusula [try] puede generar varios tipos de excepciones, conviene ser más específico y manejar la excepción con varias cláusulas [catch]:
1
2
3
4
5
6
7
8
try {
    code likely to throw the exceptions
} catch (ArrayIndexOutOfBoundsException e1) {
    handle the exception e1
} catch (NumberFormatException e2) {
    handle the exception e2
}
next statement

Las cláusulas [catch] se evalúan en orden; se ejecuta la primera cuyo tipo coincide con la excepción. Por lo tanto, una cláusula que maneja un tipo de excepción específico debe preceder a una que maneja un tipo más general: el compilador rechaza una cláusula que nunca podría alcanzarse;

  • se puede agregar una cláusula [finally] a las cláusulas [try / catch]:
1
2
3
4
5
6
7
8
try {
    code likely to throw an exception
} catch (Exception e) {
    handle the exception e
} finally {
    code executed after try or catch
}
next statement

Ocurra o no una excepción, el código de la cláusula [finally] siempre se ejecuta. Esta cláusula se usaba para cerrar un archivo; veremos que ahora existe una forma más simple, el [try] con recursos;

  • en la cláusula [catch], puede que no se quiera usar el objeto de excepción. Sin embargo, hay que darle un nombre: desde Java 22, se puede escribir [catch (NumberFormatException _)], donde el carácter _ designa una variable anónima que no se usará;
  • La clase [Exception] tiene un método, [getMessage()], que devuelve el mensaje con el detalle del error ocurrido. Para mostrarlo, se escribe:
1
2
3
4
} catch (Exception ex) {
    System.err.println("The following error occurred: " + ex.getMessage());
    ...
}
  • El método [toString()] de una excepción devuelve el nombre completo de su clase seguido de su mensaje; su método [printStackTrace()] muestra además la pila de llamadas, es decir, la lista de métodos que se estaban ejecutando en el momento del error, junto con el nombre del archivo fuente y el número de línea. Esta es la información más útil para el desarrollador, pero no está destinada al usuario. En este curso, la mayoría de las veces mostraremos el nombre de la clase de la excepción ([ex.getClass().getName()] o [ex.getClass().getSimpleName()]) y su mensaje.

3.6.2. Un primer ejemplo

El programa [Basics20.java] muestra una excepción generada al usar un elemento de arreglo inexistente:

// una excepción causada por un índice de arreglo incorrecto
void main() {
    int[] tab = {0, 1, 2, 3};
    // visualización del arreglo con un for
    for (int i = 0; i < tab.length; i++) {
        IO.println("tab[" + i + "]=" + tab[i]);
    }
    // visualización del arreglo con un for-each
    for (int elmt : tab) {
        IO.println(elmt);
    }
    // generación de una excepción
    try {
        tab[100] = 6;
    } catch (Exception e) {
        System.err.println("The following error occurred: "
                + e.getClass().getName() + " - " + e.getMessage());
        return;
    } finally {
        IO.println("finally ...");
    }
    IO.println("This line is not executed");
}

Resultados:

> java Basics20.java
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
The following error occurred: java.lang.ArrayIndexOutOfBoundsException - Index 100 out of bounds for length 4
finally ...

Comentarios:

  • línea 14: esta instrucción lanza una excepción porque el arreglo [tab] no tiene un elemento con índice 100;
  • línea 15: la cláusula [catch (Exception e)] captura todas las excepciones;
  • líneas 16–17: la excepción es de tipo [java.lang.ArrayIndexOutOfBoundsException], y su mensaje indica el índice incorrecto y el tamaño del arreglo (línea 10 de los resultados);
  • línea 18: el programa sale del método [main] y, por lo tanto, del programa;
  • líneas 19–20: se ejecutó la cláusula [finally] (línea 11 de los resultados), a pesar de que la cláusula [catch] contenía una instrucción [return]. Observe que la cláusula [finally] siempre se ejecuta;
  • línea 22: debido a [return], esta línea no se ejecuta.

3.6.3. Una entrada validada

Este es otro ejemplo, [Basics21.java], en el que manejamos la excepción causada al convertir en entero una cadena que no representa un entero:

// ingreso de una edad con manejo de la excepción de conversión
void main() {
    // pedimos el nombre
    String name = Objects.requireNonNullElse(IO.readln("Name: "), "");
    // pedimos la edad
    int age = 0;
    boolean ageOK = false;
    while (!ageOK) {
        // pregunta, lectura y verificación de la respuesta
        try {
            age = Integer.parseInt(IO.readln("age: "));
            ageOK = age >= 1;
        } catch (NumberFormatException _) {
            // ageOK sigue siendo false
        }
        if (!ageOK) {
            IO.println("Incorrect age, try again...");
        }
    }
    // visualización final
    IO.println("Your name is " + name + " and you are " + age + " year(s) old");
}

Resultados:

1
2
3
4
> java Basics21.java
Name: dupont
age: 23
Your name is dupont and you are 23 year(s) old
> java Basics21.java
Name: durand
age: x
Incorrect age, try again...
age: -4
Incorrect age, try again...
age: 99999999999
Incorrect age, try again...
age: 12
Your name is durand and you are 12 year(s) old

Comentarios:

  • línea 4: si el flujo de entrada está cerrado, [IO.readln] devuelve [null]; [Objects.requireNonNullElse] lo reemplaza por una cadena vacía;
  • líneas 8–19: el bucle de entrada de la edad;
  • línea 11: la línea ingresada por el teclado se convierte en entero mediante el método [Integer.parseInt]. Este método lanza una excepción [NumberFormatException] si la conversión no es posible, incluso cuando la cadena es [null]. Por eso la operación se colocó dentro de un [try / catch];
  • línea 12: si se llega a esta línea, significa que la conversión tuvo éxito. Sin embargo, verificamos que el entero obtenido sea mayor o igual que 1;
  • línea 13: si se lanza una excepción [NumberFormatException], el control pasa a [catch], donde no se hace nada. Así, la variable booleana [ageOK], inicializada en [false], permanece en [false]. La variable de la excepción, que no se usa, es la variable anónima _. Solo se captura la excepción esperada: una cláusula [catch (Exception _)] también enmascararía errores que no se anticiparon;
  • líneas 16–18: se muestra un mensaje de error si la edad es incorrecta.

Un número demasiado grande para un [int], como 99999999999, también provoca una [NumberFormatException]: por lo tanto, se maneja como las demás entradas incorrectas (segunda ejecución).

3.6.4. Varias cláusulas catch y lanzamiento de excepciones

El propio programa puede lanzar una excepción mediante la instrucción [throw]:

throw new IllegalArgumentException("error message");

La ejecución del método actual se detiene y la excepción se propaga a través de los métodos que lo llamaron hasta que una cláusula [catch] la maneja; si ninguna lo hace, el programa termina y muestra la excepción y la pila de llamadas. En una cláusula [catch], la instrucción [throw e;] vuelve a lanzar la excepción actual, por ejemplo, después de registrarla.

Java no tiene un filtro para las cláusulas [catch]: para manejar una excepción solo en ciertos casos, se prueba la condición dentro de la cláusula y se vuelve a lanzar la excepción si es necesario. Para verificar un parámetro que no debe ser [null], se usa el método [Objects.requireNonNull(value, message)]: devuelve el valor si no es nulo y, en caso contrario, lanza una [NullPointerException] con el mensaje especificado.

El programa [Basics22.java] ilustra estas posibilidades:

// varias cláusulas catch, lanzamiento de excepciones
void main() {
    String[] inputs = {"12", "abc", "", "99999999999", "-3", "150"};
    for (String input : inputs) {
        try {
            int age = readAge(input);
            IO.println("[" + input + "] : age=" + age);
        } catch (NumberFormatException e) {
            // sin filtro en una cláusula catch: probamos dentro de la cláusula
            if (input.isEmpty()) {
                IO.println("[" + input + "] : empty input");
            } else {
                IO.println("[" + input + "] : " + e.getClass().getSimpleName() + " - " + e.getMessage());
            }
        } catch (IllegalArgumentException e) {
            IO.println("[" + input + "] : " + e.getClass().getSimpleName() + " - " + e.getMessage());
        }
    }

    // Objects.requireNonNull lanza una NullPointerException si la referencia es null
    String[] names = {"dupont", null};
    for (String name : names) {
        try {
            String valid = Objects.requireNonNull(name, "the name is mandatory");
            IO.println("name=" + valid);
        } catch (NullPointerException e) {
            IO.println(e.getClass().getSimpleName() + " - " + e.getMessage());
        }
    }
}

// un método que lanza excepciones
int readAge(String text) {
    // Integer.parseInt lanza NumberFormatException
    int age = Integer.parseInt(text);
    // lanzamos nosotros mismos una excepción si la edad está fuera de los límites
    if (age < 0 || age > 130) {
        throw new IllegalArgumentException("age out of bounds [0,130]: " + age);
    }
    return age;
}

Resultados:

1
2
3
4
5
6
7
8
9
> java Basics22.java
[12] : age=12
[abc] : NumberFormatException - For input string: "abc"
[] : empty input
[99999999999] : NumberFormatException - For input string: "99999999999"
[-3] : IllegalArgumentException - age out of bounds [0,130]: -3
[150] : IllegalArgumentException - age out of bounds [0,130]: 150
name=dupont
NullPointerException - the name is mandatory

Comentarios:

  • línea 3: entradas simuladas, válidas o no;
  • línea 6: el método [readAge] (líneas 33–41) puede lanzar varios tipos de excepciones;
  • línea 8: las entradas "abc", "" y "99999999999" provocan una [NumberFormatException];
  • líneas 10–14: a falta de un filtro, la entrada vacía se distingue dentro de la cláusula [catch];
  • línea 15: la excepción lanzada por el propio [readAge] ;
  • línea 24: [Objects.requireNonNull] lanza una [NullPointerException] si [name] es igual a [null]; su mensaje es el que se pasó como segundo parámetro (línea 9 de los resultados);
  • línea 38: el método [readAge] lanza una excepción si la edad está fuera de los límites.

El orden de las cláusulas [catch] de las líneas 8 y 15 importa: la clase [NumberFormatException] deriva de la clase [IllegalArgumentException] (una [NumberFormatException] es un caso particular de argumento incorrecto). Si se invierten las dos cláusulas, la cláusula [IllegalArgumentException] también intercepta las excepciones [NumberFormatException], y el compilador rechaza la cláusula que se volvió inalcanzable:

1
2
3
4
Basics22.java:10: error: exception NumberFormatException has already been caught
        } catch (NumberFormatException e) {
          ^
1 error

3.6.5. Excepciones verificadas y no verificadas

Esta es una característica importante de Java. Las excepciones son objetos cuyas clases forman una jerarquía:

Image

  • la clase raíz es [Throwable];
  • la clase [Error] y sus subclases indican problemas graves de la máquina virtual ([OutOfMemoryError], [StackOverflowError]...), que un programa normalmente no intenta capturar;
  • la clase [RuntimeException] y sus derivadas ([NullPointerException], [ArithmeticException], [ArrayIndexOutOfBoundsException], [IllegalArgumentException], [NumberFormatException]...) indican por lo general errores de programación o datos incorrectos;
  • las demás clases derivadas de [Exception] ([IOException], [InterruptedException], [ParseException], [SQLException]...) informan de incidentes causados por el entorno del programa (archivo inexistente, caída de la red, base de datos fuera de servicio) que un programa correcto debe prever.

Las excepciones de esta última categoría se denominan "excepciones verificadas" (checked): el compilador comprueba que un método capaz de lanzar una de ellas, ya sea directamente o al llamar a otro método, la capture mediante una cláusula [catch] o la declare en su firma con la palabra clave [throws]:

String readFile(String name) throws IOException { ... }

La responsabilidad se transfiere entonces a los métodos que lo llaman. Las excepciones derivadas de [RuntimeException] y de [Error] se denominan "no verificadas" (unchecked): pueden capturarse, pero el compilador no lo exige y no es necesario declararlas. Muchos otros lenguajes, como C# o Kotlin, solo tienen excepciones no verificadas.

El programa [Basics23.java] ilustra estos distintos casos:

// excepciones verificadas y no verificadas
void main() {
    // 1 - readFile declara una excepción verificada (IOException): debe capturarse
    try {
        String content = readFile("missing.txt");
        IO.println(content);
    } catch (IOException e) {
        IO.println("readFile : " + e.getClass().getName() + " - " + e.getMessage());
    }
    // 2 - lo mismo con InterruptedException, declarada por waitFor
    try {
        waitFor(100);
        IO.println("wait of 100 ms finished");
    } catch (InterruptedException e) {
        IO.println("wait interrupted");
    }
    // 3 - una excepción no verificada no tiene que declararse ni capturarse
    try {
        IO.println("divide(1, 0) = " + divide(1, 0));
    } catch (ArithmeticException e) {
        IO.println("divide : " + e.getClass().getName() + " - " + e.getMessage());
    }
    // 4 - una excepción verificada envuelta en una excepción no verificada
    try {
        IO.println(readConfiguration("absent.properties"));
    } catch (UncheckedIOException e) {
        IO.println(e.getMessage() + " ; cause : " + e.getCause().getClass().getSimpleName());
    }
    // 5 - el lugar de algunas excepciones en la jerarquía de clases
    IO.println(ancestors(new NoSuchFileException("x")));
    IO.println(ancestors(new NumberFormatException()));
    IO.println(ancestors(new OutOfMemoryError()));
}

// Files.readString lanza una IOException (verificada): la declaramos
String readFile(String name) throws IOException {
    return Files.readString(Path.of(name));
}

// Thread.sleep lanza una InterruptedException (verificada)
void waitFor(long milliseconds) throws InterruptedException {
    Thread.sleep(milliseconds);
}

// una ArithmeticException no es verificada: sin cláusula throws
int divide(int a, int b) {
    return a / b;
}

// la IOException se captura y luego se relanza como excepción no verificada
String readConfiguration(String name) {
    try {
        return Files.readString(Path.of(name));
    } catch (IOException e) {
        throw new UncheckedIOException("unreadable configuration: " + name, e);
    }
}

// la cadena de clases padre de la clase de un objeto
String ancestors(Object o) {
    StringBuilder chain = new StringBuilder();
    for (Class<?> type = o.getClass(); type != null; type = type.getSuperclass()) {
        if (!chain.isEmpty()) {
            chain.append(" -> ");
        }
        chain.append(type.getSimpleName());
    }
    return chain.toString();
}

Resultados:

1
2
3
4
5
6
7
8
> java Basics23.java
readFile : java.nio.file.NoSuchFileException - missing.txt
wait of 100 ms finished
divide : java.lang.ArithmeticException - / by zero
unreadable configuration: absent.properties ; cause : NoSuchFileException
NoSuchFileException -> FileSystemException -> IOException -> Exception -> Throwable -> Object
NumberFormatException -> IllegalArgumentException -> RuntimeException -> Exception -> Throwable -> Object
OutOfMemoryError -> VirtualMachineError -> Error -> Throwable -> Object

Comentarios:

  • Líneas 36–38: el método [Files.readString] (capítulo 5) lee todo el contenido de un archivo; puede lanzar una [IOException], que es verificada. El método [readFile] no la intercepta: por lo tanto, debe declararla mediante [throws IOException];
  • líneas 4–9: a su vez, el método [main], que llama a [readFile], debe tratar la [IOException]. Como el archivo no existe, la excepción lanzada es una [NoSuchFileException], una clase derivada de [IOException], cuyo mensaje es el nombre del archivo;
  • líneas 41–43: [Thread.sleep] suspende el programa durante el tiempo indicado en milisegundos; puede lanzar una [InterruptedException] (verificada), que abordaremos en el capítulo 8;
  • líneas 11–16: la llamada a [waitFor] debe, por lo tanto, colocarse también dentro de un [try / catch];
  • líneas 46–48: una división entera puede provocar una [ArithmeticException] no verificada; no se requiere ninguna cláusula [throws];
  • líneas 18–22: el llamador captura la excepción de todos modos porque así lo decide;
  • líneas 51–57: una técnica habitual cuando un método no puede o no quiere declarar una excepción verificada: interceptarla y lanzar en su lugar una excepción no verificada (en este caso, una [UncheckedIOException] (Java 8)), pasando la excepción original como su causa;
  • línea 27: [getCause()] vuelve a lanzar la excepción original;
  • líneas 60–69: el método [ancestors] recorre la cadena de clases padre de un objeto ([getSuperclass()]) hasta la clase [Object], la raíz de todas las clases;
  • líneas 30–32: la jerarquía descrita anteriormente se refleja en los resultados (líneas 6–8).

Si se elimina la cláusula [throws IOException] de la línea 36, el compilador rechaza el programa. Señala tanto la excepción no tratada en [readFile] como la cláusula [catch], que se ha vuelto redundante en [main], ya que ningún método llamado declara ya [IOException]:

1
2
3
4
5
6
7
Basics23.java:7: error: exception IOException is never thrown in body of corresponding try statement
    } catch (IOException e) {
      ^
Basics23.java:37: error: unreported exception IOException; must be caught or declared to be thrown
    return Files.readString(Path.of(name));
                           ^
2 errors

El propio método [main] puede lanzar excepciones: [void main() throws IOException]. Una excepción no capturada termina entonces el programa, que muestra la excepción y la pila de llamadas y finaliza con un código de retorno 1. Esto es aceptable para un pequeño programa de prueba, pero no para una aplicación en producción. Las excepciones verificadas se consideran a veces demasiado restrictivas, y muchas bibliotecas recientes (Spring, Hibernate, que usaremos más adelante) utilizan únicamente excepciones no verificadas. En este curso, capturamos una excepción verificada donde sabemos cómo tratarla y, en caso contrario, la envolvemos en una excepción no verificada.

3.6.6. Liberación de recursos: el bloque try con recursos

Un recurso (un archivo abierto, una conexión de red, una conexión a una base de datos) debe cerrarse después de su uso, incluso si se produce un error mientras se utiliza. Antes de Java 7, se cerraba dentro de una cláusula [finally], lo que requería varias líneas de código complejo. Java 7 introdujo la instrucción try-with-resources:

1
2
3
try (Type resource = ...) {
    use of the resource
}

El recurso declarado entre paréntesis se cierra automáticamente (mediante una llamada a su método [close()]) cuando termina el bloque, ya sea que finalice normalmente o a causa de una excepción. El tipo del recurso debe implementar la interfaz [AutoCloseable], que contiene únicamente el método [close()]; este es el caso de todas las clases de Java para archivos, red y bases de datos. Se pueden declarar varios recursos, separados por punto y coma: se cierran en el orden inverso al de su apertura. Un [try] de este tipo puede tener cláusulas [catch] y [finally] , que se ejecutan después de cerrar los recursos.

Java 7 también introdujo multi-catch: una sola cláusula [catch] puede tratar varios tipos de excepción separados por el carácter |: [catch (NumberFormatException | ArithmeticException e)]. Los tipos enumerados no deben derivar unos de otros.

El programa [Basics24.java] es el siguiente:

// try-with-resources y multi-catch
void main() throws IOException {
    // 1 - un recurso se cierra automáticamente al salir del try
    try (Resource r = open("R1")) {
        IO.println("using " + r.name());
    }
    // 2 - varios recursos: se cierran en el orden inverso al de su apertura,
    // incluso si ocurre una excepción, y antes de ejecutar las cláusulas catch y finally
    try (Resource r2 = open("R2"); Resource r3 = open("R3")) {
        IO.println("using " + r2.name() + " and " + r3.name());
        throw new IllegalStateException("incident during use");
    } catch (IllegalStateException e) {
        IO.println("catch : " + e.getMessage());
    } finally {
        IO.println("finally");
    }
    // 3 - un BufferedReader es un recurso; readLine lanza una IOException (verificada)
    try (BufferedReader reader = new BufferedReader(new StringReader("line 1\nline 2"))) {
        String line;
        while ((line = reader.readLine()) != null) {
            IO.println("read: " + line);
        }
    }
    // 4 - multi-catch (Java 7): el mismo tratamiento para varios tipos de excepción
    String[][] operations = {{"10", "2"}, {"10", "zero"}, {"10", "0"}};
    for (String[] operation : operations) {
        try {
            int a = Integer.parseInt(operation[0]);
            int b = Integer.parseInt(operation[1]);
            IO.println(a + " / " + b + " = " + a / b);
        } catch (NumberFormatException | ArithmeticException e) {
            IO.println(Arrays.toString(operation) + " : "
                    + e.getClass().getSimpleName() + " - " + e.getMessage());
        }
    }
}

// un recurso: un objeto que implementa la interfaz AutoCloseable (capítulo 4)
record Resource(String name) implements AutoCloseable {
    @Override
    public void close() {
        IO.println("closing " + name);
    }
}

Resource open(String name) {
    IO.println("opening " + name);
    return new Resource(name);
}

Resultados:

> java Basics24.java
opening R1
using R1
closing R1
opening R2
opening R3
using R2 and R3
closing R3
closing R2
catch : incident during use
finally
read: line 1
read: line 2
10 / 2 = 5
[10, zero] : NumberFormatException - For input string: "zero"
[10, 0] : ArithmeticException - / by zero

Comentarios:

  • línea 2: el método [main] declara la excepción verificada [IOException], que puede ser lanzada por el método [readLine] en la línea 20 y que no capturamos;
  • Líneas 39–44: un recurso de demostración. Es un record (capítulo 4), una clase muy simple en la que cada objeto tiene un nombre; implementa la interfaz [AutoCloseable] definiendo el método [close()], que muestra un mensaje;
  • líneas 46–49: el método [open] muestra un mensaje y crea un recurso;
  • líneas 4–6: el recurso [r] se cierra automáticamente al final del bloque (línea 4 de los resultados);
  • líneas 9–16: dos recursos. Se lanza una excepción mientras están en uso (línea 11). Los resultados (líneas 5–11) muestran que R3 se cierra antes que R2, y que ambos se cierran antes de la ejecución de las cláusulas [catch] y [finally];
  • línea 18: un [BufferedReader] que aquí lee una cadena como si fuera un archivo. Lo usaremos en el capítulo 5 para leer archivos reales;
  • línea 20: [readLine()] devuelve la siguiente línea, o [null] al final del texto. La asignación se realiza dentro de la condición del [while]: el valor de la expresión [(line = reader.readLine())] es el valor asignado;
  • línea 31: un multi-catch: la misma acción para una [NumberFormatException] (línea 15 de los resultados) y para una [ArithmeticException] (línea 16).

3.7. Aplicación de ejemplo - V1

Queremos escribir un programa que calcule el impuesto de un contribuyente. Consideraremos el caso simplificado de un contribuyente que tiene un único salario que declarar. Las cifras provienen del baremo fiscal de 2004 para los ingresos de 2003 y se utilizan tal cual: se trata de un ejercicio de programación, no de un cálculo de impuestos vigentes. Esta aplicación servirá como hilo conductor: volveremos a ella en los capítulos siguientes, incorporando clases, archivos, una base de datos y luego funcionalidades de red.

  • Calculamos el número de partes del empleado: partes = nbChildren/2 + 1 si es soltero, nbChildren/2 + 2 si es casado, donde nbChildren es el número de 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 usando la siguiente tabla:
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 3 campos. Para calcular el impuesto I, se busca la primera fila en la que QF es menor o igual que el límite. Por ejemplo, si QF = 5000, se encontrará la fila:

8382    0.068    291.09

El impuesto I es entonces igual a 0.068 * R - 291.09 * partes, redondeado al euro más cercano. Si QF es tal que la condición QF <= límite nunca se cumple, se utilizan los coeficientes de la última fila: I = 0.481 * R - 9505.54 * partes. Por lo tanto, el límite 0 de la última fila nunca se utiliza.

Los cálculos involucran montos y coeficientes decimales: los realizamos con la clase [BigDecimal]. El programa Java correspondiente, [Tax1.java], es el siguiente:

// cálculo del impuesto - versión 1
// baremo del impuesto de 2004 (ingresos de 2003): es un ejercicio, no el baremo vigente
void main() {
    // arreglos de datos necesarios para el cálculo del impuesto
    BigDecimal[] limits = decimals("4962", "8382", "14753", "23888", "38868", "47932", "0");
    BigDecimal[] coeffR = decimals("0", "0.068", "0.191", "0.283", "0.374", "0.426", "0.481");
    BigDecimal[] coeffN = decimals("0", "291.09", "1322.92", "2668.39", "4846.98", "6883.66", "9505.54");

    // estado civil
    String answer;
    while (true) {
        answer = read("Are you married (Y/N)? ").toLowerCase();
        if (answer.equals("y") || answer.equals("n")) {
            break;
        }
        System.err.println("Incorrect answer. Try again");
    }
    boolean married = answer.equals("y");

    // número de hijos
    int nbChildren;
    while (true) {
        try {
            nbChildren = Integer.parseInt(read("Number of children: "));
            if (nbChildren >= 0) {
                break;
            }
        } catch (NumberFormatException _) {
            // entrada no numérica: se empieza de nuevo
        }
        System.err.println("Incorrect answer. Try again");
    }

    // salario anual
    int salary;
    while (true) {
        try {
            salary = Integer.parseInt(read("Annual salary: "));
            if (salary >= 0) {
                break;
            }
        } catch (NumberFormatException _) {
            // entrada no numérica: se empieza de nuevo
        }
        System.err.println("Incorrect answer. Try again");
    }

    // 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"));
    }

    // ingreso gravable
    BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));

    // cociente familiar (la división puede no resultar exacta: se fija una precisión)
    BigDecimal quotient = income.divide(shares, MathContext.DECIMAL128);

    // búsqueda del tramo del impuesto: el primero tal que quotient <= limit,
    // el último si ninguno encaja
    int i = 0;
    while (i < limits.length - 1 && quotient.compareTo(limits[i]) > 0) {
        i++;
    }

    // el impuesto (truncado al euro)
    int tax = coeffR[i].multiply(income).subtract(coeffN[i].multiply(shares)).intValue();

    // visualización del resultado
    IO.println("Tax to pay: " + tax + " euros");
}

// muestra un mensaje, lee una línea y la devuelve sin espacios iniciales ni finales
// (cadena vacía si el flujo de entrada está agotado)
String read(String prompt) {
    return Objects.requireNonNullElse(IO.readln(prompt), "").trim();
}

// convierte cadenas en números BigDecimal exactos
BigDecimal[] decimals(String... values) {
    BigDecimal[] numbers = new BigDecimal[values.length];
    for (int i = 0; i < values.length; i++) {
        numbers[i] = new BigDecimal(values[i]);
    }
    return numbers;
}

Comentarios:

  • Líneas 5–7: los tres arreglos de [BigDecimal] se construyen mediante el método [decimals] (líneas 82–88) a partir de cadenas de caracteres: cada valor, como 0.068, es así exacto. Con un [double], 0.068 sería solo una aproximación binaria. El método [decimals] acepta un número cualquiera de parámetros ([String... values]), que recibe en un arreglo; esta notación se explica en la sección "Paso de parámetros a una función";
  • líneas 10–18: ingreso del estado civil, en un bucle [while (true)] que termina con [break] cuando la respuesta es correcta;
  • línea 12: el método [read] (líneas 77–79) muestra el mensaje y lee la respuesta; si el flujo de entrada está cerrado, el valor [null] se reemplaza por una cadena vacía. El método [trim()] elimina los espacios iniciales y finales de la cadena leída, y [toLowerCase()] la convierte a minúsculas. Esto permite aceptar tanto Y como y;
  • línea 13: las cadenas se comparan con [equals], nunca con ==;
  • línea 16: los mensajes de error se escriben en el flujo [System.err];
  • línea 18: a la variable booleana [married] se le asigna el valor [true] o [false] a partir de la expresión [answer.equals("y")];
  • Líneas 21–32: ingreso del número de hijos. [Integer.parseInt] lanza una [NumberFormatException] si la entrada no es un entero: el programa pasa entonces a la cláusula [catch] (línea 28), que no hace nada, luego muestra el mensaje de error y vuelve a empezar. Si la conversión tiene éxito y el número es positivo o cero, se sale del bucle (línea 26). La variable [nbChildren], declarada sin valor en la línea 21, siempre tiene un valor al salir del bucle: el compilador lo verifica;
  • líneas 35–46: lo mismo para el salario;
  • líneas 49–50: el número de partes se calcula en [BigDecimal]. No se puede escribir simplemente [nbChildren / 2]: si nbChildren es 3, se obtendría 3/2, una división entera que daría 1 en lugar de 1.5. [BigDecimal.valueOf(nbChildren)] convierte el entero, [divide(BigDecimal.TWO)] lo divide entre dos (la constante [TWO] existe desde Java 19), y [add] suma 2 o 1. Las llamadas a métodos se encadenan: cada una se aplica al resultado de la anterior;
  • línea 52: un [BigDecimal] es inmutable: [add] no modifica [shares] sino que devuelve un nuevo objeto, que debe asignarse a la variable. Escribir solamente [shares.add(new BigDecimal("0.5"));] no tendría ningún efecto: es un error clásico;
  • línea 56: el ingreso imponible;
  • línea 59: el cociente familiar. Dividir el ingreso entre 1.5 o 3.5 partes generalmente no produce una representación decimal finita: se establece una precisión, aquí [MathContext.DECIMAL128] (34 dígitos significativos), que es más que suficiente;
  • líneas 63–66: determinación del tramo del impuesto. La búsqueda se detiene en el primer límite superior que es mayor o igual que el cociente familiar, y a más tardar en el último tramo, gracias a la condición [i < limits.length - 1]. Los operadores < y > no se aplican a [BigDecimal]: [quotient.compareTo(limits[i]) > 0] significa "quotient > limits[i]". Dos valores [BigDecimal] no se comparan con [equals], que tiene en cuenta el número de decimales: 2.0 y 2.00 no son "iguales" para [equals];
  • Línea 69: el monto del impuesto se redondea al euro más cercano mediante el método [intValue()], que descarta la parte decimal.

A continuación se muestran algunos ejemplos de salida:

1
2
3
4
5
> java Tax1.java
Are you married (Y/N)? y
Number of children: 2
Annual salary: 60000
Tax to pay: 4282 euros
> java Tax1.java
Are you married (Y/N)? yes
Incorrect answer. Try again
Are you married (Y/N)? y
Number of children: three
Incorrect answer. Try again
Number of children: 3
Annual salary: 60000 euros
Incorrect answer. Try again
Annual salary: 60000
Tax to pay: 2959 euros
> java Tax1.java
Are you married (Y/N)? n
Number of children: 0
Annual salary: 60000
Tax to pay: 11519 euros

Para un salario anual de 60,000 euros, un contribuyente casado con 2 hijos paga 4,282 euros; con 3 hijos, 2,959 euros; y una persona soltera sin hijos paga 11,519 euros. En la segunda ejecución, la entrada "60000 euros" se rechaza: [Integer.parseInt] solo acepta cadenas que representan un entero exacto (los espacios iniciales y finales fueron eliminados por [trim()]).

3.8. Argumentos del programa principal

El método [main] principal puede aceptar como parámetro un arreglo de cadenas [String[]]. Este arreglo contiene los argumentos de la línea de comandos con los que se inició la aplicación. Así, si iniciamos el programa P con el comando:

java P arg0 arg1 ... argn

y si el método [main] se declara de la siguiente manera:

    public static void main(String[] args) {

tendremos args[0]="arg0", args[1]="arg1", y así sucesivamente. En un archivo compacto, se puede obtener el mismo arreglo declarando [void main(String[] args)]. Con el lanzador de archivos de código fuente, los argumentos del programa se colocan después del nombre del archivo; las opciones del propio comando [java] (como [-cp] o [-D]) se colocan antes:

java Prog.java a0 a1 a2

Este es un ejemplo, [Basics25.java]:

1
2
3
4
5
6
7
// los argumentos de la línea de comandos en un archivo fuente compacto
void main(String[] args) {
    IO.println("There are " + args.length + " argument(s)");
    for (int i = 0; i < args.length; i++) {
        IO.println("args[" + i + "]=" + args[i]);
    }
}

Resultados:

1
2
3
4
5
6
> java Basics25.java a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Un argumento que contiene espacios debe ir entre comillas:

1
2
3
4
> java Basics25.java "jean dupont" 23
There are 2 argument(s)
args[0]=jean dupont
args[1]=23

El mismo programa escrito con una clase y un método estándar:

1
2
3
4
5
6
7
8
9
// los argumentos de la línea de comandos con un método main clásico
public class Basics26 {
    public static void main(String[] args) {
        System.out.println("There are " + args.length + " argument(s)");
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]=" + args[i]);
        }
    }
}

Resultados:

1
2
3
4
5
6
> java Basics26.java a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Comentarios:

  • línea 2: una clase pública, en el archivo [Basics26.java];
  • línea 3: el punto de entrada del programa, en su forma estándar;
  • líneas 4–7: el resto es idéntico a [Basics25.java], con [System.out.println] en lugar de [IO.println].

Una aplicación organizada en paquetes coloca sus clases en carpetas que corresponden a los nombres de los paquetes (capítulo 4); así también se organizan los proyectos Maven, que comenzaremos a usar en el capítulo 5. Por último, observe que en Java el método [main] no devuelve ningún valor: el código de salida del programa se establece mediante [System.exit].

3.9. Enumeraciones

Una enumeración es un tipo de datos cuyo dominio de valores consiste en un conjunto de constantes con nombre. Consideremos un programa que debe manejar calificaciones de exámenes. Hay cinco calificaciones posibles: Aprobado, Bastante bien, Bien, Muy bien y Excelente. Podemos entonces definir una enumeración para estas cinco constantes:

enum Honours { PASS, FAIRLY_GOOD, GOOD, VERY_GOOD, EXCELLENT }

Por convención, los nombres de las constantes se escriben en mayúsculas. Se puede declarar una variable que tome sus valores de la enumeración:

    Honours myHonours = Honours.PASS;

Se puede comparar una variable con los distintos valores posibles de la enumeración mediante el operador ==:

1
2
3
    if (myHonours == Honours.PASS) {
        IO.println("Could do better");
    }

A diferencia de otros lenguajes en los que una enumeración es simplemente un conjunto de enteros con nombre, una enumeración de Java es una clase, derivada de la clase [java.lang.Enum], cuyos únicos objetos son las constantes declaradas. Cada constante es un objeto único, creado una vez por todas; por eso se pueden comparar con ==. Cada constante conoce su nombre ([name()], o [toString()]) y su número de orden en la declaración ([ordinal()], a partir de 0). El compilador agrega dos métodos estáticos a cada enum:

  • [Honours.values()] devuelve el arreglo de constantes de la enumeración [Honours], en el orden en que fueron declaradas;
  • [Honours.valueOf(name)] devuelve la constante llamada [name], y lanza una [IllegalArgumentException] si ninguna constante tiene ese nombre.

Una enumeración no se puede convertir a un entero, ni un entero a una enumeración: hay que usar [ordinal()] y [values()].

El programa [Basics27.java] pone de relieve lo que acabamos de escribir:

// enumeraciones
enum Honours { PASS, FAIRLY_GOOD, GOOD, VERY_GOOD, EXCELLENT }

void main() {
    // una variable que toma sus valores de la enumeración Honours
    Honours myHonours = Honours.PASS;
    // visualización del valor de la variable
    IO.println("honours=" + myHonours);
    // prueba con un valor de la enumeración
    if (myHonours == Honours.PASS) {
        IO.println("Could do better");
    }
    // lista de las menciones: nombre y número ordinal
    for (Honours m : Honours.values()) {
        IO.println(m + " = " + m.ordinal());
    }
    // número ordinal -> enumeración
    Honours m3 = Honours.values()[3];
    IO.println("Honours.values()[3] = " + m3);
    // cadena -> enumeración
    Honours m2 = Honours.valueOf("GOOD");
    IO.println("m2=" + m2 + ", m2 after PASS : " + (m2.compareTo(Honours.PASS) > 0));
    try {
        Honours.valueOf("Good");
    } catch (IllegalArgumentException e) {
        IO.println("valueOf(\"Good\") : " + e.getMessage());
    }
    // una enumeración en una expresión switch: no se necesita default si se manejan todos los casos
    String assessment = switch (myHonours) {
        case PASS, FAIRLY_GOOD -> "correct";
        case GOOD, VERY_GOOD -> "very correct";
        case EXCELLENT -> "remarkable";
    };
    IO.println("assessment: " + assessment);
    IO.println("type: " + Honours.class.getName());
    IO.println("parent class: " + Honours.class.getSuperclass().getName());
}

Resultados:

> java Basics27.java
honours=PASS
Could do better
PASS = 0
FAIRLY_GOOD = 1
GOOD = 2
VERY_GOOD = 3
EXCELLENT = 4
Honours.values()[3] = VERY_GOOD
m2=GOOD, m2 after PASS : true
valueOf("Good") : No enum constant Basics27.Honours.Good
assessment: correct
type: Basics27$Honours
parent class: java.lang.Enum

Comentarios:

  • línea 2: la declaración de la enumeración. En un archivo compacto, se coloca junto a los métodos; en un programa organizado en clases, se declara, como una clase (capítulo 4), en su propio archivo, [Honours.java];
  • línea 6: una variable de tipo [Honours];
  • línea 8: una constante de enumeración se muestra por su nombre;
  • líneas 14–16: la lista de constantes y sus números de orden;
  • línea 18: la conversión de un número de orden a una constante;
  • línea 21: la conversión de una cadena a una constante de la enumeración;
  • línea 22: las constantes se comparan con [compareTo] según su orden de declaración: GOOD viene después de PASS;
  • líneas 23–27: [valueOf] distingue entre mayúsculas y minúsculas: "Good" no es el nombre de una constante;
  • líneas 29–33: las enumeraciones funcionan bien con las instrucciones switch. Las cláusulas [case] usan los nombres de las constantes sin anteponerles [Honours]. Como todas las constantes están cubiertas, la expresión es exhaustiva sin una cláusula [default]; si más adelante se agrega una constante a la enumeración, el compilador señalará la expresión switch como incompleta;
  • línea 35: el nombre completo de la enumeración es [Basics27$Honours]: en un archivo compacto, la enumeración es un tipo miembro de la clase implícita [Basics27], y el carácter $ separa los dos nombres;
  • línea 36: la clase padre de cualquier enumeración es [java.lang.Enum].

3.9.1. Enumeraciones avanzadas

Dado que una enumeración es una clase, puede tener campos, un constructor y métodos. Cada constante se crea entonces llamando al constructor con los parámetros escritos entre paréntesis después de su nombre. Esta es una característica muy utilizada en Java que evita tener que gestionar por separado arreglos de valores asociados a las constantes.

Para representar un conjunto de opciones, como los permisos de acceso a un archivo (lectura, escritura, ejecución), antes se combinaban potencias de 2 con el operador | (OR bit a bit). En Java, se usa un enum y la clase [EnumSet], un conjunto de constantes de un enum, que es tan eficiente como una combinación bit a bit (internamente lo es) pero mucho más legible. La clase [EnumMap] es, de manera similar, un diccionario cuyas claves son las constantes de una enumeración.

El programa [Basics28.java] es el siguiente:

// enumeraciones enriquecidas: campos, constructor, métodos; EnumSet y EnumMap
// cada mención tiene una nota mínima y una etiqueta
enum Honour {
    PASS(10, "Pass"),
    FAIRLY_GOOD(12, "Fairly good"),
    GOOD(14, "Good"),
    VERY_GOOD(16, "Very good"),
    EXCELLENT(18, "Excellent");

    // los campos de cada constante
    private final int minimumGrade;
    private final String label;

    // el constructor se llama una vez por cada constante
    Honour(int minimumGrade, String label) {
        this.minimumGrade = minimumGrade;
        this.label = label;
    }

    int getMinimumGrade() {
        return minimumGrade;
    }

    String getLabel() {
        return label;
    }

    // un método estático: la mención correspondiente a una nota (vacía si nota < 10)
    static Optional<Honour> forGrade(double grade) {
        Honour result = null;
        for (Honour m : values()) {
            if (grade >= m.minimumGrade) {
                result = m;
            }
        }
        return Optional.ofNullable(result);
    }
}

// derechos de acceso: un conjunto de valores se representará con un EnumSet
enum Right { READ, WRITE, EXECUTE }

void main() {
    for (Honour m : Honour.values()) {
        IO.println(m + " : \"" + m.getLabel() + "\" from " + m.getMinimumGrade());
    }
    double[] grades = {8.5, 12, 15.5, 19};
    for (double grade : grades) {
        String label = Honour.forGrade(grade).map(Honour::getLabel).orElse("no honours");
        IO.println("grade " + grade + " : " + label);
    }

    // EnumSet: un conjunto de valores de una enumeración (reemplaza las combinaciones de bits)
    EnumSet<Right> rights = EnumSet.of(Right.READ, Right.WRITE);
    IO.println("rights=" + rights + ", read : " + rights.contains(Right.READ)
            + ", execute : " + rights.contains(Right.EXECUTE));
    rights.add(Right.EXECUTE);
    rights.remove(Right.WRITE);
    IO.println("rights=" + rights);
    IO.println("all=" + EnumSet.allOf(Right.class) + ", none=" + EnumSet.noneOf(Right.class)
            + ", complement of [READ]=" + EnumSet.complementOf(EnumSet.of(Right.READ)));
    IO.println("from FAIRLY_GOOD to VERY_GOOD : " + EnumSet.range(Honour.FAIRLY_GOOD, Honour.VERY_GOOD));

    // EnumMap: un diccionario cuyas claves son los valores de una enumeración (capítulo 5)
    EnumMap<Honour, Integer> headcounts = new EnumMap<>(Honour.class);
    headcounts.put(Honour.GOOD, 7);
    headcounts.put(Honour.PASS, 12);
    IO.println("headcounts=" + headcounts);
}

Resultados:

> java Basics28.java
PASS : "Pass" from 10
FAIRLY_GOOD : "Fairly good" from 12
GOOD : "Good" from 14
VERY_GOOD : "Very good" from 16
EXCELLENT : "Excellent" from 18
grade 8.5 : no honours
grade 12.0 : Fairly good
grade 15.5 : Good
grade 19.0 : Excellent
rights=[READ, WRITE], read : true, execute : false
rights=[READ, EXECUTE]
all=[READ, WRITE, EXECUTE], none=[], complement of [READ]=[WRITE, EXECUTE]
from FAIRLY_GOOD to VERY_GOOD : [FAIRLY_GOOD, GOOD, VERY_GOOD]
headcounts={PASS=12, GOOD=7}

Comentarios:

  • líneas 4–8: las constantes de la enumeración, cada una con sus dos parámetros. El punto y coma después de la última constante es obligatorio cuando le siguen miembros;
  • líneas 11–12: los campos de cada constante. Son [private] (accesibles solo dentro de la enumeración) y [final] (asignados una vez por todas);
  • líneas 15–18: el constructor, llamado una vez por cada constante cuando la enumeración se usa por primera vez. La palabra clave [this] se refiere al objeto que se está construyendo: [this.minimumGrade] es el campo, y [minimumGrade] es el parámetro. El constructor de una enumeración es implícitamente privado: no se pueden crear constantes adicionales;
  • líneas 20–26: dos métodos que devuelven los valores de los campos. Los nombres [getMinimumGrade] y [getLabel] siguen la convención de Java para getters y setters, como se describe en el capítulo 4;
  • líneas 29–37: un método estático, que se llama sobre el propio enum ([Honour.forGrade(grade)]). Como las constantes se declaran en orden ascendente de puntaje, la última que alcanza el puntaje mínimo es la correcta. El resultado es un [Optional], que está vacío si el puntaje es inferior a 10;
  • línea 41: una enumeración simple para derechos de acceso;
  • líneas 44–46: la lista de elementos con sus campos;
  • línea 49: [map(Honour::getLabel)] transforma un [Optional<Honour>] en un [Optional<String>] que contiene la etiqueta; [orElse] proporciona un texto cuando el [Optional] está vacío;
  • línea 54: un conjunto de dos derechos;
  • líneas 55–56: el método [contains] comprueba si una constante pertenece al conjunto, tal como se comprobaría un bit;
  • líneas 57–58: se agregan y se quitan constantes;
  • líneas 60–61: el conjunto de todas las constantes, el conjunto vacío y el complemento de un conjunto;
  • línea 62: las constantes comprendidas entre dos constantes, en el orden en que fueron declaradas;
  • líneas 65–68: un [EnumMap] asocia un conjunto de valores a ciertas entradas. Sus claves se recorren siempre en el orden en que se declararon las constantes: PASS aparece antes que GOOD, aunque se haya agregado después. Los diccionarios se tratan en el capítulo 5.

3.10. Paso de parámetros a una función

En Java, las funciones se denominan métodos: siempre pertenecen a una clase, posiblemente la clase implícita de un archivo compacto. Aquí nos centramos en cómo se pasan los parámetros a un método. Consideremos el siguiente método:

1
2
3
4
void changeInt(int a) {
    a = 30;
    IO.println("Formal parameter a=" + a);
}

En la definición del método, en la línea 1, [a] se denomina parámetro formal. Se incluye únicamente para definir el método [changeInt]. Podría haberse llamado igualmente [b]. Consideremos ahora una llamada a este método:

1
2
3
    int age = 20;
    changeInt(age);
    IO.println("Actual parameter age=" + age);

Aquí, en la instrucción de la línea 2, [age] es el parámetro real que transmitirá su valor al parámetro formal [a]. Nos interesa saber cómo un parámetro formal obtiene el valor de un parámetro real.

3.10.1. Paso por valor: el único modo de paso de parámetros de Java

Java solo tiene un modo de paso de parámetros: el paso por valor. El valor del parámetro real se copia en el parámetro formal correspondiente. Son dos entidades distintas: si el método modifica el parámetro formal, el parámetro real permanece sin cambios.

Cuando el parámetro es de un tipo por referencia (un arreglo, un objeto), el valor copiado es la referencia: el parámetro formal y el parámetro real hacen entonces referencia al mismo objeto. Por lo tanto, el método puede modificar este objeto, si es modificable, y el llamador verá el cambio; sin embargo, no puede hacer que la variable del llamador haga referencia a otro objeto.

A diferencia de otros lenguajes, Java no admite el paso por referencia, en el que el parámetro formal y el parámetro real serían una sola y misma variable: un método no puede modificar una variable local de su llamador, ni "devolverle" resultados a través de sus parámetros. En su lugar, se utiliza:

  • el valor de retorno del método, que el llamador asigna a su variable;
  • un record cuando el método necesita devolver varios valores;
  • un arreglo o un objeto mutable pasado como parámetro, en el que el método deposita sus resultados.

Además, a un parámetro declarado como [final] no se le puede asignar un nuevo valor dentro del método: el compilador garantiza así que conserve el valor transmitido por el llamador.

El programa [Basics29.java] ilustra estos distintos casos:

// paso de parámetros: siempre por valor
void main() {
    // 1 - paso por valor: el parámetro real no se modifica
    int age = 20;
    changeInt(age);
    IO.println("Actual parameter age=" + age);

    // 2 - para modificar una variable del llamador: el método devuelve el nuevo valor
    int age2 = 20;
    age2 = changeInt2(age2);
    IO.println("Actual parameter age2=" + age2);

    // 3 - para devolver varios valores: un record
    Conversion c1 = convert("123");
    Conversion c2 = convert("12x");
    IO.println("c1=" + c1 + ", c2=" + c2);
    if (c1.succeeded()) {
        IO.println("value of c1: " + c1.value());
    }

    // 4 - un intercambio de valores: los valores se almacenan en un arreglo
    int[] xy = {1, 2};
    swap(xy);
    IO.println("after swap: x=" + xy[0] + ", y=" + xy[1]);

    // 5 - un arreglo pasado por valor: se copia su referencia
    int[] array = {1, 2, 3};
    modifyArray(array);
    IO.println("array=" + Arrays.toString(array));

    // 6 - un objeto modificable (mutable): el método modifica el objeto referenciado
    StringBuilder message = new StringBuilder("Hello");
    complete(message);
    IO.println("message=" + message);

    // 7 - un parámetro final no puede recibir un nuevo valor en el método
    BigDecimal price = new BigDecimal("100");
    IO.println("InclTax(" + price + ")=" + inclTax(price));
}

// el resultado de una conversión: éxito y valor obtenido
record Conversion(boolean succeeded, int value) {}

void changeInt(int a) {
    a = 30;
    IO.println("Formal parameter a=" + a);
}

int changeInt2(int a2) {
    a2 = 30;
    IO.println("Formal parameter a2=" + a2);
    return a2;
}

Conversion convert(String text) {
    try {
        return new Conversion(true, Integer.parseInt(text));
    } catch (NumberFormatException _) {
        return new Conversion(false, 0);
    }
}

void swap(int[] t) {
    int temp = t[0];
    t[0] = t[1];
    t[1] = temp;
}

void modifyArray(int[] t) {
    // modificamos el arreglo referenciado: el llamador ve la modificación
    t[0] = 100;
    // hacemos que t apunte a otro arreglo: el llamador no lo ve
    t = new int[]{7, 8, 9};
    IO.println("in modifyArray: t=" + Arrays.toString(t));
}

void complete(StringBuilder text) {
    text.append(" everyone");
}

BigDecimal inclTax(final BigDecimal amount) {
    // amount = BigDecimal.ZERO; sería rechazado: el parámetro es final
    return amount.multiply(new BigDecimal("1.2"));
}

Resultados:

> java Basics29.java
Formal parameter a=30
Actual parameter age=20
Formal parameter a2=30
Actual parameter age2=30
c1=Conversion[succeeded=true, value=123], c2=Conversion[succeeded=false, value=0]
value of c1: 123
after swap: x=2, y=1
in modifyArray: t=[7, 8, 9]
array=[100, 2, 3]
message=Hello everyone
InclTax(100)=120.0

Comentarios:

  • líneas 4–6: el valor 20 del parámetro real [age] se copió en el parámetro formal [a] (línea 44). Luego se modificó este parámetro (línea 45). El parámetro real permaneció sin cambios;
  • líneas 9–11: el método [changeInt2] (líneas 49–53) devuelve su nuevo valor, que el llamador asigna a su propia variable [age2];
  • línea 42: un record (Java 16) declara, en una sola línea, una clase cuyos objetos contienen dos valores inmutables, [succeeded] y [value]. El compilador agrega un constructor, un método getter para cada uno de los dos valores ([succeeded()], [value()]), y un método llamado [toString()]. Los records se tratan en el capítulo 4;
  • líneas 14–19: el método [convert] (líneas 55–61) devuelve dos datos (si la conversión tuvo éxito y el valor resultante) combinados en un objeto [Conversion]. Su método [toString()] muestra sus componentes;
  • líneas 22–24: el intercambio de dos valores. Un método llamado [swap(int a, int b)] intercambiaría copias sin efecto alguno sobre el llamador; por lo tanto, los dos valores se almacenan en un arreglo, que el método [swap] (líneas 63–67) modifica;
  • Líneas 27–29: la referencia al arreglo se pasa por valor. Por lo tanto, el método [modifyArray] opera sobre el mismo arreglo que el llamador: la modificación realizada por [t[0]] (línea 71) es visible para el llamador. Sin embargo, hacer que [t] apunte a otro arreglo (línea 73) solo modifica la copia local de la referencia;
  • líneas 32–34: un objeto [StringBuilder] es una cadena mutable: el método [complete] (líneas 77–79) le agrega texto, y el llamador ve el resultado. Con un [String], esto habría sido imposible: los objetos [String] son inmutables;
  • líneas 37–38: el método [inclTax] (líneas 81–84) tiene un parámetro [final]. El producto de dos objetos [BigDecimal] tiene tantos decimales como la suma de los de sus dos factores: 100 × 1.2 = 120.0, que se muestra como 120.0.

Si se reemplaza el comentario de la línea 82 por la instrucción [amount = BigDecimal.ZERO;], el compilador rechaza el programa:

1
2
3
4
Basics29.java:82: error: final parameter amount may not be assigned
    amount = BigDecimal.ZERO;
    ^
1 error

3.10.2. Sobrecarga de métodos, número variable de parámetros

Java no tiene parámetros opcionales con valores predeterminados, ni argumentos con nombre. El equivalente de los parámetros opcionales se obtiene mediante la sobrecarga de métodos: varios métodos pueden tener el mismo nombre si sus listas de parámetros difieren en el número o el tipo de parámetros; el compilador selecciona el adecuado según los parámetros reales proporcionados. Lo más habitual es que las versiones cortas llamen a la versión completa, pasándole valores predeterminados. Cuando hay muchos parámetros opcionales, se prefiere un objeto de configuración o un "builder"; veremos ejemplos de ellos más adelante en el curso.

Java 5 introdujo los métodos con un número variable de parámetros ("varargs"): el último parámetro formal se declara con puntos suspensivos, [int... numbers]. El llamador puede pasar un arreglo o una lista de valores (que puede estar vacía), que el compilador organiza en un arreglo; dentro del método, el parámetro es un arreglo.

El programa [Basics30.java] es el siguiente:

// sobrecarga de métodos, número variable de parámetros
void main() {
    // no hay parámetros opcionales en Java: se sobrecarga el método
    IO.println(greet("Pierre"));
    IO.println(greet("Pierre", "Good evening"));
    IO.println(greet("Pierre", "Hello", true));
    IO.println(greet("Paul", "Hi", true));

    // varargs: número variable de parámetros
    IO.println("sum()=" + sum());
    IO.println("sum(1, 2, 3)=" + sum(1, 2, 3));
    int[] values = {10, 20, 30};
    IO.println("sum(values)=" + sum(values));
    // métodos del JDK con número variable de parámetros
    IO.println(String.join(" - ", "a", "b", "c"));
    IO.println(String.format("%s, %s and %s", "one", "two", "three"));
    IO.println(List.of(1, 2, 3, 4));
}

// tres métodos con el mismo nombre que se distinguen por sus parámetros
String greet(String name) {
    return greet(name, "Hello");
}

String greet(String name, String greeting) {
    return greet(name, greeting, false);
}

String greet(String name, String greeting, boolean uppercase) {
    String message = greeting + " " + name;
    return uppercase ? message.toUpperCase() : message;
}

int sum(int... numbers) {
    // numbers es un arreglo
    int sum = 0;
    for (int number : numbers) {
        sum += number;
    }
    return sum;
}

Resultados:

> java Basics30.java
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
sum()=0
sum(1, 2, 3)=6
sum(values)=60
a - b - c
one, two and three
[1, 2, 3, 4]

Comentarios:

  • Líneas 21–32: tres métodos [greet] que difieren en el número de parámetros que reciben. Solo el último hace el trabajo; los otros dos lo llaman con valores predeterminados para los parámetros que faltan;
  • línea 4: [greet("Pierre")] llama a la versión de un parámetro (línea 21), que llama a la versión de dos parámetros con la cadena "Hello,", que a su vez llama a la versión completa con [false];
  • Líneas 6–7: sin argumentos con nombre, para pasar [uppercase], también se debe pasar [greeting];
  • líneas 34–41: [sum] acepta un número cualquiera de enteros, recibidos en el arreglo [numbers];
  • líneas 10–13: [sum] se llama sin parámetros, con tres enteros y luego con un arreglo;
  • líneas 15–17: muchos métodos del JDK tienen un número variable de parámetros: [String.join], [String.format], [List.of]...

3.11. Funciones locales y tuplas: soluciones en Java

3.11.1. Métodos, lambdas y clases locales

Algunos lenguajes permiten definir una función local, es decir, una función escrita dentro de otra función y utilizable solo en ese contexto. Java no lo permite. En nuestros archivos compactos, los métodos del archivo cumplen esta función; en una clase, escribimos métodos privados. Dentro de un método, disponemos de dos herramientas:

  • una lambda (Java 8), una pequeña función anónima que se almacena en una variable de un tipo adecuado, denominado interfaz funcional: [IntUnaryOperator cube = x -> x * x * x;]. Las lambdas se tratan en el capítulo 7, "Interfaces funcionales, lambdas y eventos". Una lambda puede leer las variables locales que la rodean, pero solo si nunca se modifican (variables [final] o "efectivamente finales"); no puede modificarlas;
  • una clase local, declarada dentro del método y utilizable solo dentro de este.

3.11.2. Records en lugar de tuplas

Otros lenguajes tienen tuplas, que agrupan varios valores sin necesidad de declarar un tipo. Java no las tiene: utiliza records (Java 16). La declaración [record Couple(int number, String name) {}] crea, en una sola línea, una clase en la que cada objeto consta de un entero y una cadena, junto con un constructor, los métodos de acceso [number()] y [name()], y los métodos [toString()], [equals()], y [hashCode()]. Un record puede declararse dentro de un método (record local). Sus componentes pueden extraerse mediante un patrón de record (Java 21), con el operador [instanceof] o dentro de un [switch]. Los records son la forma natural de hacer que un método devuelva varios valores; como sus componentes tienen nombre, son más legibles que las tuplas.

El programa [Basics31.java] es el siguiente:

// en lugar de funciones locales y tuplas: métodos, lambdas, clases locales y records
void main() {
    // un método privado del archivo compacto
    IO.println("square(7)=" + square(7));
    // una lambda almacenada en una variable (capítulo 7)
    IntUnaryOperator cube = x -> x * x * x;
    IO.println("cube(3)=" + cube.applyAsInt(3));

    // una lambda no puede modificar una variable local: se usa un objeto
    int[] counter = {0};
    Runnable increment = () -> counter[0]++;
    increment.run();
    increment.run();
    IO.println("counter=" + counter[0]);

    // una clase local: declarada en el método, solo puede usarse allí
    class Accumulator {
        private int total;

        void add(int value) {
            total += value;
        }
    }
    Accumulator acc = new Accumulator();
    acc.add(5);
    acc.add(8);
    IO.println("total=" + acc.total);

    // un record local agrupa varios valores con nombre
    record Couple(int number, String name) {}
    Couple t1 = new Couple(1, "one");
    IO.println("t1=" + t1 + ", t1.number()=" + t1.number() + ", t1.name()=" + t1.name());
    // deconstrucción mediante un patrón de record (Java 21)
    Object object = new Couple(3, "three");
    if (object instanceof Couple(int number, String name)) {
        IO.println("number=" + number + ", name=" + name);
    }
    // un par ya hecho: Map.entry
    Map.Entry<Integer, String> pair = Map.entry(2, "two");
    IO.println("pair=" + pair + ", key=" + pair.getKey() + ", value=" + pair.getValue());

    // un método que devuelve varios valores: un record
    IntegerDivision d = divide(17, 5);
    IO.println("17 = 5 * " + d.quotient() + " + " + d.remainder());
    MinMax mm = minMax(new int[]{12, -4, 35, 7});
    IO.println("min=" + mm.min() + ", max=" + mm.max());

    // intercambio de dos variables: una variable temporal
    int a = 1, b = 2;
    int temp = a;
    a = b;
    b = temp;
    IO.println("a=" + a + ", b=" + b);
}

int square(int x) {
    return x * x;
}

record IntegerDivision(int quotient, int remainder) {}

record MinMax(int min, int max) {}

IntegerDivision divide(int a, int b) {
    return new IntegerDivision(a / b, a % b);
}

MinMax minMax(int[] values) {
    int min = values[0], max = values[0];
    for (int v : values) {
        if (v < min) min = v;
        if (v > max) max = v;
    }
    return new MinMax(min, max);
}

Resultados:

> java Basics31.java
square(7)=49
cube(3)=27
counter=2
total=13
t1=Couple[number=1, name=one], t1.number()=1, t1.name()=one
number=3, name=three
pair=2=two, key=2, value=two
17 = 5 * 3 + 2
min=-4, max=35
a=2, b=1

Comentarios:

  • línea 4: el método [square] (líneas 56–58) en el archivo compacto;
  • línea 6: una lambda. [x -> x * x * x] se lee "la función que asocia x con x * x * x". Se almacena en una variable de tipo [IntUnaryOperator], que representa una función de un [int] a un [int] (paquete [java.util.function]);
  • línea 7: la lambda se llama mediante el método [applyAsInt] de la interfaz [IntUnaryOperator];
  • líneas 10–14: una lambda de tipo [Runnable] (sin parámetros ni valor de retorno), llamada mediante [run()]. No puede modificar una variable local [int]; sin embargo, sí puede modificar el contenido de un objeto, en este caso un arreglo con un solo elemento. Con [int counter = 0;] y [() -> counter++], el compilador habría rechazado el programa: [error: local variables referenced from a lambda expression must be final or effectively final];
  • líneas 17–23: una clase local [Accumulator], con un campo [total] y un método [add]. Las clases se tratan en el capítulo 4;
  • líneas 24–27: se crea un objeto [Accumulator] mediante el operador [new] y luego se llama a su método. El campo privado [total] sigue siendo accesible para el código del método que contiene la clase;
  • línea 30: un record local;
  • línea 32: el método [toString()] de un record muestra el nombre del record y sus componentes; los métodos [number()] y [name()] devuelven los componentes;
  • líneas 34–37: un patrón de record: si [object] es un [Couple], sus dos componentes se almacenan en las variables [number] y [name], declaradas en el patrón. Java 25 no tiene una instrucción que descomponga directamente un record en varias variables;
  • líneas 39–40: para un simple par clave-valor, la biblioteca ofrece [Map.entry(key, value)], cuyos componentes se obtienen mediante [getKey()] y [getValue()];
  • líneas 43–46: los métodos [divide] y [minMax] (líneas 64–75) devuelven cada uno dos valores, que se combinan en un record declarado en las líneas 60 y 62. Los nombres de los componentes ([quotient()], [remainder()], [min()], [max()]) hacen explícito el código que llama;
  • líneas 49–53: sin tuplas, dos variables se intercambian mediante una variable temporal;
  • líneas 71–72: una instrucción [if] cuya única acción se escribe en la misma línea, sin llaves.

En un programa más grande, definimos clases, que agrupan datos y los métodos que los manipulan: este es el tema del siguiente capítulo.