Realizado por Ramón Alarcón Sánchez

ICA0 M03-UF1: Programación estructurada

ICA0003-S01-C01-V01 Variables y tipos de datos

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100836)

Java es un lenguaje de programación que permite crear aplicaciones para múltiples sistemas
operativos, como Linux, macOS y Windows.

Java usa palabras en inglés de una forma especial, que los ordenadores entienden. Dispone de
una amplia librería de instrucciones y comandos que podemos usar en nuestras aplicaciones.
Ejemplo, System.out.println() indica al ordenador que tiene que mostrar algo en
pantalla. Ese algo puede ser un mensaje de texto, un número…

Significado del comando:

System.out.printl() se puede dividir en dos partes:

System.out.println()

La primera parte, System.out., indica al ordenador que se va a presentar algo en pantalla.

La segunda parte, println(), indica al ordenador que ese algo, entre paréntesis, lo tiene que
mostrar en una nueva línea.

System.out.println(“Hello World”); → “Hello World” es el mensaje que se va a

printar. Nótese que las comillas son necesarias: indican al ordenador que es texto lo que tiene
que mostrar.

A tener en cuenta:

• Java es case sensitive (distingue entre mayúsculas y minúsculas)

Por tanto, si la instrucción System.out.println(“Hello World”); se escribe

como system.out.println(“Hello World”); la aplicación no se ejecutará,
puesto que Java no entenderá lo que quiere decir.

• Todas las instrucciones terminan con ; Todo lo que escriba tras el ; será una nueva
instrucción

Java Main Method

En cualquier aplicación Java debe existir una clase, por ejemplo, class Main, que tenga el
método public static void main. Cuando se ejecute la aplicación, se ejecutarán las
instrucciones contenidas en este método, que irán entre llaves { }.

Variables

Los ordenadores usan «cajas temporales» donde guardan información, a las que denominamos
variables. En Java, cada variable tiene un nombre y un valor. A lo largo de una aplicación, el
nombre de una variable no cambia, pero sí que puede cambiar su valor.

Página 1 de 65
 Ejemplo de una variable: el nombre de la misma es passengers, y el valor 10.

Los valores de las variables no tienen por qué ser números enteros: también pueden ser
números decimales, letras, texto, valores booleanos…

Eso sí, si creamos una variable para que almacene un determinado tipo de dato, al cambiar su
valor tendrá que ser el mismo tipo de dato.

Página 2 de 65
Habitualmente, en las aplicaciones de Java se trabajan con distintos tipos de datos. Java
dispone de una serie de tipos de datos simples numéricos, que se muestran en las tablas:

Estos tipos de datos permiten representar valores enteros y valores decimales. Cada uno de ellos
tiene una precisión para ajustarse al rango de valores a cubrir, dependiendo de las necesidades.
La regla es usar el tipo de dato que mejor se ajuste al rango de valores, evitando así consumir
memoria innecesariamente, consiguiendo que nuestros programas vayan más rápido.

Página 3 de 65
 • int. Se utiliza, como norma general, para números enteros.
• long. Para casos en los que el entero pueda ser muy grande.
• byte y short. Se usarán cuando se tenga un mayor dominio del lenguaje.
• float. Para números decimales con pocas cifras significativas —un máximo de 6—.
• double. Para números decimales que necesiten más precisión.

• boolean. Tienen dos posibles valores: true o false.

• char y String. Se utilizan para representar texto. Diferencia:

char se usa para tipos de datos primitivos que van entre comillas simples, como
‘B’. Así, char es un espacio en memoria para un carácter, numero, símbolo, espacio
o letra que va entre comilla simple.

String se usa para cadenas de caracteres que van entre comillas dobles, como
“Buenos días”.

A continuación, vamos a explorar estos tipos de datos:

Supongamos una aplicación que lleva el número de pasajeros de un metro a lo largo de su

recorrido. Hace falta una variable que almacene el número de pasajeros. Esta variable será de
tipo entero porque no podemos tener fracciones de personas.

Para declarar una variable de tipo entero en Java escribimos int nombreDeLaVariable;,
como int passengers;. Esta sentencia indica al ordenador que tiene que crear una caja
vacía que podrá almacenar valores enteros y que su nombre será passengers. Por tanto,
int passengers; sirve para declarar la variable passengers.

Página 4 de 65
Seguidamente, hay que asignarle un valor. Antes de que el metro llegue a la primera parada
transportará 0 pasajeros. Por tanto, asignamos a la variable passengers el valor 0.

int passengers;
passengers=0;
También es posible declarar e inicializar —asignar un valor— a una variable en una misma
sentencia:

int passengers=0; → se declara la variable passengers de tipo int y se le asigna el

valor 0.

A medida que le metro realice paradas, el número de pasajeros cambiará. Por tanto, habrá que
actualizar el valor de la variable passengers.

Para actualizar el valor de una variable, escribimos su nombre seguido de = y el nuevo valor que
le queramos asignar. En este caso, es como si se quitara de la caja de la variable el valor 0 y se
insertara el valor 25:

Múltiples variables con diferentes tipos de datos

En el siguiente ejemplo se declaran e inicializan una variable isLogin de tipo boolean (valor
lógico true, false), una variable ratio de tipo float (para números decimales con pocas
cifras significativas —un máximo de 6—), una variable budget de tipo double (para números
decimales que necesiten más precisión), una variable letter de tipo char (espacio en
memoria para un carácter, numero, símbolo, espacio o letra que va entre comilla simple ‘ ’) y

Página 5 de 65
una variable greeting de tipo String (cadena de caracteres va entre comillas dobles, como
“Buenos días”).

• La inicialización de una variable de tipo float requiere que se escriba f al final del
número para diferenciarlo con respecto al tipo double.
• La inicialización de una variable de tipo char requiere que insertemos el valor entre
comillas simples ‘ ’.
• La inicialización de una variable de tipo String requiere que insertemos el valor entre
comillas dobles “ ”.

public class Main{

public static void main(String[] args) {
boolean isLogin=true;
float ratio=37.5f;
double budget=13450.99;
char letter='a';
String greeting="Hello World";
}
}

¿Cuáles de las siguientes sentencias son incorrectas?

a. char me=‘I’; Variable tipo char con el valor entre comillas simples.

b. boolean number=17; ❌ boolean solo admite true o false.

c. double price=23.5; Variable double con un número decimal.

d. long total=100.1; ❌ long admite valores enteros, no decimales.

e. fact=true; ❌ No se declara el tipo de variable.

Printar una variable

Para printar (mostrar) una variable se usa la instrucción

System.out.println(nombreVariable);, como en este ejemplo:

int passengers=0;
System.out.println(passengers);

Nótese que passengers no se pone entre comillas “ ”, puesto que no se quiere printar el
texto passengers, sino el valor de la variable passengers.

Página 6 de 65
A continuación, se declaran e inicializan una serie de variables y se printan sus valores:

public class Main{

public static void main(String[] args) {
int counter=-10;
boolean isLogin=true;
double ratio=37.5;
char letter='a';
String greeting="Hello World";
System.out.println(counter);
System.out.println(isLogin);
System.out.println(ratio);
System.out.println(letter);
System.out.println(greeting);
}
}
Print output

Normas para los nombres de las variables en Java

• Deben ser lo más autodescriptivos posibles del valor que almacenan.

• Deben comenzar con una letra minúscula o _ seguido de letras y dígitos sin longitud
máxima.

int passengers=10; → Si necesitamos una variable para registrar el valor de pasajeros

en un metro, la llamaremos passengers o pasajeros.

float width=25.5f; → Si necesitamos registrar el valor del ancho de un objeto,

llamaremos a la variable width o ancho.
double_temperature=37.2;

int i=0; → Para variables temporales son valores válidos i, j, k.

int 1passengers=10; → ❌ No se cumple la norma de que el nombre de la variable ha de

comenzar con una letra minúscula o _.

Página 7 de 65
 • No pueden coincidir con aquellas palabras reservadas en Java, que son las siguientes:

• lowerCamelCase: Si para identificar correctamente una variable se han de usar palabras

compuestas, como por ejemplo isLogin, se usa la regla lowerCamelCase: la primera
letra de la primera palabra en minúscula, y las primeras letras de las siguientes palabras
en mayúscula.
boolean isLogin=true;
char stopIdentification=’A’;

• No pueden tener espacios en blanco.

boolean isLogin=true;

char stop Identification=’A’; ❌

• Son case sensitive. Por tanto, si se declara la variable productPrice de tipo double
—double productPrice=20.5;— y luego se hace referencia a
productprice, Java dirá que no se encuentra dicha variable.

¿Cuáles de los siguientes nombres de variables son legales?

a. 2ndtName ❌ Comienza con un número.

b. _temperature Comienza con _.

c. new ❌ Palabra reservada por el lenguaje.

d. shop

e. break ❌ Palabra reservada por el lenguaje.

Constantes (variables cuyo valor no va a cambiar)

Para diferenciar entre una variable y una constante se usa el modificador final delante de la
declaración de la variable.

double TAX=0.21; → En este caso, a la variable TAX, de tipo double, se le asigna el valor
0.21. Pero, como NO es una constante, TAX podría tener otro valor posteriormente (aunque,
por regla general, el nombre de las constantes se escribe EN MAYÚSCULA).

Página 8 de 65
final double TAX=0.21; → En este caso, TAX es una CONSTANTE de tipo double, lo
que quiere decir que no se le puede asignar otro valor posteriormente, como TAX=0.25;.

Por regla general, el nombre de las constantes se escribe EN MAYÚSCULA. Cuando sea
necesario concatenar palabras se usa el _ (al no poderse aplicar la regla del lowerCamelCase):

final double TAX=0.21;

final int TOTAL_STOPS=10;

ICA0003-S01-C01-V02 - Java: Operadores aritméticos y comentarios

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100837)

Operaciones aritméticas

Una vez que se sabe declarar e inicializar, es hora de ver cómo realizar operaciones aritméticas
con las variables de tipo numérico (int, long, double).

Ejemplo: aplicación de operadores aritméticos para hacer el seguimiento del número de

pasajeros del metro a lo largo de su recorrido.

Página 9 de 65
 • Primera parada: suben 10 pasajeros y bajan 0.

Para resolverlo, hay que actualizar el valor de la variable passengers. Se hace escribiendo
nombreDeLaVariable=nombreDeLaVariable+incremento;

¿Qué pasa si tras el = no se pone el nombreDeLaVariable? Que se actualizaría su valor

sin tener en cuenta el número de pasajeros previo.

int passengers=0; → Se declara la variable passengers, de tipo int, con valor 0.

passengers=passengers+10; → Con ello, la variable passengers tendrá su valor

antiguo, en este caso 0, + 10. Así, tendrá el valor 10.

• Segunda parada: suben 15 pasajeros y bajan 3.

Hay que actualizar el valor de la variable passengers:

passengers=passengers+15-3; // second stop

• Tercera parada: suben 5 pasajeros y bajan 10.

passengers=passengers+5-10;

A continuación, las siguientes instrucciones serían incorrectas porque actualizarían el valor

de la variable passengers sin tener en cuenta el número de pasajeros previo:

passengers=5-10; ❌

passengers=10; ❌

Operaciones aritméticas básicas

Suma

int add=1+2; //=3

Para realizar operaciones de suma también disponemos del operador ++, que incrementa en 1
unidad el valor de la variable. Java permite dos posibles notaciones (ojo, no son sinónimos, dan
resultados distintos).

• Postfix: consiste en añadir ++ después del nombre de la variable.

int value=2;
value++; //=3

• Prefix: consiste en añadir ++ antes del nombre de la variable.

int value=2;
++value; //=3

Página 10 de 65
Diferencia entre la notación postfix y la notación prefix

Para ejemplificarlo, se declara la variable a, de tipo int, con el valor 10, y se printa:

int a=10;
System.out.println(a);
Print output:

10

• Notación postfix:

int a=10;
System.out.println(a);
System.out.println(a++);
System.out.println(a);

System.out.println(a++); → Usando el operador ++ con notación postfix, el valor de

la variable se incrementará en 1 después de usarse en la instrucción System.out.println.

Print output:
10
10
11

• Notación prefix:

int a=10;
System.out.println(a);
System.out.println(++a);
System.out.println(a);

System.out.println(++a); → Usando el operador ++ con notación prefix, el valor de

la variable se incrementa en 1 antes de usarse en la instrucción System.out.println. Por
esto, el valor que se muestra por pantalla es 11, que coincide con el valor de la variable a al
terminar la instrucción.

Print output:
10
11
11

De igual forma, el operador -- permite decrementar en 1 unidad el valor de la variable.

Página 11 de 65
 • Notación postfix:

int decrecimiento=2;
System.out.println(decrecimiento--);
System.out.println(decrecimiento);
Print output:

2
1

• Notación prefix:

int decrecimiento=2;
System.out.println(--decrecimiento);
System.out.println(decrecimiento);
Print output:

1
1

Multiplicación:

Para la multiplicación se usa el símbolo *

3*4; //=12

División:

Para la división se usa el símbolo /

5/2; //=2

Dividir 5 entre 2 es 2.5, pero Java entiende que dividir un entero entre otro entero es un
entero: por este motivo, del resultado 2.5 se queda con la parte entera, que es 2.

public class Main {

public static void main(String args[]) {
int div=5/2;
System.out.println(div);
}
}
Print output:

Página 12 de 65
 Si se usa una variable de tipo double el resultado se registra con decimales, pero no como
2.5, sino como 2.0 ¿Por qué? Porque Java entiende que el resultado de dividir dos tipos de datos
enteros es un entero. A esto se le conoce como TRUNCAMIENTO, que consiste en eliminar los
dígitos situados a la derecha del punto decimal.

public class Main {

public static void main(String args[]) {
double div=5/2;
System.out.println(div);
}
}
Print output:
2.0

Ahora bien, si escribimos alguno de los miembros de la división como un número decimal,
el resultado cambia. En el siguiente ejemplo, se ha sustituido el divisor entero 2 por el decimal
2.0 y Java, automáticamente, devuelve un tipo decimal con el resultado de la división. En este
caso, 2.5 ¿Por qué? Porque entiende que el resultado de hacer una división con al menos uno
de los operadores decimal da como resultado un valor decimal.

public class Main {

public static void main(String args[]) {
double div=5/2.0;
System.out.println(div);
}
}
Print output:

2.5

Resto:

El operador % se usa para calcular el resto de la división entre dos números.

int resto=5%2; //=1

Todas estas operaciones las podemos aplicar a variables. Por ejemplo:

Tenemos una variable x que almacena el resultado de una suma.

Tenemos una variable y que almacena el resultado de una resta.

Tenemos una variable z que almacena el resultado de multiplicar el valor de x e y.

int x=1+2; //=3

int y=4-5; //=-1
int z=x*y; //=-3

Podemos combinar las operaciones aritméticas según sea necesario. Por ejemplo, para calcular
la propina del camarero. Establecemos que será el 10 % del cambio. Se usará el paréntesis ( )
para indicar el orden en el que han de realizar las operaciones:

Primeramente, se hace la resta de las variables pagado y precioMenu, y su resultado —6.5—

se multiplica por 0.10, dando un valor de propina de 0.65 euros.

Página 13 de 65
public class Main {
public static void main(String[] args){
double precioMenu=23.5;
double pagado=30;
double propina=(pagado-precioMenu)*0.10;
System.out.println(propina);
}
}
Print output:

0.65

Orden de las operaciones en Java

1º: Paréntesis.

2º: Multiplicaciones y divisiones (de izquierda a derecha).

3º: Sumas y restas (de izquierda a derecha).

Ejemplos:

int value1=(4+6)*7; //70

Primero se ejecuta la suma entre paréntesis, dando como resultado 10, que seguidamente se
multiplica por 7.

int value2=16-3*4; //4

En este caso se ejecuta primero la multiplicación —3*4—, que da como resultado 12.
Seguidamente, se lleva a cabo la resta 16-12, que da como resultado 4.

❌ Si en el ejemplo de la propia se olvidan los paréntesis en (pagado-precioMenu), el

resultado sería incorrecto, porque primero se ejecutaría la multiplicación y luego la resta, lo que
haría que la variable propina tuviera el valor 27.65

public class Main {

public static void main(String[] args) {
double precioMenu=23.5;
double pagado=30;
double propina=pagado-precioMenu*0.10;
System.out.println(propina);
}
}
Print output:
27.65

String concatenation

El operador + también se usa con strings (secuencias de caracteres), indicando concatenación.

Cuando se realiza la operación String+String, lo que se hace es juntar ambas. En este ejemplo,
tenemos dos variables de tipo String que almacenan el nombre, studentFirstName, y
primer apellido, studentLastName. En una nueva variable de tipo String,
studentFullName, concatenamos el valor de ambas.

Página 14 de 65
public class Main {
public static void main(String args[]) {
String studentFirstName="John";
String studentLastName="Kennedy";
String studentFullName=studentFirstName+studentLastName;
System.out.println(studentFullName);
}
}

Print output:

JohnKennedy → Se han concatenado las variables, pero no existe espacio entre ellas, debido
a que no se ha añadido un espacio en blanco. Concatenar es esto: juntar el valor de una String
con otra String.

Para que haya espacio entre el nombre y el apellido, la variable studentFullName debe
verse así:

public class Main {

public static void main(String args[]) {
String studentFirstName="John";
String studentLastName="Kennedy";
String studentFullName=studentFirstName+" "+studentLastName;
System.out.println(studentFullName);
}
}
Print output:

John Kennedy → Hay un espacio entre el nombre y el apellido porque así se ha determinado
en la concatenación; en la variable String studentFullName.

Concatenar strings con variables

También se pueden concatenar strings con variables, como en el siguiente ejemplo:

public class Main {

public static void main(String args[]) {
int stops=0;
int passengers=0;
stops++;
passengers=passengers+10;
System.out.println("The subway has "+passengers+" passengers
after "+stops+" stop");
}
}
Print output:

The subway has 10 passengers after 1 stop.

Comentarios

El código de Java ha de tener sentido para otros programadores, porque lo más seguro es que,
cuando uno programa, forme parte de un equipo de desarrolladores. Por esto, hay que
estructurar el código ordenadamente y el nombre de las variables debe ser significativo. Como
ayuda para que el código se entienda mejor, Java permite introducir comentarios entre las
instrucciones. Estos comentarios son ignorados por la máquina que ejecuta el programa.

Hay dos formas de añadir comentarios al código:

Página 15 de 65
 • Comentario de línea: con dos slashes //

public class Main {

public static void main(String args[]) {
//Main code
System.out.println("Hello World"); //Printa el string
}
}

• Comentario de múltiples líneas:

/*
COMENTARIO DE
MÚLTIPLES
LÍNEAS
*/

/* Aplicación Hello World,

que muestra en pantalla
el mensaje Hello World
*/
public class Main {
public static void main(String args[]) {
//Main code
System.out.println("Hello World"); //Printa el string
}
}

ICA0003-S01-C01-V03 - OPERADORES DE ASIGNACIÓN Y CONVERSIÓN DE TIPOS

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100838)

Operadores de asignación

Los operadores de asignación permiten asignar un valor a una variable. El operador de

asignación = asigna el valor que tiene a su derecha a la variable que está a su izquierda.

int a=10; → El = actúa como operador de asignación.

Para que la asignación se produzca, el valor tiene que ser adecuado al tipo de variable:

char letter=‘a’;

boolean access=true;

double area=400.5;

❌ Si el valor no coincide con el tipo de variable el programa no compilará y no podrá ejecutarse.

Es lo que ocurre en este caso:

boolean isLogin=4; ❌ → A una variable boolean, que admite solo dos posibles valores, true
o false, se le intenta asignar un número. Esto es incorrecto.

int b=400.5; ❌ →A una variable int se le intenta asignar un número decimal. Esto es
incorrecto.

Página 16 de 65
Java dispone de otros tipos de operadores de asignación, además del símbolo =

• El operador += asigna el valor a la variable sumando a su valor anterior la cantidad que

viene a la derecha del operador.

En el siguiente ejemplo, a la variable a se le asigna la suma de su valor anterior (10) con

20. Es decir, se le asigna 30.

public class Main {

public static void main(String args[]) {
int a=10;
a+=20; //a=30
System.out.println(a);
}
}
Print output:

30

• El operador -= asigna el valor a la variable restando a su valor anterior la cantidad que

viene la derecha del operador.

En el siguiente ejemplo, a la variable a se le asigna la resta de su valor anterior (10) con

20. Es decir, se le asigna -10.

public class Main {

public static void main(String args[]) {
int a=10;
a-=20; //a=-10
System.out.println(a);
}
}
Print output:

-10

• El operador *= asigna el valor a la variable multiplicando su valor anterior por la

cantidad que viene a la derecha del operador.

En el siguiente ejemplo, a la variable a se le asigna la multiplicación de su valor anterior

(10) por 20. Es decir, se le asigna 200.

public class Main {

public static void main(String args[]) {
int a=10;
a*=20; //a=200
System.out.println(a);
}
}
Print output:

200

Página 17 de 65
 • El operador /= asigna el valor a la variable dividiendo su valor anterior entre la cantidad
que viene a la derecha del operador.

En el siguiente ejemplo, a la variable a se le asigna la división de su valor anterior (10)

entre 20. Es decir, se le asigna 0

¿Y por qué no 0.5? Porque la división entre dos números enteros es un número
entero, resultado de TRUNCAR la parte decimal.

public class Main {

public static void main(String args[]) {
int a=10;
a/=20; //a=0
System.out.println(a);
}
}
Print output:

Casting (conversión) entre tipos de datos

La conversión entre tipos de datos es un concepto clave en programación. Es importante saber

qué tipos de datos se pueden convertir a otros. Hasta ahora se han visto los tipos de datos
primitivos: vamos a ver las conversiones entre ellos.

Conversiones entre los tipos de datos numéricos enteros y decimales

Hay dos tipos de conversiones: la conversión por ampliación y la conversión por reducción.

Conversión por ampliación

Ocurre cuando un valor de un tipo se convierte en un tipo más amplio, uno que se representa
con más bits y, por lo tanto, tiene un rango más amplio de valores.

int a=10;
long b=a;
En este ejemplo se asigna a la
variable b, de tipo long, un
valor int. Esto es una
conversión por ampliación,
puesto que el tipo long
representa un tipo de valores
más amplio que int. Así, el tipo
int lo asignamos a variables de tipo numérico de mayor precisión.

Página 18 de 65
 • Es posible asignar tipos de datos byte a cualquier variable de los tipos de más precisión
—short, int, long, float, double—.
• Es posible asignar tipos de datos short a cualquier variable de los tipos de más
precisión —int, long, float, double—.
• Y así sucesivamente.

En el siguiente ejemplo, el tipo int lo asignamos a variables de tipo numéricos de mayor

precisión.

public class Main {

public static void main(String args[]) {
int a=10;
long b=a;
double d=a;
}
}

Página 19 de 65
Conversión por reducción

¿Es posible convertir un tipo de datos de más precisión, por ejemplo, double, a uno de menor
precisión, como float o int?

La respuesta es sí: se trata de la conversión por reducción, puesto que se reduce la precisión al
intentar almacenar en una variable un valor de mayor número de bytes.

public class Main {

public static void main(String args[]) {
double a=300.7;
int b=(int)a;
System.out.println(a);
System.out.println(b);
}
}
Print output:
300.7
300

En las conversiones por reducción hay que especificar entre paréntesis el tipo de dato en
el cual se reduce la precisión. En este caso, se asigna a una variable de tipo int un valor de tipo
double.

Utilizaremos conversiones por reducción solamente en los casos en los que tengamos muy
claro lo que estamos haciendo. Una situación típica es la que representa el ejemplo anterior:
convertir un tipo decimal, sea double o float, a un tipo entero. En la conversión el
compilador elimina la parte decimal y se queda con la parte entera.

• ❌ NO se pueden realizar conversiones entre tipos de datos boolean y el resto de

tipos de datos primitivos… ❌

Página 20 de 65
 • … Pero sí es posible realizar conversiones entre tipos numéricos y char, porque el
tipo de dato char se almacena en memoria como un número entero sin signo.

Un tipo char es un carácter, pero lo que realmente almacena es la representación del

carácter en código ASCII. Por tanto, char → número entero sin signo = valor ASCII.

En la tabla ASCII hay que distinguir:

• Caracteres imprimibles: números, mayúsculas, minúsculas.

• Caracteres de control: tienen efecto sobre cómo se procesa el texto.

El código ASCII surgió en la década de 1960 como evolución de los conjuntos de códigos
utilizados en telegrafía. Casi todos los sistemas informáticos actuales utilizan el código ASCII para
representar textos.

Por ejemplo, el carácter «nueva línea» (line feed), que hace que una impresora avance el papel,
se representa con el valor 10. La tecla Escape se representa con el valor 27. El carácter a, que
hace que se imprima esa letra en la pantalla, se representa con el valor 97. El carácter A se
representa con el valor 65.

Entonces, a cualquier tipo de dato numérico, por ejemplo, int, se le puede asignar un carácter,
como a. Lo que se almacena en la variable es el valor ASCII de este carácter.

Página 21 de 65
int entero=‘a’; //ASCII value: 97
En este caso, la variable entero vale 97, valor ASCII de la letra a.

char character=(char)97; //ASCII character: a

En este caso, a una variable de tipo char se le ha asignado un valor numérico. Lo que se
almacena en la variable es el carácter ASCII correspondiente al valor especificado. Nótese
que es necesario incluir entre paréntesis el tipo char.

Es posible realizar operaciones aritméticas y conversiones entre tipos de datos char y

numéricos. En el siguiente ejemplo, se realiza una operación de resta entre la variable letra,
de tipo char, y el número entero 32. Lo que ocurre es que se usa el valor ASCII de la variable
letra, que es 97. El resultado de la operación es un valor numérico, 65. Pero lo que se almacena
en la variable letraMayuscula es el carácter ASCII asociado a este valor; esto es, A.

public class Main {

public static void main(String args[]) {
char letra='a';
char letraMayuscula=(char)(letra-32); //ASCII character A
System.out.println(letra);
System.out.println(letraMayuscula);
}
}
Print output:

a → cuyo valor ASCII es 97.

A → cuyo valor ASCII es 65. Nótese que en el código (letra-32) es (97-32), cuyo resultado
es 65.

¿Qué pasa si al código se le quita el (char) que va inmediatamente después de char

letraMayuscula=?:

public class Main {

public static void main(String args[]) {
char letra='a';
char letraMayuscula=(letra-32); //ASCII character A
System.out.println(letra);
System.out.println(letraMayuscula);
}
}
Que da error:

/Main.java:4: error: incompatible types: possible lossy conversion from int to char

/Main.java:4: error: tipos incompatibles: posible conversión con pérdidas de int a char

Página 22 de 65
ICA0003-S01-C01-V04 Operadores relacionales y lógicos
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100839)

Operadores relacionales

Java dispone de los siguientes operadores relacionales estándar:

• Equal to == (a==b).

• Not equal to != (a!=b).

• Greater than > (a>b).

• Less than < (a<b).

• Greater than or equal to >= (a>=b).

• Less than or equal to <= (a<=b).

Cada operador relacional devuelve un boolean (tipo de variable que sólo tiene dos valores
posibles: true o false) para indicar si la comparación es true o false.

Por tanto, se puede asignar a una variable de tipo boolean el resultado de la comparación (el
resultado de una operación relacional siempre es un boolean (true/false)):

Página 23 de 65
Los operadores relacionales, al igual que los aritméticos, pueden usarse con variables,
comparando sus valores.

public class Main {

public static void main(String args[]) {
int x=10;
int y=20;
boolean check=y>x;
System.out.println(check);
}
}
Print output:
true

La variable check registra la comparación entre el valor de la variable y con el valor de la

variable x.

¿Qué valor boolean devuelven las siguientes expresiones dado int x=20?

a. x<=21 → true, porque x (20) es less than 21.

b. 2*2>8 → false, porque 2*2=4, y 4 no es greater than 8.
c. x!=5 → true, porque x (20) no es igual a 5.
d. x==20 → true, porque x (20) es igual a 20.

Operadores lógicos

Los operadores lógicos modifican o combinan valores boolean. Java admite tres operadores
lógicos estándar, que son los siguientes:

• Logical NOT ! (!a).

• Logical AND && (a&&b).

• Logical OR || (a||b).

Logical NOT (!)

El operador lógico NOT ! convierte el valor boolean que sigue al símbolo ! en su opuesto.

public class Main {

public static void main(String args[]) {
boolean value=!(3<5);
System.out.println(value);
}
}
Print output:

false

En este caso, el boolean value que resulta de evaluar la expresión (3<5) es true, porque
3 es menor que 5, PERO el operador lógico NOT ! lo convierte en false, que es el valor que
registra la variable value.

Página 24 de 65
Logical AND (&&)

El operador lógico AND && combina las dos expresiones booleanas situadas a su izquierda y a su
derecha. El resultado será true cuando ambas expresiones sean true, y false en el resto de casos.

public class Main {

public static void main(String args[]) {
boolean value=3<5&&2>15;
System.out.println(value);
}
}
Print output:

false

¿Por qué? Porque la expresión booleana de la izquierda —3<5— es true, pero la expresión
booleana de la derecha —2>15— es false. Por tanto, el resultado es false.

Posibles resultados de una operación AND &&:

Logical OR (||)

El operador lógico OR || combina las dos expresiones booleanas situadas a su izquierda y a su

derecha. El resultado es true cuando alguna de las expresiones sea true, y false en el resto de
casos.

public class Main {

public static void main(String args[]) {
boolean value=3<5||2>15;
System.out.println(value);
}
}
Print output:

true, porque al menos hay una expresión true —3<5—.

Posibles resultados de una operación OR ||:

Página 25 de 65
Un museo ofrece descuento para jóvenes de hasta 15 años y para personas mayores de 60
años. Añade el código necesario para asignar a la variable descuentoMuseo el valor
adecuado según la edad de una persona.

Por tanto, para aplicar un descuento a una persona se tiene que cumplir o que su edad sea
menor o igual a 15, o que su edad sea mayor a 60. Por esto, escribimos la expresión edad<=15
seguida del operador OR || y la expresión edad>60.

public class Main {

public static void main(String args[]) {
int edad=15;
boolean descuentoMuseo=edad<=15||edad>60;
System.out.println(descuentoMuseo);
}
}
Print output:

true → En este caso, el visitante recibiría un descuento (por tener <= 15 años).

Combinación de operadores AND (&&) y OR (||)

Aunque se combinen, los operadores lógicos AND (&&) y OR (||) continúan operando sobre los
dos valores situados a su izquierda y a su derecha. Por tanto, en el siguiente caso hay tres
expresiones encadenadas:
boolean enteredDosCode=true;
boolean passRetinaScan=false;
boolean hasDoorKey=false;
boolean knowsOverridePassword=true;
boolean
access=enteredDoorCode&passedRetinaScan||hasDoorKey||knowsOverri
dePassword;

Se pueden distinguir tres expresiones booleanas:

enteredDoorCode&&passedRetinaScan → Si introducimos el código de puerta

correcto (enteredDoorCode) y (&&) pasamos el escáner de retina (passedRetinaScan)
o (||) si tenemos una llave correcta de la puerta (hasDoorKey) o (||) si sabemos sobrescribir
la password (knowsOverridePassword), entonces el acceso está permitido.

Página 26 de 65
¿Qué valor registra la variable access?

Evaluando la expresión de izquierda a derecha, y según el valor de las variables booleanas

declaradas en la parte superior, el valor de la Expresión 1 es false (true&&false da como
resultado false).

Teniendo en cuenta el resultado de la Expresión 1, y realizando la operación OR || con el valor

de la variable hasDoorKey, el resultado es false (false||false es false).

Considerando el resultado de la Expresión 2, y realizando la operación OR || con la variable

knowsOverridePassword, el resultado es true (false||true da como resultado true).

Por tanto, en la variable access se almacena true.

Orden de los operadores lógicos

Así como Java establece un orden para evaluar los operadores aritméticos —suma, resta,
multiplicación, división y resto—, hace lo mismo para los operadores lógicos. El orden es el
siguiente:

1. Paréntesis.
2. NOT ! (de izquierda a derecha).
3. AND && (de izquierda a derecha).
4. OR || (de izquierda a derecha).
!true||false&&true

Como en esta expresión no hay paréntesis, se resuelve de izquierda a derecha:

Primero se evalúa el operador NOT ! —que convierte el true en false—.

Luego se evalúa el operador AND && —false&&true es false—.

Por último, se evalúa el operador OR || —false||false es false—, dando como resultado de

toda la expresión el valor false.

¿Qué valor boolean devuelven las siguientes expresiones?

a. ‘a’==’a’||false||10>50 → true||false||false → true → Es una

concatenación de operaciones OR, lo que significa que si hay al menos una expresión
true, como es el caso de ‘a’==’a’, el resultado será true.

Página 27 de 65
 b. true&&3>5 → true&&false → false → Es una expresión AND, donde la
expresión 3>5 es false y, por tanto, el resultado es false.

c. false&&true||true → false||true → true → Es una concatenación de

operaciones AND y OR. Evaluamos de izquierda a derecha según el orden de los
operadores lógicos: primero AND y luego OR.

d. false&&(true||true) → false&&true → false → Se trata de una

concatenación de operaciones AND y OR, pero con paréntesis. Evaluamos de izquierda
a derecha según el orden de los operadores lógicos: primero paréntesis, luego AND y
luego OR.

e. !(10>1) → !(true) → false → Evaluamos primero el paréntesis y

seguidamente hacemos la negación.

ICA0003-S01-C01-V05 Java Tools

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100823)

En este video se ven las herramientas necesarias para desarrollar aplicaciones en Java.

Java Tools

Para crear programas en Java y ejecutarlos en el ordenador se necesitan algunas herramientas:

un entorno de desarrollo como IntelliJ, que permite editar código Java, compilarlo y ejecutarlo,
y Java Development Kit (JDK), que es un conjunto de librerías que posibilitan el desarrollo y
testeo de aplicaciones en Java.

IntelliJ

Para programar aplicaciones Java es necesario un entorno de desarrollo como IntelliJ, que
permite crear ágilmente programas, compilarlos y ejecutarlos. Como IntelliJ hay otros muchos
entornos de desarrollo que se pueden usar.

Hay dos versiones de IntelliJ, Community y Ultimate. Hay que descargar Community porque
tiene todas las herramientas que se necesitan y es gratuita.

Actualmente IntelliJ incluye el JDK, por lo que no es necesario nada más. Aunque es preciso
saber que JDK puede descargarse gratuitamente desde la web de Oracle, la organización
propietaria de Java. Existe un JDK para cada tecnología Java.

Existen distintas tecnologías Java según el producto para el que se desarrolla la aplicación. Así,
la tecnología Java EE se usa en aplicaciones de entorno servidor. Java SE se usa en aplicaciones
de escritorio. Java ME en aplicaciones para televisores, móviles, etc.

En este curso se aprende a desarrollar aplicaciones para PC. Por esto, se necesita el Java SE
Development Kit, que está disponible para prácticamente todos los sistemas operativos.

Página 28 de 65
JDK tiene dos herramientas principales:

• Java Runtime Environment (JRE). Contiene el código que hay detrás de todos los tipos
de variables y funciones predefinidas de Java, como println. También contiene una
máquina virtual, conocida como Java Virtual Machine, que permite ejecutar el código
Java en cualquier sistema operativo o plataforma. Algunos PC tienen instalado el JRE
porque se necesita para ejecutar aplicaciones Java que aparecen en páginas web, pero
para desarrollar aplicaciones propias hace falta la segunda herramienta: javac - Java
programming language compiler.

• javac - Java programming language compiler. Es el compilador de Java. Un compilador

es un programa especial que traduce el código escrito en un determinado lenguaje de
programación en una forma que el ordenador sepa interpretar y ejecutar. javac traduce
código Java a Java Bytecode —ceros y unos—.

Este Java Bytecode es el que se ejecuta en la máquina virtual de Java y la aplicación se muestra
en la pantalla del PC, sea cual sea su sistema operativo. Por esto se dice que el lenguaje Java es
multiplataforma: Write once, run anywhere (WORA).

Página 29 de 65
Entonces, si tenemos el código Java de una aplicación, por ejemplo, la aplicación que muestra
en pantalla el mensaje Hello World, al compilar el código Java con javac, se obtiene el Java
Bytecode que se ejecuta en la máquina virtual de Java, mostrándose la aplicación en la pantalla.

ICA0003-S01-C01-V06 IntelliJ Environment

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100825)

Cuando se abre IntelliJ por primera vez aparece una pantalla de bienvenida con estas opciones:

• New Project. Crear un nuevo proyecto.

• Open. Abrir un proyecto desde un fichero.
• Get from VCS.

Un proyecto es una forma de organizar código. Los proyectos nos ayudan a separar y agrupar
nuestro código de forma que tenga sentido.

Seleccionaremos New Project. IntelliJ abrirá una pregunta donde se pregunta por el JDK que
usará el proyecto. Normalmente, encuentra el JDK correcto automáticamente; de lo contrario,
se puede seleccionar navegando por el sistema de ficheros hasta la ubicación donde se ha
instalado el JDK.

Página 30 de 65
En la misma pantalla IntelliJ también pregunta por librerías y frameworks, que son colecciones
de código Java y funciones que otros desarrolladores han escrito. En el curso se usan funciones
predefinidas de Java, por lo que no se necesita código externo.

En la siguiente pantalla IntelliJ pregunta si se quiere crear un proyecto usando una plantilla.
Diremos que sí y seleccionaremos la plantilla Command Line App (Simple Java application that
includes a class with main() method).

Seguidamente, hay que especificar el nombre del proyecto o aplicación. Es recomendable optar
por un nombre simple lo suficientemente descriptivo. Project location muestra la ubicación del
proyecto. También se muestra el Base package (paquete base), que se denomina por defecto
com.company. Si se está desarrollando una aplicación para ser distribuida en la web o un
dispositivo móvil es obligatorio que tenga un nombre único de paquete, pero para los ejercicios
y ejemplos de este curso puede dejarse com.company.

IntelliJ Environment

IntelliJ divide la pantalla en dos:

• A la izquierda tenemos la estructura del proyecto. Todo proyecto debe tener una
carpeta src, donde se alojará el código fuente de la aplicación. Si expandimos src
veremos que contiene el paquete base (com.company) y dentro de este el fichero Main,
que es una clase. Todo el código que se escriba debe ir dentro de clases.

• A la derecha se encuentra el código de la clase Main, que contiene el método public

static void main. Cuando se ejecuta la aplicación el PC tiene que saber dónde
empezar a ejecutar código. En las aplicaciones Java por defecto este punto de partida
es el método main. Dentro de este método es donde se escriben las instrucciones de
código.

En Run → Edit Configuration hay tres campos rellenos:

• El nombre completo de la clase que contiene el método principal (The fully-qualified

name of the class that contains the main method). En este caso es com.company.Main

• Working directory: es donde está guardado el proyecto en nuestro sistema de ficheros.

• Java Runtime Environment (JRE), que especifica la versión que se utiliza; por ejemplo,
Java 11.

Para ejecutar el programa hay dos opciones: botón derecho → Run ‘Main’ o pulsar en el símbolo
de la parte superior derecha.

Si no hay ningún error, se crea el Java Bytecode, que se encuentra en la carpeta out. Además,
aparece en la parte inferior la consola de IntelliJ, donde habrá contenido cuando haya
instrucciones System.out.print.

La aplicación ejecuta las instrucciones existentes dentro del método main una detrás de otra.

Si se desea abrir un proyecto, en la pantalla inicial quizá aparezca en la zona de abiertos

recientemente. Si no, hay que clicar en Open, navegar por el sistema de ficheros (normalmente

Página 31 de 65
están dentro de la carpeta IdeaProjects) y encontrarlo. Si el botón de ejecución Run ‘Main’ está
deshabilitado, hay que ir a Run → Edit Configuration y comprobar las opciones.

Para compartir un proyecto Java hay que comprimir el directorio donde se encuentre.

ICA0003-S01-C01-V07 Debugging in IntelliJ

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100840)

Debugging: consiste en ejecutar línea por línea el código viendo qué ocurre, qué valores toman
las variables.

Primeramente, hay que añadir un break point, pulsando al inicio de una línea, que sirve para
que el programa se ejecute de forma normal hasta llegar a la línea de código que tiene el break
point. Ahí se detendrá y esperará a que se le diga qué hacer.

Una vez establecido el break point, hay que pulsar el botón Debug ‘Main’, que permite ver el
valor de las variables sosteniendo el ratón sobre ellas, aunque también aparecen al lado de la
instrucción y en la zona inferior. La ejecución se detendrá al llegar al break point. Para que
continúe paso por paso hay que utilizar Step Over, que permite ejecutar la siguiente instrucción.

ICA0003-S01-C02-V01 Command Line Input Output - Entrada y salida por consola

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100845)

Cómo permitir que el usuario interactúe con nuestras aplicaciones Java usando la consola de
IntelliJ.

User interaction

Las aplicaciones están hechas para que el usuario interactúe con ellas: introduzca datos,
seleccione opciones, visualice resultados… Por esto, disponen de una interfaz gráfica, un
conjunto de elementos que ofrecen una información al usuario y permiten que actúe sobre ellos
usando dispositivos de entrada como ratón, teclado, pantalla táctil… Más adelante se verá cómo
crear interfaces gráficas para las aplicaciones Java, pero por ahora nos centraremos en una
interacción más simple con la consola de IntelliJ, que permite interactuar con el usuario de forma
básica.

Output

Para mostrar datos de nuestro programa en pantalla disponemos de la instrucción

System.out.println(“texto”);, aunque realmente en Java disponemos de dos
instrucciones para mostrar datos:

Página 32 de 65
 • La instrucción System.out.print(“texto”);

• La instrucción System.out.println(“texto”);

Ambas funcionan igual, la diferencia está en que System.out.println(“texto”);,

además de imprimir en pantalla el mensaje que lleva entre paréntesis, añade al final un salto de
línea.

Input

Para aprender cómo leer datos de la consola de IntelliJ usaremos una aplicación que solicita al
usuario que introduzca dos números y muestre el resultado de su suma en pantalla:

import java.util.Scanner;

public class Main{

public static void main (String[] args){

Scanner input=new Scanner(System.in);

System.out.println("Introduce un número entero (y pulsa
Enter)");
int num1=input.nextInt();
input.nextLine();
System.out.println("Introduce un número entero (y pulsa
Enter)");
int num2=input.nextInt();
input.nextLine();
int suma=num1+num2;
System.out.println("La suma es "+suma);
}
}

Página 33 de 65
Análisis del código:

import java.util.Scanner; → Para usar la herramienta Scanner, que permite la lectura

de datos de entrada, hay que importarla con esta sentencia. Las sentencias import se sitúan en
las primeras líneas de nuestro código fuente, antes de la declaración public class Main{

Scanner input=new Scanner(System.in); → Usaremos esta instrucción para disponer

de la herramienta Scanner. Se identifica con la variable input.

int num1=input.nextInt(); → En esta aplicación se leen dos números enteros

introducidos desde teclado. Esto se realizado usando la instrucción input.nextInt() dos
veces —tantas como lecturas haya que hacer—. La instrucción input.nextInt() devuelve
el número entero que se haya introducido por teclado. Por esto, podemos declarar una variable
de tipo int, por ejemplo, num1, num2… a la que asignarle este valor.

int num2=input.nextInt(); → En esta aplicación se leen dos números enteros

introducidos desde el teclado. Esto se realiza usando la instrucción input.nextInt() dos
veces —tantas como lecturas haya que hacer— (esta es la segunda lectura de un número
entero).

input.nextLine(); → Es necesario añadir la instrucción input.nextLine(); tras

haber leído cada dato numérico del teclado, pues permite limpiar el buffer de la herramienta
Scanner y dejarla preparada para leer el siguiente dato.

Lectura de tipos de datos enteros desde teclado:

Página 34 de 65
Lectura de tipos de datos decimales desde teclado:

Scanner no dispone de ninguna instrucción que permita leer caracteres simples. Por tanto,
❌ char letter=input.nextChar();❌ no sería válido.

Página 35 de 65
Si nos equivocamos y no introducimos el tipo de dato esperado, por ejemplo, un número decimal
cuando se espera un número entero, el programa se detendrá y aparecerá en pantalla un
mensaje de error; esto es, se genera un error en tiempo de ejecución.

import java.util.Scanner;

public class Main{

public static void main (String[] args){

Scanner input=new Scanner(System.in);

System.out.println("Introduce un número entero (y pulsa
Enter)");
int num1=input.nextInt(); → Con esto el programa espera que el usuario
introduzca un número entero. Por ello, si introduce un número decimal (ejemplo: 12,5)
ocurrirá un error en tiempo de ejecución
input.nextLine();
System.out.println("Introduce un número entero (y pulsa
Enter)");
int num2=input.nextInt(); → Con esto el programa espera que el usuario
introduzca un número entero. Por ello, si introduce un número decimal (ejemplo: 12,5)
ocurrirá un error en tiempo de ejecución
input.nextLine();
int suma=num1+num2;
System.out.println("La suma es "+suma);
}
}

Demo

Desarrollo de un programa que solicite al usuario un número entero y muestre el resultado de

multiplicar ese número por dos.

Para leer datos de entrada se necesita la herramienta Scanner. Para ello, hay que declarar la
variable Scanner input=new Scanner(System.in); Como hay que importar la
herramienta, o bien se escribe literalmente la sentencia import java.util.Scanner; o bien
se pulsa sobre la palabra Scanner e IntelliJ dirá la combinación de teclas a utilizar para que
automáticamente se escriba la sentencia.

A continuación, hay que pedir al usuario que introduzca un número entero. Para esto se utiliza
la instrucción System.out.println("Introduce un número entero (y pulsa
Enter)");, seguidamente, hay que utilizar la variable input y dentro de esta la sentencia
nextInt();, que devuelve un valor entero que puede almacenarse en una variable, llamada
num. Quedaría así: int num=input.nextInt();

int num → Variable num de tipo int (tipo de dato entero más empleado). En ella se almacena
el valor entero de nextInt()

input → Variable input

nextInt()→ Dentro de la variable input, sentencia que devuelve un valor entero.

Posteriormente, se escribiría la sentencia input.nextLine(); si el programa fuera a solicitar

más datos.

Página 36 de 65
Si no, printaríamos en pantalla lo siguiente: System.out.println(“Su doble es
“+(2*num));

import java.util.Scanner;

public class Main{

public static void main (String[] args){

Scanner input=new Scanner(System.in);

System.out.println("Introduce un número entero (y pulsa
Enter)");
int num=input.nextInt();
System.out.println("Su doble es "+(num*2));
}
}

Si en lugar de introducir un número entero se introduce un decimal —como 2,5— (nótese que
se pone , y no . porque en la consola de IntelliJ los decimales se ponen con , y no con .), el
programa termina produciéndose un error en tiempo de ejecución. El problema estaría en esta
sentencia: int num=input.nextInt();, que hace que se espere un número entero. Si
necesitamos una aplicación que lea tanto números enteros como decimales, hay que cambiar el
tipo de lectura dato a nextFloat o nextDouble, quedando por ejemplo así: double
num=input.nextDouble();

Otra instrucción de lectura: input permite leer también cadenas de texto, no caracteres
simples. Vamos a practicar esta instrucción de lectura, quedando el código así:

import java.util.Scanner;

public class Main{

public static void main (String[] args){

Scanner input=new Scanner(System.in);

System.out.println("Dame un nombre");
String texto=input.next();
System.out.println("El texto es: "+texto);
}
}
Con este código, si se introduce un nombre compuesto, como Maria Jose, que tiene un espacio
en blanco entre una palabra y otra, la instrucción next() lee todos los caracteres hasta llegar
al espacio en blanco, y el resto no lo continúa leyendo. Si queremos leer cadenas de texto que
contengan espacios en blanco hay que usar la expresión nextLine(), quedando el código así:

import java.util.Scanner;

public class Main{

public static void main (String[] args){

Scanner input=new Scanner(System.in);

System.out.println("Dame un nombre");
String texto=input.nextLine();
System.out.println("El texto es: "+texto);
}
}

Página 37 de 65
ICA0003-S02-C01-V01 IF statement
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100853)

Sentencias condicionales

Es habitual que en un programa se tengan que tomar decisiones en base a unos valores de
entrada para dar unos valores de salida.

Programas que toman decisiones en base a una información dada → Sentencias de control. Los
programas han de tener sentencias de control que hagan que si se da una determinada
condición, entonces se produzca una determinada acción.

Java dispone de dos sentencias condicionales: if y switch.

IF statement:

La sentencia if tiene la siguiente sintaxis: comienza con la palabra clave if, seguida de una
(condición), que es una variable booleana, y un bloque de código escrito entre llaves { },
que se ejecutará solo si la condición es true. La ejecución del programa continuará con las
sentencias de código que haya después.

Página 38 de 65
Este es el flowchart de una sentencia if. Se utiliza el símbolo decisión, un rombo , para
mostrar los bloques de código que se ejecutarán según el resultado de evaluar la condición.

El siguiente ejemplo verifica la condición isExpresso. Si su valor es true se mostrará por

consola el mensaje: Get your expresso, please!

public class Main {

public static void main(String args[]) {
boolean isExpresso=?; //true or false
if (isExpresso) {
System.out.println("Get your expresso, please!");
}
}
}

El siguiente ejemplo verifica la condición de si el valor de la temperatura es menor a 0 grados,

que es el punto de congelación del agua. Si lo es, mostrará el mensaje: It’s very cold. Considerar
wearing a scarf.

La ejecución del código continúa después del cierre de llave }, mostrando el mensaje: Have a
Good day!

public class Main {

public static void main(String args[]) {
double temperatureInCelsius=-3;
if (temperatureInCelsius<0) {
System.out.println("It's very cold. Consider wearing a
scarf");
}
System.out.println("Have a good day!");
}
}

Página 39 de 65
Print output:

It's very cold. Consider wearing a scarf

Have a good day!

¿Por qué? Porque la condición es true: temperatureInCelsius es -3, y a partir de bajo 0

muestra el mensaje It’s very cold. Consider wearing a scarf

La sentencia if puede presentar alternativas en su cláusula else si la condición es false. De

esta manera, las sentencias de código situadas en el bloque entre llaves { } tras la palabra clave
else se ejecutarán solo cuando la condición sea false. La ejecución del código continuará
tras el cierre de llave }

Ampliamos el ejemplo anterior para incluir la sentencia else:

• Si la temperatura es menor a 0, la condición es true y se muestra el mensaje It’s very

cold. Consider wearing a scarf. Continuará ejecutándose el código printándose el
mensaje: Have a good day!, que está fuera de las sentencias if else.

• Si la condición es false se muestra el mensaje It’s not that cold. Wear a t-shirt.
Continuará ejecutándose el código printándose el mensaje: Have a good day!, que está
fuera de las sentencias if else.

public class Main {

public static void main(String args[]) {
double temperatureInCelsius=20;
if (temperatureInCelsius<0) {
System.out.println("It's very cold. Consider wearing a
scarf.");
}else{
System.out.println("It's not that cold. Wear a t-shirt.");
}
System.out.println("Have a good day!");
}
}
Print output:
It's not that cold. Wear a t-shirt.
Have a good day!

Página 40 de 65
Es posible anidar múltiples sentencias else if para considerar más alternativas:

La última cláusula else es opcional:

Flowchart de múltiples sentencias else if anidadas. Se va evaluando cada una de las

condiciones ordenadamente, de la primera a la última. Se ejecutará el bloque de código
correspondiente a aquella condición que sea true. Cuando esto suceda ya no se evaluará
ninguna otra condición, ignorándose el resto de bloques de código. Si en este proceso ninguna
de las condiciones es true, se ejecutará el bloque de código else.

Página 41 de 65
En este ejemplo de else if anidados, se ha añadido una alternativa para considerar
temperaturas altas, superiores a 25 grados:

• Si la temperatura es inferior a 0, la condición es true, mostrándose el mensaje It’s very

cold. Consider wearing a scarf. Continuará ejecutándose el código existente fuera de las
sentencias if else, mostrándose el mensaje: Have a good day!

• Si la temperatura no es inferior a 0, la condición de la sentencia if es false, por lo

que se comprobará la condición de la sentencia else if. De este modo, si la
temperatura es superior a 25 grados —y, por tanto, es true—, se mostrará el mensaje
It’s really warm. Don’t forget to wear sunscreen. Continuará ejecutándose el código
existente fuera de las sentencias if else, mostrándose el mensaje: Have a good day!

• Si la temperatura no es mayor a 25, la condición de la sentencia else if es false,

por lo que se ejecutará el bloque de código de la sentencia else, mostrándose el
mensaje It’s not that cold. Wear a t-shirt. Continuará ejecutándose el código existente
fuera de las sentencias if else, mostrándose el mensaje: Have a good day!

public class Main {

public static void main(String args[]) {
double temperatureInCelsius=28;
if (temperatureInCelsius<0) {
System.out.println("It's very cold. Consider wearing a
scarf.");
}else if (temperatureInCelsius>25){
System.out.println("It's really warm. Don't forget to wear
sunscreen.");
}else{
System.out.println("It's not that cold. Wear a t-shirt.");
}
System.out.println("Have a good day");
}
}
Print output:

It's really warm. Don't forget to wear sunscreen.

Have a good day

Página 42 de 65
Variable scope

El ámbito de una variable, delimitado por dos llaves { }, es el bloque de código donde la variable
puede usarse.

En el siguiente ejemplo, la variable temperatura se ha declarado entre las llaves { } del

método public static void main, por lo que podemos usarla a lo largo del programa.
Por tanto, su ámbito es el programa entero, a partir de la línea donde se ha declarado.

Página 43 de 65
En el siguiente caso, la variable humedad se ha declarado dentro de la sentencia if, por lo que
su ámbito es este.

Si tratamos de usar una variable fuera de su ámbito, el programa dará error de compilación.

A tener en cuenta:

• En una estructura if else, solamente se ejecuta un bloque de código de todos los

posibles; el primero cuya condición sea true.

• La condición de la sentencia if siempre va entre paréntesis ( ).

• Las sentencias siempre terminan con ;

• No se pone ; tras la condición de la sentencia if.

• No hay que olvidar las llaves { } en el bloque de código if, sobre todo si en el bloque
if tenemos más de una sentencia.

Página 44 de 65
ICA0003-S02-C01-V03 SWITCH statement
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100855)

La sentencia switch considera un valor y lo compara con distintas posibilidades. Se ejecuta el

bloque de código que primero cumpla con el valor a considerar.

En Java, la sentencia switch trabaja con los tipos de datos primitivos byte, short, chart, int,
String, pero no admite tipos primitivos decimales, como float y double, ni tipos boolean.

Sentencia switch:

✅ byte, short, chart, int, String ✅

❌ float, double, boolean ❌

La sentencia switch consiste en múltiples casos. Cada caso comienza con la palabra clave
case, seguida del valor a comparar. Como en las sentencias if, cada case tiene asociado un
bloque de código. La sentencia switch determinará qué bloque de código de sus cláusulas
case se ejecutará. Es como un selector que asigna un código para cada valor posible que hay
que tratar.

Por tanto, switch significa «selecciona entre estas acciones en función de un valor».

Es posible definir un caso por defecto, que comienza con la palabra clave default y siempre
tiene que ser declarado al final, cubriendo todos los valores que no han sido especificados en
las cláusulas case anteriores.

Cada bloque de código asociado a una cláusula case o default debería terminar con la
sentencia break; que significa «rompe, sal de la sentencia switch y continúa ejecutando el
código que haya después». Así, se logra que se ejecute el bloque de código de solo una de las
cláusulas case, la que su valor mejor se acomode a la condición bajo test.

Página 45 de 65
public class Main {
public static void main(String args[]) {
int month=8;
String monthString;
switch (month) {
case 1: monthString="January"; break;
case 2: monthString="February"; break;
case 3: monthString="March"; break;
case 4: monthString="April"; break;
case 5: monthString="May"; break;
case 6: monthString="June"; break;
case 7: monthString="July"; break;
case 8: monthString="August"; break;
case 9: monthString="September"; break;
case 10: monthString="October"; break;
case 11: monthString="Novembre"; break;
case 12: monthString="December"; break;
default: monthString="Invalid month"; break;
}
System.out.println(monthString);
}
}
Print output:

August

En el código superior, se declara una variable month de tipo int cuyo valor representa un mes
del año. En la sentencia switch se evalúa la expresión entre paréntesis; es decir, el valor de la
variable month, que es 8. Inmediatamente, se ejecuta el conjunto de instrucciones asignadas a
este valor entre las diferentes cláusulas case. Se ejecuta el código de la cláusula case 8,
asignando el valor August a la variable monthString. Si no existiera ninguna cláusula case
con este valor, se ejecutaría el código de la cláusula default.

El bloque de código de la cláusula case 8 que se ejecuta se termina con la sentencia break,
que hace que se salga del bloque de código switch continuando con la ejecución del resto de
líneas del programa que, en este caso, permite mostrar el valor de la variable monthString,
que es August.

Página 46 de 65
¿Qué ocurre si se olvida terminar con break alguna de las sentencias case? Que se ejecutarán
los bloques de código de todas las cláusulas case que vayan después de la cláusula case que
cumpla la condición, hasta que se encuentre una sentencia break o se termine la sentencia
switch.

public class Main {

public static void main(String args[]) {
int month=8;
String monthString;
switch (month) {
case 1: monthString="January"; break;
case 2: monthString="February"; break;
case 3: monthString="March"; break;
case 4: monthString="April"; break;
case 5: monthString="May"; break;
case 6: monthString="June"; break;
case 7: monthString="July"; break;
case 8: monthString="August";
case 9: monthString="September";
case 10: monthString="October"; break;
case 11: monthString="Novembre"; break;
case 12: monthString="December"; break;
default: monthString="Invalid month"; break;
}
System.out.println(monthString);
}
}
Print output:

October

En el código superior, la cláusula case 8 es la que cumple con la condición del switch. Por
tanto, se ejecuta su código, asignando a la variable monthString el valor August. Pero al no
encontrar la sentencia break no se sale del bloque switch, ejecutándose el código de la
siguiente cláusula case, que actualiza el valor de monthString a September. Como la
cláusula 9 tampoco contiene la sentencia break, se ejecuta el código de la siguiente cláusula,
case 10, que actualiza nuevamente el valor de monthString a October. Esta cláusula sí
contiene la sentencia break, que hace que se salga del bloque switch y se ejecute el resto
del código del programa, mostrando por consola el valor de monthString, que es October.

En lugar de usar la sentencia switch, es posible usar sentencias if else anidadas. Aunque el
efecto es el mismo, la opción de usar if else anidadas complica la lectura de código.

Página 47 de 65
Entonces, ¿cuándo usar sentencias if o switch? Hay que basarse en facilitar la lectura y
mantenimiento del código y la condición bajo test:

• Las sentencias if pueden testear condiciones boolean.

• La sentencia switch permite testear los valores de tipos primitivos byte, short,
int, char y String.

ICA0003-S03-C01-V01 WHILE Loops

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100861)

Java dispone de tres tipos de bucles (loops):

while loop: «Mientras la condición se cumpla, haz esto».

Los bucles while comienzan con la palabra clave while seguida de una (condición).
Mientras la condición sea true, se ejecuta el bloque de código situado entre las llaves { }
una y otra vez. Cada ejecución es una iteración.

Dentro del bloque while se actualiza el valor de la condición, el valor de la variable on, que
hará que se salga del bucle. A esto se le denomina variable de control. En este caso, lo que está
dentro del bloque de código while se ejecuta una y otra vez porque la variable de control on
es true:

public class Main {

public static void main(String args[]) {
boolean on=true;
while(on){
System.out.println("Beep");
on=true;
}
}
}
Print output:
Beep
Beep
Beep
…

Página 48 de 65
En el siguiente código, lo que está dentro del bloque de código while solo se ejecuta una vez
porque la variable de control on es false.

public class Main {

public static void main(String args[]) {
boolean on=true;
while(on){
System.out.println("Beep");
on=false;
}
}
}
Print output:

Beep

while va más allá de evitarnos tener que escribir el mismo código N veces. También permite
crear aplicaciones que hagan uso de un contador, como es el caso de una tabla de multiplicar
(multiplica el número por un valor, que en cada paso se incrementa en 1):

// 0. Establecer qué tabla vamos a mostrar. Hemos seleccionado la

tabla del 5
// 1. Mostrar resultado de multiplicar el número por 1
// 2. Mostrar resultado de multiplicar el número por 2
// 3. Mostrar resultado de multiplicar el número por 3
// 4. Mostrar resultado de multiplicar el número por 4
...
// 10. Mostrar resultado de multiplicar el número por 10

public class Main {

public static void main(String args[]) {
final int TABLA=5;
int i=1; → Es la variable contador; también la variable de control
while (i<=10){
System.out.println(i+" x "+TABLA+" = "+(i*TABLA));
i++; → Incrementar el contador
}
}
}
Print output:

1 x 5 = 5
2 x 5 = 10
3 x 5 = 15
4 x 5 = 20
5 x 5 = 25
6 x 5 = 30
[…]
10 x 5 = 50

Página 49 de 65
Flowchart de la aplicación:

ICA0003-S03-C01-V02 WHILE loops examples

(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100862)

Tabla de multiplicar inversa:

public class Main {

public static void main(String args[]) {
final int TABLA=5;
int i=10;
while (i>=1) {
System.out.println(i+" x "+TABLA+" = "+(i*TABLA));
i--;
}
}
}
Print output:
10 x 5 = 50
9 x 5 = 45
8 x 5 = 40
7 x 5 = 35
6 x 5 = 30
5 x 5 = 25
4 x 5 = 20
3 x 5 = 15
2 x 5 = 10
1 x 5 = 5

Página 50 de 65
Mostrar las letras del abecedario:

En ASCII, los caracteres del abecedario en mayúscula empiezan en decimal en 65 y terminan en

90.

public class Main {

public static void main(String args[]) {
int letterIntValue=65;
while (letterIntValue<=90) {
char letter=(char)letterIntValue;
System.out.println(letter);
letterIntValue++;
}
}
}
int letterIntValue=65; → Se comienza declarando la variable letterInValue e
inicializándola en 65, valor ASCII de A.

Se declara un bucle while cuyo bloque de código tiene por objetivo printar los caracteres del
abecedario en mayúscula —System.out.println(letter);—, aunque previamente es
necesario convertir a char su valor entero —char letter=(char)letterIntValue;—.
¿Cuántas veces se tiene que ejecutar el bucle? Mientras que no se haya llegado a la Z; esto es,
mientras letterInValue sea menor o igual a 90 —while (letterIntValue<=90)—.
letterIntValue es variable de control, que debe actualizarse dentro del bloque de código
del bucle, incrementándose en una unidad en cada iteración —letterIntValue++;—.

Página 51 de 65
Juego: adivinar el número que se esconde en la caja misteriosa con tres intentos

import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner input=new Scanner(System.in);
System.out.println("Welcome to: Whats inside the mistery box?");
int mysteryBoxNumber=5;
int count=3;
boolean win=false;
while (count>0&&!win) {
System.out.println("Please enter a number");
int num=input.nextInt();
input.nextLine();
count--;
if (num==mysteryBoxNumber) {
win=true;
}
}
if(win) {
System.out.println("You win");
}
else {
System.out.println("You lose. The value of the mysteriorus box
is "+mysteryBoxNumber);
}
}
}

Página 52 de 65
ICA0003-S03-C01-V03 DO-WHILE Loops
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100863)

Java dispone de dos tipos de bucles while:

• while. Evalúa la condición al inicio de cada iteración.

• do-while. Evalúa la condición al final de cada iteración. «Haz esto y continúa
haciéndolo mientras se cumpla la condición».

La sintaxis del bucle do-while comienza con la palabra clave do, seguida de un bloque de
código entre llaves { } y la palabra clave while, seguida de una (condición).

Nótese que primero se ejecuta el bloque de código do situado entre llaves { } antes de evaluar
la condición del bloque. Se continuará ejecutado el bloque de código del bucle mientras la
condición sea true.

Página 53 de 65
Programa que printa la tabla de multiplicar con while y con do-while:

En ambos casos hay una variable contador que se usa como variable de control en la
condición lógica del bucle, actualizando su valor en cada iteración.

Programa que printa el abecedario con while y con do-while:

En la mayoría de las situaciones pueden usarse indistintamente bucles while o do-while. Se

usará do-while siempre que se quiera ejecutar su bloque de código al menos una vez,
porque la condición se evalúa al final. El caso típico es controlar si el dato introducido por el
usuario es válido, puesto que primero hay que leer la entrada del dato del usuario para,
posteriormente, evaluar si cumple los requisitos o no.

Por ejemplo, supongamos un programa que pide al usuario que introduzca un valor entre 1 y
10. Mientras el usuario no respete esta condición, el programa pedirá que se cumpla.

Página 54 de 65
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner input=new Scanner(System.in);
int valorUsuario=0;
do {
System.out.println("Introduce un valor entero entre 1 y
10");
valorUsuario=input.nextInt();
input.nextLine();
} while ((valorUsuario<1)||(valorUsuario>10));
System.out.println("Correcto, has introducido "+valorUsuario);
}
}

Si no se cumple el requisito, porque el valor introducido es menor que 1 o mayor que 10,
la condición del bucle do-while es true, por lo que se itera de nuevo. Por ejemplo:

• Si valorUsuario vale 0, significa que:

o 0<1 (cero es menor que uno), lo que es true.
o 0>10 (cero es mayor que 10), lo que es false.
o true||false=true. Por tanto, el código se itera nuevamente.

• Si valorUsuario vale 11, significa que:

o 11<1 (once es menor que uno), lo que es false.
o 11>10 (once es mayor que diez), lo que es true.
o false||true=true. Por tanto, el código se itera nuevamente.

Página 55 de 65
 Si se cumple el requisito, porque el valor introducido es mayor que 1 o menor que 10, la
condición del bucle do-while es false, por lo que se sale del bucle. Por ejemplo:

• Si valorUsuario vale 2, significa que:

o 2<1 (dos es menor que uno), lo que es false.
o 2>10 (dos es mayor que diez), lo que es false.
o false||false=false, por lo que se sale del bucle.

• Si valorUsuario vale 8, significa que:

o 8<1 (ocho es menor que uno), lo que es false.
o 8>10 (ocho es mayor que diez), lo que es false.
o false||false=false, por lo que se sale del bucle.

Posibles resultados de una operación AND &&:

Posibles resultados de una operación OR ||:

Página 56 de 65
ICA0003-S03-C01-V04 FOR Loops
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100864)

Los bucles while y do-while son muy útiles cuando se quiere repetir un bloque de código
mientras una determinada condición es true. Pero a veces se necesita repetir un bloque de
código un número específico de veces. Por ejemplo, mostrar un mensaje 20 veces.

Ejemplo: un programa que muestre el mensaje Beep del despertador 20 veces.

Puede hacerse con un bucle while:

Pero Java dispone de otro tipo de bucle (for) que permite hacer de forma abreviada lo que
se ha hecho con un bucle while. for se utiliza cuando se tiene que repetir un código un
número de veces específico.

Página 57 de 65
loop counter scope

La variable i (loop counter), que controla cuántas iteraciones tendrá el bucle, puede usarse en
el bloque de código del bucle for. Por ejemplo, para mostrar el número de Beeps en cada
iteración:

El valor de loop counter cambia automáticamente en cada iteración. Pero hay que tener cuidado
de no modificar su valor dentro del código del bucle for. En el ejemplo siguiente, en cada
iteración se incrementa automáticamente el valor de i, pero a la vez se decrementa en el bloque
de código del bucle. Por tanto, es un bucle infinito. Para evitar esto, no hay que actualizar el
valor de la variable loop counter dentro del bucle for.

Página 58 de 65
Print output:

0
0
0
0
0
0
0
0
…

loop counter values

La variable loop counter i puede inicializarse a cualquier valor entero: 0, 1, 15, 200…, según los
requisitos del programa.

loop increment

En los bucles for puede contarse hacia abajo en lugar de hacia arriba.

En el bucle for inferior izquierda, se inicia la cuenta en 0 y en cada iteración se incrementa en

1 hasta llegar a 20.

En el bucle for inferior derecha, se inicia la cuenta en 20 y en cada iteración se decrementa en

1 hasta llegar a 0.

Página 59 de 65
También puede establecerse otros tipos de incremento/decremento. En el ejemplo inferior, en
cada iteración se suma 2 al valor de la variable loop counter i.

El valor de la variable loop counter también puede variar más allá de la suma/resta. En el
ejemplo inferior, en cada iteración la variable i se incrementa multiplicando su valor por 5.

Página 60 de 65
ICA0003-S03-C01-V05 Nested Loops
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100865)

Bucles anidados: significa tener un bucle dentro de otro.

En el caso superior, hay un bucle for dentro de un bucle for:

• Bucle for externo:

for (int i=0; i<2; i++) {

El loop counter i se inicia en 0. En cada iteración se incrementa en 1 (i++) hasta llegar

a 2, lo que significa que el bloque de código situado entre las llaves { } se ejecutará dos
veces.

• Bucle for interno:

for (int j=0; j<2; j++) {

El loop counter j se inicia en 0. En cada iteración se incrementa en 1 (j++) hasta llegar

a 2. El bloque de código situado entre las llaves { } se ejecutará dos veces.

Página 61 de 65
Por tanto, este bucle anidado funciona así:

• Por cada iteración del bucle externo, el bucle interno imprime la instrucción dos veces.
• Así, en la primera iteración del bucle externo, el bucle interno se ejecuta dos veces,
printando dos veces Hello world.
• Seguidamente, se produce la segunda iteración del bucle externo. De nuevo, el bucle
interno se ejecuta dos veces, printando dos veces Hello world.
• Consecuentemente, una vez finalizado el bucle externo, Hello world se ha impreso
cuatro veces.

Normalmente, se necesitan los bucles anidados cuando se requiere repetir varias veces un
bloque de código que ya de por sí precisa de un bucle.

Por ejemplo, un programa que no solo muestre la tabla de multiplicar de un número, sino que
muestre distintas tablas de multiplicar, tantas como indique el usuario. Habrá que repetir N
veces la tarea de mostrar una tabla que a su vez es la repetición de diez multiplicaciones.

El bucle for externo controla la repetición de mostrar las distintas tablas de multiplicar (la tabla
del 1, la tabla del 2, etc.):

El bucle for interno controla la tarea de mostrar una tabla en concreto:

Página 62 de 65
Juego de la caja misteriosa: se controla que el número introducido por el usuario esté en un
rango válido, del 1 al 10. Si no es así, se le vuelve a solicitar.

El bucle while externo permite la ejecución mientras no se supere el número máximo de

intentos o se haya adivinado el número.

El bucle do-while interno controla que el valor introducido por el usuario esté dentro del
rango válido. Si no, se le vuelve a solicitar que introduzca un número.

Página 63 de 65
ICA0003-S03-C01-V06 BREAK and CONTINUE statements
(https://lasallefponline.sallenet.org/mod/videofile/view.php?id=100866)

Sentencias de control

Java, como otros lenguajes de programación, dispone de sentencias que permiten el control
directo sobre el comportamiento de las iteraciones de un bucle. Son las sentencias break y
continue.

break statement

La sentencia break se usa en la sentencia switch (switch, case, break). Indica salir, terminar.

Así, break interrumpe inmediatamente la iteración en curso del bucle, haciendo que se salga
de él.

Página 64 de 65
Sentencia break en un programa:

continue statement

La sentencia continue se aplica únicamente a bucles. Interrumpe inmediatamente la iteración

en curso, pero, a diferencia del break, el bucle no termina, sino que continúa en la siguiente
iteración.

En el siguiente ejemplo, si la iteración es múltiplo de 2, no se ejecuta el resto de código del bucle,

sino que continúa en la siguiente iteración.

Página 65 de 65