Poiché probabilmente ho corso troppo ho deciso di fare un passo in dietro e spiegare le variabili in java.
Generalmente i programmi, durante la loro esecuzione, gestiscono diversi valori, i quali possono variare durante l’esecuzione del programma stesso; i quali possono variare durante l’esecuzione del programma stesso; è necessario quindi riuscire a gestire tutti i valori utilizzati.
Una variabile può essere vista come una sorta di scatola che immagazzina un determinato valore.
Quando si dichiara una variabile, quindi, per prima cosa viene riservata ad essa un’area di memoria. Affinché questa operazione avvenga con successo il compilatore ha bisogno di due informazioni: il nome ed il tipo di valore.
Il linguaggio Java definisce i seguenti tipi di variabili:
Variabili di istanza: sono dichiarate all’interno di una definizione di classe esternamente alle dichiarazioni dei metodi.
Variabili di classe: sono variabili dichiarate con il modificatore static, questo dice al compilatre che non c’è esattamente c’è esattamente una copia du questa variabile, indipendentemente da quante volte la classe è stata istanziata.
Variabili locali: sono quelle variabili che vengono dichiarate ed utilizzate all’interno dei metodi di una classe, per questo motivo la loro visibilità è limitata al metodo nel quale vengono dichiarate.
I nomi delle variabili sono case-sensitive, ovvero distinguono le lettere maiuscole dalle minuscole.
Tipi primitivi
Il linguaggio java è fortemente tipizzato, il che significa che tutte le variabili devono essere dichiarate prima di poter essere utilizzate.
Come già detto la dichiarazione di una variabile consiste nello specificare il tipo di variabile ed il nome, ad esempio:
int numero=1;
In questo caso è dichiarata una variabile di tipo intero.
Gli otto tipi primitivi di dati supportati dal linguaggio java sono:
byte: esso è formato da 8 bit. Esso può assumere un valore compreso tra -128 e 127
short: Esso è formato da 16 bit. Questo tipo può assumere un valore compre tra -32.768 e 32.768
int: esso è a 32 bit Questo tipo può assumere un valore compre tra -2.147.483.648 e 2.147.483.647
long:Il tipo di dati long è a 64-bit e può assumere un valore tra -9.223.372.036.854.775.808 e 9.223.372.036.854.775.807
float: Il tipo di dati float è a 32 bit è può lavorare su numeri a virgola mobil3e.
double: Il tipo di dati double è a 64 bit e può lavorare su numeri positivi e negativi in virgola mobile, compresi tra 4.94065645841246544*10-324 e 1.79769313486231570*10308.
boolean: ha solo due possibili valori: true e false, questo tipo di dato si utilizza per determinare lo stato di una determinata condizione (che può essere appunto vera o falsa).
char: In Java, il tipo di dati char usa 16 bit per ogni carattere, e usa il codice UNICODE, che permette di rappresentare 216 = 65536 caratteri.
Oltre agli otto tipi primitivi di dati appena visti, il linguaggio di programmazione Java fornisce anche il supporto speciale per le stringhe di caratteri tramite la classe java.lang.String. Racchiudendo la stringa di caratteri tra virgolette si crea automaticamente un nuovo oggetto String, ad esempio:
String s = “questa è una stringa”;
La classe String non è tecnicamente un tipo primitivo di dati, ma considerando il particolare sostegno dato ad essa dal linguaggio, è possibile pensarla come tale.
Array
Un array è un oggetto contenitore che contiene, al suo interno, un numero fisso di valori di un singolo tipo. La lunghezza di un array è stabilita quando l’array viene dichiarato. Dopo la creazione, la sua lunghezza rimane fissa.
Come mostrato nella figura, la numerazione inizia con 0. L’elemento 9, per esempio, è accessibile utilizzando l’indice 8.
Il seguente programma, ArrayDemo, crea un array di tipi interi (int), mette alcuni valori in esso, e ogni valore viene stampato sullo standard output.
class ArrayDemo {
public static void main(String[] args) {
int anArray = new int[10];
anArray[0] = 100;
anArray[1] = 200; anArray[2] = 300;
anArray[3] = 400; anArray[4] = 500; anArray[5] = 600; anArray[6] = 700; anArray[7] = 800; anArray[8] = 900; anArray[9] = 1000;
//Stampa a video I singoli elementi dell’array System.out.println(“Elemento con indice 0: ” + anArray[0]); System.out.println(“Elemento con indice 1: ” + anArray[1]); System.out.println(“Elemento con indice 2: ” + anArray[2]);
System.out.println(“Elemento con indice 3: ” + anArray[3]); System.out.println(“Elemento con indice 4: ” + anArray[4]); System.out.println(“Elemento con indice 5: ” + anArray[5]); System.out.println(“Elemento con indice 6: ” + anArray[6]); System.out.println(“Elemento con indice 7: ” + anArray[7]); System.out.println(“Elemento con indice 8: ” + anArray[8]); System.out.println(“Elemento con indice 9: ” + anArray[9]); }
}
le parentesi quadre rappresentano dei caratteri speciali che in questo caso specificano che la variabile che si sta dichiarando rappresenta un array.
Un modo per creare un array è utilizzando l’operatore new.
Inoltre è possibile utilizzare la sintassi di scelta rapida per creare e inizializzare un array:
int[] anArray = {100, 200, 300,400, 500, 600, 700, 800, 900, 1000};
È inoltre possibile dichiarare un array di array (noto anche come array multidimensionale) utilizzando due o più insiemi di parentesi quadre, come:
String [][] nomi;
Nel linguaggio di programmazione Java, un array multidimensionale è semplicemente un array i cui componenti sono a loro volta array.
class MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {{“Mr. “,”Mrs. “,”Ms.”},{“Smith”,”Jones”}};
//stampa a video Mr. Smith
System.out.println(names[0][0] + names[1][0]); //stampa a video Ms. Jones System.out.println(names[0][2] + names[1][1]);
} }
E’ possibile utilizzare la proprietà length per determinare le dimensioni di un array.
System.out.println(anArray.length);
Modificatori
Per “modificatori del linguaggio JAVA” si intendono le parole chiave capaci di cambiare il significato di un componente di un’applicazione Java.
Si possono anteporre alla dichiarazione di un componente di un’applicazione Java anche più modificatori alla volta, senza tener conto dell’ordine in cui vengono anteposti. I modificatori di accesso regolano essenzialmente la visibilità e l’accesso ad un componente Java
public
Può essere utilizzato sia relativamente ad un membro (attributo o metodo) che ad una classe stessa.
Un membro dichiarato pubblico sarà accessibile da una qualsiasi classe situata in un qualsiasi package.
• Una classe dichiarata pubblica sarà anch’essa visibile da un qualsiasi package.
protected
Può essere utilizzato relativamente ad un membro (attributo o metodo) di una classe.
• Un membro protetto sarà accessibile all’interno dello stesso package ed in tutte le sottoclassi della classe in cui è definito, anche se non appartenenti allo stesso package.
private
Può essere utilizzato solo con i membri (attributo o metodo) di una classe, ed un membro privato sarà accessibile solo all’interno della classe.
final
Questo modificatore è applicabile alle variabili, ai metodi e alle classi.
• Una variabile dichiarata final diviene una costante
• Un metodo dichiarato final non può essere riscritto in una sottoclasse Una classe dichiarata final non può essere estesa
Il modificatore final si può utilizzare anche per variabili e parametri locali, i valori di tali variabili non sono modificabili localmente.
static
Un membro statico è condiviso da tutte le istanze della classe, quindi un membro statico può essere utilizzato anche senza istanziare la classe. Il suo utilizzo provocherà il caricamento in memoria della classe contenente il membro in questione. Il modificatore static prescinde dal concetto di oggetto e lega strettamente le variabili al concetto di classe, per questo a volte le variabili statiche sono definite come “variabili di classe”.Una variabile dichiarata static e public può considerarsi una sorta di variabile globale, pertanto queste andrebbero evitate. Viceversa è utile a volte utilizzare costanti globali, definite con public, static e final.
abstract
Questo modificatore è applicabile ai metodi e alle classi, una classe astratta non può essere istanziata, nulla vieta però ad una classe astratta di implementare tutti i suoi metodi.