CIAO! Conosci già bene i tipi primitivi e hai lavorato parecchio con loro. Nella programmazione (e Java in particolare), le primitive hanno molti vantaggi: usano poca memoria (e quindi rendono il programma più efficiente) e hanno un intervallo di valori chiaramente delineato. Tuttavia, imparando Java, abbiamo già ripetuto spesso il mantra "tutto in Java è un oggetto". Ma i primitivi contraddicono direttamente quelle parole. Non sono oggetti. Quindi, il nostro principio "tutto è un oggetto" è falso? In realtà, non lo è. In Java, ogni tipo primitivo ha un fratello gemello, una classe wrapper.
Che cos'è una classe wrapper?
Un wrapper è una classe speciale che memorizza internamente una primitiva. Ma poiché è una classe, puoi crearne delle istanze. Memorizzano internamente i valori primitivi, ma sono ancora oggetti reali. I nomi delle classi wrapper sono molto simili (o esattamente uguali) ai nomi delle loro primitive corrispondenti. Quindi, sono facili da ricordare.
Classi wrapper per tipi di dati primitivi |
Tipi di dati primitivi |
Classi wrapper |
int |
Numero intero |
corto |
Corto |
lungo |
Lungo |
byte |
Byte |
galleggiante |
Galleggiante |
Doppio |
Doppio |
char |
Carattere |
booleano |
Booleano |
Gli oggetti wrapper vengono creati allo stesso modo di qualsiasi altro oggetto:
public static void main(String[] args) {
Integer i = new Integer(682);
Double d = new Double(2.33);
Boolean b = new Boolean(false);
}
Le classi wrapper ci consentono di mitigare le carenze dei tipi primitivi. La più ovvia è che le primitive non hanno metodi. Ad esempio, non hanno un metodo
toString() , quindi non puoi, ad esempio, convertire un
int in un
String . Ma la classe wrapper
Integer lo rende facile.
public static void main(String[] args) {
Integer i = new Integer(432);
String s = i.toString();
}
Tuttavia, la conversione nell'altra direzione può essere più complicata. Supponiamo di avere una
String , che sappiamo per certo che contiene un numero. Indipendentemente da ciò, non esiste un modo nativo per utilizzare un
int primitivo per estrarre il numero dalla
stringa e convertirlo in un numero. Ma possiamo farlo con le classi wrapper.
public static void main(String[] args) {
String s = "1166628";
Integer i = Integer.parseInt(s);
System.out.println(i);
}
Produzione:
1166628
Abbiamo estratto con successo un numero dalla
stringa e lo abbiamo assegnato alla variabile di riferimento
Integer i . A proposito, per quanto riguarda i riferimenti. Sai già che gli argomenti vengono passati ai metodi in modi diversi: primitive per valore e oggetti per riferimento. Puoi usare questa conoscenza quando crei i tuoi metodi: ad esempio, se il tuo metodo utilizza numeri frazionari ma hai bisogno di logica per passare per riferimento, puoi passare gli argomenti
Double /
Float al metodo invece di
double /
float . Oltre ai metodi delle classi wrapper, anche i loro campi statici possono essere molto utili. Ad esempio, immagina di avere il seguente compito: visualizzare il massimo possibile
int , seguito dal valore minimo possibile. Questo problema sembra piuttosto basilare. Ma senza Google, è improbabile che tu possa farlo. Ma i wrapper ti consentono di gestire facilmente tali "compiti banali":
public class Main {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
}
}
Questi campi ti impediscono di distrarti dal portare a termine compiti più seri. Per non parlare del fatto che digitare
2147483647 (che sembra essere il valore di MAX_VALUE) non è un'impresa da poco! :) Inoltre, in una lezione precedente, abbiamo sottolineato che gli oggetti wrapper sono immutabili.
public static void main(String[] args) {
Integer a = new Integer(0);
Integer b = new Integer(0);
b = a;
a = 1;
System.out.println(b);
}
Produzione:
0
Lo stato dell'oggetto originariamente puntato da
a non è cambiato (perché anche il valore di
b sarebbe cambiato). Come con
String s, invece di modificare lo stato dell'oggetto wrapper, viene creato in memoria un oggetto completamente nuovo. Quindi, perché i creatori di Java alla fine hanno deciso di lasciare i tipi primitivi nel linguaggio? Dal momento che tutto dovrebbe essere un oggetto, e abbiamo classi wrapper che possono esprimere tutto ciò che esprimono le primitive, perché non mantenere solo i wrapper nel linguaggio e rimuovere le primitive? La risposta è semplice: prestazioni. I tipi primitivi sono chiamati primitivi perché mancano di molte delle caratteristiche "pesanti" degli oggetti. Sì, gli oggetti hanno molti metodi convenienti, ma non sempre ne hai bisogno. A volte, tutto ciò di cui hai bisogno è il numero 33, o 2,62, o
vero /
falso . In situazioni in cui i vantaggi degli oggetti non contano e non sono richiesti per il funzionamento del programma, le primitive sono molto più adatte al compito.
GO TO FULL VERSION