Wikibooks

Java/Tipi di dato: differenze tra le versioni

Naviga nella cronologia in modo interattivo
← Differenza precedenteDifferenza successiva →
Contenuto cancellato Contenuto aggiunto
VisualeWikitesto
m migrazione automatica di 3 collegamenti interwiki a Wikidata, d:q19366911
Gian BOT (discussione | contributi)
Bot
9 439 modifiche
m Bot: sostituzione tag obsoleti
Riga 2:
 
== Tipi ==
Un tipo di dati definisce un insieme di possibili valori e un insieme di operazioni che possono essere applicate su tali valori. Ad esempio, le scritture <ttcode>true</ttcode> e <ttcode>false</ttcode> identificano due ''valori'' di tipo <ttcode>boolean</ttcode>, ed è possibile utilizzarli in combinazione con gli operatori logici <ttcode>&&</ttcode>, <ttcode>||</ttcode> e altri.
 
I tipi ammessi in un programma Java sono i seguenti:
Riga 20:
Non può neanche definire tipi array personalizzati, in quanto tutti i tipi array hanno un comportamento comune fissato dal linguaggio.
 
Il ''nulltype'' ammette un solo valore possibile, indicato con il valore letterale <ttcode>null</ttcode>. Quest'ultimo, pur ''non'' essendo un oggetto, può svolgere il ruolo di "segnaposto" in sostituzione di un oggetto, perché formalmente può essere convertito (tramite cast implicito) verso qualunque tipo riferimento.<br/>
Il tipo ''void'' non ammette alcun valore ed è utilizzato come tipo di ritorno dei metodi che non restituiscono un valore.
 
Riga 57:
 
=== Differenze con il C++ ===
La dimensione dei tipi primitivi del Java non dipende dalla macchina su cui il programma è in esecuzione. Questo comportamento è differente rispetto a quello di altri linguaggi compilati in codice "nativo", primo fra tutti il linguaggio C++, nel quale i tipi base hanno dimensioni diverse a seconda che ci si trovi su una macchina piuttosto che su un'altra.<ref>Il programmatore C++ che desideri un tipo lungo esattamente ''n'' bits può importare <ttcode>cstdint</ttcode> (<ttcode>[[w:en:stdint.h|stdint.h]]</ttcode> in C).</ref> Questo significa che in Java è il linguaggio stesso che stabilisce il limite minimo e il limite massimo dei valori ammessi dai tipi numerici.
 
Su una macchina il cui processore gestisce gli interi a 32 bit usando parole a 64 bit, un compilatore C++ potrebbe decidere di implementare le variabili ''int'' facendo occupare loro 8 byte anziché 4; in Java questo non è permesso: in questo esempio, anche se la macchina virtuale ''può'' decidere di utilizzare parole a 64 bit, questo rimane trasparente al codice Java che dalla VM è eseguito, nel quale il tipo ''int'' si comporta sempre esattamente come se fosse dotato di soli 32 bits.
Riga 100:
La famiglia dei tipi base e la famiglia dei tipi riferimento sono separate l'una dall'altra e definiscono due gerarchie distinte che non hanno alcun punto di giunzione. Per questo motivo, fino alla terza edizione della specifica di linguaggio, non erano ammesse conversioni tra tipi primitivi e tipi riferimento, né tramite ''cast'' implicito, né tramite ''cast'' esplicito.
 
Ogni classe wrapper permette di associare un oggetto a un valore del tipo primitivo corrispondente, e viceversa. Ad esempio, è possibile ottenere un oggetto <ttcode>Integer</ttcode> partendo da un numero di tipo <ttcode>int</ttcode>, invocando il [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html#Integer(int) costruttore appropriato]; ed è possibile riottenere il numero intero invocando sull'oggetto il metodo [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html#intValue() intValue()]. Un discorso analogo vale per ciascuno degli altri tipi primitivi. L'operazione di inserimento di un valore primitivo in un oggetto prende il nome di ''boxing''.
 
Prima di Java 5, era necessario invocare esplicitamente i costruttori e i metodi <ttcode>xxxValue()</ttcode> appropriati. Per rendere più sintetico e leggibile il codice che richiama queste operazioni, dalla terza versione della specifica di linguaggio (Java 5) in poi, è ammesso il ''cast'' (implicito o esplicito) di un valore di un tipo primitivo verso il corrispondente tipo wrapper, e viceversa. Il compilatore sostituisce automaticamente questa sintassi con una istruzione che invoca i metodi o i costruttori del tipo wrapper.<br/>
L'operazione di inserimento di un valore primitivo in un oggetto ''tramite cast'' si chiama ''autoboxing''; l'operazione inversa (svolta sempre tramite cast) si chiama ''unboxing''.
 
Quindi, da Java 5 in poi, è possibile scrivere:
<ttcode>Integer k = 200;</ttcode>
<ttcode>int j = k;</ttcode>
invece di:
<ttcode>Integer k = new Integer(200);</ttcode> // oppure Integer k = Integer.valueOf(200);</ttcode><ref>Il metodo [http://download.oracle.com/javase/6/docs/api/java/lang/Integer.html#valueOf(int) valueOf(int)] è stato introdotto in Java 5.</ref>
<ttcode>int j = k.intValue();</ttcode>
in quanto la prima forma viene tradotta automaticamente dal compilatore.
 
Riga 116:
 
== Le stringhe ==
Una stringa è un'istanza della classe <ttcode>String</ttcode>: un oggetto che incapsula una sequenza di caratteri.<br/>
Esistono molte classi per la manipolazione delle stringhe. Quelle più comunemente utilizzate sono definite nel package <ttcode>java.lang</ttcode> e sono:
*String (stringhe: oggetti immutabili, quindi [[Java/Multithreading|thread-safe]]);
*StringBuffer (oggetti modificabili e [[Java/Multithreading|thread-safe]]);
Riga 125:
 
*La creazione di una stringa avviene tramite l'invocazione dei costruttori (operazione sconsigliata) o tramite uno ''[[Java/Variabili_locali#Valori letterali|string literal]]''.
*La concatenazione di due stringhe si ottiene interponendo tra le due stringhe l'operatore di concatenazione <ttcode>+</ttcode>:
<source lang="Java">
String s1 = "Ciao";
Riga 133:
System.out.println(s1+", amico, "+s2);
</source>
*Si possono confrontare le stringhe attraverso il metodo <ttcode>equals</ttcode> (confronto ''case-sensitive'' con un altro oggetto String) o uno dei metodi <ttcode>equalsIgnoreCase</ttcode> (confronto ''case-insensitive'' con altro oggetto String). Esistono anche altri metodi, riportati nella documentazione della classe.
:'''Nota''': le stringhe si confrontano con il metodo ''equals'', ''non'' con l'operatore <code><nowiki>==</nowiki></code>. Infatti, due stringhe possono essere uguali pur essendo contenute in due oggetti diversi:
<ttcode>String s = new String("Ciao");</ttcode>
<ttcode>String t = new String("Ciao");</ttcode>
<ttcode>assert s.equals(t); // true</ttcode>
<ttcode>assert s == t; // false</ttcode>
*Il numero di caratteri di una stringa si ottiene invocando il metodo <ttcode>length()</ttcode>.
 
== Bibliografia ==
Estratto da "https://it.wikibooks.org/wiki/Java/Tipi_di_dato"