2024-11-18-Programacion | Mediateca de EducaMadrid

grabando lo que decía que el mañana comenzamos un nuevo tema y es un tema introductorio a la 00:00:00

programación orientada objetos entonces formalmente se habla de lo que ya bien más de lo que es una 00:00:07

clase de lo que es un objeto en ese tema hablaremos de los métodos hablaremos de los atributos 00:00:13

y en realidad desde el día cero pues hemos estado hablando de todo esto porque estos primeros temas 00:00:21

por ejemplo el tema en el que estamos ahora estructurar de control si hablamos de un for 00:00:27

y de forma aislada casi es imposible cuando estás haciendo el programa evitar hablar de que va metido 00:00:31

en una clase y ya que decimos que ante una clase hablar un poquito de que va y que está dentro de 00:00:37

un método con lo cual desde el día cero ya estamos hablando de todos estos conceptos bueno pues 00:00:42

formalmente volvemos a repasarlos y profundizaremos algo más ya en este nuevo tema hoy bueno vamos a 00:00:47

a terminar de hablar un poquito de bucles y haremos algún ejercicio no sé si nos da si no 00:00:55

tenéis dudas para mucho ya los contenidos que tenemos abiertos pero bueno echaremos un rato 00:01:01

hasta que hasta que se nos acabe la gasolina digamos mirad en lo que hay en la cuenta no sé 00:01:06

si insistir suficientemente en las estructuras de control de repetición la clase anterior bueno 00:01:15

Decíamos, por ejemplo, en el for que teníamos estos tres elementos por aquí, que venía a ser inicialización de variables, aquí la condición en un segundo campo dentro de los paréntesis del for y luego aquí teníamos normalmente la evolución de la variable que comparamos aquí y que nos permite esta evolución garantizar que el bucle no es infinito, sino que termina en algún momento. 00:01:21

pero en realidad en esta estructura podemos poner casi cualquier cosa, aquí va una instrucción de código que podríamos poner lo que fuese, de hecho aquí estamos poniendo una instrucción en la cual estamos incrementando ahí, pero podría ser, no sé, podríamos poner aquí probablemente, yo creo que nos dejaría un system out, vamos a ver, println por ejemplo, de i++, 00:01:47

fijaros como esto compila 00:02:17

durante la ejecución 00:02:19

cada vuelta en el bucle hará esto 00:02:21

y también hará esto 00:02:24

igual que si lo pusiéramos 00:02:26

fuera de un 00:02:27

como una instrucción cualquiera 00:02:29

entonces vamos a hacer una ejecución 00:02:32

de esto 00:02:34

fijaros como 00:02:36

aquí nos va mostrando 00:02:40

esto justo es el 00:02:42

consecuencia de esta instrucción 00:02:43

que hay aquí 00:02:46

Lo que quiero decir es que aquí podemos tener cualquier instrucción, si tenemos un método dentro de la clase que sea el método saludar, por ejemplo, poner public void saludar, que nos diga system.out.println un saludo, pues aquí podríamos llamar también al método saludar. 00:02:46

podríamos hacer una llamada al método saludar a ver qué es lo que pasa aquí pues éste no le gusta 00:03:17

a ver qué nos dice dice que no estamos en un tricat vamos a definirlo estático estático como 00:03:38

estático así que nos deja necesitamos un objeto para ejecutar este vale bueno luego os cuento 00:03:57

un poco el tema del static ya hemos hablado de él en algún momento si acaso os cuento luego un 00:04:03

poquillo de bueno fijaros como hemos hecho una llamada aquí a un método entonces en cada vuelta 00:04:08

aquí lo que podemos poner es código bueno llamará cada vez a saludar es cierto que en este caso como 00:04:13

hemos dejado de incrementar aquí pues resulta que esto se va a convertir en un bucle infinito si no 00:04:19

modificamos el valor de y en ningún sitio continuamente valdrá cero y todo el rato se 00:04:24

igual será menor que la longitud de la raíz entonces fijaros el y en realidad que aprovechamos 00:04:30

la estructura del for para ir incrementando lo habitualmente aquí pues lo podemos incrementar 00:04:36

aquí entonces en cada vuelta y incrementará y es cierto que aquí no lo estamos incrementando pero 00:04:40

sí que llegará a cumplir la condición en la que sea ella al menos igual que la longitud de la 00:04:47

raíz y termine de ejecutar el bucle decidamos aquí fijaros como cada vez nos llama al método 00:04:53

un saludo definitiva que aquí podemos poner código el que toque y normalmente está pensado en el for 00:05:00

para trabajar sobre la variable que nos sacará en un momento dado del bucle para que no se convierta 00:05:08

en infinito pero no es obligatorio aquí fijaros podríamos poner mirad podríamos poner aquí una 00:05:16

variable de tipo entero también j que sea igual a cero y aquí utilizar en realidad j 00:05:24

es también me compila fijaros que la variable que inicial hizo aquí es una variable y que a 00:05:34

lo mejor la puede utilizar dentro del ford para alguna otra cosa y sobre la que realmente busco 00:05:40

la condición para salirme sobre j les podría poner aquí jota más más expulsamos aquí y fijaros tiene 00:05:46

ese comportamiento. Ahora va iterando mientras j sea menor que la longitud 00:05:58

de la raíz y el sitio donde incrementamos j es aquí. 00:06:02

Lo que estoy haciendo es cambiar un poco el uso que tenemos 00:06:06

pensado de estos tres campos, que la verdad, su idea, tal como dice 00:06:10

la teoría, es definir la variable con la que trabajamos 00:06:14

principalmente para ir comparando aquí y luego ir manejándola 00:06:18

aquí, pero no necesariamente es así. Se traga prácticamente for cualquier cosa 00:06:22

en tanto en cuanto, esto sean instrucciones, en tanto en cuanto aquí trabajamos para inicializar una primera vez ciertas variables que a lo mejor nos interesen por aquí 00:06:26

y no obligatoriamente tengan que ser la que utilizamos aquí en la condición. 00:06:36

Y luego el ejercicio más típico, pues ya os digo, es poner aquí un i++ y si queremos recorrer, por ejemplo, todos los elementos de un array, ir uno a uno, 00:06:42

incrementando y más más pero podría ser que quisiéramos mostrar con un bucle todos los 00:06:55

valores pares pues que podríamos hacer aquí es decir igual a cero mientras si se amen parece 00:07:00

entre cero vamos a suponer entre 0 y 5 y 30 y 20 porque no nos hagan tantos números pues este 00:07:08

bucle lo que nos haría aquí es seguir incrementando y de uno en uno aquí podríamos hacer para comprobar 00:07:15

si es par, un if. Imaginaos que lo que buscamos es que sea par, es decir, mientras i hacemos un tanto por ciento 00:07:22

el módulo de la división. Fijaros, esto no me compila porque el if aquí espera algo que se pueda evaluar 00:07:32

como verdadero o falso. Realmente el i tanto por ciento dos me va a devolver un número, que será un cero o un uno, 00:07:40

Es decir, no es verdadero o falso. Para comprobarlo, podríamos poner aquí que sea cero, y ahora ya sí que me compila porque esta comparación valdrá cero o uno, pero si es igual a cero me devolverá true, si es distinto de cero, falso. 00:07:47

Es decir, ya lo del if sí que se puede evaluar como un verdadero o falso. 00:08:03

Entonces ponemos aquí un system.out.println de i. 00:08:07

Entonces esta ejecución, fijaros que este código, 00:08:15

me ha resultado ser un bucle infinito y fijaros que no terminaba nunca 00:08:19

porque aquí mantenía la j como condición para salirse del bucle. 00:08:29

Entonces j siempre era menor que 20 porque lo habíamos inicializado aquí a 0 00:08:33

y no modificábamos su valor, tendría que ser aquí una i 00:08:38

entonces damos de nuevo a la ejecución 00:08:41

y efectivamente me muestra los números pares 00:08:44

habrá entrado tantas veces 00:08:48

habrá entrado 20 veces porque estamos haciendo el incremento de i 00:08:52

de uno en uno, pero solamente escribe aquellos que sean pares 00:08:56

que son los que cumplen la condición de 00:08:59

validar si es par el número aquí o no 00:09:01

pero fijaros en este caso lo que podríamos haber hecho 00:09:04

en lugar de este código, que efectivamente responde a lo que nosotros buscamos en el enunciado, 00:09:07

lo que podríamos haber hecho es, sabemos que vamos a entrar con i igual a 0, 00:09:13

que lo estamos considerando como un número par, ¿verdad? Porque de hecho lo es. 00:09:18

Y el siguiente que tiene que mostrar es el 2 y el siguiente el 4, es decir, vamos dando saltos de 2 en 2. 00:09:22

Entonces aquí podríamos poner 1 y más 2. 00:09:28

Entonces i, una vez que ejecuta cada uno de los bucles, lo que hace es sumarle 2 00:09:35

y ahora no hacemos ninguna comprobación 00:09:39

aquí, sino que mostramos directamente i. 00:09:41

Ya los números 00:09:44

impares, 00:09:45

para números impares no entraría aquí en el 00:09:46

for. Iría incrementando 00:09:49

de dos en dos. Entonces si damos aquí, 00:09:51

ahora, 00:09:54

efectivamente, nos ha mostrado los números pares 00:09:55

porque hemos ido dando saltos de dos 00:09:57

en dos aquí, en el incremento 00:09:59

de i. ¿Dónde quiero ir a parar? 00:10:01

Pues que aquí trabajaremos con 00:10:04

la instrucción que nos interese en un momento dado. 00:10:06

Imaginaos que... 00:10:11

Que bueno, que en el algoritmo que pongamos por aquí, lo que tenga que pasar durante el código, puede resultar que el valor de i lo queramos modificar por algún motivo. 00:10:13

Entonces podría ser que además de esta instrucción que va modificándome i, pues coger y decir que i lo incrementamos aquí. 00:10:24

vamos a hacer un supuesto 00:10:34

o sea, en este caso 00:10:36

lo que he hecho ha sido modificar que no sea 00:10:38

necesariamente el incremento de 1 en 1 00:10:40

aquí podemos trabajar con cualquier operación 00:10:42

para ir actuando sobre i 00:10:44

y aquí lo que quiero enseñar es que 00:10:45

no necesariamente los cambios de la 00:10:48

variable sobre la que trabajamos aquí 00:10:50

igual que nos ha pasado antes cuando hemos definido j 00:10:52

los podemos también ir manipulando 00:10:54

aquí 00:10:57

entonces aquí i se modificará 00:10:57

tanto aquí como aquí 00:11:00

Y al definirlo como un parámetro de la etiqueta for, de la instrucción for, actúa como una variable local para el ámbito del for. 00:11:01

Entonces existe aquí, aquí se inicializa, por aquí se modifica, aquí dentro del for está disponible y también podemos ir actualizándola. 00:11:13

Entonces en este caso iremos con i de 3 en 3, 1, 4, 7, 10, 13, porque 2 se están incrementando aquí, y en cada iteración 1 más aquí. 00:11:21

Vamos a suponer que nos dicen, mete 5 números, se introduce por teclado, 5 números entre el 1 y el 10, por ejemplo. 00:11:35

Entonces podríamos decir, mira, lo que quiero es meter cinco números, hacemos aquí el for, quiero cinco, con lo cual voy a hacer un i++, y quiero que sean cinco números, sí o sí. 00:11:48

Entonces, como es por teclado, recordad, podríamos coger aquí y definir una variable de tipo scanner, scanner, myscan, igual a new scanner, y aquí decir que lo enlazamos con system in, y esto lo vamos a importar desde las librerías de Java útil. 00:12:00

Repasamos un momentito lo que hemos hecho aquí con esta instrucción. 00:12:32

Decíamos que en Java tenemos flujos de datos que permiten comunicar nuestro programa con el mundo exterior. 00:12:36

Es como si tuviéramos una tubería y un extremo de la tubería. 00:12:43

En cualquier caso de los flujos de datos, un extremo de la tubería está pinchado en nuestro ordenador 00:12:46

y el otro extremo lo queremos enchufar por ahí en algún sitio. 00:12:51

En particular, el flujo de datos System.in, el otro extremo de la tubería donde está pinchado es el teclado. 00:12:55

y nos permite desde teclado meter información dentro de nuestro programa. 00:13:02

System.in no he tenido que hacer un import como si lo hemos hecho de escáner 00:13:09

porque System.in está definido en el paquete Java, Java lang 00:13:15

y todo lo que he definido en ese paquete se considera de tal importancia en los programas de Java 00:13:21

o de uso tan común que directamente se importa de forma automática. 00:13:26

Entonces, con System.in ya podríamos leer desde teclado. Y luego, también en los paquetes de Java, pues han hecho en otras librerías otros paquetes que tienen información quizás menos habitual, no me atrevería a decir menos importante, pero igual menos habitual que Java.lang. 00:13:32

y por lo tanto se considera que no se van a utilizar en todos los programas. 00:13:50

Y como es así, pues han dicho, pues directamente no se importa de forma automática 00:13:55

y quien necesite cada cosa particular de cada uno de los paquetes, que se preocupe de importarlo. 00:13:59

Y así no cargamos todos los programas con todas las clases de todos los paquetes 00:14:05

que tenemos definidas en absolutamente todas nuestras librerías. 00:14:09

Entonces, como Scanner no está definido en JavaLang, sino que está definido en la librería JavaUtil, 00:14:13

nos importa de forma automática y si queremos utilizarlo tenemos al principio 00:14:20

de nuestro programa que indicárselo en la cabecera con un import 00:14:24

esto es importame desde la librería java útil 00:14:27

la clase scanner y a partir de ese momento esta clase estará definida 00:14:31

allí en aquella librería y bueno por suerte 00:14:36

habrán hecho un montón de código que nos resulta 00:14:40

a nosotros útil para ir llamándolo de forma fácil a través de sus métodos y sus 00:14:44

parámetros. Entonces, la clase Scanner nos facilita 00:14:48

un acceso más sencillo a flujos de datos, que no 00:14:52

necesariamente tienen que ser SystemIn, podría ser el flujo de datos 00:14:56

la entrada de nuestro programa de información desde un fichero particular, como lo que 00:14:59

queremos ahora hacer es desde teclado, pues lo hacemos desde SystemIn. Y definimos 00:15:04

un objeto para nuestro programa 00:15:08

de la clase Scanner, igual que hemos hecho en otros casos, con el 00:15:11

new, pedimos al sistema operativo que genere la estructura 00:15:16

en memoria RAM necesaria para que este objeto sea capaz de funcionar 00:15:19

y luego, siempre después del new, acordaros que os comentaba 00:15:23

de esto hablaremos justo en el siguiente tema, lo volveremos a repasar 00:15:28

llamamos a un método que se llama igual que la clase 00:15:32

que son los métodos constructores que típicamente están pensados 00:15:35

para inicializar el objeto que estamos dando de alta 00:15:39

Primeras acciones que son necesarias para que ese objeto tenga el comportamiento que esperamos 00:15:43

luego durante la ejecución de nuestro programa. 00:15:48

En este caso, hará lo que esté programado en este método de la clase Scanner constructor 00:15:52

y además le pasamos por aquí información como parámetro para que tenga en consideración Scanner 00:15:58

que este objeto tiene que trabajar en particular con el flujo de datos Systeming 00:16:03

que es entrada desde teclado. 00:16:08

Bueno, un repasazo aquí a la línea esta por hablar un poco de terminología de Java y de la que hemos ido comentando y pegar un pequeño repaso. Una vez hecho esto, que la hemos importado desde esta librería, queremos utilizarla por aquí. 00:16:09

Y estábamos planteándonos que el programa queríamos, a través de un bucle lo estábamos pensando, recoger cinco números enteros y que su información estuviera entre 0 y 10. 00:16:25

era la condición que nos estábamos poniendo, entonces vamos a leer esa información desde aquí, entonces si yo pongo, digo aquí int string s info, aquí estoy definiendo una variable s info y digo s info igual a mi scan, 00:16:43

estoy diciendo voy a utilizar algo del objeto 00:17:08

en mi scan que voy a cargar en ese info y en particular lo que quiero 00:17:12

hacer es leer una línea, next line, y esta 00:17:15

información, bueno, pues podría, si voy a 00:17:20

trabajar con la información por aquí como tipo de 00:17:23

datos entero, pues podría hacer un parseInt, os acordáis 00:17:26

integer parseInt para pasar una variable entero, como simplemente 00:17:29

de momento lo voy a escribir en un system out, no lo voy a transformar 00:17:32

directamente, me voy a quedar aunque sea un número 00:17:35

bueno, sí, sí lo voy a transformar mejor 00:17:38

para una condición que voy a hacer ahora 00:17:40

entonces pongo int y val 00:17:42

vamos a definir aquí una variable de tipo 00:17:44

entero 00:17:46

y voy a decir que i val 00:17:47

sea igual 00:17:50

integer punto 00:17:51

parse int de un string que sea 00:17:54

ese info 00:17:56

nos paramos un par de minutitos en esta instrucción 00:17:57

para recordaros que 00:18:00

luego lo retomo también 00:18:02

para contaros otra cosa, pero en Java tenemos 00:18:04

tipos de datos primitivos algunos que que bueno pues que están digamos integrados y se consideran 00:18:06

con este nombre dentro de java y luego otros referenciados que por ejemplo podrían ser objetos 00:18:13

de clases que construyamos nosotros de la clase persona cuando la tengamos generamos un objeto 00:18:18

pues estaría referenciado fijaros los tipos de datos primitivos si ponemos aquí y val y un punto 00:18:24

¿Veis? Eclipse no me ofrece métodos que utilizar, no me está dando la posibilidad de trabajar con métodos. Los tipos primitivos no nos dan opciones, simplemente el tipo de datos con un espacio de memoria RAM donde guardar, en este caso en particular, un valor que sea de tipo entero, pero no tiene métodos para trabajar con ellos. 00:18:32

Al contrario de los referenciados, este por ejemplo es uno referenciado, es un objeto de esta clase y si le ponemos aquí miScan, al pulsar aquí, no me lo está ofreciendo porque no está compilando aquí, yo creo, aquí sí que me ofrece métodos. 00:18:58

¿Por qué? Porque este es un objeto referenciado, que es una variable referenciada correspondiente a un objeto de una clase que tiene definido, a la hora de haberlo programado, métodos, igual que el main aquí para esta clase, y atributos. 00:19:22

Es decir, los primitivos no tienen métodos atributos y los referenciados sí que los tienen. 00:19:38

pero sí que es cierto que nos interesa que los tengan 00:19:43

o sea, sí que es verdad que relacionado con lo que sería un valor entero 00:19:48

pues hay cosas, hay funciones que me van a resultar útiles 00:19:53

como los primitivos no tienen esa posibilidad de tener 00:19:56

métodos definidos, hay definidas una serie de clases que le dan 00:20:00

ese soporte a los variables primitivas 00:20:04

que son los wrapper, como hemos dicho, entonces para variables 00:20:08

de tipo int, pues tenemos la clase Integer, que si la pulsamos 00:20:12

por aquí, pues nos da ciertas funciones que típicamente 00:20:17

van a estar muy relacionadas con los tipos enteros. 00:20:20

Entonces esto sería una clase Wrapper que va de la mano de un tipo de datos 00:20:25

primitivo, que al no tener esa posibilidad de definir los datos primitivos 00:20:28

métodos para manipular ese tipo de datos, pues los tenemos 00:20:32

a través de la clase Wrapper. 00:20:37

envoltoria, clase envoltoria 00:20:38

que diríamos, un poco traduciendo 00:20:42

a la vez del inglés, entonces aquí 00:20:45

utilizando la clase grouper y el método parseInt 00:20:47

pasamos como parámetro 00:20:51

un string que en principio va a ser un número pero en formato cadena 00:20:53

de caracteres y nos lo convierte a ese mismo número 00:20:57

pero en formato numérico y lo guardamos 00:21:00

en esta variable de tipo entero que es 00:21:02

un tipo de datos primitivo. Se tiene que apoyar los datos primitivos en las 00:21:05

clases Grouper para disponer de ciertos métodos que nos den 00:21:12

funcionalidades. La ventaja es que no tenemos que andar 00:21:16

de forma explícita en el código haciendo reservas con 00:21:19

métodos, con el instruccionio, igual que sí que hemos hecho aquí para el objeto 00:21:24

que es una variable referenciada del tipo Scanner. 00:21:27

Otra vueltecilla, le damos a unos cuantos conceptos para 00:21:35

poner esta línea aquí y en definitiva aquí tendremos un valor y en el ejercicio estábamos 00:21:38

diciendo recibir cinco valores que todos ellos estén entre 0 y 10 si no están entre 0 y 10 no 00:21:45

me interesan esos valores yo lo que quiero es que sean 5 fijaros no me estoy obligando tanto a que 00:21:52

se ejecute cinco veces el for sino que los cinco valores que me dan estén entre 0 y 10 en este 00:21:58

enunciado que estamos proponiéndonos para el ejercicio. 00:22:03

Entonces resulta que aquí habré podido coger un valor que estará entre 0 y 10 00:22:07

que me gustará y un valor que no estará entre 0 y 10 y no me gustará 00:22:11

tanto, con lo cual querré seguir dando vueltas aquí en el 00:22:15

bucle. Con esta condición que tenemos aquí en el for 00:22:19

en cada iteración incrementamos en 1 el valor 00:22:22

de i, con lo cual lo que tenemos es que va a dar 5 vueltas al for. 00:22:27

Pues resulta que si en las cinco vueltas metemos el número 20, ninguno va a estar entre 0 y 10 y no habré cogido absolutamente ninguno de los números en el rango que tenía, en el que estaba yo interesado. 00:22:31

Pues aquí, por ejemplo, podríamos utilizar otra sentencia esta de control, en este caso una condicional para ver si este valor es de los que me interesan. 00:22:42

Entonces digo, if sí. Dentro del if tengo que meter aquí una condición que se evalúe a verdadero o falso y que cumpla con mis expectativas. 00:22:52

Entonces puedo decir, si i es menor de 0 o i es mayor de 10, en ese caso, si se da una de estas condiciones, el dato no me interesa. 00:23:01

entonces aquí que podría hacer 00:23:21

no considerarlo, me interesa cuando el dato 00:23:24

en este caso, ahora intentamos dar la vuelta a ese if 00:23:28

para tener la instrucción de cuando me interesa en el if 00:23:31

system.auth.println 00:23:34

ponemos aquí, dato 00:23:37

leído, y lo he leído y lo he cargado aquí 00:23:43

en ival, bueno he cometido un error porque el dato 00:23:50

en realidad que quiero evaluar no es la i 00:23:55

sino que es el dato que estoy leyendo 00:23:58

desde teclado, que es ival 00:24:00

sería aquí, si ival 00:24:02

e ival 00:24:04

y si no me interesa 00:24:06

no escribo nada 00:24:08

¿pero qué pasa si no escribo nada? pues 00:24:11

no ejecuta lels 00:24:12

me termina la estructura 00:24:14

llega al final del ámbito 00:24:17

del for, y que sea lo siguiente 00:24:19

que haga, y más más 00:24:21

aquí leo 5 veces, como os digo un 20 00:24:22

ninguna de las veces me entrará por aquí 00:24:25

todas por aquí, no me mostrará nada por pantalla y se saldrá del bucle 00:24:26

y no habremos mostrado ningún número que tenga ese dato 00:24:30

vamos a hacer una ejecución, aunque antes de, bueno 00:24:34

voy a ejecutarlo sin modificar lo que iba a hacer, para que veáis la 00:24:38

consecuencia que tiene, fijaros que el programa lo tengo en ejecución 00:24:42

y muy bien, y estoy un poco desamparado, sin saber lo que voy a hacer 00:24:47

porque me ha ejecutado el programa, me ha entrado aquí y se me ha quedado aquí 00:24:50

en el next line esperando recibir un dato pero como no he puesto un sistema println pidiéndome 00:24:54

el dato que quiero leer aquí por teclado pues el programa se me ha quedado aquí no sé muy bien lo 00:25:01

que va a pasar o lo que espera el programa de mí es mejor vamos lo paro por aquí y vamos a poner 00:25:05

aquí un sistema println pidiendo ese dato dime un número entre 0 y 10 si ponemos un sistema 00:25:13

print el n, me va a mostrar esto y me va a saltar a otra línea. Si utilizo el método system print, 00:25:30

me va a poner esto y se va a mantener ahí en la misma línea. Quizás sea más interesante para que 00:25:36

el cursor se me quede a continuación de los dos puntos y poder escribir el número. Entonces lo doy 00:25:41

por aquí, ejecutar, me dice dime un número, mira si le digo 20, se me va a otra iteración, como el 00:25:49

número no ha cumplido, ha cumplido esta condición, el 20 es mayor que 10, se me ha metido por aquí, 00:25:56

no ha hecho nada, ha dado una vuelta y me vuelve a pedir esto. Pongo ahora menos 2 aquí, otra vez 00:26:03

las mismas, fijaros que ha salido y en realidad no me ha mostrado nunca el dato. ¿Qué podríamos 00:26:09

hacer aquí para descontar cada iteración en la que el número no nos ha interesado? Pues este 00:26:17

incremento que me hace aquí pues se lo podría incrementar aquí es entonces trabajando con la 00:26:22

y no solamente en esta parte del foro sino como parte según no lo exija nuestro algoritmo como 00:26:30

parte del código dentro del ámbito del foro pues tenemos la posibilidad de hacer que nuestro 00:26:38

programa se comporte como quiera si hemos incrementa esto en 1 y el número como metido 00:26:44

ha sido menos 20, al 00:26:51

decrementarlo aquí, pues vuelve a valer 00:26:54

si valía 0, valía 1 00:26:56

en esta iteración y he metido un 20, 00:26:58

pues aquí hago que valga 00:27:01

0 para que aquí vuelva a valer 1 00:27:02

y decrementar el que estoy incrementando aquí 00:27:04

porque realmente no ha sido un dato válido 00:27:06

al no salirnos por 00:27:08

dato leído. Es decir, que trabajamos con 00:27:09

la i según nos interese. 00:27:12

Entonces, si ponemos aquí 33, 00:27:17

pues no le gusta. En realidad 00:27:19

no sabemos qué valor tiene i, pero si ahora nos deja 00:27:20

coger 5 números, voy a poner otro 33. 00:27:22

tampoco le gusta, vamos a poner menos 1 00:27:25

menos 1, menos 1, menos 1 00:27:28

66 y fijaros que ya hemos dado más de 5 vueltas 00:27:31

a mostrar esto más de 5 veces y no nos hemos salido 00:27:35

porque estamos corrigiendo el valor de la i 00:27:37

a nuestro interés aquí como parte del código 00:27:39

entonces ahora voy a meter 4 números que si están bien 00:27:43

y ahora ya si que se nos sale 00:27:46

1, 2, 3, 4 y 5 00:27:48

efectivamente recogemos esos 5 números 00:27:52

Mira, vamos a suponer que dentro de este ejercicio resulta que, bueno, somos muy, muy supersticiosos y el número 13 no nos interesa. Mira, si metes el 13 me enfada tanto que te voy a sacar del bucle y no te voy a pedir más números. 00:27:54

entonces resulta que le podemos decir aquí que si es igual a 13 00:28:15

pues poner aquí una condición que haga que nos salgamos del bucle 00:28:20

una posible condición podría ser poner aquí i igual a un valor mayor de 5 00:28:23

con lo cual de golpe ya hace que esta condición no se cumpla y se salga 00:28:31

si ponemos aquí por ejemplo, bueno con 6 sería suficiente 00:28:36

vamos a poner que i sea igual a 10 00:28:39

o sea seguimos trabajando a nuestro antojo aquí 00:28:41

decrementamos para buscar que se escribieran cinco números. Aquí estamos buscando un mecanismo de salida 00:28:47

porque resulta que es que el 13 no nos gusta nada. Entonces, si ponemos un 13, no vamos a salir de él. 00:28:53

Le damos una ejecución, ponemos un 5, que es un número que está bien, ponemos un número que no se va a considerar, 00:28:59

y ahora si ponemos aquí un 13, no se me ha salido. Ah, vale, bien, cierto, no se ha salido. 00:29:07

y no es casual porque que ha pasado os acordáis que el if es auto excluyente pues el 13 cumple 00:29:18

esta condición y cumple está como se ha encontrado primero la condición del if ha ejecutado esto 00:29:25

y no me ha ejecutado el shift del 13 con lo cual ahora mismo este código no se va a ejecutar nunca 00:29:33

porque cuando sea 13 ya habrá cumplido esta condición y le valdrá está entonces vamos a 00:29:40

salir, vamos a modificar un poquito el código 00:29:45

voy a poner este antes 00:29:48

ahí está, para que juzgue antes el de 13 00:29:51

te lo doy por aquí 00:29:58

si le pongo un 5 le gusta, le pongo un 00:30:01

99 no le gusta, le pongo un menos 1 no le gusta 00:30:04

y si le pongo un 13 ya sí que se nos sale directamente 00:30:08

del bucle, al pasar, al valer 00:30:11

igual a 10, habrá un momento en el que nos interesará 00:30:13

seguramente hacer nuestros programas 00:30:22

que sean muy versátiles. Entonces aquí estamos 00:30:24

haciendo un programa que nos está recogiendo 00:30:28

si tenéis cualquier dudilla 00:30:31

o lo que se os ocurra me va a ir diciendo y variamos 00:30:33

un poco porque estoy un poco improvisando 00:30:37

sobre la temática justo que estamos viendo en este 00:30:39

aquí en el tema 2, pero vamos, no me importa 00:30:42

irme hacia otras cosillas. Bueno, pues 00:30:46

si queremos hacer que nuestro programa sea más versátil y no solamente que recoja 00:30:49

cinco números, fijaros, pues podríamos coger aquí, aprovechando además 00:30:52

que tenemos una entrada aquí de Scanner, si no, pues la podríamos definir 00:31:00

y decir, dime cuántos 00:31:04

números quieres leer. 00:31:10

Cuántos números que estén entre 0 y 10, 00:31:16

cuántos números tienen que cumplir esta condición. Entonces aquí podríamos coger 00:31:19

y definir una variable y un número de números, lo leemos con un slide y hacemos un parseInt a este número de números 00:31:25

y este número de números lo podemos utilizar aquí, en lugar de este 5 que tenemos aquí fijo, lo podemos poner aquí. 00:31:44

Es decir, mientras el valor de la variable i sea menor que el valor de la variable inunumer, pues se irá ejecutando el ámbito del for, dará tantas vueltas como eso. 00:31:52

Y en este caso, el número de números, digamos que vamos a leer, lo estamos cargando desde teclado, en esta instrucción, y luego convirtiéndolo a un valor entero. 00:32:07

Entonces ahora ejecutamos por aquí y decimos mira lo que queremos leer son dos números, decimos 4 y 5, pues ahí ya está, se nos terminó con dos números, si decimos lo que queremos leer son cuatro números, 3, 2, 4 y 5, pues se nos termina ahora con cuatro números, conseguimos un programa mucho más versátil. 00:32:17

desde teclado, estamos recogiendo el número de números que queremos leer 00:32:43

y luego trabajando en el for con variables en lugar 00:32:48

con un número entero, con un número fijo 00:32:52

podemos hacer que la cantidad de números sean diferentes 00:32:55

mira, imaginaos que tenemos un programa, eso no es tanto el bucle 00:32:59

sino de buscar, lo que os voy a comentar, de buscar que nuestro programa sea versátil 00:33:05

imaginaos que tenemos un programa que lo que nos 00:33:10

permite es, es capaz de imprimir el listado de los grupos que tenemos aquí en el instituto. 00:33:14

Entonces, pues está el grupo que viene a la asignatura de programación y el grupo que va a la asignatura de sistemas informáticos. 00:33:21

Probablemente muchos de vosotros estéis matriculados en los dos. 00:33:30

Entonces, lo que podríamos hacer es tener un método, en este caso quizás más que un FOR, 00:33:34

podríamos tener un método que nos cogiese desde teclado 00:33:42

el grupo sobre el que queremos recuperar la información 00:33:45

probablemente en una base de datos y sacarla por impresora. 00:33:50

Haríamos un programa versátil en tanto en cuanto nos serviría 00:33:54

para imprimir el listado de unos grupos o de otros. 00:33:57

Eso lo conseguimos metiendo información a través del teclado, 00:34:01

desde base de datos, desde ficheros y cargándolo en variables 00:34:05

que lo utilizaremos como parámetros en los métodos 00:34:08

aquí tenéis un parámetro para el método parseInt 00:34:11

o como variables que forman parte de la 00:34:15

información que tiene el form, en este caso. Mirad 00:34:19

otra cosilla, os voy a comentar, si nos venimos por aquí 00:34:27

al workspace de Eclipse, pues el programa 00:34:33

el proyecto sobre el que estamos haciendo estos ejercicios 00:34:40

no sé si es el prueba, clase print tiene pinta de ser el prueba 00:34:44

pues me meto al proyecto prueba 00:34:50

me meto al bin 00:34:54

y aquí tenemos el bytecode 00:34:56

consecuencia de la compilación a través del javaz 00:34:59

como hablábamos en las primeras clases 00:35:02

del código que tenemos aquí en clase print 00:35:05

si vamos al intérprete y ponemos java class print 00:35:07

pues fijaros, dice dime cuantos números quieres leer 00:35:11

vamos a poner aquí 3 00:35:15

vamos a poner un número grande 00:35:17

no le vale, vamos a poner 13 y se sale 00:35:21

es el código efectivamente con el que estamos trabajando 00:35:24

y a ver, no me acuerdo muy bien 00:35:28

a ver, por aquí en java 00:35:31

podemos poner run configuration 00:35:33

a ver, a ver, dame un minuto a ver si encuentro una cosa 00:35:37

si no ya la contaré en otro momento 00:35:44

si, aquí mirad 00:35:45

disculpad 00:35:52

Mira, aunque os lo comentaré, pues en otros días, ya que estamos hablando de que los programas sean versátiles, aquí estamos cogiendo información desde teclado, pues la clase main tiene aquí un parámetro que siempre escribo y bueno, no se había comentado hasta ahora. 00:35:58

Vamos a hacer un primer comentario, aunque más adelante volveré a repetir lo mismo que voy a decir. 00:36:17

La clase Main nos comentaba que es el punto de entrada en nuestro programa. 00:36:25

Y este punto de entrada resulta que este método, que es el que se empieza ejecutando, 00:36:30

de hecho hemos visto que efectivamente es así, 00:36:34

este punto de entrada es capaz de recibir aquí información. 00:36:37

Igual que al escáner le hemos dicho que el flujo de datos al construir su objeto era System.in, al constructor escáner de la clase escáner, al método main, le podemos meter información en el momento que se va a ejecutar. 00:36:42

Si nosotros hacemos un programa que queremos que tenga alternativas sin tener que estar tocando su código en el momento en el que llamemos a su ejecución a través del intérprete, por ejemplo, desde aquí, desde terminal, podemos coger y meter la información en el momento de la ejecución separando. 00:36:56

Fijaros aquí la instrucción de ejecución, el intérprete, el programa que queremos ejecutar que es el bytecode sobre el que estamos programando y luego podemos meterle aquí ciertos datos que tendrán un significado durante la ejecución del programa. 00:37:19

Aquí, por ejemplo, un 5 lo podríamos meter. Podríamos meter uno o tantos como fueran necesarios. 5 o la, los que fuesen. Esto lo que está haciendo es intérprete de Java, ejecútame este programa y considera para tu ejecución estos dos parámetros que luego, muy probablemente, en la ejecución del código utilizarás para algo. 00:37:36

Por ejemplo, en lo que os comentaba antes de imprimir el listado de una determinada asignatura, pues podríamos poner aquí clase print y poner aquí programación. 00:37:56

Pues entonces cogería y esto, desde el programa, leería esta programación y escogería y nos imprimiría el listado de los alumnos de programación o sistemas. 00:38:09

Bueno, pues como fuese, ¿no? 00:38:18

¿Cómo se capturan estos datos que metemos adicionales cuando estamos haciendo la llamada a la ejecución al programa? 00:38:20

Vamos a poner aquí un 5, pues se capturan a través de esta información. 00:38:27

Fijaros que aquí tenemos una variable y esta variable es un array de strings. 00:38:34

Entonces en cada posición de este array de strings se van a ir cargando valores de los que le pasamos aquí como parámetros. 00:38:40

Fijaros, si cogemos aquí y ponemos system.out.println y vamos a poner esta variable, ars, que es ars s, recordad, es un array de strings. 00:38:48

si ponemos aquí los corchetes 00:39:11

y ponemos la posición 0 00:39:13

resulta que 00:39:15

ars s y 00:39:17

los corchetes ya sería 00:39:19

un string, entonces esto es un string 00:39:21

mira, si hacemos una ejecución 00:39:23

de este código 00:39:25

pero desde aquí, veis que 00:39:26

me ha impreso, bueno me ha sacado esto 00:39:30

porque luego el programa sigue por aquí 00:39:32

diciendo dime cuantos números 00:39:34

pero lo primero que me ha mostrado ha sido 00:39:36

un 5, pues este 5 00:39:38

resulta que es este 5 00:39:40

que se ha cargado durante la ejecución en el array ARCHS como primer elemento. 00:39:43

Voy a dar control-C para parar el programa. 00:39:51

Si yo cojo y digo aquí System.out.println a posición 1, 00:39:59

si yo ejecuto aquí el 5 y pongo aquí hola, 00:40:06

fijaros cómo me muestra un 5 y un hola. 00:40:11

Este en ARCHS se carga en la posición 0 y este en la posición 1. 00:40:14

que son los dos que estoy mostrando aquí, como veis. 00:40:20

Entonces, otra forma, además de pedir cuántos números quieres leer, 00:40:23

que podríamos haber utilizado, pues resulta que en lugar de leerlo 00:40:28

durante la ejecución en cada uno de los programas, 00:40:32

desde teclado, pues lo podríamos llamar en la llamada. 00:40:35

Entonces, el número este de iteraciones, podríamos decir que sea 00:40:39

args cero. 00:40:43

entonces también conseguimos un programa versátil que el número de vueltas que va a dar el for lo cargue en una variable 00:40:46

esta variable antes hemos probado para que se cogiese desde teclado la pedíamos por aquí 00:40:56

y en este caso el diseño del programa en realidad pedía el número de veces que queremos que se ejecute 00:41:03

pero no tanto pidiéndolo en cada ejecución por teclado, sino indicándoselo en el momento en el que lanzamos el programa. 00:41:12

Salgo de la ejecución anterior y si yo digo ahora, vamos a poner aquí, ejecútamelo para tres veces, 00:41:21

este valor, como es el primer parámetro, se cargará en ARS0. 00:41:29

El valor ARS0, fijaros, esto es un string, es decir, es un string de la misma forma que esto era un string que cargábamos con Nestline 00:41:37

y como tenemos el número en un string y queremos trabajar con él como un dato numérico 00:41:46

utilizamos el wrapper, le hacemos el parseInt y en este caso 00:41:51

el parseInt se lo estábamos haciendo de ese info cuando lo cogíamos por teclado 00:41:54

pues ahora en lugar de esta variable de tipo string que hemos cargado 00:41:59

con el nestline del escáner, le enchufamos el ars0 00:42:03

entonces si hacemos esta ejecución 00:42:07

bueno, me ha pegado aquí un fallo, vamos a ver por qué 00:42:10

bueno, se me ha pegado un fallo, ya os cuento por qué 00:42:14

mira, dice que he intentado hacer a la posición 1 00:42:18

de ARS 0, y le he hecho la ejecución, este es la posición 0 00:42:22

y no le he metido un valor en la posición 1, es el motivo 00:42:27

para evitar ese error, había comentado esta línea, como podéis ver 00:42:31

es en esta línea, a ver si me dice la línea también, fijaros, me dice que en la línea 8 00:42:34

efectivamente, veis en la línea 8, es decir, ha sido durante la ejecución de esta línea 00:42:38

cuando me ha dado el error, ¿por qué? 00:42:43

intentaba acceder en una raya 00:42:45

a una posición que realmente no existe 00:42:47

porque solo le había pasado un parámetro 00:42:49

entonces existe ARS 0 pero no ARS 1 00:42:51

¿qué ha sucedido? ¿por qué 00:42:52

me ha dado el error? 00:42:55

a pesar de haberlo compilado, pues porque 00:42:56

lo había modificado pero no había salvado 00:42:58

ahora lo salvo 00:43:01

ahora no me da el error ya 00:43:02

fijaros, ARS 0, que sí que me lo está mostrando 00:43:07

según el código que hay aquí 00:43:09

en la línea 7, me dice que vale 3 00:43:11

cargado desde aquí 00:43:13

ahora claro, no me ha hecho esta petición 00:43:14

de dime cuantos números quiere leer 00:43:17

aunque en inumbar ha cargado 00:43:19

el valor de ar0 con el parseint 00:43:21

de integer, con lo cual esto 00:43:23

se entiende que va a valer 3, vamos a comprobarlo 00:43:25

y el for lo estoy 00:43:27

haciendo en función a este valor, con lo cual 00:43:29

me estará pidiendo 3 valores 00:43:31

entre 0 y 10, siempre y cuando 00:43:33

no metamos 13 y si metemos valores 00:43:35

mayores o menores que 0 y 10 00:43:37

pues se me vendrá 00:43:39

por aquí, descontará 00:43:41

como hacíamos antes, entonces ponemos 00:43:42

el valor 4 que es válido, el 6 00:43:45

vamos a poner el 99 00:43:47

que no lo es, el menos 1 que tampoco 00:43:49

vamos a poner el 5 00:43:51

y veis, pues ya termino 00:43:53

termino con 3 vueltas 00:43:55

¿por qué ha dado 3 vueltas? porque habíamos puesto 00:43:57

aquí un 3, hemos conseguido 00:43:59

que nuestro programa 00:44:01

sea 00:44:03

versátil, nos dé alternativas 00:44:04

tanto en cuanto al número que queremos utilizar 00:44:07

pues sí, poniéndolo por aquí 00:44:09

¿Alguna pregunta por ahí? ¿Se sigue bien más o menos? Bueno, pues mira, es un array, pero que no veamos que se está inicializando no quiere decir que no se esté inicializando. 00:44:11

¿Qué sucede? Pues que antes de que se empiece a ejecutar este código, el código que haya por detrás por ahí, 00:44:58

el que sea capaz de poner, habrá un código por ahí por detrás en Java que yo desconozco, nunca he visto cómo está, 00:45:04

pero vamos, me atrevería a decirte que en algún sitio, cuando tú haces esto, tendrá que redirigirse ya empezando a ejecutarse el código 00:45:12

para que busque la clase main que se ponga en marcha. 00:45:20

Y muy probablemente, antes de hacer eso, 00:45:24

habrá hecho una lectura de cuántos campos hay aquí 00:45:27

y si hay uno, habrá hecho un new para este array 00:45:30

que será un new de un solo string. 00:45:33

Y si hay cinco, pues habrá hecho un new de cinco. 00:45:35

Pero si es un array, se habrá hecho la reserva de memoria 00:45:39

con toda seguridad. 00:45:41

O sea, no sería una colección. 00:45:44

Otra cosa es que nosotros no lo estemos viendo aquí en el código. 00:45:47

Y mira, ya que dices esto de los arrays, ahora después continúo con otras cosas que tengo por aquí apuntadas. Vamos a suponer un programa y así metemos también un bucle que nos pida información hasta que, por ejemplo, pongamos un menos uno. 00:45:49

Es decir, vamos a ir metiendo datos hasta que el dato metido sea menos uno. Y nosotros cogemos y trabajando con los arrays, podríamos hacer una primera suposición y decir, pues mira, seguro que en este programa se ejecute una mil veces, nunca vamos a meter más de cuatro números. 00:46:12

números siempre vamos a poner menos uno antes de cuatro números no sé ponlo en el contexto que te 00:46:34

parezca que es un poco descabellado el que haya que ejecutarlo más de cuatro veces no vamos a 00:46:39

buscar si quieres un una funcionalidad particular que responda a esto pero bueno sería sería lo que 00:46:44

se daría entonces podríamos coger y decir y vamos a definir un array de enteros los coches de los 00:46:49

podemos poner antes o después del nombre de la variable, 00:46:58

nos lo acepta Java. 00:47:02

New, int, vamos a suponer que acepta cuatro valores. 00:47:03

Estos cuatro valores serán los que estén en el índice 00:47:10

entre cero y tres, entre estos índices. 00:47:12

Entonces, vamos a introducir otra cosa más, fijaros, 00:47:19

que son las constantes. 00:47:24

Las constantes en Java pueden ser de diferentes tipos, 00:47:26

también de tipos primitivos. 00:47:29

Imaginaos que tenemos una constante de tipo int y decimos que número, vamos a poner cantNum, vamos a definirlo que sea igual a 4. 00:47:31

Vamos a definir de forma constante que la cantidad de números, esa que estábamos planteando aquí como máxima cantidad de números que vamos a meter, sea de 4. 00:47:46

para que esto sea, si nosotros 00:47:59

aunque hayamos puesto esto en mayúsculas 00:48:04

que es la forma que por estándar 00:48:06

se suele decir que se pongan las constantes 00:48:08

si nosotros ahora ponemos aquí que esto sea igual a 5 00:48:10

voy a definir la static 00:48:13

lo de static 00:48:20

en otro rato lo 00:48:22

volveré a contar, ya os he hecho referencia 00:48:23

a la static, hoy 00:48:26

no lo sé si hoy lo contaré, pero bueno 00:48:28

como estoy centrado en otras cosas, la defino static 00:48:29

para que me compile, fijaros 00:48:31

como esta variable 00:48:34

me permite modificar su valor porque porque es una variable si queremos que realmente actúe como 00:48:35

una constante que tenga un valor inamovible lo que es una constante lo podríamos poner la etiqueta 00:48:42

de final y en lo que normalmente sería un parámetro si se identifica lo identificamos como final 00:48:47

estamos haciendo la constante entonces fijaros cómo hará esto ya me deja de compilar es pues 00:48:54

este valor se lo vamos a poder poner aquí 00:49:01

a la definición del array 00:49:05

y así lo ponemos como un final 00:49:06

si hay 5 o 6 00:49:09

imaginaos que en el código, en el desarrollo 00:49:10

del main hay 4 o 5 sitios 00:49:13

donde nos interesa ir haciendo 00:49:15

comprobaciones de este dato porque es la 00:49:16

cantidad máxima de números que vamos a poner 00:49:18

si no lo ponemos en una constante 00:49:21

pues tendríamos que poner 4 00:49:23

por todas esas partes 00:49:24

en tantas como apareciera 00:49:26

si luego resulta que 00:49:28

Si decidimos que 4 se nos ha quedado corto y queremos que sea 5, tendríamos que ir a 5 o 6 sitios a modificar este 4 y poner un 5 para que quedara coherente en todas partes, ya que se está refiriendo al número máximo en todos los sitios del código, al número máximo de números que queremos leer. 00:49:30

En cambio, si trabajamos en todas partes con cantNum y cambiamos de 4 a 5, pues el único sitio que tenemos que poner el 5 sería aquí. 00:49:49

Y si está en un solo sitio, no tenemos lugar a equivocaciones que sí se podrían llegar a producir si el 4 lo tenemos esparcido por muchas partes del código 00:49:59

y resulta que en un sitio se me olvida cambiarlo. 00:50:09

Entonces podría llevar a equívocos o a ejecuciones erróneas del programa y de esta forma, si resulta que su comportamiento es como una constante, utilizando cant num, el único sitio donde cambiamos es aquí y ya queda perfectamente definido en todas las partes donde ese dato sea importante. 00:50:12

bueno, mirad, hemos cogido 00:50:31

y hemos definido esto, entonces ponemos aquí for 00:50:35

definimos int i 00:50:38

igual a cero, mientras i sea 00:50:40

menor, no, hemos dicho que queríamos 00:50:44

estar aquí dando vueltas 00:50:49

mientras no introduzcamos un menos uno 00:50:51

entonces ponemos int i val aquí 00:50:55

igual a cero para que nos entre una vez 00:50:57

o vamos a hacer un do while, para que entre al menos una vez 00:51:00

Hacemos un do while, definimos una variable, y val, hemos dado demasiadas cosas antes aquí, vamos a poner aquí string, ese info, mi scan punto, next line, dime número, vamos a poner un print, y aquí la misma jugada de antes, hacemos un integer, parse int, de ese info, aquí tenemos el dato que estamos leyendo. 00:51:09

Y queremos que esto se esté ejecutando mientras, fijaros que no vamos a ejecutar en base a que ya hayamos leído cuatro números, sino que vamos a ejecutar el bucle en base a que el número que se lea sea menos uno. 00:52:11

Entonces diremos que se está ejecutando mientras i val sea diferente de menos uno. 00:52:41

Esto que puede darse la situación de que aquí carguemos más números que el máximo que permite el array. 00:52:46

Entonces aquí vamos a poner que cada vez que leamos un número vamos a incrementar in un leídos. 00:52:56

Más, más. 00:53:05

Y aquí vamos a hacer una comprobación diciendo que si el número de datos leídos es mayor que esto, corremos el riesgo de que se nos desborde el array, ¿verdad? 00:53:06

Fijaros, si ya hemos leído, si tenemos que el array lo hemos definido para 4 y resulta que hemos leído más de 4, resulta que cuando vayamos a guardar la información en el array puede ser que nos dé un error. 00:53:26

entonces lo que vamos a hacer aquí va a ser 00:53:39

al array 00:53:45

a la posición del array 00:53:49

ahora repasamos todo el código de nuevo 00:53:50

se está colando un micro por ahí 00:53:52

alguien lo tenéis abierto 00:53:59

y no es que me moleste a mi mucho pero 00:54:00

a ver si luego la grabación se va a quedar con ruido 00:54:02

entonces, bueno no se os escucha 00:54:05

creo ¿no? 00:54:07

echar un ojillo para apagarlo 00:54:09

si nos importa 00:54:11

bueno, no, y val 00:54:11

mira, mi idea 00:54:15

para hacer una ejecución a ver qué es lo que va pasando por aquí ahora vemos que ponemos aquí en 00:54:18

él tenemos en esta variable es donde estamos cargando cada uno de los datos que cogemos 00:54:23

desde teclado en esta variable vamos a llevar un contador de cuántos datos hemos leído 00:54:30

anteriormente hemos definido una raíz que es donde vamos a ir guardando los datos a los guardamos 00:54:38

aquí, que lo estamos guardando aquí. ¿Veis? Cada dato que cogemos 00:54:42

lo estamos guardando en una posición del array. Para que sea una 00:54:46

posición distinta, cada vez incrementamos el 00:54:50

inum datos leído. Para que la primera lo guarde en el cero, vamos a poner 00:54:54

esto aquí después de guardarlo. Entramos por aquí. 00:55:01

Coge un número, dice el número de datos leído 00:55:07

es mayor 00:55:10

o igual a la cantidad de datos que podemos guardar 00:55:13

en el array? Pues si es el caso 00:55:19

lo que vamos a hacer aquí va a ser rehacer el array 00:55:21

para darle más tamaño. Ahora vamos a ver qué pasa si le damos más tamaño 00:55:28

que es donde quiero llegar también. Si no se da el caso de que 00:55:35

ya hayamos leído más datos, lo que voy a hacer va a ser guardar el dato en el array 00:55:41

y voy a incrementar el número de datos leídos para saber ya que hay un dato más leído 00:55:44

que estoy utilizándolo para, entre otras cosas, para ir aumentando el índice en el que voy escribiendo en el array. 00:55:49

Vamos a hacer una ejecución inicial, damos aquí, dime un número y decimos 2, 3, si meto menos 1, el programa se me acaba. 00:55:59

En ese aspecto el programa funciona bien. 00:56:12

Para ver cómo se nos queda el array, lo que podemos hacer es otro bucle aquí. 00:56:16

Este bucle lo vamos a utilizar para coger información y lo vamos a hacer otro bucle, en este caso con un for int i igual a cero, mientras i sea menor que ir.length, es decir, para recorrer todo el array, mientras i sea menor que la longitud del array, y digo un i más más. 00:56:24

Aquí voy a poner system.out.println, la información del array es, y aquí un system.out.print, y vamos a poner cada uno de los elementos del array. 00:56:48

Fijaros que este bucle, este segundo bucle, lo que hace es iterar por todos los elementos del array mostrándolos por pantalla. 00:57:19

Vamos a hacer una primera ejecución, ahora seguimos metiendo más código, dime un número. 00:57:29

decimos un 3, decimos un 4, si metemos menos 1 termina 00:57:32

y dice la información del array es 00:57:37

3, 4, bueno, menos 1, 0 00:57:39

el menos 1 lo ha guardado también por aquí en la posición array 00:57:44

y los datos que me ha metido es el 3, el 1 00:57:47

el menos 1 que me ha sacado del bucle, que también lo ha guardado en una posición del array 00:57:51

y la cuarta posición, como era un entero, está inicializada a 0 00:57:55

me ha mostrado todos los datos 00:57:59

mira, si como el array lo hemos 00:58:01

dimensionado para 4, vamos a seguir 00:58:04

haciendo casos, ahora metemos más código 00:58:07

imaginaos que metemos 00:58:08

no metemos menos 1, metemos 4, 5 00:58:10

6, 7, ya llevamos 4 00:58:12

8, y que me da 00:58:14

me da un error, porque 00:58:16

me dice array fuera de rango 00:58:18

array index out of bounds 00:58:21

he intentado meter 00:58:23

en esta línea 00:58:24

fijaros en la línea 00:58:26

26 del código 00:58:27

en una posición del array para la que ya no había definido 00:58:30

variables, esta es la posición 0, posición 1, posición 2 00:58:34

posición 3, para la posición 4 cuando el índice 00:58:37

del array va entre el 0 y el 3, he intentado meter 00:58:40

un valor y como no he reservado memoria para él 00:58:43

pues no le ha gustado y entonces ha dado 00:58:45

un fallo, un pete aquí el programa, ¿vale? 00:58:48

Para tener eso en cuenta he puesto este if en el cual todavía no he hecho 00:58:54

nada, entonces lo que vamos a hacer va a ser rehacer 00:58:57

o redimensionar el array. ¿Por qué? Porque nos hemos dado cuenta 00:59:00

que estamos metiendo más datos de los que hemos reservado 00:59:03

en memoria RAM para este array. Entonces aquí podríamos coger 00:59:09

y hacer, mira, igual que aquí le di este tamaño, pues vamos a volver 00:59:12

a hacerlo, pero en lugar de utilizar este índice, vamos a utilizar 00:59:18

como índice este cuando entre por aquí resultará que el tamaño ya es yo creo vamos a probar con 00:59:25

mayor si no lo miramos resultará que el número de datos leídos ya va a resultar mayor que la 00:59:36

cantidad de números es decir se va a dar este caso cuando llegamos a este caso este número ya 00:59:44

será mayor que la cantidad de números que la bueno todavía no porque incrementamos aquí vamos 00:59:52

a poner mayor o igual en el momento en el que aquí hemos leído el quinto dato que es este que nos ha 00:59:57

dado un error esto ya se va a cumplir y se cumple esto lo que voy a hacer va a ser dar un nuevo 01:00:05

tamaño a la raíz para que no me dé este fallo con el nuevo tamaño que es en un dato leído vamos a 01:00:10

a poner un dato leído vamos a darle de tamaño más 2 luego si acaso lo ajustamos estamos 01:00:17

redimensionando lo escogemos y decimos vale si lo redimensionamos ya no me va a dar ese 01:00:25

error efectivamente vamos a darle yo creo que no nos va a dar el error ahora entonces metemos 01:00:30

un número dos tres cuatro hasta ahora con estos cuatro números hemos entrado por ha pasado por 01:00:35

aquí no habrá pasado por aquí ninguna vez todavía y ha pasado por aquí tantas veces como están 01:00:43

permitidas según esta dimensión si ahora metemos otro número ha sido cuanto antes nos ha fallado 01:00:50

y ahora no falla veis por qué porque se ha dado cuenta que ya hay más números y ha redimensionado 01:00:54

el array para que sea más grande si antes teníamos un tamaño de 4 pues ahora tendremos un tamaño de 01:01:01

6 y si mete otro número volverá a darse cuenta y como éste lo hemos vuelto a incrementar pues 01:01:06

ahora tendrá ya un nuevo tamaño de 7. ¿Veis? Sigue sin fallarme. Voy a poner menos 1 para que se salga. 01:01:12

Y mirad lo que ha pasado en los primeros datos. ¿Os acordáis que habíamos puesto aquí un 4, un 3, un 4, un 5? 01:01:20

Mirad qué datos me saca aquí. ¿Veis que son todos los primeros datos un 0? ¿Esto por qué ha sucedido? 01:01:27

Pues cuando yo cogí y hice esta instrucción con este new, me pidió al sistema operativo un espacio 01:01:33

de memoria RAM y vamos a suponer que el espacio, el sistema operativo dijo tu posición de memoria 01:01:41

es la 30.000. Una aleatoria, donde veo un hueco 01:01:45

del sistema operativo en memoria RAM. Y tu espacio para este array 01:01:49

va a ir entre el 30.000, que es el punto de inicio, y el tamaño que necesitas 01:01:53

para 4 enteros. Es decir, entre 30.000 y 30.000 01:01:57

más el espacio de 4 enteros. Durante el 01:02:01

tiempo en el que hemos estado haciendo ejecuciones y no ha entrado por aquí, por este código 01:02:15

del if, como la primera vez esto valía 0, en la posición 30.000, según esta ejecución, habría metido un 4. 01:02:19

Es decir, en la posición 30.000, un 4. En la posición 30.000 más espacio de un entero, pues habrá metido el dato 01:02:26

que hemos capturado, el dato que hemos capturado, que es un 3, ¿veis? Pues habrá metido un 3. En la posición 30.000 01:02:45

más el espacio de dos enteros 01:03:00

habrá metido un 4. 01:03:02

O sea, todo según es previsible. 01:03:06

Pero, ¿qué pasa cuando 01:03:09

ya hemos sobrepasado 4 01:03:10

y hacemos esto? 01:03:12

Pues esto, dice, para esta variable 01:03:14

estoy pidiendo un new porque 01:03:16

me he quedado corto en el array. 01:03:18

Y como me he quedado corto en el array, lo hago más grande. 01:03:20

Pero este new, ¿qué es lo que hace? Pues busca 01:03:22

en el sistema operativo un hueco y este 01:03:24

nuevo new hace que esto ahora apunte 01:03:26

probablemente a la posición, a otra posición aleatoria que no es 30.000 01:03:28

a la 60.000. Entonces la posición 60.000 01:03:32

y reserva espacio de memoria va desde el 60.000 01:03:38

hasta más el espacio 01:03:42

del número de elementos que llevemos hasta ahora más 2 que hemos puesto 01:03:46

aquí. Imaginaos que son 6, 6 enteros. 01:03:50

Entonces la posición donde antes teníamos 01:03:57

guardado el primero de los valores 01:04:00

que habíamos metido que era la 30.000 01:04:02

no es la misma posición donde ahora apunta la array 01:04:04

que es la 60.000, entonces esta nueva posición 01:04:06

vale 0, con lo cual 01:04:08

como consecuencia 01:04:10

de esto, lo que ha pasado es que hemos perdido 01:04:12

este 4, hemos perdido este 3 01:04:14

y hemos perdido este 6 01:04:16

es decir 01:04:18

cuando nosotros damos de alta una array 01:04:20

su dimensión 01:04:22

no puede cambiar ya nunca 01:04:25

y si hacemos por código 01:04:27

que cambie, en realidad 01:04:30

no estamos cambiando la dimensión de esta array, sino lo que estamos haciendo 01:04:31

es crear un nuevo array que es verdad que está apuntado 01:04:36

por una variable que se llama igual que se llamaba aquí, de hecho es la misma variable 01:04:40

pero ya es un nuevo array con un nuevo tamaño, pero todos los datos que teníamos 01:04:43

en esta array se pierden. Entonces esto es lo que nos lleva a 01:04:48

que los arrays no pueden modificar su tamaño, son 01:04:51

estructuras de datos estáticas, porque esto ya sería 01:04:55

digamos un nuevo array diferente a este otro. Los datos que teníamos 01:04:59

de antes se han perdido. Vamos a hacer una ejecución para confirmar 01:05:03

esto ejecutando el código de tal forma que esta 01:05:07

instrucción no se ejecute nunca. Es decir, antes de llegar a esta cantidad de números 01:05:11

de datos metidos vamos a meter menos uno 01:05:15

para que esto no se ejecute. Con lo cual todo el rato es la misma estructura 01:05:19

y nos mostrará los datos que hayamos metido 01:05:23

en esa primera reserva que habíamos hecho 01:05:26

para el array en este new 01:05:29

entonces si damos una ejecución y ponemos 01:05:30

dime un número, 3, el 4 01:05:32

y le decimos menos 1 01:05:34

fijaros como si me muestra el 3 y el 4 01:05:35

como no ha pasado por aquí, no hemos rehecho el array 01:05:38

si yo hago otra 01:05:41

ejecución aquí y digo 01:05:43

3, 4, 5, 6, 7, 8 01:05:44

9, fijaros que ya he metido 01:05:47

suficientes datos como para sobrepasar 01:05:48

esta cantidad, me habrá hecho esta ejecución 01:05:50

más de una vez 01:05:53

con lo cual cada vez habrá hecho 01:05:54

un nuevo array. Y cada vez que hace un nuevo array, estará reservando la memoria 01:05:56

para este tamaño en un nuevo 01:06:01

espacio de memoria RAM. Y cada una de las ejecuciones 01:06:05

anteriores habría ido perdiendo los datos que tenían. Entonces, si ahora pongo aquí menos uno 01:06:09

para ser capaz de terminar, fijaros como ya esas primeras posiciones se han perdido. 01:06:13

¿Sí? ¿Lo veis? ¿Sí? ¿Bien? ¿Más o menos? 01:06:20

Bueno, si no me comentáis nada, entiendo que... 01:06:29

Si esto fuera una colección, que ya os digo que hay un tema de colecciones en las que volveremos a repasar la diferencia entre array y colección y trabajaremos con los diferentes tipos de colecciones que hay, que son varias. 01:06:37

Si esto fuese una colección, no se hace esta reserva inicial. 01:06:50

Entonces tú lo que defines es un identificador de la colección. 01:06:56

Este identificador de la colección, igual que el array tiene este identificador, que en este caso es IR, tendrá un determinado nombre como una variable de colección en nuestro programa. 01:07:00

Y esa colección no tendrá inicialmente ningún elemento metido, pero tampoco habrá hecho una reserva inicial del tamaño del número de elementos que puede guardar. 01:07:19

entonces si por ejemplo tuviéramos una colección de enteros 01:07:35

inicialmente no tendríamos ninguna posición de memoria 01:07:39

y si vamos a llamar call por ejemplo 01:07:43

el supuesto nombre de la colección 01:07:45

solo por ponerlo en contexto 01:07:47

la forma de añadir elementos 01:07:49

un nuevo elemento sería con el método add 01:07:52

según la colección que sea hay diferentes formas 01:07:54

entonces aquí lo que diríamos es 01:07:57

añádeme un entero que es el 7 01:07:59

por ejemplo, si fuese una colección 01:08:01

y en este momento este método add 01:08:03

lo que hace es hacer el new para ese entero 01:08:05

y internamente la colección se organiza 01:08:09

para que si luego pongo aquí otro elemento 01:08:12

añado a la colección otro elemento 01:08:15

pues hará una segunda reserva de memoria 01:08:17

y de alguna forma enlazará estos dos datos 01:08:19

para ir pudiendo pasar de uno a otro 01:08:22

si yo tengo un callremove 01:08:24

o no me acuerdo exactamente como es el método 01:08:28

de la posición del valor 7 01:08:30

pues me borraría este 01:08:32

y además de eliminar este elemento de la colección, lo que haría sería liberar su memoria RAM, 01:08:34

con lo cual la reserva de memoria RAM es dinámica. 01:08:40

Si luego meto otra vez el 7, pues volvería a hacer la reserva. 01:08:42

No tenemos el incordio este del tamaño que no puede modificarse de los arrays. 01:08:47

Lo que sí que es cierto es que si tienes garantías de que el array no se va a modificar su tamaño, 01:08:54

fijaros que el acceder a variables en una raíz es muy rápido porque esto ya sabe que empieza en el 01:08:59

30.000 y si accedes a la posición 2 pues lo único que tienes que hacer es llegar al 30.000 más en 01:09:06

espacio en zona de memoria 2 el espacio ocupan dos enteros y ya estoy en ese número directamente el 01:09:12

programa va como un tiro cambio estos son métodos en los cuales cada datos habrá ido enlazando como 01:09:18

haya podido a lo mejor el primer entero el 9 apunta al 7 y el 7 apunta para ir haciendo una 01:09:25

secuencia a cada uno de ellos al 4 y dependiendo del tipo de colección a lo mejor si quiero llegar 01:09:34

al 4 tengo que leer el 9 tengo que leer el 7 tengo que leer el 4 y si tiene muchos registros a lo 01:09:39

mejor tengo que ir de uno en uno con una algoritmia que tienen programadas las colecciones en los 01:09:45

paquetes de colecciones de Java. Entonces, toda esta búsqueda 01:09:51

del dato que yo quiero cuando no tengo garantías donde se encuentra, pues tiene un coste. 01:09:56

En cambio, este acceso es inmediato porque es al sitio 01:10:01

de memoria RAM donde apunta el array más este número de posiciones 01:10:06

que tiene que ocupar el tipo de datos que tiene ese array entero. Pues llego en un segundo a él. 01:10:10

Entonces, bueno, pues los arrays tienen sus ventajas también respecto a las colecciones y las colecciones 01:10:17

un montón de ventajas en cuanto a la manera en cuanto al manejo y la gestión de los datos que 01:10:21

ya veremos cuando llegue su tema si bien vale pues a ver otras cosas que os puedo contar por 01:10:26

ahí vale mirad otra otra cosa por ahí que os cuento mirad hay una etiqueta que es la etiqueta 01:10:40

return la etiqueta return lo que hace es finalizar la ejecución de un método se sale de un método 01:11:02

Vamos a poner el return aquí. Bueno, antes del return, os voy a contar otra cosa. Mirad, hemos hablado de los tipos de datos primitivos y de los referenciados. Los tipos de datos primitivos son en líneas generales, pues int, long, boolean. 01:11:10

para estos tipos de datos 01:11:35

hemos dicho que había dos características 01:11:38

una, no necesitamos hacer el new 01:11:40

no lo hace Java directamente 01:11:42

al final se tendrá que hacer una reserva 01:11:44

en memoria RAM por ahí 01:11:46

porque en algún sitio se tienen que guardar estas variables 01:11:47

bueno, pues por ahí la hará Java 01:11:50

métete a saber cómo 01:11:52

en sus librerías 01:11:53

y luego por otro lado no tienen métodos 01:11:55

no tienen 01:11:58

los tipos de datos primitivos, no tienen métodos 01:11:59

ni parámetros 01:12:02

es decir, si ponemos, hemos visto antes que poníamos int y value 01:12:04

o poníamos y val punto, no nos ofrecía nada, y para eso un método 01:12:09

si los parámetros están las clases estas wrap en las envoltorio 01:12:12

un tipo de datos primitivo podría ser este 01:12:17

un tipo de datos referenciado, pues podría ser el que hemos visto antes 01:12:24

el scanner, miScan, igual año 01:12:28

el scanner, como parámetro recibe el system.in 01:12:32

este sería referenciado 01:12:36

en este caso 01:12:39

hemos necesitado, porque no es primitivo 01:12:41

hacer el new y tiene 01:12:43

métodos, como veis 01:12:45

hay un tipo 01:12:49

de datos que es un poco intermedio 01:12:51

entre unos y otros, que es el string 01:12:54

el string en verdad 01:12:55

es un tipo de datos referenciados 01:12:59

referenciado, fijaros ese info 01:13:01

veis, me ofrece 01:13:03

métodos, con lo cual sigue la característica 01:13:12

esta de referenciado 01:13:14

pero no lo hacemos el new 01:13:16

bueno, ¿por qué no lo hacemos el new? 01:13:18

bueno, han considerado hacerlo 01:13:21

referenciado y no hacer un wrapper 01:13:22

como en los otros tipos 01:13:24

pues ya está, así es como es la cosa 01:13:26

y no hacemos 01:13:28

el new, bueno, pues porque 01:13:30

podrían habernos obligado 01:13:32

al ser referenciado a haberlo hecho y tendríamos 01:13:34

el hábito de hacerlo y ya está, no pasaría 01:13:36

nada, pero yo creo que 01:13:38

bueno, se dieron cuenta que hay tantas variables de tipo 01:13:40

string en los programas que aparecen 01:13:42

tanto o más como los otros tipos de datos primitivos 01:13:44

que a lo mejor pensaron, pues vamos a hacer la reserva de memoria 01:13:47

porque reserva de memoria se tendrá que hacer, en algún sitio se tiene que 01:13:50

guardar la información de hola cuando se esté ejecutando el programa 01:13:53

pero igual que dijeron, pues bueno, lo hacemos nosotros 01:13:57

por detrás y os ahorramos que estéis escribiendo siempre el new 01:13:59

de todas formas, como es referenciado 01:14:02

lo podemos poner así, fijaros, podemos hacer 01:14:06

un new string y también compila 01:14:08

o sea tratarlo por completo como un tipo de datos referenciado sale le vale le vale esta jugada vale 01:14:12

bien los tipos de datos referenciados cuando tú tienes un tipo de datos primitivo un int si 01:14:21

ponemos aquí int y val igual a 3 ya os digo que es el string es que se comporta en una forma un 01:14:35

poco intermedia. Si nosotros ponemos int ival igual a 3 y hacemos un system.out.println de ival, 01:14:45

pues ¿qué nos muestra? Nos muestra el 3, el valor que tiene. Es un tipo de datos primitivo, nos muestra 01:14:59

el 3. Si nosotros utilizamos un tipo de datos referenciado como escáner, decimos un system.out.println 01:15:04

de mi scan, mi scan es un tipo de datos, es una variable que tenemos 01:15:15

en mi programa, es un objeto de la clase scanner 01:15:24

no es primitivo, es referenciado, lo hacemos el new, llamamos a su constructor 01:15:28

entonces si yo pongo aquí mi scan y damos a una ejecución 01:15:32

fijaros, bueno, pues este saca un churro, yo creo que iba a sacar 01:15:39

menos churro todavía, pero un churro aquí importante, veis, de cosas 01:15:44

no es un valor en sí que tenga, saca ahí un montón de información 01:15:48

mirad, si yo de la clase print 01:15:52

defino un objeto, la clase print 01:15:55

es una clase, digamos que es un esquema 01:16:02

que define el comportamiento que van a poder 01:16:05

tener diferentes objetos de esa clase 01:16:08

entonces yo cojo, como es un tipo de dato referenciado 01:16:11

le hago un new de clase print 01:16:14

pongo aquí un constructor, los constructores os hablo 01:16:16

en el próximo tema, pero fijaros que sigue 01:16:20

un esquema muy parecido a éste se llama un sistema println de este objeto fijaros que lo que me saca 01:16:23

el sistema println de este me saca que es de esta clase identifica la clase a la que pertenece ese 01:16:36

objeto y saca aquí un número que no me atrevería a decir al cien por cien que es la posición de 01:16:43

memoria en la que se ha reservado espacio para las gestiones de este objeto pero podría serlo 01:16:49

mirad esta clase 01:16:55

podríamos coger, imaginaos que en lugar de la clase 01:16:58

clase print fuera 01:17:00

una clase persona y 01:17:01

definiésemos int y edad 01:17:04

y para este objeto miop 01:17:05

punto 01:17:14

y edad y decimos que sea 01:17:17

10 01:17:18

y si yo doy aquí a ejecutar 01:17:19

me sigue 01:17:22

sacando lo mismo 01:17:24

para el entero me sacó un valor 01:17:25

y podríamos pensar, oye clase print 01:17:28

tiene aquí un entero. ¿Por qué no me saca aquí un 10? 01:17:30

Me saca ese dato. 01:17:33

Si fuese a la clase 01:17:36

persona, también podría tener un nombre. 01:17:37

Y si le doy a ejecutar, 01:17:52

fijaros que me sigue sacando algo 01:17:54

de este estilo. Está claro que 01:17:55

el programa no tiene criterio 01:17:57

para saber si lo que... 01:18:00

De partida no tiene criterio para saber 01:18:02

si a mí me interesa, cuando 01:18:03

hago un System.out.printl de la clase, 01:18:06

si me interesa sacar la edad, 01:18:08

el nombre, una combinación de los dos. 01:18:10

Y como no tiene criterio, 01:18:12

Lo único que sabe es que es de esta clase y que hay aquí un identificador que posiblemente tendrá que ver con la posición de memoria 01:18:14

donde se empiezan a guardar datos de ese objeto por ahí en memoria RAM. 01:18:22

En cambio, para un tipo de dato que sí que es primitivo, no me saca posiciones de memoria ni me dice que es un entero, me saca directamente el dato. 01:18:28

pues aquí tenemos otra diferencia entre los tipos de datos que son primitivos 01:18:38

que me saca directamente la información de la variable 01:18:42

y los que son referenciados que me saca algo de este estilo 01:18:45

mirad que pasa con un string, este es info, lo hemos inicializado a hola 01:18:49

pues este si que me saca hola, veis, entonces 01:19:04

los tipos de datos string tienen un comportamiento 01:19:10

intermedio, es necesario hacer el new 01:19:14

aquí lo tengo hecho, pero hemos visto que no, con lo cual podríamos pensar es primitivo, muestra la información, efectivamente muestra la información, con lo cual podríamos pensar que es primitivo, pero luego tiene métodos, pues si tiene métodos, eso corresponde más a los referenciados, en realidad es referenciado con un comportamiento ahí mezclado, 01:19:18

hay cosas en las que se comporta como los primitivos, no me obliga a hacer el new 01:19:46

y el system.out.println, por ejemplo, me saca este hola en lugar de 01:19:49

la referencia en la posición de memoria donde andamos. 01:19:54

Luego ya os contaré en algún momento cómo modificar 01:19:57

que me saca el system.out.println aquí para que no me saque esto, pero de partida 01:20:01

lo hace así. Mirad otro comportamiento que 01:20:06

en el que anda un poco mezclado 01:20:09

en el que anda un poco mezclado el string 01:20:13

es el siguiente, mira, si ponemos nosotros aquí if 01:20:17

con un tipo de datos primitivo 01:20:20

y val, este y val 01:20:22

es este entero que he definido aquí, si es igual a 3 01:20:26

digo system.out.println 01:20:29

y val vale 3 01:20:38

entonces yo cojo 01:20:45

fijaros que cuando hago el system.out.println 01:20:48

de ival me da un 3 aquí y aquí estoy comparando ival con un 3 entonces yo cojo y le doy aquí a la 01:20:51

ejecución y me dice ival vale 3 es decir ha entrado por este if y me ha mostrado esta información 01:20:57

es un tipo de dato primitivo si yo cojo y pongo aquí if ese info ese info recuerdo que es un 01:21:02

string que hemos inicializado a hola es igual a hola justo lo mismo que he puesto aquí veis 01:21:16

y hago un system.out.println, digo, ese info vale hola. 01:21:27

Pues bueno, en principio nos haría pensar que si val vale 3, 01:21:40

eso es cierto, nos muestra aquí 3, ese info lo hemos cargado con hola, 01:21:45

de hecho el system.out.println aquí me muestra hola, 01:21:50

pues me va a decir que ese info vale hola. 01:21:52

Entonces si ejecuto esto, pues sí, me lo ha dicho. 01:21:55

Pues mirad, aquí me ha dicho ese info vale hola cuando, 01:22:12

teóricamente, además he hecho una prueba hoy en casa 01:22:15

antes de venir para acá 01:22:20

en realidad esta gestión, a ver si la hacemos aquí 01:22:21

un momentito, vamos a hacerlo así 01:22:27

con unido string, a ver si tiene un comportamiento 01:22:31

diferente, vale, bien, pues aquí está 01:22:35

la diferencia, si lo tratamos 01:22:40

como un tipo de dato referenciado 01:22:44

pues no me entra, porque el dato que considera es el mismo que me muestra 01:22:46

cuando hacemos un system of println 01:22:50

Pero si lo definimos de esta otra forma, sin hacer el new, sí me lo está considerando. 01:22:52

Esta comparación como que vale hola. 01:23:03

¿Veis? De esta otra forma sí que sale. 01:23:07

Entonces, ¿qué es lo que se dice siempre? 01:23:10

Pues en el código, cuando vayas a hacer esta comparación trabajando con una variable de tipo string, 01:23:13

como puede venir de una definición que en un momento dado ha podido ser de este tipo, 01:23:21

referenciada, igual esta línea de código queda lejos 01:23:26

de donde tienes esta otra zona de código 01:23:30

y no está a la vista, en lugar de hacer esta comparación, pues es como que 01:23:34

la tienes siempre como muy prohibida de hacerla así, y lo que se dice 01:23:38

es que se utilice un método que tiene los string 01:23:42

que es o bien el método equals o también se puede hacer 01:23:51

con el método compareTo 01:23:56

compareTo, vamos a hacerlo primero con el equals y luego 01:23:58

probamos si queréis con el compareTo, este método sea como sea 01:24:12

la hayas definido esta como la hayas definido, como un string directamente sin el new 01:24:16

o como un string con el new, este en principio 01:24:20

pues tiene que funcionar, entonces el método equals 01:24:24

como se comporta, es que devuelve 01:24:27

un verdadero o falso, si el valor 01:24:33

de la variable ese info es igual a la información que tengo aquí, es decir, el valor de la variable 01:24:36

ese info es igual a la información que tiene, con la que quiero comparar, devuelve un true. 01:24:44

Entonces, en este caso, ¿veis? Nos dice que ese info vale hola. No funcionaría en cualquier caso. 01:24:51

Entonces, cuando vayamos a comparar con strings, nunca comparamos, ya que tiene esa dualidad 01:25:02

hay entre tipo de datos primitivo y referenciado en realidad es un referencia en lugar de comparar 01:25:09

así que sí que es como lo hacemos con los tipos de datos primitivos lo que vamos a hacer va a 01:25:15

ser utilizar siempre el método y con el método compare tú el método de cuáles devuelve este 01:25:20

método devuelve un boolean el método de cuáles verdadero o falso si es igual devuelve verdadero 01:25:31

si no lo es devuelve falso mirada si no lo es vamos a hacer una ejecución sin que lo sea 01:25:36

sabiendo que ese info vale hola, lo vamos a comparar con hola2 para que no sea igual. 01:25:41

Entonces, al ser falso, esto no debería mostrarse ya. 01:25:50

Entonces, le damos aquí, ¿veis? Y ya nos muestra el mensaje, ese info vale hola. 01:25:54

¿Sí? ¿Alguien me dice que quiere comentar algo? ¿Sí? 01:26:05

¿Dime? ¿Hola? ¿Sí? ¿Alguien ha puesto un mensaje que dice que quería hablar, pero no te oigo? 01:26:09

No sé si estás hablando. A ver, por el chat, si habéis puesto algo. 01:26:26

¿José, querías hablar? Si quieres ponérmelo en el chat, porque no te escucho. 01:26:49

Bueno, continúo mientras. 01:27:02

Bueno, como os decía, el método equals devuelve verdadero o falso, como hemos visto por aquí. 01:27:06

Y luego está el método compareTo, que permite, bueno, da un poco más alternativa, 01:27:11

pero también permite ver si es verdadero o falso. 01:27:17

fijaros, el método compareTo, este método devuelve un entero, como podéis ver aquí, y si el valor es igual, lo que devuelve como entero es un 0. 01:27:19

Si uno de los valores, si este es mayor que este, devuelve un 1, un valor mayor de 0, y si este es mayor que este, devuelve un valor menor que 0. 01:27:42

Esto permite hacer ordenación, ordenar elementos según, por ejemplo, alfabéticamente si fuesen strings o bajo cualquier otro criterio de otra forma. 01:27:52

Esto ahora mismo no me compila porque los if hemos dicho que necesitan evaluar entre un boolean. 01:28:01

Entonces, como esto está devolviendo un número, pues tendremos que hacer una comparación, en este caso a cero. 01:28:11

Entonces si es cero es cuando los dos son iguales y en este caso como lo son, pues sería equivalente al equals este, le damos aquí, damos a la ejecución y dice ese info vale hola, también sería una forma para poder comparar los strings. 01:28:18

a ver, me ponían por aquí 01:28:37

me ponían por aquí 01:28:43

una consulta 01:28:47

una duda sobre el ejemplo de los euros 01:28:49

a ver si lo localizamos 01:28:51

el ejemplo de los euros 01:28:55

no sé dónde está exactamente 01:28:56

hotstream, tipos enumerados 01:28:58

uy, si no 01:29:12

no sé si no se te activa 01:29:21

el micro, si te parece 01:29:25

ponme justo dónde está 01:29:26

la duda en el 01:29:28

porque es que no sé localizarlo, por no marear mucho 01:29:30

aquí ahora con la grabación. Pónmelo en el foro y lo miro y te respondo luego, si no te importa. 01:29:32

O si podemos hablar para ir más directo, me dice justo dónde está el ejercicio ese y lo vemos más 01:29:40

directo. Es que me está poniendo en el chat la consulta sobre una duda del ejercicio de los euros. 01:29:45

Pónmela en el chat, si no te importa. Y si no te funciona el micro. No, yo no, me dice... Vale, lo dejamos 01:29:50

para el foro. Vale, perfecto, así lo hacemos, si no te importa. Vale, pues nada, para comparar streams 01:30:04

aunque hemos visto que sí que hay alguna alternativa 01:30:13

en la que parece que se traga este tipo de comparación 01:30:16

mejor es lo que se recomienda 01:30:19

en todas partes y además hemos visto que en algún caso 01:30:22

podría no funcionar, strings acordaros de hacer la comparación 01:30:24

con el compare to o con el equals 01:30:28

mejor que con esta otra técnica 01:30:31

a ver que más cosas podemos hablar 01:30:34

sobre ellas, bueno habréis visto 01:30:46

en, bueno habéis visto que ya vamos utilizando otra y en la teoría 01:30:54

que en Java podemos meter comentarios, los comentarios 01:31:02

no los considera para nada el compilador y tenemos comentarios de una 01:31:05

línea, que son los que aparecen con las dos barras 01:31:10

o de multilínea, que son los que aparecen 01:31:13

entre la barra y el asterisco, podemos meter 01:31:17

tantas líneas como sean y asterisco y barra, Eclipse para identificarnos 01:31:22

las zonas que son de comentarios pues no lo pone en verde nada nos echa una manilla de esa forma 01:31:26

cuando llamamos al compilador de java si encuentra algo de esto pues directamente no lo considera y 01:31:30

se queda simplemente para el fichero esa información se queda simplemente para el 01:31:38

fichero punto java y bueno los comentarios pues pues sí que siempre están muy recomendados porque 01:31:42

luego ayudar mucho para mantener el código si de repente nos da tenemos que hacer un mantenimiento 01:31:48

y hay alguna zona de código un poco más complicada, si tiene sus comentarios, pues viene muy bien. 01:31:54

Luego hay otros comentarios, esto yo creo que lo veréis en la asignatura de entorno de desarrollo, 01:32:02

hay otros comentarios que son los que empiezan, para que el compilador de Java no lo considere, 01:32:08

tiene que empezar con asterisco y esa barra asterisco, terminar con asterisco barra, así en multilínea. 01:32:14

Pero si ponemos barra y dos asteriscos, esto lo que le estamos diciendo al compilador de Java es no lo consideres porque está empezando así, pero luego hay otros programas como por ejemplo Javadoc, que es un programita que viene incluido en el JDK también cuando lo instalamos. 01:32:22

ahí está el programita, este javadoc, igual que tenemos el programa 01:32:46

javaz o java, el intérprete, pues está este, y este 01:32:50

cuando ejecutas este, lo que busca es esta etiqueta de inicio 01:32:54

no esta, que esta es la que utiliza el compilador, sino que 01:32:58

utiliza esta otra, y si ponemos aquí una serie de etiquetas 01:33:02

que tienen que ser acordes a lo que espera encontrar 01:33:05

javadoc, luego automáticamente este programa te genera documentación 01:33:10

cosa que te ahorra mucho trabajo 01:33:14

crear la estructura de las clases, los métodos 01:33:17

el autor 01:33:21

pero para eso dentro de estas etiquetas 01:33:24

que son las que va a leer este programa 01:33:27

pues hay que meterlo con una determinada sintaxis 01:33:30

no vale poner cualquier cosa 01:33:33

eso es si estudias Javadoc, solo comentarlo 01:33:34

y creo que algo lo veréis en la asignatura de entornos de desarrollo 01:33:38

si no la habéis cursado todavía las los comentarios estos de una sola línea se considera desde que lo 01:33:41

encuentras hasta final de línea comentario entonces si quieres poner un comentario directamente en 01:33:51

toda la línea lo pones así y si no podrías poner algo de código igual igual a 3 y luego bueno pues 01:33:56

pones aquí variable que haga lo que sea entonces realmente el compilador tendrá en cuenta de aquí 01:34:04

para allá y todo esto ya lo considera 01:34:11

comentario 01:34:13

no lo tienen consideración 01:34:14

para generar el bytecode 01:34:17

y a ver si tengo más cositas por aquí 01:34:18

apuntadas, bueno pues 01:34:24

tengo también anotado por ahí 01:34:29

pero bueno, durante el curso 01:34:31

y en otros temas también 01:34:33

lo desarrollamos un poco más 01:34:35

pues hablar un poco de algunas clases 01:34:37

como es de las librerías que tenemos 01:34:39

como la clase math 01:34:41

o la clase scanner, ya hemos hablado de ella un poco 01:34:42

o la clase string 01:34:45

que fijaros, string al ser un tipo referenciado 01:34:50

es una clase, no lo hacemos el new por aquella mezcla 01:34:54

entre primitivos y referenciados que decíamos, pero luego tiene sus métodos 01:34:58

y los métodos de la clase string, pues es que 01:35:02

hay muchos métodos que son muy interesantes, pues otro día 01:35:08

hablamos sobre ellos también un rato, si está vacía 01:35:13

el último hace búsquedas de cadenas 01:35:18

de caracteres dentro de toda la cadena 01:35:20

el equals este que hemos dicho, el compare to 01:35:22

si termina con un determinado sufijo, prefijo, tiene un montón de métodos 01:35:29

para trabajar con strings 01:35:32

otra etiqueta que os comentaba antes 01:35:37

y yo creo que con esta ya vamos a ir finiquitando 01:35:43

es otra palabra reservada, la palabra 01:35:46

return. La palabra return lo que hace es sacarnos de un determinado 01:35:50

método. Entonces fijaros, si cogemos nosotros, ponemos aquí 01:35:54

llamamos al método saludar, decimos saludar, vamos a decirle 01:35:58

que diga hola. Estamos llamando un método, fijaros, el método 01:36:05

saludar, y en particular la definición de este método saludar no tiene 01:36:12

ningún parámetro aquí definido. Y en cambio estoy intentando 01:36:18

hacer una llamada pasándole un parámetro con lo cual como no existe un método que 01:36:21

definido para saludar que tenga que recibe un método que sea del tipo cadena de caracteres 01:36:27

pues no me está compilando entonces yo pongo aquí string ese info pues ahora ya me compila 01:36:33

durante la ejecución de este método de los métodos hablamos en el siguiente tema también sabe todo 01:36:40

esto lo repetiré cuando llega el código a esta línea lo que hará será hacer un salto para ponerse 01:36:46

ejecutar este método se vendrá a ejecutar lo que haya por aquí y antes de empezar a ejecutar el 01:36:53

código que hay en su ámbito mirará el parámetro este y su información se lo cargará a esta variable 01:36:58

entonces es info en esta ejecución valdrá hola si hacemos un saludar con adiós pues este es info 01:37:05

valdrá a dios mira así para ver cómo puede funcionar el retorno vamos a poner aquí un 01:37:16

sistema punto out punto println saliendo del método saludar fijaros que aquí no me está 01:37:25

si me queja no me compila y si nos ponemos sobre él me dice que lo borre porque es un código 01:37:45

inalcanzable y por qué nunca lo va a alcanzar pues porque aquí tiene un retorno si decimos que el 01:37:51

método acaba cuando se encuentra el retorno pues este código nunca lo va a alcanzar entonces para 01:37:58

para que sí que lo alcance y hacer alguna prueba podríamos poner aquí un if y decir que si ese info 01:38:04

es igual por ejemplo a dios que se salga pues ese info podríamos pedir cuerpo nos pediría poner esto 01:38:11

pero esto no nos gusta vale esto lo consideraremos como que está mal lo que haríamos sería punto como 01:38:21

es un string punto de quals y aquí ponemos adiós fijaros en una ejecución primera ese info valdrá 01:38:29

hola este no será igual a dios con lo cual no ejecutaría el código de leaf vamos a ponerlo 01:38:41

entre llaves mejor y en la segunda ejecución adiós ese info valdría adiós porque lo ha cargado aquí 01:38:48

con lo cual esto sería verdadero y nos mostraría un retorno fijaros como ahora ya sí que hay algún 01:38:56

momento en el que este código se puede ejecutar y ya nos ha pasado a compilar que antes no lo 01:39:02

hacía porque porque el retorno no necesariamente se va a producir en todos los casos cuando valga 01:39:07

algo cuando ese info valga diferente de adiós este código sí que se ejecutará entonces si lanzamos la 01:39:13

ejecución fijaros como entra con hola veis nos muestra este un saludo por aquí y nos muestra 01:39:19

saliendo del método saludar vuelve aquí nos hace una ejecución con adiós ese info valdrá adiós nos 01:39:34

muestra un saludo pero ahora como vale adiós hace un return y ya este no aparece es decir return lo 01:39:41

que hace es sacarnos del método que se recomienda pues en un código podéis poner más de un return 01:39:47

fijaros podéis poner aquí es y si es bye vamos a suponer que haga lo mismo veis pues tenemos aquí 01:39:58

dos retos validaría uno se va por el retorno valía daría otro seguiría por el retorno en cualquiera 01:40:15

de los dos casos en este caso como hace lo mismo podríamos poner aquí una condición or para que 01:40:20

fuese si es esto o es lo otro pero bueno me interesaba ahora ponerlo separado porque quería 01:40:27

poner los dos retos se desaconseja un poco el utilizar muchos retos dentro de una dentro de 01:40:31

un método está en línea que lo desaconsejan porque porque si siempre estos casos lo mejor es irse un 01:40:41

poco hacer el bruto imaginaos que esto tiene mil líneas de código y en las y claro no te no te 01:40:49

permite ver todo el método en una pantalla para ver exactamente de un vistazo de lo que pasa 01:40:55

entonces igual tú estar centrado en una parte de código en las últimas 50 líneas 01:40:59

que crees que te está dando un error, das a ejecuciones, te estás fijando 01:41:04

en esas 50 líneas y el código nunca te llega allí y a lo mejor es porque 01:41:08

en las primeras hay un return y se te está yendo por allí 01:41:12

entonces lo que suelen recomendar un poco es que las condiciones para que 01:41:15

se vaya, pues solo pongas un return más bien hacia el final 01:41:20

del método y si tienes que tener diferentes condiciones 01:41:24

las vayas cargando con, a lo mejor con un if en una variable 01:41:27

para asegurarte que no se sale 01:41:31

en cualquier sitio y que el punto de salida del método es único 01:41:36

pero bueno, Java permite poner muchos returns aunque lo que 01:41:39

suelen aconsejar es lo otro, solo poner uno. La etiqueta está return 01:41:43

a veces la veremos que 01:41:49

aparte de decir simplemente return salen, salir, devuelva 01:41:52

una información que podrá ser un número, podrá ser una cadena 01:41:57

de caracteres, podrá ser lo que sea, podrá devolver 01:42:01

algo, para que cuando salga meter algo más 01:42:06

información aquí, lo que se hace en los métodos 01:42:09

es que el método cuando sea llamado devuelva 01:42:13

algo, pero bueno eso lo vemos en el siguiente tema porque es justo 01:42:17

sobre lo que trata, entonces cuando estemos repasando echamos un ratillo 01:42:21

Es decir, ahora quedaros solo con que return puede no tener nada, dependerá del caso o podrá estar devolviendo algo, a lo mejor un número entero o un valor, un código de cómo ha ido la ejecución de este método para que luego sea valorado o sea evaluado desde el sitio donde se ha llamado. 01:42:26

ya os digo esto lo vemos en las siguientes clases que yo creo que se trata justo en el tema que viene 01:42:42

y bueno no sé si yo creo que no voy a arrancar con nada nuevo ya son las 7 y cuarto 01:42:48

si tenéis alguna duda de lo que hemos visto hoy o alguna cosa que queréis comentar comentemos 01:42:57

el ejercicio ese que me sugeríais ahí en el chat poner en el foro y luego lo echo un ojo y os respondo 01:43:03

esta noche o mañana. La clase la subo como siempre 01:43:10

para que la tengáis disponible si alguien quiere volver a echarle 01:43:14

un ojo. Y nada, si me queréis comentar 01:43:18

alguna cosita, a vuestra disposición estoy este ratito. 01:43:22

¿No tenéis nada? Pues yo creo que vamos a ir parando entonces 01:43:33

ya si os parece. El siguiente tema 01:43:37

esta noche, a lo largo del día de mañana os lo abro 01:43:43

y nada pues seguimos trabajando sobre él vale bueno pues nada voy deteniendo aquí 01:43:46