Cuando se desarrollan algoritmos se debe considerar tanto las estructuras de datos como los controles de flujo cuya sintaxis en Java se recopila en este artículo.

1. Control de flujo: instrucciones condicionales

En Java las instrucciones de la programación estructurada están disponibles para controlar el flujo y determinar que instrucciones ejecutar o cuantas veces repetirlas.

Visita la página de historia de java para más detalles introductorios.

La primera instrucción de control es el condicional cuya forma compuesta se muestra a continuación.

// Forma simple del condicional
if(expresión booleana) {
    // Bloque en caso que la expresión sea verdadera
}
// Forma compuesta del condicional
if(expresión booleana) {
    // Bloque en caso que la expresión sea verdadera
} else {
    // Bloque en caso que la expresión sea verdadera
}
// Condicional en escalera
if(expresión booleana 1) {
    // Bloque en caso que la expresión 1 sea verdadera
} else if(expresión booleana 2) {
    // Bloque en caso que la expresión 2 sea verdadera
} else if(expresión booleana 3) {
    // Bloque en caso que la expresión 3 sea verdadera
} else{
    // Bloque en caso que ninguna expresion sea verdadera
}

Los puntos clave a resaltar sobre la instrucción condicional son los siguiente:

  • Los paréntesis en la expresión booleana son obligatorios.
  • No es requerido el uso de la parte del else en el código.
  • Es supremamente importante tener en cuenta que el código dentro de un bloque debe tener sangría aplicada.
  • En la tercera forma del condicional (en escalera) aunque varias expresiones booleanas sean verdaderas solamente se ejecuta el bloque correspondiente a la primera expresión booleana verdadera, así mismo puede haber un número indefinido de segmentos else if.
  • Tenga presente que en muchas ocasiones el operador ternario simplifica la escritura del código, sin embargo, debe balancear dicha simplicidad con la dificultad de leer expresiones muy crípticas.
  • En caso que los bloques tengan una sola instrucción no es necesario usar llaves, no obstante lo anterior es muy recomendado por legibilidad siempre usar llaves.

1.1. Instrucción swtich

Otra instrucción condicional es switch cuya sintaxis se puede apreciar en el siguiente segmento de código.

switch(variable) {
    case CONSTANTE1:
        // código 1
        break;
    case CONSTATE2:
        // código 2
        break;
    default:
        // código por defecto
}

En el caso de la instrucción switch se puede apreciar que la misma es utilizada de forma similar a un if en escalera, estos permiten realizar el control de flujo las bifuraciones del código . Hay que recordar que las instrucciones que se ejecutaran corresponden a la primera comparación verdadera de la variable con las diferentes constantes, igualmente solo se ejecuta un bloque de código que esta marcado desde los dos puntos y hasta el siguiente break, en ocasiones y dado que la instrucción break es opcional, se pueden juntar varios segmentos case para ejecutar un mismo código para cualquiera de las constantes que acompañen dichos segmentos case.

Note también que hay un segmento por defecto y es opcional, este se ejecuta cuando ninguna de las comparaciones con las constantes arrojo un resultado verdadero. Los tipos de datos soportados para la variable son: int, Integer, byte, Byte, short, Short, char, Character, String, y enum.

De otra parte las constantes, deben ser o bien literales o variables marcadas con la palabra reservada final, el tipo de dato de las constantes debe coincidir con el tipo de dato de la variable, además observe que final hace que la variable se convierta en constante y únicamente pueda recibir valor en el momento de su creación, sin embargo el código no compilara si usa una variable como constante y la misma es un parámetro de una función, así esta última este marcada como final.

2. Control de flujo: ciclos

Los ciclos son otra forma de realizar control de flujo en java al repetir o iterar una serie de isntrucciones.

2.1. Ciclo while

El ciclo más sencillo y fácil de utilizar es el while, el cual repite las instrucciones mientras una condición sea verdadera, en este sentido observe que en sintaxis se parece mucho al condicional if. A continuación se presenta su sintaxis.

while(condición booleana) {
    // Código
}

2.2. Ciclo do while

De forma similar, se encuentra el ciclo do - while el cual es similar al anterior, excepto que este se repite al menos una vez ya que la condición se evalúa al final del ciclo y no al principio. Su sintaxis se muestra a continuación.

do {
    // Código
} while(condición booleana);

2.3. Ciclo for

El tercer ciclo y de hecho uno de los más comunes es el ciclo for el cual en su presentación básica se muestra a continuación

for(inicialización, expresión booleana, actualización) {
    // Código
}

Las tres partes del ciclo for son opcionales y si todas se omiten el ciclo sería un ciclo infinito. También es posible separar múltiples sentencias de inicialización o actualización utilizando comas.

Es importante recordar que la inicialización no puede realizar ocultamiento de variables, es decir, si la variable declarada en la inicialización ya fue declarada antes del ciclo for el compilador arrojará un error indicando que se tiene una doble declaración de la variable, de esta manera las variables declaradas en la inicialización pertenecerán al ámbito del cuerpo del ciclo y no se podrán usar por fuera de este. El último ciclo disponible en Java es el ciclo for - each el cual se muestra a continuación.

for(TipoDato variable : colección) {
    // Código
}

En este caso la colección debe ser una implementación de java.lang.Iterable y el ciclo se ejecuta una vez por cada ítem de la colección, asignando en cada repetición un valor de la colección.

Algo importante a tener en cuenta con los diferentes ciclos es que los bloques de código pueden omitir las llaves cuando solo se trate de una sola línea, en estos casos es importante mantener la tabulación o poner la línea de código al frente de la estructura de control. En cualquier caso esta práctica no es muy recomendable puesto que es más propensa a introducir errores en el código.

3. Etiquetas, continue y break

Las sentencias (if, while, do while, for, switch) de Java pueden ser iniciadas con una etiqueta, normalmente escrita en mayúsculas y terminada en dos puntos. Estas etiquetas sirven para marcar los puntos donde se puede devolver el código mediante una sentencia break o continue, estas dos instrucciones permiten o romper un ciclo con la finalidad de salirse del mismo y no continuar su ejecución o en el caso de continue continuar de inmediato con la siguiente iteración del ciclo sin importar que falten instrucciones por ejecutar. La sintaxis de estas etiquetas es:

break etiquetaOpcional;
continue etiquetaOpcional;

Estas instrucciones están disponibles para los ciclos, adicionalmente las sentencia switch soporta el uso de break. El uso de estas instrucciones es particularmente útil cuando en un ciclo se detecta que no se requiere seguir ejecutando, por ejemplo, si se esta realizando una búsqueda y se encuentra el ítem deseado no se requeriría seguir iterando para buscar, en este caso se puede recurrir a la instrucción break o si la iteración ya no se requiere hacer se usaría continue.. Un ejemplo del uso de etiquetas junto con una sentencia break y continue se muestra a continuación.

PRIMERO: for( ... ) {
    SEGUNDO: for( ... ) {
        if( ... ) {
            // Rompe el ciclo actual terminándolo y haciendo
            // un salto a la etiqueta PRIMERO
            break PRIMERO;
        }
        if( ... ) {
            // Deja de ejecutar la iteración actual del ciclo
            // interno y brinca a la etiqueta SEGUNDO,
            // en este caso no es necesario el uso de etiquetas
            // puesto que la instrucción continue esta en el
            // cuerpo del segundo ciclo
            continue SEGUNDO;
        }
        // ... código ...
    }
}

4. Artículos de Interés

Operadores en Java
Encapsulamiento en Java
Listas enlazadas en Java