CICLOS DE
CONTROL EN JAVA
Eredy Rodriguez
INSTITUTO TECNOLÓGICO
SUPERIOR DE ALVARADO
INGIENERIA EN SISTEMAS COMPUTACIONALES
Materia
FUNDAMENTOS DE LA PROGRAMACIÓN
Unidad: 4
NUMERO DE CONTROL :
190Z0390
Semestre-Grupo:
PRIMER SEMESTRE – (A)
PODUCTO ACADEMICO
INVESTIGACION
Presenta
CARLOS EREDY HERNANDEZ RODRÍGUEZ
Docente
ROBERTO CÁCERES CENTENO
Fecha:
15 DE NOVIEMBRE DE 2019
TLALIXCOYAN, VER. AGO-DIC 2019
ÍNDICE
INTRODUCCIÓN..................................................................................................................3
LOS CICLOS DE PROGRAMACIÓN EN JAVA................................................................4
LOS CICLOS FOR EN JAVA...............................................................................................5
EJEMPLOS DE CICLO FOR EN JAVA...............................................................................6
EL CICLO WHILE EN JAVA...............................................................................................7
EL CICLO DO-WHILE EN JAVA......................................................................................10
CICLO IF EN JAVA............................................................................................................12
CICLO SWITCH CASE EN JAVA.....................................................................................13
DIAGRAMA DE FLUJO DE SWITCH-CASE:................................................................14
CONCLUSIÓN.....................................................................................................................15
BIBLIOGRAFÍA...........................................................................................................................16
INTRODUCCIÓN
En este trabajo veremos como se utilizan los ciclos de programación en java y
que significa cada uno de los ciclos el ciclo for que en español es para son una
estructura de control cíclica, nos permiten ejecutar una o varias líneas de código
de forma iterativa (o repetitiva), saben el significado de ciclo o bucle son una
estructura de control de total importancia para el proceso de creación de un
programa por si no lo sabes Existen diferentes tipos de ciclos o bucles en Java,
cada uno tiene una utilidad para casos específicos y depende de nuestra habilidad
y conocimientos poder determinar en qué momento es bueno usar alguno de ellos
en todos esos ejercen diferentes funciones que nosotros podemos desarrollar en
si los ciclos for (o ciclos para) son una estructura de control cíclica, nos permiten
ejecutar una o varias líneas de código de forma iterativa (o repetitiva),
LOS CICLOS DE PROGRAMACIÓN EN JAVA
Que es un ciclo:
Los ciclos o también conocidos como bucles, son una estructura de control de total
importancia para el proceso de creación de un programa. Java y prácticamente
todos los lenguajes más populares de la actualidad nos permiten hacer uso de
estas estructuras y muchas más. Un ciclo en Java o bucle en Java (como prefieras
llamarlo) permite repetir una o varias instrucciones cuantas veces lo necesitemos
o sea necesario, por ejemplo, si quisiéramos escribir los números del uno al cien
no tendría sentido escribir cien líneas de código mostrando un número en cada
una de estas, para eso y para varias cosas más (que veremos enseguida), es útil
un ciclo. Un ciclo nos ayuda a llevar a cabo una tarea repetitiva en una cantidad de
líneas muy pequeña y de forma prácticamente automática .
Existen diferentes tipos de ciclos o bucles en Java, cada uno tiene una utilidad
para casos específicos y depende de nuestra habilidad y conocimientos poder
determinar en qué momento es bueno usar alguno de ellos. Tenemos entonces a
nuestra disposición los siguientes tipos de ciclos en Java:
Esta vez vamos a ver cómo se utiliza las estructuras de control repetitivas en Java
(también conocidas como ciclos o bucles). Como mencionaba en el
tutorial Estructuras de control condicionales vamos a necesitar de estas
estructuras al momento de programar, y pues bueno este tipo de estructuras de
control se las utiliza cuando necesitamos recorrer un conjunto de datos, por
ejemplo al leer un archivo, al leer registros de una base de datos, en fin, en todos
los problemas en los que se tenga que hacer iteraciones, bucles, siempre vamos a
necesitar de estas estructuras.
LOS CICLOS FOR EN JAVA
Los ciclos for (o ciclos para) son una estructura de control cíclica, nos permiten
ejecutar una o varias líneas de código de forma iterativa (o repetitiva), pero
teniendo cierto control y conocimiento sobre las iteraciones. En el ciclo for, es
necesario tener un valor inicial y un valor final, y opcionalmente podemos hacer
uso del tamaño del "paso" entre cada "giro" o iteración del ciclo.
En resumen, un ciclo for es una estructura iterativa para ejecutar un mismo
segmento de código una cantidad de veces deseada; conociendo previamente un
valor de inicio, un tamaño de paso y un valor final para el ciclo.
¿Cómo funciona un Ciclo For?
Para comprender mejor el funcionamiento del ciclo for, solucionemos un pequeño
ejercicio práctico, supongamos que queremos mostrar los números pares
(múltiplos de dos :P) entre el 500 y el 1000. Con esta información inmediatamente
podemos determinar que por medio de un ciclo debemos mostrar una serie de
números como la siguiente: 500 502 504 506 ... 600 ... 852 ... 906 ... 980 .. 1000.
Tenemos entonces todo lo necesario para nuestro ciclo. Tenemos un valor inicial
que sería el 500, un valor final (1000) y tenemos un tamaño de paso que es 2 (los
números pares). Estamos ahora en capacidad de determinar los componentes
esenciales para un ciclo for.
Vamos a ver ahora la sintaxis de un ciclo for en Java, así estaremos listos para
usarlos en nuestros programas de ahora en adelante.
Sintaxis del Ciclo For en Java:
La sintaxis de un ciclo for es simple en Java, en realidad en la mayoría de los
lenguajes de alto nivel es incluso muy similar, de hecho, con tan solo tener bien
claros los 3 componentes del ciclo for (inicio, final y tamaño de paso) tenemos
prácticamente todo hecho
Ejemplos de Ciclo For en Java
A continuación vamos a ver unos cuantos ejemplos para comprender de manera
adecuada el uso de los ciclos for en Java, recuerda que si no comprendes alguno
de estos ejemplos o tienes alguna pregunta o sugerencia sobre estos o cualquier
contenido de la sección, puedes dejarlas en la sección de comentarios
Ejemplo 1: Mostrar en pantalla los números pares
Vamos a retomar el ejemplo anterior, donde deseábamos sacar los números pares
entre el numero 500 y el 1000, es un ejemplo sencillo con el que nos
aseguraremos de haber comprendido bien lo anterior:
Solución Ejemplo 1:
for(int i=500;i<=1000;i+=2)
{//Notemos que escribir i+=2 es similar a escribir i = i + 2
System.out.println(i);
}
El código funcional completo sería el siguiente:
public class CicloFor
public static void main(String args[])
for(int i=500;i<=1000;i+=2)
System.out.println(i);
}
EL CICLO WHILE EN JAVA
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.
El ciclo o bucle while permite ejecutar un bloque de código siempre y cuando una
condición especificada sea verdadera, la estructura básica es la siguiente:
while (condición) {
//Código que será ejecutado
En el siguiente ejemplo, el bucle se ejecutará una y otra vez, siempre que la
variable «i» sea menor que 10:
public class EjemploWhile {
public static void main(String args[]) {
int i = 0;
while (i < 10) {
System.out.println("i: " + i);
i++;
}
Debes notar que a la variable «i» se le asigna el valor cero antes de llegar al
bucle del while, el incremento del valor de esta variable se hace dentro del bloque
de código del bucle con la ayuda del operador ++, que incrementa el valor en uno
en cada pasada. Al ejecutar el código obtendrás un resultado como el siguiente:
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.
A continuación el código.
Ciclo while: Decena superior de un número ingresado por consola
Java
1 package com.ecodeup.ciclos;
2
3 import java.util.Scanner;
4
5 public class TestCiclos {
6 public static void main(String[] args) {
7 int numero;
8 Scanner entrada = new Scanner(System.in);
9 System.out.println("Ingrese un número:");
10
11 try {
12 numero = entrada.nextInt();
13 while ((numero % 10) != 0) {
14 numero++;
15 }
16 System.out.println("La decena superior es: " + numero);
17 } catch (Exception e) {
18 System.out.println("Número no válido");
19 }
20 }
21 }
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 CICLO DO-WHILE EN JAVA
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.
Otra variante del ciclo while es el bucle do-while. Este bucle ejecutará el bloque de
código al menos una vez, antes de verificar si la condición es verdadera.
do {
//El código que será ejecutado
while (condición);
El siguiente ejemplo utiliza un bucle do-while.
public class EjemploWhile {
public static void main(String args[]) {
int i = 0;
do {
System.out.println(i);
i++;
} while (i < 10);
}
Esta variante del bucle es útil si lo que buscas es que tu código se ejecute al
menos una vez, antes de verificar que la condición se cumpla y aunque esta sea
falsa y termine inmediatamente.
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:
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.
Ciclo do while: Dígitos de un número
Java
1 package www.ecodeup.com;
2
3 public class TestCiclos {
4
5 public static void main(String[] args) {
6 int numero = 345;
7 int contador = 0;
8 do {
9 numero /= 10;
10 System.out.println(numero);
11 contador++;
12 } while (numero != 0);
13 System.out.println("El número tiene " + contador + " dígitos");
14 }
15 }
CICLO IF EN JAVA
Java proporciona las instrucciones if/else, switch y el operador ternario para poder
tomar decisiones en función del resultado de la evaluación de una condición o
variable.
La instrucción if tiene la siguiente estructura:
if (condición)
{
//Código a ejecutar si condición es true
}
else
{
//Código a ejecutar si condición es false
}
Esta instrucción evalúa la expresión condición, y si es true, ejecuta el código que
hay entre las llaves que hay debajo de if. Si condición fuese false el código a
ejecutar seria el contenido entre las llaves que existen debajo de else.
La parte else es opcional, es decir, esto también es correcto:
if (condición)
{
//Código a ejecutar si condición es true
}
En este caso si condición es false no sucede nada, la instrucción no ejecuta
ninguna instrucción.
Otra simplificación también correcta es que en caso de que sólo exista una
instrucción dentro de las llaves (del if, o del else) se pueden eliminar las llaves, es
decir:
if (condición) //instrucción a ejecutar si condición es true;
else //instrucción a ejecutar si condición es false;
Lo que no está permitido eliminar en ningún caso, son los puntos y coma de las
instrucciones que empleemos en la parte verdadera (if) o falsa (else), tengamos o
no las llaves.
CICLO SWITCH CASE EN JAVA
La instrucción switch es una instrucción de múltiples vías. Proporciona una forma
sencilla de enviar la ejecución a diferentes partes del código en función del valor
de la expresión. Básicamente, la expresión puede ser tipos de datos
primitivos byte, short, char e int. A partir de JDK7, también funciona con tipos
enumerados (Enum en java), la clase String y las clases Wrapper.
1. / declaración de switch
2. switch(expresión)
3. {
4. // declaración case
5. // los valores deben ser del mismo tipo de la expresión
6. case valor1 :
7. // Declaraciones
8. break; // break es opcional
9.
10. case valor2 :
11. // Declaraciones
12. break; // break es opcional
13.
14. // Podemos tener cualquier número de declaraciones de casos o case
15. // debajo se encuentra la declaración predeterminada, que se usa cuando ninguno de los
casos es verdadero.
16. // No se necesita descanso en el case default
17. default :
18. // Declaraciones
DIAGRAMA DE FLUJO DE SWITCH-CASE:
Algunas reglas importantes para declaraciones switch :
Los valores duplicados de los case no están permitidos.
El valor para un case debe ser del mismo tipo de datos que la variable en el
switch.
El valor para un case debe ser una constante o un literal. Las variables no están
permitidas.
La declaración break se usa dentro del switch para finalizar una secuencia de
instrucción.
La declaración break es opcional. Si se omite, la ejecución continuará en el
siguiente case.
La instrucción default es opcional, y debe aparecer al final del switc
CONCLUSIÓN
En este trabajo veremos los códigos de control el cual veremos son los ciclos o
también conocidos como bucles, son una estructura de control de total importancia
para el proceso de creación de un programa. Son bucles repetidos de
construcción mencionamos que Existen diferentes tipos de ciclos o bucles en
Java, cada uno tiene una utilidad para casos específicos y depende de nuestra
habilidad y conocimientos poder determinar en qué momento es bueno usar
alguno de ellos la verdad es que mencionamos ciclos que son el for, while, do
while, if y case esas son los ciclos que funcionan en java la verdad es que son
ciclos repetidos en java en Java proporciona las instrucciones if/else, switch y el
operador ternario para poder tomar decisiones en función del resultado de la
evaluación de una condición o variable son comandos el cual funcionan en un
verdadero o falso es ternario.
Bibliografía
gonzales, r. (2004). la introducion de lo que es java (2a ed.). los angeles, estados unidos: works.
González, J. D. (2012). bucles o ciclos en java (3a ed.). colima: desarrollador web.
