Programación estructurada y programación funcional en Java ☕

En este artículo vamos a aprender muchísimas como por ejemplo como trabajar subdividir nuestro código en distintas clases y métodos, como debuggear nuestro código. Y además de ello, os presentaremos las estructuras de control (también conocida como programación estructurada) de Java.

Las estructuras de control consisten en un paradigma (técnica fundamental) de programación (que nacen con el objetivo de ayudar a resolver orientado a mejorar la claridad, calidad y tiempo de desarrollo de un programa.

¡Comenzamos! Pero antes vamos a ver la tabla del contenido del post.

📖 Tabla de contenido 📖

1. Presentación el temario

• 1.1 → La command prompt (CMD)
• 1.2 → Comentarios en Java
• 1.3 → Tipos de estructuras de control de flujo
• 1.4 → Esquema de categorías y las distintas estructuras de control en Java

2. Estructuras condicionales/selección

• 2.1 → Introducción a las estructuras condiciones
• 2.2 → Profundizando en las instrucciones condicionales
• 2.3 → ¿Cómo realizamos una operación condicional en Java?
• 2.4 → Aprendiendo a debugear
• 2.5 → Estructura condicional IF (Unidireccional)
• 2.6 → Estructura condicional IF con estructuras anidadas
• 2.7 → Analizando el rendimiento de muchos IFs frente a algunas de sus alternativas
• 2.8 → Estructura condicional IF-ELSE (Bidireccional)
• 2.9 → La ley del “70% 30%”, como organizar las estructuras condicionales
• 2.10 → Estructura condicional IF-ELSE IF- ELSE (Tridireccional o más…)
• 2.11 → Estructura condicional operador ternario/condicional (“bidireccional” en principio)
• 2.12 → Desmontando el mito que el operador condicional solo puede ser bidireccionalidad
• 2.13 → Operador condicional SWITCH
• 2.14 → Analizando el funcionamiento de la condición en SWITCH
• 2.15 → Ejemplo de SWITCH con cascada de CASES
• 2.16 → Estructura de control SWITCH mejorada (disponible a partir de la versión 14 de Java)
• 2.17 → SWITCH dentro de SWITCH
• 2.18 → ¿Cuándo usar un SWITCH frente a las otras alternativas (IF, IF-ELSE, IF-ELSE IF-ELSE o TERNARY OPERATOR)?
• 2.19 → Enfrentando a IF-ELSE con SWITCH para analizar su performance
• 2.20 → Ejercicios de estructuras condicionales

3. Estructuras repetitivas/iterativas

• 3.1 → Introducción a las estructuras repetitivas
• 3.2 → Estructura repetitiva FOR
• 3.3 → Estructura de una condición de un FOR
• 3.4 → FOR dentro de FOR
• 3.5 → Estructura de repetición ForEach (para cada), disponible a partir de la versión 5 de Java
• 3.6 → Estructura de control WHILE
• 3.7 → Estructura de control DO WHILE
• 3.8 → Ejercicios sobre estructuras iterativas

4. Instrucciones de salto: break y continue

• 4.1 → Presentación de las instrucciones de salto
• 4.2 → Ejemplo de uso de las instrucciones de salto break y continue
• 4.3 → Ejercicios con instrucciones de salto

5. Estructura secuencial y programación funcional

• 5.1 → Introducción a la estructura secuencial
• 5.2 → Introducción a la programación funcional
• 5.3 → Programación funcional: Creando métodos void (sin return) en la misma clase
• 5.4 → Programación funcional: Creando métodos (sin void) con return en la misma clase
• 5.5 → Programación funcional: Creando métodos void (sin return) en la misma clase
• 5.6 → Ejercicios de programación funcional

6. Entrada de datos con Scanner

• 6.1 → ¿Para que utilizamos la clase Scanner?
• 6.2 → Importando librería necesaria para trabajar con Scanner
• 6.3 → Aprendiendo a usar la API de Java
• 6.4 → Realizando el autoimport de Scanner
• 6.5 → Ejemplo de cómo capturar un String con Scanner
• 6.6 → Explicando cómo y porque utilizar el método close al finalizar el uso de Scanner
• 6.7 → Métodos a utilizar en función del tipo de dato que queremos capturar
• 6.8 → Protegiendo nuestro código de excepciones cuando trabajamos con Scanner
• 6.9 → Ejercicios con Scanner

1. Presentación la unidad

1.1) Command prompt (CMD) 🔝

La consola también conocida como Command prompt, línea de comandos, terminal o CMD. La podemos ejecutar con simplemente ir a Inicio y escribir CMD en el buscador:

Aquí tenemos una consola de CMD:

Esta terminal, nos permite realizar:

• Entrada (input) de datos: cuando introducimos los datos a través del teclado, ratón, etc.
• Salida (output) de datos: cuando sacamos datos por pantalla.

Aunque, como nosotros como trabajamos con Eclipse como IDE, ya no hará falta abrir un CMD, ya que, si abrimos el IDE, podemos apreciar que podemos acceder directamente a una terminal que nos proporciona el propio IDE.

Una vez dentro del IDE, creamos un proyecto desde File>New>Java Project:

Y finalmente escribimos el nombre que asignaremos a nuestro proyecto de Java. En mi caso, pondré entradaSalida ya que es el tema principal que vamos a tratar en él:

Como dice Matías ¡Java tiene mucha clase!

Por lo que vamos a crear nuestra primera clase dentro del proyecto:

Le pondremos como nombre Main para identificar que esta será la clase principal muy fácilmente. Y además, vamos a marcar la casilla para que la clase sea la clase main (la primera clase que se ejecutará cuando ejecutemos nuestro programa):

Lo que nos generará la siguiente estructura:

Dentro de la clase, vamos a escribir el método out.println() que pertenece a la clase System quedando nuestra clase Main.java de la siguiente manera:

Y finalmente ejecutemos el código desde el botón verde de run (ejecutar):

Lo que provocará que se muestre el mensaje de output en la CMD que nos proporciona el propio IDE.

1.2) Comentarios en Java 🔝

En Java disponemos de varios tipos de comentarios. Los comentarios nos permiten escribir notas dentro de nuestro código, comentar código que de momento no queremos que se ejecute, etc.

Hay que destacar que los comentarios que no serán interpretados (ni ejecutados) por el compilador de Java.

Comentarios en una sola línea: para crear un comentario de una sola línea utilizamos // en el inicio del texto del comentario.

Los comentarios de una sola línea pueden ocupar tanto una línea al completo, vamos a ver un ejemplo:

Si queremos, también los podemos poner de tal forma para que compartan la línea con una instrucción que sí que se compilará:

En ambos casos, el código que se ejecuta no muestra rastro alguno de dichos comentarios:

ℹ ️ — Esto, se produce ya que cuando se interpreta el código, llegado a estas marcas // el interprete de Java salta a la siguiente línea. Ya que ve la doble barra // como un indicador de un inicio de un comentario y, por tanto, no lo interpreta ni ejecuta el resto de la línea ya que lo ha identificado como un comentario.

Comentarios multilínea: empiezan con /* y se acaban con */

Un ejemplo de ello podría ser:

También es común que cuando escribimos el /* y pulsamos un enter, el IDE automáticamente nos ponga un * en cada principio de la línea. Esto no supone ninguna diferencia respecto al comentario anterior que acabamos de escribir:

En ambos casos, el código que se ejecuta no muestra rastro alguno de dichos comentarios:

ℹ ️ — Y lo mismo ocurre con una apertura de comentario multilínea /**/ cuando se interpreta el código, y el compilador de Java ve la marca /* identifica que se encuentra ante un comentario multilínea y, por tanto, no empieza a realizar la compilación hasta que no se realiza el cierre del comentario con */. Entendiendo, por tanto, que desde su apertura /* y hasta el cierre con */ el contenido es un comentario. Por lo que, no ejecuta el contenido hasta que llega al cierre que este englobado entre ellas.

1.3) Tipos de estructuras de control de flujo 🔝

En Java el orden natural en el que se realiza una ejecución de un programa, (también conocido como el flujo de ejecución de un programa) dictamina el orden en el que se ejecutan las instrucciones que pertenecen a un programa. Por defecto, dicho orden es secuencial. Es decir, los programas se ejecutan instrucción a instrucción de arriba hacia abajo.

Pero es posible que cuando desarrollemos nuestros programas, solamente quisiéramos ejecutar una serie de instrucciones de nuestro código en unas determinadas circunstancias, o que quisiéramos que se ejecute varias veces, etc. Para todo ello, nacen las estructuras de control.

Para englobar una serie de instrucciones utilizamos un bloque (contenido entre {}) de instrucciones que contiene una serie de instrucciones se debe ejecutar o no, disponemos de distintas estructuras de control que nos permitirán controlar modificar la ejecución secuencial del flujo de nuestros programas ejecutando solamente algunos de los bloques, ejecutarlos varias veces, etc.

Dentro de las estructuras de control tenemos:

• Estructura secuencial: es una forma de ejecutar código en la que las instrucciones se ejecutan de arriba a abajo, sentencia a sentencia una detrás de otra. Sin incluir saltos a otras partes del algoritmo y sin dejar líneas sin ejecutar.

Vamos a ver un ejemplo en el que se ejecutan 4 instrucciones, de forma secuencial:

Cuando ejecutemos el código veremos lo siguiente:

A excepción de que no añadamos otras estructuras de control, la estructura con la que por defecto se ejecuta un programa en Java es secuencial.

• Estructura condicional: permiten ejecutar o no ejecutar ciertos bloques (que contendrán una serie de instrucciones) de un código en función de si se cumplen o no una o una serie de condiciones.

Un ejemplo sería el siguiente en el que tenemos 4 instrucciones, pero solamente ejecutamos las instrucciones impares o las pares en función de si el número que hemos definido en la variable num es par u impar. Vamos a verlo:

En este caso como la variable num es impar, ejecuta solamente 2 instrucciones y no las 4 como hacíamos anteriormente en la estructura secuencial. Vamos a verlo:

• Estructuras repetitivas: permiten ejecutar un bloque de instrucciones varias veces.

Un ejemplo podría ser el tener 4 instrucciones y que estás se ejecuten varias veces con solo tener un bloque de código. Vamos a verlo:

El resultado será el siguiente:

• Instrucciones de salto: da como resultado la terminación de la iteración o del bucle al completo. Cuando se quiere detener el bucle (y, por tanto todas las iteraciones restantes) en el bucle se aplica break. O bien, continue cuando queremos finalizar la iteración actual del bucle (pero no el resto de iteraciones del bucle) ya que otorga esa responsabilidad a la instrucción encargada de realizar el control a la instrucción del bucle (continue). Vamos a ver un ejemplo:

El resultado de utilizar un break en la ejecución del bucle será el siguiente:

1.4) Esquema de categorías y las distintas estructuras de control en Java 🔝

Aunque ya hemos visto algo algún detalla sobre las estructuras de control, más abajo las analizaremos más detenidamente. Pero antes, vamos a ver un pequeño esquema a modo de resumen con los tipos de estructuras sobre las que hemos hecho esta 🦜vista de pájaro🦜:

2. Estructuras condicionales/selección

2.1) Introducción a las estructuras condiciones 🔝

En Java disponemos de distintas estructuras de control condicionales (ya que dependen de una condición o de varias) que nos permitirán ejecutar (o no ejecutar) un cierto bloque de instrucciones (que estará englobado entre {}) en función de unas determinadas condiciones.

ℹ ️ — Las estructuras de condicionales también son conocidas como estructuras de selección.

La finalidad de trabajar con condicionales es controlar si un cierto bloque de instrucciones se ejecuta o no durante la ejecución del flujo de nuestros programas en función de las condiciones que nosotros le indiquemos.

Un ejemplo de nuestro día a día que es muy similar al comportamiento de un if es el del 💂‍♂️ portero de discoteca 💂‍♂️ que analiza una condición (vestimenta, edad, actitud, estado de embriaguez…) para terminar si puedes entrar o no en una disco.

Aunque si entró Dimitriv…🕺🕴

2.2) Profundizando en las instrucciones condicionales 🔝

Para ello, antes de comenzar con las estructuras condicionales, vamos a ver primeramente ¿Qué es una instrucción condicional? En programación, una condición es toda sentencia de la cual se puede determinar su verdad (true) o falsedad (false). En su gran mayoría, son comparaciones. Por tanto, es una estructura que analiza una sentencia y retorna un valor booleano (y, por tanto, como ya vimos en los tipos de datos los boléanos trabajan sobre un solo bit) que puede tener como valor (0 o 1) creando distintos caminos que por los que podrá ir nuestro conocido más conocidos como puertas lógicas.

Cuando el resultado de dicha puerta lógica es false(falso) el valor lógico es 0, en cambio, cuando el resultado es true(verdadero) el valor de la puerta lógica es 1. Permitiendo con estás señales mandar una serie de impulsos que nos permiten controlar el hardware (componentes) del dispositivo.

Pese a que Java no está pensado para trabajar con los valores 0 y 1 como sí fueran los valores false y true, como si que pasa en otros lenguajes como por ejemplo JavaScript en el que sí que pasa el famoso “return 0 means false 1 means true”.

En JavaScript podemos ver que podemos realizar eso mismo desde JSBIN una web que nos permite muy fácilmente desde la web que nos permite ejecutar JavaScript desde la web:

Pero si intentamos hacer algo así en Java, podemos ver que cuando intentamos castear (casting = convertir un tipo de dato a otro) un booelan a un int nos aparecerá un error:

Que nos indícanos que no podemos convertir un booelana un int:

Aunque nosotros lo podemos hacer de una forma muy simple con el operador booleano o con un if tradicional (ambos serán explicados más a detalle un poquito más adelante). Siguiendo el famoso “return 0 means false 1 means true” que como acabamos de comentar, se aplica en otros lenguajes como JavaScript, podemos aplicarlo de la siguiente manera:

El resultado sería el siguiente:

Por tanto, las puertas lógicas, son las encargadas de realizar operaciones booleanas que retornarán true or false con la finalidad de poder abrir distintos caminos dentro de nuestro código en función de unas determinadas condiciones.

2.3) ¿Cómo realizamos una operación condicional en Java? 🔝

Vamos a ver un ejemplo de cómo obtener el resultado (true or false) de una condición o de varias condiciones:

El resultado de dichas operaciones será el siguiente:

2.4) Aprendiendo a debugear 🔝

Hasta ahora hemos imprimido el contenido de dichas operaciones directamente por pantalla, pero existe la posibilidad de ejecutar el debugger. Que no es nada más y nada menos que un mecanismo mediante el cual podemos detener el flujo de ejecución en un punto (donde pongamos el break point) para ir analizando al detalle lo que pasa en nuestro código paso a paso.

ℹ ️ — Recordad que es necesario poner un break point (haciendo doble click a la izquierda del número de la instrucción) para poder parar el flujo de ejecución de un programa

Tras pulsar el bichito 🪲, se activa el debug lo que provoca que el código se detenga sobre la instrucción sobre la que hemos realizado el break point y que, dicha instrucción se ponga en verde. Además, podemos ver que se nos abre una pestaña de debug que es el encarga de detener nuestro flujo de ejecución:

Una vez llegados a este punto, llegamos a la parte que nos interesa la que nos permite observar los resultados sin tener que mostrarlos por pantalla (también se aplica sobre estructuras como if, for, etc. que veremos un poco más abajo). Vamos a verlo:

Lo que nos abrirá una ventana como la siguiente con el resultado:

En este caso true.

Si ejecutamos el programa sin detener el flujo con el botón play verde, podemos ver que el resultado de la última condición devuelve true:

Pero si volvemos a ejecutar del debugger (pulsando sobre el bichito 🪲), podemos observar que los valores que actualmente tienen las variables:

E inclusive cambiar los valores actuales por otros. Por ejemplo, vamos a cambiar el valor de la variable resultado por false:

Lo que hará que el valor cambié debajo y finalmente pulsamos sobre el botón de resume(F8). Lo que provocará que al no tener más break points (puntos de ruptura) continuemos ejecutando el flujo de nuestro programa

Lo que finalmente nos devolverá la instrucción que debería imprimir true por defecto con el valor false:

Ya que la hemos modificado durante la ejecución del programa 🔥 “en caliente” 🔥 sin tener que tocar si quiera el código del programa.

El principal beneficio de esto, es que nos cambiar la dirección/camino (haciendo esta especie de “trucos”) y obligar al código a pasar por partes de nuestro código por las que en principio no debería durante su ejecución.

2.5) Estructura condicional IF (Unidireccional) 🔝

Un if (significa si en castellano) es una estructura de programación que ejecuta una instrucción siempre y que está sea verdadera. En caso de que esta sea false no se ejecutará.

Su estructura básica sería la siguiente:

Vamos a ver un ejemplo que se ejecutará siempre. Ya que true siempre serátrue y, por tanto, se evaluará como true. Por lo que, al ser siempre verdadera se ejecutaría siempre (pese a que en el bloque de instrucciones no tengamos nada y por tanto no haga nada):

Vamos a ver un ejemplo de un if que esta vez sí que hace cosas. En este caso, evalúa si la nota es menor que 5 (nota<5) para finalmente, en el caso que sea true mostrar que estamos suspendidos:

En este caso, como la nota es 3, el resultado de la condición es true, ya que:

3 < 5 significa que 3 es menor que 5. Por lo que, como el resultado de evaluar dicha condición es cierto, devuelve true

Y, por tanto, como el resultado es true sí que ejecuta el bloque del if. Vamos a ver el resultado de la ejecución:

En cambio, si la nota es mayor o igual que 5, la condición será false y no se ejecutará el bloque del if, sino que solamente se mostrará el resultado de la condición (ya que está fuera del if). Vamos a verlo:

Podemos concatenar varios ifs tanto dentro de un if como fuera, vinculados a una misma condición o vinculados a otras condiciones.

Aunque más abajo que existen formas más eficientes de realizar esto, podemos realizar varios ifs, para mostrar un mensaje de output con el mensaje de aprobado o suspendido. Vamos a ver como trabajar con varios ifs vinculados a una misma condición:

El resultado será el siguiente:

2.6) Estructura condicional IF con estructuras anidadas 🔝

Ahora vamos a ver como un ejemplo de cómo concatenar varios ifs dentro de un if. En este ejemplo, además, vamos a ver como ejecutar ifs con una sola instrucción, ya que no hace falta poner los {} obligatoriamente, aunque sí que es recomendable. Vamos a verlo:

El resultado será:

El problema por el que desaconsejo ejecutar así los ifs (sin bloque de instrucciones {}) es que si queremos poner una nueva instrucción que felicite al alumno (junto a otra instrucción con su nota) cuando el alumno saqué un 10, al ser más de una instrucción se ejecutaría siempre y no solamente cuando se ejecute la matrícula de honor. Vamos a verlo:

Si el alumno tiene un 10 vemos que se ejecuta correctamente:

Pero si tiene otra nota, podemos ver que también se ejecuta el enhorabuena:

Por tanto, un if sin bloque de instrucciones en Java solamente puede ejecutar una sola línea a diferencia de otros lenguajes como en Python en los que las identaciones (tabulaciones) determinan si un código se ejecuta o no. Por ello, a partir de ahora nosotros vamos a utilizar bloques de instrucciones en nuestros ejemplos.

Cuando utilicemos ifs sin bloque de instrucciones, podemos formatearlo de la siguiente manera para que sea más legible:

2.7) Analizando el rendimiento de muchos IFs frente a algunas de sus alternativas 🔝

Cuando ejecutamos nuestros programas, el rendimiento depende de varios factores una parte del peso como no, recae sobre el hardware de la máquina (RAM, HDD…). Otra parte, también recae sobre el tipo de sistema operativo que hemos instalado en el dispositivo o de otros muchos factores como si tenemos muchos procesos ejecutándose simultáneamente, etc. Otro factor a tener en cuenta son que los procesadores actuales soportan varios procesos a la vez en paralelo y lo que puede ralentizar un parte la ejecución el resultado de una operación.

Cada ejecución de un programa, por tanto, es independiente y puede dar un tiempo de ejecución distinto en función de todo lo que acabamos de comentar (con diferencias que usualmente suelen oscilar solamente algunos milisegundos).

Ante el caso que seamos nosotros los que desarrollamos dicho software, el rendimiento se verá en parte dictaminado por las pequeñas decisiones que tomamos cuando nos ponemos a programar.

Un ejemplo de ello puede ser el uso de muchos ifs ¿Pero cuál es el problema? ¿Qué hay de malo en ello? Cuando concatenamos ifs constantemente y tenemos que evaluar una a una TODAS las condiciones, lo que provoca que usualmente el rendimiento de nuestros programas sea menos eficiente.

Si nos centramos en el ejemplo que hemos visto anteriormente y asignamos un valor de 3 en la nota ¿Qué sentido tiene ejecutar la segunda condición? ¿Si siempre que sea 3 no va a entrar en ella?

¿Tiene sentido analizar la condición de aprobado si ya hemos entrado en la de suspendido? La respuesta claramente es NO.

Para demostrarlo, hemos diseñado un programa que ejecuta 5000 veces varios bloques de instrucciones con el objetivo de analizar el rendimiento de trabajar con ifs simples (los unidireccionales que acabamos de ver) frente a otras alternativas que veremos posteriormente (if-else, if-else if-else).

Con este programa el objetivo es analizar los milisegundos (ms) que tardan en ejecutarse las instrucciones en función de las pequeñas decisiones que hemos ido tomando durante el desarrollo de dichos programas. Con la finalidad de obtener el performance (rendimiento) de cada uno de ellos para conocer cuál de ellos es más óptimo. Vamos a ver dichos resultados:

2.8) Estructura condicional IF-ELSE (Bidireccional) 🔝

En el if simple (el unidireccional) hemos aprendido como ejecutar un bloque de código cuando la condición es true y, por tanto, nuestra estructura condicional tiene un solo “camino”.

Un if-else es similar al if que acabamos de ver, pero ante el caso tendremos dos bloques. Uno para cuando la condición sea true y otro para cuando la condición sea false.

Vamos a ver un ejemplo:

El resultado de esta operación será el siguiente:

2.9) La ley del “70% 30%”, como organizar las estructuras condicionales 🔝

Usualmente, cuando trabajamos con ifs no sabemos si una condición se va a dar con más frecuencia que otra. Pero cuando sí que sabemos que es más posible que se dé una condición sobre otra es recomendable ponerla primero ya que el rendimiento será mayor. Por ejemplo, que el 90 % de los alumnos aprueban el curso, es más aconsejable utilizar dicha condición en el primer bloque. Vamos a verlo:

El resultado en este caso si ejecutamos el programa el resultado será el siguiente:

¡Aunque la diferencia es muy poco, 284 milisegundos eso que nos podríamos llegar a ahorrar!

2.10) Estructura condicional IF-ELSE IF- ELSE (Tridireccional o más…) 🔝

Ya hemos visto dos estructuras condicionales: if (unidireccional) y if-else (bidireccional). Ahora vamos a ver if-else if-else que sería la siguiente estructura junta un if junto a un if-else.

Vamos a ver un ejemplo:

Como la variable number tiene como valor 55, se ejecutará el primer bloque y el resultado será el siguiente:

Si ponemos -25, se ejecutará el bloque central:

Y finalmente, si ponemos 0, se ejecutará el último bloque:

Es muy importante matizar que el bloque central que está entre el if y el else (el else if) , se puede llegar a introducir repetidas veces.

Vamos a ver un ejemplo:

El resultado será el siguiente:

Y de paso hemos aprovechado para ver un if con múltiples condiciones y con los operadores && (Y) y || (O).

2.11) Estructura condicional operador ternario/condicional (“bidireccional” en principio) 🔝

Vamos a ver otra forma alternativa a la estructura de un if-else, el conocido como operador ternario/condicional (bidireccional). La estructura es la siguiente:

Aquí os dejo el código:

El resultado será el siguiente:

Por tanto, en el operador ternario tenemos dos caminos (por tanto, es bidireccional) y analiza la condición retornado el primer bloque si es true y el segundo ante el caso de que la condición sea false.

ℹ ️ —Aunque no lo hemos visto aún, ya que lo veremos más abajo, el operador condicional también puede trabajar sobre return.

2.12) Desmontando el mito que el operador condicional solo puede ser bidireccionalidad 🔝

Aunque la gran mayoría de usos del operador ternario suelen emplearse para realizar estructuras bidireccionales. Existe la posibilidad de aumentar estás estructuras. Vamos a ver un ejemplo:

En este caso tenemos tres condiciones y lo que hacemos es concatenar el operador ternario varias veces en el caso que es false, para poder realizar múltiples combinaciones. En el caso del ejemplo al poner 15 años de edad, el operador nos retorna que tenemos que ir ¡Al cole!

Si fuéramos mayores que 18 y menores que 65 nos mandaría a trabajar y si fuéramos mayores de 65 nos diría que no podemos trabajar.

2.13) Operador condicional SWITCH 🔝

Hasta ahora hemos visto estructuras condicionales (if, if-else, if-else if-else y operador ternario) en las que analizábamos una (o con varias) condiciones para finalmente obtener un valor trueor false. Pero existen un tipo de estructura condicional switch que no trabaja así. Su manera de trabajar es totalmente distinta a lo hemos visto hasta ahora.

ℹ ️ — En switch, podemos usar solo un valor específico y no se puede usar para un rango de valores o para condiciones que involucran múltiples variables.

Vamos a ver un ejemplo en el que queremos imprimir el día de la semana que estamos en función del número que introducimos en la variable day (1,2,3…):

El resultado será el siguiente:

Si nos fijamos, tenemos un break al final de cada bloque ¿Pero qué pasaría si quitamos dicho break de cada uno de estos bloques? Vamos a verlo:

El break hace que una vez dentro de una opción, el flujo del programa “rompa”. Es decir, salga del bloque de instrucciones que estamos ejecutando evitando así que se ejecuten el resto de cases que tenemos en su parte inferior. Vamos a ver un ejemplo sin breaks:

ℹ ️ — Para evitar esto, tendríamos que poner un break antes de finalizar cada uno de los cases tal y como hemos visto en el ejemplo 1.

2.14) Analizando el funcionamiento de la condición en SWITCH 🔝

En switch, solamente podemos usar un solo valor en específico (o en el mejor de los casos en las últimas versiones de Java una serie de valores en específico).

Una característica importante de switch es que no soporta los tipos de datos boolean. Pero si los String ,char ,int o enum . Vamos a ver qué pasa si intentamos trabajar con un boolean en un switch:

ℹ ️ — Por tanto, en switch no podemos utilizar condiciones que nos retornen true or false.

Cuando el intérprete de la JVM interpreta la expresión que introducimos dentro de los paréntesis del switch lo que hace es buscar un case que contenga el mismo valor en el identificador (es decir, en el nombre o número que introducimos junto a la palabra case) e internamente analizar si alguna de esas constantes (los valores del case) cumple dicha condición.

El valor que introducimos como identificador en cada uno de los cases se almacena en una lista de constantes, para posteriormente compararse con el valor que le hemos pasado en la condición como variable o expresión entera:

Por ejemplo, ante un case con valor 1, el identificador será el 1. Si el valor introducido entre los paréntesis del switch corresponde a 1, ejecutará ese case y el resto los cases del switch a partir de que un valor coincida para finalmente o encontrarse con un break (lo que hace que salga del switch) o bien continuando la ejecución de todos los cases restantes y continuando el flujo de ejecución del resto del programa.

Para saber lo que hace el switch, vamos a ir a debuggear el código y pulsaremos sobre watch encima de la condición del switch:

Y aquí podemos escribir la condición que si es true ejecutará el case:

Al evaluar la expresión de switch, el intérprete busca una constante con el mismo valor. Si la encuentra, ejecuta las sentencias asociadas a esta constante hasta que tropiece con un break. La sentencia break finaliza la ejecución de esta estructura.

Ante el caso que no encuentre ninguna constante que coincida con la expresión, busca la línea default. Si existe, ejecuta las sentencias que le siguen. Además de ello, en este ejemplo ejecutamos el código con un char como tipo de dato. Aunque podríamos utilizar cualquier otro tipo de dato a excepción del boolean. Vamos a verlo:

El flujo de ejecución entrará en el default, ya que no existe ‘*’ y, por tanto, al no tener break el resultado será el siguiente:

Si ponemos los breaks, salimos del bloque de instrucción del case y solamente nos aparece el error:

ℹ ️ — La sentencia default es opcional y equivaldría a un else de un if-else.

2.15) Ejemplo de SWITCH con cascada de CASES 🔝

En determinados puntos de nuestro código, el ejecutar un switch sin romper los cases con break provocando lo que se conoce como “cascada de cases”, puede llegar a tener sentido. Vamos a ver un ejemplo:

El resultado será el siguiente:

2.16) Estructura de control SWITCH mejorada (disponible a partir de la versión 14 de Java) 🔝

A partir de Java 14, es posible poner un solo case con múltiples opciones además de la sintaxis de flecha -> que nos permitirá ejecutar una sola línea. Vamos a ver un ejemplo:

El resultado será el siguiente:

2.17) SWITCH dentro de SWITCH 🔝

También existe la posibilidad de poner un switch dentro de otro switch. Vamos a ver un ejemplo:

El resultado será el siguiente:

2.18) ¿Cuándo usar un SWITCH frente a las otras alternativas (IF, IF-ELSE, IF-ELSE IF-ELSE o TERNARY OPERATOR)? 🔝

ℹ ️ — switch se encarga de estructurar una selección múltiple. Por ejemplo, si comparamos switch con if-else nos damos cuenta que if-else solo nos permite utilizar dos alternativas/caminos, por lo que maneja un número finito de posibilidades.

Además, switch es ideal cuando trabajamos con valores. En cambio, if-else... (o alguna de sus alternativas) cuando trabajamos con condiciones.

2.19) Enfrentando a IF-ELSE con SWITCH para analizar su performance 🔝

Si analizamos el rendimiento de ambos, podemos ver que para determinadas situaciones switch se adapta mejor que if-else... (o alguna de sus alternativas). Vamos a verlo:

Si ejecutamos el código, vemos que el 🐴 “caballo ganador” 🐴 en este caso es SWITCH:

2.20) Ejercicios de estructuras condicionales 🔝

EJERCICIO 1: A PARTIR DEL SIGUIENTE CÓDIGO QUE SIMULA EL LANZAMIENTO DE UNA MONEDA AL AIRE:

REALIZA UN PROGRAMA QUE MUESTRE:

• CRUZ CUANDO EL VALOR SEA 0 Y CARA CUANDO EL VALOR SEA 1.
• PRIMERAMENTE, REALIZA EL EJERCICIO SOLAMENTE CON IFS (UNIDIRECCIONALES)
• LUEGO, REALIZA EL EJERCICIO SOLAMENTE CON LA ESTRUCTURA CONDICIONAL IF-ELSE
• POSTERIORMENTE, REALIZA EL EJERCICIO CON LA ESTRUCTURA CONDICIONAL DEL OPERADOR TERNARIO

EJERCICIO 2: A PARTIR DE VALOR DE UNA VARIABLE EN LA QUE ASIGNAMOS UNA TEMPERATURA MEDIA DE UN PAÍS. REALIZA UN PROGRAMA QUE MUESTRE LAS SIGUIENTES TEMPERATURAS:

• PRIMERAMENTE, REALIZA EL EJERCICIO SOLAMENTE CON IFS ANIDADOS.
• POSTERIORMENTE, REALIZA EL EJERCICIO CON IF-ELSE IF-ELSE

EL RESULTADO CUANDO PONGAMOS UNA TEMPERATURA DE 26.5 GRADO SERÁ EL SIGUIENTE:

EJERCICIO 3: CREA UN PROGRAMA CON (SWITCH CASE) QUE CUANDO INTRODUZCAMOS EN UNA VARIABLE LOS VALORES NÚMERICOS DEL 1 AL 9 LO IMPRIMIRÁ EN TEXTO. POR EJEMPLO, SI INTRODUCCIMOS UN 9 LO MOSTRARÁ DE LA SIGUIENTE MANERA:

EJERCICIO 4: REALIZA EL SIGUIENTE IF-ELSE IF-ELSE UTILIZANDO EL OPERADOR TERNARIO.

3. Estructuras repetitivas/iterativas

3.1) Introducción a las estructuras repetitivas 🔝

Para explicar la idea que hay detrás de las estructuras repetitivas, vamos a imaginar a un atleta dando vueltas sobre una pista de atletismo…

Esa misma puede ser la idea que nos ayude a entender rápidamente el concepto de una estructura repetitiva. En este caso, el atleta es el flujo de nuestro programa, y la pista de atletismo sobre la que dará vueltas nuestro bloque de instrucciones del bucle.

ℹ ️ — Aunque cada estructura repetitiva tiene unas peculiaridades continuará dando vueltas hasta que complete la condición.

Por tanto, en programación, los bucles no son nada más y nada menos que un bloque de instrucciones que se ejecuta varias veces, hasta que la condición asignada a dicho bucle deja de cumplirse. Y entonces, el flujo de ejecución continua su ejecución (si existen más instrucciones).

3.2) Estructura repetitiva FOR 🔝

Imaginaos que sois Bart Simpson y os castigan por gritar que el instituto se está quemando.

El castigo en si consiste en escribir 100 veces: I will not yell “fire” in a crowded classroom (No voy a gritar “fuego” en un salón de clases abarrotado) nosotros lo vamos a hacer…Pero de una forma mucho más rápida, con un bucle for. Vamos a ver el ejemplo:

El resultado será el siguiente:

3.3) Estructura de una condición de un FOR 🔝

Dentro un bucle for, tenemos 3 partes importantes que están separadas por un ; entre ellas. Vamos a verlas:

• La variable en la que indicamos el valor inicial del bucle, ya que podemos empezar con 0, 1, -50…

Si nos fijamos, como decimos que la variable i vale 0, el primer valor que se muestra es ese:

Si queremos que empiece en el 1, por ejemplo, podemos modificar la variable y la condición:

Y aunque es recomendable ponerla dentro del bucle como hemos hecho en los ejemplos anterior, ya que de esta forma se asocia claramente a dicho bucle de una forma más visual. Vamos a ver cómo podemos realizar lo mismo si sacamos fuera del bucle la variable:

ℹ ️ — Habitualmente utilizamos la letra i dentro de los bucles ya que es una abreviatura de iterrator, pero podemos utilizar cualquier otra letra y/o palabra .

• La condición (que está acompañada por un ; tanto a la izquierda como a la derecha) es la encargada de una vez el flujo de nuestro programa llegue al ciclo, analizar si se ejecutará nuestro bucle. Y, además, una vez se está ejecutando analizar cuando se detendrá nuestro bucle. Por lo que en cada iteración (vuelta) analizará si tiene que continuar ejecutándose o no en función del resultado true or false que nos devuelva dicha condición.

Si no tenemos condición el bucle será infinito:

De hecho, si vamos al administrador de tareas (haciendo click en el botón derecho de Windows):

Podemos ver que el procesador va al 100 % (está sprintando) lo que quiere decir que estamos utilizando el máximo de sus recursos. El principal culpable de esto es nuestro bucle infinito:

Para detener un bucle infinito pulsamos sobre el botón de Terminate lo que detendrá el flujo de ejecución de nuestro programa:

• La tercera parte es encarga de incrementar la variable que hemos definido en el primer bloque. Aunque puede ir vacía, usualmente se utiliza para incrementar o decrementar el bucle.

Si, por ejemplo, en este caso en concreto decrementamos la i el bucle for será infinito. Ya que i tiene un valor de -3 y si le seguimos restando (-4,-5,-6...) por lo que nunca llegará a ser 0.Y, por tanto, nunca llegará a cumplirse la condición de salida. Vamos a verlo:

En este ejemplo, vamos a ver como incrementar en + de 1 un bucle. Imaginaos que queremos mostrar los números que sean pares hasta el 10 (con el 10 incluido). Una de las formas más sencillas de hacer esto es:

Si ejecutamos el bucle, podemos ver que el resultado es el siguiente:

Existe una posibilidad de sacar el incrementador de su posición natural en un for para meterlo dentro del código. El problema es que, aunque esto se puede hacer y tiene sentido en determinadas circunstancias si no tiene un motivo lógico es recomendable dejarlo en el interior. ¡Ya que si lo borramos el bucle volverá a ser infinito!

Otra cosa a tener en cuenta ante una situación así es la posición del incrementador en nuestro código. Por ejemplo, si lo subimos encima del mensaje por pantalla. Podemos ver que:

ℹ ️ — Podemos poner varios incrementadores durante la ejecución de nuestro bucle for.

Un ejemplo de ello, es el incrementar 1 antes de la ejecución con ++i y posteriormente al finalizar el bloque i++:

3.4) FOR dentro de FOR 🔝

Un ejemplo de un doble bucle for puede ser el siguiente:

El resultado será el siguiente:

3.5) Estructura de repetición ForEach (para cada), disponible a partir de la versión 5 de Java 🔝

En las últimas versiones de Java (a partir de la versión 5 de Java), existe un bucle mejorado conocido como forEach.

forEach, nos proporciona la forma más sencilla de iterara a través de los distintos elementos de nuestra colección o array.

Y se utiliza principalmente cuando tenemos la necesidad de recorrer todos los elementos de forma secuencial. Ya que es bastante inflexible. Lo que por una parte nos impide conocer el elemento sobre el que está trabajando, ya que no tenemos un índice como en otros bucles, pero también reduce la probabilidad de errores cuando trabajamos con varios bucles, etc. Vamos a ver un par de ejemplos:

El resultado mostrará los elementos uno a uno por pantalla:

Si repetimos el ejemplo que hemos visto anteriormente en el caso del doble for, podemos ver que se reduce simplifica mucho el código:

El resultado como veis es un código mucho más limpio que el anterior, mucho más sencillo de leer y además es mucho más difícil equivocarse en estos tipos de bucles que en los for tradicionales:

3.6) Estructura de control WHILE 🔝

La estructura repetitiva while (MIENTRAS) nos permite ejecutar algo a partir de una condición booleana.

Vamos a ver su estructura básica:

Si nos fijamos en un bloque de instrucciones en el que aplicamos la estructura de control while, si ponemos un true, sin ninguna condición que modifique esto se genera un bucle infinito.

En cambio, si la condición retornará un false, ni siquiera ejecutaría las instrucción del while.

El bucle while se asemeja mucho a un if con repetición, es decir, que se ejecuta múltiples veces y no una como pasa con los ifs.

Aunque el bucle while no tiene contador, nosotros podemos definir una variable fuera del bucle sin problema para controlar identificar sobre que iteración estamos ejecutando. Vamos a ver un ejemplo:

El resultado será el siguiente:

O inclusive para determinados casos podemos hacer algo que me parece mucho más eficiente. Ya que, con una sola variable, podemos controlar cuando salir y a su vez identificar sobre que iteración nos encontramos:

El resultado sería el siguiente:

3.7) Estructura de control DO WHILE 🔝

Bueno, llevamos a la última estructura de repetición, el bucle do while. (Haz — MIENTRAS). La diferencia entre while y do-while radica en que while se ejecuta solamente cuando la condición es true. En cambio, do-while, se ejecuta como mínimo 1 vez independientemente de si la estructura es true or false. Vamos a ver un ejemplo:

Pese a que la condición es false, si ejecutamos el código se ejecuta una vez el bloque:

En cambio, si lo ponemos a true, podemos ver que se ejecuta infinitas veces:

Hasta ahora, en algunas ocasiones hemos realizado la comparativa de rendimiento entre varias estructuras de control. En este ejemplo de do-while, vamos a ir un paso más allá y vamos a ver cuántas instrucciones es capaz de procesar nuestro bucle do-while en un segundo.

Vamos a ver el ejemplo:

El resultado será el siguiente:

¡En total 270978 iteraciones en 2 segundos!

3.8) Ejercicios sobre estructuras iterativas 🔝

EJERCICIO 1: REALIZA UN BUCLE CON FOR Y CON WHILE QUE MUESTRE SOLAMENTE LOS NÚMEROS QUE SEAN DIVISIBLES POR 3.

EJERCICIO 2: REALIZA UN BUCLE QUE EJECUTE UN MENSAJE TANTO SI SE CUMPLE LA CONDICIÓN COMO SI NO Y LUEGO SE EJECUTE 3 VECES. EL EJERCICIO SE DEBE REALIZAR CON DO WHILE Y CON FOR.

4. Instrucciones de salto: break y continue

4.1 Presentación de las instrucciones de salto 🔝

Las instrucciones de salto nos permiten forzar la salida de un bucle. Estás sentencias son:

• Break: nos permite salir completamente del bucle
• Continue: nos permite salir de la iteración en la que nos encontramos actualmente y saltar directamente a la siguiente:

Este tipo de sentencias deben ir dentro de algún condicional (por ejemplo dentro de un if) ya que sino el bucle sería infinito y no se ejecutaría el resto de nuestro programa.

4.2 Ejemplo de uso de las instrucciones de salto break y continue 🔝

Vamos a ver un ejemplo con break y continue:

El resultado será el siguiente:

Si nos fijamos, continue salta el ciclo en concreto de ejecución desde el punto en el que esté situado en adelante. En cambio, break sale del bucle.

4.3) Ejercicios con instrucciones de salto 🔝

EJERCICIO 1: REALIZA UN WHILE Y SAL DEL BUCLE CUANDO ESTÉS EN LA 3ª ITERRACIÓN.

EJERCICIO 2: REALIZA UN BUCLE FOR QUE IMPRIMA UN TEXTO ACOMPAÑADO DEL NÚMERO DE LA ITERACCIÓN Y SALTA SOLAMENTE LA 5ª ITERRACIÓN

5. Estructura secuencial y programación funcional

5.1) Introducción a la estructura secuencial 🔝

Aunque más arriba ya hemos hablado el comportamiento natural del código, si no se utiliza otra estructura por defecto, nuestros algoritmos utilizan la estructura secuencial. Es decir, primero ejecuta la instrucción1, luego la instrucción2…

Realmente hasta ahora todo nuestro código mayoritariamente lo hemos trabajado en el método principal (el método main). Y aunque su flujo de trabajo se ejecuta de forma secuencial, actualmente lo estamos haciendo en un bloque de código (todo apelotonado) cada vez más grande dentro del método main.

5.2) Introducción a la programación funcional 🔝

Por lo que vamos a explicar cómo romper todo esto en clases distintas y en métodos tanto dentro de la propia clase Main.java como en otras clases. Lo que se conoce como programación funcional ¡Vamos a ver cómo sería en la práctica!

Los métodos que no son nada más y nada menos que funciones que pertenecen a una clase y que nos permiten subdividir el código contenido dentro de un bloque {} en varios bloques con la finalidad de reducir la magnitud de nuestros algoritmos, poder reutilizarlos, poder leerlos mejor, etc.

5.3) Programación funcional: Creando métodos void (sin return) en la misma clase 🔝

Vamos a ver un ejemplo de cómo crear un método en la propia clase Main.java de dos formas distintas:

Main.java

El resultado de la ejecución será el siguiente:

Si lo analizamos más a detalle, podemos ver que:

• Forma 1 (sin static): necesita realizar la creación del objeto para poder utilizar sus métodos. Aunque la palabra más correcta para referirnos al proceso de crear un objeto en una clase es instaciar, que es sacar un objeto de la Clase. La clase sería el molde del que sacamos dichos objetos.
• Forma 2 (con static): no necesita realizar la creación (instanciación) del objeto para poder utilizar los métodos. Por lo que podemos acceder directamente a ellos.

5.4) Programación funcional: Creando métodos (sin void) con return en la misma clase 🔝

El return nos permite que un método nos retorne algo. En el ejemplo anterior, usábamos void (vacío) ya que no retornábamos nada con un return. Sino que lo mostrábamos por pantalla con un System.out.println(). Vamos a analizarlo:

Pero ahora, nuestra intención ha cambiado y sí que vamos a retornar algo, por tanto, tendremos que cambiar el void por el tipo de dato que vamos a retornar en este caso String en ambos métodos. Vamos a verlo:

Si ejecutamos nuestro código, veremos que no muestra nada por pantalla:

Esto se produce debido a que cuando llamamos al return retornamos un valor, pero no lo mostramos por pantalla. Si queremos mostrarlo por pantalla, debemos de realizar lo siguiente:

Si analizamos que ha cambiado, podemos ver que ahora hemos englobado la llamada del método que nos retorna un String con un System.out.println() que nos permitirá mostrar por pantalla lo que nos retorna dicho método:

El resultado ahora si, será el mismo que el que teníamos anteriormente:

Pero obteniendo algunos beneficios que nos proporciona el trabajar con returns, ya que nos permitirá pasar como parámetro del valor de un método a otro método, entre otros beneficios.

5.5) Programación funcional: Creando métodos void (sin return) en la misma clase 🔝

Aunque ya hemos visto cómo realizarlo desde una misma clase, ahora vamos a ver cómo realizarlo desde otra clase. Para ello, primeramente, vamos a crear una clase nueva:

Y cuando nos salte el asistente de creación de clases, le pondremos a la clase como nombre Saludar:

Una vez creada la nueva clase, el proyecto tendrá dos clases Main.java (la que contiene el método main que arranca la aplicación) y Saludo.java. Vamos a ver la estructura:

Posteriormente, moveremos los dos métodos anteriores que teníamos en la clase main dentro de la clase saludo. Y eliminamos las llamadas a los métodos anteriores. Ya que, al moverlo cambiará la forma de llamarlos. Quedando ambas clases de la siguiente manera:

Saludo.java

Main.java

Si analizamos la relación que tienen ambas clases, podemos ver que aunque cambian cosas, el comportamiento es similar:

Esto se produce ya que en Java si utilizamos la palabra clave static, podemos definir un método, una clase, un bloque o una variable. Lo que nos permitirá indicarle a Java que podemos acceder a ella sin necesidad de instanciar su objeto.

Finalmente, vamos a mostrar cómo aplicar el operador ternario que ya vimos anteriormente dentro de un método en la zona de return para poder devolver varias alternativas en función de lo que se introduzca:

El resultado será:

5.6) Ejercicios de programación funcional 🔝

EJERCICIO 1: REALIZA UNA CLASE PRINCIPAL LLAMADA MAIN QUE CONTENDRÁ DOS MÉTODOS (DENTRO DE LA MISMA CLASE) CUYOS MÉTODOS TENDRÁS POSTERIORMENTE QUE INSTANCIAR. LOS MÉTODOS DEBEN CUMPLIR LAS SIGUIENTES CONDICIONES:

• GETNOMBRE: MOSTRARÁ POR PANTALLA TU NOMBRE SIN SER PASADO COMO PARAMETRO. ESTE MÉTODO DEBE NO RETORNARNOS NADA (Y, POR TANTO, DEBERÁ UTILIZAR VOID Y NO RETURN).
• GETCODIGOPOSTAL MOSTRARÁ POR PANTALLA TU CÓDIGO POSTAL. DICHO CÓDIGO POSTAL SERÁ PASADO COMO PARAMETRO. ESTE MÉTODO DEBE RETORNARNOS EL CÓDIGO POSTAL (Y POR TANTO, DEBERÁ UTILIZAR VOID Y NO RETURN). Y FINALMENTE, IMPRIME (CON LA CLASE SYSTEM.OUT.PRINLNT) EL CÓDIGO POSTAL POR PANTALLA.

EJERCICIO 2: REALIZA LO MISMO QUE HEMOS REALIZADO ANTERIORMENTE, PERO PASANDO DICHOS MÉTODOS A UNA NUEVA CLASE LLAMADA USUARIO.

EJERCICIO 3: REALIZA UN PROGRAMA QUE SOLAMENTE DEVUELVA UNA CADENA DE TEXTO SI EL RESULTADO DE DICHA CADENA ES JAVA. EN CASO CONTRARIO, DEVOLVERÁ UN NULL.

6. ENTRADA DE DATOS CON SCANNER

6.1) ¿Para que utilizamos la clase Scanner? 🔝

La clase Scanner es una sencilla clase que nos permite leer introducir datos en nuestros programas de Java desde una CMD. Scanner, por tanto, se encarga de proporcionarnos un conjunto de métodos cuya finalidad es el permitirnos leer valores de entrada de distintas fuentes.

6.2) Importando librería necesaria para trabajar con Scanner 🔝

Aunque la podemos auto importar al realizar la instanciación (declaración de un objeto a partir de una clase) del objeto Scanner (lo veremos en el siguiente apartado), la librería encargada de realizar los imports para que nuestra clase Scanner funcione correctamente será:

import java.util.Scanner;

Aunque podríamos importar todo el paquete al completo utilizando un * quedando la importación de la siguiente manera import java.util.* lo que es totalmente desaconsejable ya que importar todas las clases pertenecientes al package java.util entre las que se incluiría Scanner provocando que aumentará el tamaño de nuestros programas, además de empeorando el performance (rendimiento).

6.3) Aprendiendo a usar la API de Java 🔝

¿Cómo sabemos que tenemos que importar esa librería? Para ello, vamos a la versión de la API de Java correspondiente a nuestra versión de Java. Por ejemplo, si utilizamos la versión 14 de Java, buscaremos la API de la versión 14 de JDK en Google (y así con cualquier otra versión que busquemos). Vamos a verlo:

Y vemos que nos aparecerá un buscador en el que buscamos la clase sobre la que vamos a trabajar en este caso Scanner:

Y, finalmente, si nos metemos en dicha clase, podemos ver el módulo, el package y la clase sobre la que trabaja. Además de obtener ejemplos, métodos de la clase y mucha más información:

6.4) Realizando el autoimport de Scanner 🔝

Una vez instanciamos la clase Scanner, y si no hemos realizado el import manualmente podemos ver que nos aparece una bombillita con un error, si pulsamos encima vemos que el intelligense nos recomienda realizar un import de la clase Scanner:

Por lo que bastará con pulsar encima para realizar la auto importación de la clase. Vamos a verlo:

6.5) Ejemplo de cómo capturar un String con Scanner 🔝

Vamos a ver como guardar una cadena de texto (String) desde Scanner y finalmente como mostrarlo por pantalla (con System.out.println()):

El resultado cuando arrancamos el programa será el siguiente:

Si nos fijamos mediante Scanner, hemos conseguido entrar datos en la terminal desde nuestro teclado y posteriormente trabajar con ellos. En este caso en concreto, los hemos imprimido por la consola.

6.6) Explicando cómo y porque utilizar el método close al finalizar el uso de Scanner 🔝

Aunque cuando utilizamos Scanner no estamos obligado a cerrarlo. Una vez hemos finalizado el uso de Scanner es recomendable cerrar la instancia mediante el uso del método close(). Lo que generará que nuestro código sea más rápido y eficiente impidiendo así que se pueda volver a usar la instancia que hemos creado anteriormente.

En caso de no cerrarlo, es posible que se nos muestren algunas advertencias (bombillas) que recomienden su cierre. Y que lo que no hemos hecho nosotros (cerrar la instancia de Scanner utilizando el método close) lo haga por nosotros el recolector de basura (garbage collector). Eso sí, lo hará cuando se finalice la ejecución del bloque y, por tanto, es mejor cerrarlos tan pronto como terminemos el trabajo que queremos realizar con la clase Scanner.

De hecho, si lo intentamos llamar a Scanner después de cerrar el método, podemos ver que no nos deja utilizarlo y que nos arroja una excepción:

Si ejecutamos el ejemplo, podemos ver que nos aparece que el Scanner está closed (cerrado) y que se ha producido una IllegalStateException:

Dentro de la API de Java, en Scanner además tenemos información de los métodos que podemos utilizar. En este caso vamos a meternos en el método close():

Podemos ver que, si utilizamos Scanner después de haberlo cerrado tal y como nos dice la documentación, nos genera una excepción:

¿Qué tendríamos que hacer aquí? Lo más recomendable es si queremos utilizar la instancia de Scanner varias veces es bajar el cierre de la instancia close() inmediatamente después de cerrar usarlo las dos veces. Vamos a verlo:

Evitando así que se genere la excepción:

6.7) Métodos a utilizar en función del tipo de dato que queremos capturar 🔝

En función del tipo de dato que vayamos a recibir por teclado, podemos

• nextInt() método para leer un valor int.
• nextLong() método para leer un valor long.
• nextShort() método para leer un valor short .
• nextDouble() método para leer un valor double.
• nextByte() método para leer un valor byte.
• nextBoolean() método para leer un valor boolean.
• nextLine() método para leer un String.

6.8) Protegiendo nuestro código de excepciones cuando trabajamos con Scanner 🔝

El principal problema que tenemos es que si por ejemplo ponemos que nos introduzcan un número entero (utilizando nextInt() como método de recepción) como en el siguiente ejemplo:

Tenemos dos caminos el que se introduce el camino esperado:

O el que no recibe el resultado esperado generado otra excepción:

Para solucionarlo podemos realizar lo siguiente:

Vamos a el resultante:

6.9) Ejercicios con Scanner 🔝

EJERCICIO 1: REALIZA UN EJEMPLO DE SCANNER CON TODOS LOS MÉTODOS SIGUIENTE:

• nextInt() método para leer un valor int.
• nextLong() método para leer un valor long.
• nextShort() método para leer un valor short .
• nextDouble() método para leer un valor double.
• nextByte() método para leer un valor byte.
• nextBoolean() método para leer un valor boolean.
• nextLine() método para leer un String.

EJERCICIO 2: REALIZA UN TAMAGOCHI QUE MUESTRE LAS SIGUIENTES OPCIONES:

• 1. SALUDAR
• 2. COMER
• 3. DORMIR
• 4. CANTAR
• 5. APAGAR TAMAGOCHI

Y QUE UTILIZANDO SCANNER CAPTURÉ EL VALOR INTRODUCIDO POR EL USUARIO E INTERACTURE CON EL. EL PROGRAMA DEBE SEGUIR FUNCIONANDO TANTO CUANDO EL USUARIO INTERACTUÉ UNA O VARIAS VECES CON EL TAMAGOCHI COMO CUANDO SE INTRODUZCA UN VALOR NO VÁLIDO. CUANDO SE INTRODUZCA UN VALOR INCORRRECTO, DEBERÁ MOSTRARSE UN MENSAJE POR LA CONSOLA EN ROJO DONDE APAREZCA QUE EL VALOR ES INCORRECTO Y PIDIENDONOS QUE INTRODUZCAMOS NUEVAMENTE UNA OPCIÓN. EN EL CASO DE QUE EL USUARIO APAGUÉ EL TAMAGOCHI (OPCIÓN 5) FINALIZAREMOS EL FLUJO DE EJECUCIÓN DE NUESTRO PROGRAMA.

AUNQUE NO ES OBLIGATORIO, SI QUERÉIS, PODÉIS TRABAJAR CON DIBUJOS ASCIIS QUE NOS PERMITIRÁN REALIZAR COSAS COMO LA SIGUIENTE

───▄▀▀▀▄▄▄▄▄▄▄▀▀▀▄───
───█▒▒░░░░░░░░░▒▒█───
────█░░█░░░░░█░░█────
─▄▄──█░░░▀█▀░░░█──▄▄─
█░░█─▀▄░░░░░░░▄▀─█░░█
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█
█░░╦─╦╔╗╦─╔╗╔╗╔╦╗╔╗░░█
█░░║║║╠─║─║─║║║║║╠─░░█
█░░╚╩╝╚╝╚╝╚╝╚╝╩─╩╚╝░░█
█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█