Evaluar expresiones Java con operadores

Las aplicaciones Java procesan datos evaluando expresiones , que son combinaciones de literales, llamadas a métodos, nombres de variables y operadores. La evaluación de una expresión normalmente produce un nuevo valor, que puede almacenarse en una variable, usarse para tomar una decisión, etc.

En este tutorial, aprenderá a escribir expresiones para sus programas Java. En muchos casos, usará operadores para escribir sus expresiones Java, y hay muchos tipos de operadores para saber cómo usarlos. Presentaré brevemente los tipos de operadores de Java (incluidos los tipos aditivo, bit a bit, lógico, condicional, de desplazamiento y de igualdad) y sus operandos. También aprenderá sobre conceptos importantes como la sobrecarga de operadores y la precedencia de operadores, y verá una demostración de conversión de tipo primitivo. Concluiré con un pequeño programa Java que puede utilizar para practicar conversiones de tipo primitivo por su cuenta.

descargar Obtener el código Descargar el código fuente, por ejemplo, las aplicaciones de este tutorial. Creado por Jeff Friesen para JavaWorld.

Expresiones simples

Una expresión simple es un literal, un nombre de variable o una llamada a un método. No hay operadores involucrados. A continuación, se muestran algunos ejemplos de expresiones 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

Una expresión simple tiene un tipo , que es un tipo primitivo o un tipo de referencia. En estos ejemplos, 52es un entero de 32 bits ( int); System.out.println("ABC");es void ( void) porque no devuelve ningún valor; "Java"es una cadena ( String); 98.6Des un valor de coma flotante de precisión doble de 64 bits ( double); y 89Les un entero de 64 bits ( long). No sabemos ageel tipo.

Experimentando con jshell

Puede probar fácilmente estas y otras expresiones simples usando jshell. Por ejemplo, ingrese 52en el jshell>indicador y recibirá algo como el siguiente resultado:

$1 ==> 52

$1es el nombre de una variable temporal que jshellcrea para almacenar 52. (Las variables de Scratch se crean siempre que se ingresan literales). Ejecute System.out.println($1)y verá 52como resultado.

Puede ejecutar jshellcon el -vargumento de la línea de comandos ( jshell -v) para generar comentarios detallados. En este caso, ingresar 52resultaría en el siguiente mensaje, revelando que la variable temporal $1tiene el tipo int(entero de 32 bits):

| created scratch variable $1 : int

A continuación, intente ingresar age. En este caso, probablemente recibirá un mensaje de error indicando que no se encontró el símbolo. Java Shell asume que agees una variable, pero no conoce su tipo. Debería incluir un tipo; por ejemplo, vea qué pasa si ingresa int age.

Expresiones compuestas

Una expresión compuesta consta de una o más expresiones simples integradas en una expresión más grande a través de un operador , que es una secuencia de instrucciones representadas simbólicamente en el código fuente. El operador transforma su (s) operando (s) de expresión en otro valor. Por ejemplo, en 6 * 5, el operador de multiplicación ( *) transforma los operandos 6y 5en 30.

Las expresiones compuestas se pueden combinar en expresiones más grandes. Por ejemplo, 6 * 5 + 10presenta una expresión compuesta 6 * 5y una expresión compuesta que consta de su producto, operador de suma +y número 10. El orden de evaluación (multiplicar primero y luego agregar) lo dicta la regla de precedencia de Java , a la que llegaremos en breve.

Las expresiones compuestas también pueden ser simples

6 * 5es una expresión compuesta formada por dos expresiones simples 6y 5. Pero 6 * 5también es una expresión simple desde +la perspectiva de. El +operador solo ve su producto, 30, que es una expresión simple.

Operadores y operandos

Los operadores de Java se clasifican por su número de operandos:

  • Un operador unario tiene un operando, por ejemplo menos unario (por ejemplo, -5).
  • Un operador binario tiene dos operandos, los ejemplos son multiplicación y suma.
  • Un operador ternario tiene tres operandos; un ejemplo es el operador condicional ( ?:).

Los operadores de Java también se clasifican por posición:

  • Un operador de prefijo es un operador unario que precede a su operando (por ejemplo, -5).
  • Un operador de sufijo es un operador unario que sigue a su operando (por ejemplo, age++;- suma 1 al agevalor numérico de).
  • Un operador infijo es un operador binario o ternario entre los operandos del operador (por ejemplo, age + 5).

Otro ejemplo de jshell

Presentaré más operadores en las siguientes secciones, donde presento ejemplos en forma de aplicaciones. También puede probar estos operadores con jshell, así:

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

En este caso, primero ingresamos expresión 6 + 2, que jshellevalúa, asignando el 8 resultante a la variable cero $1. A continuación, multiplicamos $1por 7, que almacena 56 en la variable cero $2. Este ejemplo demuestra que puede utilizar variables temporales en expresiones Java.

Operadores sobrecargados

El operador más (+) es un ejemplo de un operador sobrecargado , que es un operador que realiza una de varias operaciones según los tipos de sus operandos. El operador más realiza la suma de enteros cuando ambos operandos son enteros, la suma de punto flotante cuando ambos operandos son valores de punto flotante y la concatenación de cadenas cuando ambos operandos son cadenas. El operador menos (-) también está sobrecargado y realiza una resta de números enteros o de punto flotante.

Tipos de operador en Java

Operadores aditivos

Los operadores aditivos aumentan o disminuyen un valor numérico mediante la suma y la resta. Los operadores aditivos incluyen suma ( +), resta ( -), posdecremento ( --), postincremento ( ++), predecremento ( --) y preincremento ( ++). La concatenación de cadenas ( +) también se considera aditiva. Aquí hay una definición formal para cada uno de estos operadores:

  • Además : Teniendo en cuenta , que cada operando debe ser de carácter o tipo numérico, añadir a , y devolver la suma. Ejemplo: .operand1 + operand2operand2operand14 + 6
  • La resta : Teniendo en cuenta , que cada operando debe ser de carácter o tipo numérico, se resta de y devolver la diferencia. Ejemplo: .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.

Los operadores de asignación compuesto ( +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=) evaluar expresiones y asignan los resultados a las variables en un solo paso. Cada expresión y variable debe ser compatible con la asignación. Cada operador sirve como un atajo útil. Por ejemplo, en lugar de especificar x = x + 3;, puede especificar el más corto y equivalente x += 3;.

¡Que sea breve!

En lugar de especificar x = x + 1;o x = x - 1;, puede especificar el más corto x += 1;o x -= 1;. Puede ahorrar aún más pulsaciones de teclas especificando el más corto x++;o x--;.

Operadores bit a bit