Prog Unidad 02

3/3/2019 https://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?
id=3382
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?
-Efectivamente, María, como la gran mayoría de los lenguajes de programación, Java incorpora estructuras que nos permiten
tomar decisiones, repetir código, etc. Cada estructura tiene sus ventajas, inconvenientes y situaciones para las que es
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-DVD Num. V43
https://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=3382 1/63
3/3/2019 https://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?id=3382
1.- Introducción.
En la unidad anterior, 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
No son sólo los datos de entrada aportados por un usuario, existen más variables. Sigue con atención la unidad y lo
comprenderás.
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 tiene
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 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
Piensa en un fontanero (programador), principalmente trabaja con agua (datos) y se encarga de hacer que ésta fluya públicas de Formación
Profesional a
por donde él quiere (programa) a través de un conjunto de tuberías, codos, latiguillos, llaves de paso, etc. (sentencias distancia.
CD-DVD Num. 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.
Los tipos de estructuras de programación que se emplean para el control del flujo de los datos, en cualquier lenguaje, son los siguientes:
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: 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.
Además de las sentencias típicas de control de flujo, en esta unidad haremos una revisión de las sentencias de salto, que aunque son
altamente desaconsejables en la mayoría de casos, y generalmente resulta innecesario recurrir a ellas, es necesario conocerlas.
Además, como nuestros programas podrán generar errores y situaciones especiales, echaremos un vistazo al manejo de excepciones en
Java. Posteriormente, analizaremos la mejor manera de llevar a cabo las 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.
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 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 las nociones básicas a la hora de escribir
programas.
© Stockbyte.
para plataformas públicas de
Formación Profesional a distancia.
CD-DVD Num. CD165
Este epígrafe lo utilizaremos para reafirmar cuestiones que son obvias y que en el transcurso de la unidad anterior 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.
Bloque de sentencias en una sola línea Bloque de sentencias de varias líneas
{
sentencia1;
sentencia2;
{sentencia1; sentencia2;...; sentenciaN;}
…;
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 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 Bloque de sentencias con el código organizado
Bloque de sentencias con declaración de
para en declaración de variables, entrada de datos,
variables.
ejecución procesamiento y salida
secuencial.
Sentencias
en orden Sentencias y declaraciones de variables. (0.01 Sentencias, declaraciones y organización del
secuencial. (0.01 MB) código. (0.01 MB)
MB)
En este primer En este segundo archivo, se declaran al principio En este tercer archivo, podrás apreciar que se ha
archivo, las las variables necesarias. En Java no es organizado el código en las siguientes partes:
sentencias imprescindible hacerlo así, pero sí que antes de declaración de variables, petición de datos de
están utilizar cualquier variable ésta debe estar entrada, procesamiento de dichos datos y obtención
colocadas en previamente declarada. Aunque la declaración de de la salida. Este tipo de organización está más
orden dicha variable puede hacerse en cualquier lugar estandarizada y hace que nuestros programas ganen
secuencial. de nuestro programa. 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.
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.
Incorrecto. Aunque la afirmación es correcta, deberías revisar el resto de respuestas.
Incorrecto. No es que sea falsa, pero, ¿es esta la opción más correcta?
No es correcto. La afirmación también es correcta, pero deberías revisar el resto de respuestas.
Correcto. Todas y cada una de las afirmaciones de esta pregunta son correctas. Las sentencias es imprescindible que
acaben en punto y coma, para indicar una sentencia nula basta con incluir una línea con un punto y coma, y los bloques de
sentencias se delimitan con llaves.
Solución
1. Incorrecto
2. Incorrecto
3. Incorrecto
4. Opción correcta
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.
CD-DVD Num. CD109
Al principio de la unidad nos hacíamos esta 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. Estas estructuras constan de una 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.
Por ejemplo, si el valor de una variable es mayor o igual que 5 (condición verdadera) se imprime por pantalla la palabra APROBADO
(primer grupo de sentencias, en este caso una sola) y si es menor que 5 (condición falsa) se imprime SUSPENSO (segundo grupo de
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 booleano só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 simple o estructura if.

Estructura de selección compuesta o estructura if-else.
Estructura de selección basada en el operador condicional, representado en Java por ?.
Estructura de selección múltiple o estructura switch.
A continuación, detallaremos las características y funcionamiento 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:

if / if-else.
La estructura if es una estructura selectiva, (o estructura de selección o estructura condicional, ya
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:
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
Si expresion Entonces secuencia1
secuencia1 Sino
Fin Si secuencia2
Fin Si
Funcionamiento:
La secuencia de instrucciones secuencia1 se ejecuta si y solo
Funcionamiento:
si en el caso de que la expresion se evalúe como verdadera.
Si expresion es evaluada como verdadera, se ejecuta secuencia1 y en
caso contrario, no se ejecuta secuencia1 y sí se ejecuta secuencia2.
No se hace nada en caso contrario, simplemente "se omite" la
ejecución de secuencia1.
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 Sino 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 simple. E
Sintaxis para el caso de ejecución condicional de Sintaxis para el caso de ejecución condicional de Sintaxis para el caso de ejecu
una sola rama con una sola sentencia una sola rama con un bloque de sentencias de dos ramas y una sola sente
if <code>(expresion_logica){
if (expresion_logica)
sentencia1;
sentencia1;
if <code>(expresion_logica) sentencia2;
else
sentencia1; …;
sentencia2;
sentenciaN;
}
Funcionamiento:
Funcionamiento:
Si la evaluación de la expresion_
Si la evaluación de la expresion_logica ofrece un resultado verdadero, se ejecuta la sentencia1 o bien el
primer bloque de sentencias. Si,
bloque de sentencias asociado. Si el resultado de dicha evaluación es falso, no se ejecutará ninguna
falso, no se ejecutará la primera
instrucción asociada a la estructura condicional.
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
Realiza un programa en pseudocódigo que cálcule la nota de un examen de tipo test de 20 preguntas, donde ha habido 12
aciertos, 3 errores y 5 preguntas sin contestar. Para calcular la nota final tienes que tener en cuenta que cada error restará la
mitad de un acierto, y que obviamente las preguntas sin contestar ni restarán ni sumarán. La nota final se calculará de 0 a 10 y
en la formula del cálculo de la nota final no se podrán usar literales numéricos para indicar el número de aciertos, de errores y
de preguntas sin contestar (deberán ser una variable local).
Después de realizar el paso anterior haz que el programa muestre la calificación no numérica de dicho examen:
Si la nota es menor de 5, la calificación será "INSUFICIENTE".

Si la nota es mayor o igual a 5 y menor que 6, la calificación será "SUFICIENTE".
Si la nota es mayor o igual a 6 y menor que 7, la calificación será "BIEN".
Si la nota es mayor o igual a 7 y menor que 9, entonces la calificación será "NOTABLE".
Si la nota es mayor o igual a 9 y menor o igual a 10, entonces la califación será de "SOBRESALIENTE".
Para realizar este ejercicio deberás combinar las estructuras condicionales aprendidas en este apartado.
Programa SentenciasCondicionales

/* Vamos a realizar el cálculo de la nota de un examen de tipo test. Para ello, tendremos en cuenta el número
* total de preguntas, los aciertos y los errores. Dos errores anulan una respuesta correcta.
* Finalmente, se muestra por pantalla la nota obtenida, así como su calificación no numérica.
* La obtención de la calificación no numérica se ha realizado combinando varias estructuras condicionales,
* mostrando expresiones lógicas compuestas, así como anidamiento.
*/

Inicio
/* Declaración de variables*/
numeroAciertos, numeroErrores, numeroPreguntas: entero
nota: real
calificacion: cadena

/* Inicialización de variables*/
numeroAciertos <-- 12
numeroErrores <--3
numeroPreguntas <-- 20
nota <-- 0
calificacion <-- ""

/*Procesamiento de datos*/
nota <-- ((numeroAciertos - (numeroErrores/2))*10)/numeroPreguntas

Si nota < 5 Entonces
calificacion <--"INSUFICIENTE"
Sino
/* Cada expresión lógica de estos if está compuesta por dos expresiones lógicas combinadas a través del operado
* Para que la expresión lógica se cumpla (sea verdadera) la variable nota debe satisfacer ambas condiciones si
*/
Si nota >= 5 Y nota < 6 E<code>ntonces
calificacion <-- "SUFICIENTE"
Fin Si
calificacion <-- "BIEN"
Fin Si
calificacion <-- "NOTABLE"
Fin Si
Si nota >= 9 Y nota <= 10 E<code>ntonces
calificacion <-- "SOBRESALIENTE"
Fin Si
Fin Si

/*Salida de información
Escribir ("La nota obtenida es: " , nota)
Escribir ("y la calificación obtenida es: " , calificacion)
Fin
Ahora es el momento de realizar el ejercicio en Java. Intenta resolver el mismo enunciado anterior, pero esta vez usando las
estructuras if e if-else que Java proporciona.
A continuación encontrarás dos posibles soluciones para el ejercicio. La primera solución corresponde con el
pseudocódigo anterior, la segunda solución es una solución diferente que merece la pena que analices con antención. La
primera es más fácil de entender y las segunda es un poco más compleja, pero ambas cumplen con su cometido.
Presta especial atención a los comentarios incorporados en el código fuente, así como a la forma de combinar las
estructuras condicionales y a las expresiones lógicas utilizadas en ellas.
Versión 1 de la solución (equivalente al pseudocódigo).(java - 2.48 KB)
Versión 2 de la solución.(java - 2.48 KB)
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 un programa.
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.
Incorrecto. Sí resulta posible que la sentencia que imprime el mensaje en pantalla sea ejecutada. ¿Pero será siempre, o
será cuando el resto de la división entre 2 del contenido de la variable numero, sea cero?
Efectivamente. Aunque detrás de la expresión lógica de la estructura if existe un punto y coma, la sentencia que imprime el
mensaje en pantalla siempre se ejecutará.
Incorrecto. El punto y coma colocado justo detrás de la expresión lógica de la estructura if representaría la sentencia vacía,
y pone fin a la sentencia condicional. Por tanto, la impresión del mensaje no quedaría asociada al resultado de la
evaluación de dicha expresión lógica.
Solución
1. Incorrecto
2. Opción correcta
3. Incorrecto
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
Falso
Es falso, ya que cualquier estructura tipo switch puede construirse a base de anidar estructuras if/else.
La estructura tipo switch es más eficiente para resolver un problema con múltiples posibilidades, que el uso de estructuras if/else
anidadas para resolver ese mismo problema.
Verdadero Falso
Verdadero
Es verdadero, ya que al ejecutar el switch, se evalúa la expresión una única vez, y dependiendo del valor que tome, nos
lleva a ejecutar el grupo de sentencias asociado, sin tener que volver a evaluar ninguna expresión más. Sin embargo,
para conseguir eso a base de usar if/else anidados, cada caso debe ser comprobado, y si no se cumple, hay que seguir
haciendo comprobaciones, evaluando las condiciones para decidir si se trata de cada caso particular. De esta forma, si el
caso fuese el último de la lista, obliga a haber evaluado y comprobado todas las condiciones de los casos previos antes
de descartarlos.
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
datos, ya que todo lo anterior es idéntico y destacamos en negro lo que no se corresponde
Segun (expresion) Hacer Algoritmo Sentencias_condicionales

Caso valor1: ...
sentencia1_1; // Procesamiento de datos
sentencia1_2; nota <-- ((numeroAciertos - (numeroErrores/2))*10)/numeroPreguntas
…. Segun (nota) Hacer
Caso valor2: Caso 0,1,2,3,4:
sentencia2_1; calificacion <--"INSUFICIENTE"
sentencia2_2; Caso 5:
…. calificacion <-- "SUFICIENTE"
Caso …. Caso 6:
Caso valorN: calificacion <-- "BIEN"
sentenciaN1; Caso 7,8:
sentenciaN2; calificacion <-- "NOTABLE"
…. Caso 9,10:
[De Otro Modo: calificacion <-- "SOBRESALIENTE"
sentenciaOC1; De Otro Modo:
sentenciaOC2;] escribir "Se ha introducido una calificación errónea."
Fin Segun calificacion <-- "CALIFICACIÓN ERRÓNEA"
Fin Segun
... Fin
Funcionamiento:
Comenzamos evaluando la expresión que aparece detrás de Segun y que queda delimitada por el propio Segun y por el comienzo de la pr
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
ejemplo: Caso 0,1,2,3,4:).
El valor obtenido de evaluar la expresión, que en principio puede ser de cualquier tipo discreto y ordenado (enteros, cadenas de caracteres
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 etiqu
Si el valor no coincidiera con ninguna etiqueta ni estuviera incluido en el rango establecido por ninguna, se pasaría a la etiqueta De
si no hay otros casos relevantes para los que haya que hacer algo diferente) y se ejecutarían las sentencias que contenga, que quedan de
<code>Fin Segun que además pone fin a la sentencia de selección múltiple.
Tras haber entrado en cualquier etiqueta Caso o en De Otro Modo y haber ejecutado las sentencias que contenga, el control del flujo salta
Segun.
Quizás esta estructura 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 En Otro Caso, 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
Falso
Es falso. La etiqueta En Otro Caso puede incluirse o no. Si no se incluye expresamente, y se presenta cualquier valor de
la expresión no contemplado como caso con ninguna etiqueta, simplemente la sentencia terminará sin haber hecho
nada.
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; Donde expresión debe ser del tipo char, byte, short o int, y las constantes de cada
case valor2:
deben ser de este tipo o de un tipo compatible. Sólo desde la versión 7 del lenguaje
permiten expresiones de tipo String en la expresión, pero esto no funcionará con ve
sentencia2_1;
anteriores del lenguaje.
sentencia2_2;
La expresión debe ir entre paréntesis.
…; break; 
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 sente
ruptura break o no. No hay diferencia de funcionamiento. Se permite por mantener la
case valorN: estructura de las demás etiquetas, pero el compilador no lo necesita si el default va
sentenciaN1; y como se ve en el código, puesto que la llave de cierre delimita el final del switch.
sentenciaN2;
…;
break;
default:
sentencias-default;
}
Funcionamiento:
Las diferentes alternativas de esta estructura estarán precedidas de la cláusula case que se ejecutará cuando el valor asociado al case coi
el valor obtenido al evaluar la expresión del switch.
En las cláusulas case, no pueden indicarse expresiones condicionales, rangos de valores o listas de valores (aunque otros lenguajes
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),
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
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, s
ejecutarán todas las instrucciones asociadas hasta la aparición de una sentencia break de ruptura (la sentencia break se analizará en epíg
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 "efec
cascada", de forma que seguirá ejecutando las sentencias de la siguiente cláusula case, y así sucesivamente las de todas las que sigan, h
en alguna encuentre una sentencia break, o hasta que alcance el final de la sentencia. Esto puede ser aprovechado para darle más versati
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
Realiza un programa en Java que cálcule la nota de un examen de tipo test de 20 preguntas, donde ha habido 17 aciertos, 3
errores y 0 preguntas sin contestar, siguiendo la formula explicada en apartados anteriores. La nota calculada debes
obtenerla como un número entero, aunque los cálculos los puedes hacer con números reales. Después de calcular la
nota final, haz que el programa muestre la calificación no numérica de dicho examen:
Si la nota es 0, 1, 2, 3 o 4, la calificación será "INSUFICIENTE".

Si la nota es 5, la calificación será "SUFICIENTE".
Si la nota es 6, la calificación será "BIEN".
Si la nota es 7 o 8, entonces la calificación será "NOTABLE".
Si la nota es 9 o 10, entonces la califación será de "SOBRESALIENTE".
Para realizar este ejercicio deberás usar obligatoriamente la estructura switch.
Código de ejemplo con switch:

Solución del ejercicio sobre el uso de la estructura condicional múltiple switch. (java - 2.77 KB)
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 if y 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.
CD-DVD Num. 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). HuBoro

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 contador. Por el contrario, los bucles while y do...while se consideran
bucles controlados por sucesos.
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
Si has tenido problemas para completar todos los huecos, repasa de nuevo el apartado para ver cuáles eran las tres
operaciones que generalmente estos bucles realizan sobre la variable contador que controla su ejecución, así como los
aspectos importantes a tener en cuenta.
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 repe
Representación en pseudocódigo
Veamos cómo quedaría e

Se presenta en gris atenu
Algoritmo Repetit
// En este e
// para rep
Inicio
// Decla
numero, c

// Inic
numero <
Se ponen en negrita las variables y valores que cambiarán, y sin negrita las partes de la estructura que serían fijas. resultado

//Salida
Escribir
Para variableContador <-- valorInicial Hasta valorFinal Con Paso incremento
acciones Escribir
Fin Para
// Utiliz
// La cab
// de con
// hasta
// cada i
// unidad
Para cont
Hace
res
Esc
Fin Para
Fin Algoritmo
Funcionamiento:
Primero se inicializa la variable de control del bucle (variableContador) asignándole el valor valorInicial.
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 bu
Al terminar la iteración, automáticamente se incrementa el valor de variableContador en la cantidad que se indique como paso, indicada po
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)

Donde inicialización es una expresión en la que se
sentencia; 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
Estructura for con un bloque de sentencias: verdadera, el cuerpo del bucle estará repitiéndose.
Cuando la condición deje de cumplirse, terminará
for (inicialización ; condición ; incremento){ la ejecución del bucle.
sentencia1; Donde incremento indica la manera en la que la
sentencia2;
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.
sentenciaN;
}
Ejercicio Resuelto
En el apartado anterior hay un ejemplo en pseudocódigo sobre como calcular la tabla de multiplicar del 7 usando una estructura
repetitiva tipo for. Lo que te proponemos ahora es que realices el mismo ejercicio pero ahora en Java. ¡¡Seguro que lo
consigues!!
Una posible solución del ejercicio podría ser la siguiente:
/**
* Mostrar la tabla de 7 usando una estructura repetitiva for.
* @author Profesor
*/
public class RepetitivaFor {
/**
* En esta solución se utiliza la estructura repetitiva for para representar
* en pantalla la tabla de multiplicar del siete.
*/
public static void main(String[] args) {
// Declaración e inicialización de variables
int numero = 7;
int contador;
int resultado = 0;
/* Paso 1. Mostrar la cabecera de la tabla */

System.out.println("Tabla de multiplicar del " + numero);
System.out.println(".............................. ");
/* Paso 2. Calcular la tabla de multiplicar del 7 usando un bucle for.

* La cabecera del bucle incorpora la inicialización de la variable
* de control, la condición de multiplicación hasta el 10 y el
* incremento 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.
*/
for (contador = 1; contador <= 10; contador++) {
resultado = contador * numero;
System.out.println(numero + " x " + contador + " = " + resultado);
}
/* Nota: A través del operador + aplicado a cadenas de caracteres,
* concatenamos los valores de las variables con las cadenas de
* caracteres que necesitamos para representar correctamente la
* salida de cada multiplicación.
*/
}
}
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.
Un bucle que se ejecutaría una única vez.
Efectivamente. La construcción de la cabecera del bucle ha prescindido de cada una de las partes típicas (inicialización,
condición e iteración), pero al mantener los puntos y comas en los lugares adecuados, el conjunto de instrucciones que
pudieran incluirse en el cuerpo del bucle estarán ejecutándose eternamente.
Incorrecto. La sintaxis es válida y lo que estaríamos creando es un bucle infinito.
Incorrecto. Al no existir inicialización, condición ni iteración estaríamos construyendo un bucle infinito.
Solución
1. Opción correcta
2. Incorrecto
3. Incorrecto
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.
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
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
Espero que no te haya resultado complicado. Si es así, repasa el apartado para afianzar conceptos.
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 útil en aquellos casos en los que las instrucciones que
forman el cuerpo del bucle podría ser necesario ejecutarlas o no.
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.
Solución
1. Correcto
2. Incorrecto
3. Incorrecto
4. Correcto
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.
Pseudocódigo para la estructura repetitiva tipo while 
Veamos cómo quedaría el pseudocódigo para el ejemplo que permite representar en

Se presenta en gris atenuado todo el código, salvo el de la estructura del bucle while
Algoritmo 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
Mientras condición Hacer
sentencia1 <code>/* Inicialización de variable
sentencia2 numero <-- 7
... resultado <-- 0
sentenciaN
Fin Mientras /* Salida de información <code>*/
Escribir "Tabla de multiplicar del " , numero
Escribir ".............................. "

/* Utilizamos ahora el bucle while. * Primero inicia
contador <-- 1 <code> /*
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 e
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
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 Sintaxis para el caso de un bloque de sentencias en el cuerpo del
bucle while 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.
Ejercicio Resuelto
En el apartado anterior se puso un ejemplo en pseudocódigo sobre como calcular la tabla de multiplicar del 7 usando un bucle
tipo while. Ahora te pedimos que intentes realizarlo en Java, para así poner en práctica los conocimientos de este apartado.
¡¡Seguro que podrás!!
Una solución posible sería:
/**
* Mostrar la tabla de 7 usando una estructura repetitiva while.
* @author Profesor
*/
public class RepetitivaWhile {
/**
* En esta solución se utiliza la estructura repetitiva while para representar
* en pantalla la tabla de multiplicar del siete.
*/
int numero = 7;
int contador;
int resultado=0;

System.out.println ("Tabla de multiplicar del " + numero);
System.out.println (".............................. ");
/* Paso 2. Calcular la tabla de multiplicar del 7 usando un bucle while.

* En este caso la inicialización de la variable contador hay que hacerla
* antes de entrar en el bucle y la actualización del contador se realizaría
* dentro del bucle.
*/
contador = 1; //inicializamos la variable contadora

while (contador <= 10){ //Establecemos la condición del bucle
//Modificamos el valor de la variable contadora, para hacer que el
//bucle pueda seguir iterando hasta llegar a finalizar.
contador++;
}
}
}
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á
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) System.out.println("Imprimiendo desde dentro del bucle...");
Verdadero Falso
Verdadero
La condición del bucle siempre será cierta (recuerda que un literal booleano es en sí mismo una expresión booleana, así
que el literal true es una expresión que se evalúa siempre como true) y estará continuamente ejecutándose. ¡¡Hay que
evitar el uso de este tipo de condiciones!!
Normalmente sólo reflejan una mala construcción de la lógica del programa, porque para no caer en bucles infinitos
obligan a incluir sentencias de salto incondicional en el interior del bucle, que se ejecutan dentro de una estructura
condicional que comprueba el momento en que debe salirse del bucle. ¡¡¡Para eso está la condición del bucle, para
comprobar ahí cuál es la condición de salida!!
La salida natural de un bucle es tras comprobar la condición de salida para ver si hay que volver a hacer otra iteración o
no, y todo lo que sea esquivar esa forma de hacer las cosas, es generar código poco claro, difícil de entender y de
mantener, lo que redunda en un mayor coste.
4.4.- Estructura repetitiva do-while.

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.
¡Acertaste! Ya lo indica el nombre de la estructura: primero hacer (do), luego preguntar para seguir mientras sea cierta
(while).
¡Incorrecto! Los bucles tipo for pueden no ejecutarse nunca si cuando se llega a ellos la variable de control del bucle ya ha
alcanzado el valor de salida, o en general, cuando se ha alcanzado la condición de salida.
No es correcto. El ciclo while lo primero que hace es comprobar la condición, y si es falsa, no se ejecutaría el ciclo ninguna
vez.
No has acertado. Los ciclos for/in se ejecutan una vez por cada elemento que haya en el array o en la colección, por lo que
si no hay ningún elemento, no se ejecutaría ninguna vez.
¿Estas de broma? Ni siquiera se trata de una estructura de control repetitiva.
Solución
1. Opción correcta
2. Incorrecto
3. Incorrecto
4. Incorrecto
5. Incorrecto
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 
Veamos cómo quedaría el pseudocódigo para el ejemplo que permite representar en

Se presenta en gris atenuado todo el código, salvo el de la estructura del bucle do-wh
Algoritmo 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
Hacer
sentencia1 //<code> Inicialización de variables
sentencia2 numero <-- 7
... resultado <-- 0
sentenciaN
Mientras Que (condición) // Salida de información <code>
Escribir "Tabla de multiplicar del " , numero
Escribir ".............................. "

// Utilizamos ahora el bucle while. // Primero inicia
contador <-- 1 <code> Mientras Que 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 r
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 s
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 instrucc
ejecutarse nunca.
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 Sintaxis para el caso de un bloque de sentencias en el cuerpo del
bucle do-while bucle do-while
do{
do sentencia1;
sentencia; …;
while (condición); 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".
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.
Incorrecto. No hay que duplicar esas sentencias, simplemente se entra siempre al bucle una primera vez, antes de haber
comprobado la condición, por lo que queda garantizada la ejecución al menos esa primera vez sin necesidad de
duplicarlas.
¡¡Correcto!! Presta atención al detalle: no basta con una sentencia que modifique la variable de control del ciclo, ya que si
ello no implica que la condición de salida se alcance en algún momento, estaríamos igualmente en un bucle infinito.
Totalmente incorrecto. Me lo acabo de inventar... además, si se trata de un bucle do-while, la posibilidad de que no se
ejecute nunca, no existe.
Incorrecto. No es así, una de las tres sí que es correcta.
Solución
1. Incorrecto
2. Opción correcta
3. Incorrecto
4. Incorrecto
Ejercicio Resuelto
Al igual que se pedía en apartados anteriores, ahora vamos os vamos a pedir que realiceís el ejercicio de la tabla de multiplicar
del número 7, pero usando un bucle do-while. En el apartado anterior dispones de dicho ejercicio resuelto pero en pseudocódigo
para que te sirva de guía. ¡¡Seguro que puedes conseguirlo!!
Una solución posible es la siguiente:
/**
* Mostrar la tabla de 7 usando una estructura repetitiva do-while.
*
* @author Profesor
*/
public class RepetitivaTipoDoWhile {
/**
* En esta solución se utiliza la estructura repetitiva while para
* representar en pantalla la tabla de multiplicar del siete.
*/

int numero = 7;
int contador;
int resultado = 0;

System.out.println("Tabla de multiplicar del " + numero);
System.out.println(".............................. ");
/* Paso 2. Calcular la tabla de multiplicar del 7 usando un bucle

* do-while.
* Al igual que ocurría en el bucle do-while, la variable contador
* hay que inicializarla antes de entrar en el bucle, pero hay que tener
* en cuenta que el bucle se ejecutará al menos una vez.
* Después, la variable contador se modifica dentro del bucle para que
* el bucle termine en algún momento y no se convierta en un bucle
* infinito.
*/
contador = 1; //Inicializamos la variable contador antes de empezar el bucle

do {
//Modificamos el valor de la variable contadora, para hacer que el
//bucle pueda seguir iterando hasta llegar a finalizar (no hasta el infinito)
contador++;
} while (contador <= 10); //Establecemos la condición del bucle
}
}
Recomendació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
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
Verdadero
Es verdadero porque si no hay nada dentro del bucle que modifique el valor de la condición, cuando lleguemos a
evaluarla ya habremos ejecutado las sentencias del mismo una vez, y pueden pasar dos cosas:
1.- Que la condición sea falsa, en cuyo caso hemos alcanzado la condición de salida, y no se ejecutará ninguna vez
más (pero ya se había ejecutado una).
2.- Que la condición sea verdadera, en cuyo caso volverá ejecutarse de nuevo, pero como nada hay en esa iteración
que modifique el valor de la condición, al final de cada iteración siempre vamos a encontrarnos con que sigue siendo
verdadera, por lo que seguiremos repitiendo iteración tras iteración, ¡¡hasta el infinito y más allá!!
4.5.- Ejemplos resueltos.

En este apartado 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. Lo ideal es que intentes hacerlos por tu cuenta antes de ver la
solución, pero no te preocupes si de momento tienes dificultades para resolverlos.
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 Solución en Solución
Enunciado
estructuras pseudocódigo en Java
implicadas
Hacer un programa que permita elegir entre dibujar una recta, un punto o un rectángulo,
Java
Ejercicio 1 o bien terminar sin hacer nada.
Pseudocódigo Ejercicio
switch Para ello, debe mostrarnos un menú en el que nos proporcione las opciones
Ejercicio 1 (1 KB) 1 (17 KB)
disponibles, y cuya salida sea simplemente escribir por pantalla cuál ha sido la opción
elegida.
Queremos hallar el producto de varios números enteros no negativos introducidos por

teclado. Java
Ejercicio 2 Pseudocódigo
El proceso debe terminar cuando se meta un número negativo, mostrando el producto Ejercicio
while Ejercicio 2 (1 KB)
de los números e indicando cuántos números se han multiplicado. 2 (17 KB)
(Solución usando while)
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.
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á.
Ejercicio 3 Si el valor fuera positivo, nos leerá la cantidad de números indicada, y calculará su Java
Pseudocódigo
while , suma y su media aritmética. Ejercicio
Ejercicio 3 (2 KB)
if-else Una vez conocida dicha cantidad, se repetirá un ciclo tipo while que se 3 (18 KB)
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á:
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.
Java
Ejercicio 4 Resolver el mismo problema del ejercicio 3 anterior, pero en este caso, usando do- Pseudocódigo
Ejercicio
do-while while. Ejercicio 4 (2 KB)
4 (18 KB)
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
Java
Ejercicio 5 deben leerse, sino el total de intentos que deben hacerse. Al finalizar, se indicará igual Pseudocódigo
Ejercicio
for que antes los intentos realizados, el total de números correctos (no nulos) que se han Ejercicio 5 (2 KB)
5 (18 KB)
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 Realizar un programa que calcule el índice de masa corporal (IMC) de una persona a Pseudocódigo Java
if-else (IMC = peso [kg] / altura2 [m]) e indique el estado en el que se encuentra esa persona Ejercicio 6 (2 KB) Ejercicio
en función del valor de IMC. 6 (17 KB)
Diagnóstico según IMC

Valor de IMC Diagnóstico
< 16 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.
Hacer un programa que intercambie el valor de dos variable, a y b, cuyos valores se han
Java
Ejercicio 7 leído desde teclado. Pseudocódigo
Ejercicio
if El tipo de las variables, puede ser cualquiera en realidad, pero va a suponer que es Ejercicio 7 (2 KB)
7 (17 KB)
entero.
Queremos leer una serie de 10 números enteros desde teclado, indicando cuántos de
Ejercicio 8 Java
ellos son positivos, cuántos negativos, y cuántos cero. También se pide calcular la suma Pseudocódigo
if Ejercicio
de los negativos y su media, la suma de los positivos y su media, y la suma de los 100 y Ejercicio 8 (3 KB)
for 8 (17 KB)
su media. Se desea mostrar convenientemente los valores calculados.
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:
Ejercicio 9 Las horas se pagan a tarifa normal hasta las primeras 40 horas, y como tarifa Java
Pseudocódigo
if-else extra las que pasen de esa cantidad. Ejercicio
Ejercicio 9 (2 KB)
do-while La tarifa normal es de 7,5 € la hora. 9 (18 KB)
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.
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
Ejercicio 10 aquí. En su lugar usaremos la solución iterativa. Java
while El factorial de un número entero positivo o nulo n se representa como n! y se define Pseudocódigo
Ejercicio
do-while como: Ejercicio 10 (2 KB)
10 (18 KB)
if
n! = 1 , si n vale 0.
n! = n * (n-1) * (n-2) * (n-3) * … * 2 * 1 , si n > =1
Recomendación
A partir de ahora, pensamos que no debemos ir más allá con el pseudocódigo, y 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
abordando otras 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 último que vamos a ver de pseudocódigo son los ejercicios resueltos expuestos en este apartado, para que puedas
compararlos con su solución en Java. Puedes consultar estos ejemplos cuando gustes, pero pensamos que lo más adecuado es
que los intentes resolver por tu cuenta antes de ver la solución.
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.
Las instrucciones de salto incondicional a veces han sido mal valoradas por la comunidad de
para plataformas públicas
de Formación Profesional a
programadores, pero en Java algunas de ellas son totalmente necesarias. También es verdad que las
distancia. CD-DVD Num. V43
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, continue, las etiquetas de salto y la sentencia
return.
No obstante, esos usos deben ser siempre compatibles con los principios de la programación estructurada, que promueven
seguir una serie de reglas:
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, while, for y do-while del siguiente modo:
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 break 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.
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, for y do-while del siguiente modo:
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?
Prueba a cambiarlos y a ejecutarlos para comprobar que efectivamente el resultado es el esperado, y si tienes alguna
duda, compártela con el resto de participantes del curso en el foro de la unidad.
Autoevaluación
La instrucción break puede utilizarse en las estructuras de control switch, while, for y do-while, pudiendo omitirse en la
cláusula default de la estructura switch.
Verdadero Falso
Verdadero
Si tenemos la cláusula default al final y no existe una sentencia break, directamente se pasaría a la finalización de la
estructura condicional múltiple, exactamente igual que si usáramos break
Ejercicio Resuelto
Usando la sentencia continue dentro un bucle tipo while, intenta que se muestre la secuencia siguiente de 6 líneas:
*
**
*
**
*
**
Fíjate que en las líneas impares se muestra solo un asterísco, y en las pares, dos asteríscos. ¿Se te ocurre como resolver el
problema usando un continue? Intenta primer solucionar el problema sin continue y luego con continue.
El siguiente código es una posible solución al problema sin usar continue:
public class SolucionEjercicioSinContinue {

public static void main(String[] args)
{
int i=0;
String cad="";
while (i<6)
{
i++;
if (i%2!=0) { System.out.println("*"); }
else System.out.println("**");
}
}
}
El mismo ejercicio usando un continue se hace un poco más complejo de entender (es el tipo de soluciones que tenemos
que evitar):
public class SolucionEjercicioContinue {
{
int i=0;
String cad="";
while (i<6)
{
i++;
cad="*";
if (i%2!=0) { System.out.println(cad); continue; }
cad+="*";
System.out.println(cad);
}
}
}
5.2.- Etiquetas.
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 <etiqueta>.
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
Ejercicio Resuelto
En este ejercicio que te proponemos ahora, te pedimos que diseñes un programa en Java que muestre por pantalla la siguiente
secuencia de asteriscos:
*
**
***
****
*****
Fíjate que en cada línea hay un asterisco más que en la anterior. Para realizar este ejercicio te proponemos que intentes
realizarlo usando dos bucles for, uno anidado dentro de otro, y que apliques la concatenación de cadenas.
Lo ideal, dado que estas en el apartado del salto incondicional, es que intentes realizarlo primero usando una sentencia break y
después sin usar un break.
Veamos como sería una posible solución al ejercicio usando una sentencia break:
public class SolucionEjercicioBreak {

{
String cad="";
for (int i=0;i<5;i++)
{
cad="";
for (int j=0;j<5;j++) {
cad=cad+"*";
if (i==j) break;
}
}
}
}
La solución anterior parece ideal: cuando el contador i y el contador j son iguales, se realiza el break y se sale del
bucle for interno; pero realmente hay una solución mucho mejor y más óptima sin usar la sentencia break:
public class SolucionEjercicioSinBreak {

{
String cad="";
for (int i=0;i<5;i++)
{
cad="";
for (int j=0;j<=i;j++) {
cad=cad+"*";
}
}
}
}
En esta segunda solución, simplemente se ha modificado la condición de permanencia en el bucle for interno (j<=i), la
cual es una solución elegante y fácil de entender.
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:
Para terminar la ejecución del método donde esté escrita, con lo que transferirá el control al punto desde 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.
Efectivamente, si encontramos un return antes de la finalización del código asociado a un método, éste devolverá el control
del flujo del programa a la instrucción inmediatamente posterior que existiese tras la invocación al método.
Incorrecto, no siempre se retorna un valor. La sentencia return puede ir o no acompañada por una expresión.
Incorrecto, return puede retornar un valor de un tipo y esto suele hacerse al final del método, pero no todas las demás
respuestas son correctas.
Solución
1. Opción correcta
2. Incorrecto
3. Incorrecto
6.- 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
6.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.
6.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
Falso
No se trata de probar los diferentes caminos de ejecución, se trata de probar con todos los posibles valores de entrada
del programa, lo cual puede resultar extremadamente tedioso.
6.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.
6.4.- Pruebas de caja blanca o pruebas 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
En las Pruebas de Caja Blanca nos centraremos en probar la estructura del código interno de la aplicación. En cambio,
las de Caja Negra se basan sólo en observar lo que entra y sale del programa, sin preocuparse de cómo está
implementado por dentro éste.
6.5.- Otras pruebas.
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:
Microscopio
Revisiones, inspecciones o recorridos: con base
Esta técnica no hace uso del computador para intentar erradicar errores en el código. En un recorrido se estudia el negra y tubo
listado del programa (junto con la especificación) para intentar hacer visibles los posibles errores. Es recomendable que portalentes
quien lleve a cabo el recorrido no sea la misma persona que desarrolló el código a revisar. d d
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
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, etc.
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.
6.6.- Realización de pruebas unitarias con JUnit.

Al comienzo de esta parte de la unidad dedicada a las
En blanco y negro, un médico realiza una prueba con un estetoscópio a un bebé.
pruebas y depuración de software, hablamos de un tipo
Stockbyte.
de pruebas que se aplican a cada una de las clases Uso educativo no comercial
que hayamos definido. Eran las pruebas unitarias . para plataformas públicas de
Formación Profesional a distancia..
CD-DVD Num. V43
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 tests 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.
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 tests 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 tests
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 tests de JUnit se incrementa la calidad y velocidad de generación de código.

La escritura de tests es sencilla.
Los tests JUnit chequean sus propios resultados y proporcionan información de retorno al instante.
Los tests JUnit incrementan la estabilidad del software.
Los tests 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 tests 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"
Autoevaluación
Indica si el siguiente párrafo, en su totalidad, es verdadero y falso:
"JUnit es un framework que facilita y simplifica la creación de pruebas unitarias en Java. Estas pruebas están
destinadas a obtener información sobre si el usuario tiene problemas al utilizar nuestra aplicación o no."
Verdadero Falso
Falso
La respuesta correcta es Falso. Las pruebas unitarias están destinadas a comprobar si nuestro código hace lo que tiene
que hacer de forma correcta y eficiente, y estas pruebas hay que hacerlas antes de que el usuario final use nuestra
aplicación.
7.- Depuración de programas.
Caso práctico
Ada y Juan ya conocen las capacidades del depurador que incorpora el entorno NetBeans y van Programadora
a enseñar a María las ventajas de utilizarlo. codificando un programa
frente a una pantalla de
-Puedes depurar tus programas haciendo dos cosas: creando breakpoints o haciendo ordenador.
ejecuciones paso a paso-, le comenta Juan.
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
Un doctor, con pelo cano y bata blanca, sostiene en sus manos un libro. Al fondo una pared blanca con un título enmarcado.
depuración
Stockbyte.
de Uso educativo no comercial para
programas plataformas públicas de
es el CD-DVD Num. V07
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 ejecución. Pero cuando el programa es compilado,
se realizan comprobaciones para saber si los métodos llamados existen y sus parámetros son correctos en número y tipo. Así que, los
errores de enlazado y de 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 propio 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.
Observación de variables y atributos en la ejecución paso a paso: una de las mayores ventajas que ofrecen la mayoría de los
depuradores es la posibilidad de observar (e incluso manipular) el valor de las variables en tiempo real durante la ejecución.
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.
8.- Documentación del código.
Caso práctico
Un documento con código html escrito, la esquina superior derecha aparece doblada. Abajo a la derecha un rótulo que
tiene inscrito HTML.
Dreftymac
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 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.
Captura de pantalla con

un fragmento de código
que ejemplifica el uso de
comentarios de
documentación para su
posterior generación.
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.
Efectivamente esta afirmación es totalmente cierta, documentar es muy importante y hacerlo bien es una sana costumbre
para todos los programadores y programadoras.
8.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.
Tabla que representa las

diferentes etiquetas que
podemos incluir en los
comentarios de
documentación y el ámbito
en el que éstas pueden
utilizarse.
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
¿Qué tal te ha salido?

Si has tenido problemas para completar algún hueco, te recomiendo que repases el apartado anterior y éste, para
afianzar los conceptos.
8.2.- Uso de las etiquetas.

¿Cuáles son las etiquetas típicas y su significado?
Dos páginas de un libro repletas de postits con anotaciones.
Pasaremos seguidamente a enumerar y describir la función de las etiquetas Lensim
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 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 <code>verdaderosi y solo si este vector no contiene componentes, esto es, su tamaño es cero;
* <code>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"

* @see <a href="http://www.w3.org/WAI/">Web Accessibility Initiative</a>
* @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.
No es correcto, @param debe incluirse si existen parámetros en el método.
Incorrecto, @throws debe incluirse si el método lanza excepciones.
Correcto, ya que @return no sería necesaria al no devolver nada el método.
Solución
1. Incorrecto
2. Incorrecto
3. Opción correcta
8.3.- Orden de las etiquetas.

¿Es importante el orden a la Un conjunto de botellines de cerveza cerrados, están en perfecto orden preparados para recibir su etiqueta.
hora de poner las etiquetas
Stockbyte.Uso educativo no comercial para
en los comentarios de plataformas públicas de Formación Profesional
documentación, o por el a distancia. CD-DVD Num. V07
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. Descripción.
@autor En clases e interfaces. Se pueden poner varios. Es mejor ponerlas en orden cronológico.
@version En clases e interfaces.
En métodos y constructores. Se colocarán tantos como parámetros tenga el constructor o método. Mejor en el mismo
@param
orden en el que se encuentren declarados.
@return En métodos.
@exception En constructores y métodos. Mejor en el mismo orden en el que se han declarado, o en orden alfabético.
@throws Es equivalente a @exception.
@see 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
@deprecated
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.
8.4.- Documentación externa. Requisitos de la

aplicación: diagramas de clases y de casos de uso.
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.
Para saber más

En los enlaces que te proporcionamos a continuación, te facilitamos información sobre UML, posiblemente la notación de
modelado de software más extendida y usada en el mundo entero:
Información básica sobre UML.
Información básica sobre UML en Wikipedia
Diagramas de clases en UML.
Modelo de Clases en UML (pdf - 570 KB)
En el siguiente documento encontrarás mucha más información sobre los casos de uso. Los casos de uso son muy usados a la
hora de modelar aplicaciones dentro del paradigma de la programación orientada a objetos.
Requisitos: diagramas de casos de uso.
Manual de diagramas de casos de uso en UML (384 KB)
Anexo.- Licencias de recursos.
Licencias de recursos utilizados en la Unidad de Trabajo.
Recurso (1) Datos del recurso (1) Recurso (2) Datos del recu
Visto desde Autoría: Stockbyte. Una científico Autoría: Stockbyte.

arriba, un Licencia: Uso educativo no comercial para plataformas mirando a Licencia: Uso educativo no comercia
programador públicas de Formación Profesional a distancia. través de un de Formación Profesional a distancia
frente a un Procedencia: CD-DVD Num. V43 microscopio. Procedencia: CD-DVD Num. V43
d d
Un rollo de Autoría: Stockbyte. En Autoría: Stockbyte.

papel continuo Licencia: Uso educativo no comercial para plataformas un Licencia: Uso educativo no comercia
con públicas de Formación Profesional a distancia. laborat de Formación Profesional a distancia
anotaciones Procedencia: CD-DVD Num. V07 de Procedencia: CD-DVD Num. V07
i l tó
Cubo Autoría: Yan Shuangchun Cubo Autoría: Crazynorvegian

de cristal Licencia: GPL de cristal Licencia: GPL
negro Procedencia: vacío. Procedencia:
opaco con http://commons.wikimedia.org/wiki/File:Torchlight_core.png http://commons.wikimedia.org/wiki/Fi
t
Autoría: Dr. Timo Mappes

Plano de Autoría: Lorenz kerscher
Micro Licencia: CC-BY-SA-3.0; CC-BY-SA-3.0-DE; BILD-GFDL-
unos pies Licencia: GNU Free Documentation L
con NEU;
andando por la Procedencia: Montaje sobre
base Procedencia:
playa. http://commons.wikimedia.org/wiki/Fi
negra http://commons.wikimedia.org/wiki/File:Leitz_117298_frei.jpg
Condiciones y términos de uso de los materiales
Materiales desarrollados inicialmente por el Ministerio de Educación, Cultura y Deporte y actualizados por el profesorado
de la Junta de Andalucía bajo licencia Creative Commons BY-NC-SA.
Logotipos del Ministerio de Educación, Cultura y Deporte, Junta de
Andalucía y licencia Creative Commons
Antes de cualquier uso leer detenidamente el siguente Aviso legal
Historial de actualizaciones
Versión: 01.02.00 Fecha de actualización: 25/09/18 Autoría: Salvador Romero Villegas
Ubicación: Varios Apartados

Mejora (tipo 2): - El ejemplo del apartado 6.3 usa un método de instancia, y ese momento no se han visto los métodos. En vez de quitar el
ejemplo, se propone mover el apartado 6 a la unidad 3, justo después del apartado 7 (entrada y salida), donde ya existe una noción básica
de métodos. Además, el ejercicio resuelto del apartado 6.1. usa BufferedReader, algo que no se ve hasta la unidad 7, y haciendo este
cambio se podría sustituir por algo relacionado con la clase Scanner. - Apartado 3.1.- El Ejercicio resuelto creo que sería buena idea
plantearlo como un ejercicio real, es decir un enunciado que invite al alumnado a hacerlo. - Apartado 3.2.2.- El ejercicio resuelto creo que
sería buena idea replantearlo como un ejercicio resuelto. En vez de poner Acceder al ... poner Crea un programa en Java que haga lo
siguiente.... - Apartado 4.1.2 hay un debes conocer que creo que debería plantearse como ejercicio resuelto (haz un programa en java que
calcule la tabla de un número leído por teclado). - Apartado 4.3.2 hay también un debes conocer que nuevamente pienso que debería
plantearse como un ejercicio resuelto. - Apartado 4.4.2 hay otro debes conocer que pienso que debería también plantearse como un
ejercicio resuelto. - Anexo I es conveniente que se traslade al apartado 4.5.- Ejercicios. Al estar como anexo parece que se le quita la
importancia que tienen estos ejercicios y habría que hacer hincapié en la necesidad de que practiquen estos enunciados. - Aunque no esté
recomendado el uso de break y continue, no estaría mal poner un ejercicio resuelto en el apartado 5.1.
Ubicación: Varios.
Mejora (tipo 1): - El ejemplo del apartado 6.3 usa un método de instancia, y ese momento no se han visto los métodos. En vez de quitar el
ejemplo, se propone mover el apartado 6 a la unidad 3, justo después del apartado 7 (entrada y salida), donde ya existe una noción básica
de métodos. Además, el ejercicio resuelto del apartado 6.1. usa BufferedReader, algo que no se ve hasta la unidad 7, y haciendo este
cambio se podría sustituir por algo relacionado con la clase Scanner.
- Apartado 3.1.- El Ejercicio resuelto creo que sería buena idea plantearlo como un ejercicio real, es decir un enunciado que invite al
alumnado a hacerlo.
- Apartado 3.2.2.- El ejercicio resuelto creo que sería buena idea replantearlo como un ejercicio resuelto. En vez de poner Acceder al ...
poner Crea un programa en Java que haga lo siguiente....
- Apartado 4.1.2 hay un debes conocer que creo que debería plantearse como ejercicio resuelto (haz un programa en java que calcule la
tabla de un número leído por teclado).
- Apartado 4.3.2 hay también un debes conocer que nuevamente pienso que debería plantearse como un ejercicio resuelto.
- Apartado 4.4.2 hay otro debes conocer que pienso que debería también plantearse como un ejercicio resuelto.
- Anexo I es conveniente que se traslade al apartado 4.5.- Ejercicios. Al estar como anexo parece que se le quita la importancia que tienen
estos ejercicios y habría que hacer hincapié en la necesidad de que practiquen estos enunciados.
- Aunque no esté recomendado el uso de break y continue, no estaría mal poner un ejercicio resuelto en el apartado 5.1.
Ubicación: No especificada.
Mejora (tipo 1): Eliminación del idevice de licencia.
Ubicación: Introducción
Mejora (tipo 1): En el caso práctico de la introducción se ha eliminado una imagen pero se ha quedado su texto alternativo.
Ubicación: Título y número de unidad
Mejora (Orientaciones del alumnado): El título pone: PROG03 cuando debería ser PROG02 y en el número de unidad lo mismo.
Ubicación: Página inicial

Mejora (tipo 1): Actualizado enlace con información legal del ministerio
Ubicación: Varias secciones

Mejora (tipo 1): Pequeñas erratas, enlaces que no funciona, cambiar vídeo para ponerle url con https, y modificar la sintaxis de
pseudocódigo para que tenga una sintaxis más similar a la de PSeInt.
Versión: 01.01.07 Fecha de actualización: 27/06/17 Autoría: Sonia Amate Garrido
Ubicación: No especificada.
Mejora (tipo 1): No hay cambios en los contenidos, solo en el mapa conceptual, pero se vuelve a subir el fichero de contenidos porque si
no la plataforma no permite la subida.
Ubicación: Examen online
Mejora (Examen online): Dado el siguiente fragmento de código:
int a=1, b=2, auxiliar=0;
auxiliar=a;
a=b;
Calcular el valor de las variables a y b tras su ejecución.

Seleccione una:
a. a valdrá 1 y b valdrá 2.
b. a valdrá 0 y b valdrá 2.
c. a valdrá 2 y b valdrá 1.
d. Tanto a como b valdrán 0.
e. Tanto a como b valdrán 1.
f. Tanto a como b valdrán 2.
g. Tanto a como b valdrán 2.
Hay una opción duplicada
Ubicación: Excepciones
Mejora (Mapa conceptual): Donde debería poner que pertenecen a la clase Throwable pone Throwtable
Versión: 01.01.06 Fecha de actualización: 31/10/16 Autoría: Gloria Ortiz
Ubicación: Primera página

Mejora (tipo 1): SCORM de lo contenidos: se ha puesto la licencia correctamente tal y como establece el procedimiento de Actualización
de Materiales. Mapa conceptual: corregido el número de la undiad a PROG02; corregidos enlaces internos del archivo de descripción al
archivo del mapa; corregido nombre archivos html a PROG02; corregido nombre de la imagen a PROG02 así como referencias a la
descripción.
Versión: 01.01.05 Fecha de actualización: 26/10/16 Autoría: Sonia Amate Garrido
Ubicación: 9.3 (Para Saber Más)

Mejora (tipo 1): Actualización del segundo enlace (ha cambiado su ubicación)
Ubicación: 8. (Debes conocer)
Mejora (tipo 1): Actualización del segundo enlace de esta sección (ha cambiado de ubicación la página que se mencionaba)
Ubicación: 7.6 (Para Saber Más)
Mejora (tipo 1): Sustitución del primer enlace que aparece (ya no estaba disponible la página)
Ubicación: 6.2 (Debes Conocer)
Mejora (tipo 1): Cambio del primer enlace que aparece en Debes Conocer (ya no funciona) por otro similar.
Ubicación: 6.1
Mejora (tipo 1): Se supone que tiene que haber un enlace a un video que explica las excepciones en java y el enlace no aparece
Ubicación: Examen online
Mejora (tipo 1): La pregunta: Las variables utilizadas en la condición de terminación de un bucle for deben cambiar su valor en el interior
del mismo. De no ser así, podemos caer en la creación de un bucle infinito, cuestión que se debe evitar por todos los medios es confusa.
Quizás cambiando el for por un while no cabría ninguna duda y evalua el mismo concepto, que las condiciones de bucle deben cambiar
hasta alcanzar la condición en la cual se sale del mismo y no caer en un bucle infinito.
Versión: 01.01.04 Fecha de actualización: 19/10/15 Autoría: Gloria Ortiz
Ubicación: Primera página

Mejora (tipo 1): Materiales --> Se ha puesto la licencia correctamente tal y como establece el procedimiento de Actualización de
Materiales
Versión: 01.01.03 Fecha de actualización: 08/10/15 Autoría: José Javier Bermúdez Hernández
Ubicación: En varios apartados

Mejora (tipo 1): e han añadido a lo largo del tema iDevices del tipo Recomendación para especificar errores comunes de programación,
buenas prácticas de programación, para prevenir errores etc.
Ubicación: 6.2
Mejora (tipo 1): Sobre excepciones, añadir un par de enlaces en un Debes conocer:
http://jarroba.com/excepciones-exception-en-java-con-ejemplos/
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/excepciones/excepciones.htm
Ubicación: 6.3
Mejora (tipo 1): Añadir un Debes Conocer a: http://puntocomnoesunlenguaje.blogspot.com.es/2014/04/java-excepciones.html
con el texto: A continuación tienes un artículo muy interesante donde se explica la gestión de excepciones con ejemplos.
Ubicación: 4.1
Mejora (tipo 1): Revisar la explicación, ya que al igual que en el curso pasado, hay algún alumno que no lo veo claro: Dice el epígrafe 4.1
que: La condición de terminación del bucle debe variar en el interior del mismo, por lo que el valor de la variable contador que controla el
bucle debe modificarse en algún momento.
Esto, que me parece muy lógico para otros bucles con condiciones, no termino de entenderlo para el for. La condición de terminación del
bucle se establece directamente en la linea del for al fijar el incremento, es decir, el contador se automodifica en cada ciclo
independientemente de lo que se haga en el interior, es decir, sin que nada en el interior del bucle tenga necesariamente que modificar la
variable del contador, no??
Ubicación: Apartado 5.3.- Sentencia return
Mejora (tipo 1): En el ejemplo del Para saber más hay un enlace a un archivo de código fuente Java donde hace referencia a las variables
primer_numero, segundo_numero (línea 33). Es un error. Debeían ser las variables primerNumero, segundoNumero.
Ubicación: Tarea. Ejercicio switch comunidades autónomas
Mejora (tipo 1): Especificar que la entrada sea escribiendo el nombre de la provincia, no un número.
Ubicación: Categoría estructura repetitiva - Ejercicio 4: Leer números no negativos, hasta completar 10.
Mejora (Tarea): El título del ejercicio es Leer números no negativos, hasta completar 10. Sin embargo en el enunciado dice Haz un
programa para leer números enteros no negativos, (descartando los negativos, pero contando cuántos se han leído,hasta que se
introduzcan 10 positivos,e indicar cuántos se han leído, y de ellos cuántos eran negativos, cuántos eran ceros y cuántos acaban en
2.Habría que cambiar el título del enunciado a Leer números positivos, hasta completar 10 o cambiar enunciado
Versión: 01.01.02 Fecha de actualización: 30/09/15 Autoría: Alberto Goñi García
Ubicación: a lo largo de la UT
Mejora (tipo 1): Se han añadido a lo largo del tema iDevices del tipo Recomendación para especificar errores comunes de programación,
buenas prácticas de programación, notas de rendimiento, para prevenir errores etc.
Corrregir pequeñas erratas, actualizar enlaces caídos, eliminar algunas fotos del anexo poniendo sus credenciales en la propia foto.
Corrección de erratas en 3 apartados.
Se han actualizado erratas en varios apartados, y se han añadido comentarios explicativos en el código de ejemplo sobre excepciones.
Se han introducido las estructuras de control primero en pseudocódigo, y luego en Java; se ha explicado mejor los casos en los que resulta
necesario en Java usar estructuras de salto incondicional; se ha introducido un apartado de documentación externa que aparece en
normativa y no estaba recogido en contenidos; se ha incluido un anexo de ejemplos resueltos en pseudocódigo y en Java. Se ha
actualizado el mapa conceptual, y las orientaciones del alumnado.
Versión: 01.00.00 Fecha de actualización: 30/10/13 Autoría: MECD MECD
Versión inicial de los materiales, desarrollados por el Ministerio de Educación.

Prog Unidad 02

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Prog Unidad 02

Cargado por

Copyright:

Formatos disponibles

3/3/2019 https://educacionadistancia.juntadeandalucia.es/cursos/blocks/recopila/recopila.php?

Uso de estructuras de control.

María pregunta a Juan:

Stockbyte. Uso educativo no comercial para plataformas

¿Pero es eso suficiente?

2.- Estructura secuencial: sentencias y bloques.

Organizar correctamente el código fuente es de vital importancia cuando se trabaja en entornos

¿Cómo se escribe un programa sencillo?

Bloque de sentencias en una sola línea Bloque de sentencias de varias líneas

En un bloque de sentencias, ¿éstas deben estar colocadas con un orden exacto?

Sentencias, bloques y diferentes organizaciones.

Declara cada variable antes de utilizarla.

Todas las afirmaciones son correctas.

Incorrecto. Aunque la afirmación es correcta, deberías revisar el resto de respuestas.

No es correcto. La afirmación también es correcta, pero deberías revisar el resto de respuestas.

3.- Estructuras de selección o condicionales.

Al principio de la unidad nos hacíamos esta pregunta:

Las estructuras de selección se dividen en:

Estructura de selección simple o estructura if.

3.1.- Estructura selectiva simple y selectiva compuesta:

Si la expresión que se evalúa es verdadera, se ejecuta la secuencia de instrucciones 1.

En pseudocódigo, eso se expresaría como:

Estructura if e if-else en pseudocódigo

Estructura condicional simple.(Si-entonces) Estructura condicional de doble alternativa. (Si-entonces-Si no).

La estructura if puede presentarse en Java de las siguientes formas:

Estructura if e if-else en Java

Algunas consideraciones más a tener en cuenta en Java:

Si la nota es menor de 5, la calificación será "INSUFICIENTE".

Versión 1 de la solución (equivalente al pseudocódigo).(java - 2.48 KB)

Versión 2 de la solución.(java - 2.48 KB)

Utiliza la sangría en ambos cuerpos de una estructura if-else.

3.2.- Estructura selectiva múltiple: switch.

3.2.1.- Estructura switch en pseudocódigo.

Pseudocódigo para la estructura selectiva múltiple (Según-sea)

Segun (expresion) Hacer Algoritmo Sentencias_condicionales

3.2.2.- Estructura switch en Java.

Estructura selectiva múltiple en Java. (switch.)

Si la nota es 0, 1, 2, 3 o 4, la calificación será "INSUFICIENTE".

Para realizar este ejercicio deberás usar obligatoriamente la estructura switch.

Código de ejemplo con switch:

Para saber más

Sentencia switch en Java

Ejemplos de ejercicios resueltos en Java usando if y switch

4.- Estructuras repetitivas, iterativas o cíclicas.

Bucle for (Repite para). HuBoro

¿Sabemos a priori cuántas veces necesitamos repetir un conjunto de instrucciones?

4.1.- Estructura repetitiva tipo for.

Este tipo de bucle tiene las siguientes características:

Se ejecuta un número determinado de veces.

Se inicializa la variable contador.

4.1.1.- Estructura tipo for en pseudocódigo.

Pseudocódigo para la estructura repe

Veamos cómo quedaría e

4.1.2.- Estructura tipo for en Java.

Estructura repetitiva for.

Estructura for con una única sentencia:

for (inicialización ; condición ; incremento)

Una posible solución del ejercicio podría ser la siguiente:

/* Paso 1. Mostrar la cabecera de la tabla */

/* Paso 2. Calcular la tabla de multiplicar del 7 usando un bucle for.

/* Nota: A través del operador + aplicado a cadenas de caracteres,

for (;;){ //instrucciones }

Nada, dará un error.

Un bucle que se ejecutaría una única vez.