Facultad de Informática y Ciencias
Aplicadas
Carrera: Técnico en Ingeniería de Software
Asignatura: Programación Orientada a Objetos
Sección: 02
Docente: Sandra Maritza Cantarero de Martínez
Tema: Estructuras de Control en Java
Estudiante: José Gerardo Rodríguez Tobías
Carnet: 27-0298-2026
San Salvador, El Salvador
8 de marzo de 2026
INTRODUCCIÓN
¿Qué son las estructuras de control?
Las estructuras de control son mecanismos fundamentales en la programación que
permiten dirigir el flujo de ejecución de un programa. A través de ellas, el programador
puede decidir qué instrucciones se ejecutan, cuántas veces se repiten y bajo qué
condiciones se detiene o continúa un proceso.
En el lenguaje Java, estas estructuras son esenciales para construir programas
dinámicos, eficientes y capaces de responder a distintas situaciones. Se clasifican
principalmente en estructuras condicionales, estructuras repetitivas y estructuras de
control adicional, las cuales permiten tomar decisiones, repetir acciones y modificar
el comportamiento normal del flujo del programa.
DESARROLLO TEÓRICO
Estructuras de control condicionales
Las estructuras de control condicionales permiten que un programa tome decisiones
durante su ejecución. Estas estructuras evalúan una expresión lógica o booleana y,
dependiendo de si el resultado es verdadero o falso, el programa ejecuta un bloque
específico de instrucciones.
Según Deitel y Deitel, estas estructuras permiten que el flujo de ejecución de un
programa no sea únicamente secuencial, sino que pueda desviarse hacia diferentes
caminos dependiendo de las condiciones evaluadas. Esto permite que los programas
respondan a distintas situaciones o datos proporcionados por el usuario.
if
La estructura if se utiliza para ejecutar un bloque de código únicamente cuando una
condición lógica se evalúa como verdadera. Es la forma más básica de control de
decisión en Java y permite que el programa realice una acción solo cuando se cumple
un criterio determinado. Según lo que se explica en textos como Java How to Program
de Deitel y Deitel y en la Java Language Specification de Oracle, esta estructura
forma parte de las sentencias de control que permiten dirigir el flujo de ejecución del
programa dependiendo del resultado de una expresión booleana.
if – else
La estructura if – else permite ejecutar un bloque de código cuando la condición es
verdadera y otro bloque diferente cuando la condición es falsa. De esta forma, el
programa puede tomar una decisión entre dos posibles caminos de ejecución.
if – else if – else
Esta estructura permite evaluar múltiples condiciones de forma secuencial. El
programa revisa cada condición en orden y ejecuta el bloque de código
correspondiente a la primera condición que resulte verdadera. Si ninguna condición
se cumple, se ejecuta el bloque else.
switch
La estructura switch se utiliza cuando se desea evaluar una misma variable contra
varios valores posibles. Dependiendo del valor de la variable, se ejecuta el bloque de
código asociado al caso (case) correspondiente. Es especialmente útil cuando
existen muchas comparaciones posibles.
Diferencia entre switch e if:
Según Java How to Program de Deitel & Deitel, switch se utiliza cuando se comparan
muchos valores posibles de una misma variable, mientras que if se emplea cuando
las condiciones pueden ser expresiones lógicas más complejas (comparaciones
múltiples, operadores lógicos, rangos de valores, etc.). Por lo tanto, switch suele
hacer el código más claro cuando solo se comparan valores específicos de una
misma variable.
Estructuras de control repetitivas (ciclos)
Las estructuras de control repetitivas permiten ejecutar un conjunto de instrucciones
varias veces mientras se cumpla una condición determinada. Estas estructuras son
conocidas también como ciclos o bucles.
De acuerdo con Deitel y Deitel, los ciclos permiten automatizar tareas que deben
repetirse múltiples veces sin necesidad de escribir el mismo código repetidamente.
Esto mejora la eficiencia del programa y facilita su mantenimiento.
while
La estructura while repite un bloque de instrucciones mientras una condición sea
verdadera. La condición se evalúa antes de ejecutar el bloque de código, por lo que, si
la condición es falsa desde el inicio, el ciclo nunca se ejecutará. De acuerdo con la
explicación de las estructuras iterativas en los textos académicos de Java, este tipo
de ciclo se utiliza cuando la repetición depende de una condición que se sigue
evaluando durante la ejecución del programa.
do – while
La estructura do – while funciona de manera similar al while, pero con la diferencia de
que el bloque de código se ejecuta al menos una vez antes de evaluar la condición.
Después de la primera ejecución, el ciclo continúa repitiéndose mientras la condición
sea verdadera.
for
La estructura for se utiliza cuando se conoce previamente el número de veces que se
desea repetir un bloque de código. Esta estructura incluye tres elementos
principales: la inicialización de la variable de control, la condición de repetición y el
incremento o actualización de la variable. En los textos teóricos de programación en
Java se explica que esta forma de ciclo permite controlar de manera clara el proceso
de iteración dentro de una sola estructura, facilitando el manejo de repeticiones en
un programa.
Diferencia entre do-while y while:
De acuerdo con la especificación del lenguaje Java (The Java Language Specification
de Oracle), el ciclo while evalúa la condición antes de ejecutar el bloque, mientras
que el ciclo do-while evalúa la condición después de ejecutar el bloque. Esto
garantiza que el do-while se ejecute al menos una vez, mientras que el while puede
no ejecutarse ninguna vez si la condición inicial es falsa.
Instrucciones de control adicional
Las instrucciones de control adicional permiten modificar el comportamiento normal
de las estructuras de control, especialmente dentro de ciclos o estructuras de
selección.
Según la especificación del lenguaje Java de Oracle, estas instrucciones permiten
alterar el flujo normal del programa, ya sea terminando un ciclo antes de que su
condición se vuelva falsa o saltando ciertas partes del código durante una iteración.
break
La instrucción break se utiliza para finalizar inmediatamente la ejecución de un ciclo
(for, while, do-while) o de una estructura switch. Cuando el programa encuentra esta
instrucción, sale del bloque actual y continúa con la siguiente instrucción fuera del
ciclo o del switch.
continue
La instrucción continue se utiliza dentro de estructuras repetitivas para saltar el resto
de las instrucciones de la iteración actual y continuar directamente con la siguiente
repetición del ciclo.
SINTAXIS GENERAL EN JAVA
ESTRUCTURAS DE CONTROL CONDICIONALES
Principales estructuras de control en Java
• If
• if – else
• if – else if – else
• switch
If (condición){
// instrucciones que se ejecutan únicamente cuando la condición es
verdadera
------------------------------------------------------------------------------------------------------------
if (condición) {
// instrucciones si la condición es verdadera
} else {
// instrucciones si la condición es falsa
------------------------------------------------------------------------------------------------------------
if (condición1) {
// instrucciones que se ejecutan si la primera condición es verdadera
} else if (condición2) {
// instrucciones que se ejecutan si la primera condición es falsa y la segunda es
verdadera
} else {
// instrucciones que se ejecutan cuando ninguna de las condiciones anteriores se
cumple
}
------------------------------------------------------------------------------------------------------------
switch (expresión) {
case valor1:
// instrucciones que se ejecutan si la expresión coincide con valor1
break;
case valor2:
// instrucciones que se ejecutan si la expresión coincide con valor2
break;
default:
// instrucciones que se ejecutan si ningún caso coincide con el valor de la
expresión
}
ESTRUCTURAS DE CONTROL REPETITIVAS
Principales estructuras repetitivas en Java
• while
• do – while
• for
while (condición) {
// instrucciones que se ejecutan repetidamente mientras la condición sea
verdadera
------------------------------------------------------------------------------------------------------------
do {
// instrucciones que se ejecutan al menos una vez y se repiten mientras la
condición sea verdadera
} while (condición);
------------------------------------------------------------------------------------------------------------
for (inicialización; condición; incremento) {
// instrucciones que se repiten mientras la condición sea verdadera
}
INSTRUCCIONES DE CONTROL ADICIONAL
Principales instrucciones de control adicional
• break
• continue
while (condición) {
if (otraCondición) {
break;
// finaliza inmediatamente el ciclo o estructura en la que se encuentra
// otras instrucciones del ciclo
------------------------------------------------------------------------------------------------------------
for (inicialización; condición; incremento) {
if (condición) {
continue;
// omite el resto de instrucciones de esta iteración y pasa a la siguiente
repetición del ciclo
// instrucciones que solo se ejecutan cuando no se activa continue
}
EJEMPLOS FUNCIONALES POR CADA ESTRUCTURA
Estructuras de control condicionales
If
Ejemplo que pide al usuario una nota, si la nota es 10.0 muestra un mensaje diciendo
“Felicidades, tienes una nota perfecta”, si fuera un if-else, podría colocar un mensaje
donde si la nota no fuera 10.0 diría que “No es una nota perfecta”, pero esa es la
limitante del if.
import [Link].*;
class Condicional_if{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
//Intente poner public double, pero me daba error asi que lo deje solo
como double
double nota;
[Link]("Ingrese su nota: ");
nota = [Link]();
if (nota == 10.0){
[Link]("Felicidades, tienes una nota perfecta");
}
If-else
Ejemplo que pide al usuario que ingrese su edad y si es mayor o igual a 18 muestra un
mensaje diciendo que es mayor de edad, en cambio si el numero ingresado es menor
a 18 muestra un mensaje diciendo que es menor de edad.
import [Link].*;
class Condicional_if_else{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
//Por alguna razon en este ejemplo tampoco me deja poner public int
int edad;
[Link]("Ingrese su edad: ");
edad = [Link]();
if (edad >= 18){
[Link]("Usted es mayor de edad");
}else {
[Link]("Usted es menor de edad");
}
if – else if – else
Ejemplo que le pide al usuario ingresar su edad y dependiendo del numero ingresado,
se mostrara un mensaje en pantalla mencionando la etapa del ciclo vital en el que se
encuentra, si es de 60 en adelante “Adulto mayor”, 18 en adelante “adulto”, 12 en
adelante “adolescente”, ninguna de las anteriores “infante”.
import [Link].*;
class Condicional_if_elseif_else{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
int edad;
[Link]("Ingrese su edad");
edad = [Link]();
if(edad >= 60){
[Link]("Usted es un Adulto Mayor.");
else if(edad >= 18){
[Link]("Usted es un Adulto.");
else if(edad >= 12){
[Link]("Usted es un Adolescente.");
else{
[Link]("Usted es un Infante.");
}
Switch
En este ejemplo se ha creado un menú de opciones que simula el de atención al
cliente en una empresa que tiene un menú automatizado en el que la opción que
escoja lo redireccionará con alguien que podrá ayudarlo con su problema o consulta
relacionado a la opción que escogió, si la opción escogida no se encuentra en el
menú muestra un mensaje diciendo "La opción escogida no se encuentra en el
menú".
import [Link].*;
class Condicional_switch{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
int opcion;
[Link]("--- SISTEMA DE ATENCION ---");
[Link]("1. Soporte Tecnico");
[Link]("2. Facturacion");
[Link]("3. Ventas");
[Link]("Seleccione una opcion");
opcion = [Link]();
switch (opcion) {
case 1:
[Link]("Transfiriendo a Soporte Tecnico...");
break; // Detiene la ejecución del switch
case 2:
[Link]("Conectando con Facturacion...");
break;
case 3:
[Link]("Redirigiendo a Ventas...");
break;
default:
// Se ejecuta si no coincide con ningun caso anterior
[Link]("La opcion escogida no se encuentra en el
menu");
break;
}
Estructuras de control repetitivas (ciclos)
while
Ejemplo que le pide al usuario ingresar un número mayor que 0, si el numero cumple
la condición entra en el while y una vez ingresado se ejecuta el while mostrando los
números siendo restados de uno en uno en forma de cuenta regresiva, mientras se
realiza el procedimiento de restar un numero menos al numero ingresado para que el
while no se ejecute infinitamente, si el numero ingresado al principio no es mayor que
0 entonces no entra el while y por ende no se ejecuta ninguno de los procedimientos
en su interior.
import [Link].*;
class Ciclo_while{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
int numero;
[Link]("Ingrese un numero mayor a 0");
numero = [Link]();
while(numero > 0){
[Link]("..."+ numero);
numero = numero - 1;
}
Do-while
En este ejemplo se simula una situación en la que una persona ha fallado todos los
intentos posibles de ingresar a su cuenta y ahora se le pide que ingrese su pin de 4
dígitos de seguridad para saber que es el dueño de la cuenta el que esta intentando
ingresar y no alguien más, si los números son diferentes (!=), se ejecuta el if y muestra
el mensaje en pantalla de que el pin es incorrecto y pasa al while del do-while donde
al ser diferentes el pin ingresado con el pin correcto la condición es verdadera y el
programa vuelve a ejecutarse desde el inicio del do, pero si los números son iguales
(=), no se ejecuta el if y la condición se vuelve falsa y como el ciclo solo se repite
mientras la condición sea verdadera el ciclo se rompe y continúa con la siguiente
línea fuera del do-while.
import [Link].*;
class Ciclo_do_while{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
int pinIngresado;
//Este es el pin correcto, si se ingresa en el do-while se sale del ciclo
int pinCorrecto = 1234;
do{
[Link]("Ingrese su PIN de 4 digitos");
pinIngresado = [Link]();
if(pinIngresado != pinCorrecto){
[Link]("PIN incorrecto. Intente de nuevo\n");
}
}while (pinIngresado != pinCorrecto); // Compara numeros con !=
[Link]("El PIN ingresado es correcto" + "\nBIENVENIDO");
}
For
Ejemplo que haciendo uso del for pide un numero al usuario y dependiendo del
número esa será la tabla de multiplicar que mostrará en pantalla; haciendo uso del
número ingresado lo multiplica dentro del for por la variable que determina el tamaño
y cuantas veces se realiza el ciclo (i), en este caso se inicializa en 1 y termina en 10
repitiéndose de uno en uno (sumando 1 a i cada vez que se repite), hasta que llega a
10 y se sale del ciclo.
import [Link].*;
class Ciclo_for{
public static void main(String args[]){
Scanner leer = new Scanner([Link]);
int tabla, resultado;
[Link]("Cual tabla de multiplicar quiere que se muestre en
pantalla?");
tabla = [Link]();
[Link]("Tabla del " + tabla);
for (int i = 1; i <= 10; i++) {
resultado = tabla * i;
[Link](tabla + " x " + i + " = " + resultado);
}
Instrucciones de control adicional
Continue
Break
En este ejemplo se hace uso de un for inicializando la variable que determinara las
veces que se repetirá el for en 1 y poniendo el limite en 10, dentro del for mostrara en
pantalla los números de uno en uno (uno por cada vez que se repita el ciclo hasta que
llegue a su límite), pero antes de que se muestre en pantalla el numero en el que se
encuentra el ciclo hay dos if:
1. Uno que se ejecuta cuando el ciclo llega al numero 5, cuando se cumple la
condición y entra a ese if se activará la instrucción de condición adicional
“continue”, que hará que se salte las instrucciones que se encuentran
después del continue haciendo que no se muestre en pantalla el numero en el
que se encuentra el ciclo (el numero 5).
2. El siguiente if tiene por condición que i sea = 8, así que cuando el ciclo llegue
al numero 8 entrara al segundo if y se ejecutara la instrucción de condición
adicional “break”, que hará que se salga forzosamente del ciclo en el que se
encuentra, finalizando el ciclo sin que llegue al numero 10 que era el limite
determinado en el que debía terminar el for.
class Control{
public static void main(String args[]){
[Link]("Inicio del conteo");
for(int i = 1;i <= 10;i++){
if(i == 5){
[Link]("Saltando el numero 5...");
continue; // Salta a la siguiente vuelta del ciclo
if(i == 8){
[Link]("Se alcanzo el limite 8 Rompiendo ciclo");
break; // Sale completamente del for
[Link]("Contando: " + i);
[Link]("Fin del programa");
Sin el Continue
Sin el break
CONCLUSIÓN PERSONAL
Entender las estructuras de control es muy importante cuando se aprende a
programar en Java, ya que gracias a ellas los programas pueden tener un orden y una
lógica para funcionar correctamente. Las estructuras condicionales permiten que el
programa tome decisiones según ciertas condiciones, mientras que las estructuras
repetitivas ayudan a realizar tareas varias veces sin tener que escribir el mismo
código repetidamente. Por otro lado, las instrucciones de control adicional permiten
manejar mejor el flujo del programa, ya sea para detener un proceso o continuar con
la siguiente parte.
Aprender a utilizar bien estas estructuras no solo ayuda a escribir programas más
organizados y eficientes, sino que también desarrolla la forma de pensar de manera
lógica para resolver problemas. Tanto en los estudios como en el ámbito profesional,
estas herramientas son muy útiles porque permiten crear soluciones claras y
estructuradas para distintos tipos de situaciones.
BIBLIOGRAFÍA
Deitel, H. M., y Deitel, P. J. (2017). Java How to Program. Boston: Pearson Education.
Oracle Corporation. (2023). The Java Language Specification. Redwood City: Oracle.