Primeros programas en Java

Un primer programa Java da a la computadora una breve lista de instrucciones. La clase que las contiene y el método main indican a Java dónde van esas instrucciones y dónde comienza la ejecución.

Coloca las instrucciones dentro de main

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Las llaves exteriores encierran el cuerpo de la clase. Las llaves interiores encierran el cuerpo del método. Cuando este programa comienza, Java ejecuta la primera sentencia dentro de main. Las demás sentencias colocadas debajo se ejecutan de arriba abajo. Cuando main finaliza, este pequeño programa termina.

Copia public static void main(String[] args) con cuidado. Aquí, public permite al lanzador llamar al método, static permite ejecutarlo sin crear primero un objeto y void indica que el método no devuelve ningún resultado. String[] args recibe las palabras escritas en la línea de comandos después del nombre del programa. Puedes imprimir un mensaje sin utilizar esas palabras.

Haz coincidir la puntuación y los nombres

Una sentencia como System.out.println("Hi"); termina con un punto y coma. Una llave de apertura { necesita una llave de cierre }. Las cabeceras de clase y método mostradas arriba abren bloques; no sustituyas esas llaves de apertura por puntos y coma. Aplicar a la sentencia una sangría cuatro espacios mayor que la de la cabecera del método hace visible su posición dentro de este.

Guarda public class Hello en Hello.java. El nombre de la clase pública y la parte anterior a .java deben coincidir exactamente, incluidas las mayúsculas. Si la declaración dice public class Other, el archivo debe ser Other.java. Un mensaje del compilador que indica que la clase debe declararse en otro archivo señala esta falta de coincidencia.

Java distingue mayúsculas y minúsculas. El nombre System debe empezar con S mayúscula; system.out.println("Hi"); no se compila. Un método llamado Main es distinto de main. Una clase que solo contiene Main puede compilarse, pero el lanzador no encuentra el método de entrada previsto al ejecutarla.

Haz que el código sea legible

Utiliza una sentencia por línea y cuatro espacios de sangría por cada nivel de llaves. La mayoría de los espacios y saltos de línea entre elementos del código no afectan a la compilación. Los espacios dentro del texto entre comillas sí afectan a la salida. Por convención, los nombres de clases usan PascalCase, como en TravelTime.

Un comentario explica el código a las personas. Java ignora todo lo que sigue a // en esa línea. Un comentario de bloque comienza con /* y termina con */, y puede abarcar varias líneas. Un comentario útil explica una razón, como // Convert hours to seconds, junto a una conversión cuyo propósito podría no estar claro.

Reconoce la forma más corta

Java 25 y versiones posteriores también admiten un archivo fuente compacto:

void main() {
    IO.println("Hello, world!");
}

Esta forma omite la declaración explícita de la clase. IO.println imprime una línea, y IO.readln("Your name: ") muestra una solicitud y devuelve la línea escrita. La forma clásica de clase también funciona con versiones anteriores de Java; ambas formas proporcionan un método main donde comienza la ejecución.

Escribir código fuente y ejecutar un programa son pasos distintos. Java primero comprueba y traduce tu código, y después lo ejecuta. Saber qué paso falló te ayuda a decidir dónde buscar.

Compila el código fuente y después inicia la clase

El código fuente es el texto de un archivo .java. El compilador, javac, traduce el código fuente válido a código de bytes en un archivo .class. La máquina virtual de Java (JVM) ejecuta ese código de bytes. Una JVM adecuada permite ejecutar el mismo código de bytes en distintos sistemas operativos.

Abre una terminal en la carpeta que contiene Hello.java e introduce:

javac Hello.java
java Hello

El primer comando crea Hello.class cuando la compilación tiene éxito. El segundo inicia el programa. Su argumento es el nombre de la clase, sin .class: java Hello.class pide al lanzador que busque un nombre de clase incorrecto y falla.

El JDK, o kit de desarrollo de Java, proporciona ambos comandos. Un IDE, como IntelliJ IDEA, Eclipse, NetBeans o Visual Studio Code con soporte para Java, compila e inicia el programa cuando pulsas Run. Puede señalar errores mientras escribes, pero siguen siendo errores del mismo lenguaje Java.

Desde Java 11, el modo de archivo fuente ofrece un atajo para un solo programa pequeño:

java Hello.java

Esto compila en memoria y ejecuta el código fuente sin dejar un archivo .class. Distingue las dos formas: java Hello inicia una clase compilada, mientras que java Hello.java inicia código fuente.

Interpreta los errores en tiempo de compilación

Un error en tiempo de compilación impide que la compilación termine correctamente. Por ejemplo, la falta de un punto y coma puede producir:

Hello.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^

El mensaje identifica el archivo, la línea y el lugar donde el compilador detectó el problema. El error real puede estar antes: una comilla sin cerrar en una línea puede confundir las líneas posteriores. Lee la línea marcada y la anterior. Corrige el primer error indicado y vuelve a compilar antes de cambiar varias líneas más. Una corrección puede eliminar muchos mensajes posteriores.

Distingue los errores en tiempo de ejecución de los resultados incorrectos

Si una variable entera divisor contiene cero, 5 / divisor falla durante la ejecución con ArithmeticException: / by zero. La sentencia aritmética puede ser código fuente válido aunque sus valores en tiempo de ejecución provoquen el fallo.

Un programa que imprime una media de 8 cuando el valor correcto es aproximadamente 8,33 tiene un error lógico. Ningún mensaje del compilador puede indicarte que ese resultado es incorrecto para tu tarea. Prueba con entradas conocidas, examina los valores intermedios y encuentra el primer cálculo incorrecto.

Trabaja en un ciclo breve: editar, guardar, compilar, ejecutar, probar. Guardar importa: la compilación lee el archivo guardado, por lo que los cambios sin guardar no pueden modificar el programa compilado.

La salida impresa es la primera forma de ver lo que hace un programa. Java te permite controlar los caracteres que imprime y el punto donde comienza la siguiente línea.

Sigue la posición de salida

System.out.print(...) escribe su valor y deja la posición de salida en la misma línea. System.out.println(...) escribe su valor y después comienza una nueva línea. Llamar a System.out.println() con los paréntesis vacíos añade solo un salto de línea.

System.out.print("Hello");
System.out.print(", ");
System.out.println("world");
System.out.println("Bye");

Las dos primeras llamadas dejan la posición después del espacio que sigue a la coma. La tercera añade world en esa posición y después pasa a una nueva línea. La salida exacta es:

Hello, world
Bye

Java no inserta espacios entre llamadas. Si eliminas el espacio de ", ", la primera línea pasa a ser «Hello,world». Un println() vacío entre las dos últimas sentencias crearía una línea en blanco entre los mensajes.

Decide si quieres texto o un valor

Un literal de cadena es texto encerrado entre comillas dobles. Imprimir "7 * 6" muestra el texto «7 * 6». Imprimir 7 * 6 evalúa la multiplicación y muestra «42». Las comillas son signos del código; no se imprimen como parte del literal.

Del mismo modo, si name almacena «Ada», System.out.println(name); muestra «Ada», mientras que System.out.println("name"); muestra «name». Utiliza la variable sin comillas cuando quieras su valor almacenado.

Las comillas simples cumplen otra función. 'A' es un valor char. 'Hello' no puede contener un mensaje de varios caracteres y provoca un error en tiempo de compilación. Utiliza "Hello" para ese texto.

Introduce caracteres especiales en una cadena

Una secuencia de escape comienza con una barra invertida y representa un carácter dentro del literal.

Por ejemplo:

System.out.println("She said \"hi\"");
System.out.println("C:\\Users");

Estas sentencias muestran She said "hi" y C:\Users, en líneas separadas. Las barras invertidas adicionales indican a Java cómo interpretar el carácter siguiente; no todas se copian a la salida.

Una sola llamada también puede imprimir varias líneas:

System.out.println("Name:\tAda\nAge:\t36");

La tabulación separa la etiqueta del valor, y \n coloca la edad en la línea siguiente. La llamada a println también añade su propio salto de línea final. Una tabulación avanza hasta una posición de tabulación, por lo que su anchura visible depende del entorno de salida.

Un literal de cadena ordinario entre comillas debe abrirse y cerrarse en la misma línea del código fuente. Pulsar Enter en medio de él deja un literal sin cerrar. Para dividir un mensaje largo entre líneas del código fuente, escribe dos literales completos unidos con + o utiliza llamadas de impresión separadas.

Una variable da un nombre a un valor para que las sentencias posteriores puedan utilizarlo. Su tipo indica a Java qué clase de valor puede contener; la asignación cambia el valor almacenado.

Declara e inicializa

int age;
age = 36;

La declaración presenta age como un int. La asignación almacena 36. La forma combinada int age = 36; se llama inicialización. Una variable local debe recibir un valor antes de leerla. Declarar int age; e imprimir inmediatamente age produce un error que indica que la variable podría no haberse inicializado.

Declara un nombre una sola vez en el mismo cuerpo de método. Para cambiar su valor después, escribe age = 37;, sin repetir int. Una segunda sentencia int age = 37; en ese cuerpo intenta declarar de nuevo la misma variable.

Lee la asignación de derecha a izquierda

Primero se calcula el lado derecho de =. Después Java almacena ese resultado en la variable de la izquierda:

int count = 5;
count = count + 1;

La segunda sentencia lee el valor actual 5, suma 1 y almacena 6. El signo = significa asignación, no una afirmación matemática de que un número es igual a sí mismo más uno. El lado izquierdo debe nombrar un lugar donde almacenar el valor; 36 = age; no es válido.

La asignación copia el valor en ese momento:

int a = 5;
int b = a;
a = 10;

Ahora a contiene 10 y b contiene 5. No hay un vínculo continuo que recalcule b cuando cambia a.

Sigue un intercambio

Supón que first contiene 4 y second contiene 9. La secuencia first = second; second = first; pierde el 4 en el primer paso y deja ambos valores en 9. Conserva primero el valor original:

int temp = first;
first = second;
second = temp;

Una tabla de seguimiento registra cada variable después de cada sentencia. Para int x = 3; x = x * 2; x = x + 1;, los valores son 3, después 6 y después 7. Actualiza una fila cada vez utilizando los últimos valores almacenados.

Elige nombres útiles y tipos fijos

Los nombres pueden contener letras, dígitos, guiones bajos y signos de dólar. No pueden empezar por un dígito ni ser una palabra reservada como class. Las mayúsculas importan: total y Total son distintos. Utiliza nombres descriptivos en camelCase, como distanceKm o secondsLeft.

A una variable final solo se le puede asignar un valor una vez. final int SECONDS_PER_HOUR = 3600; da un nombre claro a un factor de conversión fijo. Reasignarle un valor impide la compilación. Por convención, las constantes usan palabras en mayúscula separadas por guiones bajos.

Desde Java 10, var puede inferir el tipo de una variable local a partir de su inicializador. var count = 10; infiere int; var price = 2.5; infiere double. El tipo inferido permanece fijo. var count; falla porque no hay un inicializador del que inferir un tipo.

El tipo de un valor determina su rango, la escritura de sus literales y los cálculos que Java puede realizar con él. Utiliza int para recuentos habituales y double para medidas habituales, y reconoce también los demás tipos primitivos.

Compara los ocho tipos primitivos

Los valores finitos de float van aproximadamente de −3,4 × 10³⁸ a +3,4 × 10³⁸; los de double van aproximadamente de −1,8 × 10³⁰⁸ a +1,8 × 10³⁰⁸. Estos amplios rangos no hacen que todos los decimales que contienen puedan representarse exactamente.

Un char suele representar un solo carácter, como 'A'. Algunos caracteres Unicode necesitan dos unidades de código UTF-16, por lo que un solo char no puede representar todos los caracteres posibles. 'A' tiene el código numérico 65, 'a' tiene 97 y '7' tiene 55. El carácter '7' es distinto del entero 7. Un boolean no es un número: boolean active = 1; falla.

Escribe los literales según sus tipos

Un literal escribe un valor directamente en el código fuente. 42 es un literal int, 42L es un long, 3.5 es un double y 3.5f es un float. Los literales de carácter usan comillas simples; los literales de cadena usan comillas dobles. Los nombres de tipos primitivos se escriben en minúscula, mientras que String empieza con mayúscula.

Escribe long large = 3000000000L;. Sin la L, ese literal entero es demasiado grande. Escribe float rate = 3.5f;: 3.5 sin sufijo tiene el tipo double, que Java no reduce a float de forma automática y silenciosa. Una constante entera que quepa puede inicializar un tipo entero más pequeño: byte b = 100; se compila, pero byte b = 200; no.

Los guiones bajos entre dígitos facilitan la lectura de un literal: 1_000_000 tiene el mismo valor que 1000000. La notación científica usa e, como en 1.5e3, que significa 1500,0. Los decimales del código fuente siempre usan un punto.

Vigila el rango de la operación

Un cálculo entero puede sufrir un desbordamiento sin producir un mensaje de error. Sumar 1 al mayor int devuelve el menor int. El producto 50_000 * 50_000 utiliza aritmética int y produce -1794967296. En 50_000L * 50_000, un operando es long, por lo que el producto es el valor correcto 2500000000.

Cambiar solo la variable que recibe el resultado a long es demasiado tarde para corregir un producto int que ya ha sufrido desbordamiento. Elige un operando suficientemente amplio antes de la multiplicación.

Los valores en coma flotante tienen otra limitación. Muchas fracciones decimales se almacenan como aproximaciones binarias: 0.1 + 0.2 imprime 0.30000000000000004. Da formato a esos resultados para mostrarlos. Los cálculos monetarios exactos pueden almacenar centavos enteros en un long; la clase BigDecimal es otra opción para decimales exactos.

Una cadena String almacena texto, incluidos espacios, dígitos, signos de puntuación o ningún carácter. El operador + puede combinar ese texto con otros valores para construir un mensaje.

Une valores en un texto

String firstName = "Ada";
String lastName = "Lovelace";
System.out.println(firstName + " " + lastName);

La salida es «Ada Lovelace». El literal del medio aporta el espacio. Sin él, firstName + lastName produciría «AdaLovelace». La concatenación no añade separadores por ti.

La concatenación consiste en unir valores en una nueva cadena. Si uno de los operandos de + es una cadena String, Java convierte el otro valor en texto y los une. Así, "Age: " + 36 se convierte en «Age: 36», y "Price: " + 2.5 se convierte en «Price: 2.5». Los dígitos del resultado forman ahora parte de un valor de texto.

String empieza con S mayúscula. A diferencia de los ocho tipos primitivos, es una clase. Escribir string name = "Ada"; con s minúscula impide la compilación. La cadena vacía "" es un texto válido sin caracteres; no es un valor ausente.

Sigue los signos de suma de izquierda a derecha

Considera:

System.out.println("Sum: " + 2 + 3);

El primer + une la cadena String y 2, y crea «Sum: 2». El segundo une esa cadena y 3, y crea «Sum: 23». Una vez que el resultado acumulado es texto, el siguiente + continúa uniendo texto.

Compara tres formas:

Utiliza paréntesis cuando un mensaje deba contener el resultado de una suma o una resta. Por ejemplo, "Diff: " + (5 - 2) da «Diff: 3». Sin los paréntesis, "Diff: " + 5 - 2 intenta restar 2 de una cadena String y no se compila.

La multiplicación y la división tienen mayor precedencia que +. La expresión "Area: " + 4 * 5 calcula primero el producto y da «Area: 20».

Construye un mensaje por etapas

String message = "Hi";
message += "!";

La variable actualizada contiene «Hi!». Para una cadena String, += añade texto al final al volver a asignar el resultado concatenado a la variable. Puedes construir un mensaje corto con varias sentencias e imprimirlo una sola vez al final.

Ten cuidado con los caracteres. Dos operandos char no activan la concatenación de cadenas. 'A' + 'B' suma sus códigos numéricos, 65 y 66, y produce el int 131. Empezar con la cadena String vacía cambia la secuencia: "" + 'A' + 'B' crea primero «A» y después «AB». Las comillas determinan los tipos de los operandos, por lo que también determinan el significado de +.

Una expresión combina valores para producir un resultado. Java la evalúa según la precedencia de operadores y después una sentencia puede almacenar o imprimir ese resultado.

Escribe las operaciones explícitamente

Los operadores aritméticos son +, -, *, / y %: suma, resta, multiplicación, división y resto. Con int width = 4; e int height = 5;, width * height se evalúa como 20.

Toda multiplicación necesita *. La forma algebraica 2(3 + 4) no es Java válido; escribe 2 * (3 + 4). Java no tiene un operador aritmético de potencia. 2 ^ 3 significa una operación a nivel de bits y produce 1, no 8. Para elevar un valor al cuadrado, escribe x * x; para calcular otra potencia, utiliza Math.pow.

Aplica la precedencia antes de leer de izquierda a derecha

En el mismo nivel, estos operadores aritméticos se agrupan de izquierda a derecha. 2 + 3 * 4 es 14; (2 + 3) * 4 es 20. En 10 - 4 - 3, la primera resta da 6 y la segunda da 3. En 24 / 4 * 2, la división da 6 y la multiplicación da 12. Tratar 4 * 2 como denominador requeriría paréntesis.

Calcula correctamente una media

Supón que int a = 7, b = 8, c = 10;. La expresión a + b + c / 3 solo divide c. La división entera hace que 10 / 3 sea igual a 3 y las sumas dan después 18.

(a + b + c) / 3 agrupa el total completo, 25, pero ambos operandos de / son enteros. El resultado es 8. Utilizar (a + b + c) / 3.0 conserva la parte fraccionaria y produce 8.333333333333334.

Los tipos de los operandos determinan la aritmética. Dos operandos int producen un resultado int. Un operando double hace que el otro operando numérico se convierta en double, como en 5 * 2.0, cuyo resultado es 10.0. La variable que recibe el resultado no cambia cómo se realizó la operación anterior.

Actualiza un valor almacenado

int total = 10;
total += 5;
total *= 2;
total--;

Los valores almacenados pasan a ser 10, 15, 30 y 29. Para estos operandos int, total += 5; realiza la misma actualización que total = total + 5;. Los operadores -=, /= y %= también combinan una operación con una asignación. count++; aumenta una variable en 1, y count--; la reduce en 1. Al utilizarse como sentencias separadas, su efecto es fácil de seguir.

Una expresión como a + b no cambia ninguno de los operandos. Para utilizar su resultado, asígnalo o pásalo a una llamada de impresión: int sum = a + b; o System.out.println(a + b);. La línea aislada a + b; no se compila porque Java no permite esa expresión aritmética como sentencia independiente. Las asignaciones, los incrementos, los decrementos y las llamadas a métodos pueden aparecer por sí solos y producir efectos.

La división entera responde cuántos grupos completos caben. El resto indica qué sobra. Juntas, estas operaciones descomponen una cantidad en partes útiles.

Predice el cociente y el resto

Cuando ambos operandos son enteros, / descarta la parte fraccionaria y se desplaza hacia cero. 7 / 2 es 3, 2 / 3 es 0 y -7 / 2 es −3. Esto es truncamiento, no redondeo al entero más cercano.

El operador de resto % devuelve lo que queda después de la división. 17 / 5 da 3 y 17 % 5 da 2. Tres grupos de 5 suman 15 y quedan 2. Para operandos enteros y un divisor distinto de cero, (a / b) * b + a % b reconstruye a mediante la aritmética entera de Java.

El signo de un resto distinto de cero sigue al operando izquierdo: -7 % 3 es −1, mientras que 7 % -3 es 1. Para enteros no negativos, n % 2 es 0 para valores pares y 1 para valores impares.

Descompón segundos en unidades mayores

Empieza con 3725 segundos:

int totalSeconds = 3725;
int hours = totalSeconds / 3600;
int secondsAfterHours = totalSeconds % 3600;
int minutes = secondsAfterHours / 60;
int seconds = secondsAfterHours % 60;

La primera división encuentra 1 hora completa. El resto es 125 segundos. Dividir ese resto entre 60 da 2 minutos y sobran 5 segundos. El resultado es 1 h 2 min 5 s. Reconstruir el total da 3600 segundos más 120 segundos más 5 segundos, es decir, 3725.

Utiliza el resto después de extraer las horas para encontrar los minutos de la hora actual. Dividir el total original entre 60 daría los 62 minutos completos, incluidos los minutos ya contados como una hora.

Los mismos operadores extraen dígitos decimales de un entero no negativo. 4827 % 10 da el último dígito, 7; 4827 / 10 da los dígitos iniciales restantes, 482.

Distingue los grupos completos de los recipientes suficientes

Para 50 huevos y cajas con capacidad para 12 huevos, 50 / 12 da 4 cajas llenas y 50 % 12 da 2 huevos sobrantes. Para guardar todos los huevos se necesita una quinta caja. Para cantidades no negativas y tamaños de caja positivos, la expresión entera (count + size - 1) / size redondea hacia arriba el número de recipientes, siempre que la suma no se desborde. En este ejemplo, (50 + 12 - 1) / 12 da 5.

Elige la división fraccionaria antes de realizarla

Un destino double no puede recuperar una fracción descartada. Convierte un operando en double antes de dividir cuando necesites la fracción.

La división o el cálculo del resto por el entero cero lanza ArithmeticException durante la ejecución. La división en coma flotante se comporta de otro modo: 5.0 / 0 da Infinity, -5.0 / 0 da -Infinity y 0.0 / 0 da NaN, que significa «valor no numérico». Por tanto, un resultado puede ser inutilizable incluso cuando la ejecución no se detiene.

La aritmética decimal es útil para medidas y medias. La clase Math añade cálculos ya disponibles, mientras que el redondeo permite elegir cómo almacenar o presentar un resultado.

Conserva las fracciones y reconoce las aproximaciones

150 / 2.5 da 60.0, una velocidad en km/h cuando la distancia es 150 km y el tiempo es 2,5 horas. Como un operando es double, la división conserva un resultado fraccionario cuando es necesario. Los valores double ordinarios que son enteros se imprimen con una parte decimal, como 60.0.

Un double almacena una aproximación binaria de muchos valores decimales. Por ello, 1.1 * 3 imprime 3.3000000000000003, y 10.0 / 3 imprime 3.3333333333333335. Conserva el valor de trabajo durante los cálculos posteriores y redondéalo al presentarlo.

Los valores grandes o pequeños pueden imprimirse en notación científica. 1.23456789E7 representa 12 345 678,9, y 1.0E-4 representa 0,0001. Para valores positivos finitos, se utiliza la notación ordinaria desde 0,001 hasta 10 000 000, sin incluirlo. La notación científica cambia la forma mostrada, no el valor subyacente.

Llama a métodos útiles de Math

Math está en java.lang, por lo que no se necesita ninguna importación.

Math.sqrt y Math.pow devuelven double. La constante Math.PI es aproximadamente 3,141592653589793. Para un círculo de radio 2,5 cm, Math.PI * 2.5 * 2.5 da 19.634954084936208 cm², aproximadamente 19,63 cm². Para un triángulo rectángulo con catetos de 3 cm y 4 cm, Math.sqrt(3 * 3 + 4 * 4) primero suma los cuadrados de los catetos para obtener 25 y después da 5.0 cm.

Elige una dirección de redondeo

round elige el entero más cercano, y los valores exactamente a medio camino se redondean hacia el infinito positivo. floor baja hacia el infinito negativo; ceil sube hacia el infinito positivo. Para los negativos, «abajo» significa un valor más negativo, por lo que la parte entera inferior de −2,7 es −3,0.

Para un argumento double, Math.round devuelve un long. Almacena ese resultado en un long o conviértelo explícitamente cuando corresponda usar un int: int rounded = (int) Math.round(2.7); almacena 3. floor y ceil devuelven valores double.

Para redondear un valor almacenado a dos decimales, utiliza Math.round(12.3456 * 100) / 100.0, que da 12.35. El paso de multiplicación desplaza la posición de las centésimas al límite entre enteros. Dividir entre 100.0 devuelve el valor a su escala mediante división en coma flotante; dividir entre el entero 100 descartaría la fracción y daría 12. Si solo hay que redondear el texto impreso, printf puede dar formato directamente al valor original.

Java a veces convierte un valor numérico automáticamente. Otras conversiones necesitan una conversión explícita. Esta cambia el tipo de un valor en un punto concreto de una expresión, por lo que su posición afecta al resultado.

Amplía automáticamente

La ruta principal de ampliación numérica es byte → short → int → long → float → double. Un char también se amplía a int y a los tipos siguientes. Por ejemplo, double d = 5; almacena 5.0, y cualquier valor int cabe exactamente en un long.

La ampliación a un tipo en coma flotante puede perder precisión. Las conversiones de int a float, de long a float y de long a double pueden redondear un entero grande. Convertir un int a double es exacto. Por ejemplo, (float) 16777217 se convierte en 1.6777216E7, que representa 16 777 216.

Realiza una conversión explícita de reducción

Una conversión explícita escribe el tipo de destino entre paréntesis antes del valor:

int n = (int) 3.99;

El resultado almacenado es 3. Sin (int), Java rechaza la asignación del literal double a un int. Convertir un double finito y dentro del rango a un entero trunca hacia cero: (int) -3.99 también da −3. El truncamiento es distinto del redondeo; (int) Math.round(3.99) da 4.

Las conversiones de reducción generalmente necesitan una conversión explícita. Una excepción útil permite que una expresión entera constante que quepa inicialice un byte, short o char. Así, byte b = 100; es válido sin (byte). Una variable int no constante no recibe esta excepción de asignación de constantes solo porque su valor actual quepa.

Coloca la conversión explícita antes de la operación que la necesita

Sean int sum = 25; e int count = 3;.

Una conversión explícita tiene mayor precedencia que la multiplicación y la división. Los paréntesis determinan si se aplica a un operando o a un cálculo ya completado. Convertir explícitamente después de una división entera no puede recuperar la información descartada.

Predice los cambios en caracteres y enteros pequeños

(int) 'A' da su código de carácter, 65. Sumar 1 a 'A' produce el int 66. Para convertir todo el resultado de nuevo en un carácter, escribe (char) ('A' + 1), que da 'B'. Sin los paréntesis exteriores alrededor de la suma, la conversión explícita solo se aplicaría a 'A'.

La reducción entre tipos enteros conserva solo los bits inferiores. (byte) 200 se convierte en −56; (int) 3_000_000_000L se convierte en −1 294 967 296. Una conversión explícita permite la conversión, pero no comprueba si el valor original cabe.

La asignación compuesta incorpora una conversión al tipo del lado izquierdo. Con int x = 10;, x += 2.7; calcula 12,7 y lo reduce a 12. La asignación simple x = x + 2.7; falla porque su lado derecho es double.

Un texto puede contener dígitos sin ser un número. Para calcular con texto escrito o almacenado, analízalo y conviértelo a un tipo numérico. Para construir un mensaje, convierte un valor numérico de nuevo en texto.

Analiza el texto antes de calcular

La expresión "42" + 1 produce «421». Como el operando izquierdo es una cadena String, + realiza una concatenación. Integer.parseInt("42") + 1 produce 43 porque el análisis proporciona un int antes de la suma.

String first = "12";
String second = "30";
int total = Integer.parseInt(first) + Integer.parseInt(second);

Aquí total contiene 42. Unir las cadenas originales daría «1230». Elige la conversión según el uso previsto del valor, no según si sus caracteres parecen numéricos.

Integer.parseInt(text) devuelve un int; Long.parseLong(text) devuelve un long. Integer.valueOf("42") devuelve un objeto Integer, que Java convierte automáticamente en int cuando se requiere un int. Para una operación directa de texto a int, parseInt expresa claramente el resultado previsto.

Analiza decimales y valores de verdad

Double.parseDouble("3.75") devuelve el double 3,75. Su formato de texto usa un punto decimal en todas las computadoras, independientemente de la configuración regional. Double.parseDouble("3,5") falla. Los literales del código fuente de Java también usan un punto, aunque los métodos de lectura del teclado pueden seguir una configuración regional.

Boolean.parseBoolean(text) sigue otra regla: devuelve true para «true» con cualquier combinación de mayúsculas y minúsculas, como «TRUE». Cualquier otro texto devuelve false, incluido «yes». No interpreta una palabra afirmativa general como verdadera.

Reconoce el texto numérico no válido

Un texto numérico no válido causa una NumberFormatException mientras se ejecuta el programa. Integer.parseInt("4.5") falla porque el texto decimal no es una representación entera. Integer.parseInt("") e Integer.parseInt(" 42") también fallan. El mensaje de la excepción identifica el texto que no se pudo convertir.

El tratamiento de los espacios en blanco depende del método de análisis. Double.parseDouble ignora los espacios al principio y al final, mientras que Integer.parseInt no lo hace. Elige entradas de prueba que revelen estas diferencias al leer datos del usuario.

Un patrón cómodo de entrada consiste en leer una línea completa y analizarla:

int age = Integer.parseInt(scanner.nextLine());
double height = Double.parseDouble(scanner.nextLine());

Cada llamada consume su línea completa, incluido el fin de línea. Esto mantiene la coherencia entre la entrada de texto y la numérica y evita mezclar lecturas de unidades de entrada con lecturas de líneas completas.

Convierte un número en texto

String.valueOf(42), Integer.toString(42) y "" + 42 producen la cadena String «42». Double.toString(2.50) produce «2.5». La escritura decimal original no permanece asociada al número almacenado, por lo que esta conversión no añade un cero final para conservarla.

Utiliza String.format cuando necesites texto almacenado con un número fijo de decimales. Utiliza printf cuando quieras imprimir ese texto con formato directamente. Ni una conversión explícita numérica ni la concatenación básica proporcionan una presentación fija con dos decimales.

La entrada por teclado llega como texto. Un Scanner puede leer una línea completa, una palabra o una palabra convertida en número. Elige un plan de lectura coherente antes de pedir valores al usuario.

Crea un Scanner y lee una línea

import java.util.Scanner;

public class Greeting {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("What is your name? ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

La importación va antes de la clase. La sentencia de creación va dentro de main y conecta el Scanner a System.in. Un Scanner basta para este programa. nextLine() espera la línea escrita y devuelve su texto sin el salto de línea. Si se escribe «Ada», la última sentencia imprime «Hello, Ada!». Utilizar print para la solicitud mantiene lo que se escribe junto a la pregunta.

Elige entre líneas o unidades de entrada

Para «Ada Lovelace», next() devuelve «Ada». Una llamada posterior a nextLine() devuelve « Lovelace», incluido su espacio inicial. Dos llamadas a nextInt() pueden leer «3 4» de una línea. Una unidad de entrada numérica que no corresponda al método, como «4.5» o «abc» para nextInt(), causa una InputMismatchException.

Ten en cuenta el fin de línea sin leer

Supón que el usuario escribe «30», pulsa Enter, después escribe «Ada Lovelace» y pulsa Enter. Este código no lee el nombre como se pretende:

int age = scanner.nextInt();
String name = scanner.nextLine();

nextInt() consume 30, pero deja el fin de línea. nextLine() consume inmediatamente el resto vacío de esa misma línea, por lo que name es "". Añade scanner.nextLine(); entre las dos sentencias para descartar ese resto antes de leer el nombre en la siguiente línea.

Otra solución es leer cada respuesta con nextLine() y analizar las líneas numéricas: int age = Integer.parseInt(scanner.nextLine());. Esto evita alternar entre dos unidades de entrada diferentes.

Deja clara la convención decimal

nextDouble() sigue la configuración regional del Scanner, que inicialmente es la configuración regional de formato predeterminada de la computadora. Una configuración con coma decimal acepta «3,5» como decimal y rechaza «3.5» en este ejemplo. Para leer decimales con punto de forma coherente, añade import java.util.Locale; y crea:

Scanner scanner = new Scanner(System.in).useLocale(Locale.US);

Leer una línea completa con Double.parseDouble(scanner.nextLine()) también usa un punto. Cambiar la configuración regional del Scanner no cambia los literales del código fuente de Java ni la configuración regional utilizada por las llamadas posteriores a printf.

Lee los valores en el orden solicitado. Si pides un nombre y después una edad, la primera lectura debe almacenar el nombre. Una lectura mal colocada puede poner datos en la variable equivocada o provocar un error de conversión.

La salida con formato controla cómo aparecen los valores dentro de un mensaje. printf puede mostrar un número fijo de decimales, añadir un salto de línea y alinear valores en columnas sin cambiar sus valores almacenados.

Relaciona los marcadores con los valores

Una cadena de formato contiene texto ordinario y especificadores que comienzan con %. Cada especificador que consume un valor toma el siguiente valor proporcionado después de la cadena de formato:

System.out.printf("%s is %d years old%n", "Ada", 36);

Esto imprime «Ada is 36 years old» y comienza una nueva línea. %s muestra texto u otro valor como texto, %d muestra un entero como un int o long, y %f muestra un valor en coma flotante. %n inserta un salto de línea sin consumir un valor. %% imprime un signo de porcentaje.

printf no añade automáticamente un salto de línea. Incluye %n cuando la siguiente salida deba comenzar en una nueva línea. Una secuencia de escape ordinaria \n también representa un carácter de nueva línea dentro del texto de Java; %n es el separador de líneas del formateador específico de la plataforma.

Establece los decimales para la presentación

%f sin modificar imprime seis cifras después del separador decimal: dar formato a 2.5 produce «2.500000». La precisión de %.2f solicita dos cifras:

System.out.printf("Total: %.2f%n", 12.3456);

Con el formato de Estados Unidos, la salida es «Total: 12.35». El valor se redondea en el texto mostrado. Una variable que contiene 12,3456 sigue conteniendo ese valor de trabajo después de imprimirlo.

Para System.out.printf("%d items at %.2f each, total %.2f%n", 3, 1.5, 3 * 1.5);, los valores completan los tres marcadores en orden. Con la configuración de Estados Unidos, la salida es «3 items at 1.50 each, total 4.50».

Alinea campos con la anchura

Una anchura es un tamaño mínimo de campo. %5d alinea un entero a la derecha dentro de al menos cinco caracteres; %-6s alinea texto a la izquierda dentro de al menos seis. %6.1f combina una anchura de 6 con una cifra decimal.

System.out.printf("[%5d][%-6s][%6.1f]%n", 42, "Ada", 9.25);

Con la configuración de Estados Unidos, la salida exacta es [ 42][Ada ][ 9.3]. Los corchetes hacen visible el relleno. Un valor más largo que su anchura se sigue imprimiendo completo; la anchura no corta caracteres.

Un especificador incompatible causa un error en tiempo de ejecución. printf("%d%n", 2.5) se compila, pero lanza IllegalFormatConversionException porque %d espera un valor entero. Proporcionar muy pocos valores, como en printf("%d %d%n", 2), causa MissingFormatArgumentException.

Elige entre imprimir o almacenar texto

String.format aplica las mismas reglas de formato, pero devuelve una cadena String:

String line = String.format("%.1f km", 12.345);

Con la configuración de Estados Unidos, line contiene «12.3 km»; esa sentencia no ha impreso nada.

Ambos métodos de formato usan la configuración regional predeterminada salvo que les pases una. Añade import java.util.Locale; y después utiliza System.out.printf(Locale.US, "%.2f%n", 12.3456); para garantizar «12.35» en lugar de «12,35», que se usa en una configuración con coma decimal. String.format también puede recibir Locale.US como primer argumento. Imprimir un double con println usa un punto independientemente de la configuración regional de formato.

Un programa de cálculo completo conecta tres etapas: leer las entradas, calcular con ellas e imprimir los resultados. Planificar los valores y sus unidades antes de escribir ayuda a elegir tipos y comprobar el resultado.

Planifica un programa de tiempo de viaje

Las entradas son la distancia en kilómetros y la velocidad media en km/h. Dividir la distancia entre la velocidad da el tiempo en horas. Ambas medidas necesitan double para que la división pueda conservar una fracción. La salida serán horas y minutos enteros, redondeados al minuto más cercano.

import java.util.Scanner;

public class TravelTime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Distance (km): ");
        double distance = Double.parseDouble(scanner.nextLine());
        System.out.print("Speed (km/h): ");
        double speed = Double.parseDouble(scanner.nextLine());
        int totalMinutes = (int) Math.round(distance / speed * 60);
        int hours = totalMinutes / 60;
        int minutes = totalMinutes % 60;
        System.out.println("Travel time: " + hours + " h " + minutes + " min");
    }
}

Para 150 km a 80 km/h, la división da 1,875 horas. La multiplicación por 60 da 112,5 minutos. Math.round devuelve el long 113, y la conversión explícita lo convierte en int. La división entera y el resto dan después 1 hora y 53 minutos. La salida es «Travel time: 1 h 53 min».

Si tanto la distancia como la velocidad fueran int, 150 / 80 * 60 produciría 60. La fracción desaparece en la división, antes de la multiplicación. La elección de tipos forma parte del plan, no solo de la sentencia final de salida.

Elige la presentación y la aritmética por separado

Para una cuenta total de 87,60 repartida entre 4 personas, almacena el total en double y el número de personas en int. double share = total / people; da 21,9. Con el formato de Estados Unidos, System.out.printf("Each person pays %.2f%n", share); imprime «Each person pays 21.90». El formato proporciona la segunda cifra decimal sin cambiar el cálculo.

Para las puntuaciones enteras 7, 8 y 10, double average = (a + b + c) / 3.0; da 8.333333333333334, que se muestra como «8.33» con %.2f. Los paréntesis agrupan el total y el divisor decimal conserva su fracción.

Prueba con resultados que conozcas

Calcula los resultados esperados antes de ejecutar el programa. Para el tiempo de viaje, 120 km a 60 km/h debería imprimir 2 h 0 min. Una distancia de 0 km a una velocidad positiva debería imprimir 0 h 0 min. Prueba entradas cercanas a un límite de redondeo y distancias válidas mayores para poner a prueba más que el cálculo más sencillo.

Incluye entradas de cero, negativas y grandes al comprobar el comportamiento del programa. Decide si cada entrada tiene sentido para la tarea. Un número de cero personas hace que total / people produzca Infinity cuando total es un double distinto de cero; la división entera por cero lanza ArithmeticException. Una ejecución correcta por sí sola no demuestra que la respuesta sea útil.

Cuando la salida difiera de lo que esperabas, imprime valores intermedios o síguelos en una tabla. Encuentra el primer valor incorrecto, corrige la sentencia responsable y vuelve a ejecutar las pruebas conocidas. Compara los espacios y las etiquetas, además de los números.

Utiliza nombres como totalMinutes, constantes con nombre como MINUTES_PER_HOUR, unidades en las solicitudes y comentarios breves que expliquen el propósito de un cálculo.