lopezatienza.com

TEMA6. Estructuras de control de flujo, excepciones y comentarios

En esta Unidad Didáctica veremos como se ejecuta el flujo de ejecución de un programa mediante distintas estructuras, estudiaremos que son las excepciones y como e implementan, y veremos como documentar un fichero Java mediante comentarios.

1. Introducción
2. Estructuras de de bifurcación
3. Estructuras de iteración
4. Excepciones
5. Comentarios

1. Introducción

Estructuras de control de flujo son las que permiten ejecutar el flujo de ejecución del programa de manera no lineal.

Existen dos tipos: las estructuras de bifuración (if, switch, try-catch), que permiten realizar saltos en el código; y las estructuras iterativas (for, while, do-while), que permiten repetir código. En Java no existe la sentencia goto.

2. Estructuras de bifurcación

Nos permiten ejecutar condicionalmente instrucciones de Java. Es decir, las instrucciones que se escriban, se ejecutarán o no, dependiendo del valor de una expresión booleana que se llama condición.

La instrucción if

Permite la ejecución de un trozo de código condicionado a si se cumple una condición lógica.

Sintaxis:

if(condicion_booleana)
sentencia; if (condicion_booleana){ sentencia 1;
sentencia 2;
...
sentencia N;
}

Ejemplo:

int nota=3;
if (nota>=5)
System.out.println(“Aprobado”);
System.out.println(“Nota de programación”);
int nota=7;
if (nota>=5){
System.out.println(“Aprobado”);
System.out.println(“Nota de programación”);
}

Utilización de la claúsula else con if

Ejecución de un trozo de código u otro, condicionado a si se cumple o no se cumple una condición lógica.

Sintaxis:

if(condicion)
sentencia 1;
else
sentencia 2;
if(condicion) {
sentencia 1;
sentencia 2;
}else{
sentencia 3;
sentencia 4;
}

Ejemplo:

int edad=18;
if(edad>=18)
System.out.println(“Es mayor de edad”);
else
System.out.println(“No es mayor de edad”);

Sentencias if anidadas

Ejecución de distintos trozos de código de manera excluyente condicionado a si  se cumple o no se cumplen las distintas condiciones lógicas de la estructura.

Sintaxis:
if(condicion 1) {
sentencia 1;
} else if(condicion 2) {
sentencia 2;
} else
sentencia 3;
Ejemplo:

if(edad<15){
Cadena=”joven”;
}else if(edad<20){
Cadena=”adolescente”;
}else if(edad<25)
Cadena=”universitario”;
}else{
Cadena=”mayor”;
}
La instrucción switch
Ejecución de distintos trozos de código de manera no excluyente (excepto si se  usa break) condicionado al valor de una variable numérica (el selector).

Sintaxis:
switch(selector){
case etiqueta1: sentencia2; break;
....
case etiquetaN: sentencia N; break;
default: sentencias_alternativas;
}
Funcionalmente es igual a las sentencias if-else anidadas.
Las ventajas que proporciona respeto a las anteriores, es que es más elegante y  legible; y las desventajas es que el selector y las etiquetas solo pueden ser numéricas.
Las etiquetas son resultas en tiempo de compilación (no son dinámicas).

Si se incluye la claúsula default en la instrucción switch, se pueden especificar  una o más instrucciones que se ejecutarán cuando ninguna de las expresiones constantes coincida con la expresión de bifurcación.

Ejemplo:
String numeroAPalabra(int numero){
String palabra=” “;
switch(numero){
case 1: palabra=”uno”; break;
case 2: palabra=”dos”; break;
case 3: palabra=”tres”; break;
......
default: palabra=”indefinido”;
}
return palabra;
}
3. Estructuras de iteración
Se utilizan para repetir una o varias instrucciones ninguna, una o varias veces.
Una expresión booleana determinará el número de veces que se repite el bucle.
Una de las principales diferencias entre las estructuras de control iterativas y las  de bifurcación está en la utilización de la palabra clave continue. La ejecución de las estructuras de control iterativas puede controlarse mediante continue, mientras que las de bifurcación no. La palabra clave break puede utilizarse también con las estructuras  de control iterativas. Los usos de ambas palabras clave los veremos por separado para cada estructura de control iterativa.

Bucle for:
Sirven para repetir ninguna, una o varias veces una instrucción.
El formato de uso más simple es la palabra clave for seguida por la instrucción a repetir:

for(;;)
instrucción;
int a=0;
for(;;){
++a;
if(a>10)
break;
}
Sintaxis:
for(inicialización; condición; incremento){
Sentencias;
}
Inicialización: Se ejecuta sólo una vez y antes de entrar en el cuerpo del bucle por primera vez. Normalmente para declarar e inicializar la variable contador. El ámbito del contador se limita al cuerpo del bucle y se pueden incluir varias sentencias separadas por el operador “,”.

Condición: Es la condición de permanencia del bucle, si dicha condición es false no se produce la siguiente iteración.

Incremento: Instrucción/es que se ejecutan al terminar cada iteración del bucle mientras la condición de permanencia sea true. Se utiliza para incrementar o decrementar la variable contador. En caso de varias sentencias irán separadas por el
operador coma “,”.

Ejemplo:
for(int i=1;i<=100;i++){
System.out.println(i);
}
Bucle while:
Se utilizan para ejecutar ninguna, una o varias veces una instrucción o bloque de instrucciones. La diferencia está en que los bucles while no permiten utilizar variables de control.

La condición de permanencia se evalúa antes de ejecutarse la primera iteración.

Sintaxis:
while(condicion){
sentencia 1;
sentencia 2;
....
sentencia N;
}
Ejemplo:
int n=1;
while(n<=100){
System.out.prinln(n);
n++;
}
Bucle do-while
Son casi iguales a los bucles while, con la diferencia de que los bucles do  siempre se ejecutan al menos una vez. Los bucles do tienen condición de salida, lo que implica que la condición se evalúa al finalizar cada iteración. Este es el motivo por el
cual los bucles do se ejecutan al menos una vez.

Sintaxis:
do
Instrucciones;
while(condicion);
Ejemplo:
int n=0;
do{
n++;
System.out.println(n);
}while(n<=100);

Salida anticipada de bucles
Controlan el flujo de ejecución de bucles:

Break: Salimos del bucle.
Continue: Finalizar la iteración actual del bucle pero no se sale de él.
Su utilidad es que mejoran mucho la legibilidad del código y aportan flexibilidad a la codificación.
Ejemplo:
int opcion=0;
do{
opcion=Integer.parseInt(teclado.readLine( ));
if(opcion<1 || opcion>3){
System.out.println(“Opcion incorrecta”);
continue;
}
System.out.println(“Opcion correcta”);
break;
}while(true);
4. Excepciones
Se utilizan para controlar circunstancias no usuales que pueden dar lugar a error.
Algunos ejemplos muy usuales:
- IndexOutOfBoundException: Cuando se accede a una posición de un array no válida(fuera de sus límites).
- NullPointerException: Cuando se realiza alguna operación sobre un objeto y éste no ha sido previamente creado (con new).
- NumberFormatException: Si se intenta convertir un dato no numérico a número.
¿Qué ocurre si aparece una excepción en mi programa?
Si no se toma ninguna medida (no se captura la excepción), el programa finaliza bruscamente

java.lang.NumberFormatException: For input string: "a"at
java.lang.NumberFormatException.forInputString(Unknown Source)at
java.lang.Integer.parseInt(Unknown Source)at
java.lang.Integer.parseInt(Unknown Source)at
estadisticas.EstadisticasApp.menuEstadisticas(EstadisticasApp.java:123)at
estadisticas.EstadisticasApp.subMenu(EstadisticasApp.java:147)at
estadisticas.EstadisticasApp.main(EstadisticasApp.java:163)
Si se toman medidas, se capturaría la excepción de alguna manera y seguiría la  ejecución del programa.

¿Cómo pueden aparecer excepciones en un programa? De dos formas, no controladas, como las vistas anteriormente, programadas, se lanzan creando un objeto de tipo Exception y lanzandolo con throw.
Ejemplo:
int dato=Integer.parseInt(teclado.readLine( ));
if(dato<0){
throw new Exception(“Dato no válido (<0)”);
}
if(dato= =0){
throw new DatoInvalidoException(“Dato no valido (=0)”);
}
¿Cómo manejamos las excepciones cuando queremos controlarlas?
Con un bloque try-catch-finally:
En el bloque try ponemos las sentencias que pueden generar la excepción. Se ejecutará hasta el final si no aparece la excepción.
En el bloque catch pondremos las sentencias a ejecutar si se produce la excepción en el bloque try. Si no se produjera la excepción este bloque de código no se ejecutaría.

El bloque finally es opcional y lo que se escriba en él se ejecutará siempre (tanto si se produce la excepción como si no). Su existencia es discutida por algunos programadores.

Ejemplo:
int x=(int)(Math.random( )*5); //x entre 0 y 4
int y=(int)(Math.random( )*10); //y entre 0 y 9
int z=new int[5];
try{
System.out.prinln(x+”/”+y+”=”+(x/y));
System.out.println(“y es “+y+”z[y] es”+z[y]);
}catch(ArithmeticException e){
System.out.println(“Problema aritmetico: “+e);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println(“Problema de indice: “+e);
}catch(Exception e){
System.out.println(“Exception: “+e);
}finally{
System.out.println(“Bloque finally”);
}
¿Y si no queremos controlar una excepción? Con la claúsula throws en la cabecera del método se lo indicamos al compilador.
Ejemplo:
BufferedReader teclado=new BufferedReader(...);
public static void metodo1( ) throws IOException{
String str=teclado.readLine( );
}
public static void metodo1( ){
try{
String str=teclado.readLine( );
}catch(IOException ioe){
System.out.println(oie);
}
}
Sin embargo, el compilador no siempre me obliga a manejar las excepciones (como ocurre por ejemplo con las NullPointerException)?:

Eso es porque existen varios tipos de excepciones en Java:
- Excepciones a comprobar (checked exceptions). Todas las que heredan de Exception excepto las de tipo RuntimeException.
- Excepciones sin necesidad de comprobación. Se subdividen en: Excepciones en tiempo de ejecución (runtime exceptions). Heredan de RuntimeException. Errores: Heredan de Error.

Ejemplos de cada una de ellas:
- Checked exceptions: para controlar excepciones en programas que son correctos. Ejemplo: IOException, SecurityException, SQLException.
- RuntimeExceptions: Son errores debidos a bugs de programación.
NullPointerExceptions, ArithmeticException, IndexOutOfBoundException,
NegativeArraySizeException.
- Errores: debidos a problemas muy inusuales difíciles de controlar (normalmente de la JVM). OutOfMemoryError, UnknownError, InternalError. Son irrecuperables y no debemos preocuparnos de capturarlos y tratarlos.

Puesto que todos los tipos de excepciones derivan de Throwable, con todas se pueden usar los métodos siguientes:

- getMessage( ): devuelve el mensaje asociado con la excepción.

- toString( ): Devuelve un texto descriptivo de la excepción.
- printStackTrace( ): Indica el método donde se lanzó la excepción.
¿Qué hacer con datos incorrectos?
Si los recibimos del usuario hay que informarle del hecho, hay que capturar las excepciones. Cuando programamos métodos (servicios) para ser usados desde otros programas (clientes) hay que establecer las responsabilidades de cada parte (programación por contrato). Lanzamos excepciones en tiempo de ejecución que informan del error "al programador" pero no le obligan a programar con try-catch constantemente.

Por ejemplo: método para el cálculo de una raíz cuadrada: Si el dato recibido es negativo lanzamos una RuntimeException (por ejemplo del tipo IllegalArgumentException)
Si el dato es positivo o cero, realizamos la operación normalmente.
5. Comentarios
Los comentarios son instrucciones del código fuente que no son compiladas por el compilador. Se emplean para documentar la funcionalidad del código y dar las explicaciones aclaratorias pertinentes. Facilita la lectura, depuración y mantenimiento del código.

Comentarios de una sola línea
Se realizan mediante dos barras inclinadas. (//). El compilador Java ignora cualquier carácter desde el comienzo del comentario hasta el final de línea.

Se suelen utilizar para explicaciones breves. Un uso muy práctico es el de poder “eliminar” temporalmente líneas de código durante los procesos de depuración.

Comentarios de varias líneas
Empiezan con la secuencia de caracteres /* y termina con la secuencia */. El compilador Java ignorará cualquier carácter que escribamos dentro de dichas secuencias.

Son muy útiles para comentarios extensos, como por ejemplo las descripciones que suelen encabezar las definiciones de clases o de sus métodos.

Comentarios de documentación
Java permite unos identificadores especiales de comentario que pueden utilizarse para extraerlos cuando se genera la documentación. La herramienta que se utiliza para crear la documentación se llama JavaDoc, y genera archivos HTML que representan una forma muy eficaz de describir las características de una clase.

Comienzan con los caracteres /** y terminan con los caracteres */, y facilita el mantenimiento de la documentación.

Las etiquetas más útiles en la documentación son:
@version: Indicar versión de la clase o interfaz. Es opcional, y es útil si vamos a publicar varias versiones de las clases.
@author: Es un marcador opcional que podemos usar para especificar el autor o los autores de una clase o interfaz.
@param: Se usa para documentar los parámetros de los métodos. Especificamos un nombre de parámetro, seguido de una breve descripción. Tenemos que especificar un marcador @param para cada uno de los parámetros del método, y
enumerarlos en el mismo orden en el que aparecen en su lista de parámetros.

@return: Sirve para documentar los métodos de una clase que devuelven un valor. Describimos el valor que devuelve dicho método.
@deprecated: Nos permite compilar código pensado para versiones anteriores de Java. Cuando compilemos, se nos indica que la versión actual suministra instrucciones alternativas que son preferibles.
@exception: Documentar un método que puede generar una excepción. Si queremos referenciar a otras clases se emplea @see. @see nombre_clase genera un enlace a la documentación de la clase indicada.
Ejemplo:
import java.util.*;
/**Ejemplo de documentación de un código
*@author Felix Reyes
*@version 1.0
*/
public class Fecha
{
/**como es habitual, el metodo main puede recibir como
*argumento un array de cadenas de caracteres
*@param args array de cadenas de caracteres
*@return no retorna nada
*@exception no se generaran excepciones
*/
public static void main(String[] args){
System.out.println(“Hola, hoy es: “+new Date( ));
}
}

<< Volver al tema anterior  || >> Ir al tema siguiente

Referencias:

http://www.jmordax.com/

Autor: Antonio Lopez Atienza