1

ALGORITMOS Y
PROGRAMACIÓN
II

Unidad 1: Fundamentos de programación con JAVA

2

Tabla de contenido
Introducción..................................................................................................................................... 3

Pregunta orientadora ...................................................................................................................... 3

1. Sentencias de control de flujo en Java ................................................................................... 4

1.1. Estructuras condicionales ........................................................................................................ 4

1.1.1. Estructura de selección If .................................................................................. 4

1.1.1.1. Estructuras anidadas .................................................................................. 5

1.1.2. Función Switch .................................................................................................. 7

1.2. Estructuras Cíclicas ................................................................................................................. 7

1.2.1. Ciclo For............................................................................................................. 8

1.2.2. Ciclo While ......................................................................................................... 9

1.2.3. Ciclo Do While ................................................................................................. 10

2. Métodos y procedimientos..................................................................................................... 10

2.1. Métodos sin retorno y sin parámetros (Funciones vacías) ................................ 11

2.2. Métodos con parámetros y sin retorno de valor ................................................. 12

2.3. Métodos con parámetros, con retorno de valor .................................................. 13

Glosario ......................................................................................................................................... 15
3

Introducción
En la actualidad la tecnología ha permitido que las personas, las empresas y
organizaciones, usen diferentes programas tecnológicos, con el fin de optimizar el trabajo
que se realiza en el día a día por medio de estas herramientas, el cual les ayuda a
minimizar errores, gracias a los procesos automatizados y los lineamientos establecidos
cada uno de los programas.

Por medio de estas herramientas se han creado grandes soluciones a las diferentes
problemáticas encontradas e identificadas dentro de la sociedad, las compañías, entre
otros. Pero para poder brindarles una solución a las empresas, organizaciones y demás
entidades, se tiene que hacer un análisis de esta para así poder definir cada una de las
instrucciones que tiene que realizar el programa, y así mismo crear la secuencia de estos
por medio del código.

Sin embargo, hay ocasiones en las que es necesario hacer el uso de varios tipos de
secuencias, para darle el correspondiente funcionamiento al programa, para que ejecute
una serie de instrucciones o procesos según la necesidad o una condición determinada,
para que nuestro programa seleccione la correcta y muestre el resultado esperado.

Pero para poder desarrollar un programa es importante conocer los fundamentos

y tipos de secuencias básicas que se necesitan en la programación, para crear el
producto deseado.

Pregunta orientadora
Sin embargo, para poder identificar cual es la sentencia adecuada a aplicar en el
desarrollo óptimo de la aplicación, ¿Cuáles son los fundamentos y tipos de sentencias
que se pueden manejar y aplicar en el desarrollo de nuestra aplicación, para así crear
una solución eficiente a las necesidades reconocidas?
4

1. Sentencias de control de flujo en Java

Las estructuras de control o sentencias de control de flujo en java, nos ayuda a

generar un control sobre los programas o funcionalidades que se están realizando y
desarrollando. Este tipo de Estructuras están clasificadas entre las estructuras
condicionales y las estructuras cíclicas.

Este tipo de estructuras de control tienen las siguientes características:

• Se deben tener un único punto de entrada y salida de datos.
• Cada una de estas estructuras deben estar compuestas por un código de
sentencias, instrucciones u otras estructuras de control.

A continuación, hablaremos de algunos de estos tipos de estructuras.

1.1. Estructuras condicionales

Las estructuras condicionales nos ayudan a comparar variables, constantes ó

expresiones con respecto a otro u otros valores. En el momento de realizar esta
comparación(es), y que ya tengamos el resultado de este, se debe seguir un curso, tomar
un camino de acción dentro del programa, según el resultado obtenido.
De acuerdo con lo anterior una estructura condicional determina si se ejecutan
unas acciones u otras según la condición que se compruebe, el cual nos ayudara a
decidir qué instrucciones se tienen que ejecutar, según su resultado, el cual es una
expresión booleana, es decir debe dar como resultado un valor booleano true or false.
A continuación, hablaremos de algunas estructuras condicionales.

1.1.1. Estructura de selección If

Este tipo de estructura también es conocida como la estructura de selección única,

ya que cuando se ejecuta está estructura, el programa debe revisar si la condición es
verdadera, realiza las acciones o procesos cuando se cumple la condición, de lo
5

contrario, cuando la condición es falsa el flujo continuo posterior al if, los procesos que
definieron cuando da falso el resultado.

A continuación, veremos la estructura del mismo

if (condición) {

instrucciones si se cumple la condición (Verdadero)

} else { //si no

Instrucciones si no se cumple la condición (Falso)

1.1.1.1. Estructuras anidadas

Este tipo de estructuras se cumple cuando una estructura está dentro de otra estructura,
por ejemplo, para que la estructura de selección Si sea anidada, la estructura principal
de la función Si, se le puede agregar dentro de la misma otra estructura if, y así
sucesivamente y al mismo tiempo, dentro de cada estructura pueden existir diferentes
acciones

If anidado

A continuación, veremos la estructura de un if anidado

if (condición) {
instrucciones si se cumple la condición (Verdadero)

} else { //si no

//Se realiza el if anidado

if (condición) {

instrucciones si se cumple la condición (Verdadero)

} else { //si no

Instrucciones si no se cumple la condición (Falso)

}
6

Instrucciones si no se cumple la condición (Falso)

A continuación, veremos un ejemplo del if anidado, donde se verificará la nota final de

una asignatura y se le mostrara al usuario si aprobó o reprobó la asignatura y así mismo
la denominación que obtuvo en la misma.

if (nota_final >= 2.96) {

System.out.println("El estudiante aprobó la asignatura");
//verificamos si el estudiante paso la asignatura con aceptable, sobresaliente o
excelente
//Si aninado
if (nota_final <= 3.99) {
System.out.println("El estudiante obtuvo una nota de aceptable");
} else {
//Si aninado
if (nota_final <= 4.6) {
System.out.println("El estudiante obtuvo una nota sobresaliente");
} else {
System.out.println("El estudiante obtuvo una nota sobresaliente");
}
}
} else {
System.out.println("El estudiante reprobó la asignatura");
//verificamos si el estudiante reprobó la asignatura con insuficiente, deficiente
//Si anidado
if (nota_final <= 1.99) {
System.out.println("El estudiante obtuvo una nota de deficiente");
} else {
System.out.println("El estudiante obtuvo una nota de insuficiente");
}
}
7

1.1.2. Función Switch

Este tipo de estructura, tienes varias opciones en la cual elige entre ese grupo de
elecciones y ejecuta las instrucciones que se encuentren dentro del bloque elegido, en
el cual cada bloque finaliza con un break.
En el switch, se define un conjunto de casos, en el cual cada uno de ellos van a
tener unas instrucciones y procedimientos distintos a los demás y se ejecutará el caso
que coincida con el valor indicado en esta función.

A continuación, veremos la estructura del Switch

switch (variable_de_entrada) {
case valor_1:
//Se ejecutan las instrucciones cuando la variable de entrada es igual a
valor_1
break; // Salir del switch
case valor_2:
// Se ejecutan las instrucciones cuando la variable de entrada es igual al
valor_2
case valor_3:
// Ejecuta estas instrucciones si el valor de variable de entrada es igual a
valor_2 o valor_3, como el case valor_2 no tiene el break, ejecuta el
siguiente caso que sería el valor_3
break; // Salir del switch
default:
// Ejecutar este caso cuando el valor de la variable de entrada es distinto al
resto de casos del Switch
break; // Salir del switch
}

1.2. Estructuras Cíclicas

Este tipo de estructuras cíclicas, se utilizan cuando se necesita realizar un proceso

un número de veces finitas. Esta estructura de control permite ejecutar de forma repetida
una instrucción o un bloque de instrucciones mientras que se cumpla con una
determinada condición.
A continuación, hablaremos de algunas estructuras cíclicas
8

1.2.1. Ciclo For

La estructura cíclica for, hace que una instrucción o bloque de sentencias, el cual
se repetirá un número determinado de veces mientras se cumpla la condición, para esto
se debe definir el inicio de la condición, la evaluación de la expresión. El incremento o
decremento del valor y el bloque de instrucciones.

Este tipo de ciclos se utilizan cuando se conoce el número de veces en el que se

va a repetir las instrucciones del ciclo.

La estructura del bucle for es la siguiete:

for(inicialización; condición; incremento/decremento){ //inicio ciclo for

instrucciones;

} //fin del ciclo for

1.2.1.1. Estructuras cíclicas anidadas

Este tipo de estructuras se cumple cuando una estructura está dentro de otra estructura,
por ejemplo, para que la estructura cíclica de For sea anidada, la estructura principal de
del ciclo for, se le puede agregar otro ciclo for, y así sucesivamente y al mismo tiempo,
dentro de cada ciclo se le pueden agregar diferentes acciones

For anidado

A continuación, veremos la estructura de un For anidado

for(inicialización; condición; incremento/decremento){ //inicio ciclo for

// instrucciones;

for(inicialización; condición; incremento/decremento){ //inicio ciclo for

// instrucciones;

} //fin del ciclo for anidado

9

} //fin del ciclo for

A continuación, veremos un ejemplo del For anidado, donde se hallará la factorial de los
números del cero al 9, como se ve en el siguiente código:
for(int i = 0; i <= 9 ; i++){ //para cada número desde 0 hasta 9
//se calcula su factorial
factorial = 1;
for(int j = 1; j <= i; j++){
factorial = factorial * j;
}
//se muestra el factorial
System.out.printf("%2d! = %.0f %n", i, factorial);
}

1.2.2. Ciclo While

Este tipo de estructura o ciclo while, primero realiza una evaluación antes de
ejecutar el bloque, si la expresión o comparación es igual a verdadero es true, si esto se
cumple el ciclo procese a ejecutar de forma repetida las sentencias o instrucciones
definidas dentro de ella.

Cada vez que termina de ejecutar las instrucciones o sentencias, esta vuelve a
evaluar la expresión. Si la expresión sigue siendo verdadera vuelve a ejecutar el bloque,
de lo contrario, si la expresión sea falsa, entonces se saldrá del bucle y este terminara.

Por lo tanto, es importante que, dentro del bloque de sentencias, exista, alguna
instrucción que modifique la evaluación o el valor de la expresión u variable que se está
usando para las comparaciones, por ejemplo, incrementar o decrementar el valor de
este, de lo contario si no se va modificando este valor, nuestro ciclo podría entrar en un
bucle infinito.

A continuación, veremos la estructura de este ciclo

10

while (expresión) {
bloque_sentencias;
}

1.2.3. Ciclo Do While

En estructura repetitiva do-while, el funcionamiento es muy parecido que el ciclo
de while. Pero la diferencia entre el Do While y el While, es que este ciclo repetitivo,
primero ejecuta una vez el bloque de instrucciones o sentencias definidas y después
evalúa la expresión definida en el while. Por lo tanto, siempre se ejecutará por lo menos
una vez, el bloque de sentencias, se evaluará la condición y según el resultado el
programa evaluara si vuelven a ejecutar las instrucciones o si termina el ciclo.

La estructura de la sentencia do-while es la siguiente:

do{ //inicio del ciclo do while
instrucciones;
} while(condición); //fin del ciclo do while

2. Métodos y procedimientos

En programación es importante tener claro los conceptos de métodos y

procedimientos, para ponerlos en práctica en nuestros programas. A continuación,
veremos la definición de cada uno de estos.

Los métodos son subrutinas o subprogramas que pueden manejar los datos que
han sido definidos dentro de la clase que contiene estos métodos u otras clases externas.

Un método es un bloque de instrucciones, el cual se identifica por un nombre, y

puede o no recibir parámetros o argumentos, cada uno de estos debe realizar solo una
tarea en específico. Estos parámetros se usan para realizar alguna funcionalidad y según
la misma, se pueden devolver un valor, especificando el de tipo de dato de este.
Por medio del nombre se puede llamar el método requerido. Pero en java, en
nuestras clase principal se tiene un método que se llama main(), en el cual este método
11

es creado especialmente para que realice o comience la ejecución del programa.

Además, no use las palabras clave de Java para nombres de métodos.

Un procedimiento es un conjunto de instrucciones al igual que los métodos, solo

que este no retorna ningún valor y puede que no reciba tampoco argumentos.

Estructura de un método

Tipo_de_acceso Valor_que_retorna nombreFuncion (Tipo_parametro

Nombre_parametro)
{
/*
* Bloque de instrucciones
*/
return valor; //Solo aplica cuando se retorna algún valor
}

• Tipo de acceso: Indicamos si es público o privado, entre otros.

• Valor que retornara: Si se va a retornar algún valor, necesitamos indicarle el tipo
de datos que se retornara, por ejemplo, de tipo int, String, Boolean y en el caso
de no devolver ningún valor colocamos void.
• Nombre función: Es el identificador el nombre que se le dará a la función.
• Tipo parámetro y Nombre parámetro: Son los parámetros que necesita la función
para poder realizar los procedimientos que tiene dentro de ella, como por ejemplo
cálculos
• return valor: Indica cual es el valor que retornara o entregara la función.

A continuación, hablaremos de los tipos de métodos/procedimientos:

2.1. Métodos sin retorno y sin parámetros (Funciones vacías)

12

Ejecuta un subprograma sin argumentos ni devolución de valores y también se les

conoce como funciones vacías.

Estructura del método

Tipo_de_acceso void nombreFuncion ()

{
/*
* Bloque de instrucciones
*/
}

2.2. Métodos con parámetros y sin retorno de valor

Ejecuta unas instrucciones con argumentos o parámetros sin devolución de valores, los
parámetros o argumentos se envían desde el algoritmo, clase o método principal, la
función los toma, y se ejecuta el método sin devolver valores al método principal.
Estructura de un método

Tipo_de_acceso void nombreFuncion (Tipo_parametro Nombre_parametro)

{
/*
* Bloque de instrucciones
*/
}
13

2.3. Métodos con parámetros, con retorno de valor

Son métodos o funciones que envían valores desde el algoritmo o método principal al
subproceso, función o submétodo pasando por referencia estos valores para ser
ejecutados y retornar valores al método principal.

Estructura de un método

Tipo_de_acceso Valor_que_retorna nombreFuncion (Tipo_parametro

Nombre_parametro)
{
/*
* Bloque de instrucciones
*/

return valor; //Solo aplica cuando se retorna algún valor

}

Recursos complementarios

EducacionBA. (2017, 27 octubre). Capítulo 11: Estructuras condicionales. YouTube.

https://www.youtube.com/watch?v=nw79fnLLUho&ab_channel=EducacionBA

Eductronica. (2020, 24 noviembre). Estructura ciclicas | for, while. YouTube.

https://www.youtube.com/watch?v=CTPOzi3io70&ab_channel=Eductronica

Cervigón, C. (2013). Interfaces gráficas de usuario. POO Tema, 6.

Programación Dit-UPM (2018). Programación Tema 4: Métodos
https://www.cartagena99.com/recursos/alumnos/apuntes/PROG14-TEMA4.pdf

González, A. H. (2017). Clase 7: Introducción al lenguaje JAVA.

http://sedici.unlp.edu.ar/bitstream/handle/10915/65724/Clase_2017.pdf?sequence=1
14

Referencias
Deitel, P., Deitel, H.(2016). Java cómo programar. Pearson Educación. https:
https://www-ebooks7-24-
com.ucompensar.basesdedatosezproxy.com/stage.aspx?il=4371&pg=&ed=

Sánchez Allende, J. (2005). Programación en Java 2. McGraw-Hill España.

https://elibro-
net.ucompensar.basesdedatosezproxy.com/es/lc/ucompensar/titulos/50290?fs_q=Progr
amaci%C3%B3n&fs_contributors=40539&fs_contributors_lb=S%C3%A1nchez__Allend
e,__Jes%C3%BAs&prev=fs

Ceballos Sierra, F. J. (2015). Java 2: lenguaje y aplicaciones. RA-MA Editorial.

https://elibro-
net.ucompensar.basesdedatosezproxy.com/es/lc/ucompensar/titulos/62458

Zohonero Martínez, I. y Joyanes Aguilar, L. (2008). Estructuras de datos en Java.

McGraw-Hill España. https://elibro-
net.ucompensar.basesdedatosezproxy.com/es/lc/ucompensar/titulos/50117

Loy, M., Eckstein, R., Wood, D., Elliott, J., & Cole, B. (2002). Java swing. " O'Reilly Media,
Inc.".
https://books.google.es/books?hl=es&lr=&id=fU1K9MxaWp0C&oi=fnd&pg=PT4&dq=jav
a+swing+graphical+user+interface&ots=9RhWfdYNmB&sig=ZrBxp3OUXFfdvMYcEffyal
cfGq0#v=onepage&q=java%20swing%20graphical%20user%20interface&f=false
15

Glosario
• Conditional statement: is an instruction or group of instructions that can be
executed or not depending on the value of a condition. The best known types of
conditional sentences are the SI .. THEN (if..then), the SI ..
• Repetitive cycles: also called loops or loops allow you to repeat an operation or
sequence of operations depending on certain conditions. It is a segment of an
algorithm or program whose instructions are repeated a certain number of times
while a certain condition is met.
• Method: it is a subroutine whose code is defined in a class and can belong to both
a class, as is the case with class or static methods, as with an object, as is the
case with instance methods. Similarly to procedures in imperative languages, a
method generally consists of a series of sentences to carry out an action, a set of
input parameters that will regulate that action or, possibly, an output value (or
return value) of some type