Saltar navegación

20250320 JavaFX_1 - 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 21 de marzo de 2025 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, la arquitectura de un proyecto JavaFX se facilita si incorporamos un plugin, igual que hemos incorporado el de Window Builder, pues hay un plugin para JavaFX que si lo incorporamos se facilita la creación de proyectos JavaFX con la estructura que habitualmente tienen, ¿vale? 00:00:00
Entonces, lo primero que vamos a hacer va a ser instalar ese 00:00:21
plugin. 00:00:25
Nombre. 00:00:26
Nombre. 00:00:27
Pues, vamos a buscarlo en, ¿abrís el Eclipse Marketplace? 00:00:27
Igual que, sí, un segundito. 00:00:38
Y ahí buscáis por JavaFX. 00:00:40
Y va a ser el primero que os salga. 00:00:42
EFX Clipse. 00:00:48
Ese. 00:00:49
Pues, os saldrá EFX Clipse, ¿vale? 00:00:50
pues instaláis ese plugin 00:00:53
el plugin igual que el de window builder 00:00:57
lógicamente no es necesario 00:01:00
pero nos facilita 00:01:01
arrancar un proyecto con una estructura determinada 00:01:03
nos puede dar un primer código de partida 00:01:06
igual que el window builder 00:01:08
cuando arrancamos un JFrame desde el window builder 00:01:09
ya nos da un código de partida 00:01:12
etcétera 00:01:14
vale, a mi es que me ha desaparecido 00:01:16
el marketplace de aquí 00:01:24
lo tengo que volver a poner, pero da igual 00:01:25
ya lo tengo instalado 00:01:27
bueno, mientras se va instalando 00:01:28
que os tardará un poquito 00:01:34
vale 00:01:35
JavaFX 00:01:36
igual que Swim 00:01:40
utiliza por supuesto 00:01:42
clases ya hechas 00:01:44
y librerías de clases ya hechas 00:01:45
los .jar famosos, ¿verdad? 00:01:47
lo que pasa es que 00:01:50
la librería de Swim 00:01:51
ya está incorporada en la JRE 00:01:53
hasta la versión actual 00:01:55
incluso, en breve 00:01:57
en futuras versiones de Java ya seguramente 00:01:59
saquen, Swing y AWT 00:02:01
pero ahora mismo todavía está 00:02:03
incorporado, pero JavaFX 00:02:05
que pesa un montón y son un montón 00:02:07
de clases 00:02:09
si, tranquilo 00:02:10
yo que sé, pesa mucho 00:02:12
el plugin, el que te ofrezca 00:02:13
el último que te ofrezca 00:02:16
el que te está ofreciendo el marketplace 00:02:18
Vale, pues los .jar que tienen las clases de JavaFX hay que descargarlos aparte, ¿vale? 00:02:20
Hay que descargarlos aparte porque no están incluidos en la JRE. 00:02:28
Bueno, pues entonces, una vez que tengáis el plugin, vais a tener que descargar, que no hace falta que descarguéis, 00:02:33
que voy a ver si os los puedo subir a un aula virtual o poner en la carpeta compartida. 00:02:41
Bueno, así os voy a decir desde dónde tendréis que descargarlos, ¿vale? 00:02:45
A ver, si vosotros buscáis en, vale, vale, pues a ver, vamos a imaginar que buscamos JavaFX por aquí, a ver que nos sale, entonces, JavaFX, down, load, para afinar un poquito más, bueno, pues es una herramienta de gluon. 00:02:48
y aquí 00:03:33
en esta página 00:03:36
se pueden descargar esas librerías 00:03:38
de las que os hablo 00:03:41
que repito, no las incluye la JRE 00:03:41
a diferencia de las de SWIN 00:03:44
entonces los import 00:03:46
van a necesitar que tengamos 00:03:48
incorporadas esas clases 00:03:50
entonces eso pues uno lo descargaría 00:03:52
desde aquí 00:03:55
no sé si 00:03:55
tardaríais mucho en descargarlo 00:03:58
yo creo que no 00:04:00
lo digo porque si no 00:04:01
comparto yo 00:04:03
aquí 00:04:05
si probáis a descargarlas 00:04:06
si tiene pinta de que esto no tarda nada 00:04:10
o poquito porque aquí me dice que esto ya está hecho 00:04:18
aquí que 00:04:22
no pero esperad 00:04:25
esto no es 00:04:30
esto no es 00:04:30
esto no es 00:04:31
No, perdón 00:04:34
Ah, es que le he dado al jmods el sdk, perdón 00:04:44
Vale 00:04:47
El sdk ya sí que tarda más, claro 00:04:48
¿Qué diferencia hay entre jmods y sdk? 00:04:51
Jmods son archivos de módulos 00:04:55
Para organizar las clases 00:04:57
Y el sdk 00:04:58
Bueno, yo lo voy a detener porque yo ya sí que lo tengo descargado. 00:05:06
Una vez que lo tengáis descargado, vale. 00:05:16
Vale, cuando lo tengáis descargado tendréis este zip de aquí que cuando lo descomprimáis... 00:05:26
Cuando descomprimáis el zip descargado y entréis en el descomprimido, veréis que entrando hay una carpeta lift. 00:05:36
Dentro de ese zip navegáis y hay una carpeta lift. 00:05:45
Jesús. 00:05:48
Vale, pues dentro de la carpeta lift están todos esos JAR que tienen las clases que usa la herramienta JavaFX. 00:05:49
Dentro de estos JAR están esas clases. 00:05:58
Entonces, estas clases tendremos que incorporarlas a nuestros proyectos con JavaFX. 00:05:59
no sé si recordáis como las incorporábamos 00:06:03
pero ahora lo hacemos cuando arranquemos un primer proyecto 00:06:05
vale 00:06:08
si os ha instalado ya el plugin 00:06:09
ha reiniciado ya Eclipse 00:06:12
y todo eso 00:06:14
tarda mucho 00:06:14
vamos a parar un poquito 00:06:18
vale 00:06:22
una vez que tenemos el plugin instalado 00:06:24
ya podemos arrancar un nuevo proyecto 00:06:25
y vamos a darle ya 00:06:28
la pequeña estructura 00:06:29
que nos da el plugin 00:06:31
que podríamos pasar de ella, pero bueno 00:06:32
vamos a darle ya esa pequeña estructura 00:06:35
esa pequeña estructura, recordad 00:06:36
en new order, igual que buscábamos el builder 00:06:38
pues aquí podremos 00:06:40
encontrar el java fx 00:06:43
ahí, habrá aparecido 00:06:45
por el hecho de instalar el plugin 00:06:47
y aquí, ¿qué queremos? pues un 00:06:48
proyecto de java fx 00:06:51
queremos un proyecto de java fx 00:06:52
pues ala, marcamos proyecto de java fx 00:06:55
¿cómo le queremos llamar? 00:06:57
pues como nos dé la gana 00:07:01
Venga, va a ser 00:07:02
El proyecto 00:07:08
De saludarnos 00:07:10
Saludar 00:07:12
App para saludar 00:07:14
Ya está 00:07:17
Finish 00:07:18
Y esta es nuestra app para saludar 00:07:30
Estáis haciéndolo en paralelo, ¿no? 00:07:33
No, porque es espectacular 00:07:38
Ay, ay, ay, qué lentos, qué lentos 00:07:39
Vuestro donador es tan lento como vosotros 00:07:42
El mío no avanza 00:07:44
Llama a Brian ahora mismo 00:07:46
Y dile que venga por tu ordenador 00:07:52
Y que la próxima vez te robe uno mejor 00:07:55
No esa mierda que te roba 00:07:57
Es que esto no lo compré yo 00:07:59
Bueno, sí, se puede 00:08:00
Creo que la propia aplicación ya te instalaba 00:08:01
Ya te descargaba el java 00:08:04
17% 00:08:05
Porque, o sea, el propio 00:08:06
Sí 00:08:08
No, no, no, en realidad no 00:08:10
Porque te pone esto, pero luego esto estaba 00:08:13
Bueno, esto de aquí 00:08:15
Está sin nada 00:08:17
A ver, que si le haces algo seguramente lo haga 00:08:18
Pero 00:08:21
Abrelo 00:08:22
Te sale un hard dentro 00:08:31
Pero entras dentro y no tiene las clases 00:08:35
Entonces esta librería 00:08:37
Podríamos eliminarla de hecho 00:08:39
A ver, que la podemos configurar para que los incluya 00:08:40
Pero vamos a evitaros la vida 00:08:43
que no, que no, que no os voy a examinar de esto 00:08:45
vale, a ver, seguimos 00:08:49
entonces, lo único 00:08:51
que nos ha hecho el plugin 00:08:53
es crearnos 00:08:55
un paquete, que le podríamos haber 00:08:57
cambiado el nombre, nos ha creado 00:08:59
un paquete con un main 00:09:01
que es el que va 00:09:03
a arrancar nuestra 00:09:05
primera, madre de Dios 00:09:07
el que va a arrancar nuestra primera escena 00:09:09
vale, entonces 00:09:11
una aplicación JavaFX 00:09:13
se organiza por escenas 00:09:16
¿vale? 00:09:18
por, bueno, stage 00:09:20
no sé, se traduce más bien como escenario 00:09:22
quizás, ¿no? más que como escena 00:09:24
vale, pues como escenario 00:09:25
entonces, el método start 00:09:27
nos arranca un primer escenario 00:09:29
y este primer escenario 00:09:32
es el que ya tiene las escenas 00:09:34
¿vale? entonces 00:09:35
lo que te hace la aplicación es arrancarte 00:09:37
un primer escenario 00:09:40
este sería como el frame de partida 00:09:41
en Swim 00:09:43
si, si, si, ahora lo hacemos 00:09:44
pero, si, si, si 00:09:47
bueno, no sé exactamente lo que has hecho, pero si ahora habrás 00:09:51
hecho lo que vamos a hacer ahora, imagino 00:09:53
vale, entonces 00:09:55
lo único que nos ha hecho el plugin es incorporarnos 00:09:56
nuestro main, que nuestro main 00:09:59
arranca la aplicación 00:10:01
arranca la aplicación 00:10:03
arranca la aplicación 00:10:06
llamando al método start 00:10:09
que mete una primera escena 00:10:11
con este tamaño 00:10:14
y ya está 00:10:15
le da una hoja de estilo 00:10:18
porque una de las ventajas 00:10:20
de JavaFX 00:10:22
dime 00:10:22
¿para qué? 00:10:23
a ver 00:10:31
¿tú ya has instalado el plugin? 00:10:31
bueno pues ahora haz un proyecto nuevo 00:10:33
y ahora 00:10:35
Eclipse Marketplace 00:10:35
busca por JavaFX 00:10:41
Y el que te ofrece que es EFX 00:10:42
En Help 00:10:44
En el mismo sitio donde estaba cuando buscaste el builder 00:10:47
JavaFX 00:10:50
O sea, con Pedro os metéis y con él no 00:10:54
Sí, caerá muy bien 00:11:05
Pero despierta de repente 00:11:06
Sí, JavaFX 00:11:09
Pues ese es el que hemos dicho 00:11:12
Que tienes que instalar 00:11:15
Ese es 00:11:15
Vale 00:11:19
Bueno, pues como 00:11:21
Una de las ventajas que tiene JavaFX 00:11:22
Es el desacoplamiento 00:11:25
Es el 00:11:27
Desacoplamiento, otra vez 00:11:28
La palabra desacoplamiento la hemos usado a veces 00:11:30
Que es separar funciones 00:11:33
Dentro de una aplicación 00:11:35
Por ejemplo, la hemos usado cuando decíamos 00:11:36
Mucho mejor si en la aplicación 00:11:39
separamos en clases diferentes 00:11:42
lo relacionado con la vista, por ejemplo 00:11:43
lo que ve el usuario, lo relacionado 00:11:46
con el procesamiento de los 00:11:48
datos, lo relacionado con utilidades 00:11:50
matemáticas, si lo vamos separando 00:11:52
en clases distintas y por tanto 00:11:54
hacemos una aplicación desacoplada 00:11:56
cualquier 00:11:58
cambio, cualquier 00:12:00
incorporación nueva que haya que hacer 00:12:01
va a ser mucho más fácil porque yo toco 00:12:04
solo la parte a la que afecta, si está 00:12:06
todo mezclado y tengo que hacer 00:12:08
alguna modificación, en esa mezcla 00:12:10
me va a ser mucho más complicado incorporarlo 00:12:12
pero cualquier cosa que incorpore va a afectar a lo demás 00:12:14
bueno, pues una de las ventajas de JavaFX 00:12:16
es que están las funciones 00:12:18
más desacopladas, por ejemplo 00:12:20
a la hora de darle aspecto 00:12:22
a una aplicación 00:12:24
en lugar de dárselo como en swing 00:12:25
que teníamos que ir componente por componente 00:12:28
poniéndole el color, set color 00:12:30
set background, set no se que 00:12:32
en el mismo código, lo podemos hacer 00:12:33
mediante una hoja de estilo aparte 00:12:36
pues es otra ventaja 00:12:37
¿Vale? Uno hace una hoja de estilo 00:12:39
Las CSS, que es así que las conocéis muy bien 00:12:41
Se hace su hoja de estilo 00:12:43
Y la incorpora 00:12:45
Y entonces ya su aplicación JavaFX 00:12:47
Incorpora esos estilos 00:12:49
¿Que quiere cambiar el aspecto? 00:12:50
No tiene que irse a la aplicación, cambiar código 00:12:52
Y recompilar, que eso es lo que siempre 00:12:55
Queremos evitar, recompilar aplicaciones 00:12:57
Porque implica redesplegar en servidores 00:12:59
¿Que uno quiere cambiar el aspecto? 00:13:01
Cambia la hoja de estilo 00:13:03
Y la hoja de estilo no hay que recompilarla 00:13:05
Y ya está, ¿vale? 00:13:06
bueno, tus plegarias 00:13:08
se han escuchado 00:13:11
cuando estuve haciendo la calculadora dije 00:13:12
¿por qué no se puede usar CSS 00:13:14
para diseñar esto? 00:13:16
pues alguien en el pasado 00:13:19
se oyó 00:13:20
alguien en el, claro, la gente que se 00:13:21
hace preguntas, es la gente 00:13:24
pues que mueve el mundo, porque gracias a sus 00:13:26
preguntas, algunos intentan 00:13:28
ofrecer 00:13:31
soluciones, bueno pues 00:13:33
entonces, este pequeño main 00:13:34
que nos ha ofrecido el JavaFX 00:13:36
nos incluye esta línea 00:13:38
que es para recuperar una hoja de estilo 00:13:40
e incorporarla. 00:13:42
Entonces, él nos ha metido una primera 00:13:45
aplicación CSS que ahora mismo 00:13:46
está vacía, o sea, una primera hoja de estilo. 00:13:49
Pero si ponemos aquí estilos, 00:13:51
pues cambia los estilos de nuestra aplicación. 00:13:52
Ahora mismo no tiene nada. Vale. Y ya está. 00:13:54
Y lo único que nos ha ofrecido el plugin 00:13:57
es este main que arranca 00:13:58
un escenario 00:14:00
y luego una primera escena. 00:14:01
Y se acabó. Vale, nada más. 00:14:04
Pero claro, estas clases hay que importarlas, nos faltan, nos faltan de las clases correspondientes, ¿vale? Y si hacemos aquí esto de aquí, pues es que no nos ofrece import ni nos ofrece nada, porque los JAR no están agregados a la aplicación, o sea, las clases no están accesibles. 00:14:06
a ver Jesús 00:14:28
cállate ya 00:14:31
que es que estás muy cerca y te oigo todo lo que dices 00:14:33
vale, entonces 00:14:36
tenemos que incorporar 00:14:37
al pad de la aplicación 00:14:40
tenemos que incorporar las clases 00:14:42
que aquí faltan, vale 00:14:44
entonces una forma muy sencilla 00:14:46
es, ya que tenemos los hard directamente 00:14:47
vamos a incorporarlos 00:14:50
los hard, no sé dónde los tenéis 00:14:51
vosotros los habréis descargado y guardado en algún sitio 00:14:54
son los que están en list 00:14:56
y ahí los podéis dejar 00:14:57
vale, los que están en live 00:14:58
bueno, pues entonces ahora 00:15:01
vamos a incorporar 00:15:02
esto es el main que me ha ofrecido aquí 00:15:04
no, javafxproject 00:15:11
bueno, es que vamos a hacer un proyecto de javafx 00:15:16
un proyecto de javafx 00:15:21
bueno, todo lo que quieras 00:15:22
yo he hecho un proyecto de JavaFX 00:15:25
eso es una herramienta para que exploreis 00:15:28
vale, vosotros y solamente 00:15:30
os la damos con la idea de que la conozcáis 00:15:32
igual que nosotros la conocemos 00:15:34
pero la conocemos por encima 00:15:36
vosotros ahora podéis hacer maravillas con ello 00:15:37
vale 00:15:40
bueno, pues entonces, ¿cómo incorporamos 00:15:41
los .jar? pues ya lo hicimos 00:15:44
una vez cuando vimos lo de los paquetes 00:15:46
etcétera, pues en el botón 00:15:48
derecho podéis llegar 00:15:50
a través de construir 00:15:52
el path de la aplicación o a través de propiedades 00:15:54
como os dé la gana 00:15:57
la forma más fácil de llegar era 00:15:58
a través de build path, vamos a configurar 00:16:00
los caminos de mi aplicación 00:16:03
vamos a configurar los caminos 00:16:05
vale, pues mi aplicación 00:16:07
tiene 00:16:09
el camino hacia la 00:16:10
máquina virtual, las clases de la máquina 00:16:13
virtual, claro, por supuesto, menos mal que lo 00:16:15
tiene, porque si no, no podría encontrar 00:16:17
ni la clase string ni nada, claro que lo tiene 00:16:19
y tiene 00:16:21
y tiene el camino hacia esto 00:16:22
pero esto no tiene 00:16:27
incorporado 00:16:29
las clases 00:16:31
habría que decirle donde están 00:16:32
entonces la forma más cómoda 00:16:34
de hacer esto 00:16:37
pincháis module path 00:16:38
vamos a añadir nuestros 00:16:40
jar externos y los seleccionáis 00:16:42
los que están 00:16:45
en live del proyecto 00:16:47
no, porque vamos a trabajar con módulos 00:16:48
si lo pones en módulo de paz 00:16:53
la única diferencia es que tiene que haber un módulo de info 00:16:57
y luego dentro del módulo de info 00:16:59
como vamos a hacer ahora, cada vez que usas 00:17:01
un paquete, indicarlo dentro 00:17:03
pero eso lo vamos a ir haciendo 00:17:06
hazlo en módulo de paz porque en classpath 00:17:07
a mi muchas veces me ha dado problemas 00:17:11
para arrancar el main 00:17:13
hazlo en módulo de paz 00:17:14
¿Vale? No hay más 00:17:17
diferencias que si lo haces en módulo 00:17:18
de paz, entonces él busca siempre el módulo 00:17:20
de info. Y en el 00:17:22
módulo de info tú indicas, como vamos 00:17:24
a indicar ahora, los paquetes 00:17:27
que estás usando. Esencialmente es eso. 00:17:29
Ya lo teníamos que borrar. 00:17:31
No, no, no, no, no. 00:17:33
Nos lo ha ofrecido. Yo por eso no os he dicho que lo borremos en ningún momento. 00:17:34
Vale, pues nada. 00:17:38
Aplicamos 00:17:39
y ha desaparecido todo el rojo. 00:17:39
¿Vale? Porque ya tiene las clases. 00:17:43
Y de hecho en referencia 00:17:45
libraries pues veis que ya están ahí 00:17:46
todos los paquetes con todas las clases 00:17:48
vale 00:17:50
si abrís el módulo info 00:17:52
si abrís el módulo info por curiosidad 00:17:57
el módulo info 00:18:02
que nos ha creado el plugin 00:18:04
como veis el módulo info lo único que te va 00:18:05
incorporando aquí es 00:18:08
los paquetes que vas usando 00:18:09
entonces todos estos paquetes que estamos usando aquí 00:18:11
vale 00:18:14
Están en controls 00:18:18
Están en controles 00:18:20
Entonces 00:18:22
Por eso este tiene un 00:18:23
Requiero estos de aquí 00:18:26
Vale, bueno, hasta aquí estamos 00:18:28
Ahora ya podemos empezar la aplicación 00:18:32
Esto ya si lo arrancamos 00:18:36
Me va a hacer 00:18:37
Una primera ventanita 00:18:39
Pero muy básica 00:18:41
vale, si lo arrancamos 00:18:42
es un escenario con una escena que no tiene nada 00:18:50
pero sutilmente 00:18:53
veis que tiene un aspecto un poquito más 00:18:55
moderno, ¿verdad? sutilmente se le ve 00:18:57
algo menos ochentero, no es menos 00:18:59
vintage esto, se le ve algo 00:19:01
mejor 00:19:03
vale 00:19:03
esto ya es el aspecto 00:19:05
de punto net 00:19:10
es tal cual el aspecto, ahora lo veremos 00:19:11
cuando lleguemos a las cosas. Más bonito. 00:19:13
O sea, esto que es más fácil de usar 00:19:15
y más moderno, 00:19:17
no lo vamos a evaluar. Pero el JFrame sí. 00:19:19
Pues este año 00:19:22
sí, porque no hemos 00:19:23
actualizado la programación. 00:19:25
El año que viene yo creo que la vamos 00:19:27
a actualizar. Pero este año 00:19:29
seguimos con los contenidos del BOE y eran 00:19:31
esos. Pero el año que viene sí que yo creo 00:19:33
que la actualizaremos. 00:19:35
Vale. 00:19:38
Pues venga, 00:19:40
vamos a hacer ahora ya nuestro primer proyecto. 00:19:41
Bueno, de nuevo 00:19:43
A ver si lo has añadido al classpath 00:19:46
En vez de al module path 00:19:53
Al module path 00:19:54
Todo, bueno 00:19:57
Vamos a intentar ver la primera estructura 00:19:58
Y luego ya los que os hagan errores puntuales 00:20:01
Los vamos arreglando 00:20:03
Vale, pues ahora, vamos a hacer ya una aplicación 00:20:04
En la que tenemos que meter un botoncito 00:20:07
Una etiqueta para que cuando yo dé al botón 00:20:09
Pues me salude 00:20:11
lo típico, el primer ejercicio 00:20:12
un evento de un botón 00:20:14
y una realimentación con una etiqueta 00:20:17
vale, pues de nuevo 00:20:19
aquí javafx 00:20:21
lo bonito que tiene es otra vez el desacoplamiento 00:20:22
que es 00:20:25
la vista, la parte de vista 00:20:26
los controles que hay, todo eso 00:20:29
lo vamos a sacar a un archivo 00:20:31
xml 00:20:33
toma ya, entonces estamos desacoplando un montón 00:20:34
los estilos a un css 00:20:36
a ver, xml sabe hacer 00:20:38
todo el mundo. 00:20:42
Bueno, pues 00:20:47
un XML no es nada. 00:20:50
Vale, entonces, el colmo del desacoplamiento. 00:20:54
Un XML, obviamente, 00:20:57
sabéis que 00:20:59
es una 00:21:00
forma de almacenar información 00:21:01
y meta-información. 00:21:04
¿Sabéis lo que es la meta-información? Ese concepto 00:21:06
lo conocéis, ¿no? Que es 00:21:08
la información sobre la información. 00:21:10
Una cosa son los datos y otra cosa es la información sobre estructura de esos datos, cómo se relacionan entre sí, por qué me han llegado de esa manera. 00:21:12
Es decir, no son los datos en sí, sino información sobre esos datos. 00:21:22
Pues entonces, ¿qué pasa? Como los ficheros de eso normalmente estaban en bases de datos, los datos eran los registros y los metadatos o la metainformación, la estructura de las tablas y de las claves. 00:21:28
pero una base de datos pesa un montón 00:21:40
entonces vamos a necesitar toda nuestra vida 00:21:42
una base de datos para guardar datos 00:21:44
con lo bonitos que son los ficheros de texto 00:21:46
no, los ficheros de texto son maravillosos 00:21:48
para guardar datos porque no pesan nada 00:21:49
pues venga, vamos a intentar guardarlos en ficheros de texto 00:21:51
¿qué ocurre? que uno se pone a guardar datos 00:21:54
en ficheros de texto 00:21:56
hola, me llamo Juanito, peso 30 kilos 00:21:57
bla bla bla bla bla 00:22:00
esa información no hay ni Dios que la procese 00:22:01
ni Dios 00:22:04
una base de datos se procesa muy bien 00:22:04
porque está estructurada 00:22:07
una información, un fichero de texto, hola soy Juanito 00:22:08
patatín patatán, no la procesa ni Dios 00:22:11
porque no tiene ningún tipo de estructura 00:22:13
pesa muy poco porque es texto, pero ni Dios 00:22:15
puede procesar eso, vale 00:22:17
pues ahí entra el XML, ya está 00:22:19
vamos a darle una estructura a esta 00:22:21
información 00:22:23
justo, antes del XML 00:22:24
entró el CSV 00:22:27
que es, vamos a darle una estructura a esta información 00:22:29
que es dividiéndole, al menos 00:22:31
dividiéndola en campos, algo es algo 00:22:33
la divido en campos con separadores 00:22:35
y así al menos le facilito el trabajo a la máquina 00:22:37
que ya va buscando los separadores 00:22:40
y ya sabe que cada campo significa una cosa distinta 00:22:42
algo de estructura ya tiene un csv 00:22:46
pero es que mucha más estructura tiene el xml 00:22:48
porque el xml decide una jerarquía 00:22:52
voy a organizar la información 00:22:56
una jerarquía donde hay un nodo raíz 00:22:58
como bien sabéis ese nodo raíz me incluirá un montón de nodos 00:22:59
cada nodo tiene una etiqueta que de alguna manera con su nombre 00:23:03
describe de qué va, si además 00:23:06
ese nodo tiene partes, lo meto 00:23:09
en subnodos, pues ya está 00:23:10
un XML es una forma ligera 00:23:12
ligera de guardar información 00:23:14
mucho más que una base de datos y además 00:23:16
dándole una estructura muy útil 00:23:18
y ahora ya, al tener una estructura 00:23:20
y además darle unas reglas 00:23:23
porque el XML tiene 00:23:25
unas reglas, para que esté bien formado 00:23:26
tiene además la opción de asociarle 00:23:28
un esquema para que tú lo puedas 00:23:30
validar y decir, oye, este XML 00:23:33
responde a este esquema porque mi ordenador 00:23:34
solo sabe procesar lo que tiene este esquema 00:23:37
sí, sí, sí, este XML responde a este esquema 00:23:38
ah, vale, pues entonces mi ordenador sabrá procesarlo 00:23:41
entonces un XML es esa forma 00:23:43
ligera y con 00:23:45
directrices 00:23:46
que facilitan que un ordenador 00:23:48
sepa interpretar esa información 00:23:50
ya está, con lo cual 00:23:53
hacer un XML es poner datos en una estructura 00:23:54
jerárquica y luego ya 00:23:57
pues si yo quiero un esquema 00:23:59
concreto, pues me hago ese esquema 00:24:01
y lo valido, a ver si lo cumple o no 00:24:03
y no hay más que saber de XML 00:24:04
¿Qué más queréis saber de XML? Nada más que eso 00:24:05
Pues ya está. ¿Qué decir? No sabemos de XML 00:24:08
Pues si sabéis eso, sabéis todo lo que hay que saber de XML 00:24:11
Pues ya vamos al examen, ¿no? 00:24:12
Tú sabes hacer esquemas, sabes validar 00:24:15
XML con esquemas, sabes ver 00:24:17
si un XML está bien formado, sabes ver 00:24:18
pues ya está, es que de XML no hay más 00:24:20
Nosotros el año que viene sabremos más cosas 00:24:22
de XML, que es, vamos ahora a procesar 00:24:24
XML entre nuestras aplicaciones 00:24:27
Porque el XML no está solo para que 00:24:28
lo vea un tío, o para que me lo muestre 00:24:31
un navegador o para darle un estilo 00:24:33
no está eso 00:24:35
no está solo para asociarle un estilo 00:24:36
para presentarlo en un navegador 00:24:39
un XML también está para darle información 00:24:40
de entrada a una aplicación 00:24:43
bueno, pues esa es la parte que vemos nosotros el año que viene 00:24:44
también, en algún tema 00:24:47
cómo usar un XML como información de entrada 00:24:48
para una aplicación 00:24:50
vale, a cuento de que venía esto 00:24:51
hoy siempre 00:24:55
me lleváis por donde no 00:24:56
tiene que ser 00:24:59
porque es información muy útil 00:24:59
vale, desde luego si es información 00:25:02
que os pone en contexto 00:25:05
es información que es 00:25:06
muy bueno que tengáis, que es vamos a ver 00:25:08
de qué van los tiros de lo que estoy haciendo, dónde se coloca cada cosa 00:25:10
para que veáis qué más me va interesando 00:25:13
en qué cosas me merece la pena 00:25:15
a lo mejor que profundicen, cuáles no 00:25:16
toda la información que os pone en contexto 00:25:18
realmente es muy interesante 00:25:20
aparte de los 00:25:23
claro, incluso casi más que los contenidos 00:25:24
pero los contenidos tenéis que tenerlos como 00:25:26
entrenamiento, pero luego son variables 00:25:28
obviamente, pero sirven como 00:25:30
entrenamiento para luego aprender 00:25:32
otros contenidos más fácilmente, pero esos 00:25:34
en sí van a perder valor en un año, en dos 00:25:36
en tres, entonces 00:25:38
tienen el valor que tienen efectivamente 00:25:39
todo esto a cuento de que venía 00:25:42
que veo a 00:25:44
a este mirando con una cara de emoción 00:25:45
diciendo que ha puesto ahí 00:25:48
pues nada, he abierto el módulo de info 00:25:50
para que veáis que 00:25:51
me ha creado un módulo de info con cosas que es necesario 00:25:54
que exista porque lo he metido en el módulo de paz 00:25:56
pero no tenemos que meternos en esto 00:25:58
bueno, a todo esto 00:25:59
venía a cuento del desacoplamiento 00:26:01
que JavaFX me separa 00:26:03
el estilo en el CSS 00:26:05
y ya los controles 00:26:07
si yo quiero, si no quiero no 00:26:09
si quiero los meto ahí directamente en código 00:26:11
a lo bestia, pero si quiero 00:26:13
desacoplar los puedo sacar a un XML 00:26:15
y en un XML 00:26:17
pongo todos mis controles 00:26:19
y ahora ya mi aplicación tiene todo muy separado 00:26:21
y ahora mi aplicación 00:26:24
lo único que hará es traer del XML 00:26:25
a través de las librerías que están en el 00:26:28
JAR, claro, leerse eso 00:26:30
que hay, montarlo 00:26:32
y darle el comportamiento que digamos 00:26:34
y ya está. Luego, nuestra primera 00:26:36
tarea ahora es hacer la vista 00:26:38
y hacer el aspecto 00:26:40
el botón, la etiqueta y todo eso 00:26:42
luego ya será el comportamiento. Bueno, pues hacer 00:26:44
esa vista de la aplicación 00:26:46
va a implicar que tengamos que hacer un XML 00:26:47
con esos controles 00:26:50
¡Madre mía! Tendrá que ser una estructura 00:26:51
muy concreta, porque como no siga una 00:26:54
estructura muy concreta 00:26:56
la aplicación no lo va a entender 00:26:57
habrá unas reglas para SXML 00:26:59
tendrá que haber unas reglas, cuál es el nodo RAID 00:27:01
cuáles son los nodos, no podemos aprendernos 00:27:03
lo de memoria, no podemos saber de cabeza 00:27:05
la estructura que tiene que tener 00:27:07
SXML para hacerlo, menos mal 00:27:09
que no hace falta 00:27:11
porque tenemos una aplicación complementaria 00:27:12
para JavaFX 00:27:16
que es el Steam Builder 00:27:17
que es el que te permite crear escenas 00:27:19
con arrastra y pega y luego 00:27:21
él te genera el XML 00:27:23
menos mal, porque si no sería una locura 00:27:25
Pues venga, esa es nuestra siguiente tarea 00:27:27
Descargar 00:27:29
El Steam Builder ese 00:27:31
No, no es un plugin 00:27:33
Es una aplicación aparte 00:27:37
Es una aplicación aparte 00:27:39
Entonces el también es de 00:27:41
Glue-on, claro, y aquí 00:27:46
Pues la descargáis para vuestra plataforma 00:27:48
Si descargáis 00:27:52
El Windows Installer, tú busca Steam Builder 00:27:54
Lo primero que te sale 00:27:56
Pues te descargas el instalador 00:27:57
Para Windows y ya está 00:28:00
¿vale? 00:28:02
lo descargáis 00:28:08
lo instaláis 00:28:09
y detenemos 00:28:12
mientras lo instalamos 00:28:16
bueno, pues una vez arrancadito 00:28:17
dime 00:28:20
¿en la vacía? 00:28:20
en la vacía 00:28:24
empty, vale 00:28:24
entonces lo primero es un contenedor para poder apoyar 00:28:27
controles encima, pues aquí 00:28:30
yo con la resolución de pantalla que tengo 00:28:32
me es todo muy complicado 00:28:34
lo veréis mejor, hay un montón de contenedores 00:28:36
pero 00:28:38
yo voy a poner el panel de ancla 00:28:38
este, vale 00:28:42
pues cogéis el panel 00:28:43
un panel para anclarlo 00:28:45
todo, a mí eso de ancla me ha gustado 00:28:48
y ya está 00:28:49
entonces 00:28:52
vale 00:28:54
voy a ponerlo para que al menos 00:28:56
este es mi panel 00:28:59
veis, me aparece aquí en la jerarquía 00:29:01
Aquí me aparece en la jerarquía ya un elemento, el panel y aquí a la derecha pues tengo la ventanita de properties pues para darle aspecto y ponerle cositas, si quiero. 00:29:06
y luego 00:29:22
tengo una ventana 00:29:30
code donde properties 00:29:33
tengo también la de 00:29:35
gestor de ubicación para jugar aquí 00:29:37
con los padding del panel 00:29:39
con cositas que podéis jugar para ver los componentes 00:29:41
donde van a caer 00:29:43
donde podéis jugar con eso 00:29:44
y tengo una ventanita de código 00:29:46
que esta es importante 00:29:49
porque como hemos dicho 00:29:51
todo esto que vamos a hacer 00:29:53
aquí se va a recoger 00:29:55
un XML, no se va a recoger en código 00:29:57
se va a recoger un XML 00:29:59
pero el XML tiene que 00:30:00
conectarse con el código de alguna manera 00:30:03
pues se va a conectar con 00:30:05
el código a través de los nombres 00:30:07
que reciba en el XML 00:30:09
cada elemento que yo ponga aquí 00:30:11
entonces 00:30:13
si yo tengo que hacer referencia 00:30:15
en el código 00:30:17
al elemento, si tengo que hacer referencia 00:30:19
en el código al elemento, voy a hacer referencia 00:30:21
a ese elemento a través del nombre 00:30:23
que yo ponga aquí 00:30:25
en esta pestañita que pone 00:30:26
fxid 00:30:29
a través del nombre que pongamos ahí 00:30:30
mi programa java 00:30:33
va a poder hacer referencia 00:30:35
a ese componente del fxml 00:30:37
pero a lo mejor no tiene por qué hacerla 00:30:38
no tiene por qué hacerla 00:30:41
si no tiene que hacer nada con él 00:30:42
si no tiene que desde el controlador 00:30:44
que es el que gestiona el evento 00:30:47
cambiarle algo, no tiene que hacer referencia 00:30:48
con lo cual este panel nosotros podemos por ahora 00:30:50
dejar eso vacío, no hace falta que le pongamos nada 00:30:53
porque si mi controlador 00:30:55
mi código, porque mi aplicación 00:30:58
JavaFX ahora mismo 00:30:59
el código va a ser casi exclusivamente 00:31:01
la parte de respuesta 00:31:03
a los eventos, la parte de respuesta 00:31:05
porque la vista ya está en el XML 00:31:07
y el estilo ya está en el CSS 00:31:09
entonces lo que va a estar 00:31:11
realmente en código va a ser el evento 00:31:13
la respuesta al evento 00:31:15
pues si como respuesta al evento 00:31:17
yo no tengo que hacer nada con el panel 00:31:19
a lo mejor no tengo ni que darle nombre 00:31:21
no tengo ni que darle nombre 00:31:23
en nuestra aplicación que vamos a hacer 00:31:25
vamos a tener un botón y una etiqueta 00:31:27
a la etiqueta sí que vamos a hacer referencia desde el evento 00:31:29
porque hay que ponerle el mensaje saludar 00:31:31
entonces a la etiqueta vamos a tener que ponerle un nombrecito 00:31:33
para que el código pueda acceder a ella 00:31:35
pero yo el panel por ahora lo dejo sin nombre y ya está 00:31:37
y luego como además veis en código 00:31:39
si este panel 00:31:42
va a tener respuesta a evento 00:31:46
se le pondría aquí 00:31:48
el nombre del método 00:31:49
el nombre del método 00:31:51
pero este panel no va a recibir eventos 00:31:53
el único que va a recibir eventos es el botón 00:31:56
entonces yo esto lo dejo todo vacío 00:31:58
¿vale? bueno pues ya está 00:31:59
el panel ya está, vamos a poner el botoncito 00:32:02
el pues 00:32:04
cogemos un botón o lo que os dé la gana 00:32:06
a vosotros 00:32:08
lo arrastramos 00:32:09
y me aparece aquí en la jerarquía 00:32:11
efectivamente debajo del panel este 00:32:16
y aquí en las propiedades 00:32:18
del botón pues le cambio lo que yo 00:32:22
quiera 00:32:24
Pablo va a poder hacer 00:32:24
aquí auténticas maravillas 00:32:33
va a poder hacer 00:32:35
va a hacer lo que le dé la gana y encima 00:32:36
cada vez que le des el botón que te salga 00:32:39
ahí y que se te ponga en verde 00:32:41
va a hacer lo que quiera 00:32:42
y ahora vamos a poner la etiqueta 00:32:45
la etiqueta es otro control 00:32:51
Pues díselo 00:32:53
A Deep Blue 00:32:58
A ver, un ajedrez que juegue bien 00:33:00
O un ajedrez que juegue mal 00:33:04
A ver, en algún momento 00:33:05
Encontraré una etiqueta por aquí 00:33:10
Label 00:33:11
Vale 00:33:13
Mi etiqueta 00:33:14
Pues mi etiqueta está en la jerarquía 00:33:20
Dentro del panel 00:33:24
Debía quitar texto 00:33:25
porque ahora mismo está vacía, solo se va a poder 00:33:27
texto cuando salude 00:33:30
mi etiqueta 00:33:33
yo ya sabiendo el funcionamiento de la aplicación ya preveo 00:33:35
que el controlador 00:33:38
el que responde al evento, el listener 00:33:40
el que en 00:33:41
Swin se llama listener, que aquí lo llaman en el controlador 00:33:43
pues el listener 00:33:46
barra controlador va a tener que hacer referencia a esta etiqueta 00:33:47
con lo cual un nombre va a necesitar 00:33:50
pues vamos a irnos a su pestañita 00:33:52
de código y le vamos 00:33:53
a decir, oye, tú te vas a llamar 00:33:56
pues como te quieras 00:33:57
llamar, saludo. 00:33:59
Te vas a 00:34:03
llamar, saludo. Ya está. 00:34:04
Bueno, vamos a guardar 00:34:07
porque aquí no estamos guardando nada. 00:34:09
Venga, por ahora la voy a guardar en el escritorio por comodidad. 00:34:11
Guardarla donde os dé la gana. 00:34:14
Vista, 00:34:17
saludar. Y como veis, la 00:34:18
guarda con extensión fxml. 00:34:19
Ala, 00:34:25
ya la tenemos guardada. 00:34:25
Vale, nuestra vista ya está. Ahora, va a haber alguno de estos controles o elementos que hemos puesto aquí, va a necesitar respuesta a eventos, el botón. Vale, pues nos vamos al botón otra vez. Nos vamos al botón y desplegamos código. 00:34:26
y vamos a ver 00:34:47
a ver, ¿a qué evento queremos que responda? 00:34:49
al por defecto que es el 00:34:51
onAction, el onAction sería el 00:34:53
evento por defecto, como el actionListener de swing 00:34:55
claro, o al 00:34:57
cuando yo lo arrastro al drag 00:34:59
drop, al drag no se que, al drag que entrena 00:35:01
al mouse no se que, a todas esas morrallas que hay por ahí 00:35:03
abajo, bueno 00:35:05
vamos a poner al por defecto 00:35:07
vale, pues yo aquí me limito a poner 00:35:08
el nombre del método 00:35:11
que va 00:35:13
allá, que voy a programar 00:35:14
en mi aplicación. Porque en el 00:35:17
FXML tiene que figurar el nombre de ese 00:35:18
método. Vale. Pues 00:35:21
pulsa botón o 00:35:23
como lo queráis llamar. 00:35:25
Ala. Tenemos 00:35:27
el nombre del método. Pulsa botón. 00:35:29
Guardado. 00:35:33
Y ahora, 00:35:37
vale, esto va a tener 00:35:42
la vista ya está. 00:35:44
La vista ya está. Y si abrimos por curiosidad 00:35:46
el FXML que me ha generado, 00:35:48
que está aquí 00:35:50
lo abrís con el blog de notas 00:35:54
o con cualquier editor de xml que os sea 00:35:56
cómodo 00:35:58
o con el navegador 00:35:59
con lo que queráis que abra xml 00:36:01
vale pues este es el xml 00:36:03
vale 00:36:07
entonces como veis pues 00:36:08
tenemos 00:36:11
el nodo raíz que es el panel 00:36:13
ese es el nodo raíz 00:36:16
con sus propiedades 00:36:17
tiene un nodo 00:36:19
que es el hijos 00:36:22
¿cuántos hijos tiene el nodo raíz? 00:36:23
pues tiene un nodo hijo 00:36:26
que tiene aquí 00:36:27
como texto saludame 00:36:29
on action 00:36:31
esto suena a javascript ¿verdad? 00:36:33
cuando 00:36:36
bueno 00:36:37
pues cuando se accione este botón 00:36:39
se llamará este método 00:36:42
pulsa botón 00:36:43
¿vale? luego tenemos otro hijo que es la etiqueta 00:36:45
el nombre de la etiqueta saludo 00:36:48
a botón, como no le hemos puesto nombre 00:36:50
pues no está figurando el atributo 00:36:52
fx saludo 00:36:54
y tampoco tiene un on action, label no tiene un on action 00:36:55
porque label no responde a evento 00:36:58
pues ya está, me ha generado este xml 00:37:00
hombre, sí, lo podríamos haber hecho a mano, pero esto es un rollo 00:37:02
de hacerlo a mano, no 00:37:04
cuando uno tenga una jerarquía 00:37:05
con mil cosas, este xml es enorme 00:37:08
ya, pero eso no será un evento 00:37:09
se lo hagas tú desde código 00:37:14
por eso le has puesto nombre, por eso este tiene 00:37:15
nombre, porque ahí para hacer el set 00:37:17
necesitas el nombre, vale 00:37:19
vale, pues nuestro fxml ya está 00:37:21
vale 00:37:23
entonces, ahora 00:37:26
la aplicación esta 00:37:27
lo tiene que encontrar 00:37:29
lo tiene que encontrar 00:37:30
entonces, lo más cómodo es que 00:37:32
la metamos directamente 00:37:35
en una ruta de la aplicación, que la metamos aquí 00:37:37
el fxml 00:37:39
para que lo encuentre, lo metamos dentro del proyecto 00:37:41
que no tengamos, vale, pues bueno, copiad el fxml, copiadlo, que no tiene por qué estar dentro, puede estar fuera, porque luego desde el main vamos a hacer referencias fxml, pero por comodidad, si está dentro, pues no lo tenemos ahí perdido, vale, pues ponedlo donde os dé la gana, venga, yo lo voy a poner dentro del propio paquete, bueno, de, sí, venga, del mismo paquete, paste, vale, 00:37:43
Estoy tonta. 00:38:17
Aquí tengo mi vista saludar 00:38:20
FXML. Bueno, pues 00:38:27
ahora mi main cambia. 00:38:29
Porque ahora en mi main yo tengo que 00:38:31
pasar de este root y decir, no, 00:38:33
tú ahora ya no vas a usar este 00:38:35
raíz. Este raíz 00:38:37
que me habías puesto por defecto no vas a usar. 00:38:39
Ahora vas a usar el que está en la 00:38:41
vista. Entonces, 00:38:43
ahora ya tenemos que cambiar esta línea 00:38:45
por otra línea 00:38:47
en la cual le decimos, oye 00:38:48
que tu raíz, la raíz 00:38:51
de tu escenario, la raíz de tu 00:38:53
escenario está en el fxml 00:38:55
y eso lo hacemos con una sentencia 00:38:57
que vamos a copiar y pegar 00:38:59
o voy a copiar yo y pegar 00:39:01
y vosotros la copiáis 00:39:03
eso lo vamos a hacer con esta sentencia 00:39:04
¿vale? 00:39:07
con esta 00:39:11
aquí 00:39:12
vale 00:39:24
vale, a ver 00:39:28
como ahora ya 00:39:32
nuestro, la raíz 00:39:34
de nuestro escenario, no es ese 00:39:37
border panel root que había puesto por defecto 00:39:39
el plugin, ya no es ese, sino 00:39:41
es lo que figura en el xml 00:39:43
tenéis que cambiar 00:39:44
eso por esta línea 00:39:46
que os he puesto aquí 00:39:49
por esta 00:39:51
Claro, la ruta que 00:39:52
Se llama 00:39:58
En mi caso se llama 00:40:00
Vista saludar 00:40:03
Fxml 00:40:04
Pues 00:40:06
Vista saludar 00:40:08
Vale, entonces 00:40:12
Vale, o sea el root 00:40:16
Ahora ya no es ese border pane por defecto 00:40:19
Que él había hecho 00:40:21
si no es el root 00:40:21
ahora es un objeto padre que está 00:40:24
perfectamente ya especificado en el 00:40:25
fxml, entonces lo que le decimos es 00:40:28
la raíz de tu escenario 00:40:30
sácala del 00:40:32
fxml y ya está, lo único que 00:40:33
le tenemos que decir 00:40:35
es decir 00:40:36
cárgame 00:40:39
el root desde este fichero 00:40:40
vista saludar, cárgamelo mediante 00:40:43
el método estático load 00:40:46
de la clase fxml loader 00:40:47
¿lo habéis copiado ya? 00:40:49
He puesto el nombre del fichero 00:40:53
Vosotros ponéis el vuestro y ya está 00:41:02
Entonces, él con el getResource 00:41:04
Localiza este recurso 00:41:10
Que es un archivo 00:41:12
Los archivos son recursos de la aplicación 00:41:13
Pues localiza el recurso 00:41:15
Extrae la clase 00:41:17
En la que se puede mapear 00:41:20
Ese recurso 00:41:22
Que se podrá mapear 00:41:23
En una clase root 00:41:26
Que es la que nos interesa 00:41:27
y esa clase root ya se convierte en la raíz 00:41:28
de mi escenario 00:41:31
pero efectivamente 00:41:33
la clase fxml la tenemos que importar 00:41:41
no, no, no 00:41:43
no empezamos, está todo bien pensado 00:41:49
como no estamos trabajando 00:41:51
como estamos trabajando con módulos 00:41:53
con el módulo info 00:41:55
pues él no me ofrece directamente import 00:41:56
porque hay que pasar primero por el módulo info 00:41:59
el módulo info es una especie 00:42:01
de gestor de paquetes 00:42:03
entonces cuando yo uso un módulo info 00:42:06
no hago import sin más, sino que 00:42:07
dentro del módulo info tengo que poner 00:42:09
indicaciones también sobre los paquetes 00:42:11
que voy a importar 00:42:13
pero no tengo que saber de eso, ni tengo que 00:42:15
controlarlo, porque cuando yo uso 00:42:17
el módulo 00:42:19
info, él no me va a ofrecer 00:42:21
el import, pero si miráis hacia abajo, me ofrece 00:42:23
él, oye, añade 00:42:25
un requires al módulo info 00:42:27
pues ese es el que nos 00:42:29
interesa, ¿vale? entonces cuando 00:42:31
no usamos módulo info 00:42:33
ni el gestor de módulos y paquetes 00:42:35
nos ofrecerá el import, pues import 00:42:37
cuando usamos module info 00:42:39
como intermediario del gestor de paquetes 00:42:42
que no tenemos que saber 00:42:44
de esto para nada, que solo 00:42:46
pues me ofrece, oye, ¿quieres añadirlo al 00:42:47
module info como requerimiento de tu 00:42:50
aplicación? Sí, pues le hacéis 00:42:51
un requires y se va el error 00:42:54
y si entráis al 00:42:56
module info, efectivamente os ha 00:43:00
añadido este, oye que vuestro 00:43:02
proyecto requiere fxml 00:43:04
vale 00:43:06
Añadir requires 00:43:07
Y ya está 00:43:10
Y ahora ya lo importa el solito y todo 00:43:11
Lo importa el solo 00:43:14
Ahora ya se ha quitado el error 00:43:16
¿Vale? 00:43:18
Entonces ahora mismo 00:43:23
Esto no tiene comportamiento 00:43:24
¿Vale? 00:43:25
Y se queja 00:43:37
Me dice uy uy uy 00:43:39
¿Qué aplicación de basura es esta? 00:43:40
Si no tienes un controlador 00:43:43
JavaFX está pensado para que le incorpores 00:43:44
un controlador, que es el que te manda 00:43:47
y te dice lo que tienes que hacer 00:43:48
entonces en Swim podríamos arrancar 00:43:50
la vista sin más, pero aquí no 00:43:52
aquí necesito tener 00:43:54
si quiero arrancar la aplicación tiene que tener su controlador 00:43:56
para hacer una evaluación de la 00:43:59
vista, pues para eso ya tenemos el Steam Builder 00:44:01
que vale para eso, que tiene mi preview 00:44:02
¿verdad? este es mi preview 00:44:04
yo en el Steam Builder 00:44:06
tengo ya aquí un preview 00:44:09
que 00:44:10
me dice, a ver, ¿me gusta cómo me queda? 00:44:12
Sí, sí, qué bonito. Pues aquí ya 00:44:14
gestiono el tema de las vistas. 00:44:16
¿Vale? Vale. 00:44:18
Pero en la aplicación, si quiero arrancar la aplicación, 00:44:22
el pack completo de la aplicación, tengo que 00:44:25
hacer un controlador. Bueno, pues 00:44:26
vamos a hacer un controlador. Un controlador es 00:44:28
una clase que tiene 00:44:30
los métodos con los que 00:44:32
se va a responder a los eventos. 00:44:34
Ahora mismo nosotros solo tiene que tener uno, el pulsa 00:44:36
botón ese que hemos puesto. Ya está. 00:44:38
Pues venga, vamos a hacer un controlador. 00:44:41
pues nos ponemos aquí en app saludar 00:44:42
y hacemos el controlador 00:44:44
y el controlador tiene dentro todos los métodos 00:44:45
no es como antes que hacíamos 00:44:47
un listener para cada 00:44:50
elemento o podíamos hacer un listener y si hacíamos 00:44:51
uno solo pues teníamos que distinguirlo dentro 00:44:54
aquí es mucho más sencillo 00:44:56
y Pablo está disfrutando 00:44:57
mucho y está teniendo muchos 00:45:00
extertores 00:45:02
de placer 00:45:04
vale 00:45:04
por eso claro 00:45:05
bueno 00:45:08
He sido rápida, ¿verdad? 00:45:10
Sí 00:45:19
Está muy rápida 00:45:19
Vale, vamos a hacer el controller 00:45:23
Pablo ya no va a volver 00:45:25
al swing en toda su vida 00:45:32
Vamos a hacernos una clase 00:45:33
Controller 00:45:37
vale 00:45:41
pues la clase controller 00:45:46
tiene que tener 00:45:50
a ver 00:45:52
vale, la clase controller 00:45:53
esta de aquí que yo he puesto 00:45:59
es la que tiene que tener 00:46:01
los métodos con los que yo voy a responder 00:46:03
vale, los métodos con los que yo voy a responder 00:46:06
pues venga 00:46:08
teníamos un método 00:46:10
void 00:46:11
pulsa botón 00:46:12
vale 00:46:17
no se me olvida nada verdad 00:46:19
no, tengo mi método 00:46:21
pulsa botón 00:46:25
este de aquí 00:46:26
este método en principio que va a hacer 00:46:28
va a poner en la etiqueta 00:46:33
un texto, claro 00:46:35
la etiqueta como se llama 00:46:37
el nombre se lo he puesto en el fxml 00:46:39
entonces yo claro 00:46:41
yo la puedo declarar aquí 00:46:43
que es lo que haré, tengo un objeto etiqueta 00:46:45
imaginaos 00:46:47
que hago esto 00:46:52
claro 00:46:53
tengo un objeto etiqueta 00:46:55
yo me hago el import de label 00:46:57
sí, sí, sí, del paquete 00:46:59
de controles, y ahora yo 00:47:01
me hago etiqueta 00:47:03
punto set 00:47:06
text 00:47:07
hola 00:47:09
pero claro, aquí el tema es 00:47:11
que este controlador dirá 00:47:13
pero a ver, que yo me tengo que ir a la vista 00:47:15
y la vista 00:47:17
de todas las etiquetas 00:47:19
que tienes en la vista 00:47:22
fxml, ¿a cuál de ellas te estás 00:47:23
refiriendo? Vale, pues 00:47:25
entonces, tengo que poner aquí 00:47:27
el mismo nombre que puse 00:47:29
aquí en el 00:47:31
en el label 00:47:33
o lo que es lo mismo 00:47:35
tengo que poner, si abrimos el fxml 00:47:37
que está 00:47:40
aquí 00:47:41
si abrimos el fxml 00:47:42
a la etiqueta, ¿cómo la llamamos? 00:47:45
la hemos llamado saludo, pues tenemos 00:47:47
que llamarla saludo 00:47:49
¿vale? para que la identifique 00:47:50
como la misma 00:47:53
claro 00:47:53
¿qué lío me estoy haciendo? 00:47:55
este no, ese es este 00:47:58
tengo que llamarla saludo, eso para empezar 00:47:59
y luego además 00:48:01
tengo que decirle al controlador 00:48:03
que este no es un objeto 00:48:05
de aquí, que yo estoy instanciando 00:48:07
sin más porque me da la gana, porque podría ser 00:48:09
yo podría declarar aquí números enteros, lo que quisiera 00:48:11
porque lo necesito, sino tengo que decirle 00:48:13
oye, esta etiqueta saludo 00:48:15
búscala en el XML 00:48:17
porque pertenece a la vista del XML 00:48:19
porque yo podría crear aquí objetos 00:48:21
si me dan la gana, ¿por qué no? 00:48:23
podría crearlos, pero tengo que decirle 00:48:24
que este no es uno que yo he creado aquí 00:48:26
porque me dé la gana para que haga cosas con él 00:48:28
porque esto es perfectamente válido 00:48:30
y esto funcionaría 00:48:32
y el controlador cuando doy a pulse botón 00:48:34
pone saludo a esta etiqueta 00:48:37
pero es que esta etiqueta no tiene que ser 00:48:39
esta local que yo he creado aquí 00:48:41
esta tiene que ser la que está en el XML 00:48:42
entonces tengo que avisarle, ojo 00:48:44
que esta es la del XML 00:48:46
Pues aviso con una etiqueta, con una anotación, perdón, que es esta. 00:48:48
La estoy poniendo bien, ¿verdad? 00:48:54
Sí. 00:48:56
Aviso con una cosa que se llama anotación. 00:48:57
¿Recordáis cuando el override de los métodos que yo decía? 00:49:02
Esto es una información que avisa de cosas a la máquina virtual cuando ejecuta el código. 00:49:05
Pues aquí avisa de que esta etiqueta, oye, vete a buscarla a la vista para saber cuál es, 00:49:11
a la hora de ponerle el texto y todo eso. 00:49:16
No se lo pongas a una local tuya, 00:49:18
pónselo a la que está ahí. 00:49:20
Vale, entonces esto, pues habrá que importarlo, 00:49:21
de Java. 00:49:25
Aquí ya sí que nos ofrece el import, 00:49:25
porque ya hemos puesto en el módulo info 00:49:27
el require se de Java FXXNL. 00:49:28
Entonces ya te ofrece import sin problema. 00:49:31
No, esto una vez entendida la estructura básica, 00:49:34
ya es todo el rato lo mismo. 00:49:37
Tú añades ya todo lo que quieras en la vista 00:49:39
y se acabó y haces los controladores y nada más. 00:49:41
Vale, pues ya tenemos un controlador 00:49:43
Que al método pulsa botón 00:49:47
Responde poniendo en la etiqueta esto 00:49:48
¿Esto funcionaría ya? 00:49:50
No, todavía no 00:49:54
Nos falta un paso, vamos a comprobar 00:49:54
Que mi main todavía no funciona 00:49:56
Ay, que son las 16 00:49:59
Vale, sí, sí, sí 00:50:04
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:
15
Fecha:
21 de marzo de 2025 - 10:56
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
50′ 08″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
218.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid