2017-6-2 -6-23 3
educaci cacio onadista istan ncia cia.ju .juntad tadeandalucia lucia.e .es/ s/cu curso rsos/ s/b block locks/ s/re reco cop pila/re ila/reco cop pila.p ila.ph hp?id=1 id=10 0412
Uso de estructuras de control.
Caso práctico Los miembros de BK Programación están inmersos en el mundo de Java, ya conocen una buena parte del lenguaje y ahora van a empezar a controlar el comportamiento de sus programas. María pregunta a Juan: -Dime Juan, ¿las estructuras de control en Java son similares a las de cualquier otro lenguaje? María,, como la gran mayoría de los lenguajes de programación, Java incorpora estructuras que nos permiten -Efectivamente, María tomar decisiones, repetir código, etc. Cada estructura tiene sus ventajas, inconvenientes y situaciones para las que es Juan.. adecuada. Hay que saber dónde utilizar cada una de ellas -aclara Juan
Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. V43
Materiales actualizados por el profesorado de la Junta de Andalucía
Aviso legal
Materiales desarrollados inicialmente por el Ministerio de Educación, Cultura y Deporte Aviso Legal
1.- Introducción. En unidades anteriores, has podido aprender cuestiones básicas sobre el lenguaje Java: definición de variables, tipos de datos, asignación de valores, uso de literales, diferentes operadores que se pueden aplicar, conversiones de tipos, inserción de comentarios, etc. Posteriormente, hemos dado los primeros pasos en la solución de algoritmos sencillos, que sólo requieren ejecutar unas instrucciones detrás de otras, sin posibilidad de decidir, según la situación, ejecutar unas u otras sentencias, ni nada parecido. Todo era una ejecución secuencial, una sentencia detrás de otra, sin vuelta atrás, ni saltos de ningún tipo en el orden de ejecución en que estaban escritas. ¿Pero es eso suficiente?
Reflexiona Piensa en la siguiente pregunta: ¿Cómo un programa puede determinar la aparición en pantalla de un mensaje de ÉXITO o ERROR, según los datos de entrada aportados por un usuario? Mostrar retroalimentación
Como habrás deducido, con lo que sabemos hasta ahora no es suficiente. Existen múltiples situaciones que nuestros programas deben representar y que requieren tomar ciertas decisiones, ofrecer diferentes alternativas o llevar a cabo determinadas operaciones repetitivamente hasta conseguir sus objetivos. Si has programado alguna vez o tienes ciertos conocimientos básicos sobre lenguajes de programación, sabes que la gran mayoría de lenguajes poseen estructuras que permiten a los programadores controlar el flujo de la información de sus programas. Esto realmente es una ventaja para la persona que está aprendiendo un nuevo lenguaje, o tienen previsto aprender más de uno, ya que estas estructuras suelen ser comunes a todos (con algunos cambios de sintaxis ). Es decir, si conocías sentencias de control de flujo flujo en otros lenguajes, lo que vamos a ver a lo largo de esta unidad te va a sonar bastante, aunque seguro que encuentras alguna diferencia al verlas en Java. Para alguien que no ha programado nunca, un ejemplo sencillo le va a permitir entender qué es eso de las sentencias de control de flujo.
Stockbyte. Uso educativo no comercial para plataformas
públicas de Formación Piensa en un fontanero (programador), principalmente trabaja con agua (datos) y se encarga de hacer que ésta fluya Profesional a distancia. por donde él quiere (programa) a través de un conjunto de tuberías, codos, latiguillos, llaves de paso, etc. (sentencias CD-DVDNum. V43 de control de flujo). Pues esas estructuras de control de flujo son las que estudiaremos, conoceremos su estructura, funcionamiento, cómo utilizarlas y dónde. A través de ellas, al construir nuestros programas podremos hacer que los datos (agua) fluyan por los caminos adecuados para representar la realidad del problema y obtener un resultado adecuado.
flujo de los datos, en cualquier lenguaje, son las siguientes: Los tipos de estructuras de programación que se emplean para el control del flujo de Secuencial: Secuencial: compuestas por 0, 1 o N sentencias que se ejecutan en el orden en que han sido escritas. Es la estructura más sencilla y sobre la que se construirán el resto de estructuras. Es de hecho la que hemos usado en los ejercicios de la tarea de la unidad anterior. Selectiva o condicional: es un tipo de sentencia especial que permite tomar decisiones, depediendo del valor de una condición. Según la evaluación de la condición se generará un resultado (que suele ser verdadero o falso) y en función de éste, se ejecutará una secuencia de instrucciones u otra (que puede ser no ejecutar ninguna instrucción). Las estructuras selectivas (o de selección o condicionales) podrán ser: Selectiva simple. Selectiva compuesta. Selectiva múltiple. Iterativa, repetitiva o cíclica: cíclica: es un tipo de sentencia especial que permite repetir la ejecución de una secuencia o bloque de instrucciones según el resultado de la evaluación de una condición. Es decir, la secuencia de instrucciones se ejecutará repetidamente si la condición arroja un valor correcto, en otro caso la secuencia de instrucciones dejará de ejecutarse, y se pasará a ejecutar la siguiente sentencia detrás del ciclo. salto, que aunque son Además de las sentencias típicas de control de flujo, en esta unidad haremos una revisión de las sentencias de salto, altamente desaconse ables en la ma oría de casos eneralmente resulta innecesario recurrir a ellas es necesario conocerlas.
http://educacionadi st stancia.juntadeandalucia.es/cur so sos/blocks/r ec ecopi la la/r ec ecopil a. a.php?i d= d= 10 10412
1/32
2017-6-2 -6-23 3
educaci cacio onadista istan ncia cia.ju .juntad tadeandalucia lucia.e .es/ s/cu curso rsos/ s/b block locks/ s/re reco cop pila/re ila/reco cop pila.p ila.ph hp?id=1 id=10 0412 ,
,
.
Además, como nuestros programas podrán generar errores y situaciones situaciones especiales, echaremos un vistazo al manejo de excepciones en excepciones en Java. Posteriormente, analizaremos la mejor manera de llevar a cabo las pruebas pruebas de nuestros programas y la depuración de los mismos. Y finalmente, aprenderemos a valorar y utilizar las herramientas de documentación de programas. programas. Vamos entonces a ponernos el mono de trabajo y a coger nuestra caja de herramientas, ¡a ver si no nos mojamos mucho!
2.- Estructura secuencial: sentencias y bloques.
Caso práctico Ada valora Ada valora muy positivamente en un programador el orden y la pulcritud. Organizar correctamente el código fuente es de vital importancia cuando se trabaja en entornos colaborativos, en los que son varios los desarrolladores que forman los equipos de programación. Por ello, incide en la necesidad de recordar a Juan y María María las nociones básicas a la hora de escribir programas.
© Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. CD165
Este epígrafe lo utilizaremos para reafirmar cuestiones que son obvias y que en el transcurso de anteriores unidades se han dado por sabidas. Aunque, a veces, es conveniente recordar. Lo haremos como un conjunto de FAQ: ¿Cómo se escribe un programa sencillo? Si queremos que un programa sencillo realice instrucciones o sentencias para obtener un determinado resultado, es necesario colocar éstas una detrás de la otra, exactamente en el orden en que deben ejecutarse. ¿Podrían colocarse todas las sentencias una detrás de otra, separadas por puntos y comas en una misma línea? Claro que sí, pero no es muy recomendable. Cada sentencia debe estar escrita en una línea, de esta manera tu código será mucho más legible y la localización de errores en tus programas será más sencilla y rápida, lo que redundará en menor tiempo de desarrollo y de mantenimiento, lo que reducirá los costes. De hecho, cuando se utilizan herramientas de programación, los errores suelen asociarse a un número o números de línea. ¿Puede una misma sentencia ocupar varias líneas en el programa? Sí. Existen sentencias que, por su tamaño, pueden generar varias líneas. Pero siempre finalizarán con un punto y coma. ¿En Java todas las sentencias se terminan con punto y coma? Efectivamente. Si detrás de una sentencia ha de venir otra, pondremos un punto y coma. Escribiendo la siguiente sentencia en una nueva línea. Pero en algunas ocasiones, sobre todo cuando utilizamos estructuras de control de flujo, detrás de la cabecera de una estructura de este tipo no debe colocarse punto y coma. No te preocupes, lo entenderás cuando analicemos cada una de ellas. ¿Qué es la sentencia nula en Java? La sentencia nula es una línea que no contiene ninguna instrucción y en la que sólo existe un punto y coma. Como su nombre indica, esta sentencia no hace nada. Se puede colocar en cualquier sitio donde la sintaxis del lenguaje exija que vaya una sentencia, pero no queramos que se haga nada. Normalmente su uso puede evitarse, usando una lógica adecuada al construir las estructuras de control de flujo. ¿Qué es un bloque de sentencias? Es un conjunto de sentencias que se encierra entre llaves y que se ejecutaría como si fuera una única orden. Sirve para agrupar sentencias y para clarificar el código. Los bloques de sentencias son utilizados en Java en la práctica totalidad de estructuras de control de flujo, clases, métodos, etc. La siguiente tabla muestra dos formas de construir un bloque de sentencias. ¿Cuál de las dos crees que es más clara y que por tanto se recomienda usar?
Bloques de sentencias. Bloq Bl oque ue de sen sente tenc ncia iass en una sola lí líne neaa
Bloqu Bl oquee de se sent ntenc encia iass de va vari rias as lí líne neas as
{ sentencia1; sentencia2; …; sentenciaN;
{sentencia1;sentencia2;...;sentenciaN;}
}
En un bloque de sentencias, ¿éstas deben estar colocadas con un orden exacto? En ciertos casos sí, aunque si al final de su ejecución se obtiene el mismo resultado, podrían ocupar diferentes posiciones en nuestro programa. ¿Es importante documentar los programas? Claro que sí. Más adelante veremos que se pueden documentar de diversas formas, pero una de ellas es escribir el código con claridad, usando indentación adecuada de las sentencias, eligiendo nombres descriptivos para variables, métodos y clases, incluyendo comentarios explicativos, etc. ¿Y me tengo que preocupar de las faltas de ortografía y de gramática? Bueno... lo principal es preocuparte de la propia sintaxis del lenguaje para que todo funcione correctamente, eso es cierto. Pero es MUY importante importante que las cadenas literales que se incluyan en el código sean correctas, porque son la primera, y a veces la única impresión que el cliente obtendrá de la aplicación, y si ve faltas de ortografía, difícilmente lo vas a convencer de que al escribir en un lenguaje de programación eres una persona más cuidadosa. Además, parte de la documentación se genera con herramientas automáticas a partir de los comentarios, así que la corrección en los mismos también es fundamental.
Debes conocer Accede a los tres archivos que te ofrecemos a continuación y compara su código fuente. Verás que los tres obtienen el mismo resultado, pero la organización de las sentencias que los componen es diferente entre ellos.
Sentencias, bloques y diferentes organizaciones. Bloque de sentencias para ejecución secuencial.
Bloque de sentencias con declaración de variables.
Sentencias en orden secuencial. (0.01
Sentencias y declaraciones de variables.
(0.01
MB)
Bloque de sentencias con el código organizado en declaración de variables, entrada de datos, procesamiento y salida
Sentencias, declaraciones y organización del código. (0.01 MB)
MB)
En este primer archivo, las sentencias están colocadas en orden secuencial.
En este segundo archivo, se declaran al principio las variables necesarias. En Java no es imprescindible hacerlo así, pero sí que antes de utilizar cualquier variable ésta debe estar previamente declarada. Aunque la declaración de dicha variable puede hacerse en cualquier lugar de nuestro programa.
En este tercer archivo, podrás apreciar que se ha organizado el código en las siguientes partes: declaración de variables, petición de datos de entrada, procesamiento de dichos datos y obtención de la salida. Este tipo de organización está más estandarizada y hace que nuestros programas ganen en legibilidad y claridad.
Construyas de una forma o de otra tus programas, en Java debes tener en cuenta siempre las siguientes premisas: Declara cada variable antes de utilizarla. Inicializa con un valor cada variable la primera vez que la utilices. No es recomendable usar variables no inicializadas en nuestros programas, pueden provocar errores o resultados imprevistos.
http://educacionadi st stancia.juntadeandalucia.es/cur so sos/blocks/r ec ecopi la la/r ec ecopil a. a.php?i d= d= 10 10412
2/32
2017-6-2 -6-23 3
educaci cacio onadista istan ncia cia.ju .juntad tadeandalucia lucia.e .es/ s/cu curso rsos/ s/b block locks/ s/re reco cop pila/re ila/reco cop pila.p ila.ph hp?id=1 id=10 0412 ,
,
.
Además, como nuestros programas podrán generar errores y situaciones situaciones especiales, echaremos un vistazo al manejo de excepciones en excepciones en Java. Posteriormente, analizaremos la mejor manera de llevar a cabo las pruebas pruebas de nuestros programas y la depuración de los mismos. Y finalmente, aprenderemos a valorar y utilizar las herramientas de documentación de programas. programas. Vamos entonces a ponernos el mono de trabajo y a coger nuestra caja de herramientas, ¡a ver si no nos mojamos mucho!
2.- Estructura secuencial: sentencias y bloques.
Caso práctico Ada valora Ada valora muy positivamente en un programador el orden y la pulcritud. Organizar correctamente el código fuente es de vital importancia cuando se trabaja en entornos colaborativos, en los que son varios los desarrolladores que forman los equipos de programación. Por ello, incide en la necesidad de recordar a Juan y María María las nociones básicas a la hora de escribir programas.
© Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. CD165
Este epígrafe lo utilizaremos para reafirmar cuestiones que son obvias y que en el transcurso de anteriores unidades se han dado por sabidas. Aunque, a veces, es conveniente recordar. Lo haremos como un conjunto de FAQ: ¿Cómo se escribe un programa sencillo? Si queremos que un programa sencillo realice instrucciones o sentencias para obtener un determinado resultado, es necesario colocar éstas una detrás de la otra, exactamente en el orden en que deben ejecutarse. ¿Podrían colocarse todas las sentencias una detrás de otra, separadas por puntos y comas en una misma línea? Claro que sí, pero no es muy recomendable. Cada sentencia debe estar escrita en una línea, de esta manera tu código será mucho más legible y la localización de errores en tus programas será más sencilla y rápida, lo que redundará en menor tiempo de desarrollo y de mantenimiento, lo que reducirá los costes. De hecho, cuando se utilizan herramientas de programación, los errores suelen asociarse a un número o números de línea. ¿Puede una misma sentencia ocupar varias líneas en el programa? Sí. Existen sentencias que, por su tamaño, pueden generar varias líneas. Pero siempre finalizarán con un punto y coma. ¿En Java todas las sentencias se terminan con punto y coma? Efectivamente. Si detrás de una sentencia ha de venir otra, pondremos un punto y coma. Escribiendo la siguiente sentencia en una nueva línea. Pero en algunas ocasiones, sobre todo cuando utilizamos estructuras de control de flujo, detrás de la cabecera de una estructura de este tipo no debe colocarse punto y coma. No te preocupes, lo entenderás cuando analicemos cada una de ellas. ¿Qué es la sentencia nula en Java? La sentencia nula es una línea que no contiene ninguna instrucción y en la que sólo existe un punto y coma. Como su nombre indica, esta sentencia no hace nada. Se puede colocar en cualquier sitio donde la sintaxis del lenguaje exija que vaya una sentencia, pero no queramos que se haga nada. Normalmente su uso puede evitarse, usando una lógica adecuada al construir las estructuras de control de flujo. ¿Qué es un bloque de sentencias? Es un conjunto de sentencias que se encierra entre llaves y que se ejecutaría como si fuera una única orden. Sirve para agrupar sentencias y para clarificar el código. Los bloques de sentencias son utilizados en Java en la práctica totalidad de estructuras de control de flujo, clases, métodos, etc. La siguiente tabla muestra dos formas de construir un bloque de sentencias. ¿Cuál de las dos crees que es más clara y que por tanto se recomienda usar?
Bloques de sentencias. Bloq Bl oque ue de sen sente tenc ncia iass en una sola lí líne neaa
Bloqu Bl oquee de se sent ntenc encia iass de va vari rias as lí líne neas as
{ sentencia1; sentencia2; …; sentenciaN;
{sentencia1;sentencia2;...;sentenciaN;}
}
En un bloque de sentencias, ¿éstas deben estar colocadas con un orden exacto? En ciertos casos sí, aunque si al final de su ejecución se obtiene el mismo resultado, podrían ocupar diferentes posiciones en nuestro programa. ¿Es importante documentar los programas? Claro que sí. Más adelante veremos que se pueden documentar de diversas formas, pero una de ellas es escribir el código con claridad, usando indentación adecuada de las sentencias, eligiendo nombres descriptivos para variables, métodos y clases, incluyendo comentarios explicativos, etc. ¿Y me tengo que preocupar de las faltas de ortografía y de gramática? Bueno... lo principal es preocuparte de la propia sintaxis del lenguaje para que todo funcione correctamente, eso es cierto. Pero es MUY importante importante que las cadenas literales que se incluyan en el código sean correctas, porque son la primera, y a veces la única impresión que el cliente obtendrá de la aplicación, y si ve faltas de ortografía, difícilmente lo vas a convencer de que al escribir en un lenguaje de programación eres una persona más cuidadosa. Además, parte de la documentación se genera con herramientas automáticas a partir de los comentarios, así que la corrección en los mismos también es fundamental.
Debes conocer Accede a los tres archivos que te ofrecemos a continuación y compara su código fuente. Verás que los tres obtienen el mismo resultado, pero la organización de las sentencias que los componen es diferente entre ellos.
Sentencias, bloques y diferentes organizaciones. Bloque de sentencias para ejecución secuencial.
Bloque de sentencias con declaración de variables.
Sentencias en orden secuencial. (0.01
Sentencias y declaraciones de variables.
(0.01
MB)
Bloque de sentencias con el código organizado en declaración de variables, entrada de datos, procesamiento y salida
Sentencias, declaraciones y organización del código. (0.01 MB)
MB)
En este primer archivo, las sentencias están colocadas en orden secuencial.
En este segundo archivo, se declaran al principio las variables necesarias. En Java no es imprescindible hacerlo así, pero sí que antes de utilizar cualquier variable ésta debe estar previamente declarada. Aunque la declaración de dicha variable puede hacerse en cualquier lugar de nuestro programa.
En este tercer archivo, podrás apreciar que se ha organizado el código en las siguientes partes: declaración de variables, petición de datos de entrada, procesamiento de dichos datos y obtención de la salida. Este tipo de organización está más estandarizada y hace que nuestros programas ganen en legibilidad y claridad.
Construyas de una forma o de otra tus programas, en Java debes tener en cuenta siempre las siguientes premisas: Declara cada variable antes de utilizarla. Inicializa con un valor cada variable la primera vez que la utilices. No es recomendable usar variables no inicializadas en nuestros programas, pueden provocar errores o resultados imprevistos.
http://educacionadi st stancia.juntadeandalucia.es/cur so sos/blocks/r ec ecopi la la/r ec ecopil a. a.php?i d= d= 10 10412
2/32
2017-6-2 -6-23 3
educaci cacio onadista istan ncia cia.ju .juntad tadeandalucia lucia.e .es/ s/cu curso rsos/ s/b block locks/ s/re reco cop pila/re ila/reco cop pila.p ila.ph hp?id=1 id=10 0412
Autoevaluación Indica qué afirmación es la más correcta: Para crear un bloque de sentencias, es necesario delimitar éstas entre llaves. Este bloque funcionará como si hubiéramos colocado una única orden. La sentencia nula en Java, se puede representar con un punto y coma sólo en una única línea. Para finalizar en Java cualquier sentencia, es necesario hacerlo con un punto y coma. Todas las afirmaciones son correctas.
3.- Estructuras de selección o condicionales.
Caso práctico Juan está desarrollando un método en el que ha de comparar los valores de las entradas de un usuario y una contraseña introducidas desde el teclado, con los valores almacenados en una base de datos. Para poder hacer dicha comparación necesitará utilizar una estructura condicional que le permita llevar a cabo esta operación, incluso necesitará que dicha estructura condicional sea capaz de decidir qué hacer en función de si ambos valores son correctos o no.
Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. CD109
Al principio de la unidad nos hacíamos hacíamos esta pregunta: pregunta: ¿Cómo un programa puede determinar la aparición en pantalla de un mensaje de ÉXITO o ERROR, según los datos de entrada aportados por un usuario? Ésta y otras preguntas se nos plantean en múltiples ocasiones cuando desarrollamos programas. ¿Cómo conseguimos que nuestros programas puedan tomar decisiones? Para comenzar, lo haremos a través de las estructuras de selección. selección. Estas estructuras constan de una condición condición que se evalúa para ver si toma el valor verdadero o falso, y de un conjunto de secuencias de instrucciones, que se ejecutarán o no dependiendo de si la condición se evaluó como verdadera o como falsa. Puede haber dos bloques de instrucciones, de forma que si es verdadera la condición se ejecuta el primer bloque y si es falsa, se ejecuta el otro bloque. 5 (condición verdadera) se imprime por pantalla la palabra APROBADO Por ejemplo, si el valor de una variable es mayor o igual que 5 SUSPENSO (segundo grupo de (primer grupo de sentencias, en este caso una sola) y si es menor que 5 (condición falsa) se imprime SUSPENSO sentencias, también con una sola en este caso). Para este ejemplo, la comprobación del valor de la variable será lo que nos permite decidir qué camino tomar y cuál es la siguiente instrucción a ejecutar. La impresión de la palabra APROBADO será una secuencia de instrucciones y la impresión de la palabra SUSPENSO será otra. Cada secuencia estará asociada a cada uno de los resultados que puede arrojar la evaluación de la condición.
Curiosidad En el lenguaje de programación C, verdadero o falso se representan mediante un literal entero. 0 representará Falso y 1 o cualquier otro valor, representará Verdadero. Como sabes, en Java las variables de tipo booleanosólo podrán tomar los valores true (verdadero) o false (falso). La evaluación de las condiciones o expresiones que controlan las estructuras de selección, devolverán siempre un valor verdadero o falso.
Las estructuras de selección se dividen en: Estructura de selección de selección simple simple o estructura if. Estructura de selección compuesta compuesta o estructura if-else. if-else. Estructura de selección basada en el operador condicional, representado en Java por Estructura de selección múltiple múltiple o estructura switch. switch.
?.
A continuación, detallaremos detallaremos las características y funcionamiento ento de cada una de ellas. Es importante que a través de los ejemplos que vamos a ver, puedas determinar en qué circunstancias utilizar cada una de estas estructuras. Aunque un mismo problema puede ser resuelto con diferentes estructuras, e incluso, con diferentes combinaciones de éstas. Marcin Wichary
3.1.- Estructura selectiva simple y selectiva compuesta: compuesta: if / if-else. selectiva, (o estructura de selección o selección o estructura condicional, condicional, ya La estructura if es una estructura selectiva, (o que se suele llamar de las tres formas) se refiere a la posibilidad de que al comprobar una condición podamos tomar dos caminos alternativos, dependiendo de si la condición se evaluó como verdadera o como falsa. La representación en diagrama de flujo sería la de la imagen de la derecha, que es bastante explicativa: Si la expresión que se evalúa es verdadera, se ejecuta la secuencia de instrucciones 1. Si es falsa, se ejecuta la secuencia de instrucciones 2. Esta rama, a veces, puede no contener ninguna sentencia a ejecutar. En ambos casos, el flujo continúa con la siguiente sentencia que haya tras esta estructura condicional. En pseudocódigo, eso se expresaría como:
http://educacionadi st stancia.juntadeandalucia.es/cur so sos/blocks/r ec ecopi la la/r ec ecopil a. a.php?i d= d= 10 10412
3/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 Estructura if e if-else en pseudocódigo
Estructura condicional simple.(Si-entonces)
Estructura condicional de doble alternativa. (Si-entonces-Si no).
Si expresion entonces secuencia1 Si-no secuencia2
Si expresion entonces secuencia1 Fin-si
Fin-si
Funcionamiento: La secuencia de instrucciones secuencia1 se ejecuta si y solo si en el caso de que la expresion se evalúe como verdadera. No se hace nada en caso contrario, simplemente "se omite" la ejecución de secuencia1.
Funcionamiento: Si expresion es evaluada como verdadera, se ejecuta secuencia1 y en caso contrario, no se ejecuta secuencia1 y sí se ejecuta secuencia2.
Fíjate que la palabra entonces se pone para delimitar con claridad dónde termina la expresión que se va a evaluar y dónde empieza la secuencia de instrucciones del primer bloque. En la la parte Si-no no es necesario, ya que esa misma etiqueta delimita el final del primer bloque de instrucciones y el comienzo del segundo. En cualquier caso, siempre es necesario poner un Fin-si que delimite dónde acaba la sentencia condicional, bien sea delimitando el final del único bloque de sentencias en el condicional simple o bien delimitando el segundo La estructura if puede presentarse en Java de las siguientes formas:
Estructura if e if-else en Java Estructura if de doble alternativa ( o if-else).
Estructura if simple. Sintaxis para el caso de ejecución condicional de una sola rama con una sola sentencia
Sintaxis para el caso de ejecución condicional de una sola rama con un bloque de sentencias
Sintaxis para el caso de ejecución condicional de dos ramas y una sola sentencia en cada rama
Sintaxis para el caso de ejecución condicional de dos ramas y un bloque de sentencias en cada rama
if (expresion_logica){ sentencia1; if
(expresion_logica){ sentencia1; sentencia2;
if (expresion_logica)
if (expresion_logica) sentencia1; else sentencia2;
…; sentenciaN;
sentencia1;
…; sentenciaN; }else{ sentencia1; …; sentenciaN;
} }
Funcionamiento: Si la evaluación de la expresion_logica ofrece un resultado verdadero, se ejecuta la sentencia1 o bien el bloque de sentencias asociado. Si el resultado de dicha evaluación es falso, no se ejecutará ninguna instrucción asociada a la estructura condicional.
Funcionamiento: Si la evaluación de la expresion_logica ofrece un resultado verdadero, se ejecutará la primera sentencia o el primer bloque de sentencias. Si, por el contrario, la evaluación de la expresion_logica ofrece un resultado falso, no se ejecutará la primera sentencia o el primer bloque y sí se ejecutará la segunda sentencia o el segundo bloque.
Algunas consideraciones más a tener en cuenta en Java: La cláusula else de la sentencia if no es obligatoria. En algunos casos no necesitaremos utilizarla, pero sí se recomienda cuando es necesario llevar a cabo alguna acción en el caso de que la expresión lógica no se cumpla. En aquellos casos en los que no existe cláusula else, si la expresión lógica es falsa, simplemente se continuarán ejecutando las siguientes sentencias que aparezcan bajo la estructura condicional if . Los condicionales if e if-else pueden anidarse, de tal forma que dentro de un bloque de sentencias puede incluirse otro if o if-else. El nivel de anidamiento queda a criterio del programador, pero si éste es demasiado profundo podría provocar problemas de eficiencia y legibilidad en el código. En otras ocasiones, un nivel de anidamiento excesivo puede denotar la necesidad de utilización de otras estructuras de selección más adecuadas. Cuando se utiliza anidamiento de este tipo de estructuras, es necesario poner especial atención en saber a qué if está asociada una cláusula else. Normalmente, un else estará asociado con el if inmediatamente superior o más cercano que exista dentro del mismo bloque y que no se encuentre ya asociado a otro else.
Ejercicio Resuelto Vamos a representar en pseudocódigo un programa que realiza el cálculo de la nota de un examen de tipo test. Además de calcular el valor de la nota, se ofrece como salida la calificación no numérica de dicho examen. Para obtenerla, se combinarán las diferentes estructuras condicionales aprendidas hasta ahora. Mostrar retroalimentación
Para completar la información que debes saber sobre las estructuras if e pseudocódigo anterior.
, falta ver cómo se plasma en Java el
if-else
Mostrar retroalimentación
Recomendación Buena práctica de programación Utiliza la sangría en ambos cuerpos de una estructura if-else. Si hay varios niveles de sangría, en cada nivel debe aplicarse la misma cantidad de espacio adicional. Colocar siempre las llaves en una instrucción if-else (o cualquier estructura de control) ayuda a evitar que se omitan de manera accidental, en especial, cuando posteriormente se agregan instrucciones a una cláusula if o else. Para evitar que esto suceda, algunos programadores prefieren escribir la llave inicial y final de los bloques antes de escribir las instrucciones individuales dentro de ellas. Errores de programación Olvidar una o las dos llaves que delimitan un bloque puede provocar errores de sintaxis o errores lógicos en unprograma. Colocar un punto y coma después de la condición en una instrucción if-else produce un error lógico en las instrucciones if de selección simple, y un error de sintaxis en las instrucciones if-else de selección doble (cuando la parte del if contiene una instrucción en el cuerpo).
Autoevaluación ¿Cuándo se mostrará por pantalla el mensaje incluido en el siguiente fragmento de código? if (numero % 2 == 0); System.out.print("El número es par");
Nunca. Siempre. Cuando el resto de la división entre 2 del contenido de la variable numero, sea cero.
http://educacionadi stancia.juntadeandalucia.es/cur sos/blocks/r ecopi la/r ecopil a.php?i d= 10412
4/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
3.2.- Estructura selectiva múltiple: switch. ¿Qué podemos hacer cuando nuestro programa debe elegir entre más de dos alternativas?
Una posible solución podría ser emplear estructuras if anidadas, aunque no siempre esta solución es la más eficiente, porque en caso de que las sucesivas condiciones que se van evaluando sean falsas, puede ser necesario comprobar todas antes de saber con seguiridad en qué caso nos encontramos. ¿No sería deseable que con una sola comprobación pudiéramos ir directamente al caso apropiado y ejecutar las instrucciones que lleve asociadas? Desde luego que sí, esto sería más eficiente, y en algunos casos es posible. Cuando estamos ante estas situaciones podemos utilizar la estructura de selección múltiple, que en Java es la sentencia switch.
Autoevaluación Indica para cada afirmación si es verdadera o falsa. La estructura tipo switch resulta imprescindible en cualquier lenguaje, ya que de lo contrario no se podrían tomar decisiones que implican la posibilidad de seguir por más de dos caminos. Verdadero
Falso
La estructura tipo switch es más eficiente que para resolver un problema con múltiples posibilidades, que el uso de estructuras if/else anidadas para resolver ese mismo problema. Verdadero
Falso
3.2.1.- Estructura switch en pseudocódigo. Pero veamos primero cómo se representaría esta estructura en pseudocódigo.
Pseudocódigo para la estructura selectiva múltiple (Según-sea) Representación en pseudocódigo
Ejemplo en pseudocódigo Veamos cómo quedaría el pseudocódigo para el ejemplo de las calificaciones del examen tipo test. Sólo incluimos la parte final de procesamiento de datos, ya que todo lo anterior es idéntico y destacamos en negro lo que no se corresponde con la sentencia selectiva múltiple.
Según-sea(expresion) Caso valor1: sentencia1_1; sentencia1_2;
Programa Sentencias_condicionales ... /*Procesamiento de datos*/ nota <-- ((numeroAciertos - (numeroErrores/2))*10)/numeroPreguntas Según-Sea (nota) Caso 0 a 4:
…. Caso valor2: sentencia2_1;
calificacion <--"INSUFICIENTE" Caso 5: calificacion<-- "SUFICIENTE"
sentencia2_2; ….
Caso ….
Caso 6: calificacion <-- "BIEN" Caso 7 a 8: calificacion <-- "NOTABLE"
Caso valorN: sentenciaN1; sentenciaN2; …. [Otros-casos: sentenciaOC1;
sentenciaOC2;] Fin-según
Caso 9 a 10: calificacion <-- "SOBRESALIENTE" Otros-casos: escribir("Se ha introducido una calificación errónea.") calificacion <-- "CALIFICACIÓN ERRÓNEA" Fin-según ...
Fin
Funcionamiento: Comenzamos evaluando la expresión que aparece detrás de Según-sea y que queda delimitada por el propio Según-sea y por el comienzo de la primera etiqueta de un caso posible. Cada uno de los casos posibles comenzará con la etiqueta Caso y podrá ser un valor sin más, seguido de dos puntos (Por ejemplo: Caso 5: ) o un rango de valores seguido de dos puntos (Por ejemplo: Caso 0 a 4:). El valor obtenido de evaluar la expresión, que en principio puede ser de cualquier tipo discreto y ordenado (enteros, cadenas de caracteres...), lo comparamos con los valores o rangos de valores que situamos como etiquetas de los distintos casos que se pueden dar. Se va directamente a ejecutar las sentencias de aquella etiqueta con la que coincida o en cuyo rango esté incluido el valor. Las sentencias que hay que ejecutar en caso de entrar en una etiqueta de un caso concreto, son todas las que haya hasta la próxima etiqueta Caso. Si el valor no coincidiera con ninguna etiqueta ni estuviera incluido en el rango establecido por ninguna, se pasaría a la etiqueta Otros-casos, que es opcional y (podrá no aparecer si no hay otros " "
http://educacionadi stancia.juntadeandalucia.es/cur sos/blocks/r ecopi la/r ecopil a.php?i d= 10412
5/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
, según que además pone fin a la sentencia de selección múltiple. Tras haber entrado en cualquier etiqueta Caso o en Otros-casos y haber ejecutado las sentencias que contenga, el control del flujo saltará a la siguiente sentencia que haya después del
Fin-según.
Quizás esta sentencia es la que más diferencias y particularidades presenta para distintos lenguajes de programación, por lo que el pseudocódigo, que intenta siempre no entrar en los detalles de sintaxis del lenguaje, puede resultarte bastante distinto a la sintaxis de Java, pero el planteamiento sigue siendo el mismo: evaluamos una expresión, y según su valor, cogemos directamente el camino que marca una de las etiquetas que identifican cada uno de los casos posibles, según ese valor, y se ejecutan las sentencias.
Autoevaluación Para la estructura tipo switch, el último caso que debe incluirse es siempre la etiqueta Otros-casos, ya que debe indicarse expresamente al compilador qué debe hacer ante cualquier valor resultante de evaluar la expresión distinto de los contemplados en las etiquetas anteriores. De lo contrario, se produciría una indefinición, que provocaría que el programa abortara si se presentara cualquier otro caso no previsto expresamente con alguna etiqueta asociada a las instrucciones a ejecutar. Verdadero
Falso
3.2.2.- Estructura switch en Java. En la siguiente tabla se muestra tanto la sintaxis, como el funcionamiento de esta estructura en el lenguaje Java.
Estructura selectiva múltiple en Java. (switch.) Sintaxis
Condiciones
switch (expresion){ case valor1: sentencia1_1; sentencia1_2; …; break; case valor2: sentencia2_1; sentencia2_2; …;
…;
break;
case valorN: sentenciaN1; sentenciaN2; …;
Donde expresión debe ser del tipo char , byte, short o int, y las constantes de cada case deben ser de este tipo o de un tipo compatible. Sólo desde la versión 7 del lenguaje Java se permiten expresiones de tipo String en la expresión, pero esto no funcionará con versiones anteriores del lenguaje. La expresión debe ir entre paréntesis. Cada case llevará asociado un valor y se finalizará con dos puntos ( :). El bloque de sentencias asociado a la cláusula default puede finalizar con una sentencia de ruptura break o no. No hay diferencia de funcionamiento. Se permite por mantener la estructura de las demás etiquetas, pero el compilador no lo necesita si el default va al final, tal y como se ve en el código, puesto que la llave de cierre delimita el final del switch.
break; default: sentencias-default; }
Funcionamiento: Las diferentes alternativas de esta estructura estarán precedidas de la cláusula el valor obtenido al evaluar la expresión del switch.
case que se ejecutará cuando el valor asociado al case coincida con
http://educacionadi stancia.juntadeandalucia.es/cur sos/blocks/r ecopi la/r ecopil a.php?i d= 10412
6/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
, , programación sí lo permiten). Habrá que asociar una cláusula case a cada uno de los valores que deban ser tenidos en cuenta. La cláusula default será utilizada para indicar un caso por defecto (cualquier otro caso no contemplado en las cláusulas case, en realidad), las sentencias asociadas a la cláusula default se ejecutarán si ninguno de los valores indicados en las cláusulas case coincide con el resultado de la evaluación de la expresión de la estructura switch. La cláusula default puede no existir, y por tanto, si ningún case ha sido activado finalizaría el switch. Cada cláusula case puede llevar asociadas una o varias sentencias, sin necesidad de delimitar dichos bloques por medio de llaves. En el momento en el que el resultado de la evaluación de la expresión coincide con alguno de los valores asociados a las cláusulas case, se ejecutarán todas las instrucciones asociadas hasta la aparición de una sentencia break de ruptura (la sentencia break se analizará en epígrafes posteriores). Esto hace que si en una cláusula case no se incluye un break para finalizarla, al entrar en esa cláusula, se producirá un " efecto en cascada", de forma que seguirá ejecutando las sentencias de la siguiente cláusula case, y así sucesivamente las de todas las que sigan, hasta que en alguna encuentre una sentencia break, o hasta que alcance el final de la sentencia. Esto puede ser aprovechado para darle más versatilidad a la sentencia switch, y hacer algo parecido a los rangos que sí permiten otros lenguajes, aunque sea de una forma "no muy limpia". En resumen, se ha de comparar el valor de una expresión con un conjunto de valores constantes, si el valor de la expresión coincide con alguno de los valores constantes contemplados, se ejecutarán los bloques de instrucciones asociados al mismo. Si no existiese coincidencia, se podrán ejecutar una serie de instrucciones por defecto, si se ha incluido la cláusula default, o se saltará a la sentencia siguiente a esta estructura selectiva (tras la llave de cierre) si no se ha incluido esa cláusula.
Ejercicio Resuelto Accede al siguiente fragmento de código en el que se resuelve el cálculo de la nota de un examen de tipo test, utilizando la estructura switch. Mostrar retroalimentación
Recomendación Error común de programación Olvidar una instrucción break cuando se necesita en una instrucción switch es un error lógico.
Para saber más Una explicación bastante buena de la sentencia switch en Java puedes encontrarla en el siguiente enlace: Sentencia switch en Java Una web con algunos ejemplos típicos de uso de la sentencia switch en Java: Ejemplos de ejercicios resueltos en Java usando switch
4.- Estructuras repetitivas, iterativas o cíclicas.
Caso práctico Juan ya tiene claro cómo realizar la comprobación de los valores de usuario y contraseña introducidos por teclado, pero le surge una duda: ¿Cómo podría controlar el número de veces que el usuario ha introducido mal la contraseña? Ada le indica que podría utilizar una estructura de repetición que solicitase al usuario la introducción de la contraseña hasta un máximo de tres veces. Aunque comenta que puede haber múltiples soluciones y todas válidas, lo importante es conocer las herramientas que podemos emplear y saber cuándo aplicarlas. Stockbyte. Uso educativo no comercial para plataformas públicas de
http://educacionadi stancia.juntadeandalucia.es/cur sos/blocks/r ecopi la/r ecopil a.php?i d= 10412
7/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
Formación Profesional a distancia. CD-DVDNum. V43
Nuestros programas ya son capaces de controlar su ejecución teniendo en cuenta determinadas condiciones, pero aún hemos de aprender un conjunto de estructuras que nos permita repetir una secuencia de instrucciones determinada hasta que se consiga un determinado objetivo o hasta que se cumpla una determinada condición. La función de estas estructuras repetitivas es repetir la ejecución de una serie de instrucciones teniendo en cuenta una condición. A este tipo de estructuras se las denomina estructuras de repetición, estructuras repetitivas, bucles o estructuras iterativas. En Java existen cuatro clases de bucles: Bucle for (Repite para). Bucle for/in (Repite para cada). Bucle While (Repite mientras). Bucle Do While (Repite hasta). Los bucles for y for/in se consideran bucles controlados por controlados por sucesos.
HuBoro
contador . Por el contrario, los bucles while y
se consideran bucles
do...while
La utilización de unos bucles u otros para solucionar un problema dependerá en gran medida de las siguientes preguntas: ¿Sabemos a priori cuántas veces necesitamos repetir un conjunto de instrucciones? ¿Sabemos si hemos de repetir un conjunto de instrucciones si una condición satisface un conjunto de valores? ¿Sabemos hasta cuándo debemos estar repitiendo un conjunto de instrucciones? ¿Sabemos si hemos de estar repitiendo un conjunto de instrucciones mientras se cumpla una condición? ¿Sabemos si esas instrucciones se deben ejecutar siempre, al menos una primera vez, con independencia del resultado de evaluar la condición que controla el bucle? Éstas y otras preguntas tendrán su respuesta en cuanto analicemos cada una de las estructuras repetitivas en detalle.
Recomendación Estudia cada tipo de estructura repetitiva, conoce su funcionamiento y podrás llegar a la conclusión de que algunos de estos bucles son equivalentes entre sí . Un mismo problema, podrá ser resuelto empleando diferentes tipos de bucles y obtener los mismos resultados. De hecho, sería posible resolver cualquier problema si sólo contáramos con una estructura de control repetitiva (un único tipo de bucle), pudiendo ser cualquiera de ellos. No obstante, según el tipo de problema, disponer de varios tipos podrá permitirnos construir soluciones más simples y claras, lo que siempre resulta muy deseable.
4.1.- Estructura repetitiva tipo for. Hemos indicado anteriormente que el bucle for es un bucle controlado por contador . ¿Recuerdas lo que eso significaba? Este tipo de bucle tiene las siguientes características: Se ejecuta un número determinado de veces. Utiliza un contador (una variable usada como contador) que controla las iteraciones que se van haciendo del bucle. En general, existen tres operaciones que se llevan a cabo sobre la variable contador que controla la ejecución en este tipo de bucles: Se inicializa la variable contador. Se evalúa el valor de la variable contador, por medio de una comparación de su valor con el número de iteraciones especificado para saber si hay que continuar con otra nueva iteración. Se actualiza con incrementos o decrementos el valor del contador, en cada una de las iteraciones.
Aspectos importantes: La inicialización del contador debe realizase correctamente para hacer posible que el bucle se ejecute al menos la primera repetición de su código interno, aunque puede haber casos en los que no queramos ejecutarlo ninguna vez si la condición es de partida falsa. La condición de terminación del bucle es importante establecerla cuidadosamente, ya que si no, podemos caer en la creación de un bucle infinito, cuestión que se debe evitar por todos los medios. Es necesario estudiar el número de veces que se repite el bucle, pues debe ajustarse al número de veces estipulado.
Autoevaluación Rellena los huecos con la palabra adecuada. En la estructura repetitiva tipo for lo primero que debe hacerse es una correcta de la variable contador que controla la ejecución del bucle, luego se el valor de la variable para comprobar si se ha alcanzado el número de que deben realizarse, o si por el contrario debe realizar una nueva . Finalmente, como último paso de cada iteración, se el valor de la variable mediante sentencias de o . Es importante que el contador se actualice modificando su valor para que en algún momento se alcance la de del bucle, ya que de lo contrario podríamos caer en un ,que debe evitarse a toda costa. Enviar
http://educacionadi stancia.juntadeandalucia.es/cur sos/blocks/r ecopi la/r ecopil a.php?i d= 10412
8/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
4.1.1.- Estructura tipo for en pseudocódigo. ¿Cómo podemos representar en pseudocódigo esta estructura de control repetitiva tipo for?
Ya sabes que en pseudocódigo, lo que prima es la claridad, y que mientras eso se cumpla, es cuestión de expresar las cosas de forma que se evite cualquier ambigüedad. Una posible representación, que consigue ese objetivo sería la proporcionada en la tabla siguiente:
Pseudocódigo para la estructura repetitiva tipo for Representación en pseudocódigo
Ejemplo en pseudocódigo Veamos cómo quedaría el pseudocódigo para el ejemplo que permite representar en pantalla la tabla del 7. Se presenta en gris atenuado todo el código, salvo el de la estructura del bucle for. Programa RepetitivaTipoFor /* En este ejemplo se utiliza la estructura repetitiva for * para representar en pantalla la tabla de multiplicar del siete */ Inicio // Declaración de variables numero, contador, resultado: entero // Inicialización de variables numero <-- 7 resultado <-- 0
Se ponen en negrita las variables y valores que cambiarán, y sin negrita las partes de la estructura que serían fijas. //Salida de información Escribir ("Tabla de multiplicar del " , numero) Escribir (".............................. ")
Para variableContador <-- valorInicial Hasta valorFinal Paso incremento
Hacer acciones Fin-para
/* * Utilizamos ahora el bucle tipo for. * Lacabecera del bucle incorpora la inicialización de lavariable * decontrol, la condición de salida, que implica llegar multiplicando * hasta el 10 y el incremento (Paso) de dicha variable de uno en uno en * cada iteración del bucle. En este caso contador incrementará en una * unidad el valor de dicha variable. */ Para contador <--1 Hasta 10Paso 1 Hacer resultado <-- contador * numero Escribir(numero , " x " , contador , " = " , resultado);
Fin-para Fin
Funcionamiento: Primero se inicializa la variable de control del bucle (variableContador) asignándole el valor valorInicial. Fin-Para. Se comprueba si variableContador es menor o igual que valorFinal, y si es así, se pasa a ejecutar las acciones que hay en el cuerpo del bucle, entre Hacer y Al terminar la iteración, automáticamente se incrementa el valor de variableContador en la cantidad que se indique como paso, indicada por incremento, antes de volver al paso anterior para volver a comprobar si sigue sin haberse alcanzado valorFinal, y por tanto, si debe realizarse otra nueva iteración.
4.1.2.- Estructura tipo for en Java. En la siguiente tabla, podemos ver la especificación para el lenguaje Java de la estructura for:
Estructura repetitiva for . Sintaxis
Funcionamiento
Estructura for con una única sentencia: for (inicialización ; condición ; incremento) sentencia;
Donde inicialización es una expresión en la que se inicializa una variable de control, que será la encargada de controlar el final del bucle. Donde condición es una expresión que evaluará la variable de control. Mientras la condición sea verdadera, el cuerpo del bucle estará repitiéndose. Cuando la condición deje de cumplirse, terminará la ejecución del bucle. Donde incremento indica la manera en la que la variable de control va cambiando en cada iteración del bucle. Podrá ser en realidad, mediante incremento o decremento, y no solo de uno en uno.
Estructura for con un bloque de sentencias: for (inicialización ; condición ; incremento){ sentencia1; sentencia2; ...; sentenciaN; }
Debes conocer Como venimos haciendo para el resto de estructuras, accede al siguiente archivo Java y podrás analizar un ejemplo del pseudocódigo del apartado anterior, que contenía la utilización del bucle for para la impresión por pantalla de la tabla de multiplicar del 7. Lee atentamente los comentarios incluidos en el código, pues aclaran algunas cuestiones interesantes sobre este bucle. Uso la estructura repetitiva for.
(0.01 MB)
Autoevaluación Cuando construimos la cabecera de un bucle for, podemos prescindir de alguno de los tres elementos que la forman e incluso, podemos utilizar más de una variable contadora separando éstas por comas. Pero, ¿qué conseguiremos si construimos un bucle de la siguiente forma? for (;;){ //instrucciones }
Un bucle infinito. Nada, dará un error.
http://educacionadi stancia.juntadeandalucia.es/cur sos/blocks/r ecopi la/r ecopil a.php?i d= 10412
9/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 Un bucle que se ejecutaría una única vez.
Recomendación Error común de programación Utilizar un operador relacional incorrecto o un valor final incorrecto de un contador de ciclo en la condición de continuación de ciclo de una instrucción de repetición puede producir un error por desplazamiento en 1. Utilizar comas en vez de los dos signos de punto y coma requeridos en el encabezado de una instrucción for es un error de sintaxis. Cuando se declara la variable de control de una instrucción for en la sección de inicialización del encabezado del for, si se utiliza la variable de control fuera del cuerpo for se produce un error de compilación. Colocar un punto y coma inmediatamente a la derecha del paréntesis derecho del encabezado de un for convierte el cuerpo de ese for en una instrucción vacía. Por lo general, se trata de un error lógico. No utilizar el operador relacional apropiado en la condición de continuación de un ciclo que cuente en forma regresiva (como usar i <= 1 en lugar de i >= 1 en un ciclo que cuente en forma regresiva hasta llegar a 1) es generalmente un error lógico. Buena práctica de programación Utilizar el valor final en la condición de una instrucción de una instrucción for (o while) con el operador relacional <= nos ayuda a evitar errores por desplazamiento en 1. Por ejemplo, para un ciclo que imprime valores del 1 al 10, la condición de continuación del ciclo debe ser contador <= 10, en vez de contador < 10 (lo cual produce un error por desplazamiento en uno) o contador < 11 (que es correcto). Muchos programadores prefieren el llamado conteo con base 0, en el cual para contar 10 veces, contador se inicializaría a cero y la prueba de continuación del ciclo sería contador < 10. Limita el tamaño de los encabezados de las instrucciones de control a una sola línea, si es posible. Notas para prevenir errores Los ciclos infinitos ocurren cuando la condición de continuación del ciclo en una instrucción de repetición nunca se vuelve false. Para evitar esta situación en un ciclo controlado por un contador, debes asegurarte que la variable de control se incremente (o decremente) durante cada iteración del ciclo.
4.2.- Estructura repetitiva for/in. Junto a la estructura for, tenemos la estructura for/in que también se considera un bucle controlado por contador. Este bucle es una mejora incorporada desde la versión 5.0. de Java, por lo que no funcionará en versiones más antiguas del lenguaje. Este tipo de bucles permite realizar recorridos sobre arrays y colecciones de objetos. Los arrays son colecciones de variables que tienen el mismo tipo y se referencian por un nombre común junto a un índice que indica el lugar que ocupa el elemento dentro del array. Así mismo, las colecciones son recopilaciones de objetos que se dice son iterables, es decir, que se puede iterar sobre ellas. Una colección es también en sí misma un objeto. Este bucle es nombrado también como bucle for mejorado, o bucle foreach (para cada). En otros lenguajes de programación existen bucles muy parecidos a éste. No es sustancialmente diferente en lo básico a cualquier otra estructura tipo for, salvo por el hecho de que conceptualmente, para decidir si hay que hacer otra interacción más, en lugar de preguntarse "¿he hecho ya todas las iteraciones?", en la estructura for/in se hace una pregunta del tipo " ¿he procesado ya todos los elementos existentes en el array o la colección?". Es por ello que prescindimos de presentar una representación específica en pseudocódigo para la estructura for/in. . La sintaxis en Java es la siguiente : for (declaración : expresión) { sentencia_1; … sentencia_N; }
Donde expresión es un array o una colección de objetos. Donde declaración es la declaración de una variable cuyo tipo sea compatible con expresión. Normalmente, será el tipo y el nombre de la variable a declarar. El funcionamiento consiste en que para cada elemento de la expresión, guarda el elemento en la variable declarada y realiza las instrucciones contenidas en el bucle. Después, en cada una de las iteraciones del bucle tendremos en la variable declarada el elemento actual de la expresión. Por tanto, para el caso de los arrays y de las colecciones de objetos, se recorrerá desde el primer elemento que los forma hasta el último. Observa el contenido del código representado en la siguiente imagen, puedes apreciar cómo se construye un bucle de este tipo y su utilización sobre un array. Ejemplo de uso de for/in
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
10/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
Descripción: código de la imagen de ejemplo usando for/in
Los bucles for/in permitirán al programador despreocuparse del número de veces que se ha de iterar, pero no sabremos en qué iteración nos encontramos salvo que se añada artificialmente alguna variable que actúe como contador para que nos pueda ofrecer esta información.
Autoevaluación Completa los huecos con la palabra adecuada. La estructura for/in se puede usar con y
de objetos, y el funcionamiento es:
Se una variable del tipo de elementos que contiene el array o la colección. A partir de ahí, se van todos y cada uno de los objetos que contiene. Al visitar cada uno de ellos, se como valor a la variable declarada y se las del cuerpo del ciclo para ese objeto. Se pasa al siguiente objeto de la colección o del array, y así sucesivamente, hasta que se procesen . Enviar
4.3.- Estructura repetitiva while. En la siguiente imagen puedes ver un diagrama de flujo que representa el funcionamiento de este tipo de estructura repetitiva.
El bucle while es la primera estructura de repetición controlada por sucesos que vamos a estudiar. La utilización de este bucle responde al planteamiento de la siguiente pregunta: ¿Qué podemos hacer si lo único que sabemos es que se han de repetir un conjunto de instrucciones mientras se cumpla una determinada condición? La característica fundamental de este tipo de estructura repetitiva estriba en ser forman el cuerpo del bucle podría ser necesario ejecutarlas o no.
útil en aquellos casos en los que las instrucciones que
Es decir, en el bucle while siempre se evaluará la condición que lo controla, y si dicha condición es cierta, el cuerpo del bucle se ejecutará una vez, y se seguirá ejecutando mientras la condición sea cierta. Pero si en la evaluación inicial de la condición ésta no es verdadera, el cuerpo del bucle no se ejecutará. Es imprescindible que en el interior del bucle while se realice alguna acción que modifique la condición que controla la ejecución del mismo, en caso contrario estaríamos ante un bucle infinito, que es algo que se debe evitar siempre.
Autoevaluación De las afirmaciones siguientes, marca las que te parezcan correctas. Cualquier problema que se pueda resolver con estructuras tipo for también es posible resolverlo con estructuras tipo while. Los ciclos while son adecuados para aquellos casos en los que sabemos que las instrucciones del cuerpo del bucle se deben ejecutar al menos una vez. Para casos en los que sabemos exactamente cuántas veces debe ejecutarse el bloque de sentencias contenido del ciclo, while es mucho más adecuado que for, porque aunque hace lo mismo, permite presentar el código de una manera más simple y clara. Los ciclos while requieren que dentro de las sentencias del bucle haya alguna que modifique el valor de la condición que controla el bucle. Mostrar retroalimentación
4.3.1.- Estructura while en pseudocódigo. ¿Cómo podemos representar la estructura tipo while en pseudocódigo?
Una vez más el objetivo es elegir una forma que sea clara para cualquier persona, y que evite toda ambigüedad. Nuestra propuesta la puedes ver en la siguiente tabla, donde también se muestra un ejemplo.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
11/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 w e Representación en pseudocódigo
r
Ejemplo en pseudocódigo Veamos cómo quedaría el pseudocódigo para el ejemplo que permite representar en pantalla la tabla del 7. Se presenta en gris atenuado todo el código, salvo el de la estructura del bucle while. Programa RepetitivaTipoWhile /* En este ejemplo se utiliza la estructura repetitiva while * para representar en pantalla la tabla de multiplicar del siete */ Inicio /* Declaración de variables */ numero, contador, resultado: entero /* Inicialización de variables */ numero <-- 7 resultado <-- 0
MientrascondiciónHacer sentencia1 sentencia2 ... sentenciaN Fin-mientras
/* Salida de información */ Escribir ("Tabla de multiplicar del " , numero) Escribir (".............................. ") /* Utilizamos ahora el bucle while.
* Primero inicializamos la variable contador.
*/ contador <-- 1
/* Establecemos la condición del bucle
* Fíjate en que la última sentencia del bucle es actualizar el
* valorde contador, la variable de control del bucle.
*/
Mientras contador <= 10 Hacer resultado <-- contador * numero Escribir (numero , " x " , contador , " = " , resultado) contador <-- contador + 1 Fin-mientras
Fin
Funcionamiento: Se evalúa la condición de control del bucle. Si es correcta, se ejecutan las sentencias que hay en el cuerpo del bucle, y se vuelve a comprobar la condición para ver si hay que seguir ejecutando las sentencias. Si es falsa, se termina la ejecución del bucle y salta a la siguiente sentencia detrás del mismo. Resumidamente: Si la condición es de entrada falsa, las sentencias no se ejecutan ninguna vez. Si es cierta, se ejecutarán repetidamente, mientras que tras cada iteración se compruebe que la condición sigue siendo verdadera. Cuando la condición sea falsa, el bucle termina.
4.3.2.- Estructura while en Java. A continuación vamos a presentarte la sintaxis de los ciclos while en Java.
Estructura repetitiva while. Sintaxis para el caso de una sola sentencia en el cuerpo del bucle while
Sintaxis para el caso de unun bloque de sentencias en el cuerpo del bucle while
while (condición) { sentencia1;
while(condición) sentencia;
…; sentenciaN; }
Funcionamiento: Mientras la condición sea cierta, el bucle se repetirá, ejecutando las instrucciones de su interior (una o varias). En el momento en el que la condición no se cumpla, el control del flujo del programa pasará a la siguiente instrucción que exista justo detrás del bucle while. La condición se evaluará siempre al principio, y podrá darse el caso de que las instrucciones contenidas en él no lleguen a ejecutarse nunca si no se satisface la condición de partida. .
Recomendación Error de programación Si en el cuerpo de una instrucción while no se proporciona una acción que ocasione que en algún momento la condición de un while no se cumpla, por lo general se producirá un error lógico conocido como ciclo infinito, en el que el ciclo nunca terminará
Debes conocer Accede al siguiente archivo java y podrás analizar un ejemplo de utilización del bucle while para la impresión por pantalla de la tabla de multiplicar del siete. Lee atentamente los comentarios incluidos en el código, pues aclaran algunas cuestiones interesantes sobre este bucle. Como podrás comprobar, el resultado de este bucle es totalmente equivalente al obtenido utilizando el bucle for. Uso la estructura repetitiva while.
(0.01 MB)
Autoevaluación Utilizando el siguiente fragmento de código estamos construyendo un bucle infinito. ¡IMPORTANTE! Lee con atención la retroalimentación, porque en ella se explican algunos aspectos muy a tener en cuenta sobre la formación de ciclos con este tipo de condiciones. while (true) Sys tem.out.println("Imprimiendo desde dentro del bucle...");
Verdadero
Falso
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
12/32
2017-6-23 . .-
s ruc ura repe
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 va o-w e.
En la siguiente imagen puedes ver un diagrama de flujo que representa el funcionamiento de este tipo de estructura repetitiva.
La estructura do-while es otro tipo de estructura repetitiva controlada por sucesos. En este caso, la pregunta que nos planteamos es la siguiente: ¿Qué podemos hacer si sabemos que se han de ejecutar un conjunto de instrucciones al menos una vez, y que dependiendo del resultado, puede que deban seguir repitiéndose mientras que se cumpla una determinada condición? La característica fundamental de este tipo de estructura repetitiva estriba en ser útil en aquellos casos en los que las instrucciones que forman el cuerpo del bucle necesitan ser ejecutadas al menos una vez y repetir su ejecución mientras que la condición sea verdadera. Por tanto, en esta estructura repetitiva se ejecuta el cuerpo del bucle siempre una primera vez . Como en el caso de while, para do-while también es imprescindible que en el interior del bucle se realice alguna acción que modifique la condición que controla la ejecución del mismo, en caso contrario estaríamos ante un bucle infinito.
Autoevaluación Indica cuál es la estructura de control de flujo repetitiva o cíclica que garantiza que las sentencias del cuerpo del bucle se ejecutarán al menos una primera vez, con independencia del valor de la condición en el momento de comenzar la ejecución del ciclo. do-while. for. while. for/in. switch.
4.4.1.- Estructura do-while en pseudocódigo. ¿Cómo podemos representar la estructura tipo do-while en pseudocódigo?
Una vez más el objetivo es elegir una forma que sea clara para cualquier persona, y que evite toda ambigüedad. Nuestra propuesta la puedes ver en la siguiente tabla, donde también se muestra un ejemplo.
Pseudocódigo para la estructura repetitiva tipo do-while
Representación en pseudocódigo
Ejemplo en pseudocódigo Veamos cómo quedaría el pseudocódigo para el ejemplo que permite representar en pantalla la tabla del 7. Se presenta en gris atenuado todo el código, salvo el de la estructura del bucle do-while. Programa RepetitivaTipoDoWhile /* En este ejemplo se utiliza la estructura repetitiva while * para representar en pantalla la tabla de multiplicar del siete */ Inicio /* Declaración de variables */ numero, contador, resultado: entero /* Inicialización de variables */ numero <-- 7
Hacer sentencia1 sentencia2 ...
resultado <-- 0 /* Salida de información */
sentenciaN Mientras(condición)
Escribir ("Tabla de multiplicar del " , numero) Escribir (".............................. ")
/* Utilizamos ahora el bucle while.
* Primero inicializamos la variable contador.
*/ contador <-- 1
/* Establecemos la condición del bucle
Hacer
* Fíjate en que la última sentencia del bucle es actualizar el
* valorde contador, la variable de control del bucle.
*/
resultado <-- contador * numero Escribir (numero , " x " , contador , " = " , resultado) contador <-- contador + 1 Mientras contador <= 10 Fin
Funcionamiento: El cuerpo del bucle se ejecuta la primera vez, a continuación se evaluará la condición y si ésta es verdadera, el cuerpo del bucle volverá a repetirse, y así sucesivamente, hasta que la condición sea falsa. El bucle finalizará por tanto, cuando la evaluación de la condición sea falsa. En ese momento, el control del flujo del programa pasará a la siguiente instrucción que exista justo detrás del bucle do-while. La condición se evaluará siempre después de una primera ejecución del cuerpo del bucle, por lo que no se dará el caso de que las instrucciones contenidas en él no lleguen a
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
13/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 .
Resumidamente: "Primero dispara y luego pregunta".
4.4.2.- Estructura do-while en Java. Es el turno de ver cuál será la sintaxis de la estructura do-while en Java.
Estructura repetitiva do-while. Sintaxis para el caso de una sola sentencia en el cuerpo del bucle do-while
Sintaxis para el caso de un bloque de sentencias en el cuerpo del bucle do-while
do{ do sentencia; while(condición);
sentencia1; …; sentenciaN; }while(condición);
Funcionamiento: El cuerpo del bucle se ejecuta la primera vez, a continuación se evaluará la condición y si ésta es verdadera, el cuerpo del bucle volverá a repetirse, y así sucesivamente, hasta que la condición sea falsa. El bucle finalizará cuando la evaluación de la condición sea falsa, por tanto. En ese momento el control del flujo del programa pasará a la siguiente instrucción que exista justo detrás del bucle do-while. La condición se evaluará siempre después de una primera ejecución del cuerpo del bucle, por lo que no se dará el caso de que las instrucciones contenidas en él no lleguen a ejecutarse nunca. Resumidamente: "Primero dispara y luego pregunta".
Debes conocer Accede al siguiente archivo java y podrás analizar un ejemplo de utilización del bucle do-while para la impresión por pantalla de la tabla de multiplicar del siete. Lee atentamente los comentarios incluidos en el código, pues aclaran algunas cuestiones interesantes sobre este bucle. Como podrás comprobar, el resultado de este bucle es totalmente equivalente al obtenido utilizando el bucle for y el bucle while. Uso de la estructura repetitiva do-while.
(0.01 MB)
Recomendación Buena práctica de programación Incluye siempre llaves en una instrucción do-while, aún cuando estas no sean necesarias. Esto ayuda a eliminar ambigüedad entre las instrucciones while y do-while que contienen una sola instrucción.
Autoevaluación En las sentencias do-while , ¿qué hay que tener siempre presente? La necesidad de duplicar el código de las sentencias de control del bucle justo antes de entrar al mismo, de forma que se garantice así que al menos se van a ejecutar una vez. La necesidad de que dentro del cuerpo del bucle se incluya alguna sentencia que modifique la variable de control del ciclo, de forma que pueda verse alterado el valor de verdad de la condición que controla el bucle de tal manera que garanticemos que en algún momento se alcance la condición de salida, sin entrar en un bucle infinito. La posibilidad de que el bucle no se ejecute nunca, por lo que la sentencia que modifique la variable de control del bucle debe ser previa al do-while, o de lo contrario estaríamos dejando la puerta abierta a que nunca se modificara esa sentencia, y por tanto, nunca se alcanzara la condición de salida, produciendo un bucle infinito, que es algo que siempre hay que evitar. Las respuestas anteriores son todas incorrectas.
Autoevaluación Un bucle tipo do-while, que no contenga en su cuerpo ninguna sentencia capaz de modificar el valor de verdad de la condición que controla el ciclo, o bien se ejecuta una sola vez, o bien entra en un bucle infinito ejecutándose indefinidamente. Verdadero
Falso
Recomendación A partir de ahora, pensamos que no debemos ir más allá con el pseudocódigo, que a estas alturas debe haber cumplido con su cometido fundamental en este curso, que es ayudar a entender las estructuras de control de flujo. Podríamos seguir considerando estructuras de salto condicional en pseudocódigo, llamadas a rutinas o procedimientos, subprogramas, etc., pero a partir de este punto, creemos que no aportaría claridad, sino todo lo contrario. Por tanto, lo único que queda por ver de pseudocódigo son algunos ejemplos resueltos que puedas comparar con su solución en Java. Es lo que te ofrecemos en el Anexo I al final de la unidad. Puedes saltar allí a ver esos ejemplos cuando gustes, pero pensamos que ahora es un buen momento.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
14/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
5.- Estructuras de salto incondicional.
Caso práctico Juan recuerda que algunos lenguajes de programación permitían realizar saltos a lo largo de la ejecución de los programas, incluso a zonas remotas del código, saltándose los ámbitos de las estructuras de control de flujo incluso, y conoce algunas sentencias que aún se siguen utilizando para ello. Le pregunta a Ada: -¿Es posible prescindir por completo de las estructuras de salto incondicional? ¿Es posible programar cualquier salto incondicional de forma que se prescinda de él, y sólo se hagan los saltos ligados a las estructuras de control condicionales o cíclicas, tras comprobar sus condiciones? Ada, mientras toma un libro sobre Java de la estantería del despacho, le aconseja: Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. V43
Las instrucciones de salto incondicional a veces han sido mal valoradas por la comunidad de programadores, pero en Java algunas de ellas son totalmente necesarias. También es verdad que las situaciones en las que resultan o bien útiles o bien necesarias están muy delimitadas, y que usarlas fuera de esos casos concretos es en general evitable, y además resulta muy desaconsejable, ya que produce código menos claro, difícil de entender y de mantener, y por tanto más costoso, así que yo te voy a pedir que tengas muy claro cuándo debes usarlas y cuándo debes evitarlas, porque en esta empresa queremos hacer software de calidad a buen precio. Mira, en este libro se habla del uso de las sentencias break, continue y return en Java. -Vale, voy a empaparme del asunto. Gracias por el libro.
¿Saltar o no saltar? He ahí la cuestión. En la gran mayoría de libros de programación y publicaciones de Internet, siempre se nos recomienda que prescindamos de sentencias de salto incondicional, es más, se desaconseja su uso por provocar una mala estructuración del código y un incremento en la dificultad para el mantenimiento del mismo. Pero Java incorpora ciertas sentencias o estructuras de salto que es necesario conocer, que en algunos casos son imprescindibles, y que por tanto son útiles en algunas partes de nuestros programas. En Java, las estructuras de salto incondicional están representadas por las sentencias break, return.
No obstante, esos usos deben ser siempre compatibles con los seguir una serie de reglas:
, las etiquetas de salto y la sentencia
continue
principios de la programación estructurada, que promueven
Limitar el uso de estructuras de control a las tres estudidas hasta ahora: secuencial, selectiva y repetitiva. Mantener el principio de "una entrada - una salida". Eso implica que cualquier bloque de código debe tener una única entrada y una única salida. Esto desde luego, se consigue limitando el uso de las tres estructuras anteriores, ya que todas tienen una entrada y una salida, pero también hay que tenerlo presente en los casos en los que hagamos uso de sentencias de salto. Un buen ejemplo sería la sentencia switch, que requiere usar los break para evita rel efecto de "ejecución en cascada", pero que no por ello rompe el principio de la entrada única y salida única. Evitar saltos a regiones remotas de código. Incluso en los casos en los que se estime que usar sentencias de salto incondicional puede mejorar la claridad del código, deben evitarse los saltos a regiones remotas del código, ya que resultan difíciles de seguir a la hora de hacer el mantenimiento del código y por tanto producen código poco claro, difícil de entender y de mantener, y costoso de desarrollar.
En los siguientes subepígrafes vamos a analizar la sintaxis y funcionamiento de las sentencias de salto incondicional en Java.
5.1.- Sentencias break y continue. Se trata de dos instrucciones que permiten modificar el comportamiento de otras estructuras o sentencias de control, simplemente por el hecho de estar incluidas en algún punto de su secuencia de instrucciones. La sentencia break incidirá sobre las estructuras de control switch,
, for y do-while del siguiente modo:
while
Si aparece una sentencia break dentro de la secuencia de instrucciones de cualquiera de las estructuras mencionadas anteriormente, dicha estructura terminará inmediatamente. Si aparece una sentencia b reak dentro de un bucle anidado sólo finalizará ejecución del bucle más interno en el que se encuentra, el resto se ejecuta de forma normal. Es decir, que break sirve para romper el flujo de control de un bucle, aunque no se haya cumplido la condición del bucle. Si colocamos un break dentro del código de un bucle, cuando se alcance el break, automáticamente se saldrá del bucle pasando a ejecutarse la siguiente instrucción inmediatamente después de él. En la siguiente imagen ampliable, puedes apreciar cómo se utilizaría la sentencia break dentro de un bucle for.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
15/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
Descripción: código de la imagen para el ejemplo usando break
¡Recuerda! Debemos saber cómo funciona break, pero su uso, salvo en el caso del switch, donde es obligado usarlo para evitar una "ejecución en cascada", se desaconseja, y siempre es evitable. La salida de cualquier ciclo usando break es en general una mala práctica de programación, que esconde una mala planificación de la lógica asociada al ciclo . La salida natural y única de cada ciclo debe ser comprobando la condición de control del mismo, único punto donde debemos comprobar si ha llegado o no el momento de terminarlo. Cualquier comprobación de cualquier condición de salida dentro del cuerpo del bucle para forzar la salida del bucle desde el interior del mismo usando break, debería haberse incorporado a la condición de control del mismo, y supone ir abriendo puertas traseras de salida que hacen que el código se haga cada vez más complicado de entender y mantener. ¡¡Evita usar break siempre que sea posible!! Y salvo el caso de switch, siempre es posible. La sentencia continue incidirá sobre las sentencias o estructuras de control while,
y do-while del siguiente modo:
for
Si aparece una sentencia continue dentro de la secuencia de instrucciones de cualquiera de las sentencias anteriormente indicadas, dicha sentencia dará por terminada la iteración actual y se ejecuta una nueva iteración, evaluando de nuevo la expresión condicional del bucle. Si aparece en el interior de un bucle anidado solo detendrá la ejecución de la iteración del bucle más interno en el que se encuentra, el resto se ejecutaría de forma normal. Es decir, la sentencia continue forzará a que se ejecute la siguiente iteración del bucle, ignorando y saltándose las instrucciones que pudiera haber después del continue, y hasta el final del código del bucle, para esta iteración. En la siguiente imagen, puedes apreciar cómo se utiliza la sentencia continue en un bucle for para imprimir por pantalla sólo los números pares.
Descripción: código de la imagen para el ejemplo usando continue
¡¡Recuerda!! Con la sentencia continue, también se desaconseja el uso. Igual que pasaba con el uso de break, es en general una mala práctica de programación, que esconde un mal diseño de la lógica asociada al ciclo . De hecho, la sentencia continue, como en el ejemplo de la imagen anterior, se pondría dentro de un if para que se ejecute dependiendo de una condición. La sentencia continue lo que hace implícitamente de hecho, es meter las demás sentencias que siguen a partir de ella en una "invisible" cláusula else del condicional, ya que sólo serán alcanzables y ejecutables en el caso de que la condición sea falsa y por tanto no se ejecute continue. Si un grupo de sentencias del bucle deben dejar de ejecutarse bajo ciertas circunstancias, lo que hay que hacer es incluirlas en un condicional que compruebe dicha condición, y que se salte esas sentencias cuando sea oportuno. Para clarificar algo más el funcionamiento de ambas sentencias de salto, vuelve a mirar detenidamente el diagrama representativo del comienzo de este epígrafe.
Reflexiona ¿Cómo reescribirías el código de los dos ejemplos asociados a las imágenes ampliables del apartado, para conseguir el mismo funcionamiento, pero sin usar sentencias break ni continue? Mostrar retroalimentación
Autoevaluación La instrucción break puede utilizarse en las estructuras de control switch, while, for y cláusula default de la estructura switch. Verdadero
, pudiendo omitirse en la
do-while
Falso
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
16/32
2017-6-23 . .
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 .
Ya lo indicábamos al comienzo del epígrafe dedicado a las estructuras de salto: Los saltos incondicionales y en especial, saltos a una etiqueta son totalmente desaconsejables. No obstante, Java permite asociar etiquetas cuando se va a realizar un salto, y por tanto es conveniente saber que existen y cómo se usan. Las estructuras de salto break y continue, pueden tener asociadas etiquetas. Es a lo que se llama un break etiquetado o un continue etiquetado. Pero sólo podría estar indicado su uso cuando se hace necesario salir de bucles anidados hacia diferentes niveles, para indicar a qué nivel nos traslada una sentencia break o continue. No obstante, desde el momento que cualquier salida por la puerta trasera de un bucle usando break o continue es indeseable y evitable . Si las cosas se han hecho bien, no debería haber tales salidas, y por tanto, no debería ser necesario recurrir a etiquetas. Abrev
¿Y cómo se crea un salto a una etiqueta?
En primer lugar, crearemos la etiqueta mediante un identificador seguido de dos puntos (:). A continuación, se escriben las sentencias Java asociadas a dicha etiqueta encerradas entre llaves. Por así decirlo, la creación de una etiqueta es como fijar un punto de salto en el programa para poder saltar a él desde otro lugar de dicho programa. ¿Cómo se lleva a cabo el salto? Es sencillo, en el lugar donde vayamos a colocar la sentencia break o continue, añadiremos detrás el identificador de la etiqueta. Con ello, conseguiremos que el salto se realice a un lugar determinado. La sintaxis será break . Quizá a quienes hayáis programado en HTML os suene esta herramienta, ya que tiene cierta similitud con las anclas que pueden crearse en el interior de una página web, a las que nos llevará el hiperenlace o link que hayamos asociado. También para quienes hayáis creado alguna vez archivos por lotes o archivos batch bajo MS-DOS es probable que también os resulte familiar el uso de etiquetas, pues la sentencia GOTO que se utilizaba en este tipo de archivos, hacía saltar el flujo del programa al lugar donde se ubicaba la etiqueta que se indicara en dicha sentencia. A continuación, te ofrecemos un ejemplo de declaración y uso de etiquetas en un bucle. Como podrás apreciar, las sentencias asociadas a cada etiqueta están encerradas entre llaves para delimitar así su ámbito de acción. Ejemplo de código usando etiquetas.
Descripción: código de la imagen sobre ejemplo de uso de etiquetas
5.3.- Sentencia return. Ya sabemos cómo modificar la ejecución de bucles y estructuras condicionales múltiples, pero, ¿podríamos modificar la ejecución de un método? ¿Es posible hacer que éstos detengan su ejecución antes de que finalice el código asociado a ellos? Sí es posible, y en Java a través de la sentencia return podremos conseguirlo. La sentencia return puede utilizarse de dos formas: método donde esté escrita, con lo que transferirá el control al punto desde Para terminar la ejecución del el que se hizo la llamada al método, continuando el programa por la sentencia inmediatamente posterior. Para devolver o retornar un valor , siempre que junto a return se incluya una expresión de un tipo determinado. Por tanto, en el lugar donde se invocó al método se obtendrá el valor resultante de la evaluación de la expresión que acompañaba al método. En general, una sentencia return debe aparecer al final de un método, de este modo el método tendrá una entrada y Fudgecrackers34 una salida, cumpliendo con uno de los principios de la programación estructurada, de forma que la salida natural para cualquier método será ejecutar la última sentencia que contiene, y que debe ser un return. No obstante, también es posible utilizar una sentencia return en cualquier punto de un método, con lo que éste finalizará en el lugar donde se encuentre dicho return. Pero de esta forma, estaríamos creando "puertas traseras" que complicarían la comprensión del código, y lo harían más difícil de entender y mantener, pudiendo generar efectos colaterales oscuros no previstos que deriven en un mal funcionamiento. Por tanto se recomienda NO incluir más de un return en un método, que deberá ir al final del mismo, como salida natural. El valor de retorno es opcional, si lo hubiera debería de ser del mismo tipo o de un tipo compatible con el tipo del valor de retorno definido en la cabecera del método, pudiendo ser desde un entero a un objeto creado por nosotros. Si no lo tuviera, el tipo de retorno sería void, y return serviría para salir del método sin necesidad de añadirle ningún valor ni expresión detrás.
Para saber más En el siguiente archivo .java encontrarás el código de un programa que obtiene la suma de dos números, empleando para ello un método sencillo que retorna el valor de la suma de los números que se le han pasado como parámetros. Presta atención a los comentarios y fíjate en las conversiones a entero de la entrada de los operandos por consola. Uso de return en métodos.
(1.70 KB)
Autoevaluación ¿Qué afirmación es correcta? Con return, se puede finalizar la ejecución del método en el que se encuentre. Con return, siempre se retornará un valor del mismo tipo o de un tipo compatible al definido en la cabecera del método. Con return, puede retornarse un valor de un determinado tipo y suele hacerse al final del método. Además, el resto de respuestas también son correctas.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
17/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
6.- Excepciones.
Caso práctico Para que las aplicaciones desarrolladas por BK Programación mantengan una valoración positiva a lo largo del tiempo por parte de sus clientes, es necesario que éstas no se vean comprometidas durante su ejecución. Hay innumerables ocasiones en las que programas que aparentemente son formidables (por su interfaz, facilidad de uso, etc.) comienzan a generar errores en tiempo de ejecución que hacen que el usuario desconfíe de ellos día a día. Para evitar estas situaciones, Ada va a fomentar en María y Juan la cultura de la detección, control y solución de errores a través de las poderosas herramientas que Java les ofrece. Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. V43
A lo largo de nuestro aprendizaje de Java nos hemos topado en alguna ocasión con errores, pero éstos suelen ser los que nos ha indicado el compilador. Un punto y coma que falta por aquí, un nombre de variable incorrecto por allá, pueden hacer que nuestro compilador nos avise de estos descuidos. Cuando los vemos, se corrigen y obtenemos nuestra clase compilada correctamente. Pero, ¿sólo existe este tipo de errores? ¿Podrían existir errores no sintácticos en nuestros programas? Está claro que sí, un programa perfectamente compilado en el que no existen errores de sintaxis, y que no se detectan por tanto en tiempo de compilación, puede generar otro tipo de errores que quizá aparezcan cuando estamos usando nuestro programa, en tiempo de ejecución. A estos errores se les conoce como excepciones, y seguramente has experimentado ya los efectos de este tipo de errores en algún pequeño programa que, por ejemplo, reciba un número real o una cadena de caracteres como entrada, cuando el código está esperando un número entero. Si todavía no has experimentado esto, es un buen momento para probarlo y ver qué pasa. Aprenderemos a gestionar de manera adecuada estas excepciones y tendremos la oportunidad de utilizar el GNUFree Documentation License Erik van Leeuwen potente sistema de manejo de errores que Java incorpora. La potencia de este sistema de manejo de errores radica en que: 1.- El código que se encarga de manejar los errores, es perfectamente identificable en los programas. Este código puede estar separado del código que maneja la aplicación. 2.- Java tiene una gran cantidad de errores estándar asociados a multitud de fallos comunes, como por ejemplo divisiones por cero, fallos de entrada de datos, formato numérico erróneo, índice fuera de rango en un array o en una cadena, argumentos no válidos en un método, y un largo etc. Al tener tantas excepciones localizadas, podemos gestionar de manera específica cada uno de los errores que se produzcan. En Java se pueden preparar los fragmentos de código que pueden provocar errores de ejecución para que si se produce una excepción, el flujo del programa sea alterado, transfiriendo el control hacia ciertas zonas o rutinas que han sido creadas previamente por el programador y cuya finalidad será el tratamiento efectivo de dichas excepciones. Estas rutinas son lanzadas (throw), y toman el control de la situación, de forma que permiten capturar (catch) la excepción producida, y darle un tratamiento adecuado, o al menos terminar lo más ordenadamente posible la ejecución del programa, en caso de que se tratara de un error irrecuperable. Si no se captura la excepción, el programa se detendrá con toda probabilidad, aunque al menos podrá dar una información precisa y detallada de qué tipo de error se ha producido, en qué línea de código, qué secuencia de instrucciones se han ejecutado hasta llegar a esa situación. Todo ello es información útil a la hora de corregir el error. En Java, las excepciones están representadas por clases. La clase java.lang.Exception contiene todos los tipos de excepciones. Todas las excepciones derivarán de la clase Throwable, existiendo clases más específicas. Por debajo de la clase Throwable existen las clases Error y Exception. La clase Error se encargará de los errores que se produzcan en la máquina virtual, no en nuestros programas, y que por tanto, quedan fuera del alcance de lo que nosotros podemos corregir. La clase Exception será la que nos interese conocer, pues gestiona los errores provocados en nuestros programas. Java lanzará una excepción en respuesta a una situación poco usual. Cuando se produce un error se genera un objeto asociado a esa excepción. Este objeto es de la clase Exception o de alguna de sus herederas. Este objeto se pasa al código que se ha definido para manejar la excepción. Dicho código puede manipular las propiedades del objeto Exception. El programador también puede lanzar sus propias excepciones. Para ello se usa la cláusula throw (sin s, no confundir con throws, con s, y que se verá en el epígrafe dedicado a delegación de excepciones). El usuario puede definir excepciones como subclases de la clase Exception, o de alguna de alguna de sus subclases, y la cláusula throw fuerza la generación del error invocando al método constructor de un nuevo objeto del tipo de la excepción que se quiere lanzar... Todo ello, para ser bien entendido, requiere conocimientos de programación orientada a objetos que todavía no se han abordado en este curso, por lo que se explicará nuevamente y ya con más detalle en próximas unidades. Las excepciones en Java serán objetos de clases derivadas de la clase base Exception. Existe toda una jerarquía de clases derivada de la clase base Exception, que se dividen en dos grupos principales: Las excepciones en tiempo de ejecución, que ocurren cuando el programador no ha tenido cuidado al escribir su código. Las excepciones que indican que ha sucedido algo inesperado o fuera de control. En la siguiente imagen te ofrecemos una aproximación a la jerarquía de las excepciones en Java.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
18/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
6.1.- Capturar una excepción con try. Para poder capturar excepciones, emplearemos la estructura de captura de excepciones try-
catch
-finally.
Básicamente, para capturar una excepción lo que haremos será declarar bloques de código donde es posible que ocurra una excepción. Esto lo haremos mediante un bloque try (intentar). Si ocurre una excepción dentro de estos bloques, se lanza una excepción. Estas excepciones lanzadas se pueden capturar por medio de bloques catch. Será dentro de este tipo de bloques donde se hará el manejo de las excepciones. Su sintaxis es:
Beatrice Murch
try{ código que puede generar excepciones; }catch (Tipo_excepcion_1 objeto_excepcion){ instrucciones para manejar excepción de Tipo_excepcion_1; }catch (Tipo_excepcion_2 objeto_excepcion){ instrucciones para manejar excepción de Tipo_excepcion_2; }catch (...){
...
}finally{ instrucciones que se ejecutan siempre }
En esta estructura, la parte catch puede repetirse tantas veces como excepciones diferentes se deseen capturar. La parte finally es opcional y, si aparece, solo podrá hacerlo una sola vez. Cada catch maneja un tipo de excepción. Cuando se produce una excepción, se busca el catch que posea el manejador de excepción adecuado, será el que utilice el mismo tipo de excepción que se ha producido. Esto puede causar problemas si no se tiene cuidado, ya que la clase Exception es la superclase de todas las demás. Por lo que si se produjo, por ejemplo, una excepción de tipo AritmethicException y el primer catch captura el tipo genérico Exception, será ese catch el que se ejecute y no los demás. Por eso el último catch debe ser el que capture excepciones genéricas y los primeros deben ser los más específicos. Lógicamente si vamos a tratar a todas las excepciones (sean del tipo que sean) igual, entonces basta con un solo catch que capture objetos Exception. En la bibliografía sobre excepciones en Java, frecuentemente se cuestiona la utilidad de la cláusula finally, debido a que al ser instrucciones que se ejecutan siempre, bien podrían sacarse del bloque de manejo de la excepción. Es cierto que finally no aporta la posibilidad de hacer nada que no se pueda conseguir hacer de forma igualmente clara sin finally, por lo que en lo que a este curso respecta, su uso queda a criterio del gusto de quien programa. Eso sí, hay que saber que existe y cómo funciona.
Ejercicio resuelto Realiza un programa en Java en el que se solicite al usuario la introducción de un número por teclado comprendido entre el 0 y el 100. Utilizando manejo de excepciones, debes controlar la entrada de dicho número y volver a solicitarlo en caso de que ésta sea incorrecta. Mostrar retroalimentación
Debes conocer Si deseas conocer en mayor detalle el manejo de excepciones, te aconsejamos el siguiente enlace en el que podrás encontrar un vídeo ilustrativo sobre su creación y manejo. Excepciones en Java. Resumen textual alternativo para el vídeo sobre excepciones Java
Autoevaluación Si en un programa no capturamos una excepción, será la máquina virtual de Java la que lo hará por nosotros, pero inmediatamente detendrá la ejecución del programa y mostrará una traza y un mensaje de error. Verdadero
Falso
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
19/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
6.2.- El manejo de excepciones con catch. ¿Es obligatorio entonces el manejo de excepciones, o podemos dejar que sea la propia máquina virtual en última instancia quien las capture y las trate? Como hemos comentado, siempre debemos controlar las excepciones que se puedan producir o de lo contrario nuestro software quedará expuesto a fallos. Que las excepciones las trate la propia máquina virtual, significa haber dejado que "ocurra la catástrofe", y que el programa se termine de forma abrupta, lo que nunca es deseable. Las excepciones pueden tratarse de dos formas: Interrupción. En este caso se asume que el programa ha encontrado un error irrecuperable. La operación que dio lugar a la excepción se anula y se entiende que no hay manera de regresar al código que provocó la excepción para intentar reconducir la situación. Reanudación. Se puede manejar el error y regresar de nuevo al código que provocó el error. Java emplea la primera forma, pero puede simularse la segunda mediante la utilización de un bloque try en el interior de un while, que se repetirá hasta que el error deje de existir. En la siguiente imagen tienes un ejemplo de cómo llevar a cabo esta simulación. Ejemplo de estructura try-catch
Descripción: Código de la imagen en archivo de texto para el ejemplo de uso de try-catch.
En este ejemplo, a través de la función de generación de números aleatorios (de la clase Math que incorpora Java), se obtiene el valor del índice i. Con dicho valor se accede a una posición del array que contiene cinco cadenas de caracteres. Este acceso, a veces puede generar un error del tipo ArrayIndexOutOfBoundsException, que debemos gestionar a través de un catch. Al estar el bloque catch dentro de un while, se seguirá intentando el acceso hasta que no haya error, momento en que se mostrará el contenido del array para el índice elegido, y se terminará la ejecución del ciclo.
Debes conocer En este enlace puedes ver explicado algún ejemplo de excepciones. Ejemplo comentado de excepciones. Como la gestión de excepciones es un asunto bastante importante, te ponemos un enlace más con algún ejemplo adicional. Excepciones en Java
6.3.- Dele ación de exce ciones con throws. http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
20/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
¿Puede haber problemas con las excepciones al usar llamadas a métodos en nuestros programas? Efectivamente, si se produjese una excepción es necesario saber quién será el encargado de solucionarla. Puede ser que sea el propio método llamado o el código que hizo la llamada a dicho método. Quizá pudiéramos pensar que debería ser el propio método el que se encargue de sus excepciones, aunque es posible hacer que la excepción sea resuelta por el código que hizo la llamada. Cuando un método utiliza una sentencia que puede generar una excepción, pero dicha excepción no es capturada y tratada por él, sino que se encarga su gestión a quién llamó al método, decimos que se ha delegado la excepción o que se ha producido una delegación de excepciones.
Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. V43
Para establecer esta delegación, en la cabecera del método se declara el tipo de excepciones que puede generar y que deberán ser gestionadas por quien invoque a dicho método. Utilizaremos para ello la sentencia throws (con s, no confundir con throw, sin s, y que sirve para indicar el punto del código donde se quiere lanzar una excepción). Tras la palabra throws se indica qué excepciones puede provocar el código del método. Si ocurre una excepción en el método, el código abandona ese método y regresa al código desde el que se llamó al método. Allí se posará en el catch apropiado para esa excepción, que la capturará y manejará adecuadamente. Si no lo hiciera, la excepción puede seguir propagándose hasta que en el peor de los casos llegara a la máquina virtual, que la trataría provocando que el programa aborte. Su sintaxis es la siguiente: public class DelegacionDeExcepciones { ... public int leeAnio(BufferedReader lector) throws IOException, NumberFormatException{ String linea = lector.readLine(); Return Integer.parseInt(linea); } ... }
Donde IOException y NumberFormatException, serían dos posibles excepciones que el método leeAnio() podría generar, pero que no gestiona. Por tanto, un método puede incluir en su cabecera un listado de excepciones que puede lanzar, separadas por comas. La cláusula throws avisa al compilador de que ese método puede generar errores, pero además avisa al programador de que si usa ese método, debería capturar y manejar la excepción que puede lanzar, ya que de lo contrario el programa puede "abortar".
Debes conocer A continuación tienes un artículo muy interesante donde se explica la gestión de excepciones con ejemplos. Gestión de excepciones
Para saber más Si deseas saber algo más sobre la delegación de excepciones, te proponemos el siguiente enlace: Excepciones y delegación de éstas. Además te volvemos a remitir al vídeo demostrativo sobre manejo de excepciones en Java que se incluyó en el epígrafe titulado "capturar una excepción con try".
Autoevaluación Rellena los huecos con las palabras adecuadas. La captura y manejo de es la forma en que Java controla los en tiempo de . Para ello, se definen bloques de código, mediante la palabra reservada seguida de llaves que delimitan el bloque de código en el que se puede producir el error. Cuando la excepción se produce el control del programa se transfiere a la primera cláusula que encuentra, para comprobar si el error es del tipo de de excepción que ahí se captura, y si no lo es sigue comparando con las siguienes cláusulas que pueda haber. Si encuentra coincidencia con alguna, ejecuta el bloque de código que contenga, y transfiere el control a la cláusula , si la hubiera. Esta cláusula, de aparecer, se ejecutará siempre, tanto si se ha producido, capturado y tratado la excepción, como si no. El usuario puede crear sus propias excepciones, además de forzar la generación de alguna excepción usando la sentencia . También puede decidir que un método no capture ni trate una determinada excepción, sino que la para que sea tratada por el código que hizo la llamada, avisando de ello al compilador y al programador, con la inclusión de la cláusula seguida de los nombres de las excepciones que , separados por comas, en la cabecera de la declaración del método. Enviar
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
21/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
7.- Prueba de programas.
Caso práctico Continuando con el especial interés de BK Programación porque sus aplicaciones sean de verdadera calidad, Ada está dispuesta a emprender un plan de pruebas de software que sea capaz de reducir al mínimo posible los errores que puedan contener las aplicaciones que están desarrollando. Juan y María ya conocían de la existencia de ciertas pruebas que se suelen hacer al software, pero necesitarán aprender bien las técnicas y utilizar las herramientas que los entornos de desarrollo ofrecen para tal proceso.
¿Crees que es frecuente que los programas funcionen bien a la primera? ¿Conoces alguna aplicación que saque frecuentemente versiones nuevas para corregir errores de las versiones anteriores? A veces, los programas son complejos y es difícil hacer que éstos funcionen correctamente. Las pruebas del software son un conjunto de técnicas utilizadas para verificar que un programa lleva a cabo su tarea correctamente. Viéndolo desde otro punto de vista, podríamos decir que la realización de pruebas en nuestros programas intentan revelar la existencia de errores. Cuando detectamos que existe un error, necesitamos localizarlo llevando a cabo técnicas de depuración de código, para luego acometer las modificaciones necesarias que eliminen dicho error. No obstante, las técnicas de prueba del software no garantizan que todos los errores vayan a salir a la luz, y aún así, habrá programas de gran tamaño que sigan conteniendo errores ocultos en ellos. De todas maneras, la realización de pruebas de software está considerada como una etapa de gran importancia en el desarrollo de software. Casi la mitad del tiempo dedicado al desarrollo de un programa, se emplea en la realización de pruebas al mismo . En algunas organizaciones, la realización de pruebas se considera tan importante que existen equipos de desarrollo de software en los que hay tantos probadores de software como programadores. Los procesos de prueba y depuración requieren una considerable cantidad de tiempo y esfuerzo, haciéndose difícil tomar una decisión acertada entre continuar la prueba del programa o entregarlo en su estado actual al cliente. Un concepto muy importante con el que vamos a trabajar es el de verificación de programas. La verificación de programas es un proceso por el que se intenta corroborar que un programa hace lo que se espera de él. Se trata de confirmar que el programa cumple con sus especificaciones. En esta parte de la unidad nos centraremos en las técnicas de prueba sistemática de programas, verificación y análisis de deficiencias del software. Las técnicas que veremos son: Pruebas de caja negra o test funcionales. Pruebas de caja blanca o test estructurales. Revisiones o recorridos. Análisis paso a paso del código con un depurador ( debugger ). Un pequeño programa que consiste sólo en una única clase, normalmente puede ser probado de una sola vez. En cambio, un programa de mayor tamaño que incluye más cantidad de clases, es posible que por su complejidad, deba ser probado por partes. En Java, el tamaño natural de cada una de esas partes será la clase y será conveniente probar nuestros programas clase por clase. Esto es llamado Pruebas de Unidad, y cuando se realizan pruebas de funcionamiento reuniendo todas las partes del programa completo, las pruebas reciben el nombre de Pruebas de Integración o Pruebas de Sistema.
Autoevaluación Rellena los espacios con los conceptos adecuados. En el proceso de se trata de confirmar que el programa cumple con sus
.
Enviar
7.1.- La especificación. ¿Cómo hacer un buen programa si no sabemos bien qué debe hacer? El punto de partida para cualquier prueba es la especificación. No podemos considerar una pérdida de tiempo el análisis claro de dicha información. En ocasiones, podría ser necesario volver a entrevistar a un cliente o al futuro usuario del programa. Para entender la importancia de este elemento, supongamos la siguiente especificación: Es necesario escribir un programa que solicite la entrada al usuario de números a través de cajas de texto. El programa debe calcular y mostrar la suma de los números. A priori, esta especificación puede parecer simple y clara. Nada más lejos de la realidad, ya que existen lagunas como: 1.- ¿Los números son enteros o coma flotante? 2.- ¿Cuál es el rango y precisión de dichos números? 3.- ¿Pueden incluirse números negativos? 4.- ¿Cuántos números deben leerse en cada caso? 5.- etc. Si estas preguntas no son aclaradas antes de que el programador o la programadora comience su trabajo, pueden producirse dificultades en el desarrollo del programa. Y corregir un programa que funciona mal siempre es más costoso que invertir algo de tiempo en asegurar su buen funcionamiento. Por tanto, será parte del proceso de programación el estudio de la especificación para descubrir cualquier omisión o confusión y para conseguir una especificación totalmente clara. A continuación se muestra una versión mucho más clara de la especificación anterior: Es necesario escribir un programa que solicite la entrada al usuario de una serie de números enteros a través de una caja de texto. Los enteros están en el rango 0 a 10.000. El programa calcula y muestra la suma de los números, y estará pidiendo la introducción de nuevos números hasta que el usuario indique que quiere parar. Como puedes apreciar, esta especificación es más precisa al establecer el rango permitido de entrada de valores, por ejemplo. Una vez valorada la importancia de una correcta especificación, el programador puede comenzar el proceso de pruebas del software a través de las herramientas que se detallarán en los siguientes epígrafes de la unidad.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
22/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
7.2.- Pruebas exhaustivas. ¿He de probar todas las posibilidades? Es una pregunta que puede surgir cuando comenzamos a programar. Podríamos pensar en que la realización de una prueba requeriría probar nuestro software con todos los posibles valores de entrada. Este tipo de prueba se denomina prueba exhaustiva y significa que seleccionamos todos los posibles valores de entrada, así como todas sus posibles combinaciones y hacemos que nuestro programa opere con ellos. Pensemos un momento en el amplio rango de posibles valores que pueden tomar los números int de Java. ¿Te imaginas lo que puede suponer realizar una prueba de este tipo? ¡Podríamos estar hablando de años! En resumen, la prueba exhaustiva (aunque sea para un programa pequeño) no es factible. Es importante reconocer que la prueba completa de programas no es posible, por lo que tendremos que adoptar otras técnicas más adecuadas.
Autoevaluación Durante una prueba exhaustiva hemos de seleccionar una muestra de los posibles valores de entrada del programa y hacer que éste tome diferentes caminos de ejecución para ver los resultados que se obtienen. Verdadero
Falso
7.3.- Pruebas de caja negra o pruebas funcionales. Descartadas las pruebas exhaustivas, una técnica más adecuada para la realización de nuestras pruebas es el empleo de las Pruebas de Caja Negra. Este tipo de pruebas se basa en utilizar unos datos de entrada que pueden ser representativos de todos los posibles datos de entrada. Con ellos, se pone en funcionamiento el programa y se analiza qué ocurre. Normalmente tendremos que seleccionar un conjunto de datos que incluyan valores límite, máximos, mínimos, datos erróneos para ver cómo reacciona el código, etc., de forma que al probar el programa con ese conjunto, podamos estar razonablemente tranquilos de que toda la casuística posible ha sido probada. Se llaman de Caja Negra porque no se utiliza ningún conocimiento del funcionamiento interno del programa como parte de la prueba, sólo se consideran las entradas y las salidas. El programa se piensa como si fuera una caja negra que recibe datos de entrada y ofrece unas salidas determinadas. También reciben el nombre de Pruebas Funcionales porque utiliza solamente el conocimiento de la función del programa (no cómo trabaja internamente). Inicialmente, se anotan los datos de prueba y el resultado previsto, antes de ejecutar la prueba. Es a lo que se denomina especificación o planificación de la prueba. Posteriormente, se pone el programa en funcionamiento, se introducen los datos y se examinan las salidas para ver si existen diferencias entre el resultado previsto y el resultado obtenido. Los datos de prueba deberán también comprobar si las excepciones son manejadas por el programa, de acuerdo a su especificación. Es decir, tendremos que poner en aprietos a nuestro programa a través de unos datos de entrada determinados, para comprobar si reacciona correctamente a las especificaciones que deba cumplir.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
23/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
7.4.- Pruebas de caja blanca o pr uebas estructurales. ¿Pero realmente prueban nuestros datos todo el código? ¿Hemos probado todos los posibles caminos y ramificaciones que el código contiene? Este otro tipo de pruebas se basa en el conocimiento del funcionamiento interno del programa, la estructura del mismo, para seleccionar los datos de prueba. A lo largo de las pruebas de caja blanca cada declaración que forma parte del programa es ejecutada en algún momento. Por lo que cada secuencia de instrucciones o camino por el que pueda fluir el programa es ejecutada en alguna ocasión durante dicha prueba. Considerándose caminos nulos, sentencias condicionales simples o compuestas, bucles, etc. La prueba deberá incluir cualquier camino del programa que pueda generar una excepción. Este tipo de pruebas está muy ligado al código fuente del programa, de forma que la persona que realiza las pruebas, debe escoger distintos valores de entrada para chequear cada uno de los posibles caminos de ejecución que existen en el programa y verificar que los resultados de cada uno de ellos son adecuados.
Autoevaluación Rellana los espacios con los conceptos adecuados. Si nos encontramos realizando pruebas y estamos examinando el funcionamiento de un bucle while, estaremos realizando Pruebas de Caja . Enviar
7.5.- Otras pr uebas.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
24/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
Citas para pensar "Cuatro ojos ven más que dos". Sabiduría popular
Además de las típicas pruebas de Caja Blanca y Negra, existen otras técnicas de prueba que detallamos a continuación: Revisiones, inspecciones o recorridos: Esta técnica no hace uso del computador para intentar erradicar errores en el código. En un recorrido se estudia el listado del programa (junto con la especificación) para intentar hacer visibles los posibles errores. Es recomendable que quien lleve a cabo el recorrido no sea la misma persona que desarrolló el código a revisar. Si has programado alguna vez, quizá te suene esta situación: Llevas más de una hora buscando un error en el código de tu programa, ya que éste te está generando errores de compilación o ejecución. Miras, vuelves a mirar, revisas, repasas, cambias alguna variable o sentencia, ...¡Nada, no encuentras el fallo! De pronto, un colega relee tu código mientras se toma un café y oyes detrás de ti una voz que dice: ¡Anda, te falta un paréntesis ahí! Para llevar a cabo este tipo de prueba necesitaremos la especificación del programa y el código fuente en papel. Las acciones que suelen realizarse son: Inspeccionar la inicialización de variables. Realización de llamadas a métodos correctas. Definición adecuada de cabeceras de métodos. Parámetros correctos. etc. Posteriormente, se ha de llevar a cabo una revisión de la lógica del programa simulando ejecutar los métodos como si fuéramos el computador. Las pruebas de revisión o recorrido no comprueban el estilo del código, sino posibles deficiencias que pueden provocar errores. Está demostrado que los recorridos son una vía adecuada para encontrar errores. Análisis paso a paso: Existen algunos entornos de desarrollo para Java que incorporan depuración paso a paso del código. Esto permite al programador o a la programadora ejecutar una a una cada instrucción de su programa. De este modo, es posible ver qué camino de ejecución se está tomando, los valores de las distintas variables, etc. Este análisis paso a paso está estructurado y automatizado, permitiéndonos etc . comprobar si el flujo del programa es el correcto, si los valores de las variables varían en función de la ejecución del programa, Esta técnica suele confirmar o desmentir la existencia de un determinado fallo, aunque está más cerca de la depuración de programas que de la propia prueba de los mismos.
7.6.- Realización de pruebas unitarias con JUnit. Al comienzo de esta parte de la unidad dedicada a las pruebas y depuración de software, hablamos de un tipo de pruebas que se aplican a cada una de las clases que hayamos definido. Eran las pruebas unitarias . Es cierto que cualquier código que escribamos debería de ser probado antes de dar por finalizada la implementación de una clase, ya que si no no tendríamos la total seguridad acerca de su correcto funcionamiento. Para verificar que el código no contiene errores de programación y que además realiza adecuadamente lo que esperábamos de él, se realizan una serie de test que lo corroboren. ¿Quién no ha ido escribiendo mensajes de salida de texto a lo largo de su código para saber qué está haciendo exactamente su programa? Esta es una técnica muy utilizada para controlar el valor de ciertas variables y para la detección de posibles errores, lo que confirma que todos realizamos pruebas a nuestros programas de alguna u otra manera.
Stockbyte. Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia.. CD-DVDNum. V43
Pero, ¿existen formas más avanzadas, eficientes y seguras de probar el código? Sí. Podemos utilizar para ello JUnit. A través de JUnit tendremos la posibilidad de realizar test a nuestras clases de forma sencilla, rápida y elegante, así como validar los resultados que nos ofrecen. ¿Y qué es JUnit? Es un conjunto de bibliotecas que se utilizan en programación para hacer pruebas unitarias a aplicaciones Java. El conjunto de clases (framework) incluidas en JUnit permite controlar la ejecución de las clases Java, de tal forma que podremos evaluar si el funcionamiento de cada uno de los métodos de la clase realiza su trabajo como debería. JUnit se emplea para indicar si la clase en cuestión ha pasado los test de prueba, en otro caso se devolverá una notificación de fallo en el método correspondiente. Actualmente, el entorno de desarrollo NetBeans cuenta con plugins que permiten la generación automática de plantillas de pruebas de clases Java. ¿Por qué utilizar JUnit? A continuación te damos algunas razones de peso por la que este framework está muy extendido entre la comunidad de programadores Java: A través de los test de JUnit se incrementa la calidad y velocidad de generación de código. La escritura de test es sencilla. Los test JUnit chequean sus propios resultados y proporcionan información de retorno al instante. Los tests JUnit incrementan la estabilidad del software. Los test JUnit se escriben en Java. JUnit es gratuito.
Para saber más El IDE NetBeans en la actualidad ya incorpora JUnit desde la instalación, por lo que podemos beneficiarnos de esta herramienta de testeo sólo con utilizarla desde el IDE. Si quieres conocer cómo realizar los primeros pasos con ella y ver ejemplos de utilización, te recomendamos los siguientes enlaces: Primeros pasos con JUnit. Tutorial para creación de test usando JUnit con NetBeans, en la propia página oficial del proyecto NetBeans (en inglés): Writing JUnit Tests in NetBeans IDE Y un interesante vídeo donde podrás ver una introducción y ejemplos con JUnit. Introducción y ejemplos con JUnit. Resumen textual alternativopara "Introducción y ejemplos con JUnit"
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
25/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
En versiones anteriores a NetBeans 7.0, para poder trabajar con el FrameWork JUnit era necesario incorporarlo manualmente al IDE. Verdadero
Falso
8.- Depuración de programas.
Caso práctico Ada y Juan ya conocen las capacidades del depurador que incorpora el entorno NetBeans y van a enseñar a María las ventajas de utilizarlo. -Puedes depurar tus programas haciendo dos cosas: creando ejecuciones paso a paso-, le comenta Juan.
breakpoints o haciendo
María, que estaba codificando un nuevo método, se detiene un momento y pregunta: -Entonces, ¿cuando el programa llega al breakpoint podré saber qué valor tiene una variable determinada? -Efectivamente, María, y podrás saber el valor de aquellas que tú decidas. De este modo a través de los puntos de ruptura y de las ejecuciones paso a paso podrás descubrir dónde puede haber errores en tus programas. Conocer bien las herramientas que el depurador nos ofrece es algo que puede ahorrarnos mucho trabajo-, aporta Ada.
La depuración de programas es el proceso por el cual se identifican y corrigen errores de programación. Generalmente, en el argot de programación se utiliza la palabra debugging, que significa localización y eliminación de bichos (bugs) o errores de programa. A través de este proceso se descubren los errores y se identifica qué zonas del programa los producen. Hay tres etapas por las que un programa pasa cuando éste es desarrollado y que pueden generar errores: Compilación: una vez que hemos terminado de afinar un programa, solemos pasar generalmente cierto tiempo eliminando errores de compilación. El compilador de Java mostrará una serie de chequeos en el código, sacando a la luz errores que pueden no apreciarse a simple vista. Una vez que el programa es liberado de los errores de compilación, obtendremos de él algunos resultados visibles pero quizá no haga aún lo que queremos. Enlazado: todos los programas hacen uso de librerías de métodos y otros utilizan métodos generados por los propios programadores. Un método es enlazado (linked) sólo cuando éste es llamado, durante el proceso de Stockbyte. ejecución. Pero cuando el programa es compilado, se realizan comprobaciones para saber si los métodos Uso educativo no comercial para plataformas públicas de llamados existen y sus parámetros son correctos en número y tipo. Así que, los errores de enlazado y de Formación Profesional a distancia. CD-DVDNum. V07 compilación son detectados antes de la fase de ejecución. Ejecución: cuando el programa entra en ejecución, es muy frecuente que éste no funcione como se esperaba. De hecho, es normal que el programa falle. Algunos errores serán detectados automáticamente y el programador será informado, nos referimos a errores como acceder a una parte de un array que no existe (error de índices), por ejemplo. Otros son más sutiles y dan lugar simplemente a comportamientos no esperados, debido a la existencia de errores ocultos (bugs) en el programa. De ahí los términos bug y debugging. El problema de la depuración es que los síntomas de un posible error son generalmente poco claros, hay que recurrir a una labor de investigación para encontrar la causa. La depuración de programas es algo así como ser doctor: existe un síntoma, hemos de encontrar la causa y entonces determinar el problema. El trabajo de eliminación de errores puede ser interesante. La depuración y la prueba suelen requerir una cantidad de tiempo considerable en comparación con el tiempo dedicado a la primera codificación del programa. Pero no te preocupes, es normal emplear más tiempo en este proceso. ¿Y cómo llevamos a cabo la depuración de nuestros programas? Pues a través del debugger o depurador del sistema de desarrollo Java que estemos utilizando. Este depurador será una herramienta que nos ayudará a eliminar posibles errores de nuestro programa. Podremos utilizar depuradores simples, como el jdb p ropio de Java basado en línea de comandos. O bien, utilizar el depurador existente en nuestro IDE (en nuestro caso NetBeans). Este último tipo de depuradores muestra los siguientes elementos en pantalla: El programa en funcionamiento. El código fuente del programa. Los nombres y valores actuales de las variables que se seleccionen. ¿Qué elementos podemos utilizar en el depurador? Existen al menos dos elementos fundamentales que podemos utilizar en nuestro debugger o depurador, son los siguientes: Breakpoints o puntos de ruptura: estos puntos pueden ser determinados por el propio programador a lo largo del código fuente de su aplicación. Un breakpoint es un lugar en el programa en el que la ejecución se detiene. Estos puntos se insertan en una determinada línea del código, entonces el programa se pone en funcionamiento y cuando el flujo de ejecución llega hasta él, la ejecución queda congelada y un puntero indica el lugar en el que la ejecución se ha detenido. El depurador muestra los valores de las variables tal y como están en ese momento de la ejecución. Cualquier discrepancia entre el valor actual y el valor que deberían tener supone una importante información para el proceso de depuración. Ejecución paso a paso: el depurador también nos permite ejecutar un programa paso a paso, es decir, línea por línea. A través de esta herramienta podremos seguir el progreso de ejecución de nuestra aplicación y supervisar su funcionamiento. Cuando la ejecución no es la esperada quizá estemos cerca de localizar un error o bug. En ocasiones, si utilizamos métodos procedentes de la biblioteca estándar no necesitaremos hacer un recorrido paso a paso por el interior de éstos métodos, ya que es seguro que no contendrán errores internos y podremos ahorrar tiempo no entrando en su interior paso a paso. El debugger ofrece la posibilidad de entrar o no en dicho métodos.
Debes conocer Para completar tus conocimientos sobre la depuración de programas, te proponemos los siguientes enlaces en los que podrás encontrar cómo se llevan a cabo las tareas básicas de depuración a través del IDE NetBeans. Depuración básica en NetBeans. Uso básico del depurador en NetBeans.
Para saber más Si deseas conocer algo más sobre depuración de programas, pero a un nivel algo más avanzado, puedes ver el siguiente vídeo. Debugging avanzado en NetBeans. Resumen textual alternativo para Debugging avanzado en NetBeans.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
26/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
9.- Documentación del código.
Caso práctico Ada está mostrando a Juan la documentación sobre una serie de métodos estándar que van a necesitar para completar el desarrollo de una parte de la aplicación. Esta documentación tiene un formato estructurado y puede accederse a ella a través del navegador web. -¡Qué útil y fácil está siendo el acceso a esta documentación! La verdad es que los que la han generado se lo han currado bastante. Generar esta documentación se llevará mucho tiempo, ¿verdad, Ada? -pregunta Juan mientras recoge de la impresora la documentación impresa. Ada prepara rápidamente una clase en blanco y comienza a incorporarle una serie de comentarios: -Verás, Juan, documentar el código es vital y si incorporas a tu código fuente unos comentarios en el formato que te voy a mostrar, la documentación puede ser generada automáticamente a través de la herramienta Javadoc. Observa -responde Ada.
Llegados a este punto, vamos a considerar una cuestión de gran importancia, la
Dreftymac
documentación del código fuente.
Piensa en las siguientes cuestiones: ¿Quién crees que accederá a la documentación del código fuente? Pues serán los autores del propio código u otros desarrolladores. ¿Por qué hemos de documentar nuestro código? Porque facilitaremos su mantenimiento y reutilización. ¿Qué debemos documentar? Obligatoriamente: clases, paquetes, constructores, métodos y atributos. Opcionalmente: bucles, partes de algoritmos que estimemos oportuno comentar, ... A lo largo de nuestra vida como programadores es probable que nos veamos en la necesidad de reutilizar, modificar y mantener nuestro propio código o incluso, código de otros desarrolladores. ¿No crees que sería muy útil que dicho código estuviera convenientemente documentado? ¿Cuántas veces no hemos leído código de otros programadores y quizá no hayamos comprendido qué estaban haciendo en tal o cual método? Como podrás comprender, la generación de una documentación adecuada de nuestros programas puede suponer una inestimable ayuda para realizar ciertos procesos en el software. Si analizamos la documentación de las clases proporcionada en los paquetes que distribuye Oracle, nos daremos cuenta de que dicha documentación ha sido generada con una herramienta llamada Javadoc . Pues bien, nosotros también podremos generar la documentación de nuestro código a través de dicha herramienta. Si desde el principio nos acostumbramos a documentar el funcionamiento de nuestras clases desde el propio código fuente, estaremos facilitando la generación de la futura documentación de nuestras aplicaciones. ¿Cómo lo logramos? A través de una serie de comentarios especiales, llamados comentarios de documentación que serán tomados por Javadoc para generar una serie de archivos HTML que permitirán posteriormente, navegar por nuestra documentación con cualquier navegador web. Los comentarios de documentación tienen una marca de comienzo (/**) y una marca de fin (*/). En su interior podremos encontrar dos partes diferenciadas: una para realizar una descripción y otra en la que encontraremos más etiquetas de documentación. Veamos un ejemplo: /** * Descripción principal (texto/HTML) * * Etiquetas (texto/HTML) */
Este es el formato general de un comentario de documentación. Comenzamos con la marca de comienzo en una línea. Cada línea de comentario comenzará con un asterisco. El final del comentario de documentación deberá incorporar la marca de fin. Las dos partes diferenciadas de este comentario son: Zona de descripción: es aquella en la que el programador escribe un comentario sobre la clase, atributo, constructor o método que se vaya a codificar bajo el comentario. Se puede incluir la cantidad de texto que se necesite, pudiendo añadir etiquetas HTML que formateen el texto escrito y así ofrecer una visualización mejorada al generar la documentación mediante Javadoc. Zona de etiquetas: en esta parte se colocará un conjunto de etiquetas de documentación a las que se asocian textos. Cada etiqueta tendrá un significado especial y aparecerán en lugares determinados de la documentación, una vez haya sido generada. En la siguiente imagen puedes observar un ejemplo de un comentario de documentación de una clase del propio lenguaje.
Citas para pensar "Do not document bad code, rewrite it."
R. Caron
Reflexiona Documentar el código de un programa es añadir suficiente información como para explicar lo que hace, punto por punto, de forma que no sólo los ordenadores sepan qué hacer, sino que además los humanos entiendan qué están haciendo y por qué. Documentar un programa no es sólo un acto de buen hacer del programador por aquello de dejar la obra rematada. Es además una necesidad que sólo se aprecia en su debida magnitud cuando hay errores que reparar o hay que extender el programa con nuevas capacidades o adaptarlo a un nuevo escenario. Mostrar retroalimentación
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
27/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
9.1.- Etiquetas y posición. Cuando hemos de incorporar determinadas etiquetas a nuestros comentarios de documentación es necesario conocer dónde y qué etiquetas colocar, según el tipo de código que estemos documentando en ese momento. Existirán dos tipos generales de etiquetas: 1. Etiquetas de bloque: son etiquetas que sólo pueden ser incluidas en el bloque de documentación, después de la descripción principal y comienzan con el símbolo @. 2. Etiquetas en texto: son etiquetas que pueden ponerse en cualquier punto de la descripción o en cualquier punto de la documentación asociada a una etiqueta de bloque. Son etiquetas definidas entre llaves, de la siguiente forma {@etiqueta} En la siguiente tabla podrás encontrar una referencia sobre las diferentes etiquetas y su ámbito de uso.
Autoevaluación Completa el texto con la palabra adecuada para ada hueco. En Java es posible generar documentación de forma automática, con una herramienta llamada , siempre y cuando hayamos tenido la precaución de incluir de en el código. Los comentarios son obligados para , , , y , y son opcionales para y partes de algoritmos que pensemos que necesitan ser explicadas. Dichos de , siempre deben comenzar con y terminar con y en su interior pueden llevar pueden ser de dos tipos: De En
. .
Enviar
9.2.- Uso de las etiquetas.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
28/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
¿Cuáles son las etiquetas típicas y su significado? Pasaremos seguidamente a enumerar y describir la función de las etiquetas más habituales a la hora de generar comentarios de documentación. @autor texto con el nombre: esta etiqueta sólo se admite en clases e interfaces. El texto después de la etiqueta no necesitará un formato especial. Podremos incluir tantas etiquetas de este tipo como necesitemos. @version texto de la versión: el texto de la versión no necesitará un formato especial. Es conveniente incluir el número de la versión y la fecha de ésta. Podremos incluir varias etiquetas de este tipo una Lensim detrás de otra. @deprecated texto: indica que no debería utilizarse, indicando en el texto las causas de ello. Se puede utilizar en todos los apartados de la documentación. Si se ha realizado una sustitución debería indicarse qué utilizar en su lugar. Por ejemplo: @deprecated El método no funciona correctamente. Se recomienda el uso de {@link metodoCorrecto}
@exception nombre-excepción texto: esta etiqueta es equivalente a @throws. @param nombre-atributo texto: esta etiqueta es aplicable a parámetros de constructores y métodos. Describe los parámetros del constructor o método. Nombre-atributo es idéntico al nombre del parámetro. Cada etiqueta @param irá seguida del nombre del parámetro y después de una descripción de éste. Por ejemplo: @param fromIndex: El índice del primer elemento que debe ser eliminado.
@return texto: esta etiqueta se puede omitir en los métodos que devuelven void. Deberá aparecer en todos los métodos que devuelvan algo distinto de void, haciendo explícito qué tipo o clase de valor devuelve y sus posibles rangos de valores. Veamos un ejemplo: /** * Chequea si un vector no contiene elementos. * @return verdaderosi y solo si este vector no contiene componentes, esto es, su tamaño es cero; * falso en cualquier otro caso. */ public boolean VectorVacio() { return elementCount == 0; }
@see referencia: se aplica a clases, interfaces, constructores, métodos, atributos y paquetes. Añade enlaces de referencia a otras partes de la documentación. Podremos añadir a la etiqueta: cadenas de caracteres, enlaces HTML a páginas y a otras zonas del código. Por ejemplo: * @see "Diseño de patrones: La reusabilidad de los elementos de la programación orientada a objetos" * @seeWebA ccessibilityInitiative * @see String#equals(Object) equals
@throws nombre-excepción texto : en nombre-excepción tendremos que indicar el nombre completo de ésta. Podremos añadir una etiqueta por cada excepción que se lance explícitamente con una cláusula throws, pero siguiendo el orden alfabético. Esta etiqueta es aplicable a constructores y métodos, describiendo las posibles excepciones del constructor/método.
Autoevaluación ¿Qué etiqueta podría omitirse en un método que devuelve void? @param. @throws. @return.
9.3.- Orden de las etiquetas. ¿Es importante el orden a la hora de poner las etiquetas en los comentarios de documentación, o por el contrario es indiferente? Las etiquetas deben disponerse en un orden determinado, ese orden es el siguiente:
Orden de etiquetas de comentarios de documentación. Etiqueta. @autor
Descripción.
@version
En clases e interfaces.
@param
En métodos y constructores. Se colocarán tantos como parámetros tenga el constructor o método. Mejor en el mismo orden en el que se encuentren declarados.
@return
En métodos.
@exception @throws @see
@deprecated
Stockbyte.Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. CD-DVDNum. V07
En clases e interfaces. Se pueden poner varios. Es mejor ponerlas en orden cronológico.
En constructores y métodos. Mejor en el mismo orden en el que se han declarado, o en orden alfabético. Es equivalente a @exception. Podemos poner varios. Comenzaremos por los más generales y después los más específicos. En cualquier parte de la documentación. Marca código que ha pasado a estar obsoleto, para el que se recomienda dejar de usarlo y eventualmente, sustituirlo por algún otro método, clase, etc.
Para saber más Si quieres conocer cómo obtener a través de Javadoc la documentación de tus aplicaciones, sigue los siguientes enlaces: Documentación con Javadoc. Documentación de clases y métodos con Javadoc.
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
29/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
9.4.- Documentación externa. Requisitos de la aplicación: diagramas de clases y de casos de uso.
Debes conocer En este módulo nos vamos a centrar en la documentación interna del código, principalmente mediante comentarios Javadoc, que hemos venido viendo en los apartados anteriores, y que entrarán de lleno en el ámbito de vuestra actividad profesional al término de este ciclo formativo. No obstante, también existen todo un conjunto de técnicas bastante estandarizadas, que permiten aportar documentación externa al código. Aunque no va a ser materia en la que profundicemos, sí que conviene que conozcas su existencia, y que cuando veas algunos de los diagramas que se usan para documentar la estructura de clases de nuestros programas, sepáis interpretar la información que contienen. No se trata por tanto de una materia que debáis estudiar en profundidad, pero sí es importante que al menos leáis la información que se proporciona en los siguientes enlaces. Requisitos: diagramas de clases. Modelo de Clases en UML
Requisitos: diagramas de casos de uso. Manual de diagramas de casos de uso en UML
(384 KB)
Información básica sobre UML. Información básica sobre UML en Wikipedia
Anexo I. Ejemplos resueltos en pseudocódigo y Java. En este Anexo te vamos a proporcionar algunos ejemplos más desarrollados en pseudocódigo y en Java, para que puedas compararlos y usarlos de referencia para cuando tengas que resolver tus propios programas. Esperamos que te resulten clarificadores y útiles. De momento en estos ejercicios no nos preocupamos (ni nos ocupamos) de controlar la entrada, y asumimos que los datos que recibe el programa son correctos, según las especificaciones que se dan en el mismo, sin que se comprueben situaciones de error, ni valores incorrectos, salvo que se indique expresamente lo contrario en el enunciado.
Ejemplos resueltos en pseudocódigo y Java Nº Ejercicio y estructuras implicadas
Enunciado
Solución en pseudocódigo
Solución en Java
Ejercicio 1 switch
Hacer un programa que permita elegir entre dibujar una recta, un punto o un rectángulo, o bien terminar sin hacer nada. Para ello, debe mostrarnos un menú en el que nos proporcione las opciones disponibles, y cuya salida sea simplemente escribir por pantalla cuál ha sido la opción elegida.
Pseudocódigo Ejercicio 1 (1 KB)
Java Ejercicio (17 1 KB)
Ejercicio 2 while
Queremos hallar el producto de varios números enteros no negativos introducidos por teclado. El proceso debe terminar cuando se meta un número negativo, mostrando el producto de los números e indicando cuántos números se han multiplicado. (Solución usando while)
Pseudocódigo Ejercicio 2 (1 KB)
Java Ejercicio 2 (17 KB)
Pseudocódigo Ejercicio 3 (2 KB)
Java Ejercicio 3 (18 KB)
Se trata de calcular la suma y la media aritmética para una serie de números enteros no nulos leídos desde teclado. La cantidad de números a leer será lo primero que deberemos solicitar al usuario.
Ejercicio 3 while , if-else
Si el valor fuera negativo, terminará la ejecución con un mensaje indicando el error: no es posible leer una cantidad negativa de números, y terminará. Si el valor fuera 0, nos mandará un mensaje indicando que no se ha leído ningún número, y terminará. Si el valor fuera positivo, nos leerá la cantidad de números indicada, y calculará su suma y su media aritmética. Una vez conocida dicha cantidad, se repetirá un ciclo tipo while que se encargará de leer los números necesarios, de manera que si un número es negativo, se descartará y se volverá a leer otro número en su lugar. Así, el programa terminará su ejecución cuando se hayan leído todos los números requeridos. Como salida nos mostrará:
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
30/32
2017-6-23
educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412 El total de intentos de lectura que se han hecho. El total de números correctos (no nulos) que se han leído. La suma de los números no nulos leídos y su media aritmética.
Ejercicio 4 do-while
Resolver el mismo problema del ejercicio 3 anterior, pero en este caso, usando do-while.
Ejercicio 5 for
Resolver el mismo problema del ejercicio 3, pero con una pequeña diferencia. En este caso lo que se leerá al comienzo no será la cantidad de números enteros no nulos que deben leerse, sino el total de intentos que deben hacerse. Al finalizar, se indicará igual que antes los intentos realizados, el total de números correctos (no nulos) que se han leído, la suma de los mismos y su media aritmética. En este caso, al ser un número fijo de intentos a realizar, lo más adecuado es resolverlo usando for.
Ejercicio 6 if-else
Realizar un programa que calcule el índice de masa corporal (IMC) de una persona a (IMC = peso [kg] / altura 2 [m]) e indique el estado en el que se encuentra esa persona en función del valor de IMC.
Pseudocódigo Ejercicio 4 (2 KB)
Java Ejercicio 4 (18 KB)
Pseudocódigo Ejercicio 5 (2 KB)
Java Ejercicio 5 (18 KB)
Pseudocódigo Ejercicio 6 (2 KB)
Java Ejercicio 6 (17 KB)
Diagnóstico según IMC Valor de IMC < 16
Diagnóstico Criterio de ingreso en hospital.
de 16 a 17
Infrapeso.
de 17 a 18
Bajo peso.
de 18 a 25
Peso normal (saludable).
de 25 a 30
Sobrepeso (obesidad de grado I).
de 30 a 35
Sobrepeso crónico (obesidad de grado II).
de 35 a 40
Obesidad premórbida (obesidad de grado III).
>40
Obesidad mórbida (obesidad de grado IV).
Se resolverá usando sentencias if-else anidadas. Ejercicio 7 if
Hacer un programa que intercambie el valor de dos variable, a y b, cuyos valores se han leído desde teclado. El tipo de las variables, puede ser cualquiera en realidad, pero va a suponer que es entero.
Pseudocódigo Ejercicio 7 (2 KB)
Java Ejercicio 7 (17 KB)
Ejercicio 8 if for
Queremos leer una serie de 10 números enteros desde teclado, indicando cuántos de ellos son positivos, cuántos negativos, y cuántos cero. También se pide calcular la suma de los negativos y su media, la suma de los positivos y su media, y la suma de los 100 y su media. Se desea mostrar convenientemente los valores calculados.
Pseudocódigo Ejercicio 8 (3 KB)
Java Ejercicio 8 (17 KB)
Pseudocódigo Ejercicio 9 (2 KB)
Java Ejercicio 9 (18 KB)
Pseudocódigo Ejercicio 10 (2 KB)
Java Ejercicio 10 (18 KB)
Queremos hacer un algoritmo para calcular el sueldo neto semanal de un trabajador o trabajadora y la deducción por impuestos a aplicarle en función de las horas trabajadas en esa semana. Se supone que se introducen por teclado el número de horas trabajadas en la semana (que no puede ser negativo) junto al nombre del trabajador o de la trabajadora. Se debe tener en cuenta que: Las horas se pagan a tarifa normal hasta las primeras 40 horas, y como tarifa extra las que pasen de esa cantidad. La tarifa normal es de 7,5 € la hora. La tarifa extra es un 50% más cara que la tarifa normal. Una vez calculado el sueldo bruto se calculan los impuestos a deducir, teniendo en cuenta lo siguiente: Los primeros 150 € semanales no pagan impuestos. Los siguientes 150 € pagan una tasa de impuestos del 15% El resto de salario paga una tasa de impuestos del 35% Se necesita escribir como salida el nombre del trabajador o de la trabajadora, su sueldo bruto, los impuestos a pagar y el sueldo neto.
Ejercicio 9 if-else do-while
Ejercicio 10 while do-while if
Queremos calcular el factorial de un número entero no negativo leído desde teclado. Aunque existe una solución recursiva para este problema, no es la que aplicaremos aquí. En su lugar usaremos la solución iterativa. El factorial de un número entero positivo o nulo n se representa como n! y se define como: n! = 1 , si n vale 0. n! = n * (n-1) * (n-2) * (n-3) * … * 2 * 1 , si n > =1
Anexo.- Licencias de recursos. Licencias de recursos utilizados en la Unidad de Trabajo. Recurso (1)
Datos del recurso (1)
Recurso (2)
Datos del recurso (2)
Autoría: Stockbyte. Licencia: Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. Procedencia: CD-DVD Num. V43
Autoría: Stockbyte. Licencia: Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. Procedencia: CD-DVD Num. V43
Autoría: Stockbyte. Licencia: Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. Procedencia: CD-DVD Num. V07
Autoría: Stockbyte. Licencia: Uso educativo no comercial para plataformas públicas de Formación Profesional a distancia. Procedencia: CD-DVD Num. V07
Autoría: Yan Shuangchun
Autoría: Crazynorvegian
http://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=10412
31/32
