Saltar navegación

20260109 Repaso_Static_EjemploTeclado - 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 12 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues lo último que estuvimos viendo el miércoles estaba en relación con el concepto de estática, ¿vale? Entonces, sabemos lo que es que una propiedad sea estática y es una propiedad, es, vale, estática, vale, entonces, vale, ya sabemos que una propiedad, 00:00:00
Si tiene el static delante, en una clase, la que sea, clase A, ya sabemos que eso significa que todos los objetos de la clase A, a1, a2, a3, todos, tienen como propiedad .num esta, la misma. 00:00:40
todos tienen la misma 00:01:08
entonces si hacemos a1.num 00:01:11
vamos aquí, pero si hacemos 00:01:13
a2.num también vamos aquí 00:01:15
hasta ahí está claro, entonces tanto es así 00:01:17
que podemos llamar 00:01:20
esa propiedad static con el nombre de la clase 00:01:21
sin más, a.num 00:01:23
no hace falta que la llamemos 00:01:25
como a1.num 00:01:28
o como a2.num 00:01:29
se puede, pero no es lo recomendable 00:01:31
el propio compilador te va a decir 00:01:34
que manera tan artificiosa de llamarlo 00:01:35
¿vale? no llamamos 00:01:37
así a las propiedades estáticas, sino lo llamamos 00:01:39
con el nombre de la clase. 00:01:41
¿Vale? Porque como vayamos 00:01:44
por donde vayamos, vamos a ir al mismo sitio. 00:01:45
Además hay otra 00:01:48
implicación, y es 00:01:49
que si llamamos así a la propiedad 00:01:51
necesitamos que exista 00:01:53
un objeto previamente. 00:01:55
¿Vale? ¿Y hace falta 00:01:58
que exista un objeto 00:01:59
para que exista la propiedad estática? 00:02:00
No hace falta. 00:02:03
Las propiedades estáticas de una clase 00:02:05
son lo que se llaman el contexto estático 00:02:07
de la clase, que puede haber una o mil 00:02:09
y esas propiedades 00:02:11
pueden existir en memoria RAM 00:02:13
aunque no exista ningún objeto 00:02:15
aunque no exista ninguno 00:02:17
y cuando 00:02:19
aparecen, cuando se crean, porque sabemos 00:02:21
cuando se crea un objeto, un objeto se 00:02:23
crea cuando lo instancias con el new 00:02:25
¿vale? pero cuando 00:02:27
aparecen las propiedades estáticas de una clase 00:02:29
si hubiéramos 00:02:31
instanciado algún objeto con el new 00:02:33
en el momento de instanciar 00:02:35
el primer objeto 00:02:37
ya aparecen, ya están ahí 00:02:38
ya aparecen a disposición de todas las demás 00:02:40
pero si no hemos instanciado 00:02:42
ningún objeto, también pueden 00:02:44
aparecer, ¿cuándo? la primera vez 00:02:46
que accedamos a ellas, por ejemplo 00:02:48
si yo hago a.num 00:02:50
igual a 3 00:02:52
puedo hacer esta sentencia 00:02:53
a.num igual a 3 00:02:56
sin haber instanciado ningún objeto antes 00:02:58
pues en este momento 00:03:01
que es la primera vez que hago 00:03:02
referencia a la propiedad a través del número 00:03:04
de la clase, aparece 00:03:06
Y ahí aparece, es el contexto, ella y todas las demás, no solo ella, todas las demás que hay estáticas, aparecen. 00:03:08
Es decir, el contexto estático de una clase, o lo que es lo mismo, toda esa información compartida por todos los objetos 00:03:17
que se supone que está pensada para describir la entidad en conjunto y no cada objeto por separado, 00:03:25
pues ese contexto estático aparece la primera vez que se hace referencia a esa clase en el código. 00:03:32
Bien porque se hace referencia a una variable, a una propiedad, bien porque es instancia en objeto, por lo que sea. 00:03:38
Bueno, pues esas son las variables estáticas. 00:03:45
El hecho de que hubiera variables estáticas implicaba automáticamente que entonces puede haber métodos que sean estáticos también. 00:03:48
Entonces, los métodos ya sabemos lo que son. 00:04:00
Los métodos son un montón de líneas de código que yo encierro ahí entre llaves, a la que puedo llamar por su nombre, la llamo por su nombre, y en condiciones normales a ese método le llamamos, ¿vale? 00:04:01
en condiciones normales 00:04:18
a ese método le llamamos 00:04:23
asociado a un objeto 00:04:25
este método de aquí 00:04:26
que me devuelve un entero 00:04:28
me devuelve lo que sea 00:04:30
¿vale? 00:04:31
este método de aquí 00:04:33
en condiciones normales 00:04:34
pues yo instanciaría un objeto 00:04:36
a uno igual a ni uno sé qué 00:04:37
y haría a uno punto método 00:04:41
y ya está 00:04:44
¿vale? es un método normal y corriente 00:04:46
Entonces, este método va a ejecutar este código que hay aquí 00:04:48
Y cuando este método haga referencia a alguna de las variables de la clase 00:04:53
Como por ejemplo esta, x igual a 3 00:04:58
Pues, ¿a qué variable se va a referir en esta ejecución en concreto? 00:05:02
Pues en esta ejecución en concreto, cuando veamos x 00:05:07
Se va a referir a la propiedad x del objeto a1, obviamente 00:05:10
si lo llama el objeto A2 00:05:15
pues cuando se ejecute este código 00:05:18
y accedamos a la variable X 00:05:22
se va a referir 00:05:24
a la variable propiedad X 00:05:25
de este A2, hasta ahí está claro 00:05:28
bueno, pero puede ocurrir 00:05:29
que haya métodos 00:05:33
que no necesiten 00:05:34
para trabajar 00:05:36
que no lo necesiten 00:05:38
acceder a las propiedades del objeto 00:05:39
porque hagan cosas 00:05:41
que no están relacionadas 00:05:43
con el contenido concreto del objeto 00:05:45
que hagan otro tipo 00:05:47
de cosas, que no es modificar 00:05:49
ni acceder en las propiedades concretas 00:05:51
del objeto, entonces ese método 00:05:53
automáticamente es un método que ya 00:05:55
en la clase decimos, bueno es un método independiente 00:05:57
de cualquier objeto, lógicamente 00:05:59
si este método no 00:06:01
depende lo que hace 00:06:03
un método, por ejemplo 00:06:05
este método que saluda, pues ya está 00:06:10
este método saluda 00:06:12
bla bla bla 00:06:13
este método 00:06:15
no accede en ningún momento 00:06:17
¿dónde van ustedes? 00:06:19
este método en ningún momento accede 00:06:23
a las propiedades del objeto 00:06:25
luego da igual que lo llame Pepito 00:06:27
da igual que lo llame Juanito 00:06:30
da igual, va a hacer lo mismo 00:06:31
lo llame quien lo llame, va a hacer lo mismo 00:06:33
entonces cuando nos damos cuenta 00:06:35
de que el método es independiente del objeto 00:06:37
¿y cuándo es independiente del objeto? 00:06:39
cuando no accede a ninguna propiedad 00:06:41
no estática 00:06:44
pues entonces ese método 00:06:46
decimos, uy, pues tiene la personalidad 00:06:49
de estático, y la tiene 00:06:51
y ya está, pues si además de 00:06:53
darnos cuenta de que la tiene 00:06:55
le ponemos el static delante 00:06:56
habilitamos ya por código 00:06:58
poder llamarlo con el nombre de la clase 00:07:03
si yo a este método 00:07:05
que es estático en su comportamiento 00:07:07
que tiene el siso y es estático 00:07:09
porque no accede a X 00:07:10
no le pongo el static delante 00:07:12
no pasa nada 00:07:14
pero voy a estar obligada 00:07:15
a instanciar siempre un objeto 00:07:18
para llamarlo 00:07:20
y menuda tontería 00:07:21
¿para qué voy a instanciar un objeto 00:07:23
si este método no usa para nada 00:07:25
los datos de este objeto? 00:07:28
da igual que lo llame para 1, que para 2, para 3 00:07:30
¿para qué voy a instanciarlo? 00:07:32
querría no tener que instanciar un objeto 00:07:33
bueno, pues para poder hacerlo así 00:07:35
si yo me doy cuenta 00:07:38
de que es estático 00:07:41
lo marco 00:07:42
lo marco poniendo el static delante 00:07:44
y desde el momento en que está marcado 00:07:46
el compilador ya nos deja 00:07:48
llamarlo 00:07:51
con el nombre 00:07:53
de la clase 00:07:55
¿vale? entonces poder 00:07:55
llamar a un método sin haber instanciado 00:08:00
un objeto previamente 00:08:02
llamándolo con el nombre de la clase 00:08:03
nos habilita automáticamente 00:08:06
enorme, la enorme herramienta 00:08:10
de las famosas 00:08:13
funciones de librería 00:08:14
que yo tengo utilidades para hacer cosas 00:08:15
pues le pongo esas utilidades 00:08:18
hay guardaditas en un archivo 00:08:20
utilidades para hacer cosas con números, con cadenas 00:08:21
con lo que sea 00:08:24
cuando quiera yo hacer esas cosas 00:08:25
nombre de la clase 00:08:27
que tiene las utilidades 00:08:30
nombre de la utilidad 00:08:31
y ya está, y no tengo ni que crear objetos 00:08:33
ni que hacer nada 00:08:36
entonces los métodos estáticos 00:08:37
representan 00:08:40
en Java el concepto de los métodos 00:08:42
de librería de toda la vida 00:08:44
métodos que hacen cosas 00:08:46
ahí guardaditas 00:08:47
no asociados a ningún objeto concreto 00:08:49
hacen cosas genéricas 00:08:51
y yo los llamo 00:08:52
con el nombre de la clase 00:08:54
donde están guardados 00:08:55
cuando tenga que usarlo 00:08:56
¿vale? 00:08:57
entonces recordad 00:09:01
un método estático 00:09:02
su única condición 00:09:03
es que no use 00:09:05
propiedades no estáticas 00:09:06
si usa static 00:09:08
sigue siendo estático 00:09:10
lógicamente 00:09:11
porque depende de los objetos 00:09:12
si se le pasan propiedades 00:09:13
aquí, pues no pasa nada 00:09:16
está usando propiedades suyas 00:09:18
que le han pasado, no pasa nada 00:09:20
sigue siendo estático igualmente 00:09:22
aquí puede tener variables locales, lógicamente 00:09:23
solamente va a 00:09:26
depender el método del objeto 00:09:28
solo va a depender 00:09:30
si accede a propiedades propias 00:09:31
si no accede a propiedades propias 00:09:34
ya es estático, lo marco 00:09:35
y lo puedo llamar así 00:09:38
bueno, pues en relación a esto dijimos 00:09:39
Y vamos a usar esta posibilidad para a lo mejor ahorrarnos un poco de la problemática asociada, por ejemplo, al famoso escáner este. Tenemos que estar siempre preocupándonos de instanciar el escáner cuando queremos leer por tecla, de instanciarlo, luego si he leído un número, acordarme de que se queda un salto de línea y si luego leo una cadena, va a interpretar que es la cadena vacía, seguida el salto de línea. 00:09:42
y si podemos meter toda esa complejidad 00:10:09
en unas funciones de librería 00:10:12
que se llame en unos métodos estáticos 00:10:14
que se llame leer entero, leer no sé qué 00:10:17
cuando yo quiera leer, llamo a leer entero y ya está 00:10:18
pues qué fácil, me olvido ya del escáner para siempre 00:10:21
y nos sirve como ejemplo de métodos estáticos 00:10:24
bueno, pues era lo que hicimos el último día 00:10:28
y el asunto era el siguiente 00:10:32
Vale, pues lo hicimos con este ejemplo 00:10:37
Este proyecto lo subo luego 00:10:50
O sea, esta clase, vamos 00:10:53
Este proyecto de aquí 00:10:54
Nos hicimos aquí este paquete 00:10:57
En el mismo proyecto de ejercicios 00:11:00
Nos hicimos un paquete teclado 00:11:01
Con esta clase de aquí 00:11:03
Vale 00:11:06
Dijimos, me interesa a mí el método 00:11:07
Leer un numerito entero 00:11:09
Y que me devuelva como valor de retorno el entero 00:11:12
entonces, como esta clase 00:11:15
que yo he llamado teclado 00:11:18
no tiene propiedades 00:11:20
es que este método 00:11:22
es obligatoriamente 00:11:24
static, es imposible que dependa 00:11:26
de propiedades de la clase, es imposible 00:11:28
pues entonces le marco con static 00:11:30
eso que me va a permitir 00:11:32
llamarlo ya desde cualquier 00:11:34
sitio, porque tiene el public, claro 00:11:36
con teclado 00:11:38
punto leer entero 00:11:40
y ya me devolverá como valor de retorno 00:11:41
el int. Y ahora yo ya 00:11:46
meto aquí dentro todo lo que 00:11:48
quiera hacer. Entonces dijimos, 00:11:50
como esto lo estamos 00:11:53
usando como ejemplo, esto 00:11:54
no era una cosa que había que 00:11:55
entender ni de nada. Dije, vamos a cambiar 00:11:58
el escáner por este objeto, 00:12:00
que es otra forma de leer 00:12:02
que me evita los errores del salto de línea. 00:12:04
Y como luego a partir de ahí 00:12:07
ya esto se va a quedar metido en este método 00:12:08
y no lo voy a volver a ver, 00:12:10
pues ahora mismo no nos preocupa entenderlo 00:12:12
Entonces, instanciamos este objeto, que era igual que un escáner, pero sin menos problemas que el escáner, porque es más complejo. 00:12:14
Y dentro del entero instanciamos este, que se instancia de esta manera. 00:12:23
Y luego ya llamábamos a esta sentencia, que es la que me permite leer un número entero con este objeto. 00:12:29
Este objeto me lee una cadena, luego lo transformo entero y lo devuelvo con el retorno. 00:12:38
La clase BufferReader está en java.io, aquí, ¿vale? 00:12:43
Y esta clase, su constructor tira a la vez de esta otra, que también se queda aquí. 00:12:58
Y entonces, si quitamos esto un segundito, que es lo que mete aquí mucha basurilla, 00:13:08
nos quedaba esto, ¿vale? 00:13:15
Entonces el método es 00:13:17
Créame este objeto 00:13:20
Que es como si fuera un escáner 00:13:22
Ya lo entenderemos cuando veamos entrada y salida 00:13:23
Pero es como si fuera un escáner 00:13:25
Y ahora este objeto 00:13:27
Te lee líneas del teclado 00:13:28
Y ahora tú ya 00:13:31
Las conviertes a numerito entero 00:13:33
¿Vale? 00:13:36
Podríamos poner un escáner también 00:13:45
Y hacer siempre un next line 00:13:47
Y convertirlo a entero 00:13:49
Y ya está 00:13:50
si este 00:13:51
vale, de hecho 00:13:52
estoy pensando en que vamos a 00:13:56
para no poner cosas 00:14:00
vamos a cambiarlo 00:14:01
por el escáner directamente 00:14:08
vale, entonces 00:14:09
sí, lo que pasa es 00:14:17
claro, pero lo que hago es 00:14:24
ahora no hago el next in, sino que hago 00:14:25
el next line y lo convierto entero 00:14:27
para que se coja el salto de línea 00:14:29
porque el next line sí que coge el salto 00:14:31
de línea, y así me ahorro 00:14:33
eso de la excepción que 00:14:37
os he puesto, entonces todos estos 00:14:39
import no hacen 00:14:41
falta, vale 00:14:43
no, no os liéis, vamos a 00:14:45
entonces vamos a hacer un método que 00:14:46
me creo un objeto 00:14:49
scan 00:14:53
se supone que 00:14:54
este método lo voy a llamar cuando el usuario 00:14:57
vaya a introducir un número entero 00:14:59
pero el número entero lo leo 00:15:00
con next line, ¿para qué? 00:15:03
para asegurarme de que el 00:15:06
objeto escáner se queda con el 00:15:07
salto de línea porque el next line 00:15:09
elimina el salto de línea del buffer 00:15:11
el next int no 00:15:13
y ahora ya ese numerito que yo he leído 00:15:14
en formato cadena 00:15:17
lo convierto a integer parse int 00:15:18
porque claro, si hiciéramos esto 00:15:21
return 00:15:25
scan.next 00:15:27
int 00:15:29
si hiciéramos esto de arriba 00:15:30
el salto de línea 00:15:32
se queda, entonces en la siguiente 00:15:35
lectura tendría el problema 00:15:37
vale, entonces no queremos hacer esto 00:15:38
sino esto de abajo 00:15:41
vale, pues entonces 00:15:42
leer entero 00:15:45
lo llamaremos 00:15:47
y no tenemos que instanciar ya scan en nada 00:15:49
pero ya lo va a hacer leer entero 00:15:51
leer decimal lo vamos a hacer igual 00:15:52
y aquí eso nos permite 00:15:54
quitar esta excepción que todavía no 00:16:11
las conocemos 00:16:13
scan.nextline 00:16:15
y este de aquí lo mismo 00:16:22
leer decimal, leer cadena 00:16:28
es más fácil 00:16:32
leer cadena es 00:16:33
directamente 00:16:39
return scan next line 00:16:41
bueno, para 00:16:43
usar una clase única para todas las entradas y salidas 00:16:48
entonces como 00:16:52
diseño tiene sentido 00:16:53
que esta clase 00:16:55
me encapsula todo lo relacionado con la 00:16:57
entrada 00:16:59
entonces siempre como de nuevo 00:17:00
principio de diseño básico 00:17:03
vamos a encapsular 00:17:05
en clases separadas 00:17:07
las actividades 00:17:09
que están relacionadas por significado 00:17:12
pues todo lo relacionado 00:17:14
con las entradas 00:17:15
se va ahí, por ejemplo 00:17:16
era otra cosa que iba a decir ahora 00:17:22
pues en lugar de hacer aquí variables locales 00:17:25
podría hacer aquí 00:17:27
la variable scanner static 00:17:29
y que todos la usen 00:17:31
único problema 00:17:33
que desde el momento en que haga el primer uso 00:17:35
el contexto estático de esa clase 00:17:38
ya va a existir para siempre 00:17:40
sin embargo aquí es variable local 00:17:42
luego va a desaparecer 00:17:44
cada vez que yo llame al método 00:17:46
se crea y desaparece 00:17:47
sin embargo si yo lo pongo aquí como variable estática 00:17:49
hay un escáner ahí 00:17:52
enganchado 00:17:53
a la consola 00:17:54
ya para siempre 00:17:56
porque es una variable estática 00:17:58
que aparece la primera vez que se usa esta clase 00:18:01
y ahí se queda para siempre 00:18:03
todo lo que sea local, en principio 00:18:04
mejor, porque sólo está 00:18:07
sólo existe el tiempo que se le usa 00:18:09
en general, son de nuevo 00:18:11
pues pautas más o menos 00:18:13
generales, vale, pues yo me 00:18:15
aquí tengo tres funciones 00:18:17
de librería, tres métodos estáticos 00:18:19
que he querido hacer porque 00:18:21
me interesa, como hago muchas veces 00:18:23
lo de leer datos 00:18:25
pues no quiero cada vez preocuparme 00:18:26
de hacer un escáner y patatín 00:18:29
pues nos hacemos 00:18:30
esta clase 00:18:33
¿vale? con los tres métodos 00:18:34
y ahora ya, por ejemplo 00:18:37
que la queremos usar 00:18:39
desde cualquier otro 00:18:41
sitio 00:18:43
desde este main que teníamos aquí 00:18:44
que era el de 00:18:47
clientes pedidos, pues yo me hacía un 00:18:49
escáner para usarlo 00:18:51
pues podría pasar 00:18:53
de este escáner 00:18:55
podría pasar de él 00:18:56
y ahora ya, que quiero leer un decimal 00:18:59
pues llamo a mi función de librería 00:19:01
quería leer yo aquí 00:19:05
un decimal para 00:19:09
llamo a mi función de librería 00:19:10
y mi función de librería, ¿dónde está? 00:19:13
está en el paquete teclado 00:19:15
con minúsculas y se llama teclado 00:19:17
luego su nombre real 00:19:19
es este, teclado punto teclado 00:19:21
leer 00:19:23
decimal 00:19:25
ala, ya está 00:19:26
ya está, ni 00:19:28
escáner ni nada, que yo quiero 00:19:32
leer un decimal, llamo al método de 00:19:34
librería o método estático de la clase 00:19:36
teclado 00:19:38
que no queremos 00:19:39
arrastrar todo el nombre del paquete 00:19:42
¿qué hacíamos? 00:19:44
un import, ¿vale? 00:19:46
si yo no quiero arrastrar el 00:19:48
nombre, me hago aquí un import 00:19:50
y ya está 00:19:51
me hago aquí el import y se acabó 00:19:53
que 00:19:56
aquí, por ejemplo, 00:19:58
aquí teníamos el problema de que teníamos que 00:20:00
quitar esto. Pues no, 00:20:02
ahora ya no me hace falta esto. 00:20:04
Vale, aquí queremos leer una cadena. 00:20:06
Hombre, pues no la voy a leer así. 00:20:08
La voy a leer con mi función de librería. 00:20:10
Teclado, punto, leer 00:20:12
cadena. Vale, aquí lo mismo. 00:20:14
No la quiero leer así, más que 00:20:16
nada porque el escáner lo acabo de quitar. 00:20:18
Teclado, punto, leer 00:20:20
cadena. Aquí teníamos 00:20:22
lo mismo. Teclado, 00:20:26
punto, leer 00:20:31
sin duda 00:20:32
ah, esto era un decimal, no una cadena 00:20:45
vale, y teníamos más entradas 00:20:49
salidas 00:20:54
pues aquí teníamos una cadena 00:20:55
cadena, vale 00:20:57
y ya está, sí 00:21:10
puedes ir al baño 00:21:12
y ya casi hemos acabado 00:21:13
este era el entero, este es el proyecto de clientes 00:21:16
pedidos que estábamos haciendo 00:21:18
Jolines 00:21:20
Un segundito 00:21:24
Irretul 00:21:32
Teclado 00:21:35
Leer 00:21:40
Entero era 00:21:41
Vale, pues como veis 00:21:43
Hemos usado esas funciones de librería 00:21:46
Ahora ya las hemos 00:21:49
Reutilizado, las hemos usado 00:21:51
Desde un montón de sitios 00:21:52
y aquí ya esta aplicación 00:21:54
mía, mi main, ya se olvida 00:21:57
de toda la complejidad del escáner 00:21:59
de si es 00:22:01
next line, si es next in 00:22:03
de todos esos detalles se olvida 00:22:05
yo ya sé que tengo unos métodos 00:22:07
leer decimal, leer entero 00:22:09
y no solo eso 00:22:10
sino, aquí habíamos llegado 00:22:14
a comentar, no habíamos llegado a comentar 00:22:17
y no solo eso 00:22:19
como esta, en este caso 00:22:24
son tres métodos muy sencillitos 00:22:27
tampoco es que hayamos metido ahí 200.000 líneas 00:22:29
que le ahorran mucho trabajo a nadie 00:22:31
pero bueno, es un ejemplo de procedimiento 00:22:32
si nosotros hacemos esto 00:22:35
además, ¿qué es? 00:22:37
me he hecho unas funciones de librería maravillosas 00:22:38
para que la gente las use y se despreocupe 00:22:40
de hacer el trabajo que hago yo aquí dentro 00:22:42
si hacemos eso, hombre, la idea es documentarlo 00:22:44
que menos 00:22:47
para que la gente sepa qué es lo que hace eso 00:22:48
qué va a usar 00:22:51
documentación estándar 00:22:52
con Javadoc 00:22:55
que es un tipo 00:22:57
concreto de comentarios 00:22:59
que empiezan 00:23:01
con barra 00:23:03
y ahora dos asteriscos 00:23:05
y en cuanto le dais a un enter 00:23:07
esto lo mencionamos, ¿verdad? 00:23:08
En cuanto le dais a un enter 00:23:10
ya él te pone el formato de Javadoc. 00:23:12
Entonces, el formato de Javadoc 00:23:16
pues 00:23:17
si hay parámetros, te pondría 00:23:19
parameters, aquí, return 00:23:20
tú aquí dices, bueno, aquí explicas 00:23:23
Este método me lee un entero del teclado. 00:23:25
Retún, ¿qué devuelve? 00:23:36
El número entero leído. 00:23:39
Vale. 00:23:46
Y sería interesante que pusiéramos. 00:23:47
Cuidado. 00:23:49
va a dar excepción 00:23:50
si lo que introduce el tipo 00:23:52
no es un número 00:23:55
porque el integer parseInt 00:23:57
si le pasamos solo a Pepito 00:23:58
pues va a cascar 00:24:00
al integer parseInt 00:24:01
hay que pasarle una cadena que tenga 3, 2, 7 00:24:04
o menos 4, 9, 2 00:24:07
el integer parseInt 00:24:09
coge esta cadena y lo transformaba 00:24:10
al número entero que representaba 00:24:13
si yo paso una cadena que no tiene 00:24:14
una secuencia de números enteros va a dar un error 00:24:17
Entonces, aquí sería interesante avisar. Cuidado, si no pasas, si no escribes una cadena de números válida, da excepción. Vale, y uno lo comenta y lo deja así estupendo. Con comentarios Javadoc, que empiezan así. 00:24:18
ahora, ¿qué ganamos de nuestros comentarios? 00:24:48
pues que ahora alguien usa 00:24:52
está usando mi clase teclado 00:24:53
porque la ha conseguido, ya veremos 00:24:55
cómo la ha conseguido 00:24:57
ha conseguido mi clase teclado, dice 00:24:58
oye, pues yo, uy que bien, tengo esta clase teclado 00:25:01
que hace cositas 00:25:03
voy a ver qué hace 00:25:04
y esto que hago en cualquier otro entorno 00:25:06
funciona exactamente igual, me da igual que sea 00:25:09
Intelligent, Bins, funcionan todos igual 00:25:11
le pones el punto para ver lo que te 00:25:13
ofrece esta clase y dice 00:25:15
ah mira, me ofrece varios, a ver 00:25:17
leer entero que me ofrece 00:25:18
y tú pinchas aquí 00:25:20
leer entero 00:25:22
y automáticamente el entorno, cualquier 00:25:23
entorno, está conectado 00:25:26
a los comentarios de Javadoc, cualquiera 00:25:28
entonces aquí te sale lo que tú has 00:25:30
escrito, este entero me lee un número 00:25:32
el número entero leído, cuidadín 00:25:34
si no escribes una cadena te va a dar 00:25:37
excepción, ¿vale? que es la manera 00:25:38
de desarrollar 00:25:41
tus librerías, comentándolas 00:25:43
con Javadoc y así 00:25:44
el que las usa, que no le interesa 00:25:46
nada el código que hay dentro 00:25:49
pero sí lo que hace 00:25:50
pues directamente desde su entorno 00:25:52
ya dice, oye a ver que tienes, ah tienes todo esto 00:25:54
vale, y cada cosa que hace 00:25:57
si yo no la tuviera comentada 00:25:58
si pincho la de arriba 00:26:01
la de arriba 00:26:02
no le he puesto el comentario javadoc 00:26:04
luego no me sale nada 00:26:06
no le he puesto el comentario 00:26:08
tengo que deducir por el nombre que es lo que hace 00:26:10
pero la de abajo al tener el comentario 00:26:12
javadoc, pues que estupendo 00:26:15
y ya decido, me interesa, pues sí, me interesa 00:26:16
uso eso 00:26:19
y esto es así en cualquier entorno 00:26:19
de nuevo 00:26:23
son procedimientos, normas 00:26:24
a las que todos nos adaptamos 00:26:27
para poder hacer 00:26:29
una comunidad de desarrollo 00:26:31
en la que de alguna manera progresemos 00:26:32
vale, hasta aquí está claro 00:26:35
perdón 00:26:39
para leer stream 00:26:51
A ver un momentito 00:26:54
Si es por la mañana, sí 00:27:06
Que me están montando la cocina 00:27:08
Y la están liando el pardo 00:27:11
Si es por la mañana, sí 00:27:12
Vale 00:27:14
vale 00:27:37
hasta aquí estamos 00:27:46
todo el mundo 00:27:48
lo tiene ready 00:27:52
bueno pues 00:27:53
y ahora me diréis 00:27:59
vosotros 00:28:02
con todo el buen criterio del mundo 00:28:02
no, para qué sirve no 00:28:06
porque eso es evidente, si alguno me pregunta 00:28:10
para qué sirve, es que tiene 00:28:12
el cerebro de un mosquito 00:28:14
¿alguien aquí tiene el cerebro de un mosquito? no 00:28:15
pues entonces nadie 00:28:18
me haría esa pregunta, obviamente 00:28:20
¿vale? 00:28:22
es evidente, las funciones 00:28:24
de librería son la magia de la programación 00:28:26
¿vale? 00:28:28
¿las usamos continuamente? 00:28:30
vale 00:28:32
entonces, pero sí, la pregunta 00:28:32
que sí que me haríais 00:28:37
la que sí que me haríais, lógicamente 00:28:38
es, menudo 00:28:41
rollo, o sea, si yo ahora quiero usar esta 00:28:43
clase teclado, que la tengo aquí 00:28:45
en este proyecto 00:28:47
de ejercicios, aquí la tengo 00:28:48
encerrada en un paquete y claro 00:28:50
la he podido usar desde 00:28:53
otras clases 00:28:55
del mismo proyecto 00:28:56
pero si ahora yo quiero usar la clase teclado 00:28:58
como debería querer usarla 00:29:01
desde cualquier proyecto 00:29:02
de cualquier parte 00:29:03
porque me es muy cómoda 00:29:04
me olvido del escáner 00:29:05
voy a tener que ir a este proyecto 00:29:06
coger este paquete 00:29:09
copiarlo en mi proyecto 00:29:11
pues no es la manera de trabajar 00:29:12
más que nada 00:29:15
en todo caso 00:29:17
en nuestro caso 00:29:18
si estamos nosotros 00:29:19
practicando estos ejercicios 00:29:20
pues sí podría serlo 00:29:21
porque nos es cómodo 00:29:22
pero no es la manera 00:29:24
de trabajar en general 00:29:25
más que nada 00:29:26
porque las aplicaciones 00:29:27
el término de proyecto 00:29:28
es un término del entorno de desarrollo, 00:29:30
de Eclipse, de IntelliJ, del que sea. 00:29:33
No es de Java. 00:29:35
Para Java lo único que hay es clases. 00:29:36
No hay proyectos, no hay nada. 00:29:40
Yo tengo que trascender un poco de esta idea 00:29:41
de que tengo esto en un proyecto, 00:29:44
ahora lo copio a otro. 00:29:45
No. 00:29:46
Tengo que sacar esto a algo más general 00:29:47
para que lo pueda usar cualquier aplicación Java. 00:29:49
Este me tiene un entorno de desarrollo 00:29:52
o ya no, ya sea un conjunto de clases, 00:29:54
pero es una aplicación Java fuera del entorno. 00:29:56
Vale. 00:29:59
Pues entonces, ¿qué es lo que hacemos cuando nosotros queremos ofrecer nuestras aplicaciones al exterior? Bien sean clases de librería o una aplicación con un main que ya funciona, ¿vale? Queremos ofrecer nuestra aplicación al exterior, pues no le damos a ese humano el proyecto, no le damos el proyecto, porque si le diéramos el proyecto le estaríamos obligando a que él se instale en un entorno de desarrollo, cargue el proyecto en el entorno y lo ejecute. 00:30:00
obviamente no 00:30:28
cuando nosotros le damos una aplicación Java 00:30:29
o funciones de librería 00:30:32
a alguien, ese alguien 00:30:34
no tiene que tener un entorno de desarrollo 00:30:36
lo único que tiene que tener es una máquina virtual 00:30:38
una JVM para ejecutarlo 00:30:39
no necesita nada más 00:30:42
cuando os descargáis una aplicación Java 00:30:43
hacéis clic y pum, esa aplicación arranca 00:30:45
porque tenéis una máquina virtual que la interpreta 00:30:48
pero no 00:30:50
os dan un proyecto 00:30:52
y lo abrís desde un entorno 00:30:53
eso no lo hacéis nunca 00:30:55
Bueno, pues entonces, ¿cómo distribuimos nuestras aplicaciones 00:30:57
o funciones de Iberia para que funcione así la máquina virtual 00:31:01
tal cual las interprete? 00:31:04
Pues tenemos que empaquetarlas, tenemos que guardarlas, 00:31:06
que comprimirlas de una manera que la máquina virtual sepa entender. 00:31:09
Que repito, no es el formato proyecto. 00:31:14
La máquina virtual de Java no entiende el formato proyecto. 00:31:17
La máquina virtual de Java, ¿qué formato entiende para ejecutar 00:31:20
y desentrañar y meterse dentro a cotillear? 00:31:24
jar 00:31:28
este 00:31:31
con la herramienta jar 00:31:33
se generan archivos 00:31:38
.jar 00:31:40
y los archivos .jar son la base 00:31:41
de Java, que es un archivo .jar 00:31:46
algo que tiene tropecientas 00:31:48
clases 00:31:50
una de ellas se supone que será un mail 00:31:50
y cuando a la máquina virtual le pasas 00:31:54
un jar, pues ya está 00:31:56
la máquina virtual es capaz de meterse 00:31:58
en el jar porque ese sí que lo entiende 00:32:00
no como el proyecto, lo entiende 00:32:02
y de ahí busca el mail 00:32:04
y se ejecuta, y ya está 00:32:06
luego un fichero .jar 00:32:08
es un conjunto de clases, y esa es la 00:32:10
manera de distribuir el código java 00:32:12
porque ese es el que la máquina virtual puede 00:32:13
entender, luego 00:32:16
si nosotros 00:32:18
queremos este 00:32:20
paquetito java teclado de aquí 00:32:24
este de aquí 00:32:26
distribuirlo para usarlo 00:32:27
desde cualquier lado 00:32:30
vamos a tener que empaquetarlo en hard 00:32:31
empaquetarlo en hard 00:32:34
es muy sencillo, es una herramienta 00:32:36
que se puede usar desde consola 00:32:38
como el zip 00:32:39
pues hard con unos parámetros 00:32:41
y ya está y te lo crea 00:32:44
pero somos tan absolutamente 00:32:45
vagos que los centros de desarrollo 00:32:48
nos lo facilitan todo 00:32:50
no tenemos que abrir la consola ya para nada 00:32:52
desgraciadamente 00:32:54
porque es la mejor manera 00:32:56
de aprender 00:32:58
entonces 00:32:59
el entorno de desarrollo 00:33:01
como me puede ayudar 00:33:03
a crear un jar 00:33:05
con un conjunto de clases dentro 00:33:06
pues botón derecho 00:33:08
export 00:33:10
en cualquier lado, luego ya lo marcamos 00:33:12
pero si tú vas a exportar este 00:33:17
paquete, ya directamente 00:33:19
hazlo ahí y ya te va a 00:33:21
aparecer marcado ese paquete, aunque luego 00:33:23
podrías cambiarlo 00:33:25
siempre tiene que haber un empaquetado 00:33:25
No es obligatorio 00:33:35
O sea, puedes exportar sin empaquetado 00:33:42
Pero no es recomendable 00:33:44
Export 00:33:46
Entonces, ¿export qué queremos exportar? 00:33:49
Por nosotros hasta ahora 00:33:52
Lo único que queremos exportar es un 00:33:53
JAR file 00:33:56
El JAR de arriba 00:33:58
Porque son clases de librería 00:34:00
Si fuera un proyecto con main 00:34:02
Sería el de abajo, el runable 00:34:04
que ahora lo mencionamos 00:34:06
venga, quiero un hard file 00:34:08
que es empaquetar clases sin más 00:34:10
pues marcamos el hard file 00:34:12
y ahora 00:34:14
oye 00:34:16
¿a qué fichero lo quieres empaquetar? 00:34:18
pues aquí 00:34:21
ya le dais un fichero .hard 00:34:22
que él va a crear 00:34:24
yo por ejemplo lo he puesto en el escritorio 00:34:26
uno que se llame teclado.hard 00:34:28
que tenga la extensión .hard 00:34:30
es lo único que necesitamos 00:34:33
y ahora aquí 00:34:34
es que claro 00:34:39
yo con la pantalla que tengo 00:34:40
aquí se ve fatal 00:34:43
pero en esta 00:34:45
mini ventanita, os aparecerá más grande 00:34:47
ahí ya podéis marcar 00:34:49
el paquete o los paquetes que queréis 00:34:51
exportar, ¿vale? 00:34:53
pero marcamos solo 00:34:55
el paquete teclado 00:34:57
porque esa es la única clase 00:34:58
que queremos exportar 00:35:01
para usarla desde otras partes 00:35:03
pero os va a aparecer 00:35:04
marcado si lo habéis hecho lo de botón derecho 00:35:07
desde ahí 00:35:09
lo que pasa es que yo aquí no veo nada 00:35:10
src 00:35:13
teclado, vale 00:35:21
vale 00:35:26
pues ya está, nes 00:35:31
dejamos todas las opciones por defecto 00:35:33
porque no merece la pena 00:35:36
que nos metemos a explicarlas ahora 00:35:37
solo queremos ver 00:35:39
ala 00:35:40
vale 00:35:43
si queremos 00:35:46
que 00:35:49
se exporte 00:35:51
con la posibilidad 00:35:57
de que salga el javadoc 00:35:58
tenemos que marcar esta pestañita de aquí 00:36:00
exportar source files 00:36:03
and resources, vale 00:36:05
marcáis esta pestañita 00:36:06
pero esto es solo para que se vea 00:36:08
la ayuda 00:36:11
nada, todo por defecto 00:36:11
todo por defecto 00:36:15
finish 00:36:17
vale 00:36:17
no, era un aviso 00:36:19
de que el fichero ya existía en mi caso 00:36:27
vale, pues es este 00:36:29
entonces, este no es 00:36:31
un programa Java que la máquina virtual 00:36:35
ahora mismo puede ejecutar 00:36:37
porque no tiene un main 00:36:39
pero es que este en particular no es para 00:36:40
ejecutarlo, este es para 00:36:43
usarlo desde otras aplicaciones 00:36:45
no es para ejecutarlo 00:36:47
porque no tiene main, es para usarlo 00:36:49
desde otras, ¿vale? Pues aquí 00:36:51
lo dejamos nosotros, tan feliz 00:36:53
y ahora, por ejemplo 00:36:55
vamos a imaginarnos que yo 00:36:57
arranco un proyecto nuevo 00:36:59
es solamente 00:37:01
un proyecto de prueba 00:37:05
y ahora voy a borrar 00:37:06
es solo para... 00:37:10
y aquí tengo mi proyecto de prueba 00:37:15
mi proyecto de prueba 00:37:17
pues yo voy a hacer cosas que lean del teclado 00:37:20
y me apetecería usar 00:37:22
eso 00:37:24
entonces lo que yo tengo que tener es el 00:37:25
JAR, pero el JAR lo tendré porque 00:37:28
quien sea me lo ha dado, o lo he 00:37:30
descargado yo de un repositorio, que es lo habitual 00:37:32
de un repositorio lo he descargado 00:37:34
y ahí lo tengo 00:37:36
entonces desde mi repositorio de Maven 00:37:36
o el que sea, o de GitHub 00:37:40
yo me he descargado ese JAR, que me han dicho 00:37:41
que está muy bien para hacer cosas 00:37:44
y ya lo tengo 00:37:45
¿vale? y ya está aquí 00:37:46
y siempre será en JAR 00:37:49
cuando yo me descargo código Java, siempre 00:37:52
Pues ahí lo tengo, en cualquier lado. Vale, ahora, ¿cómo lo incorporo a mi proyecto para hacerlo accesible? ¿Cómo lo incorporo? Bueno, pues le dais botón derecho y veis donde pone Build Path. Pues Build Path, configurar Build Path. 00:37:54
Build Path significa 00:38:18
Configura los caminos 00:38:19
En los que hay cosas 00:38:22
En este proyecto 00:38:26
Path es 00:38:28
Configúrame, por favor 00:38:29
Los caminos en los cuales va a haber recursos 00:38:31
Es lo que significa 00:38:34
Lo digo para que lo asocéis como regla mnemotécnica 00:38:35
Ya sabéis que es camino 00:38:38
Configúrame el camino a mis recursos, por favor 00:38:39
Pues voy a configurarte 00:38:42
Un camino al recurso teclado 00:38:44
Voy a configurarte un camino a ese recurso. Teclado.jar es un recurso que me he descargado, que está por ahí. Pues, oye, por favor, configúrame los caminos a recursos, anda. Pues, venga, vamos a configurarlo. Vale. 00:38:46
al darle aquí a configurar 00:39:00
es que ya me sale automáticamente una pestaña 00:39:03
que es librerías 00:39:05
esto es para configurar el camino 00:39:06
a librerías, justo, venga 00:39:09
librerías, vale 00:39:10
venga, pues 00:39:12
pincháis en cualquiera de los dos 00:39:15
classpath, para no liarnos 00:39:16
porque no estamos haciendo módulos 00:39:20
aquí en classpath 00:39:22
y decido, venga, voy a añadir un 00:39:23
jar, vale 00:39:26
aquí ya aparece 00:39:28
botón añadir JAR externo. 00:39:30
Porque el JAR está afuera, me lo he descargado 00:39:32
y está en mi escritorio, está fuera del proyecto. 00:39:34
Venga, voy a añadir un JAR. 00:39:36
Añadir un JAR es añadirme un camino, un recurso. 00:39:38
Venga, pues lo añado. 00:39:41
Y ahora ya lo buscamos. 00:39:42
Lo buscamos 00:39:45
donde esté. 00:39:46
Añadir external. 00:39:52
Porque está fuera del proyecto, 00:39:53
está en el escritorio. 00:39:55
Sí. 00:39:57
Uno nuevo que he hecho. 00:40:01
Uno nuevo limpio que he hecho 00:40:02
en el que se supone que quiero usar esas utilidades. 00:40:05
¿Vale? 00:40:08
Entonces, he hecho un proyecto nuevo. 00:40:09
En el botón derecho de ese proyecto, 00:40:11
he dado BuildPad, configure BuildPad 00:40:13
y se me ha abierto esto. 00:40:14
Entonces, el configure BuildPad es como decirle, 00:40:17
voy a configurarte caminos a recursos, 00:40:20
caminos a recursos. 00:40:23
¿Vale? 00:40:25
Pues, las librerías son recursos. 00:40:25
Pues, marco ClassPad, que es el camino de mis clases, 00:40:28
dame el camino a mis clases. 00:40:32
Y aquí le he dicho, oye, pues te voy a añadir un camino a un JAR externo, ¿vale? Con ADE externo al JAR, te voy a añadir un camino a un JAR externo. Lo hemos buscado en nuestro explorador de archivos y aquí apareció ya. 00:40:33
entonces, no es que hayamos metido 00:40:47
el JAR dentro del proyecto, no, no, el JAR 00:40:50
sigue fuera, lo que hemos añadido 00:40:52
es un caminito 00:40:54
le hemos dicho, uy, te ha abierto un camino 00:40:55
a ti proyecto, te ha abierto 00:40:58
un camino, que es el camino users admin 00:41:00
de esto, te ha abierto un camino 00:41:02
y en ese camino tienes este recurso 00:41:04
por si quisieras usarlo 00:41:06
todos los 00:41:08
caminos que no, todos los recursos 00:41:10
que no estén aquí 00:41:12
o sea, Java solamente va a poder 00:41:13
acceder a lo que esté dentro 00:41:16
de su proyecto 00:41:18
si quiero que acceda a algo que esté fuera 00:41:19
va a tener que ser 00:41:22
dándole caminos aquí 00:41:24
¿vale? pero bueno ahora 00:41:25
quedémonos solamente con esto sin meternos en más 00:41:28
¿vale? pues le hemos añadido un caminito 00:41:30
a este recurso teclado 00:41:32
ya lo tenemos, voy a play and close 00:41:34
y ahora 00:41:37
fijaos lo que nos ha parecido 00:41:42
en mi proyecto de prueba 00:41:43
nos ha parecido esto 00:41:46
que no estaba 00:41:50
y ahora esto me dice 00:41:52
oye, tu proyecto 00:41:55
tiene acceso a la librería de la máquina virtual 00:41:56
eso como siempre, a esta tiene que tener acceso 00:41:59
siempre a las clases de la máquina virtual 00:42:01
tienes acceso 00:42:03
a tu código fuente, lógicamente 00:42:05
como no te da objeto a tu código fuente 00:42:07
y tienes acceso a estos recursos 00:42:08
que están en este caminito 00:42:11
es decir, he añadido a mi proyecto 00:42:12
un caminito, un recurso nuevo 00:42:15
y ya está 00:42:16
y cada vez que quiera usar ese hardware de un proyecto 00:42:18
de esta manera, añado con el 00:42:21
Configure Buildpad, el camino a ese recurso. 00:42:23
El JAR es uno, está ahí. 00:42:26
Y los proyectos, les digo, oye, que aquí tienes esto, 00:42:28
oye, que aquí tienes esto y ahí tienes esto. 00:42:32
Y ya está. 00:42:34
Y ahora lo podemos usar como cualquier otra clase. 00:42:35
De hecho, si desplegamos aquí, ¿veis? 00:42:39
Si desplegamos, ¿veis que me aparece lo que hay dentro del 00:42:41
JAR? 00:42:46
Si desplegamos, me aparece esto. 00:42:48
Como si el paquete estuviera en mi proyecto. 00:42:50
que no está en mi proyecto 00:42:53
el paquete está en el jar 00:42:54
y al jar llego por este camino 00:42:57
pero lo puedo usar exactamente igual 00:42:59
que mis propias clases 00:43:02
exactamente igual 00:43:03
sí porque lo he exportado 00:43:04
pero podría en el jar no exportarlo 00:43:09
claro 00:43:11
de hecho yo aquí 00:43:13
solo me aparece teclado.class 00:43:18
pero si yo le pincho 00:43:20
me sale el código 00:43:21
porque lo he exportado en el hard 00:43:23
¿vale? 00:43:26
pero Raquel, pasa algo si lo importas directamente 00:43:28
¿cómo si lo importas directamente? 00:43:30
la clase y le importa 00:43:33
la clase de teclado 00:43:34
bueno, es que el import lo tendremos que hacer ahora 00:43:35
pero eso es aparte 00:43:40
yo lo que le he dicho es, le he dicho a la aplicación 00:43:41
oye, ahí tienes un paquete 00:43:44
que puedes usar 00:43:46
y ahora yo ya programo como siempre 00:43:47
ahora el import lo voy a tener que hacer sí o sí 00:43:49
pero es que eso lo hacía igualmente 00:43:51
si el paquete ya estaba dentro del proyecto 00:43:53
entonces ahora ya 00:43:55
lo que he hecho es decirle que esto 00:43:56
está aquí, que lo puedo usar 00:43:59
si yo no hago esto, no lo puedo usar 00:44:00
entonces, ahora, pues yo por ejemplo 00:44:02
pues ahora yo ya me hago mi aplicación 00:44:05
pues cualquier cosita 00:44:06
vale, mi main 00:44:09
y ahora ya 00:44:15
pues en mi 00:44:17
uy, si, nueva clase 00:44:19
pues esta es mi clase 00:44:22
main 00:44:28
ala, pues que quiero yo 00:44:29
leer un numerito entero 00:44:32
es lo primero que quiero hacer 00:44:33
pues que suerte 00:44:35
porque tengo acceso 00:44:36
a una clase teclado 00:44:40
con su ayuda y con todo 00:44:41
ahí tengo acceso, aquí ya ni escáner 00:44:43
ni nada, yo estoy accediendo 00:44:46
directamente 00:44:48
¿vale? 00:44:48
claro, el import lo tengo que hacer, lógicamente 00:44:52
pero esto es independiente 00:44:54
del otro 00:44:55
¿Vale? 00:44:56
Que ahora quiero leer una cadena 00:44:58
Pues ya está, yo puedo leer mi cadena 00:45:03
Tan tranquilamente 00:45:09
¿Vale? 00:45:12
Usando las funciones de esta librería 00:45:13
Que está en el jar 00:45:15
¿Vale? 00:45:16
Si yo no hubiera hecho este input 00:45:24
De hecho voy a deshacerlo 00:45:26
¿Cómo lo puedo deshacer? 00:45:28
Pues lo voy a deshacer así rápidamente 00:45:30
Diciendo quítalo del path 00:45:32
Lo digo, quítalo del camino 00:45:33
quita este camino, fuera, quitao 00:45:35
desapareció 00:45:37
quité el camino a ese recurso 00:45:38
quité el camino, ahora este import 00:45:41
me dice, pero ¿qué es esto? 00:45:44
¿qué es este paquete? 00:45:45
es que no puedo hacer import de nada porque este paquete no existe 00:45:47
no sé nada de él 00:45:50
claro, porque le hemos quitado el camino a ese paquete 00:45:50
se lo hemos quitado 00:45:53
si se lo volvemos a poner 00:45:55
al library 00:45:58
a este lanzar 00:46:02
teclado 00:46:03
ala, pues ya está 00:46:06
le hemos puesto el camino, ahora ya sí 00:46:09
reconoce ese paquete con el INP 00:46:11
¿vale? 00:46:13
entonces vamos a ver un momento 00:46:16
si ahora el tema de los 00:46:17
saltos de línea 00:46:20
me lo hace bien 00:46:21
ahora ya sí hemos codificado bien 00:46:23
esos métodos, aunque fueran dos líneas 00:46:26
¿vale? con el 00:46:27
escáner directamente sin más 00:46:32
después de hacer el next in 00:46:34
se quedaba el salto de línea 00:46:36
con lo cual no me dejaría 00:46:40
leer esto, ¿verdad? 00:46:42
o sea, no se quedaría 00:46:44
aquí a la espera porque se quedaría con el salto de línea 00:46:46
voy a ver si ahora se queda 00:46:48
vale, entero, 6 00:46:49
muy bien, cadena 00:47:06
no sé cuántos, fin, ¿vale? 00:47:08
bueno, pues que 00:47:14
queréis olvidaros de los escáneres 00:47:15
pues os hacéis el teclado .jar, os limitáis 00:47:17
a incorporarlo 00:47:20
a cada proyecto que hagáis y ya está 00:47:22
y a partir de ahí, cada vez que queréis leer algo 00:47:23
lo leéis así y ya está 00:47:25
bueno, pues esto venía como 00:47:27
ejemplo 00:47:32
de la utilidad 00:47:33
de los métodos estáticos 00:47:36
¿veis? este obviamente es un 00:47:37
método estático, lo llamo asociado al nombre 00:47:40
de la clase, ni objeto ni nada 00:47:42
es un método de librería 00:47:44
bueno, dudas 00:47:45
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
12 de enero de 2026 - 20:58
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
581.99 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid