Un programa es, en esencia, datos que se transforman. Las variables son los recipientes donde guardas esos datos y los tipos son las reglas que determinan qué cabe en cada recipiente y qué operaciones tienen sentido con él. En Java estas reglas se comprueban antes de ejecutar nada, y eso convierte al sistema de tipos en tu primera red de seguridad: mucho de lo que en otros lenguajes explota en producción, aquí ni siquiera compila. En esta lección aprenderás los ocho tipos primitivos, la diferencia crucial entre primitivos y referencias, el comportamiento especial de String, las conversiones de tipo, las constantes y la inferencia con var. Al terminar habrás modelado con variables el primer libro del catálogo de BiblioTech.

1. Declaración, inicialización y asignación
2. Los ocho tipos primitivos
3. Literales: cómo se escriben los valores
4. Primitivos frente a referencias: qué guarda cada variable
5. String: el tipo especial
6. Conversiones de tipo
7. Envoltorios, autoboxing y conversión desde texto
8. final y constantes
9. Inferencia de tipos con var
10. Modelando un libro de BiblioTech
11. Errores Comunes y Consejos
12. Ejercicios

Tres operaciones que conviene distinguir desde el principio:

• Declarar es anunciar al compilador: "existirá una variable llamada anioPublicacion que contendrá enteros". A partir de ahí, el compilador vigila que no le metas otra cosa.
• Inicializar es darle su primer valor.
• Asignar es darle un valor (el primero o cualquier otro posterior). El símbolo = no significa igualdad matemática, sino "guarda a la derecha en la variable de la izquierda".

Una regla que Java impone y que conviene celebrar: no puedes leer una variable local antes de asignarle un valor.

Otros lenguajes te devolverían basura o undefined; Java se niega a compilar. Eso elimina toda una familia de errores sutiles.

Puedes declarar varias variables del mismo tipo en una línea, aunque por legibilidad se prefiere una por línea:

Java tiene exactamente ocho tipos primitivos. No son objetos: son valores puros que la JVM manipula de forma directa y eficiente.

Notas importantes sobre esta tabla:

• La columna "valor por defecto" solo aplica a los campos de una clase (módulo 3), no a las variables locales dentro de main, que como acabamos de ver deben inicializarse explícitamente.
• En la práctica usarás int, double, boolean y char el 95 % del tiempo. byte, short y float son casos especiales.
• long es imprescindible cuando int se queda corto. El límite de int (unos 2.147 millones) parece enorme hasta que cuentas milisegundos: el número de milisegundos desde 1970 desbordó int en 1970 + 24 días.
• char no es un String de un carácter: se escribe con comillas simples ('A') y es un tipo numérico por debajo.
• boolean en Java no es un número. No existe la equivalencia "0 es falso, 1 es verdadero" de C: if (1) no compila.

Un literal es un valor escrito directamente en el código. Java admite varias notaciones:

Cuidado con el octal: int x = 010; vale 8, no 10. Es una fuente clásica de errores; evita los ceros a la izquierda.

Desde Java 7 puedes usar _ para hacer legibles los números largos. El compilador los ignora por completo:

Restricciones: no pueden ir al principio, al final, ni junto al punto decimal.

Regla que causa muchos errores: un literal decimal sin sufijo es double. Por eso float peso = 0.68; no compila: estás intentando meter un double en un float, que es más pequeño. Hay que escribir 0.68f.

Secuencias de escape más usadas:

Esta es una de las ideas más importantes del módulo, y la que explica muchos comportamientos que de otro modo parecen arbitrarios.

Java divide los tipos en dos familias:

• Tipos primitivos (los ocho anteriores): la variable contiene el valor directamente.
• Tipos por referencia (String, arrays, y todas las clases): la variable contiene una referencia (una dirección) a un objeto que vive en otra zona de memoria.

La memoria de un programa Java se organiza, de forma simplificada, en dos zonas:

• La pila (stack): rápida y pequeña, guarda las variables locales de los métodos.
• El montículo (heap): grande, guarda los objetos. Es donde actúa el recolector de basura.

Fíjate en la diferencia: anioPublicacion es 2018; titulo no es el texto, sino una flecha que apunta a él.

Consecuencias prácticas inmediatas:

Una variable de referencia puede además valer null, que significa "no apunta a ningún objeto". Los primitivos nunca pueden ser null.

Intentar usar una referencia null produce el error de ejecución más famoso de Java, NullPointerException. Lo tratarás formalmente en el módulo 6.

String no es un primitivo, es una clase. Pero recibe un trato tan privilegiado del lenguaje que se comporta a medio camino.

String es la única clase que se puede crear con un literal, sin new. Usar new String(...) es un antipatrón: crea un objeto extra sin ninguna ventaja.

Un String no se puede modificar nunca. Todos los métodos que "cambian" una cadena devuelven en realidad una cadena nueva:

Este es uno de los errores más frecuentes de quien empieza. Si un método de String no parece hacer nada, casi seguro que has olvidado guardar el resultado.

¿Por qué son inmutables? Por seguridad (una cadena no puede cambiar bajo tus pies), por eficiencia (permite compartir cadenas idénticas en el pool de cadenas) y porque las hace seguras entre hilos sin coste alguno (módulo 8).

El operador + concatena. Cuando uno de los operandos es un String, Java convierte automáticamente el otro a texto. Esto también significa que "Total: " + 2 + 3 produce "Total: 23" y no "Total: 5": se evalúa de izquierda a derecha, y en cuanto hay un String todo lo demás se pega como texto. Se corrige con paréntesis: "Total: " + (2 + 3).

Partimos de:

Los índices empiezan en 0, y substring(i, j) incluye i pero excluye j. Es la convención de todo Java; interiorízala ya.

Ejemplo aplicado a BiblioTech:

Para textos de varias líneas existe una sintaxis con triple comilla que evita los \n y las concatenaciones:

Detalles: la triple comilla de apertura debe ir seguida de un salto de línea, y la indentación se calcula respecto a la línea de cierre, de modo que puedes indentar el bloque dentro del código sin que esos espacios aparezcan en la salida. Es enormemente cómodo para menús, plantillas o fragmentos de JSON y SQL.

Cuando mezclas tipos numéricos, Java aplica reglas estrictas.

Va de un tipo pequeño a uno mayor. No se pierde información, así que Java la hace sola:

Esto explica por qué 12 * 0.25 da 3.0: el int se convierte a double antes de multiplicar.

Va de un tipo mayor a uno menor. Puede perder información, así que Java te obliga a pedirla explícitamente con un cast, que es tu firma de "sé lo que hago":

Puntos críticos:

• El cast a entero trunca, no redondea. (int) 3.99 es 3. Para redondear se usa Math.round(3.99), que da 4.
• Si el valor no cabe, el resultado es basura silenciosa:

Aquí no hay error ni aviso: el compilador asume que sabías lo que hacías. Por eso los casts deben usarse con conocimiento de causa.

En una operación entre tipos distintos, Java promociona al mayor de los dos:

Y la trampa clásica, que veremos a fondo en la lección de operadores:

La división se hace entre enteros (dando 2) y solo después se convierte a double. La solución es forzar antes: (double) total / partes.

Cada primitivo tiene una clase envoltorio (wrapper) que lo representa como objeto:

¿Para qué sirven? Por dos motivos:

1. Las colecciones (módulo 5) solo admiten objetos, no primitivos. No puedes tener una lista de int, pero sí de Integer.
2. Pueden ser null, lo que permite representar "sin valor" (un año de publicación desconocido, por ejemplo).

Desde Java 5, la conversión entre primitivo y envoltorio es automática:

Es cómodo, pero tiene dos costes que conviene conocer: consume más memoria y, sobre todo, un unboxing sobre una referencia null lanza NullPointerException. Regla práctica: usa primitivos salvo que necesites null o una colección.

Aquí está su utilidad más inmediata en este módulo: convertir texto a número. Recuerda que los argumentos de línea de comandos y lo que se lee por consola llegan siempre como String.

Si el texto no representa un número válido (Integer.parseInt("dos mil")), el programa falla en ejecución con NumberFormatException. Cómo capturar y tratar ese fallo se estudia en el módulo 6; por ahora basta con saber que existe y con introducir datos correctos.

La palabra final aplicada a una variable significa que su valor no puede cambiar después de asignarse:

Por qué usarlas:

• Comunican intención. Quien lee el código sabe que ese valor es una regla de negocio, no un dato variable.
• Evitan errores. Un valor que no debe cambiar, no puede cambiar por accidente.
• Eliminan los "números mágicos". Comparar 0.25 disperso por veinte sitios con una única TARIFA_DIARIA es la diferencia entre poder cambiar la tarifa en un minuto o en una tarde.

Las constantes se escriben en MAYUSCULAS_CON_GUION_BAJO, como vimos en la lección anterior:

Un matiz importante para más adelante: en una variable de referencia, final impide reasignar la referencia, no modificar el objeto apuntado. Con String no se nota porque son inmutables, pero con objetos mutables (módulo 3) sí.

Desde Java 10 puedes omitir el tipo de una variable local y dejar que el compilador lo deduzca del valor asignado:

Es crucial entender que var no convierte Java en un lenguaje de tipado dinámico. El tipo se fija en compilación y es tan estricto como siempre:

Restricciones de var:

• Solo para variables locales (dentro de métodos). No vale para campos de clase ni parámetros.
• Obliga a inicializar en la misma línea: var x; no compila.
• No admite null como valor inicial: var x = null; no compila, porque no hay tipo que inferir.

Este curso usa tipos explícitos en el módulo 1 (para que veas siempre qué tipo hay en juego) y var a partir del módulo 5, donde los tipos genéricos lo hacen realmente útil.

Apliquemos todo lo aprendido. El catálogo de Nexus Software necesita registrar, para cada libro: título, autor, ISBN, año de publicación y disponibilidad. Con lo que sabes hoy, eso se traduce en variables sueltas:

Salida:

Este enfoque funciona para un libro. Pero Nexus Software tiene cientos. Con variables sueltas necesitarías titulo1, titulo2, titulo3… y nada garantizaría que autor2 corresponde realmente a titulo2. Los datos que forman una unidad conceptual están desperdigados.

Esa es exactamente la carencia que resuelve la programación orientada a objetos: en el módulo 3 crearás una clase Libro que agrupe estas cinco variables en un único tipo, y en el módulo 5 guardarás cientos de esos objetos en una colección. Fíjate en que los nombres que estás usando ahora (titulo, autor, isbn, anioPublicacion, disponible) serán literalmente los campos de esa clase. Estás sentando la base.

• Olvidar guardar el resultado de un método de String. titulo.toUpperCase(); no cambia nada. Debe ser titulo = titulo.toUpperCase();.
• float x = 3.75; no compila. Los literales decimales son double; hay que escribir 3.75f.
• long x = 10000000000; no compila. El literal se interpreta como int y desborda. Hay que escribir 10000000000L.
• Confundir 'A' con "A". Comillas simples es char, dobles es String. No son intercambiables.
• Esperar que (int) 3.99 sea 4. El cast trunca. Para redondear, Math.round().
• Usar == para comparar String. Compara referencias, no contenido. Se usa equals(). Es tan importante que la próxima lección le dedica un apartado completo.
• Declarar variables sin inicializar y leerlas. El compilador lo impide en variables locales; agradécelo.
• Abusar de var. var resultado = calcular(); obliga al lector a ir a buscar la firma del método. Úsalo solo cuando el tipo sea evidente.
• Consejo: declara final todo lo que no vaya a cambiar. Es gratis y convierte un error potencial en un error de compilación.
• Consejo: usa nombres que digan qué contiene la variable, no de qué tipo es. diasRetraso es mejor que numeroEntero1.
• Consejo: cuando dudes de un método de String, ábrelo en JShell y pruébalo. Cinco segundos frente a diez minutos de suposiciones.

Sin ejecutar el código, escribe qué imprime cada línea y justifica por qué. Después compruébalo en JShell o compilándolo.

Escribe la clase FichaCompleta que declare las variables necesarias para el libro "Patrones de Diseño" (ISBN 978-0000000002, año 1994, autor "Erich Gamma y otros", disponible) y calcule y muestre:

1. Los años de antigüedad del libro respecto a 2026.
2. El ISBN sin el prefijo 978-.
3. El título en mayúsculas.
4. Si el título tiene más de 10 caracteres (usa una variable boolean y calcula el valor con una comparación, sin if).

Usa constantes final donde corresponda y respeta las convenciones de nomenclatura.

El siguiente código tiene seis errores de compilación relacionados con tipos. Encuéntralos, explica cada uno y escribe la versión corregida.

Solución 1

Justificación línea a línea:

• a / b → 3. Ambos son int, así que se hace división entera: el resultado 3,5 se trunca a 3. Es el error más clásico de Java.
• (double) a / b → 3.5. El cast se aplica a a antes de dividir, así que la operación es 7.0 / 2 y por promoción da 3.5.
• (int) 3.99 → 3. El cast a entero trunca la parte decimal; no redondea.
• Math.round(3.99) → 4. Este sí redondea al entero más cercano.
• titulo → Java Efectivo. toUpperCase() devuelve una cadena nueva que se descarta, porque no se ha asignado. Los String son inmutables.
• substring(0, 4) → Java. Desde el índice 0 incluido hasta el 4 excluido: caracteres 0, 1, 2 y 3.
• length() → 13. "Java Efectivo" tiene 4 + 1 espacio + 8 = 13 caracteres.
• "Total: " + 2 + 3 → Total: 23. Se evalúa de izquierda a derecha: "Total: " + 2 da "Total: 2", y a esa cadena se le pega el 3.
• "Total: " + (2 + 3) → Total: 5. Los paréntesis fuerzan la suma numérica primero.
• (byte) 300 → 44. Un byte solo llega a 127. El valor desborda y se conservan únicamente los 8 bits bajos de 300 (100101100 → 00101100 = 44). No hay ningún aviso: es una pérdida silenciosa.

Solución 2

Salida:

La idea clave del punto 4: una comparación como titulo.length() > 10 es una expresión booleana. No hace falta un if para obtener true o false; el if sirve para decidir qué hacer con ese valor, y eso llega en el módulo 2.

Solución 3

Los seis errores:

1. float tarifaDiaria = 0.25; — el literal 0.25 es double; no cabe en un float sin sufijo. Solución: 0.25f (o mejor, usar double).
2. long identificador = 100000000045; — el literal se interpreta como int y desborda su rango. Falta el sufijo L.
3. char seccion = "J"; — las comillas dobles crean un String. Un char necesita comillas simples: 'J'.
4. int multa = 3.75; — asignar un double a un int es una conversión estrechante y requiere cast explícito (o, mejor, declarar multa como double, que es lo correcto para dinero).
5. DIAS_PRESTAMO = 20; — la variable es final; no puede reasignarse.
6. System.out.println(paginas); — paginas se ha declarado pero nunca inicializado, y las variables locales deben tener valor antes de leerse.

Versión corregida:

Ya sabes declarar, inicializar y asignar variables; conoces los ocho tipos primitivos con sus rangos y cuáles usarás de verdad; escribes literales en cualquier base y con sufijos correctos; distingues los primitivos (que guardan el valor) de las referencias (que guardan una flecha al montículo); dominas String, su inmutabilidad y sus métodos esenciales, incluidos los text blocks; conviertes entre tipos entendiendo cuándo la conversión es automática y cuándo trunca; usas envoltorios y Integer.parseInt para transformar texto en número; proteges tus reglas de negocio con final; y sabes cuándo var ayuda y cuándo estorba. Con todo ello has modelado el primer libro de BiblioTech.

En la siguiente lección, Operadores, pondremos esos datos en movimiento: aritmética (incluida la trampa de la división entera y el módulo), asignación compuesta, incremento y decremento, comparaciones, operadores lógicos con evaluación de cortocircuito, el operador ternario, operaciones a nivel de bit, precedencia, y el error clásico de comparar cadenas con == en lugar de equals. El hilo será el cálculo de la multa por retraso de un préstamo de BiblioTech.