Get documents about "MÓDULO III_ESTRUCTURAS DE CONTROL
Document Sample
Fundamentos de programación
Tema 3. Estructuras de control
Área de Lenguajes y Sistemas Informáticos
Curso 2007-2008
1
Contenidos
• Introducción a la programación estructurada
• Estructuras de selección: if, else, switch
• Estructuras de repetición: while, do/while, for
• Enunciados break y continue.
• Principios de la Programación Estructurada.
Introducción
procedural:
Programación imperativa o procedural:
Programa:
secuencial.
• Conjunto de instrucciones que se ejecutan de forma secuencial.
• Saltos en el código, condicionales e incondicionales.
Se usan variables que representan el contenido de las celdas de memoria.
Se utilizan sentencias de asignación para cambiar el valor de las variables.
Es la forma de programación que más se ajusta a la arquitectura del hardware.
Existe una evolución histórica desde el paradigma imperativo al orientado a objetos:
Prog. Imperativa → Estructurada → Modular (basada en objetos)→ Prog. Orientada a Objetos.
Introducción
La programación imperativa es la forma de programar más antigua y la que
mejor refleja la arquitectura de los microprocesadores.
Sin embargo el uso indiscriminado de saltos en la secuencia del programa da
lugar a:
• Código spaghetti (la “infame” sentencia goto).
• Muy difícil de entender y mantener.
• su
En cuanto aumenta el tamaño de los proyectos se hace imposible su planificación
y gestión.
Se hacía absolutamente necesaria una estrategia para desarrollar y mantener
eficientemente los programas
Un nuevo paradigma de programación o una modificación del paradigma
imperativo
PROGRAMACIÓN ESTRUCTURADA
Introducción
Se trata de:
un
1. Buscar una forma de estructurar los programas para que no sean un laberinto.
fá demá
2. Desarrollar programas fáciles de entender por uno mismo y por los demás.
programació propó
La programación estructurada nace con el propósito de satisfacer ambos objetivos, para lo
cual, entre otros principios, establece que:
• control:
Sólo se consideran tres estructuras de control: Secuencia, Selección y Repetición.
• Todas ellas con un solo punto de entrada y un solo punto de salida.
bloques sí
La idea fundamental es que los programas son un conjunto de bloques que encajan entre sí
sobre la premisa de que cada bloque tiene un solo punto de entrada y un solo punto de
salida,
salida, y la salida de uno se enchufa a la entrada del siguiente.
Estructuras de control de Java
Java tiene 7 estructuras de control:
continuació
Estructura de secuencia: Las instrucciones se ejecutan una a continuación de otra.
selecció có segú
Estructuras de selección: Se salta de una parte a otra del código según el
condició
cumplimiento de una condición.
if if/else switch
repetició ejecució instrucció
Estructuras de repetición: Se repite la ejecución de una instrucción o conjunto de
condició
instrucciones si se cumple una cierta condición.
while do/while for
• Todas estas estructuras cumplen los principios de la programación
estructurada.
• Los algoritmos de los programas Java se construyen a partir de estas
estructuras de control combinadas de dos modos: Apilamiento y Anidamiento
Estructura de selección if
Sentencia de selección única:
selecció Si se cumple la condición se
if (condicion ) sentencia_1; ejecuta la sentencia_1,
si no,
instrucció
se salta hasta la siguiente instrucción.
expresió ló
condicion es una expresión ló gica
booleana)
(booleana ) cuyo resultado es
true Sentencia_1 (true) (false)
verdadero (true) o falso (false)
CONDICIÓN
Ejemplo:
(calificació
if (calificació n >= 5)
false
System.out.println( Aprobado”
System.out.println(“ Aprobado”);
Estructura de selección if/else
selecció
Sentencia de selección doble:
Si se cumple la condición se ejecuta la
if (condicion )
sentencia_1,
sentencia_1;
else si no,
sentencia_2; ejecuta la sentencia_2.
Ejemplo:
(calificació
if (calificació n >= 5)
false true
S_2 condición S_1 System.out.println( Aprobado”
System.out.println (“Aprobado”);
else
System.out.println( Suspendido”
System.out.println (“Suspendido ”);
Estructura de selección if/else
Si se quiere indicar que se ejecuta más de una sentencia, hay que
ponerlas entre llaves:
if (condicion){
sentencia_1; • ¡ No olvidar los paréntesis en la
sentencia-2; condición !
} • ¡ No olvidar las llaves si hay más de
una sentencia !
else {
sentencia_3; • ¡ Sangrar las sentencias para hacer el
programa más legible !
sentencia_4;
sentencia_5;
}
if/else en cascada (I)
if (calificació n >= 9)
(calificació Para hacer el programa más
System.out.println(“Sobresaliente”);
System.out.println( Sobresaliente” legible se suele escribir:
else
if (calificacion >= 7)
System.out.println(“Notable”
System.out.println(“Notable ”);
else
if (calificacion >= 5)
System.out.println(“Aprobado”
System.out.println(“Aprobado”);
else
System.out.println(“Suspendido”
System.out.println(“Suspendido”);
(calificació
if (calificació n >= 9)
System.out.println( Sobresaliente”
System.out.println(“Sobresaliente ”);
else if ( calificacion >= 7)
System.out.println(“Notable ”);
System.out.println(“Notable”
else if ( calificacion >= 5)
System.out.println(“Aprobado”
System.out.println(“Aprobado”)
else
System.out.println(“Suspendido”
System.out.println(“Suspendido”);
if/else en cascada (II)
¡¡ else siempre se refiere al if anterior !!
if (x>5)
if (y>5)
System.out.println(“x e y son mayores que 5 ”);
System.out.println( 5”
else
System.out.println( 5”
System.out.println(“x es menor o igual que 5”);
Pero lo que realmente pretendemos es esto:
(x>5){
if (x>5){
if (y>5)
System.out.println( 5”
System.out.println(“x e y son mayores que 5 ”);
}
else
System.out.println( 5”
System.out.println (“x es menor o igual que 5”);
if/else en cascada (III)
Errores típicos: Punto y coma mal colocado
• Puede producir un error de lógica:
if (nota >= 5); harí despué condició
// No haría nada después de evaluar condición
System.out.println( Aprobado”
System.out.println(“Aprobado”); //Siempre se ejecuta
• Puede producir un error de sintaxis:
if (calificación>= 5) ;
(calificació if/ aquí
// if/else acaba aquí
System.out.println (“Aprobado”); // Siempre se ejecuta
System.out.println( Aprobado”
else
System.out.println( Suspendido” qué
System.out.println (“Suspendido ”); // ¿A qu é if se refiere?
Estructura de selección switch
selecció mú
Sentencia de selección múltiple:
sí
switch (expresi ón) {
(expresió Acción a break
Caso a
valor_1:
case valor_1: sentencia_1; no
break;
break;
sí
case valor_2: sentencia_2;
valor_2: Acción b break
Caso b
break;
break; no
...
valor_i: sentencia_i;
case valor_i: sentencia_i;
break;
break;
sí
default:
default: sentencia_por_defecto; Acción i break
Caso i
break;
break;
no
}
expresió despué
La expresión después de cada case debe ser una expresión entera
expresió
combinació cará
constante, es decir, una combinación de constantes de carácter y constantes
enteras que al evaluarse produzca un valor entero constante.
cará cará cuestió
Una constante de carácter se representa como el carácter en cuestión
apó
encerrado entre apóstrofos: ´A´
Estructura de selección switch (II)
Particularidades de la estructura switch
• ¿Qué ocurre si falta la palabra break?
Qué
Si falta break se siguen ejecutando todas las sentencias en las que haya
coincidencia hasta encontrar el siguiente break. Si no hay break se ejecutaría
ejecutarí
el default aunque haya habido coincidencia con otras antes.
• inclusió ponerlo.
La inclusión de un caso por defecto es opcional, pero es aconsejable ponerlo.
• Después de cada caso (case) no se incluyen llaves { } aunque haya más de una
Despué má
sentencia.
valor_i: sentencia_a;
case valor_i: sentencia_a;
sentencia_b;
sentencia_b;
break;
break;
Estructura de repetición while
Permite al programador especificar que una Ejemplo: Encontrar la primera potencia
acció
acción se repita en tanto se cumpla una de 2 mayor que 1000.
condició
condición.
while (condicion ) sentencia; int producto = 2;
while (producto <= 1000)
while (condicion ){
producto = 2 * producto;
sentencia_1;
………
sentencia_n;
}
true Sentencia
CONDICIÓN
false
Estructura de repetición do/while
acció
Permite al programador especificar que una acción se
condició
repita en tanto se cumpla una condición.
do
sentencia;
condicion);
while (condicion);
T
do{
do{
sentencia_1; F
……
sentencia_n;
sentencia_n; OBSERVACIONES:
condicion)
} while ( condicion)
infinitos:
• Ojo con los bucles infinitos: hay que
condició
asegurarse de que la condición deja de
Ejemplo: Encontrar la primera
cumplirse.
potencia de 2 mayor que 1000.
• Diferencia con sentencia while: La
int producto = 2;
sentencia o sentencias se ejecutan al menos
do
vez. condició despué
una vez. La condición se comprueba después
producto = 2 * producto;
iteració
de haber realizado la primera iteración.
while (producto <= 1000)
Estructura de repetición for (I)
Repetició
Repetición controlada por contador:
for (inicialización del contador;
condición; Inicialización
expresión incremento del contador) Incremento
sentencia;
true
Condición Sentencia
for (inic. cont.; cond.; inc. cont.){
sentencia_1; false
……
sentencia_n;
}
Semántica ( pasos):
Semá pasos):
Ejemplos: (1) (só
Se inicializa contador (sólo la primera vez).
Variable de control de 7 a 77 en incrementos de 7. (2) evalú condició
Se evalúa condición.
for (int i = 7; i <= 77; i += 7){…};
7; 77; 7){…}; • Si true → ejecutar sentencias.
• Si false → a paso 5 (salir del bucle).
Variable de control de 99 a 0 en incrementos de -11
segú expresió
(3) Se incrementa contador según expresión de
(int 99; 0;
for (int i = 99 ; i >= 0; i = i - 11) 11)
incremento.
{…};
(4) Volver al paso 2.
(5) Salir del bucle.
Estructura de repetición for (II)
Las tres expresiones de la estructura for son opcionales:
inicializació
• Se puede omitir la inicialización del contador si se ha inicializado antes.
int i = 1;
for(
for( ; i < 10; i++) { ... }
comprobació condició condició
• Si se omite la comprobación de la condición, Java supone que la condición para
creá
continuar el ciclo se cumple, creándose un bucle infinito.
for(
for( ; ; i++) { ... } // Bucle infinito. Posible desbordamiento de i.
for(
for( ; ; ) { ... } // Bucle infinito.
cuerpo for.
• La propia variable de control se puede utilizar dentro del cuerpo del for.
for(
for( ; i < 10; i++ ) {
if ( i%2 == 0) { ... } // Se hace algo cuando i es par.
}
for.
• El incremento del contador puede omitirse si se hace dentro del cuerpo del for.
for(
for( ; i < 10; ) { ... i++ ... } // Nada aconsejable.
Estructura de repetición for (III)
Las expresiones de un for pueden contener expresiones aritméticas.
aritmé
Por ejemplo,
int x = 2;
int y = 10;
for ( int j = 2; j <= 80; j += 5 )
System.out.println(j);
System.out.println(j);
for ( int j = x; j <= 4 * x * y; j += y / x )
System.out.println(j);
System.out.println(j);
Pero cuidado con las expresiones:
Ambos bucles for son equivalentes si x e y no se modifican en el cuerpo del ciclo,
ciclo,
difí
pero el primero es claro y el segundo difícilmente comprensible.
Estructura de repetición for (IV)
La sentencia
for (int contador = 1; contador <= 10; contador ++)
sentencia;
es equivalente a:
int contador = 1; Inicialización
while (contador <= 10) { Incremento
sentencia;
contador++;
contador++; true
Condición Sentencia
}
false
Elecció repetició
Elección de una estructura de repetición:
• Si número fijo de veces, elegir for
nú
• Si 1 o más veces, elegir do { } while { }
má
• Si 0 o más veces, elegir while ( ) { }
má
mejorar
¡ Se trata de elegir la que mejor se ajuste al concepto para mejorar la legibilidad !
Break y continue en estructuras de repetición (I)
La palabra reservada break en el cuerpo Continue: Causa el salto a la
terminació
de un ciclo causa la terminación iteració
siguiente iteración del ciclo, pero sin
ciclo.
inmediata de dicho ciclo. salirse del ciclo .
int i = 0; (int
for (int i = 0; i < 100; i++) {
int s = 0;
continue;
if (i % 2 == 1) continue ;
while (i <= 5) {
s = s + 1; Só aquí
// Só lo se pasa aquí si i es par
break;
if ( s == 7) break ; // sale // otras sentencias ...
// otras sentencias …
}
i++;
i++;
}
aquí
// Se pasa aquí si i > 5 o s == 7
• En las estructuras while y do/while la condición para continuar el ciclo se
eval úa inmediatamente despu és de ejecutarse continue.
• En la estructura for se incrementa el contador y luego se eval úa la condición.
Break y continue en estructuras de repetición (II)
Las siguientes porciones de código son equivalentes:
1; 10;
for (int i = 1; i <= 10; i++ ) { int i = 1;
// sentencia 1 while ( i <= 10 ) {
// sentencia n // sentencia 1
} // sentencia n
i++;
i++;
}
Pero las dos siguientes NO son equivalentes:
1; 10;
for (int i = 1; i <= 10; i++ ) { int i = 1;
// sentencia 1 while ( i <= 10 ) {
continue; // sentencia 1
// sentencia n continue;
continue;
} // sentencia n
i++;
i++;
}
// Incremento antes de continue.
continue. // Incremento después del continue
break etiquetado
• El enunciado break sólo causa la salida de la estructura while, do/while o for
que lo encierra directamente.
• Para salirnos de una serie de estructuras anidadas se usa el enunciado break
enunciado
etiquetado:
ejecució continú despué
• La ejecución del programa continúa con el primer enunciado después del enunciado
enunciados
compuesto etiquetado, el cual consiste en una serie de enunciado s encerrados en
llaves y precedidos por una etiqueta.
// Enunciado compuesto rotulado o etiquetado
stop:
fila++)
for ( int fila = 1; fila <= 10; fila ++) {
columna++)
for (int columna = 1; columna <= 5; columna++) {
if ( fila == 5)
stop;
break stop;
System.out.println(“Fila es menor que 5” );
System.out.println( 5”
}
}
System.out.println( 5”
System.out.println(“La fila es 5” );
continue etiquetado
• El enunciado continue continúa con la siguiente iteración de la estructura while,
continú iteració
do/while o for que lo encierra directamente.
• El enunciado continue etiquetado se salta el resto de los enunciados del cuerpo de
iteració
la estructura de iteración que lo contiene y cualquier cantidad de estructuras de
iteració continú iteració
iteración que la encierren y continúa con la siguiente iteración de la estructura de
repetició
repetición etiquetada.
// Enunciado compuesto rotulado o etiquetado
stop:
fila++)
for ( int fila = 1; fila <= 10; fila ++) {
columna++)
for (int columna = 1; columna <= 5; columna++) {
if ( fila == 5)
stop;
continue stop;
System.out.println(“Fila es distinta que 5”);
System.out.println( 5”
}
}
System.out.println( 10”
System.out.println(“La fila es 10 ”);
Advertencias sobre break y continue
break y continue suponen una violación de las reglas de la
programación estructurada, si bien de alcance limitado.
• El uso de break está justificado en pocas ocasiones. Puede evitarse con
una escritura más cuidadosa de las condiciones de terminaci ón del ciclo
int i; int i;
char s; char s;
while (i <= 5 || s != ´a´) { while (i <= 5 && s != ´a´){
if (s == ´a ´) break;
break; // Sentencias
// Sentencias i++;
i++; }
}
má má difí
Si hay más de una salida del ciclo del programa se hace más difícil de leer y
programació
analizar y se va en contra de los principios de la programación estructurada.
Advertencias sobre break y continue
• El uso de continue puede evitarse con una escritura más cuidadosa del
cuerpo del ciclo y de la expresi ón de incremento de la variable de control.
(int
for (int i = 0; i < 100; i ++) { (int 2)
for (int i = 0; i < 100; i += 2) {
if (i%2 == 1) continue; segú
// Procesamiento según valor de i
segú
// Procesamiento según valor de i
}
}
• continue ayuda a reducir los niveles de anidado en el cuerpo de la estruc tura de
estructura
iteració
iteración,
• explí
pero es peligroso si no se hacen explícitas las condiciones para ejecutar el resto del ciclo.
// int a, b (declaradas antes) // int a, b (declaradas antes)
// posible bucle ∞ si b es cero al entrar while (a < 5) {
while (a < 5){ if (b == 0){
if (b == 0) continue ;
continue; a++;
continue;
// otras sentencias;
}
a++;
// otras sentencias;
} a++;
a++;
}
Principios de la programación estructurada
1. Comenzar con el diagrama de flujo más sencillo.
2. apilamiento:
Regla de apilamiento: Cualquier acción puede ser sustituida por dos o más
acciones en secuencia.
3. anidamiento: acció
Regla de anidamiento: Cualquier acción puede ser sustituida por cualquier
só control:
estructura de control y sólo se consideran tres estructuras de control:
• Secuencia.
• Selección.
• Repetición.
Todas ellas con un solo punto de entrada y un solo punto de salida
Ø só
Sólo hay una forma de entrar en cada estructura de control y sólo
hay una forma de salir de ella.
4. tantas
Las reglas 2 y 3 (apilamiento y anidamiento) pueden aplicarse ta ntas veces
orden.
como se desee y en cualquier orden.
Related docs
Other docs by acortescastillo
Cronograma de seguimiento por fechas y semanas - Proyecto de Intervención I
Views: 67 | Downloads: 0
DISEÑO CURRICULAR - Programación V - Módulo I Introducción a la Programación Concurrente
Views: 201 | Downloads: 0
