Évaluer les expressions Java avec des opérateurs

Les applications Java traitent les données en évaluant des expressions , qui sont des combinaisons de littéraux, d'appels de méthode, de noms de variables et d'opérateurs. L'évaluation d'une expression produit généralement une nouvelle valeur, qui peut être stockée dans une variable, utilisée pour prendre une décision, etc.

Dans ce didacticiel, vous apprendrez à écrire des expressions pour vos programmes Java. Dans de nombreux cas, vous utiliserez des opérateurs pour écrire vos expressions Java, et il existe de nombreux types d'opérateurs à savoir comment les utiliser. Je vais brièvement présenter les types d'opérateurs Java (y compris les types additif, bit à bit, logique, conditionnel, décalage et égalité) et leurs opérandes. Vous découvrirez également des concepts importants tels que la surcharge des opérateurs et la priorité des opérateurs, et vous verrez une démonstration de conversion de type primitif. Je conclurai avec un petit programme Java que vous pouvez utiliser pour pratiquer vous-même les conversions de type primitif.

télécharger Obtenir le code Téléchargez le code source des exemples d'applications dans ce didacticiel. Créé par Jeff Friesen pour JavaWorld.

Expressions simples

Une expression simple est un littéral, un nom de variable ou un appel de méthode. Aucun opérateur n'est impliqué. Voici quelques exemples d'expressions simples:

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

Une expression simple a un type , qui est soit un type primitif, soit un type référence. Dans ces exemples, 52est un entier 32 bits ( int); System.out.println("ABC");est void ( void) car il ne renvoie aucune valeur; "Java"est une chaîne ( String); 98.6Dest une valeur à virgule flottante double précision 64 bits ( double); et 89Lest un entier de 64 bits ( long). Nous ne connaissons pas agele type.

Expérimenter avec jshell

Vous pouvez facilement essayer ces expressions et d'autres expressions simples en utilisant jshell. Par exemple, entrez 52à l' jshell>invite et vous recevrez quelque chose comme la sortie suivante:

$1 ==> 52

$1est le nom d'une variable scratch qui jshellcrée pour stocker 52. (Les variables Scratch sont créées chaque fois que des littéraux sont entrés.) Exécutez System.out.println($1)et vous verrez 52comme sortie.

Vous pouvez exécuter jshellavec l' -vargument de ligne de commande ( jshell -v) pour générer des commentaires détaillés. Dans ce cas, la saisie 52entraînerait le message suivant, révélant que la variable scratch $1est de type int(entier 32 bits):

| created scratch variable $1 : int

Ensuite, essayez d'entrer age. Dans ce cas, vous recevrez probablement un message d'erreur indiquant que le symbole n'a pas été trouvé. Java Shell suppose qu'il ages'agit d'une variable, mais il ne connaît pas son type. Vous devrez inclure un type; par exemple, voyez ce qui se passe si vous entrez int age.

Expressions composées

Une expression composée consiste en une ou plusieurs expressions simples intégrées dans une expression plus grande via un opérateur , qui est une séquence d'instructions symboliquement représentée dans le code source. L'opérateur transforme son (ses) opérande (s) d' expression en une autre valeur. Par exemple, dans 6 * 5, l'opérateur de multiplication ( *) transforme les opérandes 6et 5en 30.

Les expressions composées peuvent être combinées dans des expressions plus grandes. Par exemple, 6 * 5 + 10présente une expression de composé 6 * 5et une expression de composé constituée de leur produit, de l'opérateur d'addition +et du nombre 10. L'ordre d'évaluation (multiplier d'abord puis ajouter) est dicté par la règle de préséance de Java , à laquelle nous reviendrons sous peu.

Les expressions composées peuvent aussi être simples

6 * 5est une expression composée composée de deux expressions simples, 6et 5. Mais 6 * 5c'est aussi une expression simple du +point de vue de. L' +opérateur ne voit que son produit, 30, qui est une expression simple.

Opérateurs et opérandes

Les opérateurs Java sont classés par leur nombre d'opérandes:

  • Un opérateur unaire a un opérande, par exemple un moins unaire (par exemple, -5).
  • Un opérateur binaire a deux opérandes, les exemples sont la multiplication et l'addition.
  • Un opérateur ternaire a trois opérandes; un exemple est l' opérateur conditionnel ( ?:).

Les opérateurs Java sont également classés par position:

  • Un opérateur de préfixe est un opérateur unaire qui précède son opérande (par exemple, -5).
  • Un opérateur de suffixe est un opérateur unaire qui suit son opérande (par exemple, age++;- ajoutez 1 à agela valeur numérique de).
  • Un opérateur infixe est un opérateur binaire ou ternaire entre les opérandes de l'opérateur (par exemple, age + 5).

Un autre exemple jshell

Je présenterai plus d'opérateurs dans les sections suivantes, où je présente des exemples sous forme d'applications. Vous pouvez également essayer ces opérateurs avec jshell, comme ceci:

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

Dans ce cas, nous entrons d'abord expression 6 + 2, qui jshellévalue, en affectant le 8 résultant à la variable scratch $1. Ensuite, nous multiplions $1par 7, ce qui stocke 56 dans la variable scratch $2. Cet exemple montre que vous pouvez utiliser des variables scratch dans les expressions Java.

Opérateurs surchargés

L'opérateur plus (+) est un exemple d' opérateur surchargé , qui est un opérateur qui effectue l'une des nombreuses opérations en fonction des types de ses opérandes. L'opérateur plus effectue une addition d'entiers lorsque les deux opérandes sont des entiers, une addition à virgule flottante lorsque les deux opérandes sont des valeurs à virgule flottante et une concaténation de chaînes lorsque les deux opérandes sont des chaînes. L'opérateur moins (-) est également surchargé, effectuant une soustraction entière ou flottante.

Types d'opérateurs en Java

Opérateurs additifs

Les opérateurs additifs augmentent ou diminuent une valeur numérique par addition et soustraction. Les opérateurs additifs incluent addition ( +), soustraction ( -), postdecrement ( --), postincrement ( ++), predecrement ( --) et preincrement ( ++). La concaténation de chaînes ( +) est également considérée comme additive. Voici une définition formelle pour chacun de ces opérateurs:

  • Addition : Étant donné , où chaque opérande doit être de caractère ou de type numérique, ajouter à et retourner la somme. Exemple: .operand1 + operand2operand2operand14 + 6
  • Soustraction : Étant donné , où chaque opérande doit être de caractère ou de type numérique, soustrayez de et retourner la différence. Exemple: .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.

Les opérateurs d'affectation de composé ( +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=) évalue les expressions et affecter les résultats à des variables en une seule étape. Chaque expression et variable doit être compatible avec l'affectation. Chaque opérateur sert de raccourci utile. Par exemple, au lieu de spécifier x = x + 3;, vous pouvez spécifier le plus court et l'équivalent x += 3;.

Soyez bref!

Au lieu de spécifier x = x + 1;ou x = x - 1;, vous pouvez spécifier le plus court x += 1;ou x -= 1;. Vous pouvez enregistrer encore plus de frappes en spécifiant le plus court x++;ou x--;.

Opérateurs au niveau du bit