Capítulo 002 Ejercicio 019 (While etiquetado)

// El bucle While Etiquetado de Java

public class WhileEtiquetado{

public static void main(String args[]){
int i = 0;
externo:
while(true){
visualizar("Bucle While externo");
while(true){
i++;
visualizar("i = " + i);

if(i == 1){
visualizar("Continuar");
continue;
}

if(i == 3){
visualizar("Continuar externo");
continue externo;
}

if(i == 5){
visualizar("Salir");
break;
}

if(i == 7){
visualizar("Break externo");
break externo;
}
}
}
}

static void visualizar(String s){
System.out.println(s);
}

}

/** Las mismas reglas son ciertas para while:
*
* 1. Un continue sin más va hasta el comienzo del bucle más interno y continúa.
* 2. Un continue etiquetado va a la etiqueta, y vuelve a entrar en el bucle situado justo después de la etiqueta.
* 3. Un break "abandona" el bucle.
* 4. Un break etiquetado abandona el final del bucle marcado por la etiqueta.
*
* La salida de este método lo deja claro:
*
* --------------------Configuration: --------------------
* Bucle While externo
* i = 1
* Continuar
* i = 2
* i = 3
* Continuar externo
* Bucle While externo
* i = 4
* i = 5
* Salir
* Bucle While externo
* i = 6
* i = 7
* Break externo
*
* Process completed.
*
* Es importante recordar que la única razón para usar etiquetas en Java es cuando se tienen bucles anidados,
* y se quiere utilziar sentencias "break" o "continue" a través de más de un nivel de anidamiento.
*
* En el artículo "El goto considerado dañino" de Dijkstra, se ponen objeciones a las etiquetas, no al
* goto en sí. Dijkstra observó que el número de errores tiende a incrementarse con el número de etiquetas
* que haya en un programa. Las etiquetas y las sentencias goto hacen díficil el análisis estático, puesto
* que introducen ciclos en el grafo de ejecución de los programas. Fíjese que las etiquetas de Java no
* tienen este problema, pues están limitadas a su ubicación, y no pueden ser utilizadas para transferir el
* control de forma directa. Tambiéne s interesante tener en cuenta que éste es el caso en el que una
* característica de un lenguaje se convierte en más interesante, simplemente restringiendo el poder
* de la propia sentencia.
*
**/