ESTRUCTURA DE LENGUAJE DE JAVA
ALGORITMOS Y LENGUAJE DE PROGRAMACION
Lic. Claudia Escobar Cordova
Ing. Industrial 4°B
Luis Alfredo de la Cruz Salazar
TAPACHULA, CHIAPAS
25/03/2020
1
INDICE
Simple .................................................................................................................................................. 4
Bicondicional: ...................................................................................................................................... 5
Condición múltiple .............................................................................................................................. 5
SWITCH-CASE ...................................................................................................................................... 6
Estructura Repetitivas ......................................................................................................................... 7
FOR ...................................................................................................................................................... 7
ESTRUCTURA WHILE............................................................................................................................ 8
LA ESTRUCTURA DE CONTROL DO WHILE ........................................................................................... 9
2
Estructuras Selectivas
La especificación formal de algoritmos es realmente útil cuando se requiere una
descripción más complicada que una lista sencilla de instrucciones. Este es el caso
cuando existen un número de posibles alternativas resultantes de la evaluación de
una determinada condición.
Las estructuras selectivas se utilizan para tomar decisiones lógicas; de ahí que
también se conocen como estructuras de decisión o alternativas.
En las estructuras selectivas se evalúa una condición, y en función del resultado de
la misma se toma un camino u otro.
Las condiciones se establecen usando expresiones lógicas.
La representación de una estructura selectiva se hace con palabras (Si-entoncessi_no), con una figura geométrica en forma de rombo, que incluye dos salidas. La
salida que se utiliza depende del resultado de evaluar la expresión lógica que se
encuentra en la parte interna del rombo.
Las estructuras selectivas o alternativas pueden ser:
Simples
Dobles
Múltiples
¿Qué es una estructura repetitiva?
Las estructuras repetitivas se utilizan cuando se quiere que un conjunto de
instrucciones se ejecuten un cierto número finito de veces, por ejemplo, escribir algo
en pantalla cierta cantidad de veces, mover un objeto de un punto a otro cierta
cantidad de pasos, o hacer una operación matemática cierta cantidad de veces. Se
les llama bucle o ciclo a todo proceso que se repite cierto número de veces dentro
de un pseudocódigo o un programa y las estructuras repetitivas nos permiten
hacerlo de forma sencilla.
Existen diferentes tipos de estructuras que veremos una a una.
For (Desde o para)
While (Mientras)
Do while (Repetir Hasta)
3
Simple
La estructura simple es si (if) con dos formatos: Formato Pascal, si-entonces (ifthen) y en formato C, si(if) a estructura selectiva doble es igual que la estructura
simple si al cual se le añade la cláusula si-no (else) a estructura selectiva múltiples
según-sea(switch en lenguaje C, case en pascal)
Estructura condicional: if y else
Es usada para ejecutar una instrucción o bloque de instrucciones solo si una
condición es cumplida. Su forma es:
if (condición) extracto
donde la condición es la expresión que será evaluada. Si esta condición es true
(verdadera), el extracto es ejecutado. Si esta es falsa (false), el extracto es ignorado
(no ejecutado) y el programa continua en la siguiente instrucción después de la
estructura condicional.
por ejemplo, el siguiente fragmento de código imprime x es 100 solo si el valor
guardado en la variable x es en verdad 100:
if (x == 100)
cout << "x es 100";
Si queremos más de una instrucción para ser ejecutada en caso de que la condición
sea verdadera podemos especificar un bloque de instrucciones usando llaves { }:
if (x == 100)
{
cout << "x es ";
cout << x;
}
Podemos adicionalmente especificar que queremos que pase si la condición no es
cumplida mediante el uso de la palabra reservada else. su forma usada en
conjunción con if es:
if (condición) extracto1 else extracto2
4
Bicondicional:
La ejecución de la acción de esta secuencia depende del valor de esta. La acción
de diferente en cada valor. Se utiliza la estructura if (condición) else en este tipo de
secuencia.
La instrucción selectiva doble si entonces / sino permite que el lujo del diagrama se
bifurque por dos ramas diferentes dependiendo del cumplimiento de una condición
P.
if (P)
Instrucciones1;
else
Instrucciones2;
o también
if (P) f
Instrucciones1;
else f
Instrucciones2;
Condición múltiple
Depende del valor de una expresión la acción que se ejecutara, pero en esta
secuencia se decidirá entre diferentes acciones. Se utiliza la estructura switch
(expresion) en esta secuencia.
Son estructuras selectivas que contienen a otras estructuras selectivas
if (Condicion1){
if (Condicion1) f
if (Condicion2){
if (Condicion2) f
Operacion21;
Operacion21;
{
else{
Operacion22;
f
else f
Operacion22;
}
}
5
SWITCH-CASE
La sentencia múltiple switch ( ) está formada por una serie de etiquetas case que
solamente cumplen con una condición determinada y un caso opcional default en el
que están contemplados todos los valores que no se encuentran en los case.
La forma general de las sentencias switch ( ) es:
switch (expresion)
{
case constante1:
sentencia1;
break;
case constante2:
sentencia2;
break;
case constante_n:
En esta sentencias el case solamente evalúa una
expresión y no mas aunque puede llevar n numero
de case, pero son un gran numero se recomienda
usar ciclos. Estas expresiones solo puede ser de tipo
entero y de un solo carácter, al igual las constantes
que se colocan.
Si el valor de la expresión es igual a alguna de las
constantes, se ejecutará el bloque de instrucciones
hasta encontrar la instrucción break, de lo contrario
pasa al siguiente bloque y si no cumple ninguno de
los bloques entonces se ejecuta las sentencias del
default.
sentencia_n;
break;
default:
sentencias;
break;
Ejemplo:
Switch (confiabilidad_del_producto) {
Case A:
Cout<<”perfecta”;
Break;
Case B:
Cout<<”Muy Buena”;
6
Break;
Case C:
Cout<<”Regular”;
Default:
Cout<<”Fuera de rango”;
Break ;
Estructura Repetitivas
FOR
El ciclo for permite ejecutar un conjunto de sentencias un número fijo de veces y
antes de saber cómo funciona esta sentencia, primero que nada vamos a ver la
sintaxis.
Como podemos ver esta sentencia está compuesta de 3 partes separadas por ;
(punto y coma) la primera parte llamada inicialización permite controlar el ciclo,
suele ser la variable de tipo entero por lo general la letra i, pero puede ser cualquier
otra letra, esta variable es declarada e inicializada dentro de la estructura aunque
se la puede hacer desde fuera, la variable de inicialización indica desde que valor
va empezar el ciclo. La segunda parte es la condición, la condición indica cuantas
veces se va ejecutar el ciclo y se evalúa antes de cada iteración, si la condición es
verdadera el ciclo continua, tomar en cuenta que si se omite esta parte, el ciclo se
vuelve infinito.
La tercera parte es el incremento o decremento y le indica en pasos de cuánto debe
incrementarse o decrementarse la variable de inicialización en cada iteración, por lo
general es de uno en uno, pero todo dependerá del problema que se quiera resolver,
también puede omitirse esta parte, si se lo hace el ciclo se vuelve infinito (no
siempre).
7
ESTRUCTURA WHILE
Esta estructura es parecida al ciclo for, la diferencia está en su sintaxis:
El ciclo while permite ejecutar n veces un conjunto de instrucciones siempre y
cuando la condición se cumpla o sea verdadera.
Nota importante: Este ciclo se utiliza cuando no sabemos el número de veces
exacto que se ejecutará el ciclo.
Si la condición siempre es verdadera o siempre se cumple este ciclo puede crear
un bucle que nunca termine, por eso hay que tener en cuenta que en algún
momento del ciclo la condición no debe cumplirse (debe volverse falsa) para que
el ciclo termine, caso contrario el ciclo se vuelve infinito.
VAMOS A VER UN EJEMPLO
Ingresar un número por teclado e imprimir por la consola su decena superior:
Ejemplo sin ingreso el número 5, su decena superior es 10, si ingreso el 25, su
decena superior es 30.
ANÁLISIS DEL PROBLEMA PARA SABER QUE CICLO UTILIZAR
El ejemplo anterior lo podemos resolver también con un ciclo for, pero como no
sabemos cuantas iteraciones o cuantas veces se repite el ciclo ya que la decena
superior cambiará de acuerdo al número ingresado, es recomendable utilizar el
ciclo while.
8
Explicando un poco el ciclo, en la línea 12, se obtiene el número desde teclado (si
deseas un ejemplo completo de cómo ingresar números desde teclado puedes
ingresar a esta entrada Entrada de datos en Java utilizando la Clase Scanner), en
la línea 13 empieza el ciclo while, la condición para que ingrese al ciclo, es que el
módulo o resto de dividir el número entre 10 sea diferente de cero.
El módulo de dividir cualquier número entre 10, (excepto los múltiplos de 10 por
ejemplo 10, 20, 30, 40, etc..) siempre nos dará un valor diferente de cero y por
ende ingresa al ciclo.
Entonces la idea es ir incrementando el número ingresado hasta que sea múltiplo
de 10 y con esto el módulo de dividir el número entre 10 va ser cero y por ende ya
no va ingresar al bucle.
Con esto el número se habrá incrementado y sabremos cual es la decena superior
de cualquier número ingresado.
LA ESTRUCTURA DE CONTROL DO WHILE
El ciclo do while también permite ejecutar n número de veces un conjunto de
instrucciones, es muy parecida a las otras 2 estructuras de control que hemos
visto anteriormente, salvo que este ciclo siempre se ejecuta por lo menos una vez,
recordemos que en el ciclo for debemos conocer el número de veces que se va
ejecutar las instrucciones, el ciclo while hay una condición que se debe cumplir
para que se ejecuten las instrucciones, en cambio en el ciclo do while primero se
ejecutan las instrucciones y luego verifica la condición y si esta es verdadera el
ciclo se repite hasta verificar de nuevo la condición, para salir del ciclo la condición
se debe volver falsa.
La sintaxis del ciclo do while es la siguiente:
VAMOS A VER UN EJEMPLO
Obtener los dígitos de un número ingresado por teclado, ejemplo 100, tiene 3
dígitos.
Una forma para obtener los dígitos que tiene un número, realizamos divisiones
sucesivas entre 10 hasta que el número se vuelve cero (del resultado de la
división sólo se debe tomar la parte entera), para obtener el número de dígitos
contamos las veces que se ha dividido. Por ejemplo tenemos el número 345:
9
El resultado debe ser almacenado en una variable de tipo entero.
345/10=34
34/10=3
3/10=0
En este caso se ha realizado 3 divisiones por lo que el número de dígitos es 3
También hubiésemos podido utilizar el ciclo while que funciona con todos los
números, menos con el número 0 (cero), no entra en el ciclo porque número es
igual que cero y por ende la respuesta va ser:
sto se soluciona con el ciclo do while que me garantiza que por lo menos el ciclo
se va ejecutar una vez, con esto, si se ingresa el número cero va ingresar al ciclo
ya que la condición se verifica al final.
Nota importante: Este ciclo se utiliza cuando sabemos que se ejecutará el ciclo al
menos una vez .
10
CONCLUSION
En conclusión las estructuras se pueden colocar de maneras diferentes a la hora
de programar, pero cada una tiene su función y debe ser utilizada en el momento
que se necesite.
11
BIBLIOGRAFIA
http://www.marcossarmiento.com/2014/09/02/estructuras-selectivassimples-dobles-y-multiples/
https://www.ecodeup.com/estructuras-de-control-repetitivas-en-java-forwhile-do-while/
12
0
