Java/Operatori: differenze tra le versioni
Riscrittura (quasi ultimata) |
Nessun oggetto della modifica |
||
Riga 39: | Riga 39: | ||
si usano per eseguire operazioni di somma, sottrazione, divisione e moltiplicazione: |
si usano per eseguire operazioni di somma, sottrazione, divisione e moltiplicazione: |
||
lunghezzaDellaCirconferenza = 2 * PI_GRECO * raggioDellaCirconferenza; |
'''lunghezzaDellaCirconferenza''' = 2 * PI_GRECO * '''raggioDellaCirconferenza; |
||
''' |
|||
===Relazionali=== |
===Relazionali=== |
||
Sono detti 'relazionali' perché non hanno per risultato un numero, ma confrontano i due [[w:operandi|operandi]] e restituiscono un [[w:valore di verità|valore di verità]]: |
|||
{| {{prettytable}} |
{| {{prettytable}} |
||
|- bgcolor="#efefef" |
|- bgcolor="#efefef" |
||
Riga 75: | Riga 76: | ||
'''if'''( a >= b ) '''faiQualcosa()'''; |
'''if'''( a >= b ) '''faiQualcosa()'''; |
||
Fai attenzione alla differenza tra == e .equals(), che verrà affrontata quando parlemo di oggetti (nel caso di tipi semplici '''non''' si puó utilizzare la seconda forma). |
|||
===Booleani=== |
|||
Sono detti cosí in onore di chi li ha impiegati per primo: G. Boole. |
|||
Per chiarezza sono suddivisi in [[w:bitwise|''bitwise'']] (scusate l'[[wt:anglicismo|anglicismo]]) e logici. |
|||
====Bitwise==== |
|||
Agiscono su i singoli [[w:bit|bit]] di cui sono composti gli operandi. |
|||
====Logici==== |
|||
Agiscono su intere proposizioni e possono essere usati solo nei test condizionali ('''if, for, do, while''') |
|||
===Operatori <nowiki>#=</nowiki>=== |
===Operatori <nowiki>#=</nowiki>=== |
||
Riga 83: | Riga 95: | ||
c = c % d; |
c = c % d; |
||
e = e + f; |
e = e + f; |
||
sono molto frequenti nella scrittura di programmi, è stata |
sono molto frequenti nella scrittura di programmi, cosí è stata inventata una forma abbreviata, il cui significato è identico a quelle precedenti, |
||
a+=1; |
a+=1; |
||
Riga 91: | Riga 103: | ||
il loro uso rende il codice piú intuitivo (io penso "Aggiungi a a b", non "Aggiungi a a b e metti il risultato in a") ma è un fatto personale, per il compilatore |
il loro uso rende il codice piú intuitivo (io penso "Aggiungi a a b", non "Aggiungi a a b e metti il risultato in a") ma è un fatto personale, per il compilatore |
||
a = a + d; e a+=d; |
a = a + d; e a+=d; |
||
sono |
sono equivalenti. |
||
È sconsigliato -ma legittimo- l'uso di: |
|||
&= |= |
|||
È invece un errore scrivere: |
|||
'''controllaQuesto() &&= controllaQuello();''' |
|||
La facilità con cui si incontra l'operazione |
La facilità con cui si incontra l'operazione |
||
a+=1; |
a+=1; |
||
è |
è tanto elevata che ne è stata concepita una forma ancora più breve: |
||
a++ o ++a |
a++ o ++a |
||
Sono equivalenti in genere, ma la prima [[w:incrementa|incrementa]] la variabile prima di utilizzarla, la seconda dopo. Ció è di vitale importanza in istruzioni (a cui i programmatori C sono abituati, ma che è buona norma non usare in Java) come: |
Sono equivalenti in genere, ma la prima [[w:incrementa|incrementa]] la variabile prima di utilizzarla, la seconda dopo. |
||
Ció è di vitale importanza in istruzioni (a cui i programmatori C sono abituati, ma che è buona norma non usare in Java) come: |
|||
elementoNumeroA = elementi[a++]; |
elementoNumeroA = elementi[a++]; |
||
''(l'elemento preso sarà il numero a o a+1 ?)'' |
''(l'elemento preso sarà il numero a o a+1 ?)'' |
||
ma indifferente in: |
|||
for(int i = 0; i=100; i++); for(int i = 0; i=100; ++i); |
|||
Le stesse considerazioni valgono per a-- e --a. |
Le stesse considerazioni valgono per a-- e --a. |
||
==Operatori unari== |
==Operatori unari== |
||
Agiscono su '''una sola variabile''' |
Agiscono su '''una sola variabile''' e il loro significato è spesso oscuro, perché non hanno corrispondenti in aritmetica. |
||
{| {{prettytable}} |
{| {{prettytable}} |
||
Riga 126: | Riga 146: | ||
|align="center"|'''--''' |
|align="center"|'''--''' |
||
|align="center"|a-- ''oppure'' --a |
|align="center"|a-- ''oppure'' --a |
||
|- |
|- |
||
|align="center"|'''(nome_di_tipo)''' |
|align="center"|'''(nome_di_tipo)''' |
Versione delle 20:49, 24 dic 2007
MODIFICA QUESTA PAGINA!
Benvenuti nella sandbox.
Nei parchi giochi, la sandbox è un'area delimitata, dove i bimbi giocano con paletta e secchiello. Analogamente, su Wikibooks la sandbox è una pagina dove si può scrivere liberamente, senza timore di fare danni in questo progetto che stiamo costruendo anche con il tuo contributo. Qui, se vuoi, puoi anche depositare bozze dei tuoi articoli in attesa di salvarli, anche se è più comodo usare per questo scopo le sottopagine della tua pagina utente (in questo modo: Utente:Nomeutente/Sandbox).
Fate qui le vostre prove!
Clicca qui per modificare il contenuto attuale.
Clicca qui per avere spazio bianco dove scrivere (sarà aggiunto in fondo alla pagina).
La sintassi wiki è spiegata alla pagina Aiuto:Markup. Dopo averla letta, se hai ancora un dubbio su come si fa, clicca qui e lascia un messaggio.
Considera che il tuo testo potrebbe non rimanere a lungo in questa pagina, che viene spesso sovrascritta da altri utenti e "ripulita" con una certa regolarità.
Introduzione
Gli operatori servono a manipolare le variabili e sono dunque alla base di ogni programma: Java ne mette a disposizione molti, con una sintassi simile a quella del C.
Definizione
Classifichiamo gli operatori in tre categorie a seconda dello loro significato.
Operatori binari
Gli operatori binari agiscono su due variabili semplici (non su oggetti) di tipo compatibile (due double, un double e un int, ma MAI un boolean e un integero un byte e un oggetto), per produrre un risultato. Sono a loro volta divisi in:
Algebrici
Sono i quattro operatori algebrici fondamentali, a cui si aggiunge quello di resto della divisione e hanno lo stesso significato che assumono in aritmetica.
Operatore | Uso | Significato |
---|---|---|
+ | a + b | somma a e b |
- | a - b | sottrae b da a |
* | a * b | moltiplica a per b |
/ | a / b | divide a per b |
% | a % b | calcola il resto della divisione intera di a per b (solo con int, longint e byte) |
si usano per eseguire operazioni di somma, sottrazione, divisione e moltiplicazione:
lunghezzaDellaCirconferenza = 2 * PI_GRECO * raggioDellaCirconferenza;
Relazionali
Sono detti 'relazionali' perché non hanno per risultato un numero, ma confrontano i due operandi e restituiscono un valore di verità:
Operatore | Uso | Significato |
---|---|---|
== | a == b | vero se a è uguale a b |
!= | a != b | vero se a è diverso da b |
> | a > b | vero se a è maggiore di b |
< | a < b | vero se a è minore di b |
>= | a > b | vero se a è maggiore o uguale a b |
<= | a <= b | vero se a è minore o uguale a b |
vengono uati ovunque sia richiesto un test di verità:
if( a >= b ) faiQualcosa();
Fai attenzione alla differenza tra == e .equals(), che verrà affrontata quando parlemo di oggetti (nel caso di tipi semplici non si puó utilizzare la seconda forma).
Booleani
Sono detti cosí in onore di chi li ha impiegati per primo: G. Boole. Per chiarezza sono suddivisi in bitwise (scusate l'anglicismo) e logici.
Bitwise
Agiscono su i singoli bit di cui sono composti gli operandi.
Logici
Agiscono su intere proposizioni e possono essere usati solo nei test condizionali (if, for, do, while)
Operatori #=
Istruzioni come:
a = a + 1; b = 3 * b; c = c % d; e = e + f;
sono molto frequenti nella scrittura di programmi, cosí è stata inventata una forma abbreviata, il cui significato è identico a quelle precedenti,
a+=1; b*=3; c%=d;
il loro uso rende il codice piú intuitivo (io penso "Aggiungi a a b", non "Aggiungi a a b e metti il risultato in a") ma è un fatto personale, per il compilatore
a = a + d; e a+=d;
sono equivalenti.
È sconsigliato -ma legittimo- l'uso di:
&= |=
È invece un errore scrivere:
controllaQuesto() &&= controllaQuello();
La facilità con cui si incontra l'operazione
a+=1;
è tanto elevata che ne è stata concepita una forma ancora più breve:
a++ o ++a
Sono equivalenti in genere, ma la prima incrementa la variabile prima di utilizzarla, la seconda dopo. Ció è di vitale importanza in istruzioni (a cui i programmatori C sono abituati, ma che è buona norma non usare in Java) come:
elementoNumeroA = elementi[a++]; (l'elemento preso sarà il numero a o a+1 ?)
ma indifferente in:
for(int i = 0; i=100; i++); for(int i = 0; i=100; ++i);
Le stesse considerazioni valgono per a-- e --a.
Operatori unari
Agiscono su una sola variabile e il loro significato è spesso oscuro, perché non hanno corrispondenti in aritmetica.
Operatore | Uso | Significato |
---|---|---|
- | -a | inverte il segno di a |
! | !a | inverte il valore di verità di a |
~ | ~a | complemento a uno di a |
++ | a++ oppure ++a | |
-- | a-- oppure --a
| |
(nome_di_tipo) | (double)a | |
sizeof | sizeof a oppure |
|!
|~
|?
|:
|-
|&& |||
|&
||
|^
|<<
|>>
|>>>
|-
|+= |-= |*= |/= |&= ||= |^= |%= |<<= |>>= |>>>=
|}