I campi nelle classi Java
In Java, ogni classe è una sorta di modello che può contenere variabili e metodi, e i campi (o variabili di istanza) sono i dati che rappresentano lo stato di ciascun oggetto creato dalla classe.
Cos'è un campo? Un campo è semplicemente una variabile che appartiene a una classe o a un'istanza di una classe. Quando crei un oggetto da quella classe, l'oggetto avrà i suoi valori per quei campi, rendendolo unico. Alcuni li chiamano anche "proprietà" o "attributi".
I campi sono una parte essenziale in Java perché definiscono lo stato degli oggetti, ovvero il loro "comportamento" nel sistema.
Ogni oggetto della stessa classe può avere valori diversi per questi campi.
Facciamo un esempio semplice: supponiamo di voler rappresentare un punto in un piano, usando le coordinate `x` e `y`.
class Punto {
public double x;
public double y;
}
In questo caso, `x` e `y` sono i campi della classe `Punto`. Ogni oggetto creato da questa classe avrà le sue coordinate personali.
Poi creiamo un oggetto dalla classe `Punto`:
Punto p1 = new Punto();
Questo oggetto, `p1`, avrà i propri valori per `x` e `y`, indipendenti da qualsiasi altro oggetto della classe `Punto`.
Ad esempio, assegniamo a questo oggetto le coordinate x=1 e y=2
p1.x=1;
p1.y=2;
Ora creiamo un altro oggetto `p2` usando la stessa classe, a cui assegniamo le coordinate x=3 e y=4
Punto p2 = new Punto();
p2.x=3;
p2.y=4;
Questi due oggetti 'p1' e 'p2' sono stati creati dalla stessa classe 'Punto', hanno gli stessi campi 'x' e 'y' ma valori diversi.
System.out.println("p1.x = "+p1.x);
System.out.println("p1.y = "+p1.y);
System.out.println("p2.x = "+p2.x);
System.out.println("p2.y = "+p2.y);
p1.x = 1.0
p1.y = 2.0
p2.x = 3.0
p2.y = 4.0
Nei prossimi paragrafi di questa guida approfondiremo la visibilità e i vari tipi di campi in Java.
Tipi di campi
Esistono due tipi principali di campi in Java:
- Campi di istanza
I campi di istanza appartengono a una singola istanza (oggetto) della classe. Ciò significa che ogni oggetto ha la propria copia di questi campi, e i loro valori possono essere diversi da oggetto a oggetto.class Persona {
Ad esempio, ogni oggetto `Persona` avrà il proprio nome e la propria età.
String nome;
int eta;
} - Campi statici
I campi statici, invece, appartengono alla classe stessa, non alle singole istanze. C'è solo una copia di questi campi, condivisa da tutti gli oggetti della classe.class Persona {
Ad esempio, il campo `numeroDiPersone` è un campo statico che tiene traccia di quante istanze della classe `Persona` sono state create. Ogni volta che crei un nuovo oggetto `Persona`, questo campo viene incrementato.
static int numeroDiPersone = 0;
String nome;
int eta;
Persona(String nome, int eta) {
this.nome = nome;
this.eta = eta;
numeroDiPersone++;
}
}
Visibilità dei campi
Un altro concetto importante riguarda la visibilità dei campi, ovvero chi può accedere e modificare questi campi. Ecco i vari livelli:
- Public
Un campo dichiarato `public` è accessibile da qualsiasi parte del programma. Questo significa che qualsiasi altra classe o metodo può leggere o modificare il valore del campo.class Libro {
In questo esempio, il campo `titolo` è pubblico e accessibile da ovunque nel programma.
public String titolo;
} - Private
Un campo dichiarato `private` è accessibile solo all'interno della classe in cui è definito. Questo è il livello di accesso più restrittivo ed è molto usato per proteggere i dati, rendendoli inaccessibili direttamente dall'esterno della classe.class Libro {
In questo caso, il campo `titolo` è privato e può essere letto o modificato solo attraverso i metodi pubblici `getTitolo()` e `setTitolo()`.
private String titolo;
public String getTitolo() {
return titolo;
}
public void setTitolo(String titolo) {
this.titolo = titolo;
}
} - Protected
Un campo `protected` è accessibile dalle sottoclassi o dalle classi che si trovano nello stesso pacchetto. - Package-private (senza modificatore)
Se non si specifica alcun modificatore di accesso, il campo è accessibile solo dalle altre classi nello stesso pacchetto.
Valori predefiniti dei campi
Se un campo non viene inizializzato esplicitamente, Java assegna un valore predefinito in base al tipo di dati:
- Tipi numerici (`int`, `double`, ecc.): 0 oppure 0.0
- Boolean: `false`
- Oggetti (es. `String`): `null`
Ad esempio, definisci questa classe:
class Libro {
String titolo; // Valore predefinito: null
int pagine; // Valore predefinito: 0
}
Poiché non hai assegnato esplicitamente valori ai campi, Java assegna `null` al campo `titolo` e `0` al campo `pagine`.
Campi final
Un campo dichiarato come `final` non può essere modificato una volta che gli è stato assegnato un valore.
In altre parole, il suo valore può essere inizializzato solo una volta, generalmente nel costruttore o durante la dichiarazione.
Ad esempio, questa è una classe che usa un campo `final`:
class Libro {
final String ISBN;
Libro(String isbn) {
this.ISBN = isbn; // L'ISBN può essere assegnato solo una volta
}
}
In questo caso, l'ISBN può essere assegnato solo una volta, e dopo non può essere più cambiato.
Incapsulamento
Infine, parliamo dell'incapsulamento, un concetto fondamentale nella programmazione orientata agli oggetti.
L'idea è di nascondere i dettagli interni di un oggetto, permettendo l'accesso solo attraverso metodi pubblici che controllano e gestiscono le interazioni con quei dettagli.
Per ottenere questo, i campi vengono dichiarati `private` e i metodi `getter` e `setter` pubblici per accedervi o modificarli.
class Persona {
private String nome;
private int eta;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getEta() {
return eta;
}
public void setEta(int eta) {
this.eta = eta;
}
}
In questo esempio, il campo `nome` non può essere modificato direttamente dall'esterno, ma solo tramite il metodo `setNome()`, il che permette di controllare esattamente come e quando il campo viene aggiornato.
