Valuta le espressioni Java con gli operatori

Le applicazioni Java elaborano i dati valutando espressioni , che sono combinazioni di valori letterali, chiamate di metodi, nomi di variabili e operatori. La valutazione di un'espressione produce in genere un nuovo valore, che può essere memorizzato in una variabile, utilizzato per prendere una decisione e così via.

In questo tutorial imparerai come scrivere espressioni per i tuoi programmi Java. In molti casi userete operatori per scrivere le vostre espressioni Java e ci sono molti tipi di operatori da sapere come usare. Introdurrò brevemente i tipi di operatore di Java (inclusi i tipi additivo, bit per bit, logico, condizionale, shift e uguaglianza) ei loro operandi. Imparerai anche concetti importanti come il sovraccarico degli operatori e la precedenza degli operatori e vedrai una dimostrazione della conversione di tipi primitivi. Concluderò con un piccolo programma Java che puoi usare per esercitarti in conversioni di tipo primitivo da solo.

download Ottieni il codice Scarica il codice sorgente per applicazioni di esempio in questo tutorial. Creato da Jeff Friesen per JavaWorld.

Semplici espressioni

Una semplice espressione è un valore letterale, un nome di variabile o una chiamata a un metodo. Nessun operatore è coinvolto. Di seguito sono riportati alcuni esempi di semplici espressioni:

52 // integer literal age // variable name System.out.println("ABC"); // method call "Java" // string literal 98.6D // double precision floating-point literal 89L // long integer literal

Un'espressione semplice ha un tipo , che è un tipo primitivo o un tipo di riferimento. In questi esempi, 52è un numero intero a 32 bit ( int); System.out.println("ABC");è void ( void) perché non restituisce alcun valore; "Java"è una stringa ( String); 98.6Dè un valore a virgola mobile a doppia precisione a 64 bit ( double); ed 89Lè un intero lungo a 64 bit ( long). Non conosciamo ageil tipo.

Sperimentando con jshell

Puoi facilmente provare queste e altre semplici espressioni usando jshell. Ad esempio, inserisci 52al jshell>prompt e riceverai qualcosa di simile al seguente output:

$1 ==> 52

$1è il nome di una variabile zero che jshellcrea per memorizzare 52. (Le variabili scratch vengono create ogni volta che vengono immessi i valori letterali.) Esegui System.out.println($1)e vedrai 52come output.

È possibile eseguire jshellcon l' -vargomento della riga di comando ( jshell -v) per generare un feedback dettagliato. In questo caso, l'immissione 52risulterebbe nel seguente messaggio, rivelando che la variabile scratch $1ha il tipo int(intero a 32 bit):

| created scratch variable $1 : int

Quindi, prova a entrare age. In questo caso, probabilmente riceverai un messaggio di errore indicante che il simbolo non è stato trovato. Java Shell presume che agesia una variabile, ma non ne conosce il tipo. Dovresti includere un tipo; per esempio, guarda cosa succede se entri int age.

Espressioni composte

Un'espressione composto costituito da una o più espressioni semplici integrati in un'espressione complessa tramite un operatore , che è una sequenza di istruzioni simbolicamente rappresentati nel codice sorgente. L'operatore trasforma i suoi operandi di espressione in un altro valore. Ad esempio, in 6 * 5, l'operatore di moltiplicazione ( *) trasforma gli operandi 6e 5in 30.

Le espressioni composte possono essere combinate in espressioni più grandi. Ad esempio, 6 * 5 + 10presenta un'espressione composta 6 * 5e un'espressione composta costituita dal loro prodotto, operatore di addizione +e numero 10. L'ordine di valutazione (prima moltiplicare e poi aggiungere) è dettato dalla regola di precedenza di Java , alla quale arriveremo a breve.

Anche le espressioni composte possono essere semplici

6 * 5è un'espressione composta composta da due espressioni semplici 6e 5. Ma 6 * 5è anche una semplice espressione dal +punto di vista di. L' +operatore vede solo il suo prodotto, 30, che è una semplice espressione.

Operatori e operandi

Gli operatori di Java sono classificati in base al numero di operandi:

  • Un operatore unario ha un operando, ad esempio unario meno (ad esempio, -5).
  • Un operatore binario ha due operandi, gli esempi sono la moltiplicazione e l'addizione.
  • Un operatore ternario ha tre operandi; un esempio è l' operatore condizionale ( ?:).

Gli operatori Java sono anche classificati per posizione:

  • Un operatore prefisso è un operatore unario che precede il suo operando (ad esempio, -5).
  • Un operatore postfisso è un operatore unario che segue il suo operando (ad esempio, age++;- aggiungi 1 al agevalore numerico di).
  • Un operatore infisso è un operatore binario o ternario tra gli operandi dell'operatore (ad esempio, age + 5).

Un altro esempio di jshell

Introdurrò più operatori nelle sezioni seguenti, dove presento esempi sotto forma di applicazioni. Puoi anche provare questi operatori con jshell, in questo modo:

jshell> 6 + 2 $1 ==> 8 jshell> 7 * $1 $2 ==> 56

In questo caso, inseriamo prima l'espressione 6 + 2, che jshellvaluta, assegnando l'8 risultante alla variabile di zero $1. Successivamente, moltiplichiamo $1per 7, che memorizza 56 nella variabile zero $2. Questo esempio dimostra che è possibile utilizzare le variabili scratch nelle espressioni Java.

Operatori sovraccarichi

L'operatore più (+) è un esempio di operatore sovraccarico , ovvero un operatore che esegue una delle numerose operazioni in base ai tipi dei suoi operandi. L'operatore più esegue l'addizione di interi quando entrambi gli operandi sono interi, l'addizione a virgola mobile quando entrambi gli operandi sono valori a virgola mobile e la concatenazione di stringhe quando entrambi gli operandi sono stringhe. Anche l'operatore meno (-) viene sovraccaricato, eseguendo la sottrazione di numeri interi o virgola mobile.

Tipi di operatore in Java

Operatori additivi

Gli operatori additivi aumentano o diminuiscono un valore numerico tramite addizione e sottrazione. Gli operatori additivi includono addizione ( +), sottrazione ( -), postdecremento ( --), postincremento ( ++), predecremento ( --) e preincremento ( ++). Anche la concatenazione di stringhe ( +) è considerata additiva. Ecco una definizione formale per ciascuno di questi operatori:

  • Inoltre : Dato , in cui ogni operando deve essere di carattere o di tipo numerico, aggiungere alla e restituire la somma. Esempio: .operand1 + operand2operand2operand14 + 6
  • Sottrazione : Dato , dove ogni operando deve essere di carattere o tipo numerico, sottrarre da e restituire la differenza. Esempio: .operand1 - operand2operand2operand14 - 6
  • Postdecrement: Given variable--, where variable must be of character or numeric type, subtract 1 from variable's value (storing the result in variable) and return the original value. Example: x--;.
  • Postincrement: Given variable++, where variable must be of character or numeric type, add 1 to variable's value (storing the result in variable) and return the original value. Example: x++;.
  • Predecrement: Given --variable, where variable must be of character or numeric type, subtract 1 from its value, store the result in variable, and return the new decremented value. Example: --x;.
  • Preincrement: Given ++variable, where variable must be of character or numeric type, add 1 to its value, store the result in variable, and return the new incremented value. Example: ++x;.
  • String concatenation: Given operand1 + operand2, where at least one operand is of String type, append operand2's string representation to operand1's string representation and return the result. Example: "A" + "B".

The addition, subtraction, postdecrement, postincrement, predecrement, and preincrement operators can generate values that overflow the limits of the result type. For example, adding two large positive 64-bit integer values can produce a value that cannot be represented in 64 bits. The resulting overflow is not detected or reported by Java's additive operators.

Overflow detection in the Java standard class library

The standard class library's Math class includes methods for detecting overflows. For example, int addExact(int x, int y) adds the values in x and y, returning the sum or throwing an exception on overflow.

Example application: Additive operators

Listing 1 presents a small application for playing with Java's additive operators.

Listing 1. Additive operators in Java (AddOp.java)

class AddOp { public static void main(String[] args) { System.out.println(125 + 463); System.out.println(2.0 - 6.3); int age = 65; System.out.println(age); System.out.println(age--); System.out.println(age++); System.out.println(--age); System.out.println(++age); System.out.println("A" + "B"); } }

You learned in the previous tutorial how to use the JDK's javac tool to compile Java source code and the java tool to run the resulting application. Execute the following command to compile Listing 1:

javac AddOp.java

Assuming successful compilation, you should observe an AddOp.class file in the current directory. Execute the following command to run it:

java AddOp

AddOp responds by producing the following output:

588 -4.3 65 65 64 64 65 AB

Studying this output offers insight into the postincrement, postdecrement, preincrement, and predecrement operators. For postincrement/postdecrement, age's current value is output before the increment/decrement operation. For preincrement/predecrement, the operation is performed and its result is stored in age, and then age's new value is output.

Iterating with Java operators

The additive operators are especially useful in the context of an iteration statement, where they are used to advance to the next iteration. You'll learn about iteration statements in the next Java 101 tutorial.

Array index operator

The array index operator ([]) accesses an array element by providing the element's index (position). This operator is placed after the array variable's name, as in grades[0] (access the first element in the array assigned to grades; the first element is stored at index 0). Here's a formal definition:

Given variable[index], where index must be of integer (int) type, read a value from or store a value into variable's storage element at location index. Example: temperatures[1]

The value passed to index is a 32-bit integer that is either 0 or a positive value ranging to one less than the array's length, which is indicated by appending .length to the name of the array. For example, grades.length returns the number of elements in the array assigned to grades.

Array variables vs arrays

grades is not an array, but is a variable containing a reference to a region of memory that forms the array. This is true for all Java arrays. However, it's conventional to refer to grades or any array variable as an array.

Example application: Array index operator

Listing 2 presents the source code to an example application that lets you play with the array index operator.

Listing 2. Array index operator in Java (ArrayIndexOp.java)

class ArrayIndexOp { public static void main(String[] args) { int[] grades = { 89, 90, 68, 73, 79 }; System.out.println(grades[1]); grades[1] = 91; System.out.println(grades[1]); int index = 4; System.out.println(grades[index]); System.out.println(grades['C' - 'A']); // System.out.println(grades[1D]); } }

Listing 2 is somewhat more interesting than Listing 1. After creating a five-element, one-dimensional array of integers (via an array initializer) and assigning the array's reference to grades, main() proceeds to access various elements. Two items are of special interest:

  • The array index operator's index must ultimately be a 32-bit integer (0 or a positive value). You can specify the name of an integer variable (e.g., index), which contains the index value, as the index.
  • You can specify a calculation involving character literals. (Later in this tutorial I'll introduce type conversions, and you'll discover why 'C' - 'A' produces an integer (2), which serves as a valid index.)

The final example, which passes 1D as an index to the array index operator, is commented out because it will not compile. If you uncomment the line and attempt to compile Listing 2, you will receive an error message about incompatible types: "possible lossy conversion from double to int.."

Compile Listing 2 (javac ArrayIndexOp.java) and run the application (java ArrayIndexOp). You should observe the following output:

90 91 79 68

The array index operator and multidimensional arrays

You can use this operator with multidimensional arrays. For example, assuming a two-dimensional costs array, costs[0][1] accesses the element assigned to the first row (via [0]) and the second column (via [1]).

Assignment operators

The assignment operator (=) assigns an expression's value to a variable (e.g., i = 6;), including an array element (e.g., x[0] = 15;). The expression and variable must be assignment compatible, meaning their types must agree. For example, you cannot assign a string literal to an integer variable. I'll explain more about this when we discuss type conversions.

Gli operatori di assegnamento composto ( +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=) valutano le espressioni e assegnano i risultati a variabili in un solo passaggio. Ogni espressione e variabile deve essere compatibile con l'assegnazione. Ogni operatore funge da utile scorciatoia. Ad esempio, invece di specificare x = x + 3;, puoi specificare il più breve e l'equivalente x += 3;.

Sii breve!

Invece di specificare x = x + 1;o x = x - 1;, puoi specificare il più breve x += 1;o x -= 1;. È possibile salvare ancora più sequenze di tasti specificando il più breve x++;o x--;.

Operatori bit per bit