1. Che cosa sono classe e oggetto
Cominciamo con un’analogia. Immaginate il progetto di un’automobile. Nel progetto è indicato che l’auto ha quattro ruote, un motore, un colore, sedili ecc. Ma il progetto di per sé non percorre le strade, non fa rumore con il motore e non ha bisogno di benzina. È solo una descrizione di come è fatta l’auto.
Classe in programmazione — è un “progetto” (o modello) che definisce quali dati (campi) e azioni (metodi) avranno le sue istanze.
Oggetto — è la “macchina reale” assemblata secondo quel progetto, cioè un’istanza concreta. Ogni oggetto ha il proprio stato (per esempio, un’auto è rossa, un’altra — blu) e un comportamento: ogni oggetto può eseguire le azioni definite nella classe (ad esempio, andare, frenare, suonare).
Esempi dalla vita reale
- Classe: Chelovek (Person) — la descrizione secondo cui una persona ha nome, età, altezza e può parlare o correre.
- Oggetti: Vasya, Petya, Katya — persone concrete, ciascuna con il proprio nome ed età.
| Classe | Oggetto 1 | Oggetto 2 |
|---|---|---|
|
|
|
Perché le classi sono importanti?
- Raggruppare insieme variabili e metodi correlati.
- Creare quanti oggetti si desidera con la stessa struttura ma dati diversi.
- Descrivere facilmente entità complesse: ad esempio “Conto bancario”, “Prodotto”, “Libro”, “Utente”.
2. Sintassi della dichiarazione di una classe
In Java una classe si dichiara con la parola chiave class. Segue il nome della classe (per tradizione — con l’iniziale maiuscola), e poi — le parentesi graffe, all’interno delle quali si scrivono campi e metodi.
Esempio più semplice
public class Person {
// Qui andranno campi e metodi
}
Spiegazione:
- public — modificatore di accesso.
- class — dice al compilatore: “sto dichiarando una classe”.
- Person — il nome della classe (lo scegliete voi, ma con iniziale maiuscola).
Regole importanti per i nomi delle classi
- Il nome di una classe deve iniziare con la maiuscola (ad es., Car, Account, Book).
- Nel nome della classe non sono consentiti spazi e caratteri speciali, tranne il trattino basso e $ (ma è raro).
- Se il nome è composto da più parole, usa lo stile CamelCase: BankAccount, BookStore.
Dove scrivere le classi?
Si può dichiarare una classe in un file separato (di solito si fa così: un file — una classe) oppure all’interno di un’altra classe (dei tipi annidati parleremo più avanti).
Ad esempio, il file Person.java:
public class Person {
// campi e metodi
}
3. Campi e metodi di una classe (in breve)
Finora abbiamo solo dichiarato la classe, ma è vuota — come una scatola senza contenuto. Aggiungiamo “proprietà” (campi) e “azioni” (metodi).
Campi (variabili all’interno della classe)
I campi descrivono quali dati avrà ogni oggetto di questa classe.
public class Person {
String name; // nome della persona
int age; // età
}
Metodi (funzioni all’interno della classe)
I metodi descrivono che cosa sa fare un oggetto.
public class Person {
String name;
int age;
void sayHello() {
System.out.println("Ciao, mi chiamo " + name + "!");
}
}
Spiegazione:
- void — il metodo non restituisce nulla (parleremo dei valori di ritorno più avanti).
- sayHello() — nome del metodo, le parentesi tonde sono obbligatorie.
- All’interno del metodo si può accedere ai campi della classe (ad esempio a name).
4. Creazione di un oggetto
E ora — magia! Come trasformare il progetto in una “macchina reale”? Si usa la parola chiave new.
Sintassi di creazione di un oggetto
Person vasya = new Person();
- Person — il tipo della variabile (la nostra classe).
- vasya — il nome della variabile (puoi sceglierne uno qualsiasi).
- new Person() — creazione di un nuovo oggetto di tipo Person.
Ora abbiamo la variabile vasya, che fa riferimento a un oggetto della classe Person. Questo oggetto ha i suoi campi e metodi.
Accesso ai campi e ai metodi
Si accede a campi e metodi tramite il punto:
vasya.name = "Vasya";
vasya.age = 25;
vasya.sayHello(); // Stamperà: Ciao, mi chiamo Vasya!
Si possono creare quanti oggetti si vuole
Person petya = new Person();
petya.name = "Petya";
petya.age = 30;
petya.sayHello(); // Ciao, mi chiamo Petya!
Ogni oggetto è una “copia” indipendente con i propri dati.
5. Collegamento con gli argomenti precedenti
Fino a questa lezione, tutte le variabili e i metodi li dichiaravamo direttamente nella classe con il metodo main e non pensavamo a creare tipi propri. Ora possiamo creare nostri “contenitori” di dati e funzioni.
Questo apre enormi possibilità! Ora potete descrivere qualsiasi entità presente nel vostro problema: clienti, prodotti, conti, ordini, animali, automobili — tutto ciò che volete. I programmi diventano più strutturati, leggibili e scalabili.
Esempio: la nostra prima classe personalizzata
Scriviamo una semplice classe per la nostra mini‑app — diciamo, “BankAccount”. Svilupperemo questo esempio man mano che prosegue il corso.
public class BankAccount {
String owner; // titolare del conto
int balance; // saldo del conto
void printInfo() {
System.out.println("Proprietario: " + owner + ", saldo: " + balance + " euro.");
}
}
Ora, nel metodo main (che serve comunque per avviare il programma) possiamo creare oggetti di questa classe:
public class Main {
public static void main(String[] args) {
BankAccount account1 = new BankAccount();
account1.owner = "Ivan";
account1.balance = 1000;
account1.printInfo(); // Proprietario: Ivan, saldo: 1000 euro.
BankAccount account2 = new BankAccount();
account2.owner = "Maria";
account2.balance = 2000;
account2.printInfo(); // Proprietario: Maria, saldo: 2000 euro.
}
}
Attenzione: ogni oggetto ha i propri valori dei campi. Se modificate il saldo di account1, ciò non influisce in alcun modo su account2.
Schema visivo: classe e oggetti
graph TD
subgraph Class
Person["Class Person | name:String | age:int | sayHello()"]
end
subgraph Objects
vasya["vasya : Person | name = 'Vasya' | age = 20"]
petya["petya : Person | name = 'Petya' | age = 25"]
end
vasya --> Person
petya --> Person
Spiegazione:
- Person — è la classe (modello).
- vasya e petya — sono oggetti (istanze) creati da questo modello.
6. Errori tipici nella dichiarazione delle classi e nella creazione degli oggetti
Errore n. 1: Nome della classe con iniziale minuscola.
In Java è consuetudine (il compilatore non si lamenta, ma tutti i programmatori esperti — sì!) chiamare le classi con iniziale maiuscola. Non scrivere class person — scrivi class Person.
Errore n. 2: Mancanza delle parentesi graffe.
Ricordate che il corpo della classe deve sempre essere racchiuso tra parentesi graffe.
public class Person // errore!
String name;
Corretto:
public class Person {
String name;
}
Errore n. 3: Tentativo di accedere ai campi e ai metodi della classe senza creare un oggetto.
Se un metodo o un campo non è dichiarato come static, si può accedervi solo tramite un oggetto:
Person.sayHello(); // errore!
Corretto:
Person vasya = new Person();
vasya.sayHello();
Errore n. 4: Disallineamento tra nome del file e nome della classe (per una classe public).
Se una classe è dichiarata come public, il nome del file deve coincidere con il nome della classe:
// File Person.java
public class Person { ... }
Se il file ha un nome diverso, il compilatore genererà un errore.
Errore n. 5: Uso delle variabili della classe senza inizializzare un oggetto.
I campi della classe (non static) appartengono all’oggetto, non alla classe stessa.
GO TO FULL VERSION