Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 16-01-24 - 4 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 16 de enero de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Vale? Vamos a volver ya con este rollo de Static 00:00:00
para ya que conocemos lo que son métodos estáticos, variables estáticas, 00:00:03
usarlas para hacernos funciones de librería nuestras 00:00:07
que nos puedan ser útiles. 00:00:10
Por ejemplo, 00:00:12
imaginaos que nos hacemos nuestra propia clase, llamémosla 00:00:14
entrada por teclado, por ejemplo, llamemos a la clase entrada por teclado. 00:00:18
Y hacemos en nuestra clase unos métodos 00:00:22
leer entero, leer decimal, 00:00:25
leer cadena y dentro del código que hagamos dentro 00:00:28
pues ya hacemos los apaños que haya que hacer 00:00:32
para arreglar las cosas que queramos arreglar 00:00:36
que nos estén funcionando mal, como lo del next line, etc. 00:00:39
Y ahora ya podremos llamar a esos métodos igual de a los del escáner. 00:00:42
A lo mejor eso nos soluciona un poco la vida. 00:00:47
Vamos a hacer eso como ejemplo de métodos estáticos. 00:00:49
Vale, pues venga. 00:00:55
Vamos a hacer un proyecto que luego vamos a, 00:00:58
esa clase estática, vamos a aprender cómo empaquetarla 00:01:00
para poder importarla desde cualquier otro proyecto 00:01:03
y usarla yo donde quiera. 00:01:05
Pues venga, vamos a hacernos un proyecto nuevo. 00:01:08
Vamos a llamarle a este proyecto, por ejemplo, 00:01:11
utilidades teclado. 00:01:15
Utilidades. 00:01:19
Utilidades teclado, por ejemplo. 00:01:25
¿Vale? 00:01:28
Y ahora me voy a hacer un paquete. 00:01:34
Voy a quitar el módulo info este que he puesto aquí. 00:01:39
Vale. 00:01:43
Voy a hacerme un paquete utilidades 00:01:45
que es el que luego voy a exportar. 00:01:47
Utilidades teclado también lo voy a llamar 00:01:50
para que se vea claro 00:01:54
que es de teclado. 00:01:56
Entonces. 00:02:00
¿Vale? Esto es lo que me he hecho simplemente, 00:02:04
una aplicación vacía, un proyecto vacío 00:02:06
con un paquete utilidades teclado. 00:02:08
Y aquí vamos a hacer ya la clase con métodos estáticos 00:02:11
para luego usar. 00:02:13
¿Vale? Pues en este paquete nos vamos a hacer una nueva clase. 00:02:16
Pues bueno, cada uno el nombre que le sea más... 00:02:21
Pues venga, teclado, 00:02:26
porque la vamos a usar para leer. 00:02:28
Pues hala, una clase teclado 00:02:30
y ya está. Y ahora ya sí que quito la lupa. 00:02:32
Hala, esta es mi clase teclado. 00:02:36
Vale. Pues vamos a hacerle unos métodos estáticos 00:02:39
públicos para poder llamarlos desde fuera. 00:02:43
Este método que quiero que me haga 00:02:48
me lea un entero de la consola 00:02:50
leer entero. 00:02:53
Me lo lea 00:02:55
y me lo devuelva como valor de retorno. 00:02:57
¿Vale? Esto es lo que yo quiero hacer. 00:02:59
Que me lea un entero de la consola 00:03:01
y me lo devuelva como valor de retorno. 00:03:03
Y ahora aquí yo ya es cuando haría 00:03:05
todo el rollo de hacer el escáner 00:03:07
de patatín, de patatán. 00:03:09
Y cuando yo quiera, una vez que tengo 00:03:11
este método estático, desde otra aplicación cualquiera 00:03:13
leer un entero, 00:03:15
me limito a hacer teclado punto leer entero 00:03:17
y me olvido de crear el escáner, 00:03:19
me olvido de todo, porque ya 00:03:21
está todo aquí dentro hecho. 00:03:23
Bueno, pues entonces 00:03:25
como es un método que vamos a programar 00:03:27
una vez y luego vamos a usarlo 00:03:29
desde cualquier lado sin preocuparnos 00:03:31
lo que hay dentro, 00:03:33
pues vamos a dejarlo bien hecho. 00:03:35
Vale, pues en lugar de la clase escáner 00:03:37
hay otras clases para leer 00:03:39
por teclado 00:03:41
que a la hora de escribir 00:03:43
su declaración es más largo, 00:03:45
por eso ya estaría usado solo escáner, 00:03:47
pero a cambio esas clases 00:03:49
no tienen el problema de que te dejen basura en el buffer. 00:03:51
Pues vamos, como lo vamos 00:03:53
a escribir solo una vez ahora, solo una vez 00:03:55
lo vamos a escribir aquí y luego ya lo usaremos 00:03:57
a través de la llamada leer teclado 00:03:59
vamos a usar ahora esa clase. 00:04:01
Porque solo hay que escribirlo una vez, que es aquí 00:04:03
luego ya llamaremos a leer teclado. 00:04:05
Vale, pues es un nombrecito 00:04:07
muy largo efectivamente. 00:04:09
Entonces 00:04:11
la clase que yo digo 00:04:15
sería esta. 00:04:18
Esta clase. 00:04:20
En lugar de escáner es esta. 00:04:22
Y para instanciarla 00:04:24
pues hay que hacer 00:04:26
todo esto. 00:04:28
Es decir, más largo que el new escáner. 00:04:42
Por eso, 00:04:44
hasta ahora he usado el escáner solo, 00:04:46
aunque es un poco pataterilla 00:04:48
para algunas cosas, porque escribir esto 00:04:50
es más largo. 00:04:52
De hecho, es newBufferReader, 00:04:54
newInputStreamReader y luego ahí 00:04:56
System.In. 00:04:58
Todo eso. 00:05:00
Claro, tengo que importar de Java.IO 00:05:02
estas clases, igual que antes importaba el escáner 00:05:04
pues el bufferreader 00:05:06
se importa de Java.IO 00:05:08
este se importa de 00:05:10
Java.IO 00:05:12
Vale, esta es la declaración de la clase. 00:05:15
Y ahora ya la usamos para leer 00:05:17
el numerito y devolverlo. 00:05:19
newBufferReader, 00:05:23
newInputStreamReader, System.In. Eso de ahí. 00:05:25
Sí. 00:05:33
Vale, la clase ya está. Pues ahora 00:05:39
esta clase cómo se usa. 00:05:41
Pues esta clase te ofrece un método 00:05:45
que es el método 00:05:47
readLine, este de aquí. 00:05:49
Este método 00:05:51
que este método 00:05:53
te lee todo lo que le hayas metido tú 00:05:55
y el salto de línea 00:05:57
te lo quita, con lo cual 00:05:59
nunca va a haber problemas con que se quede un salto de línea pendiente ahí. 00:06:01
Te lee todo lo que has escrito 00:06:03
y te quita el salto de línea. 00:06:05
Pero solo hay un problema, que todo lo que has escrito 00:06:07
te lo devuelve como formato string. 00:06:09
¿Vale? 00:06:11
Entonces, si tú has leído un número 00:06:13
tienes que convertirlo luego a string. 00:06:15
Pero eso es muy sencillo. 00:06:17
Primero, vamos a hacerlo por partes 00:06:19
para que sea más cómodo. 00:06:21
Primero leemos del teclado, la línea leída del teclado. 00:06:23
Esta. 00:06:25
La leemos con el readLine, este de aquí. 00:06:27
Vale. 00:06:29
Ahora el rojo lo quitamos ahora. 00:06:31
¿Vale? 00:06:33
Ahora, 00:06:35
ya no hay 00:06:37
ningún salto de línea del teclado. 00:06:39
No hay nada. 00:06:41
De ese problema ya nos olvidamos afortunadamente. 00:06:43
Pero claro, yo este método lo quiero 00:06:45
para leer un numerito. 00:06:47
Lo haré cuando esté esperando que el tío me escriba 00:06:49
37, 12. 00:06:51
Entonces, yo no quiero 37, 12 en formato string. 00:06:53
Quiero 37, 12 en entero 00:06:55
para devolverlo como entero, 00:06:57
porque va a ir a una variable entera. 00:06:59
Es como cuando hacía el nextIn. 00:07:01
Era para llevar una variable entera. 00:07:03
Entonces, vamos a convertirlo a entero. 00:07:05
¿Cómo se convierte un numerito que está en una cadena string 00:07:07
al entero correspondiente? 00:07:10
Pues tenemos de nuevo 00:07:12
un maravilloso método estático 00:07:14
que está en una clase. 00:07:16
¿Ves a JRE que hay tantas clases? 00:07:18
La Math, la Scanner, la Patatín. 00:07:20
¿Eh? 00:07:22
Eh, no. Parseing. 00:07:24
Tu string es para hacer lo contrario, un entero a un string. 00:07:26
Vale. Pues tenemos 00:07:28
una clase maravillosa que es la clase Integer 00:07:30
que está ahí en la JRE 00:07:32
que resulta que tiene un método 00:07:34
estático estupendo 00:07:36
que es el método estático parseing 00:07:38
que tú le pasas un string 00:07:40
y te devuelve el numerito 00:07:44
entero que representa, ya guardado 00:07:46
como variable entera. 00:07:48
Pues eso es justo lo que queríamos devolver 00:07:50
como valor de retorno. 00:07:52
Pues hala eso al retun 00:07:54
y tan ricamente. Eso al retun. 00:07:56
Entonces sería nuestro método. 00:08:00
Y eso ni va a dejar 00:08:02
salto genial de tecla 00:08:04
ni va a dejar nada. 00:08:06
Entonces cuando queramos leer un entero llamaremos 00:08:08
a teclado.leer 00:08:10
entero y solucionado. 00:08:12
Nos tenemos que despreocupar de todo. 00:08:14
El rojo lo quitamos ahora. 00:08:16
¿Qué haremos para leer un dabble? 00:08:18
Pues vamos a copiar y pegar esto mismo 00:08:20
pero con dabble. 00:08:22
Yo quiero leer 00:08:26
un decimal. 00:08:28
Leer decimal. Leer dabble 00:08:32
como queráis. 00:08:34
Lo leo con el readline igual. 00:08:36
3,7 lo que sea. 00:08:38
Pero claro, yo no quiero la cadena 00:08:40
3,7. Quiero su 00:08:42
conversión al numerito dabble 00:08:44
que representa. 00:08:46
Pues de nuevo, de todas esas miles de clases que tenemos 00:08:48
en la JRE, tenemos una clase 00:08:50
estupenda que es la clase 00:08:52
dabble. 00:08:54
La clase dabble 00:08:56
como veis es mayúscula. 00:08:58
Mayúscula. Esto es una clase. 00:09:00
No es el tipo dabble 00:09:02
primitivo con minúscula. No, dabble 00:09:04
es el tipo primitivo. 00:09:06
Esto es mayúscula. Es otra cosa. Esto es una clase. 00:09:08
Esto es una clase. 00:09:10
Pues tenemos la clase dabble maravillosa 00:09:12
que tiene un método estático 00:09:14
que se llama parseDabble 00:09:16
y este método estático 00:09:20
parseDabble 00:09:22
te devuelve 00:09:24
el numerito dabble 00:09:26
en el que ha convertido este string. 00:09:28
Tengo que cambiar el método de retorno, claro. 00:09:32
El valor 00:09:34
de retorno es el dabble en este método. 00:09:36
¿Vale? 00:09:38
De nuevo 00:09:40
este rojo lo quitamos ahora. No os preocupéis ahora 00:09:42
por él. 00:09:44
¿Vale? Pues este método yo lo llamaré 00:09:46
y me devolverá 00:09:48
un numerito decimal como valor de retorno 00:09:50
que ha leído por teclado. 00:09:52
Que queremos incorporar a esta clase 00:09:56
nuestra de métodos estáticos un método 00:09:58
para leer una cadena de texto, 00:10:00
pero también podemos leer cadena de texto, ¿no? 00:10:02
Pues venga, vamos a hacer un método 00:10:04
leer cadena de texto. En este caso, ¿qué me devolverá? 00:10:06
Un string 00:10:08
leerCadena. 00:10:10
Pero en este caso es que ya devuelvo línea 00:10:14
directamente. Es que no tengo que convertirla en nada. 00:10:16
No tengo que convertirla en nada. 00:10:18
Porque ya la propia 00:10:20
cadena es la que devuelvo. De hecho, 00:10:22
podríamos meter esto aquí en el retún 00:10:24
directamente y ya está. 00:10:26
Vamos a meter esto en el retún. 00:10:28
Vale, leerCadena es 00:10:30
la propia cadena que he leído. ¡Hala, esa! 00:10:32
La devuelvo valor de retorno, string. 00:10:34
Bueno, pues 00:10:36
tres métodos estáticos tiene esta clase, teclado. 00:10:38
Y de hecho es que esta clase 00:10:48
esta clase es que no podría 00:10:50
tener métodos no estáticos. 00:10:52
Porque fijaos lo que le pasa a esta clase. 00:10:54
Esta clase no tiene propiedades. 00:10:56
No tiene propiedades, con lo cual 00:10:58
es imposible que haya un método 00:11:00
que dependa de las propiedades de 00:11:02
un objeto teclado en concreto. 00:11:04
Porque si un objeto teclado no tiene 00:11:06
propiedades, es imposible que haya un 00:11:08
método que dependa de las propiedades de aquí. 00:11:10
Es que no las hay, no existen. 00:11:12
Luego, todos los métodos de una clase 00:11:14
que no tiene propiedades, 00:11:16
todos serán estáticos por definición. 00:11:18
Todos, porque no van a depender de ningún 00:11:20
objeto concreto. 00:11:22
Vale, pues tengo yo mi clase estupenda. 00:11:24
A falta de arreglarle el rojo, que lo vamos 00:11:26
a arreglar ahora. 00:11:28
Vale. 00:11:30
Ahora, este rojo 00:11:34
a cuento de que viene. 00:11:36
Este rojo 00:11:38
viene a cuento de 00:11:40
una cosa que veremos en el tema 00:11:42
correspondiente, pero podemos adelantar ahora un poquito. 00:11:44
Como lo vamos a escribir una vez, 00:11:46
ya no hay que escribirlo más. 00:11:48
Podemos adelantar un poquito y tampoco va a sonar muy raro. 00:11:50
Esto viene a cuento de un concepto 00:11:52
en Java, 00:11:54
en cualquier lenguaje, 00:11:56
que es el concepto de excepción. 00:11:58
¿Vale? 00:12:00
Y es, cuando uno desarrolla 00:12:02
las excepciones, es una forma 00:12:08
de habilitar, una 00:12:10
forma de avisar de que algo raro ha pasado. 00:12:12
Pero avisas tú 00:12:14
por código, no es que explote 00:12:16
lo del ordenador, no tiene nada que ver. 00:12:18
Es decir, tú puedes programar y ya veremos cómo. 00:12:20
Y además, 00:12:22
puedes avisar de una manera 00:12:24
curiosa, ya veremos cómo es de curiosa, 00:12:26
de que ha pasado algo raro. 00:12:28
Bueno, pues avisar de una manera curiosa 00:12:30
es lo que se llama lanzar 00:12:32
una excepción. 00:12:34
Las excepciones se lanzan en los programas. 00:12:36
Uno, cuando hace programas, puede lanzar 00:12:38
excepciones. Y es una forma 00:12:40
rara, extraña, peculiar y útil, 00:12:42
ya veremos cómo es de útil, de avisar 00:12:44
de que ese código 00:12:46
te ha hecho algo raro. Bueno, 00:12:48
pues el que hizo el 00:12:50
código readline, que como veis, readline 00:12:52
será un método de la clase 00:12:54
buffer-reader, ¿no? Porque se llama 00:12:56
con el objeto in. 00:12:58
Pues el que hizo este código 00:13:00
utilizó esa manera 00:13:02
de avisarte 00:13:04
de que puede que pase algo raro. 00:13:06
Hombre, y tanto que puede que pase algo raro. 00:13:08
Imagínate que el teclado no está 00:13:10
conectado. Es que aquí no vas a poder 00:13:12
leer. Entonces, el que escribió 00:13:14
este código usó esa forma de avisarte 00:13:16
de que, oye, puede que pase 00:13:18
algo raro, lo que es lo mismo. Puede que 00:13:20
aparezca una excepción. Pasar algo 00:13:22
raro es aparecer una excepción. 00:13:24
Es el nombre técnico. 00:13:26
Entonces, este método, como 00:13:28
tiene eso programado por dentro, 00:13:30
tiene esa forma de avisar, 00:13:32
te obliga a decir, vale, 00:13:34
como me estás avisando de que puede que pase 00:13:36
algo raro, me obligas 00:13:38
a mí a, en caso 00:13:40
de que pase ese algo raro, 00:13:42
¿yo qué haría? Si no pasa nada 00:13:44
raro, el programa sigue. 00:13:46
Pero me estás diciendo 00:13:48
que, y si pase ese algo raro que me 00:13:50
dices, ¿qué hago? Me estás obligando 00:13:52
a que yo te dé 00:13:54
esa alternativa. 00:13:56
Vale, pues, ¿cómo se hace eso? 00:13:58
Haciendo el famoso 00:14:00
try catch. 00:14:02
Haciendo el famoso try catch. 00:14:04
Entonces, el try catch lo podemos escribir, 00:14:06
se escribe así. 00:14:08
Y es... 00:14:10
Vamos a ver. 00:14:12
Vamos a, primero, declarar 00:14:14
la línea 00:14:16
y luego ya intentamos leerla. 00:14:18
Vamos a intentar leerla. Entonces, 00:14:20
esto significa, tú tienes 00:14:22
que decirle, oye, intenta leerla. 00:14:24
Intenta leerla. 00:14:26
Línea igual a in 00:14:28
punto readline. 00:14:30
Vale, que aquí estaba la sentencia peligrosa. 00:14:32
Más que la peligrosa, 00:14:34
la que tiene programado dentro que puede 00:14:36
que te dé un aviso de excepción. 00:14:38
Pues dice, venga, intenta leerla. 00:14:40
Que ha ido estupendo. 00:14:42
Que no me sale esa excepción. 00:14:44
Ya está, no hay más que hacer. Sigo. 00:14:46
Sigo, salgo de la llave 00:14:48
y sigo, y sigo con el retuido y lo que fuera. 00:14:50
Pero, ¿qué pasa? 00:14:52
Si este código al ejecutarse, 00:14:54
¡paf!, lanza 00:14:56
esa excepción que tiene programada dentro 00:14:58
que puede que la lance. 00:15:00
Habrá un if. Si teclado no funciona, 00:15:02
lánzala. 00:15:04
Bueno, pues, ¿qué pasa? Pues, me obligas 00:15:06
a mí a ponerte aquí 00:15:08
en un catch 00:15:10
lo que vas a hacer 00:15:12
en el caso de que eso 00:15:14
pase. 00:15:16
Y yo lo pongo de esta manera. 00:15:18
¿Vale? 00:15:22
Entonces, 00:15:24
aquí en esta parte yo pongo 00:15:26
lo que quiero que se haga 00:15:28
si es que como 00:15:30
consecuencia de meterse en readline 00:15:32
ha aparecido esa excepción. 00:15:34
¿Puede aparecer? Puede que no. Lo normal es que no aparezca. 00:15:36
Pero me obligas, me estás obligando 00:15:38
a decir qué hacer en caso de que aparezca. 00:15:40
¿Y qué hago en caso de que aparezca? 00:15:42
Lo que yo ponga ahí. ¿Qué voy a hacer? Dejarlo vacío. 00:15:44
Yo no quiero hacer nada. 00:15:46
Voy a confiar en que va a estar siempre 00:15:48
el teclado conectado y ya está. 00:15:50
Pero podría poner ahí otras cosas, etc. 00:15:52
Todo esto, que es importante 00:15:54
controlarlo y tiene muchos detalles, 00:15:56
lo veremos en el tema de excepciones. 00:15:58
Ahora mismo, 00:16:00
con entender la idea 00:16:02
simplemente entender 00:16:04
que hay códigos que tienen programado 00:16:06
por dentro 00:16:08
la probabilidad de que pase algo raro. 00:16:10
Y los códigos que tienen programado 00:16:12
por dentro, como es este método readline, 00:16:14
la probabilidad de que pase algo raro, 00:16:16
cuando tú los llamas 00:16:18
tienes que especificar 00:16:20
qué vas a hacer si pasa ese algo raro. 00:16:22
Tienes que especificarlo. 00:16:24
Porque te obliga el compilador. Te obliga. Tienes que especificarlo. 00:16:26
Venga, me obligas a especificarlo. 00:16:28
Pues lo especifico. 00:16:30
Lo especifico diciendo lo que tienes que hacer es 00:16:32
nada. 00:16:34
Que yo podría poner aquí un chorizo de cosas, pero no lo quiero. 00:16:36
Quiero nada. 00:16:38
¿Vale? 00:16:40
Vale, entonces, IOExcepciones, 00:16:42
porque esto es a su vez otra clase 00:16:44
y hay que importarla. Por eso me lo pone en rojo. 00:16:46
Pero no pasa nada. La importo y ya está. 00:16:48
¡Hala! Pues estupendo. 00:16:50
Ya he tranquilizado 00:16:52
al compilador que me dice 00:16:54
cuidado con readline 00:16:56
que si 00:16:58
entra en el if en el que te salta excepción 00:17:00
no me estás diciendo qué hacer. 00:17:02
Ya te lo he dicho. Haz nada. 00:17:04
¿Vale? 00:17:06
¿Vale? Esta es la idea. 00:17:08
Nosotros como no vamos a limitar a llamar a este método leer entero 00:17:10
una vez que hemos escrito esto dentro 00:17:12
ya es que nos da igual. 00:17:14
Bueno, pues este mismo tryCatch 00:17:16
vamos a 00:17:18
todo esto mismo vamos a copiarlo 00:17:20
arriba 00:17:22
en las otras partes que nos daba rojo. 00:17:24
Aquí. 00:17:26
Aquí. 00:17:28
Aquí. 00:17:30
Y aquí. 00:17:34
Vale. 00:17:40
¡Hala! Ya no tengo ningún rojito. 00:17:42
Vale. Está entendido más o menos 00:17:46
estos métodos entonces. Son métodos estáticos 00:17:48
que me sirven para leer 00:17:50
un entero, 00:17:52
para leer un decimal y para leer 00:17:54
una cadena. Y nunca se van a dejar 00:17:56
un salto de línea en el teclado. Nunca. 00:17:58
Porque la clase UFR no lo hace. 00:18:00
A diferencia de la scanner. No lo hace. Nunca. 00:18:02
Y ahora ya yo uso esto cuando 00:18:06
me dé la gana. Por ejemplo, vamos a hacer aquí 00:18:08
un main sólo para probarlo. 00:18:10
Vamos a hacer otro nuevo paquete. 00:18:12
Main. 00:18:14
Un nuevo paquete 00:18:18
main. 00:18:20
vamos a 00:18:24
hacer una clase main cualquiera 00:18:28
para probar esto. 00:18:30
Main. Vale. 00:18:32
Pues venga. 00:18:34
Ahora resulta 00:18:36
que yo tengo que leer un numerito entero. 00:18:38
Tengo que leer un numerito entero. 00:18:40
Y guardarlo en N. 00:18:42
Pues me olvido de scanner. 00:18:44
Me olvido de todo. Para eso tengo yo 00:18:46
el método estático que me acabo de hacer 00:18:48
en la clase teclado. 00:18:50
Leer un entero. Y ya está. Y me olvido 00:18:52
de todo. 00:18:54
Ya está todo aquí metido. 00:18:56
Que ahora resulta que tengo que leer 00:19:00
un dabble. 00:19:02
Bueno. Pues venga. 00:19:04
Para eso tengo yo mi clase teclado. 00:19:06
Ahí. Estupenda. 00:19:08
Para leer un decimal. 00:19:12
Y me despreocupo de cara de scanner. Me preocupo de todo. 00:19:14
Tengo ya este método que me lo hace todo. 00:19:16
Y como son estáticos, los llamo 00:19:18
el nombre de la clase. Es que no tengo que hacer 00:19:20
ni un teclado ni nada. No tengo que hacerlo. 00:19:22
Porque son métodos estáticos. 00:19:24
¿Que quiero leer una cadena? 00:19:26
Bueno. Pues vale. Ahora tengo que leer 00:19:30
una cadena. 00:19:32
Venga. Pues ala. 00:19:40
Tengo yo mi clase teclado que me ofrece 00:19:42
un método 00:19:44
leer cadena 00:19:46
para leer una cadena. 00:19:48
Y ni instancio scanner ni instancio 00:19:50
nada. 00:19:52
Cut. 00:19:56
Y de hecho aquí, como veremos, estamos leyendo 00:19:58
un número y después una cadena. 00:20:00
Y no va a haber problema. 00:20:02
Me va a dejar leerlo todo. 00:20:04
Voy a ejecutarlo. 00:20:06
Aquí se está creando. 00:20:12
Ahí está la espera del entero. Está en leer 00:20:14
el entero. Está ahí esperando. 00:20:16
Pues venga. A la una entero. 00:20:18
Y me lo muestra. Y sigue esperando. 00:20:20
Sigue esperando porque ahora tiene un 00:20:22
Dabble. Un leer Dabble. Ahí sigue. 00:20:24
Pues venga. 56.9 00:20:26
Ahí está. El Dabble lo acaba de meter. 00:20:30
Y sigue esperando. Sigue esperando 00:20:32
porque ahora tiene que leer una cadena. 00:20:34
Como veis, no tiene el problema de que 00:20:36
se haya quedado un salto de línea ahí. 00:20:38
Porque Buffer no tiene ese problema. 00:20:40
Pues venga. Esta cadena. Y ahí la tiene. La acaba de leer. 00:20:42
Entonces, 00:20:46
si usáis 00:20:48
esta clase en todos 00:20:50
vuestros proyectos que 00:20:52
lean por teclado, pues 00:20:54
lo vais a ver más fácil. 00:20:56
Pasáis ya del Skype a partir 00:20:58
de ahora siempre. 00:21:00
¿Vale? 00:21:02
Claro, ¿qué implica 00:21:06
esto? Que tendréis 00:21:08
que hacer un copia y pega de la 00:21:10
clase teclado. Es decir, 00:21:12
la clase teclado es que yo ya tengo en este proyecto. 00:21:14
Que la quiero usar en otro. 00:21:16
Pues, la clase 00:21:18
teclado la tendré que pegar en el otro. 00:21:20
¿Vale? A menos que 00:21:22
la exportemos en un hard y la 00:21:24
importemos. Pero eso es que no nos da tiempo de hacerlo. 00:21:26
Eso es justo lo que acabo de decir. 00:21:30
A menos que exportemos el paquete en un hard 00:21:32
y lo importemos al classpath del otro. 00:21:34
¿Vale? Pero eso es lo que prefiero 00:21:36
hacer el próximo día 00:21:38
para que hay que entenderlo bien. 00:21:40
¿Vale? 00:21:42
Entonces, ejemplo de utilidad de los 00:21:44
métodos estáticos. 00:21:46
Son fundamentales para hacer cosas. 00:21:48
¿Vale? 00:21:50
Adiós. 00:21:54
Vale. 00:21:56
Y vamos a aprovechar 00:21:58
este ratito 00:22:00
para volver 00:22:02
en algo en lo que no hemos entrado 00:22:04
cuando hay viendo métodos, 00:22:06
incluso trycatch y todo. 00:22:08
Se supone que más o menos 00:22:10
tenéis claro, pero hay que 00:22:12
volver en ello por si acaso. 00:22:14
Por ejemplo, 00:22:18
vámonos a un 00:22:20
método cualquiera de la clase 00:22:22
pues cualquiera, pedido, por ejemplo. 00:22:24
De la clase pedido 00:22:26
en la que está de aquí. 00:22:28
Vámonos al método de volver 00:22:30
precio total. 00:22:32
¿Vale? 00:22:34
Este método, ¿con qué variables se está 00:22:36
trabajando? 00:22:38
Con variables de tres tipos. 00:22:40
Una. Bueno, 00:22:42
esta no tiene parámetro. 00:22:44
Con el parámetro o los parámetros 00:22:46
si los tuviera. Esta en particular 00:22:48
no tiene. A ver si hay alguna que 00:22:50
esta sí que tiene. 00:22:52
Vale, este método, 00:22:56
por ejemplo. 00:22:58
Este método, ¿con qué variables 00:23:00
diferentes se está trabajando? 00:23:02
Este método y cualquiera. 00:23:04
Pues está trabajando primero 00:23:06
con el parámetro 00:23:08
o los parámetros que se pasen al método. 00:23:10
Con eso está trabajando. 00:23:12
Lo está usando, de hecho, 00:23:14
en algún sitio está usando 00:23:16
descripción. Aquí hay un equal 00:23:18
que no se ve. 00:23:20
¿No? 00:23:22
Aquí lo está usando. 00:23:24
Vale. 00:23:26
Lo está usando ese parámetro. 00:23:28
¿Está claro? Yo lo he pasado para usarlo. 00:23:30
Eso está claro. Vale. 00:23:32
¿Qué más está usando? 00:23:34
Está usando la variable 00:23:36
ItemsPedido que no ha tenido que 00:23:38
declararla. Es que no solo que no tiene 00:23:40
que declararla, es que no tiene que declararla. 00:23:42
Porque esa variable es una variable del objeto que llama al método. 00:23:44
Esta variable ItemsPedido 00:23:46
está aquí arriba. 00:23:48
Es esta. 00:23:50
Y trabaja directamente con ella. 00:23:52
Sin ningún problema. Porque es una propiedad 00:23:54
del objeto que llama al método. Está ahí arriba. 00:23:56
Trabaja con ella directamente. Vale. 00:23:58
Bueno, pero es que además de eso, el método 00:24:00
también puede trabajar, si quiere, 00:24:02
con variables que declare 00:24:04
él. Que declare él. 00:24:06
Por ejemplo, éste 00:24:10
está trabajando además 00:24:12
con esta variable out, que ha declarado 00:24:14
él ahí dentro. Vale. 00:24:16
Pues esta variable que ha declarado 00:24:18
el método ahí dentro, es lo que 00:24:20
se llama una variable local del 00:24:22
método. ¿No? Luego 00:24:24
distinguir las variables 00:24:26
locales a los métodos 00:24:28
que son las que declaran ellos ahí dentro 00:24:30
para hacer un uso local ahí dentro 00:24:32
de las variables de la clase que 00:24:34
están arriba. 00:24:36
Claro, entonces 00:24:38
¿qué pasa con una variable local? 00:24:40
Que esa variable 00:24:42
desaparece cuando el método termina. 00:24:44
Desaparece. Se ha creado 00:24:46
para ser usado durante el tiempo 00:24:48
que dure el método. Y cuando 00:24:50
el método termina, esa variable 00:24:52
desaparece. Claro, porque tiene 00:24:54
un uso muy concreto, que es durante el tiempo de vida 00:24:56
del método. Esos son los variables locales. 00:24:58
Y las variables 00:25:00
locales no se declaran 00:25:02
solo dentro de métodos, sino se declaran 00:25:04
dentro de cualquier bloque. 00:25:06
Recordad lo que llamábamos bloque al principio. 00:25:08
Un bloque es un trozo de código entre llaves. 00:25:10
Un trozo de código entre llaves. 00:25:12
Entonces, si yo declaro una variable 00:25:14
dentro de un bloque, 00:25:16
esa variable es local al bloque. 00:25:18
Cuando el bloque termina, la variable 00:25:20
desaparece. Eso es algo 00:25:22
¿qué? Más o menos. Pues con 00:25:24
lo que hemos asumido, pero conviene que 00:25:26
ahora volvamos a ello. 00:25:28
Por ejemplo, me voy yo aquí a mi main 00:25:30
este que he hecho aquí para 00:25:32
probar el teclado, así no 00:25:34
embasuro el otro proyecto. 00:25:36
Imaginaos que yo tengo aquí 00:25:38
un if que me dice, si el 00:25:40
n que acabo de leer es igual a 00:25:42
3, y me abro 00:25:44
aquí unas llaves para hacer cosas. 00:25:46
Pues al abrirme aquí unas llaves, 00:25:48
esto es 00:25:50
un bloque. De repente es un bloque. 00:25:52
Vale, no pasa nada, un conjunto de sentencias es un bloque. 00:25:54
Claro, pero ¿qué pasa si ya tiene 00:25:56
un bloque? Pues que, imaginaos 00:25:58
que yo declaro aquí una variable 00:26:00
int m igual a 8. 00:26:02
Vale, no hay 00:26:04
ningún problema. ¿Qué ocurre? 00:26:06
Que m aquí no 00:26:08
existe, ha desaparecido. 00:26:10
¿Vale? Porque es 00:26:12
una variable que está declarada 00:26:14
dentro del bloque. 00:26:16
Luego, si yo intento aquí 00:26:18
mostrar m, 00:26:20
me va a decir, 00:26:22
oye, m no existe, ¿quién es? 00:26:24
Pues vuelvo a esto, 00:26:26
más o menos, se supone 00:26:28
que más o menos lo vislumbramos, conviene que 00:26:30
insistamos en ello. 00:26:32
m, al estar 00:26:34
declarada dentro de un bloque de un código 00:26:36
entre llaves, es local 00:26:38
al bloque, es local. 00:26:40
Luego, cuando el bloque termina, a partir 00:26:42
de aquí, la variable m desapareció. 00:26:44
Solo existe 00:26:46
durante el tiempo que se ejecute el código. 00:26:48
Como si fuera un método. 00:26:50
Un método es un código entre llaves también. 00:26:52
Luego, un método, al tener un código entre llaves, 00:26:54
es un bloque. Las variables que yo 00:26:56
declare locales a ese método, cuando el método 00:26:58
ha terminado, han dejado de existir. 00:27:00
Pues esto es igual. 00:27:02
Entonces, que yo quiero que esa variable 00:27:04
m, poder verla, que 00:27:06
siga existiendo aunque este bloque termine, 00:27:08
pues la declaro fuera. 00:27:10
No pasa nada, la declaro fuera, 00:27:12
aquí, 00:27:14
y le doy, 00:27:16
y ya la uso dentro, para lo que me dé la gana, 00:27:18
darle valor o lo que sea, la uso dentro. 00:27:20
Entonces, 00:27:22
ahora ya sí puedo ver m 00:27:24
si me da la gana. Puedo ver m 00:27:26
porque al estar declarada fuera, 00:27:28
aunque este código termine, 00:27:30
la variable no desaparece porque está declarada 00:27:32
fuera. Recibirá 00:27:34
su valor 8, eso sí, cambiará su valor 00:27:36
que pasará a ser 8. 00:27:38
Y yo podré verla y tendrá aquí su valor 8. 00:27:40
Pero el espacio 00:27:42
de memoria m no ha desaparecido. 00:27:44
¿Vale? 00:27:46
Luego, cuidado porque las variables locales, 00:27:48
a lo mejor uno se cree que una variable 00:27:50
la puede ver desde una zona 00:27:52
de un código, y dice, pero si no puedo verla, 00:27:54
claro que no puedes, porque la has declarado dentro 00:27:56
de un bloque, declarada 00:27:58
fuera, entonces podrás verla. 00:28:00
Es lo que 00:28:02
yo he hecho así, de forma muy 00:28:04
disimulada, 00:28:06
cuando he hecho lo del 00:28:08
try-catch. 00:28:10
Poneos en el try-catch. 00:28:12
El try-catch, de nuevo, 00:28:14
me abre un bloque, por 00:28:16
narices, me lo abre, 00:28:18
porque por obligación, el try 00:28:20
tiene que ir entre llaves. 00:28:22
¿Qué hubiera pasado si yo hubiera 00:28:24
declarado el string line aquí, 00:28:26
en vez de aquí, 00:28:28
esto fuera? 00:28:30
Pues que esto no tendría sentido, 00:28:34
porque al estar esto 00:28:36
declarado dentro de las llaves, 00:28:38
cuando el try termina, 00:28:40
línea ha desaparecido, 00:28:42
luego no puedo devolverla, no podría. 00:28:44
Por eso, 00:28:46
saco la declaración fuera, 00:28:48
y valor sí que se doy aquí, 00:28:50
obviamente, el valor se lo doy en el try, porque me 00:28:52
obliga a hacer esto dentro de un try. 00:28:54
Pero la declaración la hago fuera, 00:28:56
para que cuando el try termine, yo 00:28:58
poder devolverla. 00:29:00
¿Vale? Luego, no perdáis de vista 00:29:02
lo que se llama esto, 00:29:04
el ámbito de las variables, es que una variable 00:29:06
solo es visible dentro 00:29:08
del bloque en el que está declarada, 00:29:10
solo es visible ahí. Cuando ese bloque 00:29:12
termina, esa variable ha desaparecido. 00:29:14
Y a veces queremos que sea así, 00:29:16
porque yo una variable solo la uso dentro de un bloque. 00:29:18
Si solo la uso ahí, la declaro 00:29:20
ahí. ¿Para qué quiero que sea visible 00:29:22
fuera? ¿Para dar guerra? No. Yo la declaro 00:29:24
donde la voy a usar. Pero claro, 00:29:26
si la declaro aquí, solo la puedo usar aquí. 00:29:28
Si quiero usarla fuera, la declaro fuera. 00:29:30
En este 00:29:32
caso, es que tengo que declararla fuera, 00:29:34
porque si no, luego no puedo hacer el return. 00:29:36
¿Vale? 00:29:40
Como principio básico, 00:29:48
uno tiene que hacer las variables 00:29:50
lo más locales posible, 00:29:52
para que estén 00:29:54
lo más 00:29:56
escondidas posibles y no molesten 00:29:58
a los demás. Pero claro, 00:30:00
lo más locales 00:30:02
posibles, siempre y cuando 00:30:04
solo se usen ahí. Si se usan 00:30:06
fuera, tendré que declararle fuera. 00:30:08
¿Vale? 00:30:14
Y que si se abren más bloques, pues igual. 00:30:16
imaginaos este if, a lo mejor podría tener 00:30:20
aquí otro if. Si m 00:30:22
igual a 7, cualquier 00:30:24
chorrada. 00:30:26
Vale. Aquí he abierto 00:30:28
un bloque dentro de otro bloque. 00:30:30
Lo que yo declare 00:30:32
aquí, imaginaos que aquí declaro una variable 00:30:34
Esta variable 00:30:38
aquí fuera no existe. 00:30:42
Porque solo existe dentro de este bloque 00:30:44
de aquí. 00:30:46
Es decir, puede haber bloques dentro de bloques. 00:30:48
Aquí hay un bloque 00:30:50
dentro de este otro. 00:30:52
La variable h solo existe 00:30:54
aquí. Solo existe ahí. Cuando yo salga 00:30:56
de este bloque, h ya ha dejado de existir. 00:30:58
Puede que sea eso lo que me interese 00:31:00
o puede que no. En función de eso, 00:31:02
decido dónde declaro. 00:31:04
¿Vale? 00:31:06
Luego, con esto, uno está 00:31:08
trabajando todo el rato, porque claro, uno tiene que declarar 00:31:10
variables, y las va declarando, y aquí dice 00:31:12
ah no, espérate, que la he declarado demasiado dentro. 00:31:14
Al declararla demasiado dentro, no puedo usarla 00:31:16
fuera. Pues saco la declaración y la llevo arriba. 00:31:18
Es algo con lo que uno está trabajando todo el rato. 00:31:20
¿Vale? Pero repito, 00:31:22
la idea es que 00:31:24
cuanto más dentro esté una variable, 00:31:26
mejor, porque así no molesta 00:31:28
afuera. Porque esta h, por ejemplo, 00:31:30
aquí ya no existe. Con lo cual, aquí puedo 00:31:32
utilizar otra h si me da la gana. 00:31:34
Pero si declaro esta h aquí, 00:31:36
solamente puedo utilizar una h. 00:31:38
Entonces yo declaro lo más local 00:31:40
posible, siempre y cuando no 00:31:42
la necesite fuera. Si la necesito fuera, es que 00:31:44
ahí no hay tu tía. Tengo que declararla fuera. 00:31:46
Pero si solo la necesito aquí, 00:31:48
solo voy a usar h aquí, pues entonces aquí. 00:31:50
Y así ya no molesta fuera 00:31:52
porque ha dejado de existir. Eso 00:31:54
como principio general. 00:31:56
¿Vale? Para que no hagáis el truco de 00:31:58
declaro todo fuera al principio y así 00:32:00
no tengo problema. No. Eso es una forma de 00:32:02
programar fea. Entonces tienes un montón de variables 00:32:04
que no usas todo el rato en memoria. 00:32:06
Todo el rato en memoria. No. 00:32:08
Cuanto más locales, mejor. 00:32:10
Pero siempre y cuando solo se usen 00:32:12
en su bloque. 00:32:14
¿Vale? Si no van saliendo hacia afuera. 00:32:16
¿Vale? Pues esto es lo que se llama 00:32:18
el ámbito de variables en general. Pero bueno, 00:32:20
uno está trabajando con esto todo el rato. 00:32:22
Vale, venga. Pues ahora sí que paramos aquí. 00:32:24
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
16 de enero de 2024 - 21:42
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
32′ 29″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
112.28 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid