2024-11-11-Programacion | Mediateca de EducaMadrid

No sé, ¿alguna otra consulta en cualquier ámbito? Aunque sea fuera del temario nuestro o en particular del temario. No, no tenéis nada. 00:00:01

Vale, pues nada, vamos a dar una vuelta un poco a los contenidos del tema 3 00:00:17

El otro día estuvimos rematando, aunque ya tenéis abiertos los contenidos de este tema 00:00:22

Algunos asuntos que nos habían quedado pendientes del tema 2 en la tutoría anterior 00:00:26

Y quedó grabado, claro, en la tutoría 00:00:31

Y hoy, bueno, pues vamos a repasar un poco lo del tema 3 00:00:34

Tema 3, tenemos esta semana por delante 00:00:37

Y la semana que viene, todavía, creo que se abre el martes de la siguiente semana 00:00:41

con lo cual el lunes todavía podríamos hablar sobre asuntos del tema 3 00:00:46

y si hoy más o menos lo finiquitamos 00:00:51

pues hacemos algunos ejercicios la semana que viene 00:00:54

o dudas que podáis tener por ahí. 00:00:57

En este tema 3 habla de las estructuras de control. 00:01:01

El otro día habíamos hecho una pequeña referencia a ello 00:01:08

y decíamos que cuando trabajamos sobre un proyecto 00:01:12

la ejecución del proyecto en principio 00:01:15

pues sigue una secuencia ordenada de arriba a abajo pues empezamos en el método main cualquiera 00:01:17

ese punto de inicio de cualquiera de nuestros proyectos pues la ejecución se va haciendo de 00:01:24

arriba abajo es secuencial pero sí que es cierto que podemos poner en nuestros códigos dos dos 00:01:28

tipos de estructuras de control que son típicas de cualquier lenguaje de programación que son las que 00:01:37

evaluan una condición y hace que se ejecute ese código o no, con lo cual 00:01:43

podamos ir dando saltos en esa ejecución que por lo normal va a ser secuencial 00:01:48

o que nos toque hacer una actividad repetitiva, una iteración. 00:01:52

En este contexto, pues imaginaros que tenemos que imprimir las facturas 00:01:59

de todos nuestros clientes. Tenemos en una base de datos mil clientes, 00:02:04

Entonces, en lugar de poner impresión de la factura número 1 y a continuación impresión de la factura número 2 y impresión de la factura número 3 y así hasta 1000 con unos puntos suspensivos por aquí, lo que podríamos hacer es hacer el código propio y general de la impresión de una factura y hacer un bucle que esté dando vueltas a ese mismo código y en lugar de replicar 1000 veces ese código, pues tenerlo escrito una sola vez y obligar a que se ejecute 1000 veces. 00:02:10

con la ventaja incluso de que si el número de veces que tenemos que ejecutar un determinado código 00:02:40

fuese 1000, pues podríamos hacerlo de esta forma, indicarlo aquí en una variable al principio del código 00:02:50

o incluso leerlo a través de escáner desde teclado y ejecutarlo tantas veces ese mismo código 00:02:57

como veces estuviésemos en una variable, bien puesto aquí o leído por escáner. 00:03:05

Si lo leemos por escáner, fijaros que la ejecución de un mismo código 00:03:10

lo podríamos adaptar a diferente número de facturas en cada una de las ejecuciones. 00:03:13

Y si no existiese la posibilidad de tener estos bucles o ejecuciones iterativas, 00:03:21

lo que tendríamos que hacer es modificar cada vez el código fuente 00:03:26

para que tuviera un número de impresiones en este contexto del ejemplo que estamos hablando 00:03:29

que nos planteásemos en cada una de las ejecuciones. 00:03:34

Bueno, nada como ponernos a explicar cómo funciona, pues vamos a ello. 00:03:39

Mirad, entonces, las estructuras de control son de dos tipos, 00:03:43

o bien de selección o bien de iteración. 00:03:47

Si ponemos la tilde en un sitio, la ponemos en otro o en ninguno. 00:03:59

Cuando son de selección, esta sintaxis, aunque pueda variar un poquito 00:04:02

en cuanto a la forma de escribirlo, por lo menos el tipo de instrucción es común 00:04:08

prácticamente a cualquier lenguaje de programación. Hay cosas que pueden ser 00:04:13

particulares de Java, pero esto sí que aparece en todas partes. 00:04:16

Entonces, el ar de selección, que se ejecuta un código 00:04:21

en función de si una condición es cierta o no, 00:04:24

la indicamos, bueno, existen dos tipos de estructuras, la estructura 00:04:28

if, que la podemos completar con algún apartado 00:04:32

más, ahora lo vemos, y la estructura switch. Vamos primero con la if. 00:04:37

Cuando trabajamos con una sentencia 00:04:44

del tipo if, if en inglés condición, lo que hacemos 00:04:46

es poner aquí entre los paréntesis la condición que queremos evaluar. 00:04:50

Y en caso de que esta condición sea cierta, se ejecuta el código que está 00:04:54

en su ámbito, que podemos marcar un ámbito entre llaves. 00:04:58

Entonces si ponemos aquí, por ejemplo, system out 00:05:02

.println 00:05:05

escribe 00:05:07

porque es cierto 00:05:15

fijaros que aquí estamos poniendo 00:05:17

bueno, todavía no tenemos 00:05:20

una gran variedad de posibilidad de instrucciones 00:05:21

porque no las hemos dado todavía 00:05:24

así que sabemos como escribir por pantalla 00:05:25

pues bueno, vamos a poner aquí 00:05:28

este código, pero tened en cuenta que 00:05:30

en el ámbito de elif, entre la llave de apertura 00:05:31

y cierre, podría estar cualquier código 00:05:34

que nosotros programásemos 00:05:36

para dar respuesta 00:05:38

a nuestro algoritmo. Vamos a poner aquí dos instrucciones, escribe esto es cierto, segunda línea. 00:05:40

Entonces, en la ejecución de nuestro código, a la que va haciendo la ejecución de forma secuencial 00:05:50

buscando instrucciones de arriba a abajo, si lo que se encuentra es una estructura de control 00:05:57

de tipo if, lo que hará será validar lo que hay aquí, que puede tener dos posibles valores, 00:06:03

o bien verdadero o bien falso en true o false que viene a ser los dos posibles valores que 00:06:09

tienen las variables primitivas de tipo boolean que habíamos hablado estos días atrás la forma 00:06:16

más fácil de comprobar si esto es cierto pues podríamos poner aquí un true directamente 00:06:24

entonces esto pues porque así está definido y no hay más condición que evaluar pues es verdadero 00:06:29

entonces como esto es verdadero se nos ejecutaría este código si ponemos damos a la ejecución 00:06:36

fijaros como por aquí efectivamente ejecuta el código que hay dentro del ámbito del if y nos 00:06:44

lo muestra por pantalla o sea que poner aquí fuera del if le damos damos como es cierto se ejecuta el 00:06:50

código que hay en el ámbito y luego este que ya está fuera del ámbito se ejecutará sí o sí 00:07:06

si la instrucción es 00:07:11

falsa, es decir 00:07:14

lo que se evalúa dentro de los paréntesis 00:07:16

y ser falso, la forma más clara 00:07:17

de hacerlo falso es directamente ponerlo así 00:07:19

fijaros que en esta ejecución 00:07:21

por ser falso 00:07:24

lo que está dentro del ámbito del if no se ha ejecutado 00:07:25

y sí que se ejecutaría este en cualquier caso 00:07:28

tanto cuando es cierto como cuando es falso 00:07:30

porque son instrucciones que están fuera 00:07:31

del ámbito del if 00:07:33

antes de avanzar con más cosas del if 00:07:34

decimos que aquí tenemos la condición 00:07:39

que estamos evaluando 00:07:42

y que lo que se ejecuta, en caso de ser cierto, es lo que hay dentro del ámbito del if, 00:07:43

que es lo que hay entre sus llaves. 00:07:49

Acordaros de los ámbitos que hablábamos otras veces. 00:07:52

El ámbito del método main sería entre sus llaves. 00:07:55

Fijaros cómo me lo marca aquí Eclipse, de aquí a aquí. 00:07:57

El ámbito de la clase serían estas otras llaves. 00:08:01

Pues el ámbito del if serían estas. 00:08:04

tenemos con con if aunque normalmente siempre se aconseja poner un ámbito con unas llaves tenemos 00:08:07

la posibilidad de no poner un ámbito entonces si no ponemos un ámbito bueno no pone un ámbito 00:08:15

quizás no sea lo más correcto no poner unas llaves para identificar el ámbito es decir poner algo así 00:08:21

imaginaos que ponemos este mismo código incluso tabulado pero lo ponemos sin las llaves que 00:08:26

implica un if que no tiene llaves? Pues lo que implica es que el if solamente está aplicando a la primera 00:08:38

instrucción que encuentra. Entonces por mucho que a propósito yo he tabulado este system out como para hacer 00:08:44

pensar que forma parte de este if, este ya no forma parte del if porque al no haber llaves solamente considera 00:08:50

una instrucción y estaría fuera del if de la misma forma que lo está este otro. Fijaros que siendo esto falso 00:08:57

no se debería ejecutar el código asociado al if 00:09:07

pero decimos que es esta solo al no tener llaves y si le damos a ejecutar 00:09:11

efectivamente fijaros como esta al ser falso no se ejecuta 00:09:15

pero esta al no haber llaves 00:09:19

ya no se considera parte del ámbito de este if y si que me la he puesto 00:09:22

impresa, se ha convertido en una instrucción más igual que esta 00:09:27

que gráficamente sin la trampita aquí de tenerlo 00:09:30

tabulado para que parezca que es del if, vendría a ser un poco 00:09:35

para que gráficamente se comporte más como de verdad 00:09:39

luego funciona, pues lo podríamos poner más cerquita de este otro y 00:09:43

en el tabulador para que no parezca que esté asociado al if. Si ponemos un ámbito 00:09:47

ya os digo, ya no sólo se preocupa 00:09:53

de una sola instrucción, sino que se preocupa de todo 00:09:57

lo que haya dentro del ámbito. Entonces, aquí nos ejecuta 00:10:01

consideraría las dos y, como al ser falso, no ejecutaría ninguna de ellas. 00:10:05

Vale, pues mirad, el if tiene la opción de simplemente evaluar si es cierto o falso 00:10:16

y si es cierto ejecuta su ámbito, si no, continúa con el programa secuencial a partir del cierre de la llave. 00:10:22

En este caso, lo que estábamos considerando es que, si lo que hay entre paréntesis es verdadero, 00:10:30

ejecute esto y si no, pues no tenga ninguna consideración particular 00:10:36

y siga con el código de normal, vamos a poner aquí un int y valor 00:10:41

vamos a decir que sea igual a 3 00:10:46

y ponemos aquí valor igual a 3 00:10:50

si ponemos en el if una condición que ya no sea directamente 00:10:56

un true o un false, lo que hará será evaluar esto, lo que hay entre paréntesis 00:11:02

y el resultado de esto siempre nos tendrá que dar como salida 00:11:06

un boolean verdadero o falso si ponemos algo que nos dé verdadero o falso pues no nos va a compilar 00:11:10

en este caso lo que estamos haciendo es comparar un valor con 3 ya habréis visto en algún programa 00:11:17

de los de ejemplo que cuando estamos comparando hay que poner dos iguales eso es muy importante 00:11:24

porque si ponemos uno solo bueno directamente ni siquiera nos compila aquí si ponemos uno solo no 00:11:29

está haciendo unos un igual sólo no hace funciones de comparación entre valores sino que lo que hace 00:11:36

es funciones de asignación estaría intentando asignar hay valor un 3 cuando queremos comprobar 00:11:43

por igual es necesario poner el igual igual en este caso si el valor es igual a 3 cosa que es 00:11:49

cierta porque sólo hemos asignado aquí ejecutaría esto y no lo mostraría por pantalla damos 00:11:56

Y efectivamente, sigue con ese comportamiento. 00:12:02

La instrucción if tiene la posibilidad de poner aquí una segunda cláusula, que es la cláusula else. 00:12:06

La cláusula else no tiene condición, no lo ponemos entre paréntesis, porque es si no se cumple el if. 00:12:13

Si no se cumple el if, podemos poner aquí otra parte del código, porque es falso, vamos a poner aquí. 00:12:21

Y cuando llegamos aquí a esta condición, lo que hace es evaluar el if, si es cierto ejecuta lo que está en su ámbito. 00:12:27

Y si no es cierto, se va al else y ejecuta el ámbito del else, 00:12:38

que en este caso sería, escribe porque es falso, escribe porque es falso, segunda línea. 00:12:42

Fijaros, haciendo un análisis del código, como y valor vale 3, 00:12:50

esta condición cuando se valore será cierta, y si es cierta, 00:12:54

en principio lo que esperamos es que ejecute estas dos instrucciones y no estas. 00:12:59

Estas nos ejecutarán, estas sí. 00:13:03

Por eso es una estructura de control de selección. 00:13:06

seleccionamos entre diferentes alternativas. Entonces si damos aquí, fijaros como las dos 00:13:10

líneas que se escriben son estas dos, al ser cierta esta condición, y la que no se 00:13:16

descubre, y esta siempre se escribe en cualquier caso, cierto o falso, y estas otras dos en 00:13:21

cambio ahora nos están mostrando por pantalla al ser la condición cierta. Si aquí pusiéramos 00:13:26

que el valor es un 4, pues esta condición ya no sería cierta, y al no ser cierta, si 00:13:32

la ejecutamos, el ámbito del if no se ejecutará y el ámbito del else será el que se escriba. 00:13:38

Entonces fijaros como aquí tenemos estas dos líneas, se escribe porque el falso está 00:13:45

de aquí arriba y se escribe porque el falso es segunda línea. 00:13:49

Lo mismo que hemos dicho antes del ámbito del if, que lo marcábamos entre llaves, pues 00:13:54

lo podemos tener en consideración en el else. 00:14:01

Entonces si el else no lo ponemos con llaves, fijaros que no se me queja en cuanto a compilar, 00:14:04

pero él es también estará considerando una sola instrucción como como ámbito si no lo 00:14:08

ponemos con las llaves si hacemos una ejecución en este caso como y valores 4 la evaluación del 00:14:14

if va a dar falso esto por ser falso no se va a ejecutar y va a ejecutar lo asociado al ex como 00:14:23

en él es no hemos puesto unas llaves solamente considera una instrucción entonces esta será la 00:14:28

que se ponga y ésta se pondrá en cualquier caso si le damos aquí ejecutar veis no salen las dos 00:14:34

está por les y está porque se pone en cualquier caso al igual que esta otra y para tener certeza 00:14:42

de eso pues convertimos la condición de élite en cierta y si es cierta fijaros como ahora nos 00:14:49

muestra estas dos líneas esta no nos la muestra porque al no tener las llaves es la que se 00:14:57

considera ámbito de leyes pero está ya fuera del ámbito de leer sí que le está escribiendo y está 00:15:05

bueno de igual forma es incorrecto el programa es incorrecto el programa si no ponemos el ámbito de 00:15:12

ley del ifo leyes pues no pero el comportamiento tenemos que tener claro que es ese y se recomienda 00:15:20

incluso aunque sea una sola instrucción poner siempre las llaves porque las llaves digamos 00:15:26

que visualmente cuando estamos haciendo un mantenimiento del programa como que nos como 00:15:31

que nos dan pistas de cuál es el ámbito del else y aquí está claro con las llaves que lo que hay 00:15:36

aquí sea una instrucción o sean dos pues es lo que está asociado al else pero si lo hacemos así 00:15:42

bueno pues un día estamos haciendo un mantenimiento y nos podría llevar a equivocación aunque en 00:15:49

realidad cómo se comporta es como hemos dicho pero nos podría llevar a equivocación así que 00:15:54

la mejor de las técnicas y la que se recomienda siempre es identifica los ámbitos con llaves 00:15:58

incluso aunque sea una sola instrucción en cuyo caso el comportamiento sería el mismo con llaves 00:16:04

o sin llaves y luego el if en cuanto a la estructura está de selección aparte del if else 00:16:11

pues nos da alguna alternativa más que es utilizar más condiciones a evaluar el else fijaros que no 00:16:20

tiene entre paréntesis ninguna no hace ninguna valoración porque es la de por defecto lo que 00:16:27

pasa en cualquier caso y aquí igual que tenemos este if que sí que valora algo pues podríamos 00:16:32

evaluar más cosas esto lo hacemos con un el shift es decir si pasa esto ejecuta este código si lo 00:16:39

que pasa es esto otro el shift ejecuta me otro código y si no ha pasado ninguna de las anteriores 00:16:47

ejecuta me este es lo que básicamente viene a decir entonces el el si fijaros como ahora 00:16:53

mismo no me compila porque si de la forma que aunque el es no exige ninguna condición que 00:16:58

evaluar el el shift si lo exige aquí por ejemplo podemos coger lo que haya en el el shift lo que 00:17:04

haya dentro del shift también se tiene que poder evaluar con un verdadero falso pues podríamos 00:17:15

poner aquí la condición de mayor si es mayor que 3 pues que haga otra serie de cosas identificamos 00:17:19

el ámbito del el shift se escribe porque él valor es mayor de 3 como funciona el elicia del shift 00:17:27

pues en el momento de forma secuencial en esta valoración es cuando ya se cumple uno es el que 00:17:49

se ejecuta es decir si el valor es igual a 3 vamos a poner que el valor sea igual a 4 fijaros con un 00:17:55

valor igual a 4 esta es cierta y está también pero la que se ejecuta es la primera en la secuencia de 00:18:02

arriba abajo que se cumple y sólo se ejecuta esa que si ponemos aquí que valga 4 vamos a ejecutar 00:18:10

y fijaros que lo que el código que nos lo que nos ha impreso en pantalla corresponde al código de 00:18:19

este y del if no del el cif a pesar de que éste también es cierto pero en el momento en esta 00:18:26

estructura de selección cuando se cumple una ya las demás se dan por descartadas se cumple una 00:18:32

ejecuta su código y la secuencia del código salta después de todo el bloque y felps if es 00:18:39

si el shift el shift else y continúa ya por aquí que es lo que ha sucedido si ponemos aquí un 5 en 00:18:47

este caso como está ya no es cierta pero está así que lo es pues lo previsible es que nos va a 00:18:57

imprimir este código. Le damos aquí y veis, ahora nos saca el código de estas dos instrucciones. 00:19:03

Y ya está, ¿no? Porque al ser falsa no es ejecutado. Y si lo que ponemos es un valor de 2, al darle a 00:19:13

ejecutar a la instrucción, pues lo que nos muestra es esta. ¿Por qué? Porque 2 no es igual a 4, es falso, 00:19:23

no se cumple. No es mayor que 3, es falso, no se cumple, pues ejecuto la condición que haya por 00:19:30

defecto en este caso es el else en cualquiera de todos los casos se cumpla una condición u otra 00:19:37

la que sea el código seguirá por aquí y lo que tengamos aquí será lo que se ejecute podemos 00:19:44

tener que no haya ninguna acción por defecto en caso de que no se cumplan y que no exista la 00:19:52

condición else tenemos el if else if si se cumple alguna de las dos en la que se ejecuta y si no no 00:19:57

hace nada por defecto es en este caso pues nos muestra el fuera él y porque dos no cumplen ni 00:20:04

esta condición ni esta otra en las en las instrucciones de selección y en las de iteración 00:20:10

ambas dos juegan con la valoración de una estructura aquí de una parte de código que nos 00:20:25

tiene que devolver en su conjunto un verdadero o un falso y este este conjunto verdadero falso nos 00:20:33

permite jugar con las con las instrucciones de tipo los operadores aritméticos que veíamos en 00:20:39

el otro tema el ant el or un ant solo uno solo el diferente el mayor el menor bueno pues todas 00:20:48

estas verdad entonces vamos a vamos a hacer una estructura aquí más completa mira si puede por 00:21:04

ejemplo lo que sí que es cierto es que con todas estas combinaciones lo que hay 00:21:11

en su conjunto entre el paréntesis tiene que devolverlos un valor asociado al 00:21:15

boolean verdadero o falso para poder valorar si el código aquí se ejecuta 00:21:19

si por ejemplo ponemos aquí si el valor es igual a 4 00:21:25

or o vamos a poner un true aquí directamente en su conjunto esto va a 00:21:30

ser verdadero, porque es verdad que esto es falso, pero con un OR 00:21:39

al ser esto verdadero, pues se convierte en verdadero. 00:21:42

Si os acordáis del tema anterior, la tabla de verdad de un Boolean 00:21:47

para el operador OR es que en el momento 00:21:50

que haya alguno verdadero o los dos verdaderos, la estructura en su conjunto 00:21:55

nos devuelve verdadero. Entonces este caso sería verdadero 00:21:59

si le damos, pues fijaros como efectivamente nos muestra este código. 00:22:02

Y si ponemos aquí, por ejemplo, un AND, ahí está el AND, en ese caso, este operador aritmético lo que nos hace es que convierte el conjunto en que sea cierto en el caso en el que ambos valores sean ciertos. 00:22:09

En cuanto uno sea falso, aquello ya es falso. Con lo cual, en este caso, este está claro que es verdadero, pero este otro, viendo que aquí ahora tiene el valor de 2, pues sería falso. 00:22:33

entonces falso and true se convierte en falso con lo cual es de esperar que esta parte del 00:22:47

código no se ejecute aquí la valoración también sale negativa porque valores igualados pues con 00:22:52

este código es de esperar que nos muestre escribe porque es falso vamos a ver es escribe porque es 00:22:59

falso y esto bueno lo podemos combinar tanto como sea necesario y valor y valor 2 igual a 5 00:23:07

entonces jugando con los paréntesis aquí esta expresión acordaros que hemos dicho que era 00:23:20

falsa porque al ser un ant ya es falso pero se va si evaluamos eso y luego ponemos aquí un 00:23:29

word por ejemplo y valor 2 que sea igual a 5 es evaluando este paquete por ser este falso 00:23:35

nos daría en su conjunto falso con lo cual tendríamos que todo este bloque es falso pero 00:23:46

se encuentra con un ORD aquí y con un ORD ya sabemos que cuando cualquiera de los dos lados sea verdadero, 00:23:52

se convierte en un verdadero. Como hay valor 2, lo estamos comparando con 5, que es el valor que hemos dado aquí, 00:23:59

pues en su conjunto ya sería verdadero. Entonces vamos aquí a ejecutar. Fijaros cómo nos muestra aquí la línea. 00:24:05

Y esta expresión podría ser tan complicada o podríamos poner tantas cosas como sean necesarias. 00:24:14

Por ponerlo en contexto, imaginaos un ejercicio donde queremos sacar un mensaje en el que se indique si una persona es un niño o una niña y si es mayor o menor de edad. 00:24:22

Podríamos tener un if si es niño y es menor de edad, pues tendrá que un system.out.println niño o menor de edad. 00:24:36

el shift si es un niño antes es menor de edad pues niño menor de edad el shift si es niña mayor de 00:24:48

edad pues niña mayor de edad y en este caso si son las cuatro posibilidades pues poner un es niña 00:24:57

menor de edad para finalizar se nos pueden dar situaciones vale en las que lo que haya que 00:25:04

evaluar aquí pues sea algo algo más complejo algo grande algo complicado y luego la diferencia que 00:25:10

no lo hablábamos en el otro tema, entre poner dos veces el indicador 00:25:18

o uno, que nos vale para la AND o nos vale para el OR, por ejemplo, 00:25:24

consiste en que si nosotros ponemos el valor dos veces, 00:25:30

si lo ponemos dos veces, imaginaos que tenemos aquí un AND. 00:25:36

Si este es falso, digamos que igual que la ejecución del programa 00:25:47

se hace de arriba a abajo, cuando valora algo de esto, lo intenta hacer de izquierda a derecha. 00:25:51

Entonces, si aquí se da cuenta que hay un OR, un AND, si esto es falso, voy a quitar para no complicar 00:25:58

la doble estructura, con ese AND, si esto es falso, ya con toda certeza todo esto va a ser falso, 00:26:08

porque esto es un AND. Entonces, si es un AND y esto es falso, me da igual el valor que sea este, 00:26:16

que sea verdadero o falso, que ya va a ser falso en su conjunto al encontrarse 00:26:22

en uno de los lados delante el falso. Entonces, si ponemos aquí 00:26:26

dos veces el carácter, esta parte ni siquiera se evalúa. Digamos que ahorramos 00:26:29

a la ejecución del programa Java que haga 00:26:34

esa operación. Entonces, ganamos en rendimiento. 00:26:38

Porque esto va a ser así. 00:26:41

Imaginaos que esto es un OR de la misma forma que 00:26:46

antes si resulta que esto es verdadero en este caso no lo es pero si tuviéramos aquí un 4 pues 00:26:50

esto ya es verdadero si es verdadero al tener aquí un or me da igual lo que hay aquí verdadero falso 00:26:56

a la hora de evaluarlo que ya en su conjunto va a ser verdadero con lo cual cuando podemos 00:27:02

prescindir de valorar el segundo de los de los bloques entonces no lo ejecuta si hemos puesto 00:27:08

aquí doble bien en el or o bien en el and y entonces ya pues si es un or ejecuta esto y si 00:27:16

es un and lo descarta y en cambio si sólo ponemos una de ellas el or o el and independientemente de 00:27:21

lo que haya dado la evaluación de esta parte ejecutará esta otra y podemos decir bueno y eso 00:27:31

no parece que nunca tenga sentido no porque si ya va a ser falso para qué vamos a perder tiempo 00:27:39

ejecutando esto. Pero es que las instrucciones en Java, luego ya más adelante, bueno, pues pueden irse 00:27:44

complicando un poco. Entonces, imaginaros que lo que tenemos es lo siguiente. Tenemos y valor 2 más más 00:27:50

igual a 5. Esta parte del código, aparte de la comparación, lo que está haciendo es incrementar 00:28:00

valor 2 hace esta operación como si como si tuviéramos esto aquí digamos incremento y valor 00:28:12

2 y esto lo quitamos más o menos podría parecerse aunque igual no tiene mismo comportamiento en el 00:28:21

100% de las veces pero podríamos decir incrementamos y valor 22 esta es esta notación 00:28:29

en java es igual que poner que es igual a y valor 2 más 1 vale más o menos sí entonces como que 00:28:35

incrementamos y valor 2 y luego lo comparamos pero pero esto podemos llegar a hacerlo ya os digo 00:28:48

aquí directamente lo comento ahora termino de deciros lo que estoy diciendo y ahora hago 00:28:56

referencia a esto que me preguntas entonces en este caso si tenemos esta instrucción o tenemos 00:29:14

Esta otra sí que es diferente. ¿Por qué? Porque una vez terminado el if, yValor2 aquí nos ha incrementado, en caso de que sea verdadero, si tenemos dos veces el or, como esto es verdadero, esta parte de código ya no se considera, no se ejecuta. 00:29:23

Con lo cual, y valor de or dos nos incrementa. Y si tenemos uno solo, esta parte de código, que aún así sigue siendo verdadera, porque ya es verdadera esta primera parte, sí se ejecuta. 00:29:47

Entonces, sí que hay una diferencia entre poner los dos OR o poner el 1. Es decir, el hecho de que esta parte la obliguemos a que se ejecute, aunque ya se haya decidido aquí si es verdadero o falso, o no se ejecute, puede tener connotaciones, por ejemplo, en este caso, en la variable 2. 00:29:59

entonces es lo que diferencia ponerlo dos veces o ponerlo una 00:30:18

con el and doble la parte segunda no se ejecuta 00:30:23

si ya decide el valor la primera de las partes 00:30:28

igual que con el or doble y en cambio con el and 00:30:31

sencillo o el and o el or sencillo siempre 00:30:36

se ejecuta la segunda parte independientemente de que esta parte ya haya 00:30:40

decidido si es verdadero o falso ¿se entiende esto? la diferencia 00:30:44

entre poner un 2 o 1? 00:30:52

Sí. Vale. Genial. 00:30:56

Mirad, otra 00:30:58

cosa que me preguntaban 00:30:59

era, ¿qué diferencia hay entre 00:31:01

poner... 00:31:03

Cuando estamos incrementando 00:31:05

el valor de una variable 00:31:07

en 1, 00:31:09

pues tenemos 00:31:13

la posibilidad de decir si ese valor 00:31:13

y valor es igual 00:31:15

a i 00:31:17

valor más 1. 00:31:18

podemos poner y valor más más 00:31:21

digamos como un atajo para no tener que escribir tanto, incrementarlo en una 00:31:25

podemos poner más más y valor 00:31:30

esto también está haciendo un incremento, si la instrucción 00:31:33

está así sola, si tenemos que y valor 00:31:38

aquí vale 4 y ponemos esta, cuando el programa siga por aquí va a valer 00:31:42

y valor 5, si la que ponemos es esta, cuando el 00:31:46

programa si va por aquí abajo va a seguir valiendo 5 y si la ponemos esta por aquí abajo va a valer 00:31:52

también 5 con lo cual en esta en este justo tal cual hemos puesto el código las tres son 00:31:59

totalmente equivalentes la diferencia está si tenemos por ejemplo y valor 3 y decimos que sea 00:32:04

igual a y valor más más o ponemos y valor int y valor 3 igual a más más y valor. Esto lo cuento 00:32:13

por una pregunta que me hacía un compañero antes. Lo digo para cuando los que vean la grabación me 00:32:31

preguntaba por la diferencia entre poner el más más aquí o poner el más más aquí. En esta instrucción 00:32:38

lo que hace es asigna el valor que tiene iValor a iValor3, vendría siendo un 4, pues le asigna un 4 y en la ejecución por aquí iValor3 valdrá 4 e iValor valdrá 5. 00:32:45

fijaros entramos con y valor valiendo 4 al estar el más más aquí después lo primero que hace es 00:33:03

asignar el y valor a y valor 3 con lo cual y valor 3 valdrá 4 entonces el código por aquí implicará 00:33:12

que si queremos trabajar con la variable y valor 3 valdrá 4 y valor 5 antes de terminar se incrementa 00:33:24

por este más más, con lo cual iValor valdrá 5. 00:33:30

Por aquí iValor 3 valdrá 4, iValor 5. 00:33:33

En cambio, si lo hacemos así, 00:33:37

antes de hacer esta asignación del valor a iValor 3, 00:33:41

lo que hace es incrementarlo. 00:33:44

Con lo cual iValor, que vale 4, lo incrementa a 5, 00:33:45

con lo cual iValor vale 5, 00:33:49

y en ese momento asigna el valor a iValor 3. 00:33:51

Con lo cual, con este código, 00:33:55

ambas iValor y iValor 3 valdría 5. 00:33:58

Vamos a probarlo. 00:34:02

Ponemos aquí y valor 3, y valor, entonces damos aquí, a ver qué es lo que me ha pasado, y valor 3, tiene la mayúscula, la variable, entonces damos a ejecutar aquí y fijaros, me dice que y valor 3 vale 4 y valor vale 5, es decir, y valor lo ha incrementado después de haber asignado su valor que tiene a y valor 3 que de partida era un 4. 00:34:03

En cambio, si ponemos este otro código, fijaros como en este caso ambas variables valen 5. Entonces sí que tienes un matiz el poner el más más aquí o el poner el más más aquí. ¿Por qué os decía que aquí no importaba mucho? 00:35:08

Bueno, no importaba en absoluto, porque en realidad no le estamos asignando el valor a ningún sitio. Estas tres son equivalentes. A la salida de aquí, iValor va a haber incrementado en todos los casos. 00:35:32

Entonces, si entramos con iValor 4, tanto con esta como con esta, iValor va a pasar a valer 5, que es lo mismo que sucede en esta y en esta. En ambos casos, iValor pasa a valer 5. Lo tengas posfijo, el más más o lo tengas prefijo. 00:35:44

La diferencia está en el valor que se asigna a la variable que tiene a la izquierda. Antes de ejecutar la instrucción, aquí incrementa la variable y aquí la incrementa después de ejecutar la instrucción. 00:36:05

¿Sí? ¿Bien? ¿Más o menos? Vale. Vale, pues nada. Entonces, no sé si me dejo más cosas de las instrucciones estas de selección con el if. Yo creo que poco más que contaros del if. 00:36:19

si habéis visto alguna cosa que me que me dejo en el tintero de la teoría si lo habéis echado un 00:36:43

ojillo me decís y si no si la caes en la cuenta luego después pues ya me decís en por los foros 00:36:53

mira la segunda instrucción de selección que tenemos a las instrucción switch vamos a utilizar 00:37:00

por ejemplo aquí un entero y hicimos switch y valor la instrucción switch a ver si me acuerdo 00:37:11

de la sintaxis, la uso menos y nunca me acuerdo exactamente bien 00:37:20

aquí va entre paréntesis 00:37:24

o no va entre paréntesis y valor, voy a tener que buscar 00:37:29

la instrucción switch porque no me acuerdo 00:37:58

voy a consultar un segundo la sintaxis de la instrucción switch 00:38:01

estructura de selección por aquí, ah vale me falta 00:38:23

abrir un ámbito, no es esto, expresión 00:38:50

case así que es así no no sé si veis algo que me esté dejando alguien por ahí sí sí dime me estoy 00:39:11

dejando alguna cosita por el s eso es eso es si lo estoy viendo aquí ahora mismo ahora mismo yo 00:39:37

también aquí con el que hay valor y los dos puntos estaba me faltaba ante la llave y luego que es 32 00:39:45

puntos ahí está vale gracias no la siente switch la verdad es que bueno es una expresión es una 00:39:55

estructura de control muy utilizada, o sea, no es para nada 00:40:01

una cosa así residual, pero yo tengo 00:40:05

poca costumbre de utilizarla y hay momentos en los que 00:40:07

queda más claro el código utilizando la estructura SWITCH que la ETH 00:40:10

o el SILF, pero como puedes utilizar una u otra 00:40:13

de forma intercambiable, pues 00:40:16

suelo utilizar más la otra y nunca me acuerdo bien de esta estructura. 00:40:19

Bueno, pues nada, esta es la jugada. 00:40:23

Entonces, la forma de 00:40:26

trabajar con el SWITCH, también tenemos 00:40:28

un ámbito, aquí identificamos la variable, el switch 00:40:30

no permite poner expresiones tan complejas como el if o el shift 00:40:35

que sí que te permite poner ans y entre paréntesis y se evalúa una cosa muy gorda 00:40:39

el switch permite mucho menos, prácticamente casi 00:40:43

en valores enteros y poco más y lo que 00:40:47

teníamos antes en el if que decíamos 00:40:51

a lo que comparamos el valor que estamos poniendo aquí, este sería 00:40:54

el equivalente a un if, pues sería 00:40:59

en este caso, if 00:41:02

y valor es 00:41:04

igual 00:41:07

a 3, pues este if y valor 00:41:08

es igual a 3, aquí se traslada 00:41:11

en esta expresión, aquí poniendo 00:41:13

el y valor, el igual o igual no se pone 00:41:15

y se dice en el caso de que sea 3 00:41:17

trabaja sobre 00:41:19

este código que pongamos 00:41:20

colgando del case 3 00:41:25

vendría a ser el equivalente 00:41:27

si es 3, nos ejecuta 00:41:29

este código, si es 4 ejecuta este código, pero switch con el if, el if, el if que hemos visto antes eran 00:41:36

excluyentes, aquí el switch no es excluyente y cómo funciona es que en el momento que encuentra de 00:41:44

arriba a abajo un case que le gusta ejecuta todo el código en adelante, fijaros que bueno pues 00:41:53

conociendo cómo funciona case, podría interesarnos 00:42:02

en algún momento. Entonces, fijaros, si aquí 00:42:05

decimos que iValor es igual a 3, que es este primer case, 00:42:10

como este es cierto, ya empieza a ejecutar por aquí, 00:42:13

pero al ser este cierto, no solamente ejecuta el case 3, 00:42:16

sino que ya él considera y ejecuta 00:42:19

todo el código que encuentra de ahí en adelante. 00:42:22

Fijaros, si le damos aquí una ejecución, nos dice vale 3, 00:42:25

vale 4 y dos veces vale 4 porque este no ha cambiado 00:42:28

Es decir, tiene un comportamiento un poquito diferente a como lo hace el if-else if en ese aspecto. Cuando en un if-else if se cumple una de las condiciones, el resto ya no se ejecuta. 00:42:31

Lo que sí que es cierto es que podemos utilizar una etiqueta, una instrucción que haga que se rompa la ejecución del switch, también lo vamos a ver luego en los bucles, en un momento dado. 00:42:47

Entonces, por ejemplo, si queremos que cuando se cumpla la condición 3, su comportamiento se parezca mucho más a la del if, el shift y solo se ejecute lo que cuelgue de su case, entonces después de lo que queremos que se ejecute podemos poner un break y el resto de la instrucción case que se encuentra por debajo ya no se ejecuta. Es como que este break da un salto del ámbito del switch y continúa ejecutando por aquí abajo, fuera del switch. 00:42:59

entonces con el break ahora, fijaros, le damos aquí 00:43:35

y ya me pone vale 3, este vale 4, este vale 5 00:43:39

no lo pone y me dice fuera del switch 00:43:43

en verdad si tenemos un enunciado podría ser 00:43:45

que con el 3 nos interesase que se ejecutase el 3 y el 4 00:43:51

pues podríamos poner un break aquí, si ponemos un break 00:43:54

aquí, ¿qué es lo que va a suceder? pues si se cumple la condición 00:44:00

3 nos mostrará este, intentará ejecutar todo el código 00:44:03

del switch de aquí hacia abajo, con lo cual ejecutará este 00:44:06

y al encontrarse un break 00:44:09

saltará del switch y se vendrá acá 00:44:11

si se cumple la condición 4 00:44:13

como no se ha cumplido la 3 00:44:16

este nunca se ejecutaría 00:44:18

se ejecutaría este y al encontrarse un break 00:44:20

se viene aquí 00:44:22

vamos a hacer una ejecución con valor 3 00:44:24

fijaros, no muestra el 3 00:44:28

y el 4, ¿por qué no muestra el 5? 00:44:31

porque se acaba de encontrar un break 00:44:32

y de aquí hacia abajo ya 00:44:34

no ejecuta el código asociado con el switch 00:44:35

se viene, rompe 00:44:39

hace un break del switch, digamos, con lo cual se viene aquí al final del switch 00:44:40

y continúa la ejecución con el código que pudiéramos tener aquí, 00:44:44

que sería el que esté dando respuesta al problema que queramos resolver. 00:44:48

En este caso, un system of println y poco más. 00:44:52

Entonces, si lo que queremos es un comportamiento que sea lo más parecido posible 00:44:56

a un if, el if, el if, lo que podríamos hacer es poner un break en cada una de ellas. 00:45:00

Aquí tendríamos if y valores igual a 3, ejecútame este código. 00:45:06

el shift y valores igual a 4 ejecuta me este el shift y valores igual a 5 ejecuta me este 00:45:11

y en las en las instrucciones y felps y felps y teníamos un el final verdad pues aquí es un 00:45:18

default la instrucción default es el si no se cumple ninguna otra ninguna de las anteriores 00:45:26

si ahora mismo ejecutamos como y valor vale 3 sí que se cumple una pues no ejecuta el default pero 00:45:53

y vale 13 pues los que es que tenemos por aquí no se cumple ninguno le damos aquí y lo que nos 00:46:01

sale es la del default que sería el equivalente al el shift del que hablábamos antes si resulta 00:46:08

que no hemos puesto breaks el default por lo que creo recordar también se considera como 00:46:16

una instrucción más decimos que sea 3 para que se cumple el primer que es esto nos muestra el 00:46:23

el 3, el 4, el 5, ninguna de las anteriores, es decir, todo el código 00:46:33

que cuelga desde el momento en el que se cumple la condición. 00:46:37

Ahí tenéis, ahora ha sido 4, pues este nos ha cumplido, pero este ya sí, 00:46:46

a partir de aquí ejecuta todas. 00:46:49

Si ponemos breaks, pues ya os digo, se lo va saltando. 00:46:52

Podemos agrupar también condiciones, me parece recordar. 00:46:59

Entonces, imaginaos que decimos vale 3 o vale 4. 00:47:02

Imaginaos que resulta que para el valor 3 y 4, el código que queremos 00:47:06

que se ejecute sea este mismo, entonces podríamos poner 00:47:10

algo así, el mismo código, o me parece 00:47:14

recordar que podemos separarlos por comas aquí los valores 00:47:22

entonces esto lo que hace es que si valor vale 3 o y valor vale 4 00:47:25

el código que se ejecuta pues será este, vamos aquí 00:47:31

ejecutar, como no hemos puesto break, ejecuta de ahí para abajo 00:47:36

ha entrado porque vale 4, pero si vale 3 00:47:39

pues sigue ejecutándolo, es decir, para considerar 00:47:43

un conjunto de valores que tienen 00:47:48

las mismas consecuencias en el código, para los cuales se ejecuta el mismo código 00:47:52

podemos separarlo por comas, y bueno, pues imaginaos que tenemos 50 valores 00:47:56

que tienen el mismo comportamiento, pues separamos los 50 valores aquí con comas 00:48:01

y no tendríamos que poner 50 veces entradas case 00:48:05

repitiendo esas 50 veces el mismo código 00:48:08

y bueno, no sé, poco más que contra los del switch case 00:48:11

yo creo, matiz un poco diferenciador 00:48:20

pues la jugada esta del break, la opción de meter el break 00:48:24

para que se comporte como el if, el shift y no ejecute 00:48:28

todo hacia abajo y si no tener en cuenta que va a ejecutarlo 00:48:32

en el momento que una se acierta, todo el código que se encuentre hasta el final del ámbito 00:48:35

del switch, si no tenéis preguntas 00:48:40

pasamos a las estructuras de control de repetición hemos visto las de selección que son estas dos y 00:48:51

las de repetición o iteración si las de selección lo que hacen es ejecutar una parte de código en 00:49:01

función de si es verdadero o falso las de repetición lo que hacen es estar repitiendo 00:49:10

un código durante el tiempo en el que se cumple la condición la primera de la que podemos hablar 00:49:15

es la estructura de control while, mientras lo que hace es estar ejecutando el código que tiene dentro de su ámbito 00:49:24

mientras lo que hay aquí sea cierto, entonces imaginaros que tenemos aquí una variable int y valor que inicialmente vale 0 00:49:35

decimos mientras y valor sea 00:49:45

menor de 5, aquí pondremos el código 00:49:50

de lo que tenga que suceder, imaginaros que estamos 00:49:59

como os comentaba al principio, hablando de imprimir todas las facturas que tiene 00:50:03

mi empresa, todas las facturas o un mensaje a todos los 00:50:07

clientes, entonces a lo mejor podría tener una base de datos con todos los clientes 00:50:11

y aquí acceder a la base de datos por esta zona de código 00:50:15

y hacer una consulta de todos los clientes 00:50:18

que en un momento dado me da 1000 y en otro momento me da 00:50:22

20.000 o los que sea, los que tenga 00:50:24

y para cada uno de ellos igual recojo cierta información 00:50:27

y hago aquí un determinado proceso, lo que me pide el programa 00:50:30

mientras vaya teniendo clientes 00:50:33

en la base de datos, ve repitiéndome 00:50:37

este proceso, hará el proceso para uno 00:50:40

llegará aquí y volverá a hacer la comprobación de si esto 00:50:43

ver cierto o no. Ahora el proceso de nuevo, después de hacer el proceso de nuevo, volverá en el momento 00:50:46

que llega al final del while, antes de continuar el código por aquí, fuera del while, antes de continuar 00:50:52

por aquí, lo que hará será volver a evaluar la condición esta, a ver si sigue siendo verdadera o falsa, 00:51:00

en caso de que sea verdadero, otra vueltecita que nos damos. Si ya es falso, continúa después del ámbito 00:51:06

del while y ejecuta el código 00:51:12

que pongamos aquí. 00:51:14

Vamos a poner aquí un system. 00:51:16

Entonces aquí un 00:51:32

bucle que se me ocurre sencillo 00:51:33

pues sería poner un system.out.println 00:51:35

Ya os digo que el código que hay 00:51:39

aquí podría ser cualquiera. 00:51:41

De momento como estamos trabajando mucho con el 00:51:43

system.out pues decimos que 00:51:45

la variable y valor 00:51:47

vale y sacamos por pantalla 00:51:49

el valor que tiene y valor. 00:51:54

Cada vez y valor con una línea de nuevo. 00:51:56

¿Qué sucede en este caso? Pues fijaros, si no pusiéramos más código y valor vale 0, diría y valor es menor que 0, esto lo evalúa verdadero o falso, en caso de ser verdadero ejecuta el código que hay dentro del bucle del while, en caso de ser falso nos vendríamos a continuar trabajando por aquí. 00:51:58

es cierto, y valor es menor que 5 00:52:16

porque vale 0, entonces nos diría aquí y valor vale 0 00:52:20

y cuando llega al final del while de su ámbito 00:52:22

antes de continuar por aquí se viene a hacer una nueva 00:52:26

valoración de la condición y diría 00:52:29

y valor es menor que 5, pues sí, porque vale 0 00:52:31

entonces nos diría y valor vale 0 00:52:35

se vendría aquí, se daría cuenta que se acaba el ámbito 00:52:38

vendría aquí, y valor es menor que 5, sí 00:52:40

si no cambiamos algo para que esta condición 00:52:43

deje de cumplirse como verdadera, nos quedaríamos aquí en un bucle infinito 00:52:48

se quedaría el ordenador bloqueado, entonces dentro de 00:52:52

entre cada una de las valoraciones de esta condición 00:52:56

tendrá que ir pasando algo para que 00:53:00

en algún momento eso se convierta en falso, entonces 00:53:03

si por ejemplo ponemos que y valor 00:53:08

más más, acordaros de lo que decíamos antes 00:53:11

esto sería igual a iValor es igual a iValor más uno 00:53:18

y si lo ponemos en una línea solo, daría igual poner más más iValor también 00:53:21

después de mostrar aquí el valor que tiene iValor, lo incrementaría, entonces cuando 00:53:25

llegue aquí, iValor tendría uno más, entonces en la primera vuelta 00:53:30

pasaría de iValor cero a iValor uno, iValor vale uno 00:53:34

es menor que cinco, todavía lo es, como es cierto, nos mostraría que hay el valor uno 00:53:39

pasaría al 2, comprobaría, 2 menor que 5, sí, también, igual para 3, cuando vale 4, todavía esto sigue siendo cierto, es menor que 5, con lo cual nos mostraría aquí el 4, y resulta que cuando vale el siguiente incremento, pasaría y valor a valer 5, se vendría aquí y diría, y valor es menor que 5, no, porque ya es igual, como ya la condición es falsa, no ejecutaría el ámbito del while, se vendría por aquí, 00:53:43

y ya seguiría ejecutando el código a partir de este punto. 00:54:11

Entonces, damos aquí. 00:54:17

Claro, bueno, te respondo ahora mismo. 00:54:24

Mirad la ejecución, nos ha mostrado valor 0, 1, 2, 3, 4 00:54:30

y luego ya fuera el while. 00:54:34

Ya el valor, cuando hay valor vale 5, 00:54:35

ya no lo ha mostrado porque esta condición ha sido falsa. 00:54:38

Mirad, me preguntaban para la grabación 00:54:41

si en lugar de poner esto, pongo esto otro. 00:54:43

en ambos casos cuando acaba la instrucción 00:54:46

tanto para este como para este, iValor se ve incrementado 00:54:53

si iValor aquí vale 0 antes de ejecutar esta instrucción, aquí iValor 00:54:57

va a valer 1, si iValor vale 2, aquí iValor vale 3 00:55:01

se incrementa tanto en este como en este, con lo cual en este caso 00:55:05

nos da igual, cuando tiene influencia el más más como prefijo 00:55:09

o como sufijo, cuando aparte de 00:55:13

la actuación que tenga sobre esta variable tiene más implicaciones 00:55:16

como os ponía antes, si tenemos aquí un int y valor 2 00:55:21

y decimos aquí en este 00:55:25

y valor 2 igual, y aquí ponemos 00:55:28

y valor 2 igual 00:55:33

bajo el supuesto de que esta es la primera vuelta y valor vale 0 00:55:37

a la salida de aquí y valor 00:55:44

se ve incrementado y vale 1, pero este incremento, si tiene el más más como prefijo, lo hace 00:55:48

antes de hacer la asignación, con lo cual iValor vale 1 sí o sí y como lo ha hecho 00:55:55

antes de la asignación, iValor2 también valdría 1. Y aquí el incremento, como lo 00:56:01

tiene justo después de iValor, lo hace después de hacer la asignación, con lo cual iValor2 00:56:10

valdría 0, pero y valor 1 en ambos casos 00:56:17

valdría 1. ¿Quién se ve afectado 00:56:20

en realidad con que esté el más más 00:56:24

como prefijo o como sufijo? Y valor 2. 00:56:26

Entonces, si yo cojo y hago esto, que no 00:56:30

se ve implicado ningún y valor 2, 00:56:32

estas dos instrucciones son equivalentes. 00:56:35

Estas dos, y si no os gusta poner 00:56:39

sufijos y prefijos, pues también tendríamos aquí 00:56:41

valor más uno en este caso estas tres instrucciones serían equivalentes se entiende se vale vale pues 00:56:44

esta sería la jugada vale en definitiva la retomando un poco la estructura de control 00:57:01

de repetición una de las posibilidades que tenemos es el wild cuando llega al wild se valora si esta 00:57:10

condición es verdadera o falsa. Si la condición es verdadera, se ejecuta su ámbito. Si es falsa, 00:57:17

se deja de ejecutar. Si ha sido verdadera una, dos o mil veces, las que sean, en el momento que 00:57:24

llega al final del ámbito del while, en lugar de continuar por aquí directamente, se queda de 00:57:31

nuevo la condición. Si sigue siendo cierta, damos otra vuelta. En el momento que ya sea falsa, se 00:57:38

marcha. La instrucción while tiene la posibilidad de que el código que hay dentro de su ámbito no 00:57:43

se ejecute ninguna vez. Si y valor inicialmente vale 10, cuando llega aquí directamente es falso 00:57:53

y su código no se ejecuta nunca. Pero si le damos aquí a ejecutarlo, ¿veis? Fuera del while no me ha 00:58:00

puesto este mensaje ninguna vez. ¿Por qué? Porque ha evaluado 00:58:09

esto y se ha dado cuenta que era falso. Es decir, igual 00:58:13

se puede dar entre 0 y n veces 00:58:20

y esa n veces dependerá de cuándo termina por cumplirse esta condición. 00:58:24

Si aquí ponemos la condición true con este código 00:58:29

bueno, fijaros que ya el sistema 00:58:32

Eclipse se ha dado cuenta que este código no se va a ejecutar nunca 00:58:41

y se me está quejando la compilación porque ha dicho se te va a quedar el código siempre ahí 00:58:45

aquí tienes código muerto que no se va a ejecutar nunca si lo tenemos así como esto siempre sería 00:58:49

true se quedaría en un bucle infinito aquí existe una posibilidad que tiene que ver con 00:58:55

para gestionar los wild pero no es muy recomendable es mejor siempre poner es más 00:59:05

recomendable poner aquí la condición por la que te sales del bucle que podría ser mantener aquí 00:59:10

un true y poner aquí un break os acordáis del break que hemos puesto antes en el switch cuando 00:59:15

hemos puesto un break en el switch lo que hacía era dejar de ejecutar el switch pues si metemos 00:59:21

dentro de una iteración un break lo que hace es dejar de ejecutar el bucle entonces en este caso 00:59:27

con la instrucción break fijaros como ahora ya me compila esto porque esto ya no es un bucle 00:59:34

infinito al asistir un break aquí aunque esto se va a volver siempre como cierto si se encuentra 00:59:39

este break rompe el while y seguiría ejecutando a partir de aquí mirad algo parecido a lo que 00:59:45

habíamos hecho antes utilizando el break aunque ya os digo que esto no nos suelen recomendar mucho 00:59:51

es mejor poner la condición aquí en el while que es donde esperas tú encontrar el motivo por el 00:59:56

que se repite el bucle y no poner aquí algo tan genérico como algo tan genérico como un true y 01:00:03

que luego en mitad del código de repente aparezca un break porque aquí tenemos tres líneas que lo 01:00:08

vemos muy fácil, pero si tuviéramos un código muy extenso, pues a lo mejor 01:00:13

localizar el break costaba más, y aquí en cambio, si lo ponemos 01:00:17

directamente vemos la condición ahí y sabemos cómo salirnos, pero 01:00:21

un equivalente a lo de antes, fijaros, si ponemos aquí un if 01:00:25

si valor es igual a 5, que haga el break 01:00:28

entonces fijaros que este código viene a ser lo mismo que lo que hemos 01:00:41

puesto antes aquí, porque esto, siempre que lo evalúa, lo evalúa 01:00:45

acierto, es cierto, aquí nos mostraría el 0, incrementa 01:00:49

1, luego diría, oye, y valor es igual a 5, no, porque vale 01:00:53

1, que lo acabo de incrementar, pues no ejecuto el break, me vengo aquí 01:00:57

evalúo el while y como siempre es cierto, vuelvo a entrar 01:01:01

me vengo por aquí, y incremento a 2 01:01:05

y valor vale 2, vale 5, no, porque vale 2, no ejecuto el break 01:01:09

llego al final del ámbito del while, vuelvo por aquí, evalúo 01:01:13

esto es true pues vuelvo a ejecutarlo habrá un momento en el que este incremento convierta el 01:01:17

valor de valor a 5 en ese caso si valor es igual a 5 ejecuta el break y el break lo que nos saca 01:01:22

es del bucle con lo cual se nos vendría por aquí vamos a hacer una ejecución para que lo veáis 01:01:29

1 2 3 4 y se nos sale con el wine y luego tenemos otra etiqueta que en los switches 01:01:38

sí que se utiliza mucho el break esta es una herramienta que tenéis disponible pero es más 01:01:48

aconsejable poner la condición aquí que no poner aquí un verdadero y luego jugar con la condición 01:01:54

para salirme por ahí en mitad del bucle y tenemos otra otra opción otra etiqueta que es la etiqueta 01:01:59

continua y vamos a poner aquí vamos a devolver aquí que el valor sea igual a 5 y aquí en cuando 01:02:06

sea igual a 3 en lugar de la etiqueta break vamos a poner la etiqueta continua esta etiqueta lo que 01:02:17

hace es vamos a poner así el código no vamos a subir para ver cómo funciona el continuo este 01:02:23

código aquí arriba está aquí está etiqueta lo que hace cuando se encuentra un continuo que ejecuta 01:02:43

lo que hace es dejar pegar un salto al final del ámbito del while pero de esta ejecución y se 01:02:50

vuelve aquí. Si nos encontramos un break, como hemos visto antes, lo que hacía era romper el 01:02:58

while por completo y ya continuaba el código por aquí. En cambio, si lo que encuentra es un 01:03:03

continue, lo que hace es parar esa iteración, esa vuelta que está dando el código. Es decir, 01:03:08

si llegamos por aquí por el while y ejecuta este continue, en lugar de ejecutar esta instrucción, 01:03:14

directamente se vendrá aquí, sin ejecutar esta parte de código porque está después del continue, 01:03:18

y se vendría a evaluar esto de nuevo. 01:03:23

¿En este código qué pasaría? 01:03:29

Pues bueno, sería en realidad un bucle infinito, ahora vemos por qué. 01:03:30

Y ahora lo modificamos para que deje de serlo. 01:03:34

Si el valor vale 0, como no es 0, no ejecutaría el continue, 01:03:36

se vendría por aquí, nos mostraría 0 y diría valor 1. 01:03:42

Y valor valdría 1, se vendría por aquí. 01:03:47

Y valor que vale 1 no es igual a 5, como no es igual a 3, no hace el continue, 01:03:50

no mostraría el 1, incrementaría a 2, la siguiente vuelta incrementaría a 3, 01:03:54

en esa vuelta en la que hay que incrementar a 3, llegaría aquí al final del ámbito, 01:04:02

diría, ¿y valor es igual a 5? No, pues, o sea, es distinto de 5, tendría que ser el código, 01:04:07

¿y valor es distinto de 5? Sí, como esto es verdadero, me meto, pero ¿y valor es igual a 3? Sí, 01:04:14

Entonces haría un continue. Este continue no ejecutaría este código, se vendría por aquí y se vendría aquí. Y diría, ¿y valores distintos de 5? Sí, porque vale 3. En este caso no lo hemos incrementado, ¿verdad? 01:04:21

entonces como vale 3 volvería a entrar por aquí por el continuo volvería a saltar y se vendría 01:04:33

aquí con lo cual nos habríamos quedado en un bucle infinito sin ejecutar este código nunca y en 01:04:42

particular sin ejecutar esta instrucción que es la que nos está llevando a que lleguemos a llegar a 01:04:47

una condición de salida entonces aquí por ejemplo vamos a poner antes del continuo y vamos a poner 01:04:53

un valor más más también para que también se incremente para que cuando valga 3 lo incrementa 01:04:59

4 haga el continuo y no muestre ese valor lo incrementaría 5 en este caso y ya esto sería 01:05:05

falso fijaros como la vez que ha valido 3 no nos ha mostrado por pantalla porque porque ha hecho 01:05:16

un continuo veis continuo no ha ejecutado este código bueno pues si en algún momento dado dentro 01:05:29

de una iteración, dentro de un while, nos interesa que en algún 01:05:38

momento una de esas vueltas no ejecute 01:05:42

el código que hay por aquí abajo, pues podremos poner un continue 01:05:46

y se salta esa vuelta del bucle. Es en cuanto al break y al continue. 01:05:49

Si tenéis dudas, me decís. 01:05:59

Vamos con otra instrucción de control de estas de repetición. 01:06:04

El while, hemos dicho que podría darse la situación 01:06:09

en la que no se ejecutase ninguna vez. 01:06:13

Si tenemos como condición que iValor sea menor que 5 01:06:17

y ponemos aquí un 10, directamente la primera vez 01:06:19

ya es falso esto y no se ejecuta ninguna vez. 01:06:23

Si queremos tener un bucle que garantice 01:06:25

que al menos se ejecuta una vez, 01:06:28

utilizaremos en lugar del while otra estructura 01:06:31

que es el doWhile, que al final van a ser intercambiables 01:06:34

y ahora os muestro cómo. 01:06:37

como en este caso, hacemos 01:06:38

el código que queramos que se vaya repitiendo 01:06:41

antes de hacer la comprobación, que la ponemos en el while 01:06:45

pues aquí nos garantizamos que este bucle 01:06:48

se ejecuta al menos una vez 01:06:51

¿cuál es la sintaxis? pues ponemos 01:06:52

do while y aquí ponemos el punto y coma del final de la instrucción 01:06:57

en este caso 01:07:00

un poco interpretando lo que ponen las palabras 01:07:02

pues decimos do, haz esto 01:07:06

y luego hazlo mientras que pase esto. 01:07:07

Entonces, hará al menos una vez esto, hará la comprobación 01:07:12

y si la comprobación es cierta, vuelve a hacer el do. 01:07:15

Es casi exactamente igual que el while anterior, 01:07:20

pero nos garantiza que al menos se ejecuta una vez el código. 01:07:24

Puede ser que necesitamos que se ejecute siempre una vez algo 01:07:28

o puede que no sea necesario. 01:07:32

Si no es necesario, utilizamos un while. 01:07:34

si no podemos optar 01:07:36

por un do while 01:07:38

entonces fijaros que aquí 01:07:39

con un valor de iValor igual a 10 01:07:41

aunque ya la condición 01:07:44

esta primera vez es falsa 01:07:46

como se encuentra primero el do 01:07:47

no va a ejecutar al menos una vez el system.out.println 01:07:49

este 01:07:52

le damos aquí y veis 01:07:53

ha puesto iValor 10 01:07:56

como consecuencia de ejecutar esta instrucción 01:07:57

bueno pues nada pues esto 01:08:00

es así el do while 01:08:04

prácticamente igual que el while 01:08:06

pero garantizando una primera ejecución. Si a alguien le gusta mucho más 01:08:07

utilizar un while mejor que el do while pero quiere que se ejecute una vez 01:08:12

pues tiene la opción de hacer lo siguiente. Pone aquí 01:08:16

la condición del while y antes del while pone 01:08:20

el código que está dentro una vez. Con lo cual la vez que se ejecuta con el do 01:08:24

se ejecuta porque no estamos haciendo ninguna valoración 01:08:28

y este es el while que el do while se encontraría al final. 01:08:31

Entonces este código, justo poniendo una ejecución primero y luego utilizando la estructura de repetición while, es equivalente a, vamos a ejecutarla, ¿veis? Me muestra un valor, como es lógico porque se lo encuentra y ya está, incrementa y luego valora. Esta es equivalente a esta otra. 01:08:35

Bueno, la tercera forma que tenemos para trabajar con Arrays 01:09:09

Con Arrays, perdón 01:09:22

Estaba pensando en lo que voy a contar luego después 01:09:23

Si nos da tiempo y si no el próximo día 01:09:26

Y se me ha ido a los Arrays 01:09:28

La tercera estructura que tenemos es 01:09:30

Para hacer las repeticiones es la FOR 01:09:32

La instrucción FOR 01:09:35

Tiene también un ámbito por aquí 01:09:39

Aquí ponemos el código 01:09:41

Y tiene aquí tres bloques 01:09:43

Entonces, primero aparece una inicialización. Vamos a poner inti igual a 0, por ejemplo. Luego aparece una comprobación, mientras sí, sea menor que 5 y luego aparece una actualización de la condición que normalmente aquí vamos a poner una actualización de la condición que estamos evaluando aquí. 01:09:45

y cómo funciona el ford y después después buscamos variantes y os cuento más cosas del ford pero 01:10:15

vamos primero con esta básica cuando llega el código por aquí lo primero que hace en la primera 01:10:21

vuelta siempre es hacer esta inicialización entonces dice y vale cero y justo a continuación 01:10:27

hace esta comprobación que vendría a ser la comprobación por ejemplo que antes teníamos en 01:10:33

el while la única que teníamos aquí pues en el ford la expresamos aquí después de hacer esta 01:10:37

comprobación si es cierta ejecuta el código, el código que tengamos puesto aquí y cuando termina 01:10:44

el ámbito se viene y hace esta actualización. Después de esta actualización vuelve a hacer 01:10:52

esta comprobación. Es decir, la primera vez que llegamos ejecuta esta inicialización, solamente 01:10:57

la hace la primera vez que llegamos. Después de esa inicialización comprueba si es cierto, ejecuta 01:11:05

el ámbito del fort y una vez terminado la ejecución del ámbito de fort actualiza después 01:11:12

de actualizar comprueba si es cierta vuelve a ejecutar el fort es un bucle repetitivo después 01:11:18

de terminar actualiza después de actualizar comprueba si el verdadero otra vez la jugada 01:11:26

si el falso en el momento que esto sea falso se vendrá por aquí y dejará ejecutar el fort antes 01:11:33

en el while decíamos, para que no se nos quede en un bucle infinito, 01:11:42

que decíamos aquí, mientras ia sea menor 01:11:46

de 5, y por aquí dentro del código 01:11:57

decíamos, de alguna forma tendrá que haber una evolución aquí 01:12:01

para que esta condición en algún momento se convierta en falsa y eso no sea un bucle 01:12:05

infinito. En un for lo más normal es que esa condición que poníamos 01:12:09

por aquí, la trabajemos aquí. ¿Ok? Alternativas, 01:12:13

Ahora os cuento más cosas, pero la trabajemos aquí. Esto es lo que hará avanzar a la variable con la que estamos trabajando en la comparación. 01:12:17

Y probablemente, mirad, como aquí en el while, habíamos hecho, antes de empezar a ejecutar, una primera inicialización de la variable que aparece por aquí. 01:12:28

pues lo más normal es que en el for 01:12:37

esa inicialización la tengamos aquí 01:12:39

entonces ponemos aquí un system.out 01:12:41

println 01:12:50

y vale 01:12:53

más y 01:12:57

fijaros ahora aquí dentro del ámbito del for 01:13:01

solo ponemos esta instrucción 01:13:04

no ponemos el avance porque lo estamos considerando aquí 01:13:05

y no hemos inicializado 01:13:08

porque lo estamos haciendo aquí 01:13:10

por encima del for 01:13:11

y la condición que siempre se va a evaluar 01:13:12

pues va a ser esta 01:13:15

entonces si damos aquí una ejecución 01:13:16

Fijaros que la primera vez inicializa 0, comprueba, efectivamente es menor que 5, 0, me muestra aquí el valor de i y me escribe esta línea. 01:13:19

Llega al final del ámbito, volvemos por aquí, va a la zona de actualización, 0, más, más, pues se convierte en un 1i y 1 es menor que 5. 01:13:28

Esto ya no lo vuelve a ejecutar porque solo lo hizo la primera vez. Como 1 es menor que 5, es cierto, vuelve dentro del for y me muestra la línea 1. 01:13:37

vamos repitiendo hasta el momento en el que este y más más 01:13:45

bueno, con este y más más hay un momento en el que pasa a valer 01:13:50

y de 3 a 4, como 4 es menor que 5 01:13:54

ejecuta por aquí, me muestra esta entrada 01:13:57

llegamos al final del ámbito, del for, ese 4 con el y más más 01:14:00

se convierte en 5 y antes de ejecutar por aquí comprueba 01:14:06

y dice 5 es menor que 5, no, porque ya es igual, se termina el for 01:14:09

y nos salimos por aquí 01:14:12

y nos muestra esto 01:14:15

el formato que ponemos aquí 01:14:17

es inicialización 01:14:22

comprobación 01:14:24

y actualización 01:14:26

alternativas que tenemos en el for 01:14:30

pues fijaros 01:14:33

esta actualización 01:14:33

aquí hemos hecho que vaya de uno en uno 01:14:35

pero si ponemos que i 01:14:36

aquí podemos poner instrucciones 01:14:38

más complejas 01:14:39

¿verdad? 01:14:40

podemos poner que i sea igual a i más 2 01:14:41

en lugar de un i++, i++ era una instrucción de java 01:14:42

pues aquí podemos poner instrucciones, pues este i 01:14:47

igual a i más 2 implica que i va a ir 01:14:51

incrementando de 2 en 2, entonces fijaros como la ejecución 01:14:55

la primera vale 0, la segunda vale 2 y la segunda vale 4 01:14:58

es decir que no hay que ir de uno en uno, aquí podemos poner código más complejo 01:15:03

si nosotros definimos aquí esta variable como un parámetro 01:15:08

del for pasa algo parecido a lo que decíamos de los 01:15:14

métodos que también podían recibir parámetros 01:15:17

y esta variable se convierte en una variable disponible 01:15:19

en este ámbito, entonces fijaros que 01:15:23

en un primer ejemplo hemos puesto que la actualización 01:15:26

de esta variable que es la que comprobamos aquí 01:15:29

trabajamos sobre ella aquí, pero aquí dentro del código también podríamos 01:15:31

poner, fijaros, si ponemos aquí un i igual a 10 01:15:35

pues antes de llegar al final del ámbito del for 01:15:37

i va a pasar a valer 10, esta variable i es esta misma 01:15:42

fijaros como me lo chiva Eclipse 01:15:45

que al marcarla me lo pone aquí 01:15:47

un poquito más marcado con 01:15:49

fondo más marrón 01:15:51

y negro o marrón y gris 01:15:53

pues entonces si va a pasar a valer 10 01:15:55

después de este incremento 01:15:57

va a pasar incluso a valer 12 01:16:00

y 12 ya va a ser 01:16:01

menor que 5 con lo cual 01:16:03

aquí solamente vamos a tener una iteración 01:16:05

es decir esta variable la podemos modificar por aquí 01:16:07

dentro, veis, me muestra el 01:16:09

de 0, cuando llega aquí 01:16:14

¿Qué vale y? Pues vale 10. Además, lo primero que va a hacer al llegar al for va a ser incrementarlo en 2. Va a valer 12. En definitiva, 12 es menor que 5. Pues entonces deja ejecutarse el for y solamente me ha dado una vuelta este for. Es decir, que aunque la estructura normal es inicialización, comprobación, actualización, podemos trabajar con esas variables por aquí. 01:16:16

mirad otra cosa, si nosotros definimos esta variable aquí 01:16:40

esta variable está disponible en el ámbito del for 01:16:45

el for es este, es la llave, entonces si yo cojo y pongo aquí 01:16:50

un system.out.println 01:16:54

y vale, fijaros 01:17:00

como directamente Eclipse no me deja, no me compila, porque dice esta variable 01:17:08

la estás utilizando en este ámbito, en el ámbito de la clase main 01:17:12

y en el ámbito de la clase main no está definida esta variable porque es una variable 01:17:17

que está acotada al ámbito de la clase for, de la instrucción 01:17:21

for. Imaginaos que esta variable que ha ido 01:17:25

ahí evolucionando con estas actualizaciones incluso por aquí 01:17:29

queremos tenerla disponible para escribirla aquí. Entonces 01:17:33

¿dónde tendría que estar definida? Pues en el ámbito donde está 01:17:37

donde estamos utilizando esta instrucción 01:17:40

que es la del main. Entonces esto podríamos coger y decir 01:17:45

mira, esta variable que es la que vamos a utilizar, la vamos a definir 01:17:48

aquí. Si queréis no la inicializamos porque 01:17:52

nos interesa inicializarla aquí en el for, pero 01:17:56

la definimos en este otro ámbito. Entonces veis como ahora ya sí que me compila 01:18:00

por aquí. Entonces le damos aquí y este i vale 01:18:04

y pues nos muestra este 12 que este 12 como os decía es este 10 al volver al ford lo primero 01:18:09

que hace es la actualización lo pasa 12 hace la comprobación 12 es menor que 5 falso se sale del 01:18:16

ford y cuando me muestra aquí el valor que tiene y pues me dice que efectivamente que es 12 porque 01:18:22

la tengo disponible aquí en esta instrucción la variable y pues porque es una variable que 01:18:27

está definida en ese ámbito, en el ámbito 01:18:32

del main. Volviendo a la 01:18:36

memoria RAM que os hablaba en otras clases, pues 01:18:38

aquí lo que sucede es cuando llegamos aquí, fijaros que esto es 01:18:41

un dato primitivo de Java, con lo cual no es necesario 01:18:44

poner la instrucción que sí que ponemos en los 01:18:48

referenciados del new, ¿verdad? Que decíamos 01:18:50

por ser primitivo, ya no va a hacer la reserva, 01:18:52

pues ¿en qué momento nos pedirá el sistema operativo 01:18:56

para este dato primitivo que nos guarde un trocito 01:18:59

de memoria random de guardar información que vaya teniendo 01:19:02

y a lo largo del programa, aquí 01:19:05

¿en qué momento dejará de estar disponible esta variable? 01:19:07

cuando se salga de su ámbito, su ámbito 01:19:12

lo hemos definido ahí, es el main, pues dejará de estar disponible 01:19:14

aquí, si deja de estar disponible aquí y la queremos usar 01:19:17

aquí, todavía es posible hacerlo 01:19:20

con lo que hablábamos antes, si lo ponemos aquí 01:19:23

fijaros que ya me deja de compilar aquí y ¿cuál es la 01:19:26

explicación de esto? Pues aquí todavía no hemos hecho esa reserva. ¿En qué 01:19:31

momento el programa pedirá al sistema operativo espacio 01:19:35

donde guardar información por una variable de tipo Java primitiva 01:19:39

que es un entero? Pues lo hará aquí. 01:19:42

¿Y esta variable en qué ámbito lo estamos definiendo? En el ámbito del for. ¿Cuándo dejará de existir 01:19:47

esta variable i? Cuando acabe el ámbito del for, que será 01:19:51

aquí. Entonces, si aquí deja de existir, donde tengo ahora mismo el cursor, por aquí, 01:19:55

y la quiero utilizar aquí, pues ya coge y me dice 01:19:59

esa variable no existe. Bueno, ¿a dónde quiero llegar 01:20:02

con todo esto? Pues que 01:20:09

hablar del for como 01:20:11

inicialización aquí, comprobación 01:20:15

y actualización, pues bueno, esa es la estructura 01:20:18

base del for, pero luego nos da para hacer muchas 01:20:21

alternativas, muchas jugadas por ahí. ¿Se entiende 01:20:24

el for? ¿Alguna duda por aquí sobre esto que os cuento? 01:20:30

no principio no seguís por ahí eso sí verdad se vale bueno vale perfecto vale pues mira bueno 01:20:35

otra con la estructura del ford a partir de una cierta versión en java existe la posibilidad de 01:20:48

recorrer a raíz o colecciones que viene a ser indicar aquí el tipo de datos y que lo vaya 01:20:57

ejecutando aquí. Es algo que en la teoría os habla de un for each. 01:21:06

Para poder conocer ese for, pues primero vamos a hablar un poquito de los arrays 01:21:11

y si nos da tiempo hablamos de ese for hoy y si no, pues lo comentamos 01:21:15

luego en la siguiente clase. Cuando estamos 01:21:19

trabajando con nuestros programas, al final tienen 01:21:25

que ir haciendo cosas sobre datos. 01:21:29

Si queremos 01:21:34

imprimir facturas, pues al final tendremos 01:21:37

que coger el nombre de la persona esa 01:21:39

a la que le vamos a enviar la factura o la publicidad 01:21:41

de algo, por no entrar con facturas que 01:21:43

nos va a tocar pagar si no. 01:21:45

Y el nombre de esa persona, pues en un momento dado 01:21:47

habrá que ir guardándolo en algún sitio, que 01:21:49

será una variable 01:21:51

invita que sea de tipo string 01:21:52

para guardar una cadena de caracteres. 01:21:55

A lo mejor esa persona tendrá 01:21:58

un saldo en una cuenta, si es de un 01:21:59

banco, y eso lo tendremos que poner 01:22:01

en una variable de tipo entero. 01:22:03

Habrá un momento en el que 01:22:05

Durante la ejecución del programa en un determinado ámbito, vayamos a definir una variable tipo long, si tenemos mucho dinero, o una variable tipo int, si tenemos un poco menos. 01:22:07

Con el int ya, si lo llenamos de números, ya sale un número interesante para tenerlo en euros en nuestra cuenta. 01:22:16

Entonces, esas variables, estos días atrás hablábamos que existen las variables primitivas, que hacen la reserva esa de memoria RAM directamente, y las referenciadas. 01:22:24

diferenciadas. Por ejemplo, un objeto de una clase 01:22:33

que estamos definiendo nosotros, que para hacer la reserva 01:22:36

de memoria RAM utilizábamos el new. En nuestras clases 01:22:39

definimos, aparte de los parámetros, 01:22:45

por ejemplo, el nombre este que decimos o 01:22:48

la cantidad de dinero que tenemos, definimos una serie 01:22:50

de métodos para poder ir trabajando y haciendo cosas 01:22:53

con los objetos de esa clase. 01:22:56

Y en las primitivas decíamos que 01:22:59

cuando definimos un int i, 01:23:02

y si poníamos aquí un y punto, no nos ofrecían 01:23:04

nada de clase. Estas variables de tipo primitiva solamente son la variable 01:23:12

y ya está. En cambio, como a veces queremos hacer cosas con estas variables, 01:23:16

teníamos las clases Wrapper, las clases Wrapper 01:23:21

que envuelven a los tipos primitivos, por ejemplo, 01:23:24

la clase Integer tenía una serie de métodos estáticos que no teníamos que 01:23:28

instanciar un objeto, también hablábamos de la etiqueta estática, 01:23:32

Entonces, si poníamos aquí un punto, ya nos ofrecía cosas, parámetros y cosas que hacer con ella, las clases Wrapper. 01:23:36

Es muy típico y sobre todo trabajando con bucles, querer hacer una serie de cosas que se vayan repitiendo sobre un conjunto de datos que son del mismo tipo. 01:23:47

¿Qué conjuntos de datos del mismo tipo tenemos? Pues tenemos dos posibilidades y hay temas por delante que hablaremos bastante de ellos. 01:24:00

No os preocupéis si no llegamos a grandes detalles. Por un lado están los Arrays y por otro lado están las colecciones. Las colecciones van luego por ahí por el tema 7 más o menos y los Arrays hablamos de ellos un poquito antes. 01:24:07

Cuando definimos un array, estamos definiendo un conjunto de datos que son del mismo tipo 01:24:20

y la reserva de memoria RAM para el conjunto de datos se hace en el momento en el que defines el array. 01:24:30

Esto quiere decir que podemos decidir tener un array de 20 clientes y definimos un array de 20 objetos de la clase cliente. 01:24:37

Podemos tener un array de 20 enteros y definimos un array de 20 enteros. En el momento en el que definimos el array de 20 enteros, el sistema, el programa pedirá al sistema operativo el trozo de memoria necesario para poder guardar la información de esos 20 enteros. 01:24:48

eso los arrays, son estructuras de datos 01:25:04

estáticas, estructura de datos porque podemos tener 01:25:08

conjuntamente una serie de datos y el tamaño de esos datos 01:25:11

lo cerramos en el momento en el que definamos la estructura 01:25:16

los accesos a este tipo de estructuras suelen ser rápidos desde el programa 01:25:19

eso está bien para el rendimiento, pero tiene un inconveniente, imaginaros 01:25:26

que intentamos hacer un array de los clientes que van a mi tienda 01:25:30

y en el programa yo digo, hago una suposición y digo 01:25:34

nunca en mi tienda va a haber más de 20 clientes, voy a definir un array de 20 clientes 01:25:38

y luego un día pongo una oferta y me llegan 21 clientes 01:25:42

pues ese array ya no me vale porque el tamaño del array lo tienes 01:25:46

que definir de antemano, como dijiste es que iban a ser 20 01:25:50

pues ha llegado el 21 y ese array ya no te da la funcionalidad de tener 01:25:53

todos los clientes que están en ese momento en tu tienda 01:25:58

inconveniente ventaja los accesos a raíz son más rápidos en comparación a lo que os voy a contar 01:26:01

ahora por aquí que son las colecciones o los mapas una colección lo que hace es ir creciendo es 01:26:08

también un conjunto de variables bien referenciadas o primitivas todas ellas del mismo tipo pero que 01:26:16

va creciendo hay un tema de colecciones vale lo veremos muy en profundidad más adelante pero ya 01:26:24

que os voy a contar los Arrays, os pongo en el contexto global de toda la situación. 01:26:30

Entonces, las colecciones van creciendo en función de la demanda. Es decir, yo tengo 01:26:34

una colección para, yo defino una colección de clientes como los que van 01:26:38

a ir a mi tienda y de primeras, cuando defino la colección, no cierro 01:26:42

un tamaño, como si pasan los Arrays. Entonces, la colección 01:26:46

está vacía. Si viene un primer cliente, añado un cliente y es 01:26:50

en ese momento para ese cliente, para el que se hace una reserva de memoria, pero para ese 01:26:54

cliente, no para el conjunto de clientes que preveo puede 01:26:58

haber en mi tienda en un futuro. Viene un segundo cliente, 01:27:01

pues reservo memoria para un segundo cliente. Se marcha un cliente, 01:27:04

pues a la par que en mi código 01:27:07

hago las cosas que correspondan a que el cliente 01:27:10

deja mi tienda, elimino de la colección ese cliente 01:27:13

y se libera la memoria RAM que estaba ocupando ese segundo cliente 01:27:16

y se me queda la colección con uno solo. Como hay que hacer 01:27:19

más gestión que con los arrays, que ya está la memoria 01:27:24

reservada y no hay que andar haciendo o deshaciendo, 01:27:27

Las colecciones en cuanto a rendimiento suelen ser un poco más costosas que los accesos a los arrays, pero bueno, tienen algunas muchas ventajas también. Y una de ellas, por ejemplo, es que imaginaros que me gusta mucho el fútbol y voy a un estadio que tenga 50.000 espectadores. 01:27:30

entonces mi programa tendría que tener 01:27:47

en consideración, si lo quiero hacer 01:27:50

un array de espectadores 01:27:52

tendría que hacer una reserva de antemano 01:27:54

en el momento en el que lo defino 01:27:56

de 50.000, para 50.000 personas 01:27:57

con lo cual bloquearía 01:28:00

mucha memoria RAM para esas 50.000 01:28:02

posibles espectadores que van a ir a ver 01:28:04

mi partido, y resulta que ese día 01:28:06

en lugar de ir a ver al 01:28:08

equipo principal 01:28:10

al equipo principal, es un partido 01:28:11

de Alevines y van 10 padres 01:28:14

Pues resulta que, si lo he hecho con un array, obligatoriamente en el sistema estoy bloqueando espacio para esos 50.000, aunque luego voy a utilizar simplemente 10. 01:28:16

Cosa que no me sucede con las colecciones, porque como lo voy haciendo bajo demanda, el día que hay 50.000 reservaré espacio de memoria RAM para 50.000 y el día que haya 10.000 la reservaré para 10.000. 01:28:26

Estas, los arrays, se llaman estructuras de datos estáticas y estas se llaman estructuras de datos dinámicas. 01:28:38

Las colecciones ya las veremos y una vez puesto en contexto vamos a hablar un poquito de los Arrays. 01:28:45

¿Cómo definimos los Arrays? 01:28:51

En los Arrays la característica que tienen es que definimos un conjunto de variables, 01:28:53

todas ellas a través del mismo número y hacemos su reserva de forma inicial. 01:28:58

En algún ejercicio ya hemos hecho uso de algún Array y desde el primer día los hemos tenido a la vista. 01:29:03

Esto es un Array de Strings. 01:29:09

args es un array de strings 01:29:11

las teclas que se asocian a los arrays son los corchetes 01:29:15

si lo que quiero es definir dentro de mi código un array de enteros 01:29:21

pues puedo definir ir, aquí le doy el nombre común 01:29:24

a todos ellos y ponemos los corchetes que los podemos poner antes 01:29:29

o después del nombre, podemos poner inar 01:29:34

ponemos aquí un igual a new, int 01:29:38

tres. Vamos a poner. Mirad, este array 01:29:41

inar es un array 01:29:47

de enteros. Y si ponemos inar 01:29:53

entre corchetes, cada uno de ellos será un entero. 01:29:56

El número de enteros que estoy definiendo en este 01:30:01

caso es tres. Le hemos dado ese tamaño inicial que os decía. 01:30:05

Con lo cual, esta instrucción 01:30:10

lo que habrá hecho habrá sido ir a la memoria RAM y decir necesito espacio para tres variables de tipo entero. 01:30:13

Y ese espacio para los arrays se reserva en memoria RAM de forma contigua. 01:30:23

Entonces el sistema operativo dirá pues en la posición, es decir, la 20.000, por ejemplo, 01:30:29

a partir de esta posición voy a hacer una reserva para tres enteros y el primero de los enteros estará en la posición 20.000, 01:30:35

el segundo estará en la posición 20.000 más el espacio que ocupa un entero 01:30:41

y el tercero de ellos estará en la posición más el espacio que ocupan dos enteros. 01:30:49

Y lo que dice es que a la posición 20.000, como si fuera un puntero, 01:31:01

una referencia de las que hablábamos en clases anteriores, es donde apunta IAR, la variable IAR. 01:31:06

y ar que es un array de enteros 01:31:13

y ar apunta a la posición 20.000 01:31:16

el tamaño total es de 3 enteros 01:31:19

entonces si yo cojo y digo 01:31:23

y ar entre corchetes 01:31:25

empiezo a poner aquí un índice 01:31:27

empezando por 0 en los arrays 01:31:28

lo que decimos es que y ar y corchetes 01:31:30

si lo vemos aquí en la definición 01:31:35

y ar y corchetes que es un entero 01:31:37

entonces y ar es un array de enteros 01:31:39

IAR es una raya de enteros 01:31:44

IAR entre corchetes es un entero, es una variable de tipo entero 01:31:47

Entonces aquí podré coger y asignarle un valor 01:31:53

de un valor entero, igual que aquí 01:31:56

consideramos que I era un entero y le asignábamos un valor de entero 01:31:59

Es decir, con IAR 0 trabajamos como un entero 01:32:04

¿En qué posición se empezará a guardar en memoria RAM este 5? 01:32:10

pues empezará a guardar, si IAR apunta al 20.000 y este es el primero, pues hemos dicho que el primero de los enteros empezará a guardarse en la posición 20.000. 01:32:15

Si yo digo IAR1 igual a 15, resulta que aquí lo que hará será, dirá, IAR está en la posición 20.000, 01:32:29

quiero trabajar sobre el entero, no el primero sino el segundo 01:32:38

que es el que tiene el índice 1, pues irá a la posición 20.000 más el espacio 01:32:43

que ocupa un primer entero, y en esa zona de memoria RAM guardará un 15 01:32:48

y con la misma idea, si guardamos para 01:32:52

IR2, el 25, este IR2 01:32:58

vendrá al 20.000, se fijará en el índice 01:33:02

conocerá que es un array de enteros sobre el 20.000 01:33:06

considerará el espacio de un entero por 2 01:33:11

y en esa posición será donde me guarde 01:33:14

el 25. Es decir, 01:33:17

podemos trabajar con variables de tipo 01:33:20

entero. Fijaros que 01:33:22

aquí lo que hemos dicho es que son 3 enteros 01:33:25

y para cada uno de los 3 enteros no hemos 01:33:29

hecho ningún new. ¿Por qué? Porque los tipos enteros son primitivos 01:33:32

de Java y venimos diciendo que cuando definimos 01:33:35

un tipo entero, no es necesario hacer el new. 01:33:37

Hemos hecho un new, es cierto, para dar tamaño a un array, 01:33:41

pero no para cada uno de los enteros, 01:33:44

cosa que sí tendremos que hacer luego con los tipos referenciados en los arrays. 01:33:47

Continuamos con ello haciendo un ejemplo en algún momento. 01:33:52

Entonces, fijaros, los arrays, que son estructuras que tienen elementos iguales, 01:33:57

del mismo tipo, trabajan mucho con los bucles. 01:34:05

Si ponemos aquí un for y decimos int i 01:34:09

igual a cero, para recorrer todos los elementos 01:34:13

de un bucle, decimos mientras i 01:34:18

esta variable sea menor, y los arrays 01:34:21

tienen una serie de métodos también, decimos menor y una serie 01:34:27

de parámetros. Todo array tiene la longitud que le hemos 01:34:31

asignado a través del parámetro length, que esa length se ha aplicado de inicio al crear el array 01:34:35

aquí y decimos aquí un y más más, se me queja aquí porque ya tengo definida la variable y la voy a 01:34:44

quitar, pues yo puedo coger y decir system.out.println valor de la posición y del array 01:34:57

de la posición y del array 01:35:14

es, y aquí pongo el entero 01:35:23

y ar y, a ver que es lo que me he dejado 01:35:28

por ahí, me falta un más aquí, no sé si se entiende este for 01:35:39

cuando inicializo una variable y 01:35:45

que mi intención es utilizarla como índice en el array 01:35:49

irá desde la posición 01:35:54

0 hasta mientras sea menor que la longitud que tiene la raíz la longitud que tiene la raya es 01:35:58

de 3 entonces como incremento y de uno en uno ejecutará esto para la posición valor de y 0 01:36:07

para valor de y 1 también que es menor que la longitud para valor de y 2 para valor de y 3 ya 01:36:14

no me lo ejecutará con lo cual las posiciones sobre las que ir trabajando en el array será 01:36:21

la 0, la 1 y la 2 y mostrar aquí su valor 01:36:25

y para ayudarme, en la posición 01:36:29

cuando i valga 0, la posición 0, me mostrará el valor de la raíz en la posición 0 01:36:33

la posición 1, me mostrará el valor de la raíz en la posición 1 01:36:37

posición 2, me mostrará el valor de la raíz en la posición 3 01:36:41

y cuando i valga 3, ya esto no lo va a ejecutar porque 01:36:45

para el valor de 3, cuando i valga 3, ya no será menor que la longitud 01:36:49

del array, porque se lo hemos asignado a 3, ya será igual, con lo cual 01:36:53

saldrá del for y se terminó, entonces si damos aquí una ejecución 01:36:58

pues nos dice para la posición 0, 1 y 2 01:37:10

el array, el entero del array vale 0, lógico 01:37:15

los enteros por defecto se inicializan a 0 y no hemos 01:37:19

modificado ninguno de los dos valores, de todos los valores 01:37:22

entonces ponemos aquí por ejemplo, keyArr 0 01:37:26

valga 1 01:37:29

vamos a decir que la posición 1 01:37:32

valga 10 01:37:35

y la posición 2 valga 15 01:37:38

fijaros como ha ido accediendo 01:37:43

a las diferentes posiciones 01:37:49

aquí con asignación a enteros 01:37:50

que tenemos disponibles en el array 01:37:53

y por aquí 01:37:55

luego a cada una de las posiciones 01:37:56

a través de un bucle 01:37:59

entonces los bucles y los arrays 01:38:00

pues suelen ser muy amigos 01:38:02

solemos utilizar muchas veces bucles recorriendo a raíz para trabajar sobre el elemento de la raya 01:38:04

aquí mostramos su valor por pantalla pero otras veces pues haremos otras cosas de igual forma que 01:38:14

recorremos los a la raíz también es posible recorrer pero ya lo veremos las colecciones 01:38:20

alguna cosilla por ahí alguna duda vale pues pues yo creo que casi lo vamos a ir dejando por aquí 01:38:26

y ya, no sé si tenéis alguna consulta más por ahí 01:38:49

el próximo día terminamos de ver los bucles 01:38:53

el for each 01:38:56

y ya está, yo creo que no da mucho más de sí la teoría 01:38:57

de este tema, entonces el próximo día 01:39:02

si no me planteáis cosas en los foros 01:39:04

que queráis que atendamos más en la tutoría 01:39:07

pues no sé, miramos, completamos con el for each 01:39:10

y abrimos algunos ejercicios 01:39:14

de los que os propone 01:39:17

y que vayáis haciendo 01:39:19

y lo vamos resolviendo aquí en la tutoría 01:39:20

algunos de ellos 01:39:22

vale 01:39:23

pues os parece 01:39:27

vamos cerrando, os parece entonces 01:39:30

no tenéis ninguna consulta que hacerme 01:39:32

vale, pues nada 01:39:33

pues detengo la 01:39:39

2024-11-11-Programacion - Contenido educativo

Del mismo autor…

1TRIMESTRE INFANTILD

Clase11_Aceleración

¿Dónde vas con mantón de Manila?

Una noche en el museo de Ciencias Naturales

Pasos de chotis

Cambia los fondos con Scratch para hacer una portada cuando programes un juego

El baile de Santa