UNIVERSIDAD DE COLIMA

FACULTAD DE INGENIERÍA MECÁNICA Y ELÉCTRICA

INGENIERÍA EN COMPUTACIÓN INTELIGENTE
2° SEMESTRE GRUPO B
ALUMNO: OSCAR DALI NATTANIEL ROMERO RAYGOZA
PROFESOR: WALTER MATA
CD. GUZMAN, JALISCO
23/03/2020 – 27/03/2020
índice

1. Modulo 1 Java Basics

a. Introducción………………………………………………………………………………………………4
b. Writing your first program
i. Teoría…………………………………………………………………………………………….4
ii. Códigos…………………………………………………………………………………………..6
iii. Resultados……………………………………………………………………………………..6
iv. Cuestionarios…………………………………………………………………………………7
c. Basic Java Commands
i. Teoría……………………………………………………………………………………………9
ii. Códigos…………………………………………………………………………………………11
iii. Resultados…………………………………………………………………………………….12
iv. Cuestionarios………………………………………………………………………………..13
d. Data Types and Variables
i. Teoría……………………………………………………………………………………………15
ii. Códigos…………………………………………………………………………………………18
iii. Resultados…………………………………………………………………………………….19
iv. Cuestionarios………………………………………………………………………………..20
e. Interactive Programs
i. Teoría…………………………………………………………………………………………...23
ii. Códigos…………………………………………………………………………………………24
iii. Resultados…………………………………………………………………………………….24
iv. Cuestionarios………………………………………………………………………………..24
f. Proyecto: Trip Planner
i. Descripción del problema……………………………………………………………..25
ii. Códigos…………………………………………………………………………………………25
iii. Resultados…………………………………………………………………………………….27
g. Conclusión………………………………………………………………………………………………..27

2. Modulo 2 Control Structures

a. Introducción…………………………………………………………………………………………….28
b. Logic
i. Teoría…………………………………………………………………………………………..28
ii. Códigos………………………………………………………………………………………..30
iii. Resultados……………………………………………………………………………………31
iv. Cuestionarios……………………………………………………………………………….32
c. Loop Basics
i. Teoría………………………………………………………………………………………….35
2
 ii. Códigos………………………………………………………………………………………35
iii. Resultados………………………………………………………………………………….36
iv. Cuestionarios……………………………………………………………………………..36
d. More Loops
i. Teoría…………………………………………………………………………………………37
ii. Códigos………………………………………………………………………………………37
iii. Resultados………………………………………………………………………………….38
iv. Cuestionarios……………………………………………………………………………..39
e. Proyecto: Odds or Evens
i. Descripción del problema…………………………………………………………..40
ii. Códigos……………………………………………………………………………………….41
iii. Resultados…………………………………………………………………………………..43
f. Conclusión………………………………………………………………………………………………43

3
 MODULO 1
JAVA BASICS

1. Introducción
En el primer modulo veremos los conceptos básicos del lenguaje Java. Este se
enfocará en que se familiarice con la sintaxis del lenguaje mientras que se ven las
herramientas que se utilizaran en el resto del curso.
En este módulo se verán:

• Las diferentes partes de un programa.

• Imprimir texto en consola.
• El uso de métodos para organizar el código.
• Como Java guarda y ve los tipos básicos de datos.
• Diferentes maneras de manipulación de datos.
• Como hacer un programa que interactúe con el usuario.

2. Writing your first Java program

i. Teoria
¿Que es Java?
Java es un lenguaje de programación escrito por Sun Microsystems en 1995 y a
permanecido como un lenguaje popular por mas de 20 años. A pesar de ser uno de los
lenguajes mas antiguos Java sigue siendo popular por una variedad de razones:

• Es relativamente fácil de aprender.

• Tiene excelentes funciones para escribir soluciones de software grandes y
complejas.
• Tiene muchas bibliotecas con código listas para usar.
• Hay muchos recursos para desarrolladores como libros y grupos.

4
Partes de un programa en Java
Generalmente hay 3 partes en un programa en Java:

• Class: Es la capa mas externa del programa. Comienza con las palabras “public
class” y luego el nombre del archivo, tiene que ser el nombre del archivo exacto,
incluyendo mayúsculas. La clase esta encerrada entre “{}”. Todo el código que se
ejecutara debe estar en medio de estos.
• Main method: Es la parte que le dice a tu computadora cuales líneas de código se
ejecutaran. En Java esto se hace con una serie de palabras definidas “public static
void main(String[] args) {“, después de la llave abierta es donde va el código que se
quiere ejecutar, no se debe olvidar cerrar la llave. Normalmente se utiliza sangría
para diferenciar la parte del main con la de la clase.
• Statements: Son las líneas de código que la computadora va a ejecutar. Cada línea
es llamada declaración (Statement en inglés) y debe terminar con un punto y coma
“;”. Se pueden escribir tantas líneas como se desee, la computadora las ejecutara
una por una desde el inicio hasta el final.

Comentarios
Son notas que se escriben en el código fuente por el programador, para describir
cierta parte del código. Son ignorados por el compilador por lo que solo se pueden leer
por humanos. Hay dos formas de escribir comentarios:
/*
Comentario multilínea
*/
// Comentario de una sola línea
Es recomendable que añadas comentarios:

• En la parte superior del código para describir su función general.

• En la parte superior de un método para describir su contribución a la
solución general.
• Para explicar partes del código particularmente complicadas.
• Para aislar líneas de código cuando se buscan problemas sin tener que
eliminarlo.

5
 ii. Códigos

Hello World
public class BasicsA {
public static void main(String[] args){
[Link]("Hello World");
}
}

Comments
// Este programa imprime en la pantalla un Hola Mundo
public class BasicsB { //Esta es la clase del archivo
public static void main(String[] args) { //Esta es la declaración del main
//Aquí va el código a ejecutar
[Link]("Hello World"); //Imprimimos el Hola Mundo
} //Cerramos el main
} //Cerramos la clase

iii. Resultados
Hello World

Comments

6
 iv. Cuestionarios
¿Que es Java?

Hello World

7
Partes de un programa en Java

8
Comentarios

3. Basic Java commands

i. Teoria
Strings and Printlns
En Java un String (Cadena) es cualquier secuencia de caracteres. Existen algunos
caracteres que son especiales y que si se usan de manera simple causaran problemas con
prints. Para eso se utilizan las secuencias de escape, estas son maneras para poner esos
caracteres. Cuando Java ve una barra diagonal inversa en una cadena “\”, esto le dice que
omita la función del carácter siguiente y que simplemente la agregue a la cadena. Por
ejemplo:

• “ \” ” Agregara una comilla doble ‘ ” ’.

• “ \\ “ Agregara una barra diagonal inversa “ \ “.
• “ \t “ Agregara el espacio de un tab.
• “ \n “ Agregara una nueva línea.

9
 Las computadoras no serían muy útiles si no pudieran comunicarse con las
personas, una de las maneras más simples en que lo hacen es con un “print out”. Para
tener una salida de cadenas utilizamos la declaración “println” que se escribe de esta
manera: “[Link]();”, lo que queremos que se imprima ira en medio de los
paréntesis y cuando se termine de imprimir brincara una línea. Existe otra forma de
imprimir, se utiliza: “[Link]()” que funciona igual al anterior, pero sin brincar
líneas.

Las computadoras no serían muy útiles si no pudieran comunicarse con las

personas, una de las maneras más simples en que lo hacen es con un “print out”. Para
tener una salida de cadenas utilizamos la declaración “println” que se escribe de esta
manera: “[Link]();”, lo que queremos que se imprima ira en medio de los
paréntesis y cuando se termine de imprimir brincara una línea. Existe otra forma de
imprimir, se utiliza: “[Link]()” que funciona igual al anterior, pero sin brincar
líneas.
Methods
Los programadores no pueden estar enfocados en muchas líneas de código al
mismo tiempo por lo que para programas muy grandes se utilizan los métodos. Así se
pueden enfocar en pequeñas partes del código que son llamadas al programa principal. En
general se pueden usar métodos cuando:

• Se puede dividir una tarea en subtareas poniéndolas en orden para que se

entienda mejor.
• Si se tiene código redundante, es decir si hay código innecesario que aparezca mas
de 1 vez. Se puede eliminar haciéndolo solo una vez y si algo sale mal solo se tiene
que arreglar una vez en lugar de buscarlo en todo el código.
• Si tu método esta siendo mas grande que 20 o 30 líneas.
Se debe examinar que cada método esta haciendo una sola cosa especifica y no
una relación de cosas no relacionadas. Una vez que se haya organizado en métodos, el
main se convertirá en una lista de llamadas a métodos.
Cada método en Java tiene su propio nombre. Existe un nombre que es especial, el
main solo puede ser usado para ejecutar el programa por lo que no se puede utilizar el
mismo nombre en otro método. Como lo que queremos es hacer métodos para hacer
alguna tarea, es buena idea empezar el método con un verbo y seguir con el elemento
para el que servirá el módulo. Un ejemplo: calcularEdad.
La primera línea de cada método se llama “method header” y está escrito de esta
forma específica: “public static void myMethod(){}”. Esto es llamado definir un método,
estos se suelen escribir después del main, aunque no sea necesario. Lo que si es necesario
es que debe estar fuera del main, pero adentro del class.

10
 Solo definir un método no será suficiente para que la computadora lo ejecute. Para
que el código adentro del método se ejecute otro método debe llamarlo o invocarlo por
su nombre. La línea para invocarlo inicia con el nombre del método a ejecutar, seguido
por un par de paréntesis terminando con un punto y coma. Cuando llamas a un método la
computadora brincara al método que ha sido llamado, ejecutara el código y una vez
terminado volverá a la línea en la que se llamó el método.
Control Flow

Existen algunas reglas que las computadoras respetan para ejecutar nuestros
códigos:
1) Lo primero es encontrar el método main, si no tiene main el programa no se
ejecutará.
2) Ejecutar cada orden desde el arriba hasta abajo empezando por la llave abierta.
3) Si la orden es una llamada a un método, brinca a la definición del método y ejecuta
todas las ordenes desde arriba hasta abajo.
4) Cuando termina de ejecutar algún método regresa a donde se llamó el método y
continua con la siguiente línea.
5) Cuando se llega al final del método main, se termina el programa.
Sabiendo esto los programadores pueden saber como manejar el flujo por el que
se mueve el programa, es vital que los programadores lo sepan ya que si no se logra
entender es posible que no puedan trabajar bien.

ii. Códigos
Strings and Printlns
public class CommandsA {
public static void main(String[] args){
[Link](" \" "); //Esto imprimira "
[Link](" \t \\ \n \" "); /* Esto imprimira \
" */
}
}

Methods
public class CommandsB {
public static void main(String[] args){
metodoUno(); //Ejecutara el codigo de metodoUno
metodoDos(); //Ejecutara el codigo de metodoDos
}

public static void metodoUno(){

11
 [Link]("Hola ");
}

public static void metodoDos(){

[Link]("Mundo!");
}
}

Control Flow
public class CommandsC {
public static void main(String[] args){
metodo1(); //llamamos al metodo 1
metodo2(); //llamamos al metodo 2
[Link]("Fin del main");
}

public static void metodo1(){

[Link]("Este es el metodo 1");
}

public static void metodo2(){

[Link]("Este es el metodo 2");
metodo1(); // llamamos al metodo 1
}
}

iii. Resultados
Strings and Printlns

Methods

12
Control Flow

iv. Cuestionarios
Strings and Printlns

13
Methods

Control Flow

14
 4. Data types and variables
i. Teoria
Data Types
Java define algunos tipos de datos primitivos muy simples y eficientes. Existen 8 en
total, pero solo veremos 4 de ellos.

• Integers: Representa números enteros. Java se refiere a ellos como el tipo de datos
int. Como la memoria de las computadoras no es infinita, existe un limite en que
tan grande puede ser un int. El int más grande que Java puede presentar es
2,147,483,647 y el más chico es -2,147,483,648.
• Double: Representan los números reales. Estos pueden llegar a números mucho
mas grandes y mucho mas pequeños, sin embargo, estos son solo aproximaciones
no valores exactos, ya que solo se pueden tener cierta cantidad de decimales.
• Character: Son caracteres simples que pueden ser espacios, letras o símbolos.
Estos se definen como char. Cuando defines un char es necesario encerrarlo en
comillas simples ‘. Los Strings están hechos de chars. Por último, un ‘a’ no es lo
mismo a “a”, el primero es un carácter simple y el segundo es una cadena de un
solo carácter.
• Boolean: Son tipos de datos que pueden tener solo dos valores True
(Verdadero)/False (Falso). Los booleanos son lo básico para las decisiones de
lógica, se puede pensar que estos son datos de Si/No. Estos datos son llamados
boolean por Java.

Variables
Los programas necesitan usar memoria cuyo valor puede cambiar. En Java existe
una manera para contener los datos cuyo valor cambia, se denominan variables.

15
 Antes de que podamos utilizar una variable en Java debemos declararla. Para hacer
esto debemos decirle a Java que tipo de datos queremos guardar en la variable y darle un
nombre, todo adentro del Scope en el que se requiera. Al declarar la variable se crea un
espacio en la memoria para un valor, para almacenar esa variable en el espacio se usa una
declaración de asignación. Esta comienza con el nombre de la variable, luego un signo
igual, luego el valor que queremos asignar y para terminar un punto y coma. Un ejemplo:
String hola = “Hola mundo”.

Una vez hecho lo anterior podemos usar el String en cualquier lugar donde lo
necesitemos. Si cambiamos el valor del String este ahora mostrara el nuevo valor, en lugar
del anterior. Solo se puede declarar una variable una vez, si se intenta otra Java informara
un error, esto también aplica con los nombres, solo se puede usar uno por Scope.
Cualquier variable que se declare entre las llaves de un método se llama “variable
local” porque solo se puede usar dentro del método, si se intenta usar fuera del mismo,
Java informara que no se puede encontrar. En general decimos que el Scope de una
variable son las líneas de código donde puede ser usado.
Además de las variables locales adentro de los métodos podemos declarar
variables que no están dentro de ningún método, si no que su alcance esta en toda la
clase. Normalmente las variables de clase son constantes, lo que significa que no cambia
su valor. Para declarar una de estas necesitas poner los términos “public static final”,
luego el tipo de datos y además necesitamos asignarle el valor al mismo tiempo.
Normalmente se pone después de iniciar la clase. Los nombres que le ponemos a las
variables de clases se deben escribir todos en mayúsculas y se deben de espaciar con
guion bajo “_”.

Mathematical Operations
Se pueden escribir operaciones matemáticas en Java justo como se hacen en
algebra, suma (+), resta (-), multiplicación (*), división (/). Se utilizan las mismas reglas que
en algebra. De izquierda a derecha y respetando las leyes:
1) Paréntesis.
2) Multiplicación y División.
3) Suma y Resta.

En Java no hay un operador para el exponente por lo que no se cuenta en las leyes.
Dividir dos enteros en Java puede ser confuso, por ejemplo 7/2 nos daría un
resultado de 3, en lugar de 3.5. Esto es porque cuando Java divide dos enteros, este trunca
la parte decimal, para hacer al resultado entero también, no lo redondea.

16
 Java tiene otro operador para obtener el residuo de una división, % generalmente
llamado modulo: 3 % 2 == 1 o 11 % 3 == 2.
Java también tiene algunos operadores aritméticos extra para cosas que los
programadores hacen frecuentemente. Estos son más rápidos de escribir y más fácil de
leer. Estos operadores funcionan tanto con ints como con doubles:

Operador Ejemplo Equivalente

++ X ++ X=X+1
-- X -- X=X-1
+= X += Y X=X+Y
-= X -= Y X=X-Y
*= X *= Y X=X*Y
/= X /= Y X=X/Y
%= X %= Y X=X%Y
Cuando Java utiliza un operador con dos int el resultado será int, si se utiliza con
dos double el resultado será un double. Sin embargo, si se utiliza con un int y un double el
resultado siempre será double.

String Concatenation
Uno de los operadores aritméticos puede ser utilizado además con Strings, este es
el símbolo de suma (+). Cuando se usa con dos Strings lo que hace es concatenar o
conectar estas dos para crear un nuevo String. Cuando concatenamos un String (Aunque
este vacío) con otro tipo de datos, Java regresara un String. Se debe notar que, si se
combinan operaciones matemáticas y Strings, Java empezara a evaluar la expresión de
izquierda a derecha, convirtiendo entre tipos mientras sea apropiado. Por ejemplo: 1 + 3 +
“3” + 2 seria igual a “432”. De igual manera Java seguirá el orden de los operadores
matemáticos, por ejemplo: 1 * 2 + “3” + 2 * 5 sería igual a “2310”.

Casting
Como se ha visto se debe de tener cuidado cuando se combinan valores de
diferentes tipos de datos. Java te deja cambiar explícitamente el tipo por otro. Esto se
hace al darle explícitamente el tipo de datos que se quiere después de la operación. “(Tipo
de dato resultante) expresión”, por ejemplo: (int)(4/3.0) daría igual a 1 en lugar de 1.33.
Sin embargo, si se encierra mal daría un diferente resultado. Por ejemplo: (int)4/3.0 daría
igual a 1.33 ya que el cast solo está funcionando en el primer numero que ya es int por lo
que la operación quedaría como 4/3.0.

17
 ii. Códigos
Variables
public class VariablesA {
public static final int ano=2020; //Declaramos una variable global

public static void main(String[] args){

String hi = "Hola mundo"; //Declaramos una variable local
[Link](hi); //Imprimimos la variable local
thisYear(); //Llamamos la funcion thisYear
}

public static void thisYear(){

String hi = "Feliz "; //Declaramos la variable local
[Link](hi + ano); //Imprimimos la variable local y la
variable global
}
}

Mathematical Operations
public class VariablesB {
public static void main(String[] args){
int n1 = 5;
int n2 = 2;
double n3 = 7.0;
double n4 = 2.0;
int resu1 = n1/n2;
double resu2 = n3/n4;
double resu3 = n1/n4;
[Link](n1 + " / " + n2 + " = " + resu1);
[Link](n3 + " / " + n4 + " = " + resu2);
[Link](n1 + " / " + n4 + " = " + resu3);
}
}

String Concatenation
public class VariablesC {
public static void main(String[] args){
String pal1 = "Hola ";
String pal2 = "Mundo";
String pal3 = 2 + 1 + "2" + 2 + 1; //Esto deberia imprimir "3221"
String pal4 = 2 * 3 + "4" + 3 * 3; //Esto deberia imprimir "649"
[Link](pal1 + pal2); //Esto deberia imprimir Hola Mundo"
[Link](pal3);
[Link](pal4);
}
}

18
Casting
public class VariablesD {
public static void main(String[] args){
double n1 = 2.0;
int n2 = 5;
int resu1 = (int)(n2/n1); //Haremos casting a int para ver el resultado
truncado
double resu2 = (int)n2/n1; //Se hace casting solo a n2, para ver el
resultado sin cast
[Link](resu1);
[Link](resu2);
}
}

iii. Resultados
Variables

Mathematical Operations

String Concatenation

19
Casting

iv. Cuestionarios
Data Types

20
Variables

Mathematical Operations

21
String Concatenation

22
Casting

5. Interactive programs
i. Teoria
La mayoría de los programas son usados por personas que no son los programadores que
los hicieron, a esta entrada se le llama el usuario. Un programa interactivo es aquel que
recibe información del usuario, no solo del programador. Existen muchas maneras de
obtener entrada de datos por los usuarios, Java tiene una clase por cada uno de ellos. El
objeto que usaremos para el teclado es Scanner y es usado para tener entrada de texto.
Cada vez que lo queramos usar tendremos que llamarlo, haremos esto con “import
[Link].*;”, es necesario poner esta línea al inicio de nuestro programa.
Después tendremos que crear nuestro propio Scanner con un nombre que
nosotros definamos, y le diremos que lea el texto con “[Link]”, lo que saldría así:
“Scanner input = new Scanner([Link]);”. Finalmente le diremos a nuestro objeto que
tome la siguiente línea en una cadena: “String name = [Link]();”. Cuando Java

23
tiene la línea “[Link]();”, el programa se detiene y espera a que el usuario presione
enter para continuar.
También se pueden ingresar otros tipos de datos además de los Strings haciendo
pequeñas modificaciones, por ejemplo: si queremos un int usaremos “[Link]();”, si
queremos un double entonces seria “[Link]();”. Se tiene que ver que no se
pongan otros tipos de datos mas de los que se piden ya que si esto ocurre Java mandara
un error y terminara el programa.

ii. Códigos
import [Link].*;

public class Scan {

public static void main(String[] args) {
Scanner input = new Scanner([Link]);
[Link]("Dime tu nombre: ");
String name = [Link]();
[Link]("Hola " + name);
}
}

iii. Resultados

iv. Cuestionarios

24
 6. Proyecto: Trip Planner
i. Descripción del problema
En este proyecto escribirás un programa que pregunte al usuario por cierta
información sobre el viaje internacional que harán. El programa deberá tener lo siguiente:
1. Saludos: El programa deberá pedir el nombre del usuario y luego deberá
preguntarle el lugar al que se dirige, una vez hecho esto el programa dirá que es un
buen lugar.
2. Tiempo de viaje y presupuesto: En esta parte deberás preguntar cuanto
presupuesto tiene y cuantos días se quedará, además de preguntar la moneda y el
valor de esta en USD. Con estos datos el programa deberá sacar cuanto tiempo es
en horas y minutos, después sacara el presupuesto en la moneda del lugar al que
viajara y finalmente sacara cuanto dinero se puede gastar cada día en USD y en
moneda del lugar al que ira.
3. Diferencia horaria: El programa preguntara cual es la diferencia de horario entre el
lugar de origen y el destino. Con esta información el programa debe sacar la hora
en el lugar destino cuando en el lugar de origen son las 12 y las 24.
4. Área del país: El programa pedirá que el usuario del tamaño del área en kilómetros
cuadrados y lo convertirá en millas cuadradas.
Nota: Cada una de las partes debe estar en un método diferente.

ii. Códigos
import [Link];

public class TripPlanner {

public static void main(String[] Args){
greetings();
travelTime();
timeDifference();

25
 countryArea();
}

public static void greetings(){

Scanner input = new Scanner([Link]);
[Link]("Bienvenido al organizador de viajes!");
[Link]("Cual es tu nombre? ");
String name = [Link]();
[Link]("Hola " + name + "!, a donde viajas? ");
String destino = [Link]();
[Link]("Excelente, "+ destino + " suena como un buen
lugar.");
}

public static void travelTime(){

Scanner input = new Scanner([Link]);
[Link]("Cuantos dias estaras de viaje? ");
double dias = [Link]();
[Link]("Cual es tu presupuesto en USD? ");
double dinero = [Link]();
[Link]("Cual es el simbolo de la moneda del lugar al que
iras?");
String moneda = [Link]();
[Link]("Cuanto vale el USD en el lugar al que iras? ");
double valor = [Link]();

[Link]("Estaras " + dias + " dias en el lugar que son: " +

(int)dias*24 + " horas y " + (int)dias*24*60 + " minutos");
double cam = dinero/dias*100;
int pres = (int)cam;
[Link]("Tu presupuesto en dolares es "+(int)dinero+ ", cada
dia podras gastar: " +pres/100.0);
[Link]("En " + moneda + " tu presupuesto es "
+(double)(dinero*valor));
cam = (double) (dinero*valor/dias)*100;
int gasto = (int)cam;
[Link](". Cada dia podras gastar " + gasto/100.0);
}

public static void timeDifference(){

Scanner input = new Scanner([Link]);
[Link]("Cual es la diferencia de horario entre tu casa y tu
destino? ");
int dif = [Link]();
[Link]("Cuando sea medianoche en casa en tu destino seran
las " +(24+dif)%24 + " horas.");
[Link]("Cuando sea mediodia en casa en tu destino seran las
" + (12+dif)%24 + " horas.");
}

public static void countryArea(){

Scanner input = new Scanner([Link]);
[Link]("Cuanto mide el lugar al que iras en KM2? ");
double km = [Link]();
double millas = km * .62137 *100;

26
 int mil = (int)millas;
[Link]("En milles2 son: " + mil/100.0);
}

iii. Resultados

7. Conclusion
A pesar del tiempo Java sigue siendo uno de los lenguajes de programación mas
utilizados por los programadores, me parece muy importante conocer este lenguaje ya
que lo necesitaremos como futuros programadores que queremos ser.
En este modulo solo vimos lo más básico del lenguaje, sin embargo, mientras más
avancemos veremos más cosas hasta convertirnos en muy buenos programadores. Es muy
importante practicar también ya que si no lo hacemos no podemos llegar a ser muy
buenos, tanto en el lenguaje como en otras cosas.

27
 MODULO 2
CONTROL STRUCTURES

1. Introducción
En este segundo módulo veremos cómo resolver problemas usando lógica
computacional. Las computadoras tienen como base un mecanismo verdadero/falso,
comprender esto ayudara a traducir los problemas humanos en soluciones informáticas.
En este módulo se verán:

• La unidad básica de lógica: El booleano.

• Programación condicional con sentencias if/else.
• Uso de bucles para ahorrar código repetitivo y aprovechar patrones:
o Bucle For.
o Bucle While.
o Bucles anidados.

2. Logic
i. Teoria
Booleans
Como hemos mencionado antes existe un tipo de datos llamado Booleano el cual
solo puede tener 2 valores Verdadero/Falso. Con este tipo de dato es como evaluamos
una decisión. Este tipo de condiciones expresan una relación entre dos valores usando un
operador relacional. Estos son los que existen en Java:

Operador Significa Ejemplo Resultado

Relacional
== Igual a 3 + 4 == 7 true
!= Diferente de 3 + 4 != 7 false
< Menor que 3<4 true
> Mayor que 10 > 10 false
<= Menor o igual que 3.7 <= 3.5 false
>= Mayor o igual que 4 >= 4 true

28
Se debe notar que el simbolo de igual a son dos símbolos igual igual, esto es para
diferenciarse del igual simple que sirve para asignación.
Estos operadores se pueden usar en cualquier tipo de dato, menos Strings. String
tiene diferentes operadores que son los siguientes:

Método Descripción Ejemplo

equals Ve si las cadenas son iguales. [Link](“Hola”);
equalsIgnoreCase Ve si las cadenas son iguales, [Link]
ignora mayúsculas o IgnoreCase(“hola”);
minúsculas.
startsWith Ve si las cadenas empiezan [Link](“H”);
por los mismos caracteres.
endsWith Ve si las cadenas terminan [Link](“a”);
con los mismos caracteres.
contains Ve si la cadena contiene los [Link](“ol”);
caracteres.

If/else Statement
Usualmente queremos que los programas hagan ciertas acciones dependiendo de
lo que el usuario proporcione. Java le permite ejecutar solo partes de su código si algo es
verdadero. A esto se le llama una declaración if, y se escribe de esta forma:
If(condición){
Código;
}
Si la expresión booleana entre paréntesis es verdadera, Java hace todas las
declaraciones. De lo contrario los omite y pasa a la siguiente declaración. La decisión
booleana puede ser lo que quiera siempre y cuando de como resultado Verdadero o Falso.
Cuando se utiliza una declaración if, esta limitado a una sola respuesta, ya sea que
el código se ejecute o no. Cuando necesite hacer dos cosas diferentes dependiendo de si
la condición es verdadera o no, se puede agregar una instrucción else, de esta manera:
If(condición){
Código;
}
else{
Código;
}
En otras ocasiones se puede querer comprobar varias condiciones diferentes. Para
esto puede combinar el else con otro if para cada condición separada:

29
If(condición){
Código;
}
else if(2da condición){
Código;
}
else{
Código;
}
En estos casos Java empezara a revisar desde arriba hasta abajo para encontrar la
condición que sea verdadera, si ninguna es correcta pasara a el código de else. Se debe de
tomar en cuenta que solo uno de los bloques se ejecutara y que cuando esto pase el
código brincara a cuando se termine el segmento if/else.
Combining Logic
A veces es necesario que se combinen condiciones en diferentes maneras. Se
pueden utilizar expresiones booleanas para codificar así. Java nos da 3 operadores lógicos
para combinar expresiones booleanas:

Operador Nombre Ejemplo Sera verdadero si y

solo si…
&& And A && B A y B son
verdaderos.
|| Or A || B A o B son
verdaderos (o
ambos).
! Not !A A no es verdadero.

ii. Códigos
If/else Statement
public class LogicA {
public static void main(String[] args){
si(3);
ifelse(8);
sino(17);
}

public static void si(int x){

if(x<10){
[Link]("X1 es menor que 10");
}
}

public static void ifelse(int x){

30
 if(x<5){
[Link]("X2 es menor que 5");
}
else if(x<15){
[Link]("X2 es menor que 15 y mayor que 5");
}
}

public static void sino(int x){

if(x<5){
[Link]("X3 es menor que 5");
}
else if(x<15){
[Link]("X3 es menor que 15 y mayor que 5");
}
else{
[Link]("X3 es mayor que 15");
}
}
}

Combining Logic
public class LogicB {
public static void main(String[] args){
int x = 8;
if (x<10 && x>5){
[Link](x + " es menor a 10 y mayor a 5.");
}
int y = 3;
if (y>10 || y<5){
[Link](y + " es mayor a 10 o menor a 5.");
}
}
}

iii. Resultados
If/else Statement

31
Combining Logic

iv. Cuestionarios
Booleans

32
If/else Statement

33
Combining Logic

34
 3. Loop basics
i. Teoria
Meet Loops
En los programas existe algo llamado Loop, esto se refiere a cuando se termina el
código y vuelve a empezar para así durar mas sin tener tanto código. Cada loop debe
terminar en algún momento y esa es la parte complicada de los loops en programación,
Java tiene muchas maneras de hacer esto, por ahora veremos el For.

For Loops
Uno de los loops mas comunes es cuando solo quieres repetir ciertos códigos un
numero especifico de veces. Entonces siendo repetir líneas una mala practica se puede
utilizar un for loop para repetir las líneas el numero de veces que las necesitemos. La
sintaxis es así:
for(Inicialización; Condición; Actualización){
Código;
}
Teniendo 4 partes:

• Inicialización: Es la variable que se va a revisar en el loop, dependiendo de lo que

necesitemos podemos empezar desde 0 o desde n.
• Condición: Es la parte que se va a revisar, se pone una operación que retorne un
valor booleano, esto dirá cuando terminara el loop.
• Actualización: Es como la variable inicial va a ir cambiando, puede ir aumentando o
disminuyendo, dependiendo de lo que se necesite.
• Código: Son las líneas que se ejecutaran cuando la condición será correcta.

ii. Códigos
For Loops
public class BaLoopsA {
public static void main(String[] args){
[Link]("Tabla de multiplicar del 7.");
for(int i=1; i<=10; i++){
[Link]("7 x " + i + " = " + i*7);
}
[Link]("Fin.");
}
}

35
 iii. Resultados
For Loops

iv. Cuestionarios
For Loops

36
 4. More loops
i. Teoria
Nested Loops
Como se puede poner ifs adentro de ifs. También se pueden poner fors adentro de
fors. Este tipo de loops anidados se suelen utilizar con talas bidimensionales o con
matrices, con el loop externo manejando las filas y el interno las columnas. Para que
funcione debe de tener una inicialización diferente de la primera.
While Loops
Los for loops son a veces llamados loops definidos, ya que nosotros conocemos
aun antes de empezar exactamente cuantas veces se van a repetir. En otras ocasiones
tendremos que esperar hasta que algo suceda, mientras que seguimos repitiendo el loop.
Para estas situaciones Java tiene un While Loop, la estructura del While solo contiene la
condición, por lo que tienes que poner la inicialización antes del While y además poner la
actualización adentro del código del While.

ii. Códigos
Nested Loops
public class MoLoopsA {
public static void main(String[] args){
for(int i=1; i<=5; i++){
for(int j=1; j<=5; j++){
if(j==i || j+i==6){
[Link]("1");
}
else{
[Link]("0");
}
}
[Link]();
}
}
}

37
While Loops
import [Link];
public class MoLoopsB {
public static void main(String[] args){
Scanner input = new Scanner([Link]);
String dec = "";
while(![Link]("si")){
[Link]("Terminar el programa? ");
dec = [Link]();
}
[Link]("Terminado.");
}
}

iii. Resultados
Nested Loops

While Loops

38
 iv. Cuestionarios
Nested Loops

39
While Loops

5. Proyecto: Odds or Evens

i. Descripción del problema
En este Segundo Proyecto haremos un programa que se llamara OddsAndEvens. Que
es un juego parecido a piedra, papel o tijeras. El juego trata de que se eligen pares o
impares y se sacan los dedos de una mano, se cuenta la suma de los dedos y se ve si es par
o impar. En este caso el programa jugara contra el usuario. Al igual que el anterior estará
dividido en partes:

40
 1. Elegir Pares o Impares: El programa pedirá un nombre. Después saludara y
preguntara si se quiere jugar con par o impar. La computadora elegirá el otro.
2. Jugar el juego: El programa debe preguntarle al usuario cuantos dedos quiere
sacar. Entonces la computadora mediante el objeto Random elegirá un numero
entre el 0 y el 5. El programa deberá imprimir cuantos dedos eligió la
computadora. Una vez hecho esto se sumarán ambos dedos y se decidirá si la
suma es par o impar.
3. ¿Quién gana?: El programa deberá ver con el resultado anterior, quien de los dos
gano, una vez hecho esto deberá imprimirlo en la pantalla.

ii. Códigos
import [Link].*;
public class OddsAndEvens {
public static void main(String[] Args){
Scanner input = new Scanner([Link]);
[Link]("Juguemos Pares o Impares.");
[Link]("Cual es tu nombre? ");
String name = [Link]();
boolean endGame = true;
String playerOption, result;
int playerFingers, computerFingers;
while(endGame) {
playerOption = intro(name);
playerFingers = fingers();
computerFingers = computerfingers();
result = evenOrOdd(playerFingers, computerFingers);
winner(name, playerOption, result);
endGame = playAgain();
}
}
public static String intro(String name){
Scanner input = new Scanner([Link]);
[Link]("Hola " + name + "! Que eliges? (O)dds o (E)vens: ");
String playerOption = [Link]();
if ([Link]("O")){
[Link](name+" eligio Odds la computadora sera Evens.");
}
else if([Link]("E")){
[Link](name+" eligio Evens la computadora sera Odds.");
}
else{
[Link]("No se a elegido una opcion valida.");
}
[Link]("--------------------------------------------------
");
return playerOption;
}
public static int fingers(){
Scanner input = new Scanner([Link]);

41
 [Link]("Cuantos dedos sacaras? ");
int numberFingers = [Link]();
return numberFingers;
}

public static int computerfingers(){

Random rand = new Random();
int computer = [Link](6);
[Link]("La computadora eligio " + computer + " fingers.");
[Link]("-------------------------------------------------");
return computer;
}

public static String evenOrOdd(int player, int computer){

int suma = player + computer;
[Link](player + " + " + computer + " = " + suma);
String result;
if (suma%2==0){
result = "Even";
}
else{
result = "Odd";
}
[Link](suma + " is... " + result);
[Link]("------------------------------------------------");
return result;
}

public static void winner(String name, String playerOption, String result ){

if([Link]("O") && [Link]("O")){
[Link](name+" Wins.");
}
else if([Link]("E") && [Link]("E")){
[Link](name+" Wins.");
}
else{
[Link]("Computer Wins.");
}
}
public static boolean playAgain(){
Scanner input = new Scanner([Link]);
[Link]("Play Again? (Y)es or (N)ot: ");
String desicion = [Link]();
boolean endGame;
if([Link]("Y")){
endGame = true;
}
else{
endGame = false;
}
[Link]("-----------------------------------------------");
return endGame;
}
}

42
 iii. Resultados

4. Conclusión
En este módulo vimos las decisiones, además de las estructuras de control y los
loops. Es muy importante y necesario conocer estos temas ya que, como se ha expresado
a lo largo del modulo son cosas que los programadores siempre suelen utilizar, ya sea para
ahorrar código o para que el programa sea interactivo con el usuario.
Es muy bueno conocer y practicar con estas cosas, ya que son herramientas básicas
para programadores y nos ayudaran a tener un mejor código y a que nuestros programas
sean mucho mejores.

43