Un programa és, en essència, dades que es transformen. Les variables són els recipients on deses aquestes dades i els tipus són les regles que determinen què cap en cada recipient i quines operacions hi tenen sentit. En Java aquestes regles es comproven abans d'executar res, i això converteix el sistema de tipus en la teva primera xarxa de seguretat: molt del que en altres llenguatges peta en producció, aquí ni tan sols compila. En aquesta lliçó aprendràs els vuit tipus primitius, la diferència crucial entre primitius i referències, el comportament especial de String, les conversions de tipus, les constants i la inferència amb var. En acabar hauràs modelat amb variables el primer llibre del catàleg de BiblioTech.

1. Declaració, inicialització i assignació
2. Els vuit tipus primitius
3. Literals: com s'escriuen els valors
4. Primitius davant de referències: què desa cada variable
5. String: el tipus especial
6. Conversions de tipus
7. Embolcalls, autoboxing i conversió des de text
8. final i constants
9. Inferència de tipus amb var
10. Modelant un llibre de BiblioTech
11. Errors Habituals i Consells
12. Exercicis

Tres operacions que convé distingir des del principi:

• Declarar és anunciar al compilador: "existirà una variable anomenada anyPublicacio que contindrà enters". A partir d'aquí, el compilador vigila que no hi fiquis cap altra cosa.
• Inicialitzar és donar-li el seu primer valor.
• Assignar és donar-li un valor (el primer o qualsevol altre de posterior). El símbol = no significa igualtat matemàtica, sinó "desa el de la dreta a la variable de l'esquerra".

Una regla que Java imposa i que convé celebrar: no pots llegir una variable local abans d'assignar-li un valor.

Altres llenguatges et retornarien brossa o undefined; Java es nega a compilar. Això elimina tota una família d'errors subtils.

Pots declarar diverses variables del mateix tipus en una línia, encara que per llegibilitat es prefereix una per línia:

Java té exactament vuit tipus primitius. No són objectes: són valors purs que la JVM manipula de manera directa i eficient.

Notes importants sobre aquesta taula:

• La columna "valor per defecte" només s'aplica als camps d'una classe (mòdul 3), no a les variables locals dins de main, que com acabem de veure s'han d'inicialitzar explícitament.
• A la pràctica faràs servir int, double, boolean i char el 95 % del temps. byte, short i float són casos especials.
• long és imprescindible quan int es queda curt. El límit d'int (uns 2.147 milions) sembla enorme fins que comptes mil·lisegons: el nombre de mil·lisegons des del 1970 va desbordar int el 1970 + 24 dies.
• char no és un String d'un caràcter: s'escriu amb cometes simples ('A') i és un tipus numèric per sota.
• boolean en Java no és un número. No existeix l'equivalència "0 és fals, 1 és cert" de C: if (1) no compila.

Un literal és un valor escrit directament al codi. Java admet diverses notacions:

Compte amb l'octal: int x = 010; val 8, no pas 10. És una font clàssica d'errors; evita els zeros a l'esquerra.

Des de Java 7 pots fer servir _ per fer llegibles els números llargs. El compilador els ignora completament:

Restriccions: no poden anar al principi, al final, ni al costat del punt decimal.

Regla que causa molts errors: un literal decimal sense sufix és double. Per això float pes = 0.68; no compila: estàs intentant ficar un double dins d'un float, que és més petit. Cal escriure 0.68f.

Seqüències d'escapada més utilitzades:

Aquesta és una de les idees més importants del mòdul, i la que explica molts comportaments que d'una altra manera semblen arbitraris.

Java divideix els tipus en dues famílies:

• Tipus primitius (els vuit anteriors): la variable conté el valor directament.
• Tipus per referència (String, arrays, i totes les classes): la variable conté una referència (una adreça) a un objecte que viu en una altra zona de memòria.

La memòria d'un programa Java s'organitza, de manera simplificada, en dues zones:

• La pila (stack): ràpida i petita, desa les variables locals dels mètodes.
• El monticle (heap): gran, desa els objectes. És on actua el recol·lector de brossa.

Fixa't en la diferència: anyPublicacio és 2018; titol no és el text, sinó una fletxa que hi apunta.

Conseqüències pràctiques immediates:

Una variable de referència pot valer, a més, null, que significa "no apunta a cap objecte". Els primitius no poden ser mai null.

Intentar fer servir una referència null produeix l'error d'execució més famós de Java, NullPointerException. El tractaràs formalment al mòdul 6.

String no és un primitiu, és una classe. Però rep un tracte tan privilegiat del llenguatge que es comporta a mig camí.

String és l'única classe que es pot crear amb un literal, sense new. Fer servir new String(...) és un antipatró: crea un objecte extra sense cap avantatge.

Un String no es pot modificar mai. Tots els mètodes que "canvien" una cadena retornen en realitat una cadena nova:

Aquest és un dels errors més freqüents de qui comença. Si un mètode de String no sembla fer res, gairebé segur que has oblidat desar-ne el resultat.

Per què són immutables? Per seguretat (una cadena no pot canviar sota els teus peus), per eficiència (permet compartir cadenes idèntiques al pool de cadenes) i perquè les fa segures entre fils sense cap cost (mòdul 8).

L'operador + concatena. Quan un dels operands és un String, Java converteix automàticament l'altre a text. Això també significa que "Total: " + 2 + 3 produeix "Total: 23" i no "Total: 5": s'avalua d'esquerra a dreta, i tan bon punt hi ha un String tota la resta s'hi enganxa com a text. Es corregeix amb parèntesis: "Total: " + (2 + 3).

Partim de:

Els índexs comencen en 0, i substring(i, j) inclou i però exclou j. És la convenció de tot Java; interioritza-la ja.

Exemple aplicat a BiblioTech:

Per a textos de diverses línies existeix una sintaxi amb triple cometa que evita els \n i les concatenacions:

Detalls: la triple cometa d'obertura ha d'anar seguida d'un salt de línia, i el sagnat es calcula respecte a la línia de tancament, de manera que pots sagnar el bloc dins del codi sense que aquells espais apareguin a la sortida. És enormement còmode per a menús, plantilles o fragments de JSON i SQL.

Quan barreges tipus numèrics, Java aplica regles estrictes.

Va d'un tipus petit a un de més gran. No es perd informació, així que Java la fa sola:

Això explica per què 12 * 0.25 dona 3.0: l'int es converteix a double abans de multiplicar.

Va d'un tipus gran a un de més petit. Pot perdre informació, així que Java t'obliga a demanar-la explícitament amb un cast, que és la teva signatura de "sé el que faig":

Punts crítics:

• El cast a enter trunca, no arrodoneix. (int) 3.99 és 3. Per arrodonir es fa servir Math.round(3.99), que dona 4.
• Si el valor no hi cap, el resultat és brossa silenciosa:

Aquí no hi ha error ni avís: el compilador assumeix que sabies què feies. Per això els casts s'han de fer servir amb coneixement de causa.

En una operació entre tipus diferents, Java promociona al més gran dels dos:

I el parany clàssic, que veurem a fons a la lliçó d'operadors:

La divisió es fa entre enters (donant 2) i només després es converteix a double. La solució és forçar-ho abans: (double) total / parts.

Cada primitiu té una classe embolcall (wrapper) que el representa com a objecte:

Per a què serveixen? Per dos motius:

1. Les col·leccions (mòdul 5) només admeten objectes, no primitius. No pots tenir una llista d'int, però sí d'Integer.
2. Poden ser null, cosa que permet representar "sense valor" (un any de publicació desconegut, per exemple).

Des de Java 5, la conversió entre primitiu i embolcall és automàtica:

És còmode, però té dos costos que convé conèixer: consumeix més memòria i, sobretot, un unboxing sobre una referència null llança NullPointerException. Regla pràctica: fes servir primitius llevat que necessitis null o una col·lecció.

Aquí hi ha la seva utilitat més immediata en aquest mòdul: convertir text a número. Recorda que els arguments de línia d'ordres i el que es llegeix per consola arriben sempre com a String.

Si el text no representa un número vàlid (Integer.parseInt("dos mil")), el programa falla en execució amb NumberFormatException. Com capturar i tractar aquesta fallada s'estudia al mòdul 6; de moment n'hi ha prou amb saber que existeix i amb introduir dades correctes.

La paraula final aplicada a una variable significa que el seu valor no pot canviar després d'assignar-se:

Per què fer-les servir:

• Comuniquen intenció. Qui llegeix el codi sap que aquell valor és una regla de negoci, no una dada variable.
• Eviten errors. Un valor que no ha de canviar, no pot canviar per accident.
• Eliminen els "números màgics". Comparar un 0.25 escampat per vint llocs amb una única TARIFA_DIARIA és la diferència entre poder canviar la tarifa en un minut o en una tarda.

Les constants s'escriuen en MAJUSCULES_AMB_GUIO_BAIX, com vam veure a la lliçó anterior:

Un matís important per a més endavant: en una variable de referència, final impedeix reassignar la referència, no modificar l'objecte apuntat. Amb String no es nota perquè són immutables, però amb objectes mutables (mòdul 3) sí.

Des de Java 10 pots ometre el tipus d'una variable local i deixar que el compilador el dedueixi del valor assignat:

És crucial entendre que var no converteix Java en un llenguatge de tipatge dinàmic. El tipus es fixa en compilació i és tan estricte com sempre:

Restriccions de var:

• Només per a variables locals (dins de mètodes). No val per a camps de classe ni paràmetres.
• Obliga a inicialitzar a la mateixa línia: var x; no compila.
• No admet null com a valor inicial: var x = null; no compila, perquè no hi ha tipus a inferir.

Aquest curs fa servir tipus explícits al mòdul 1 (perquè vegis sempre quin tipus hi ha en joc) i var a partir del mòdul 5, on els tipus genèrics el fan realment útil.

Apliquem tot el que hem après. El catàleg de Nexus Software necessita registrar, per a cada llibre: títol, autor, ISBN, any de publicació i disponibilitat. Amb el que saps avui, això es tradueix en variables soltes:

Sortida:

Aquest enfocament funciona per a un llibre. Però Nexus Software en té centenars. Amb variables soltes necessitaries titol1, titol2, titol3… i res no garantiria que autor2 correspon realment a titol2. Les dades que formen una unitat conceptual estan escampades.

Aquesta és exactament la mancança que resol la programació orientada a objectes: al mòdul 3 crearàs una classe Llibre que agrupi aquestes cinc variables en un únic tipus, i al mòdul 5 desaràs centenars d'aquests objectes en una col·lecció. Fixa't que els noms que estàs fent servir ara (titol, autor, isbn, anyPublicacio, disponible) seran literalment els camps d'aquella classe. N'estàs posant la base.

• Oblidar desar el resultat d'un mètode de String. titol.toUpperCase(); no canvia res. Ha de ser titol = titol.toUpperCase();.
• float x = 3.75; no compila. Els literals decimals són double; cal escriure 3.75f.
• long x = 10000000000; no compila. El literal s'interpreta com a int i desborda. Cal escriure 10000000000L.
• Confondre 'A' amb "A". Cometes simples és char, dobles és String. No són intercanviables.
• Esperar que (int) 3.99 sigui 4. El cast trunca. Per arrodonir, Math.round().
• Fer servir == per comparar String. Compara referències, no contingut. Es fa servir equals(). És tan important que la lliçó següent hi dedica un apartat sencer.
• Declarar variables sense inicialitzar i llegir-les. El compilador ho impedeix en variables locals; agraeix-ho.
• Abusar de var. var resultat = calcular(); obliga el lector a anar a buscar la signatura del mètode. Fes-lo servir només quan el tipus sigui evident.
• Consell: declara final tot allò que no hagi de canviar. És gratis i converteix un error potencial en un error de compilació.
• Consell: fes servir noms que diguin què conté la variable, no de quin tipus és. diesRetard és millor que numeroEnter1.
• Consell: quan dubtis d'un mètode de String, obre'l a JShell i prova'l. Cinc segons davant de deu minuts de suposicions.

Sense executar el codi, escriu què imprimeix cada línia i justifica per què. Després comprova-ho a JShell o compilant-lo.

Escriu la classe FitxaCompleta que declari les variables necessàries per al llibre "Patrons de Disseny" (ISBN 978-0000000002, any 1994, autor "Erich Gamma i altres", disponible) i calculi i mostri:

1. Els anys d'antiguitat del llibre respecte al 2026.
2. L'ISBN sense el prefix 978-.
3. El títol en majúscules.
4. Si el títol té més de 10 caràcters (fes servir una variable boolean i calcula'n el valor amb una comparació, sense if).

Fes servir constants final on correspongui i respecta les convencions de nomenclatura.

El codi següent té sis errors de compilació relacionats amb tipus. Troba'ls, explica cadascun i escriu-ne la versió corregida.

Solució 1

Justificació línia a línia:

• a / b → 3. Tots dos són int, així que es fa divisió entera: el resultat 3,5 es trunca a 3. És l'error més clàssic de Java.
• (double) a / b → 3.5. El cast s'aplica a a abans de dividir, així que l'operació és 7.0 / 2 i per promoció dona 3.5.
• (int) 3.99 → 3. El cast a enter trunca la part decimal; no arrodoneix.
• Math.round(3.99) → 4. Aquest sí que arrodoneix a l'enter més proper.
• titol → Java Eficac. toUpperCase() retorna una cadena nova que es descarta, perquè no s'ha assignat. Els String són immutables.
• substring(0, 4) → Java. Des de l'índex 0 inclòs fins al 4 exclòs: caràcters 0, 1, 2 i 3.
• length() → 11. "Java Eficac" té 4 + 1 espai + 6 = 11 caràcters.
• "Total: " + 2 + 3 → Total: 23. S'avalua d'esquerra a dreta: "Total: " + 2 dona "Total: 2", i a aquella cadena s'hi enganxa el 3.
• "Total: " + (2 + 3) → Total: 5. Els parèntesis forcen la suma numèrica primer.
• (byte) 300 → 44. Un byte només arriba a 127. El valor desborda i es conserven únicament els 8 bits baixos de 300 (100101100 → 00101100 = 44). No hi ha cap avís: és una pèrdua silenciosa.

Solució 2

Sortida:

La idea clau del punt 4: una comparació com ara titol.length() > 10 és una expressió booleana. No cal cap if per obtenir true o false; l'if serveix per decidir què fer amb aquest valor, i això arriba al mòdul 2.

Solució 3

Els sis errors:

1. float tarifaDiaria = 0.25; — el literal 0.25 és double; no cap en un float sense sufix. Solució: 0.25f (o millor, fer servir double).
2. long identificador = 100000000045; — el literal s'interpreta com a int i en desborda el rang. Falta el sufix L.
3. char seccio = "J"; — les cometes dobles creen un String. Un char necessita cometes simples: 'J'.
4. int multa = 3.75; — assignar un double a un int és una conversió estrenyent i requereix cast explícit (o, millor, declarar multa com a double, que és el correcte per a diners).
5. DIES_PRESTEC = 20; — la variable és final; no es pot reassignar.
6. System.out.println(pagines); — pagines s'ha declarat però no s'ha inicialitzat mai, i les variables locals han de tenir valor abans de llegir-se.

Versió corregida:

Ja saps declarar, inicialitzar i assignar variables; coneixes els vuit tipus primitius amb els seus rangs i quins faràs servir de debò; escrius literals en qualsevol base i amb sufixos correctes; distingeixes els primitius (que desen el valor) de les referències (que desen una fletxa al monticle); domines String, la seva immutabilitat i els seus mètodes essencials, inclosos els text blocks; converteixes entre tipus entenent quan la conversió és automàtica i quan trunca; fas servir embolcalls i Integer.parseInt per transformar text en número; protegeixes les teves regles de negoci amb final; i saps quan var ajuda i quan fa nosa. Amb tot això has modelat el primer llibre de BiblioTech.

A la lliçó següent, Operadors, posarem aquestes dades en moviment: aritmètica (inclòs el parany de la divisió entera i el mòdul), assignació composta, increment i decrement, comparacions, operadors lògics amb avaluació de curtcircuit, l'operador ternari, operacions a nivell de bit, precedència, i l'error clàssic de comparar cadenes amb == en comptes d'equals. El fil conductor serà el càlcul de la multa per retard d'un préstec de BiblioTech.