1. Introduzione
Quando inizi a programmare, sembra di poter scrivere codice riga dopo riga e che tutto funzionerà. Ma non appena il programma diventa più complesso, nella testa inizia la confusione: dove si trova cosa, perché è stato scritto, e se bisogna cambiare una riga — dov'è esattamente?
Per questo Java, come la maggior parte dei linguaggi moderni, ci offre un modo per “mettere in ordine” il codice sugli scaffali, così da poter capire in ogni momento che cosa fa il programma e trovare rapidamente il punto giusto.
Immagina un'azienda. Ci sono le risorse umane, la contabilità, il reparto IT, la logistica e così via. Ogni reparto — la propria area di responsabilità, i propri dipendenti e i propri compiti.
In un programma in Java ogni “reparto” è una classe. Una classe si occupa, per esempio, del lavoro con gli utenti, un'altra — dei calcoli, una terza — del lavoro con i file.
Ecco la struttura tipica di un progetto semplice:
- Main.java — sede centrale: qui si trova il “punto di ingresso” da cui tutto inizia.
- User.java — reparto in cui vengono memorizzati e trattati i dati dell'utente.
- Calculator.java — reparto dei calcoli.
- FileHelper.java — specialisti dei file.
Anche in un programma molto piccolo di solito c'è almeno una classe. E i progetti grandi — sono veri e propri “grattacieli” di centinaia di classi!
2. La classe è una cassetta degli attrezzi
Java è un linguaggio orientato agli oggetti, e in esso tutto è un oggetto. I tipi di oggetti si chiamano classi.
Una classe è come una scatola o un armadietto in cui mettiamo le cose che ci servono: variabili, metodi. Immagina una scatola con l'etichetta “Martelli”: dentro ci sono solo strumenti legati ai martelli.
class Example
{
// Qui ci saranno i nostri strumenti: variabili e metodi
}
Le classi di solito contengono variabili e funzioni. In Java le variabili della classe si chiamano campi, e le funzioni della classe — metodi. Ma il senso non cambia.
Ricordi il nostro primo codice?
System.out.println("Ciao a tutti!");
In questo codice ci sono sia una classe sia metodi:
- System — è una classe che contiene metodi per lavorare con il sistema.
- out — è un campo che è un oggetto della classe PrintStream.
- println — è un metodo della classe PrintStream che stampa testo a schermo.
In un certo senso tutta la programmazione si riduce a scrivere le proprie classi e i propri metodi, che a loro volta chiamano i metodi di altre classi.
3. Forma abbreviata del metodo main()
In realtà il programma minimo in Java è così:
class Program
{
public static void main(String[] args)
{
// Qui va il tuo codice
}
}
Contiene almeno una classe, che deve contenere un metodo main con la seguente intestazione (signature):
public static void main(String[] args)main in Java
Tuttavia in Java 21 è stata introdotta la possibilità di scrivere il metodo main() in forma abbreviata. Il compilatore Java poi (in fase di compilazione) lo trasforma nel metodo main() corretto.
Quindi ogni volta che scrivi del codice del tipo:
void main()
{
Scanner console = new Scanner(System.in);
int age = console.nextInt();
System.out.println("Età: " + age);
}
il compilatore Java lo trasforma nel codice:
class Program
{
public static void main(String[] args)
{
Scanner console = new Scanner(System.in);
int age = console.nextInt();
System.out.println("Età: " + age);
}
}
4. Una classe Java tipica
Una tipica classe Java assomiglia a questa:
public class MathUtils
{
// Variabili statiche (globali per la classe)
static final double PI = 3.14159;
static int callCounter = 0;
// Metodo statico: calcolo dell'area del cerchio
public static double circleArea(double radius)
{
callCounter++;
return PI * radius * radius;
}
// Metodo statico: trovare il massimo di due numeri
public static int max(int a, int b)
{
callCounter++;
return (a > b) ? a : b;
}
// Metodo statico: quante volte sono stati chiamati i metodi
public static int getCallCount()
{
return callCounter;
}
// Accediamo ai campi e ai metodi dal metodo main()
public static void main(String[] args)
{
System.out.println("Area del cerchio: " + circleArea(5));
System.out.println("Massimo: " + max(10, 42));
System.out.println("I metodi sono stati chiamati " + getCallCount() + " volte");
}
}
Che cosa vediamo qui:
- Una classe può avere molti metodi.
- Una classe può avere delle proprie variabili.
- I metodi della classe possono chiamarsi tra loro.
- I metodi della classe possono accedere a variabili comuni.
- Davanti a ogni metodo ci sono le stesse “parole magiche” del tipo: public static.
- Davanti a ogni metodo ci sono tipi diversi: int, double, void.
Di seguito analizzeremo tutte queste sfumature.
5. I campi (variabili) di una classe sono la sua memoria
All'interno di una classe si possono memorizzare variabili, spesso chiamate campi (fields). Sono come celle di memoria in cui riponiamo dei dati.
public class MathUtils
{
// Variabili statiche (globali per la classe)
static final double PI = 3.14159;
static int callCounter = 0;
}
I campi permettono alla classe di ricordare qualcosa tra le chiamate di metodi diversi. Per esempio, contare quante volte è stato premuto un pulsante. Oppure quante volte è stato invocato un metodo (callCounter). I campi possono essere in numero arbitrario.
6. Metodi — azioni che la classe può eseguire
I metodi sono le “abilità” della nostra classe. Se la classe è un dipendente, i metodi sono le sue competenze: che cosa sa fare.
Per esempio, un metodo può:
- stampare qualcosa sullo schermo,
- calcolare la somma di due numeri,
- ricevere dati “in ingresso” e restituire un risultato.
Struttura di un metodo:
- Tipo di valore restituito (per esempio, void — se non restituisce nulla, oppure int — se restituisce un numero).
- Nome del metodo (per esempio, circleArea).
- Parametri tra parentesi (possono mancare).
- Parenti graffe { ... } — il corpo del metodo.
public class MathUtils
{
// Metodo statico: calcolo dell'area del cerchio
public static double circleArea(double radius)
{
callCounter++;
return PI * radius * radius;
}
// Metodo statico: trovare il massimo di due numeri
public static int max(int a, int b)
{
callCounter++;
return (a > b) ? a : b;
}
}
Maggiori dettagli sui metodi e su tutte le sfumature correlate li imparerai nelle prossime lezioni.
7. Modificatori di accesso
In Java è possibile definire quali parti della classe sono accessibili da altre classi e quali rimangono solo per esigenze interne. A questo servono i modificatori di accesso.
- public — visibile a tutti. Tali metodi e campi possono essere usati/invocati da qualsiasi punto del programma.
- private — visibile solo all'interno della stessa classe. Sono dettagli interni che non devono essere accessibili agli altri. Come se non esistessero affatto.
public class MathUtils
{
// Variabili statiche (globali per la classe)
private static final double PI = 3.14159;
private static int callCounter = 0;
// Metodo statico: calcolo dell'area del cerchio
public static double circleArea(double radius)
{
callCounter++;
return PI * radius * radius;
}
}
Regola d'oro: di solito i campi si dichiarano private, ed “espongono” all'esterno solo i metodi necessari con il modificatore public. Maggiori dettagli sulla visibilità — nelle prossime lezioni.
8. Metodi e variabili statici
Di solito in Java una classe è usata come modello per creare oggetti. Scrivi la tua classe, poi crei oggetti di quella classe con la parola chiave new. E solo dopo richiami i metodi sugli oggetti.
Esiste però anche un secondo modo di usare una classe — come contenitore per variabili e metodi globali, richiamabili da qualsiasi punto del programma. A questo serve la parola chiave static. Indica al compilatore Java che i metodi e i campi della classe non sono legati a un oggetto della classe, ma direttamente alla classe stessa. E quindi si possono chiamare anche senza creare oggetti della classe.
Tra l'altro, usi continuamente metodi di questo tipo:
Integer.parseInt(); // Metodo statico parseInt() della classe Integer
String.valueOf(); // Metodo statico valueOf() della classe String
Double.isInfinite(); // Metodo statico isInfinite() della classe Double
Arrays.copy(); // Metodo statico copy() della classe Arrays
Il metodo main() è sempre dichiarato statico, perché da esso inizia l'esecuzione del tuo programma Java. Prima di creare qualsiasi oggetto.
9. Trucco in IDEA
La firma completa del metodo main() è la seguente:
public static void main(String[] args)
E per non doverla scrivere ogni volta in IntelliJ IDEA, ci sono delle scorciatoie. Scrivi semplicemente psvm e premi Tab, e IntelliJ IDEA scriverà per te questo codice:
public static void main(String[] args)
{
}
È facile ricordarla — psvm — sono le iniziali di public static void main.
GO TO FULL VERSION