El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Sintaxi i estructura bàsica

Següent ►
►

A la lliçó anterior vas escriure HolaBiblioTech.java i el vas executar, però ho vas fer copiant una estructura sense entendre-la. Aquella sensació d'"escric un conjur i funciona" és incòmoda i, sobretot, impedeix avançar: quan alguna cosa falli no sabràs on mirar. Aquesta lliçó disseca un fitxer Java paraula per paraula: què és un paquet, per a què serveix un import, què significa cada terme de public static void main(String[] args), com se separen les sentències, com es comenta el codi, quines convencions de noms segueix la comunitat sencera i, molt important, com llegir els missatges del compilador per no quedar-te mai encallat.

Contingut

  1. Anatomia completa d'un fitxer Java
  2. La declaració de paquet
  3. Els imports
  4. La declaració de classe
  5. El mètode main, paraula per paraula
  6. Sentències, blocs i punt i coma
  7. Comentaris: línia, bloc i Javadoc
  8. Convencions de nomenclatura
  9. Sagnat i estil
  10. Paquets i directoris a la pràctica
  11. Arguments de línia d'ordres: args
  12. Errors de compilació típics i com llegir-los
  13. Errors Habituals i Consells
  14. Exercicis

  1. Anatomia completa d'un fitxer Java

Comencem pel mapa. Aquest és un fitxer Java complet amb totes les seves parts, tal com quedarà l'arrencada de BiblioTech:

package com.nexussoftware.bibliotech;          // 1. Declaracio de paquet

import java.util.Scanner;                      // 2. Imports

/**
 * Punt d'entrada de BiblioTech, el sistema de gestio
 * de la biblioteca tecnica interna de Nexus Software.
 */
public class BiblioTechApp {                   // 3. Declaracio de classe

    public static void main(String[] args) {   // 4. Metode main

        System.out.println("BiblioTech v0.1");  // 5. Sentencies

    }                                          // fi del metode main
}                                              // fi de la classe

L'ordre d'aquestes parts no és opcional: si hi ha declaració de paquet, va la primera; després els imports; després la classe. Invertir l'ordre és un error de compilació.

flowchart TD
    A["package com.nexussoftware.bibliotech;<br/><i>opcional, però com a màxim una i sempre la primera</i>"] --> B["import java.util.Scanner;<br/><i>zero o més</i>"]
    B --> C["public class BiblioTechApp {<br/><i>una classe pública per fitxer</i>"]
    C --> D["public static void main(String[] args) {<br/><i>punt d'entrada</i>"]
    D --> E["sentències;<br/><i>acabades en punt i coma</i>"]

  1. La declaració de paquet

package com.nexussoftware.bibliotech;

Un paquet és un espai de noms: agrupa classes relacionades i evita col·lisions. Si dues llibreries diferents defineixen una classe Llibre, sense paquets seria impossible fer servir totes dues; amb paquets són com.nexussoftware.bibliotech.Llibre i com.altraempresa.Llibre, i no hi ha ambigüitat.

Regles concretes:

  • Ha de ser la primera sentència de codi del fitxer (només la poden precedir comentaris).
  • Només n'hi pot haver una per fitxer.
  • S'escriu completament en minúscules, amb punts separant nivells.
  • Per convenció es fa servir el domini de l'organització a l'inrevés: Nexus Software controlaria nexussoftware.com, així que els seus paquets comencen per com.nexussoftware. Després s'hi afegeix el nom del projecte: com.nexussoftware.bibliotech.

Si n'ometes la declaració, la classe queda al paquet per defecte (sense nom). Funciona per a proves ràpides, però està desaconsellat en qualsevol codi real: les classes del paquet per defecte no es poden importar des d'altres paquets, cosa que bloqueja el creixement del projecte. Durant aquest mòdul veuràs totes dues formes; a partir del mòdul 3, quan BiblioTech tingui diverses classes, farem servir sempre paquet explícit.

  1. Els imports

import java.util.Scanner;

Un import diu al compilador on trobar una classe que faràs servir, perquè puguis escriure Scanner en comptes del nom complet java.util.Scanner cada vegada.

És important entendre el que no fa: un import no copia codi ni augmenta la mida del programa ni l'alenteix. És purament una comoditat d'escriptura. Aquestes dues versions són equivalents:

// Amb import
import java.util.Scanner;
...
Scanner entrada = new Scanner(System.in);

// Sense import, fent servir el nom totalment qualificat
java.util.Scanner entrada = new java.util.Scanner(System.in);

Variants:

Forma Significat
import java.util.Scanner; Importa una classe concreta. És la forma recomanada.
import java.util.*; Importa totes les classes del paquet java.util (no dels seus subpaquets)
import static java.lang.Math.PI; Import estàtic: permet escriure PI en comptes de Math.PI

Per què no has hagut d'importar mai String ni System? Perquè el paquet java.lang s'importa automàticament a tots els fitxers Java. Conté el més bàsic: String, System, Math, Integer, Object, Exception. Tota la resta cal importar-ho.

Els IDE gestionen els imports per tu (IntelliJ els afegeix en escriure el nom de la classe; Ctrl+Alt+O neteja els que sobren), però convé saber què està passant.

  1. La declaració de classe

public class BiblioTechApp {
    ...
}

En Java, tot el codi executable viu dins d'una classe. No existeixen funcions soltes a nivell de fitxer com en Python o JavaScript. Encara que en aquest mòdul la classe sigui només un contenidor per a main, a partir del mòdul 3 en veuràs el propòsit veritable: agrupar dades i comportament.

Dissequem la línia:

  • public és un modificador d'accés: indica que la classe és visible des de qualsevol altre paquet. L'alternativa és no posar-hi res (visibilitat de paquet). Els modificadors d'accés s'estudien a fons a la lliçó 03-07.
  • class és la paraula reservada que declara una classe.
  • BiblioTechApp és el nom. Ha de començar per lletra, $ o _ (a la pràctica, sempre per lletra) i no pot ser una paraula reservada del llenguatge.
  • { ... } delimiten el cos de la classe. Tot el que pertany a la classe va a dins.

La regla del nom del fitxer, ja avançada: si la classe és public, el fitxer ha de dir-se exactament igual que ella més .java. public class BiblioTechApp → BiblioTechApp.java. Java distingeix majúscules de minúscules, així que bibliotechapp.java no val. Un fitxer pot contenir diverses classes, però només una d'elles pot ser public.

  1. El mètode main, paraula per paraula

public static void main(String[] args) {

Aquesta signatura és un contracte amb la JVM. Quan executes java BiblioTechApp, la màquina virtual busca en aquella classe un mètode amb exactament aquesta forma. Si difereix en qualsevol detall, no arrenca. Analitzem cada terme:

Paraula Què significa Per què cal aquí
public Accessible des de qualsevol lloc La JVM crida el mètode des de fora de la teva classe; si fos privat no podria
static Pertany a la classe, no a un objecte En arrencar el programa encara no existeix cap objecte de BiblioTechApp; sense static la JVM n'hauria de crear un primer
void No retorna cap valor Quan main acaba, no hi ha ningú al teu codi a qui retornar res
main El nom exacte que busca la JVM És una convenció fixada per la plataforma, no pot ser cap altre
String[] args Un paràmetre: array de cadenes Rep els arguments escrits a la línia d'ordres

Detalls que solen sorprendre:

  • El nom del paràmetre sí que pot canviar: String[] arguments és igual de vàlid. El que no pot canviar és el seu tipus.
  • String[] args i String args[] són equivalents; la primera forma és la convenció moderna.
  • Des de Java 21 es pot escriure void main() sense modificadors en fitxers d'un sol fitxer (una característica en previsualització pensada per a l'aprenentatge). Aquest curs fa servir la forma estàndard completa, que és la que trobaràs a tot el codi professional.
  • Pots escriure static public void main(...): l'ordre dels modificadors és lliure. La convenció és public static.

Si t'equivoques a la signatura, el programa compila sense problemes (és un mètode vàlid, senzillament no és el main), però en executar-lo obtens:

Error: Main method not found in class BiblioTechApp

És a dir, un error d'execució, no de compilació. Recordar-ho t'estalviarà confusió.

  1. Sentències, blocs i punt i coma

Una sentència és una instrucció completa. En Java tota sentència acaba en punt i coma:

int anyPublicacio = 2018;
System.out.println("BiblioTech");
double multa = diesRetard * 0.25;

Un bloc és un conjunt de sentències entre claus { }. Els blocs defineixen el cos de classes i mètodes, i més endavant el de condicionals i bucles.

La regla que evita el 90 % dels dubtes: les claus no porten punt i coma al darrere.

public class BiblioTechApp {   // sense ; despres de la clau
    public static void main(String[] args) {   // sense ; tampoc
        System.out.println("Hola");            // AMB ; : es una sentencia
    }                                          // sense ;
}                                              // sense ;

Java és un llenguatge de format lliure: els salts de línia i els espais no canvien el significat, només la llegibilitat. Aquestes tres versions compilen de manera idèntica:

// Llegible
int anyPublicacio = 2018;
String titol = "Java Eficac";

// Igualment valid, illegible
int anyPublicacio=2018;String titol="Java Eficac";

// Igualment valid, absurd
int
    anyPublicacio
        =
            2018 ;

Que el compilador accepti les tres no vol dir que valguin el mateix: el codi es llegeix moltes més vegades de les que s'escriu.

  1. Comentaris: línia, bloc i Javadoc

Els comentaris són text que el compilador ignora. Java en té tres formes i cadascuna té el seu lloc:

// Comentari d'una linia. Tot el que segueix a // fins al final de linia s'ignora.

/*
   Comentari de bloc.
   Pot ocupar diverses linies.
   Util per desactivar temporalment un fragment de codi.
*/

/**
 * Comentari Javadoc. S'escriu ABANS d'una classe, metode o camp
 * i serveix per generar documentacio HTML amb l'eina javadoc.
 *
 * @author Equip BiblioTech
 * @version 0.1
 */
Tipus Sintaxi Ús típic
Línia // text Aclarir una línia concreta; el més habitual
Bloc /* text */ Explicacions llargues; desactivar codi temporalment
Javadoc /** text */ Documentar l'API pública: què fa una classe o mètode

Javadoc és més que un comentari bonic: l'eina javadoc inclosa en el JDK genera amb ells un lloc web de documentació, i els IDE els mostren com a ajuda contextual quan passes el ratolí sobre una classe. La documentació oficial de l'API de Java està generada exactament així. Les seves etiquetes més utilitzades són @param (descriu un paràmetre), @return (descriu el valor retornat) i @author. En aquest mòdul amb prou feines les faràs servir perquè només tens main, però a partir del mòdul 3 seran habituals.

Un consell sobre el bon comentari: no expliquis què fa el codi si el codi ja ho diu; explica per què.

// MALAMENT: redundant, no aporta res
int diesRetard = 12;   // assigna 12 a diesRetard

// BE: aporta context que el codi no pot expressar
// Nexus Software concedeix 15 dies naturals de prestec abans d'aplicar multa.
final int DIES_PRESTEC = 15;

  1. Convencions de nomenclatura

Java no obliga a seguir-les: el compilador accepta class biblio_tech_app. Però la comunitat Java és excepcionalment uniforme en aquest punt, i saltar-se les convencions marca immediatament el codi com a amateur. A més, tenen un valor funcional: et diuen d'un cop d'ull quin tipus d'element estàs mirant.

Element Convenció Exemples de BiblioTech
Classe i interfície PascalCase (cada paraula en majúscula) BiblioTechApp, Llibre, GestorPrestecs
Mètode camelCase, comença per verb calcularMulta(), registrarPrestec()
Variable camelCase titol, anyPublicacio, diesRetard
Constant MAJUSCULES_AMB_GUIO_BAIX TARIFA_DIARIA, DIES_PRESTEC
Paquet tot.en.minuscules com.nexussoftware.bibliotech

Per què importen de debò:

  • En llegir Llibre llibre = ... saps sense pensar-hi que Llibre és un tipus i llibre una variable. La convenció elimina l'ambigüitat.
  • En veure TARIFA_DIARIA saps que és un valor que no canvia, sense anar a buscar-ne la declaració.
  • Els IDE, els analitzadors estàtics i les eines de generació de codi les donen per fetes.

Regles addicionals sobre noms:

  • Han de començar per lletra, _ o $. Mai per dígit.
  • Poden contenir lletres, dígits, _ i $. Java admet accents i ç perquè accepta Unicode, però evita'ls: causen problemes de codificació entre sistemes. Escriu anyPublicacio, no anyPublicació.
  • No poden ser paraules reservades (class, int, public, static, new, return…).
  • Es distingeixen majúscules i minúscules: titol, Titol i TITOL són tres identificadors diferents.
  • Fes servir noms descriptius. diesRetard és infinitament millor que d o x. El nom d'una variable és la documentació més llegida del codi.

  1. Sagnat i estil

El sagnat no afecta la compilació, però és el primer que separa el codi llegible de l'illegible. Les convencions dominants en Java:

  • Quatre espais per nivell d'imbricació (no tabuladors; configura-ho al teu IDE).
  • Clau d'obertura al final de la línia, no en línia pròpia. És l'estil oficial de Java i difereix de l'habitual en C#.
  • Un espai al voltant dels operadors: int total = a + b;, no int total=a+b;.
  • Línies de longitud raonable (100-120 caràcters com a màxim).
  • Una línia en blanc per separar blocs lògics.
// Estil Java convencional
public class BiblioTechApp {

    public static void main(String[] args) {
        String titol = "Java Eficac";
        int anyPublicacio = 2018;

        System.out.println(titol + " (" + anyPublicacio + ")");
    }
}

Tots els IDE reformaten automàticament: a IntelliJ és Ctrl+Alt+L, a Eclipse Ctrl+Shift+F, a VS Code Shift+Alt+F. Acostuma't a prémer-ho abans de donar per acabat un fitxer.

  1. Paquets i directoris a la pràctica

Aquí hi ha una regla estricta que provoca molts errors en començar: la jerarquia de paquets s'ha de correspondre amb la jerarquia de directoris.

Si el teu fitxer declara:

package com.nexussoftware.bibliotech;

llavors BiblioTechApp.java ha de ser a .../com/nexussoftware/bibliotech/BiblioTechApp.java.

flowchart TD
    A["src/main/java/"] --> B["com/"]
    B --> C["nexussoftware/"]
    C --> D["bibliotech/"]
    D --> E["BiblioTechApp.java<br/>package com.nexussoftware.bibliotech;"]

I això canvia com compiles i executes des del terminal. Situat a src/main/java:

# Compilar indicant el cami complet del fitxer
javac com/nexussoftware/bibliotech/BiblioTechApp.java

# Executar fent servir el nom COMPLETAMENT QUALIFICAT de la classe
java com.nexussoftware.bibliotech.BiblioTechApp

Observa la diferència essencial: en compilar fas servir barres (és un camí de fitxer); en executar fas servir punts (és un nom de classe). Escriure java BiblioTechApp a seques quan la classe és dins d'un paquet produeix Could not find or load main class, perquè el nom real de la classe inclou el seu paquet.

Una opció pràctica per no embrutar el codi font amb els .class:

javac -d ../../../out com/nexussoftware/bibliotech/BiblioTechApp.java
java -cp ../../../out com.nexussoftware.bibliotech.BiblioTechApp
  • -d indica el directori de sortida dels .class, i javac hi recrea l'estructura de paquets automàticament.
  • -cp (classpath) indica on ha de buscar les classes l'ordre java.

Quan treballis a l'IDE, tot això ho gestiona ell; però quan alguna cosa falli, sabràs què està fent per sota.

  1. Arguments de línia d'ordres: args

El paràmetre String[] args rep els valors que escrius després del nom de la classe en executar. És la manera més simple de passar dades a un programa.

public class ArgumentsBiblioTech {
    public static void main(String[] args) {
        // args.length indica quants arguments s'han rebut.
        System.out.println("Arguments rebuts: " + args.length);

        // args[0] es el primer, args[1] el segon... (es compta des de 0)
        System.out.println("Primer argument: " + args[0]);
        System.out.println("Segon argument: " + args[1]);
    }
}

Execució:

javac ArgumentsBiblioTech.java
java ArgumentsBiblioTech "Java Eficac" 978-0000000001

Sortida:

Arguments rebuts: 2
Primer argument: Java Eficac
Segon argument: 978-0000000001

Punts clau:

  • Els arguments se separen per espais. Si un valor conté espais (com ara Java Eficac), cal envoltar-lo de cometes; si no, arribarien com a dos arguments diferents.
  • Sempre arriben com a String, encara que escriguis un número. java Programa 2018 fa que args[0] sigui el text "2018", no pas el número. Per convertir-lo es fa servir Integer.parseInt(args[0]), que veuràs a la lliçó 01-04.
  • L'índex comença en 0: el primer argument és args[0].
  • Si accedeixes a un índex que no existeix (per exemple args[1] quan només n'has passat un), el programa falla en execució amb ArrayIndexOutOfBoundsException. Comprovar args.length abans requereix condicionals, que arriben al mòdul 2; el tractament de l'error, al mòdul 6.
  • El nom de la classe no forma part d'args, a diferència del que passa en C.

Als IDE també es poden configurar: a IntelliJ, Run → Edit Configurations… → Program arguments.

  1. Errors de compilació típics i com llegir-los

Aprendre a llegir els missatges de javac és una habilitat que es paga sola. El format és sempre el mateix:

Fitxer.java:NUMERO_DE_LINIA: error: DESCRIPCIO
        el codi d'aquesta linia
              ^   <- assenyala la posicio exacta
1 error

Vegem els quatre més freqüents amb el seu diagnòstic.

';' expected

System.out.println("BiblioTech")   // falta el punt i coma
BiblioTechApp.java:4: error: ';' expected
        System.out.println("BiblioTech")
                                        ^

Diagnòstic: falta un punt i coma. Avís important: el compilador assenyala el final de la línia anterior al problema, així que si l'error sembla no tenir sentit a la línia indicada, mira la línia de sobre.

cannot find symbol

System.out.println(titol);   // 'titol' no s'ha declarat
BiblioTechApp.java:5: error: cannot find symbol
        System.out.println(titol);
                           ^
  symbol:   variable titol
  location: class BiblioTechApp

Diagnòstic: el compilador no coneix aquest nom. Les tres causes, per freqüència: (1) no l'has declarat; (2) l'has escrit amb unes altres majúscules (Titol vs titol); (3) falta l'import d'una classe.

incompatible types

int anyPublicacio = "2018";   // text assignat a un enter
BiblioTechApp.java:4: error: incompatible types: String cannot be converted to int
        int anyPublicacio = "2018";
                            ^

Diagnòstic: el tipatge estàtic de Java en acció. Estàs ficant un valor d'un tipus dins d'una variable d'un altre. És exactament la mena d'error que en un llenguatge dinàmic explotaria en producció.

class X is public, should be declared in a file named X.java

Diagnòstic: el nom del fitxer no coincideix amb el de la classe pública. Reanomena'n un dels dos.

Errors de compilació davant d'errors d'execució

És una distinció fonamental:

Error de compilació Error d'execució
Quan apareix En executar javac, abans de córrer res Mentre el programa està funcionant
Qui el detecta El compilador La JVM
Exemples Falta ;, tipus incompatibles, símbol no trobat ArrayIndexOutOfBoundsException, divisió entera per zero
Cost Barat: el veus en segons Car: pot aparèixer només amb certes dades, fins i tot en producció

Un consell de mètode: quan javac reporti vint errors, corregeix només el primer i torna a compilar. Una sola errada (una clau sense tancar, per exemple) desencadena una cascada d'errors derivats que desapareixen sols.

Errors Habituals i Consells

  • Posar punt i coma darrere de la clau de tancament d'un mètode o classe. No és un error greu (Java ho tolera com a sentència buida en alguns contextos), però delata desconeixement i en altres casos produeix error.
  • Escriure Main en comptes de main. Java distingeix majúscules: compila, però en executar diu Main method not found.
  • Oblidar que la classe pública i el fitxer s'han de dir igual.
  • Col·locar l'import abans del package. L'ordre és fix: package, després import, després la classe.
  • Executar java BiblioTechApp quan la classe és dins d'un paquet. Cal fer servir el nom qualificat complet: java com.nexussoftware.bibliotech.BiblioTechApp.
  • Refiar-se del número de línia de l'error sense mirar l'anterior. Molt típic amb ';' expected.
  • Consell: configura el teu IDE perquè formati en desar. No discutiràs mai sobre estil i el teu codi serà uniforme des del primer dia.
  • Consell: quan copiïs codi d'internet, teclegeja'l. Els errors que cometis i corregeixis són l'aprenentatge real.
  • Consell: les claus desequilibrades són la causa més freqüent d'errors incomprensibles. Tots els IDE ressalten la clau parella en situar-hi el cursor a sobre: fes-ho servir.

Exercicis

Exercici 1: Caçar els errors

El fitxer següent, desat com a BiblioTechApp.java, conté cinc errors. Localitza'ls, explica per què són errors i escriu-ne la versió corregida.

import java.util.Scanner;
package com.nexussoftware.bibliotech;

public class bibliotechApp {
    public static void Main(String args) {
        System.out.println("BiblioTech - Nexus Software")
        System.out.println("Llibre: " + Titol);
    }
}

Exercici 2: Fitxa amb paquet i arguments

Crea la classe FitxaBiblioTech dins del paquet com.nexussoftware.bibliotech, amb l'estructura de directoris correcta. El programa ha de rebre per línia d'ordres el títol i l'ISBN d'un llibre i mostrar-los al costat d'una capçalera. Inclou-hi un comentari Javadoc a la classe i un comentari de línia que expliqui d'on surten les dades. Escriu també les ordres exactes de compilació i execució.

Execució esperada:

java com.nexussoftware.bibliotech.FitxaBiblioTech "Patrons de Disseny" 978-0000000002

Sortida:

=== BiblioTech (Nexus Software) ===
Titol: Patrons de Disseny
ISBN: 978-0000000002

Exercici 3: Aplicar les convencions

El codi següent compila perfectament, però incompleix totes les convencions de Java. Reescriu-lo aplicant-les i justifica cada canvi.

public class prestec_app{
public static void main(String[] args){
int DiesRetard=12;
double tarifa_diaria=0.25;
final double multa_maxima=20.0;
String Nom_Empleat="Marta Ruiz";
System.out.println(Nom_Empleat+" deu "+(DiesRetard*tarifa_diaria));
}
}

Solucions

Solució 1

Els cinc errors:

  1. import abans de package. La declaració de paquet ha de ser la primera sentència del fitxer.
  2. class bibliotechApp no coincideix amb el nom del fitxer BiblioTechApp.java. A més incompleix PascalCase.
  3. Main en comptes de main. Amb majúscula no és el punt d'entrada; el programa compilaria però fallaria en executar-se amb Main method not found.
  4. String args en comptes de String[] args. El paràmetre ha de ser un array de cadenes; sense els claudàtors, la signatura no és la que busca la JVM.
  5. Falta el punt i coma al final del primer println. I hi ha un sisè problema encadenat: Titol no està declarat enlloc, cosa que produiria cannot find symbol.

Versió corregida:

package com.nexussoftware.bibliotech;   // 1. El package va SEMPRE el primer

import java.util.Scanner;               // L'import va despres del package

// 2. El nom de la classe publica coincideix amb el del fitxer, en PascalCase
public class BiblioTechApp {

    // 3 i 4. Signatura exacta que busca la JVM: main en minuscules i String[]
    public static void main(String[] args) {

        // Declarem la variable abans de fer-la servir (soluciona 'cannot find symbol')
        String titol = "Java Eficac";

        // 5. Tota sentencia acaba en punt i coma
        System.out.println("BiblioTech - Nexus Software");
        System.out.println("Llibre: " + titol);
    }
}

Nota: si finalment no fas servir Scanner, el correcte és eliminar-ne l'import. Un import sense fer servir no és un error, però sí soroll.

Solució 2

Estructura de directoris, partint de l'arrel del projecte:

bibliotech/
└── src/
    └── main/
        └── java/
            └── com/
                └── nexussoftware/
                    └── bibliotech/
                        └── FitxaBiblioTech.java

El fitxer:

package com.nexussoftware.bibliotech;

/**
 * Mostra per consola la fitxa basica d'un llibre del cataleg de BiblioTech.
 * Les dades es reben com a arguments de linia d'ordres.
 *
 * @author Equip BiblioTech - Nexus Software
 * @version 0.1
 */
public class FitxaBiblioTech {

    public static void main(String[] args) {
        // args[0] i args[1] arriben des de la linia d'ordres, en aquest ordre,
        // i SEMPRE son de tipus String encara que continguin digits.
        String titol = args[0];
        String isbn = args[1];

        System.out.println("=== BiblioTech (Nexus Software) ===");
        System.out.println("Titol: " + titol);
        System.out.println("ISBN: " + isbn);
    }
}

Ordres, situant-se a src/main/java:

# Compilar: s'indica el CAMI del fitxer, amb barres
javac -d ../../../out com/nexussoftware/bibliotech/FitxaBiblioTech.java

# Executar: s'indica el NOM DE LA CLASSE qualificat, amb punts
java -cp ../../../out com.nexussoftware.bibliotech.FitxaBiblioTech "Patrons de Disseny" 978-0000000002

Detall important: "Patrons de Disseny" va entre cometes perquè conté espais. Sense elles, el sistema passaria tres arguments (Patrons, de, Disseny) i la sortida seria incorrecta.

Solució 3

/**
 * Calcula la multa per retard d'un prestec de BiblioTech.
 */
public class PrestecApp {                          // PascalCase, no snake_case

    public static void main(String[] args) {
        int diesRetard = 12;                       // camelCase per a variables
        double tarifaDiaria = 0.25;                // camelCase, no snake_case
        final double MULTA_MAXIMA = 20.0;          // constant: MAJUSCULES_AMB_GUIO
        String nomEmpleat = "Marta Ruiz";          // camelCase, comenca en minuscula

        double multa = diesRetard * tarifaDiaria;  // extraiem el calcul a una variable

        System.out.println(nomEmpleat + " deu " + multa + " euros");
        System.out.println("Multa maxima aplicable: " + MULTA_MAXIMA + " euros");
    }
}

Justificació de cada canvi:

Abans Després Motiu
prestec_app PrestecApp Les classes fan servir PascalCase; snake_case no és estil Java
DiesRetard diesRetard Començar per majúscula fa que sembli una classe
tarifa_diaria tarifaDiaria Les variables fan servir camelCase
multa_maxima MULTA_MAXIMA És final, és a dir, una constant: s'escriu en majúscules
Nom_Empleat nomEmpleat Barrejava dues convencions incorrectes alhora
Sense sagnat 4 espais per nivell Llegibilitat
Càlcul dins del println Variable multa Separa el càlcul de la presentació i facilita reutilitzar-lo

Conclusió

Ja no hi ha conjurs: saps que un fitxer Java s'ordena en package, import i classe; que public static void main(String[] args) és un contracte amb la JVM i què hi aporta cada paraula; que les sentències acaben en punt i coma i les claus no; que hi ha tres tipus de comentari i que Javadoc genera documentació real; que les convencions de noms comuniquen informació d'un cop d'ull; que els paquets es corresponen amb directoris i això canvia com compiles i executes; que args porta arguments de la línia d'ordres sempre com a text; i, sobretot, com llegir un missatge d'error del compilador en comptes de bloquejar-t'hi al davant.

A la lliçó següent, Variables i tipus de dades, omplirem de contingut aquest esquelet: els vuit tipus primitius amb els seus rangs, els literals, la diferència entre tipus primitius i per referència, String i la seva immutabilitat, les conversions de tipus, les constants amb final i la inferència amb var. En acabar-la podràs modelar un llibre complet del catàleg de BiblioTech amb variables.

◄ Anterior
◄
Següent ►
►

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de control

Mòdul 3: Programació orientada a objectes

Mòdul 4: Programació orientada a objectes avançada

Mòdul 5: Estructures de dades i col·leccions

Mòdul 6: Gestió d'excepcions

Mòdul 7: Entrada/sortida de fitxers

Mòdul 8: Multifil i concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes avançats

Mòdul 11: Frameworks i llibreries de Java

Mòdul 12: Construcció d'aplicacions del món real

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2026. Tots els drets reservats