Ahora que ya entiende las variables y los operadores es el momento de aprender lo que son las expresiones, las sentencias y los bloques. Los operadores se utilizan para construir expresiones que calculan valores; las expresiones son los componentes centrales de las sentencias; las sentencias se pueden agrupar en bloques.

Expresiones

Una expresión es una construcción hecha de variables, operadores e invocaciones de métodos, creados según la sintaxis del lenguaje, que evalúa a un solo valor. Ya hemos visto ejemplos de expresiones, ilustradas en negrita a continuación:

int cadence = 0;
     anArray[0] = 100;
     System.out.println("Elemento 1 en el índice 0: " + anArray[0]);

     int result = 1 + 2; // result es ahora 3
     if(value1 == value2) System.out.println("value1 == value2");
 

El tipo de dato del valor devuelto por una expresión depende de los elementos utilizadas en ella. La expresión cadence = 0 devuelve un int porque el operador de asignación devuelve un valor del mismo tipo de dato que el operando de su izquierda; en este caso cadence es un int. Como puede observar en los demás ejemplos, una expresión puede devolver también otro tipo de datos, por ejemplo boolean o String.

El lenguaje de programación Java permite construir expresiones compuestas a partir de varias expresiones más pequeñas siempre que el tipo de dato requerido por una parte de la expresión concuerde con el de la otra. A continuación un ejemplo de una expresión compuesta:

1 * 2 * 3

En este ejemplo el orden en el que se evalúa la expresión no es importante porque el resultado de la muliplicación no depende del orden; el resultado es siempre el mismo sin importar el orden en que se apliquen las multiplicaciones. Sin embargo esto no es cierto para todas las expresiones. Por ejemplo, la siguiente expresión dará resultados diferentes según se realice primero la operación de suma o la de división:

x + y / 100     // ambíguo

Puede indicar exáctamente cómo se debe evaluar una expresión mediante el uso de paréntesis: ( y ). Para eliminar la ambigüedad de la expresión anterior se podría escribir de la siguiente forma:

(x + y) / 100    // no ambíguo, recomendado

Si no indica explícitamente el orden de las operaciones que se deben realizar, el orden lo determina la precedencia asignada a los operadores utilizados en la expresión. Lo peradores con mayor precedencia se evalúan primero. Por ejemplo, el operador de división tiene mayor precedencia que el de suma. Por lo tanto las siguientes dos sentencias son equivalentes:

x + y / 100  
x + (y / 100) // no ambíguo, recomendado

Sea explícito al escribir expresiones compuestas e indique con paréntesis qué operadores se deben evaluar primero. Esta práctica hará que su código sea más fácil de leer y mantener.

Sentencias

Las sentencias son, a grandes rasgos, equivalentes a las oraciones del lenguaje natural. Una sentencia forma una unidad de ejecución completa. Los siguientes tipos de expresiones se pueden convertir en sentencia si se terminan con punto y coma (;).

• Expresiones de asignación
• Cualquier uso de code>++ o --
• Invocaciones de métodos
• Expresiones de creación de objetos

Este tipo de sentencias se llaman sentencias de expresión. Veamos algunos ejemplos de sentencias de expresión.

unValor = 8933.234;                      // sentencia de asignación
unValor++;                               // sentencia de incremento
System.out.println("¡Hola Mundo!");     // sentencia de invicación de método
Bicycle miBici = new Bicycle(); // sentencia de creación de objeto
 

Hay dos otros tipo de sentencias además de las de expresión: sentencias de declaración y sentencias de control de flujo. Una sentencia de declaración declara una variable. Ya hemos visto muchos ejemplos de sentencias de declaración:

double unValor = 8933.234; //sentencia de declaración
 

Finalmente, las sentencias de control de flujo regulan el orden en el que se ejecutan las sentencias. Aprenderá más acerca de las sentencias de control de flujo en la siguiente sección, Sentencias de control de flujo

Bloques

Un bloque es un grupo de sentencias contenido entre corchetes emparejados que se puede utilizar en cualquier lugar en el que se permita una sentencia sencilla. El siguiente ejemplo, BlockDemo, ilustra el uso de bloques:

class BlockDemo {
     public static void main(String[] args) {
          boolean condition = true;
          if (condition) { // empieza el bloque 1
               System.out.println("Condition es verdadero.");
          } // fin del bloque one
          else { // empieza el bloque 2
               System.out.println("Condition es falso.");
          } // fin del bloque 2
     }
}