Differenze tra le versioni di "Java/Operatori"

2 735 byte aggiunti ,  13 anni fa
nessun oggetto della modifica
 
=Definizione=
Classifichiamo gli operatori in tre categorie a seconda dellodel loronumero significatodi [[w:operandi|operandi]]: unari (uno), binari (due) e ternari (tre). Cominciamo da quelli binari, i più comuni.
 
==Operatori binari==
'''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 impiegatiintrodotti: per primo[[w:George Boole|G. Boole]].
Per chiarezza -gli errori di programmazione sono sempre in agguato- 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, eseguono cioé l'operazione su ogni coppia di bit (i primi, i secondi...) separatamente. Vanno applicati '''solo alle variabili numeriche'''.
 
====Logici====
Agiscono su intere proposizioni e possono essere usati solo nei test condizionali ('''if, for, do, while'''), per congiungere più condizioni:
'''if( seiUscito(tu) || staiDormendo(tu) ) nonRispondiAlTelefono();'''
'''while( mangi() && dormi() ) staiLavorando = False;'''
 
{| {{prettytable}}
|- bgcolor="#efefef"
! Operatore !! Uso !! Significato
|-
|align="center"|'''&&'''
|align="center"| a() && b()
|align="left"| vero se '''a()''' vero e '''b()''' vero
|-
|align="center"|'''||'''
|align="center"| a() || b()
|align="left"| True se '''a()''' vero o '''b()''' vero o entrambi veri
|}
 
È garantito che vengono esaminate solo le proposizioni necessarie a stabilire il valore di veritá:
se in
if( controllaQuesto() && controllaQuello() )
 
===Operatori <nowiki>#=</nowiki>===
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 [[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++];'''
''(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''', ealcuni ilrichiedono loroche significatoil èrisultato spessosia oscuro,assegnato perchéa nonuna hanno corrispondentiseconda, inaltri aritmeticano.
 
===Algebrici===
Ha significato uguale al corrispettivo algebrico:
{| {{prettytable}}
|- bgcolor="#efefef"
|align="center"|-a
|align="left"|inverte il segno di a
|!-
|~}
il risultato deve essere assegnato a una variabile;
'''b = -a;'''
 
===Booleani===
Il significato è lo stesso che hanno in [[w:algebra booleana|algebra booleana]].
{| {{prettytable}}
|- bgcolor="#efefef"
! Operatore !! Uso !! Significato
|-
|align="center"|'''!'''
|align="center"|'''~'''
|align="center"|~a
|align="left"|[[w:complemento a uno|complemento a uno]] di a
|?}
non è obbligatorio assegnarne il valore a un'altra variabile, ma potrebbe rendere incomprensibile il tuo programma.
 
Alcuni sono unari, malgrado abbiano due operandi:
{| {{prettytable}}
|- bgcolor="#efefef"
! Operatore !! Uso !! Significato
|-
|align="center"|'''++>>'''
|align="center"|a++ ''oppure'' ++a>>b
|align="left"| sposta bit a bit '''a''' verso destra
|-
|align="center"|'''--<<'''
|align="center"|a-- ''oppure'' --a<<b
|align="left"| sposta bit a bit '''a''' verso sinistra di b bit
|:}
 
Il significato di "spostare bit a bit" è molto più semplice di quanto tu pensi:
se '''a''' era
10000000
allora a>>5 è
00000100
 
 
===Funzionali===
Il loro significato è spesso oscuro, perché non hanno corrispondenti in aritmetica.
 
{| {{prettytable}}
|- bgcolor="#efefef"
! Operatore !! Uso !! Significato
|-
|align="center"|'''(nome_di_tipo)'''
|align="center"|(double)a
|align="left"|effettua una conversione di tipo
|-
|align="center"|'''sizeof'''
|align="center"|'''sizeof a''' ''oppure'' '''sizeof(int)'''
|align="left"|restituisce la dimensione in byte del dato (o del tipo)
|}
 
'''sizeof''' ha due forme possibili:
dimensioneDellaMiaVariabile = sizeof laMiaVariabile;
dimensioneDelTipoInteger = sizeof(int);
la seconda è un' eredità del C: in Java è inutile, perché le dimensioni dei tipi sono fisse, a meno che vi interessi veramente sapere quanta memoria occupa un '''int''' o un '''float'''.
 
==Operatori Ternari==
|!
È facile avere a che fare con variabili che devono assumere due valori differenti data una condizione.
|~
Per esempio:
|?
//calcoliamo <nowiki>|a|</nowiki> (il [[w:valore assoluto(matematica)|modulo]] di a)
|:
if(a >= 0)
{ modulo = a;
}
else
{ modulo = -a;
}
 
L'opeartore ?: sostituisce questa scrittura, pesante e pe''d''ante:
|-
modulo = a>0? a: -a;
 
che equivale alla precedente (e è mooolto più comoda).
|&&
<!--
|<nowiki>||</nowiki>
 
 
|&
|<nowiki>|</nowiki>
|^
|<<
|>>>
 
|-
 
|<nowiki>+=</nowiki>
|<nowiki>-=</nowiki>
|*=
|/=
|&=
|<nowiki>|=</nowiki>
|^=
|%=
|<<=
|>>=
|>>>=
-->
|}
 
[[Categoria:Linguaggio Java|Operatori]]
7

contributi