Java  »  Guide  »  Guida Java 

Gli operatori del linguaggio Java sono gli stessi degli altri linguaggi, in più ogni nuovo tipo avrà i propri metodi che ne implementeranno nuovi operatori, come abbiamo visto nell'esempio della classe Complessi.
Abbiamo già visto gli operatori di accesso alle classi e agli oggetti, ovvero il semplice punto. Volendo accedere al campo X dell'oggetto x scriveremo semplicemente x.X, anche se x ha un metodo Y(int valore), noi vi accediamo, o meglio in questo caso lo invochiamo scrivendo x.Y(39); Ci sono i soliti operatori aritmetici: +,-,*,/ e %.

Da notare che le operazioni sono anch'esse tipate, ovvero se sommo due interi ho un valore intero, così per tutte le operazioni, in modo che data una espressione è sempre possibile definirne il tipo del risultato.

Java fa un forte controllo sui tipi, infatti non è possibile assegnare un carattere ad un intero, cosa possibile nel linguaggio C, ma è anche impossibile assegnare un double ad un float, senza un esplicito casting. Il casting consiste nel forzare un valore di un tipo ad assumere un tipo diverso. Se scrivo 5 io intendo un intero, mentre se ne faccio un cast a float intenderò la versione di 5 reale, per farlo scriverò (float) 5.

facendo così posso fare i famosi assegnamenti di interi a reali e di reali double a reali float, si pensi ad esempio a :

double v1=10.0;
float v2;
int v3=5;

e si pensi agli assegnamenti errati seguenti:

v2=v1;
v1=v3;

Se effettuiamo dei cast, diventano leciti anche per Java:

v2=(float) v1;
v1=(double) v3;

Da notare che la divisione tra interi, a differenzache in altri linguaggi da un intero, quindi se si vuole il numero reale derivato dalla divisione dei due numeri interi x e y, bisogna prima trasformarli in reali:

float risultato= (float ) x / (float) y;

Per le stringhe esiste un operatore di concatenamento:

String a="Pietro " ;
String b= a + "Castellu";
String b+="cci"

Il risultato sarà Pietro Castellucci. L'operatore è il +. Abbiamo ad un certo punto usato un assegnamento particolare, ovvero +=, questa è una abbreviazione, se devo scrivere a=a+1; posso abbreviare e scrivere a+=1, che è lo stesso. Vale lo stesso per ogni operatore binario.
L'operatore + appende ad una stringa anche caratteri e numeri, si pensi agli output degli esempi precedenti, dove scrivevamo ad esempio:

System.out.println("Numero complesso:"+Re+"+i"+Im+" ha modulo "+mod);

Sembra strano questo, anche in considerazione del fatto che abbiamo detto che le espressioni Java sono ben tipate a differenza del C, questo avviene però perché il sistema effettua delle conversioni implicite di tipi primitivi e oggetti in stringhe. Ad esempio definendo un qualsiasi oggetto, se ne definisco un metodo toString(), il sistema che si troverà a lavorare con stringhe e con quest'oggetto ne invocherà automaticamente il metodo toString().

Java inoltre offre altri quattro operatori che sono delle abbreviazioni, due di incremento di variabili e due di decremento, sia X una variabile, io posso scrivere:

X++
++X
X--
--X

che stanno rispettivamente ad indicare valuta prima e poi incrementa X, incrementa prima e poi valuta X, valuta e decrementa X ed infine decrementa e valuta X, questo vuol dire che l'espressione X++ è un comando di assegnamento, ma anche una espressione che restituisce un risultato, risultato che in questo caso è X prima di essere incrementata.

Ad esempio:

X=10;
Y=X++;

mi darà come risultato X=11 e Y=10. Provate ad editare ed eseguire il seguente class incdec

{ public static void main(String [] a)
{
int X,Y,Z,W,V;
X=10;
System.out.println("X="+X);
Y=X++;
System.out.println("Y=X++: ho X="+X+",Y="+Y);
Z=++Y;
System.out.println("Z=++Y: ho Z="+Z+",Y="+Y);
W=Z--;
System.out.println("W=Z--: ho W="+W+",Z="+Z);
V=--W;
System.out.println("V=--W: ho V="+V+",W="+W);
}
}

Altri operatori sono quelli di confronto, ovvero:

> maggiore di, x>y restituisce true se x è maggiore stretto di y, false altrimenti

>= maggiore o uguale di, x>=y restituisce true se x è maggiore o uguale di y, false altrimenti

< minore di, x<y restituisce true se x è minore stretto di y, false altrimenti

<= minore o uguale di, x<=y restituisce true se x è minore o uguale di y, false altrimenti

== uguale, x==y restituisce true se x uguale a y, false altrimenti

!= diverso, x!=y restituisce true se x diverso da y, false altrimenti

Vi sono gli operatori logici &&, || e !, che rappresentano l'and, l'or e il not:
Date x e y valori booleani, x && y sarà vera se x e y sono entrambe vere, sarà falsa altrimenti (se tutte e due false o se una vera e l'altra falsa).
x || y sarà vera se x oppure y o entrambe sono vere (sarà falsa solo se sono ambedue false).
!x sarà vera se x è falsa, mentre sarà falsa se x è vera.

Vi sono gli ovvi operatori binari orientati ai bit:

&, AND bit a bit
| , OR bit a bit
^, OR ESCLUSIVO, bit a bit
e gli shift, >>, <<, >>>.

Queste operazioni binarie sono molto utili nella costruzione di maschere.

L' ultimo operatore da vedere è l'operatore condizionale, che permette di definire espressioni con due differenti risultati a seconda di un valore booleano.
Si consideri ad esempio l'espressione seguente:

int ValoreAssoluto = ( a<0 ? -a : a );

ValoreAssoluto assumerà il valore -a se a è negativo oppure a se è positivo o nullo.
A questo punto siamo in grado di scrivere tutte le espressioni che vogliamo nel linguaggio Java.

Altri articoli

Altre guide

Altre newsletter