Quando si parla di precedenza in Java il primo pensiero viene all'operatore. Esistono alcune regole definite in Java per specificare l'ordine in cui vengono valutati gli operatori in un'espressione. Precedenza degli operatori è un concetto per determinare il gruppo di termini in un'espressione. La precedenza degli operatori è responsabile della valutazione delle espressioni. In Giava , parentesi() E Indice dell'array[] hanno la massima precedenza in Java. Ad esempio, addizione e sottrazione hanno una precedenza maggiore rispetto agli operatori spostamento a sinistra e spostamento a destra.
Di seguito è riportata una tabella definita in cui l'operatore con la precedenza più bassa viene visualizzato nella parte superiore.
| Precedenza | Operatore | Tipo | Associatività |
|---|---|---|---|
| 1) | = += -= *= /= %= | Incarico Compito aggiuntivo Assegnazione della sottrazione Compito di moltiplicazione Assegnazione della divisione Assegnazione del modulo | Da destra a sinistra |
| 2) | ? : | Condizionale ternario | Da destra a sinistra |
| 3) | || | OR logico | Da sinistra a destra |
| 4) | && | AND logico | Da sinistra a destra |
| 5) | | | OR inclusivo bit per bit | Da sinistra a destra |
| 6) | ^ | OR esclusivo bit per bit | Da sinistra a destra |
| 7) | & | AND bit per bit | Da sinistra a destra |
| 8) | != == | Relazionale non è uguale a Relazionale è uguale a | Da sinistra a destra |
| 9) | < <= > >= istanza di | Relazionale meno di Relazionale minore o uguale Relazionale maggiore di Relazionale maggiore o uguale Confronto di tipi (solo oggetti) | Da sinistra a destra |
| 10) | >> << >>> | Spostamento a destra bit per bit con estensione del segno Spostamento a sinistra bit per bit Shift a destra bit per bit con estensione zero | Da sinistra a destra |
| undici) | - + | Sottrazione Aggiunta | Da sinistra a destra |
| 12) | * / % | Moltiplicazione Divisione Modulo | Da sinistra a destra |
| 13) | - + ~ ! ( tipo) | Meno unario Più unario Complemento bit a bit unario Negazione logica unaria Typecast unario | Da destra a sinistra |
| 14) | ++ -- | Post-incremento unario Post-decremento unario | Da destra a sinistra |
| quindici) | · () [] | Operatore punto Parentesi Pedice dell'array | Da sinistra a destra |
Ordine di precedenza
Quando due operatori condividono un unico operando, l'operatore con la massima precedenza inizia per primo. Ad esempio, x + y * z viene trattato come x + (y * z), mentre x * y + z viene trattato come (x * y) + z perché l'operatore * ha la massima precedenza rispetto all'operatore +.
java mescolando a int
Associatività
L'associativo è un concetto relativo agli operatori applicati quando in un'espressione compaiono due operatori con la stessa precedenza. Il concetto di associatività è molto utile per partire da quella situazione. Supponiamo di avere un'espressione a + b - c Gli operatori (+ e - hanno la stessa priorità) , e questa espressione verrà trattata come (a + (b - c)) perché questi operatori sono associativi da destra a sinistra. D'altra parte, a+++--b+c++ verrà trattato come ((a++)+((--b)+(c++))) perché gli operatori unari di post-incremento e decremento sono associativi da destra a sinistra.
Di seguito viene definito un esempio per comprendere come viene valutata un'espressione utilizzando l'ordine di precedenza e l'associatività.
Espressione: x = 4 / 2 + 8 * 4 - ( 5+ 2 ) % 3
Soluzione:
1) Nell'espressione precedente, l'operatore con la precedenza più alta è () . Quindi, la parentesi va per prima e calcola per prima.
x = 4/2 + 8 * 4 - 7% 3
2) Ora, /, * E % gli operatori hanno la stessa precedenza e il massimo rispetto a + E - Qui usiamo il concetto di associatività per risolverli. Gli associativi di questi operatori vanno da sinistra a destra. COSÌ, / l'operatore va prima e poi * E % contemporaneamente.
elenco doppiamente concatenato
x = 2 + 8 * 4 - 7 % 3
x = 2 + 32 - 7% 3
x = 2 + 32 - 1
3) Ora, + E - anche gli operatori hanno entrambi la stessa precedenza e l'associatività di questi operatori è più a destra. COSÌ, + l'operatore andrà per primo e poi - andrò.
x = 34 - 1
x = 33
codice fibonacci java
Precedenza più alta.java
//import classes import java.util.*; //creating HighestPrecedence class to evaluate the expression public class HighestPrecedence { //main() method starts public static void main(String[] args) { //initialize variables with default values int x = 2; int y = 5; int z = 12; //calculating exp1, exp2, and exp3 int exp1 = x +(z/x+(z%y)*(z-x)^2); int exp2 = z/x+y*x-(y+x)%z; int exp3 = 4/2+8*4-(5+2)%3; //printing the result System.out.println(exp1); System.out.println(exp2); System.out.println(exp3); } } Produzione
