##
CONTROL DE FLUJO

Muchas de las sentencias de control del flujo del programa se han tomado del C:

### Sentencias de Salto

if/else

        if( Boolean ) {
            sentencias;
            }
        else {
            sentencias;
        }

switch

        switch( expr1 ) {
            case expr2:
                sentencias;
                break;
            case expr3:
                sentencias;
                break;
            default:
                sentencias;
                break;
            }

### Sentencias de Bucle

Bucles for

        for( expr1 inicio; expr2 test; expr3 incremento ) {
            sentencias;
            }

El siguiente trocito de código Java que dibuja varias líneas en pantalla alternando sus colores entre rojo, azul y verde. Este fragmento sería parte de una función Java (método):

        int contador;
        for( contador=1; contador <= 12; contador++ ) {
            switch( contador % 3 ) {
                case 0:
                    setColor( Color.red );
                    break;
                case 1:
                    setColor( Color.blue );
                    break;
                case 2:
                    setColor( Color.green );
                    break;
                }
            g.drawLine( 10,contador*10,80,contador*10 );
            }

También se soporta el operador coma (,) en los bucles for

        for( a=0,b=0; a < 7; a++,b+=2 )

Bucles while

        while( Boolean ) {
            sentencias;
            }

Bucles do/while

        do {
            sentencias;
            }while( Boolean );

### Excepciones

try-catch-throw

        try {
            sentencias;
        } catch( Exception ) {
            sentencias;
        }

Java implementa excepciones para facilitar la construcción de código robusto. Cuando ocurre un error en un programa, el código que encuentra el error lanza una excepción, que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones predefinidas.

### Control General del Flujo

        break [etiqueta]
        continue [etiqueta]
        return expr;
        etiqueta: sentencia;

En caso de que nos encontremos con bucles anidados, se permite el uso de etiquetas para poder salirse de ellos, por ejemplo:

        uno: for( )
                 {
            dos: for( )
                    {
                    continue;           // seguiría en el bucle interno
                    continue uno;       // seguiría en el bucle principal
                    break uno;          // se saldría del bucle principal
                    }
                }

En el código de una función siempre hay que ser consecuentes con la declaración que se haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero, es imprescindible que se coloque un return final para salir de esa función, independientemente de que haya otros en medio del código que también provoquen la salida de la función. En caso de no hacerlo se generará un Warning, y el código Java no se puede compilar con Warnings.

        int func()
        {
        if( a == 0 )
            return 1;
        return 0;    // es imprescindible porque se retorna un entero
        }

|  | ##### [Anterior] [Indice] [Siguiente]