Saltar navegación

20260407 JavaFX_intro - 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 18 de abril de 2026 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues ni pizarra ni nada 00:00:00
pero luego es un pollo 00:00:02
bueno, pues 00:00:03
nosotros hasta el año pasado 00:00:05
dábamos 00:00:08
swing 00:00:10
¿vale? 00:00:13
swing 00:00:19
a ver, las interfaces gráficas en Java 00:00:19
tradicionalmente 00:00:28
se han hecho usando 00:00:30
el paquete swing 00:00:32
¿vale? 00:00:33
que en realidad 00:00:36
se sigue usando 00:00:38
en realidad se sigue usando 00:00:39
porque tú puedes hacer cualquier cosa en Swing 00:00:41
¿vale? y hay 00:00:43
alumnos que hasta no hace mucho 00:00:45
incluso ahora supongo 00:00:47
pues parte de lo que tenían que hacer en la empresa 00:00:49
pues era ampliar 00:00:51
modificar, hacer una aplicación que estaba 00:00:53
hecha en Swing ¿vale? 00:00:55
es un paquete que en realidad pues sigue 00:00:57
estando ahí, son muchos paquetes 00:00:59
¿vale? 00:01:01
entonces, ¿en qué se basa la construcción? 00:01:03
a ver 00:01:06
si hay ese ruido de fondo todo el rato es imposible 00:01:07
hablar sin perder el hilo 00:01:09
al final se dicen tonterías 00:01:11
¿vale? entonces 00:01:13
¿en qué se basa la construcción 00:01:15
de interfaces gráficas en swing? 00:01:17
bueno, pues tenemos unas librerías 00:01:20
estas librerías, ya sabéis que son 00:01:21
en realidad 00:01:25
ficheros.jar con un montón de 00:01:26
clases dentro 00:01:29
y estas librerías 00:01:30
¿qué nos ofrecen? 00:01:34
pues nos ofrecen afortunadamente cosas que ya están hechas 00:01:35
para que yo las instancie en mi aplicación 00:01:38
y las deje pegaditas 00:01:43
por ejemplo, ¿qué me ofrece? 00:01:44
¿cuál es la clase básica de Swing? 00:01:47
pues la clase JFrame 00:01:50
¿qué es el JFrame? 00:01:52
el JFrame es esta ventanita de toda la vida 00:01:55
la que tiene los estos de minimizar, de no sé qué y de cerrar 00:01:58
esto es un JFrame 00:02:02
esto ya está hecho 00:02:05
claro, en la clase JFrame 00:02:07
no tenemos que hacerlo, si tuviéramos que 00:02:09
programar una interfaz gráfica desde cero sería una locura 00:02:11
¿vale? 00:02:13
pero podemos hacerlo todo 00:02:15
claro 00:02:17
pero ya hay un montonazo de clases hechas 00:02:17
en los paquetes de swing 00:02:21
pues por ejemplo, entre ellos 00:02:22
la clase JFrame 00:02:24
este es el marco básico 00:02:26
la raíz básica, el punto de partida 00:02:28
básico de una aplicación 00:02:31
hecha con swing 00:02:33
entonces nosotros que hacemos 00:02:34
nosotros que hacemos con swing 00:02:36
pues hacemos nuestra propia 00:02:39
clase 00:02:41
que herede de jframe 00:02:42
entonces al heredar de jframe 00:02:44
pues nuestra aplicación, la que sea 00:02:49
al heredar de jframe 00:02:51
ya nuestra aplicación ya tiene 00:02:53
esto, que es el 00:02:55
marco de partida, ya tiene esto 00:02:57
y a nosotros que hacemos 00:02:59
Le añadimos a esto que ha heredado de JFrame 00:03:00
Le añadimos ya lo que queramos 00:03:04
Pues un panel con botones 00:03:06
Otro panel por aquí con una de esta 00:03:08
Una no sé qué de texto para no sé cuántos 00:03:12
Un desplegable, un menú 00:03:15
Le añadimos lo que nos dé la gana 00:03:17
Y esto que le añadimos 00:03:19
Afortunadamente también está hecho 00:03:21
¿Esto es un botón? 00:03:23
Pues sí, yo tengo dentro de este paquete mío Swing 00:03:25
tengo mi clase 00:03:28
JButton que es ya un botoncito 00:03:32
entero ya hecho 00:03:34
lo único que tenemos que hacer es instanciarlo 00:03:35
y ponerlo 00:03:38
como propiedad dentro de mi app 00:03:40
es decir, mi aplicación 00:03:43
amplía, extiende 00:03:46
hereda de JFrame, la amplía 00:03:48
poniéndole cosas 00:03:50
que la caracterizan 00:03:52
¿y qué es lo que caracteriza una clase? 00:03:53
sus propiedades, pues pueden ser 00:03:56
estos componentes que yo meto 00:03:58
¿vale? eso esencialmente 00:04:00
es como se construye una aplicación en Swing 00:04:02
heredamos de un JFrame 00:04:04
y le metemos 00:04:06
como propiedades ya que lo caracterizan 00:04:08
a él de forma ya propia 00:04:10
le metemos como 00:04:12
propiedades los componentes que a mí me den la gana 00:04:14
eso en resumen 00:04:16
esos componentes son clases que ya están 00:04:17
hechas afortunadamente, no podemos construir 00:04:20
un botón desde cero, un área de texto 00:04:22
desde cero, ¿vale? no podemos 00:04:24
en el momento 00:04:26
luego ya, esto luego tiene 00:04:28
pues lógicamente matices 00:04:30
aparte de añadir el botón 00:04:31
por ejemplo como propiedad 00:04:34
de mi clase aplicación 00:04:36
como propiedad de mi clase aplicación 00:04:38
que lo caracteriza de forma única 00:04:40
pues luego ya tendré que ir a los métodos 00:04:41
de esta clase botón para decidir 00:04:44
donde se coloca dentro del frame 00:04:46
luego ahí hay cosas de aprender a utilizar 00:04:48
los métodos sin más 00:04:50
para colocar las cosas 00:04:51
entonces con eso uno construye 00:04:53
su interfaz gráfica 00:04:57
pero claro, aquí ya sí que aparece algo 00:04:59
que ya sí que es 00:05:02
completamente distinto 00:05:04
a todo lo que hemos visto hasta ahora 00:05:05
que ya sí que es novedoso 00:05:07
y es que aquí hemos construido 00:05:09
nuestra interfaz gráfica programando 00:05:11
como sabemos hacer, haciendo nuestra clase 00:05:13
heredando, poniéndole 00:05:16
propiedades que en este caso 00:05:17
serán componentes que lo particularizan 00:05:19
¿vale? cosas que sabemos 00:05:22
hacer 00:05:24
cambiar las características 00:05:24
de estos objetos 00:05:28
que a su vez tienen sus propias propiedades 00:05:30
como color, todo eso ya lo sabemos hacer 00:05:32
¿vale? pero ¿qué conseguimos 00:05:34
con eso? pues plantar ahí 00:05:36
nuestra ventanita con un montón 00:05:38
de cosas 00:05:40
y ya está, y así nos hemos quedado, eso no vale para nada 00:05:41
lógicamente, una ventana y un montón de cosas 00:05:44
¿dónde está ahí la comunicación 00:05:46
con el usuario? 00:05:48
pues la comunicación con el usuario está 00:05:50
que ahora mi aplicación 00:05:51
arranca, yo la arranco 00:05:54
arrancar la aplicación implica 00:05:56
que todo esto se construye 00:05:58
y se queda ahí construido 00:05:59
pero se queda ahí parado 00:06:00
y ahora ya la aplicación está como ahí parada 00:06:03
está como 00:06:06
no es una aplicación que yo la arranco 00:06:07
se construye esto y se termina 00:06:09
yo la arranco y se queda ahí 00:06:10
mi hilo de ejecución 00:06:14
se queda ahí parado 00:06:15
esperando una cosa que se llama 00:06:16
eventos 00:06:20
y los eventos 00:06:21
es lo que el usuario hace desde fuera 00:06:25
de forma completamente asíncrona cuando le dé la gana 00:06:28
un evento es hacer clic en este botón con el ratón 00:06:31
por ejemplo, otro evento puede ser 00:06:34
escribir en esta área de texto, eventos hay un montón 00:06:37
otro evento puede ser redimensionar 00:06:40
un panel que tengo yo aquí, todos esos son eventos 00:06:43
que vienen de forma asíncrona y 00:06:46
hasta ahora no hemos hecho nada parecido a esto 00:06:50
lo único que hemos hecho parecido a esto es 00:06:53
la sentencia real 00:06:56
de la consola, la única 00:06:57
¿qué hacía la sentencia real? 00:06:59
el next in 00:07:02
perdón, por ejemplo 00:07:03
o el next line, o sea las sentencias del escáner 00:07:05
con las que leíamos del teclado 00:07:08
¿qué hacía? pues 00:07:09
el hilo de ejecución 00:07:12
se quedaba ahí parado 00:07:15
ahí parado 00:07:16
a la espera de que 00:07:17
alguien escribiera algo 00:07:20
en el teclado, y ese era el único evento 00:07:22
posible 00:07:24
escribir algo en el teclado 00:07:25
ese era el único evento posible 00:07:27
entonces cuando eso ocurría 00:07:29
el hilo ya despertaba 00:07:31
cogía lo que había en el teclado y hacía cosas 00:07:33
eso era lo más parecido a esto que hemos hecho 00:07:35
aquí lo que pasa es que hay un montón 00:07:37
de eventos posibles 00:07:39
pues 00:07:40
hacer clic en un botón, escribir un área de texto 00:07:42
hacer focus 00:07:45
en un panel en lugar de en otro 00:07:47
aquí hay un montón de eventos distintos 00:07:49
no hay solo uno 00:07:50
y cada evento 00:07:52
distinto queremos una respuesta 00:07:54
diferente, hasta ahora 00:07:57
nuestro único evento era 00:07:59
escribir en el teclado y la 00:08:00
respuesta era única, que es 00:08:02
coger lo que habíamos escrito 00:08:04
y pasarlo a una variable, ya está 00:08:06
y luego ya nosotros con eso en la variable 00:08:08
hacemos lo que correspondiera 00:08:11
pero aquí tendremos 00:08:13
que hacer 00:08:15
una cosa que es la gestión 00:08:15
de los eventos 00:08:19
y la gestión de los eventos implica 00:08:21
decidir qué eventos 00:08:29
nos importan de la aplicación, pero a lo mejor 00:08:31
una aplicación, el único evento que nos importa es hacer clic 00:08:33
en el botón, vale 00:08:35
qué eventos nos importan de la aplicación 00:08:37
pueden ser varios, uno 00:08:39
qué código de respuesta 00:08:41
vamos a dar a esos eventos, pues todo eso 00:08:43
implica programar bastante 00:08:45
y hasta ahora de todo eso 00:08:47
no hemos tenido que hacer nada 00:08:49
luego, construir una interfaz 00:08:50
gráfica en swing 00:08:54
y también en lo que vamos a ver 00:08:55
en realidad tiene como dos partes 00:08:57
por decirlo así, psicológicamente 00:08:59
tiene dos momentos 00:09:02
el momento de 00:09:03
decidir el diseño de la interfaz 00:09:05
voy a necesitar estos componentes, estos patins 00:09:07
decidirlo, diseñarlo y hacer 00:09:09
toda la parte de código para construirla 00:09:12
el extend, el 00:09:14
ir pegando, bla bla bla 00:09:15
y luego ya, después de 00:09:17
esa primera parte, tengo psicológicamente 00:09:19
la segunda parte, que es 00:09:21
ahora voy a ver cómo he gestionado los eventos 00:09:23
qué componentes son los que pueden recibir 00:09:25
evento, qué código, con qué 00:09:28
código quiero yo responder a esos eventos 00:09:30
etcétera, tendrás esas dos 00:09:32
partes, vale 00:09:34
bueno, pues 00:09:35
nosotros hasta el año pasado esto lo veíamos con 00:09:38
Swing, que es la herramienta de Java de toda la vida 00:09:42
y este año 00:09:44
lo vamos a ver con 00:09:45
esto, vale 00:09:47
sí, JavaFX 00:09:51
que es la versión más moderna 00:09:53
vale 00:09:56
a ver, podemos rápidamente en un pispás 00:10:00
volver un poco la idea, pero bueno 00:10:03
viene a ser un poco lo mismo, pero en versión antigua 00:10:05
entonces 00:10:07
los componentes por defecto de swing 00:10:09
cuando los ponemos, vemos que su aspecto por defecto 00:10:11
es muy anticuado, tú luego le puedes 00:10:13
fijar el aspecto que te dé la gana 00:10:15
pero ya solo ves el detalle de que 00:10:16
el aspecto por defecto es muy anticuado 00:10:19
JavaFX 00:10:21
son controles como más modernos 00:10:23
sin necesidad de 00:10:25
cambiarle esto el aspecto, su aspecto por defecto 00:10:26
es más moderno 00:10:29
eso por un lado 00:10:30
por otro lado 00:10:32
incorpora ya 00:10:34
conceptos que Swing no incorporaba 00:10:36
porque todavía no estaban en Java 00:10:38
como los de programación funcional 00:10:40
con los que tendremos que meternos un pelinín 00:10:42
solo para poder usarlo aquí 00:10:44
un pelín solo 00:10:46
el concepto de separación 00:10:47
que en Swing estaba 00:10:51
más mezclado 00:10:52
de la vista 00:10:53
separarla del código 00:10:56
eso si no lo tenía 00:10:58
pues java x ya veremos como 00:10:59
la vista, la parte de diseño 00:11:01
la puede separar completamente del código 00:11:03
y meterla en archivo xml 00:11:06
eso si que es novedoso 00:11:07
yo toda la parte de diseño la meto 00:11:09
no la hago en java 00:11:12
la meto en archivos xml 00:11:13
y ahora ya mi aplicación java lee de ellos 00:11:15
entonces si yo quiero cambiar algo 00:11:18
lo puedo cambiar en xml 00:11:20
y cuando la aplicación arranca 00:11:21
Pues le doy ese archivo 00:11:23
No tengo que cambiar el código 00:11:25
¿Vale? También tiene una integración 00:11:27
Con acceso a bases de datos 00:11:29
Un poquito más 00:11:31
Funcional 00:11:33
Para eso, la integración a bases de datos 00:11:35
Está mejor soportada aquí 00:11:38
Que aquí, hay que hacerla más a mano 00:11:39
Entonces, bueno, es la versión como más moderna 00:11:41
¿Vale? 00:11:43
De aquí he hecho unos apuntillos 00:11:44
Que ya os pasaré, pero después 00:11:47
Cuando ya hayamos visto primero 00:11:49
Cómo funciona 00:11:52
para que os sirvan 00:11:53
como recordatorio. 00:11:56
Pero después, ¿vale? Primero vamos a aprender 00:11:57
a hacerlo y luego ya eso que nos sirva como recordatorio. 00:11:59
Es sencillo. 00:12:01
¿Vale? Bueno, pues entonces 00:12:03
JavaFX 00:12:06
la idea también es la misma. 00:12:08
Tu interfaz, 00:12:11
tu objeto, 00:12:11
aquí no se llama el JFrame. 00:12:12
En JavaFX es el Stage. 00:12:16
O sea, el marco 00:12:19
básico en 00:12:19
Swin es el JFrame 00:12:23
pues eso mismo, que es la ventanita 00:12:24
con el minimizado, el cuadradito y esto 00:12:26
eso mismo en JavaFX, en JavaFX es stage 00:12:28
ya está, pero la idea 00:12:31
es la misma, tú te haces tu stage 00:12:33
le pones las escenas, que las escenas 00:12:34
serían, pues ahora ya, el panel 00:12:36
con los componentes 00:12:39
y luego tienes que gestionar los eventos 00:12:40
¿vale? 00:12:43
bueno, pues entonces, vamos a 00:12:46
ver un poquito como arrancar 00:12:48
vamos a ver si conseguimos arrancar una aplicación 00:12:52
en JavaFX, porque no es tan 00:12:54
trivial como en Swing 00:12:56
por pequeñitas cosas 00:12:57
bueno, primer problema 00:12:59
si queremos hacer una aplicación con JavaFX 00:13:06
primer problema que nos encontramos 00:13:08
que lógicamente las clases 00:13:11
que necesitamos, bueno no tan lógicamente 00:13:14
podrían estar, pero bueno 00:13:16
la clase stage, los componentes 00:13:17
todo eso, las clases que necesitamos 00:13:20
no las trae el JDK 00:13:22
las trae el JDK, las tenemos que importar 00:13:23
entonces 00:13:27
eso ya es una primera complicación 00:13:28
para nosotros, porque nosotros 00:13:30
hasta ahora hemos visto 00:13:32
cómo generar un JAR para poder 00:13:34
difundir unas librerías nuestras 00:13:36
y hemos visto cómo incorporarlo 00:13:37
al ClassPath, pero 00:13:40
no hemos necesitado, en ninguna de nuestras aplicaciones 00:13:42
hemos necesitado, que yo recuerde, 00:13:44
incorporar una librería externa para 00:13:46
que funcione. 00:13:47
Bueno, si podemos, cuando nos lo enseñaste un poco 00:13:49
al principio del curso, cuando importábamos algo 00:13:51
Sí, pero para aprender a hacerlo 00:13:53
y para aprender cómo era, pero que todas las aplicaciones 00:13:56
que hemos hecho, todas las clases 00:13:57
que usábamos estaban en el JDK 00:14:00
no necesitábamos importar nada 00:14:02
bueno, pues aquí ya 00:14:03
necesitamos librerías externas 00:14:05
vale, esa es la primera complicación 00:14:08
entonces, bueno 00:14:19
no sería tan complicado porque efectivamente 00:14:21
sabemos cómo importar 00:14:23
librerías externas, cómo están las clases 00:14:25
que uno distribuye por ahí al mundo 00:14:27
están metidas en .jar, ¿verdad? 00:14:29
esto es lo que es un .jar 00:14:34
un .jar es 00:14:36
un fichero comprimido que tiene un montón 00:14:37
de clases, a su vez 00:14:39
distribuidas en paquetillos 00:14:41
entonces, importarlas 00:14:42
¿qué significa? pues lo hemos hecho alguna vez 00:14:45
cuando hemos generado un hard 00:14:47
pues añadirlas a la 00:14:49
famosa variable classPath 00:14:51
entonces, al añadirlas a la 00:14:53
famosa variable classPath 00:14:57
este hard, decir, oye, classPath 00:14:59
tú, usa que mi 00:15:01
aplicación va a usar las clases que están 00:15:03
en este jar, eso es lo que realmente 00:15:05
hacemos cuando importamos un jar 00:15:07
desde Eclipse, le estamos diciendo 00:15:09
a esta variable, oye tú 00:15:11
mi aplicación 00:15:13
va a usar clases que están 00:15:16
en este jar, tenlo en cuenta, para que 00:15:17
si yo te las pido con el import 00:15:19
que tú sepas dónde están, eso es lo que hacemos 00:15:21
entonces hasta ahí pues este 00:15:23
punto no sería tan horrible, no sería 00:15:25
un punto tan horrible, si sabemos hacer importar 00:15:27
un jar para que se usen las clases, no sería tan horrible 00:15:29
vale, pues sí 00:15:31
se convierte en un pelín horrible 00:15:33
Bueno, no un pelín horrible 00:15:35
Pero un pelín no tan fácil 00:15:37
Como esto 00:15:40
A ver, me distraigo mucho 00:15:41
¿Por qué no os escribís las cosas? 00:15:43
¿O habláis por señas? 00:15:45
¿No podéis estar hablando de fondo cuando alguien está hablando? 00:15:47
Es que eso no se puede hacer 00:15:50
Podéis no prestarme atención 00:15:52
Pero no me distraigáis 00:15:55
Si habláis, me distraéis 00:15:56
Os lo vais escribiendo en el monitor 00:15:58
Si queréis 00:16:00
Vale, entonces 00:16:01
esto, que sería 00:16:06
en principio, bueno, no es una complicación 00:16:09
tan grande, bueno, no es una complicación tan grande 00:16:11
ya sabemos añadir un JAR a un CLASSPAD 00:16:13
ya sabemos, pues si se convierte 00:16:15
en una complicación un poquito más grande, ¿por qué? 00:16:17
porque estas librerías 00:16:20
de JavaX 00:16:22
usan el sistema 00:16:23
de módulos 00:16:26
¿os acordáis 00:16:27
el módulo info que nos ha dado guerra alguna vez? 00:16:30
el módulo info 00:16:33
que decía, nada, bórralo y así no nos molesta 00:16:34
Vale, pues las librerías de JavaX, por estar hechas a partir de la versión JBK10 o no sé qué, usan el concepto de módulo de Java, que no es un concepto en realidad que se haya usado mucho y esté muy extendido, pero bueno, hay que conocerlo, pues si usamos alguna librería que lo usa, pues para no tener que pegarnos con ella demasiado, usa el concepto de módulo. 00:16:36
entonces, eso implica 00:17:10
que esto 00:17:12
no sea tan sencillo 00:17:13
importar el hat 00:17:16
de las librerías JavaFX 00:17:17
no sea tan sencillo 00:17:20
como agregarlo al classpath 00:17:21
con el configure buildpath 00:17:24
que hemos hecho hasta ahora 00:17:26
vale 00:17:27
entonces, ¿qué implicaciones tiene 00:17:28
que usen el concepto de módulo? 00:17:34
un poquito por encima 00:17:37
que es esto de los módulos, un poco por encima 00:17:38
no es algo que a nosotros nos importe 00:17:40
ni vayamos a trabajar con ello, ni vayamos a semear de ello, ni de nada. 00:17:41
Pero sí un poco nos importa saber qué es esto de módulos 00:17:45
porque JavaFX los usa. 00:17:48
Y eso nos va a implicar, más que nos va a implicar, 00:17:51
pues nos va a permitir entender por qué lo vamos a hacer 00:17:54
con la herramienta que lo vamos a hacer. 00:17:56
¿Vale? 00:17:58
Pues, ¿qué son los módulos en una aplicación Java que use módulos? 00:18:00
Bueno, pues si una aplicación Java no usa módulos, 00:18:05
todo el código está 00:18:08
todo junto, es como si fuera todo el código 00:18:12
está en la misma caja 00:18:15
entonces todo el código que usa la aplicación 00:18:16
estará pues en los hard 00:18:19
en las propias clases que yo he hecho 00:18:21
estará donde esté, pero está como 00:18:23
todo el código junto y cuando digo 00:18:25
junto es que hay una 00:18:27
única variable 00:18:29
¿vale? una única variable 00:18:30
que es la variable classPath que afortunadamente 00:18:33
como trabajamos con un entorno de desarrollo 00:18:35
la maneja el entorno de desarrollo 00:18:37
y no la manejamos nosotros. 00:18:39
Pues hay una única variable que nos dice 00:18:41
oye, esta aplicación usa este hard, 00:18:43
usa estos paquetes, usa no sé qué, 00:18:46
usa no sé cuántos, está todo aquí. 00:18:48
¿Vale? 00:18:51
Entonces es como si estuviera todo metido en la misma caja. 00:18:52
¿Vale? 00:18:56
Cuando una aplicación usa módulos, 00:18:57
lo que ocurre es que es como si el código 00:18:59
se distribuyera, se separara 00:19:02
en cajitas separadas. 00:19:05
En cajitas separadas. 00:19:08
y cada cajita es un módulo, cada cajita es un módulo y el módulo declara dentro información 00:19:09
sobre qué cosas uso yo de otras cajas y qué cosas de las que yo tengo dentro permito usar, 00:19:19
entonces una aplicación con módulos, cada parte del código, estas clases, estas clases, 00:19:27
clases, cada parte del código 00:19:35
puede ser un módulo diferente 00:19:36
cada módulo 00:19:39
se describe en el famoso 00:19:40
módulo info 00:19:43
por eso cuando hacéis 00:19:44
una aplicación en Eclipse 00:19:46
él asume 00:19:48
que va a haber un solo módulo 00:19:50
que es vuestra aplicación, un único módulo 00:19:52
y os crea ya un módulo info 00:19:55
para describir ese módulo 00:19:57
¿qué ocurre? que si hay un solo 00:19:59
módulo 00:20:01
podemos pasar 00:20:01
de eso completamente, si hay un solo módulo 00:20:04
da igual, está todo en la misma caja 00:20:06
igual, entonces borramos el módulo info 00:20:08
y lo quedamos tan tranquilo, porque no hay 00:20:10
no hace falta que describir el módulo 00:20:12
ni nada, porque solo hay uno 00:20:14
pero si hubiera varios 00:20:15
cada módulo tiene su módulo info 00:20:17
que el módulo info es un ficherito de texto 00:20:20
que dice, oye 00:20:22
este módulo 00:20:24
necesita las clases 00:20:26
de aquí, de aquí, de aquí 00:20:28
y además permite el uso 00:20:30
de las clases suyas, esta y esta 00:20:32
y esta, entonces se queda todo como más 00:20:34
compartimentado, más encapsulado 00:20:36
para esto van los módulos en realidad 00:20:38
para tener el código más organizado, más compartimentado 00:20:40
más compartimentado 00:20:42
y todo eso 00:20:46
para eso vale 00:20:46
que normalmente las aplicaciones de 00:20:47
todo el mundo, de toda la vida de Dios son un solo módulo 00:20:50
y ya está, y el módulo info 00:20:52
describe ese módulo si es que lo queremos usar 00:20:55
pero no hace falta 00:20:57
bueno 00:20:58
el módulo es como un paquete 00:21:00
entonces para distintas 00:21:03
cada módulo tiene un montón de paquetes 00:21:04
dentro 00:21:07
cada módulo es como una parte 00:21:07
de mi código, o sea mi código a lo mejor son 00:21:11
mi aplicación, son mil clases 00:21:13
y puedo tener un módulo 00:21:15
con 500, otro módulo con 150 00:21:17
y otro módulo con 250, yo que sé 00:21:18
o sea un paquete tiene clases y un módulo tiene paquetes 00:21:20
exacto 00:21:23
y un módulo aparte de sus clases 00:21:26
puede ser que necesite para funcionar 00:21:28
clases de otro módulo, porque lo llaman 00:21:30
sus propias clases 00:21:32
y además puede ser que quiera dar 00:21:33
permiso para que otros módulos usen sus 00:21:36
clases o las instancien, pues todo eso 00:21:38
se describe en el módulo 00:21:41
info 00:21:42
¿vale? con que nos quedemos con eso 00:21:43
es suficiente 00:21:46
no hay más 00:21:47
entonces, ¿qué ocurre? 00:21:49
bueno 00:21:54
pues que las librerías 00:21:54
de JavaFX 00:21:56
están modularizadas 00:21:57
es decir, son .jar 00:22:01
que están separados por módulos 00:22:03
eso es lo que nos implica 00:22:05
ahora nosotros 00:22:07
nuestra aplicación va a seguir siendo un módulo igualmente 00:22:08
mi aplicación va a ser un módulo 00:22:11
pero va a necesitar cosas 00:22:12
de otros módulos 00:22:15
que no lo sabré yo 00:22:17
porque ya son estas librerías que yo descargaré 00:22:19
¿vale? 00:22:22
pero mi aplicación va a ser igual 00:22:23
un mismo módulo como lo hemos hecho siempre 00:22:24
lo único es que ahora 00:22:26
las clases 00:22:28
que tenemos que importar 00:22:31
no son puntojar que están ahí sueltos 00:22:32
de la vida de Dios, yo los meto al 00:22:35
claspaz y ya está, no son puntojar 00:22:37
que están sueltos para que vayan al claspaz 00:22:39
lo que son 00:22:41
son módulos 00:22:42
entonces importar un módulo 00:22:44
no es tan sencillo 00:22:47
entonces esa es la primera 00:22:50
cosa peliaguda, que las 00:22:53
librerías de JavaFX al ser en realidad 00:22:55
al estar organizadas en módulos 00:22:57
ellas, al estar organizadas en módulos 00:22:59
yo no incorporo el jar al classpath y se acabó 00:23:01
no, tengo que hacer algo más 00:23:03
¿vale? 00:23:05
y ahora eso por un lado 00:23:08
y por otro lado, arrancar la aplicación 00:23:10
tampoco es trivial 00:23:12
¿vale? porque para cuando la aplicación 00:23:13
arranca, hay que decir 00:23:16
no puedo arrancarla como he hecho hasta ahora 00:23:18
de runas, java, application, no 00:23:20
porque cuando una aplicación tiene módulos 00:23:22
para arrancarla, tenemos que 00:23:24
explicarle a la aplicación 00:23:26
dónde se encuentran esos módulos, 00:23:28
porque ahora no hay un classpath donde está todo. 00:23:30
Ahora no hay un classpath donde está todo. 00:23:32
Ahora hay que arrancarla con unos parámetros 00:23:34
que informen de dónde están esos módulos 00:23:37
que yo he incorporado. 00:23:40
Conclusión. 00:23:42
Se convierte en mucho más complicado 00:23:44
importar las librerías 00:23:46
y arrancar la aplicación. 00:23:48
Podríamos hacerlo incorporando las librerías 00:23:51
al módulo de path 00:23:53
y luego arrancando la aplicación 00:23:54
dándole unos parámetros a la máquina virtual, 00:23:55
dándole las rutas de los módulos 00:23:57
podríamos hacerlo así y ya está 00:23:59
pero ya empieza a complicarse 00:24:00
una tarea tan automática 00:24:03
entre comillas 00:24:05
como importar librerías y ejecutar 00:24:06
que en principio es automática hasta ahora 00:24:09
importo librerías, ejecuto 00:24:11
pues una tarea que en principio debería ser automática 00:24:13
se empieza a hacer complicada 00:24:15
entonces como se empieza a hacer complicada 00:24:17
y no tiene sentido que lo hagamos todo el rato 00:24:19
cada vez que queremos incorporar la aplicación 00:24:21
ni nosotros ni el universo 00:24:22
pues aquí es donde ya empiezan a cobrar 00:24:24
sentido unas cosas 00:24:27
que igual habéis mencionado ya 00:24:29
en entornos de desarrollo 00:24:30
que son las herramientas de 00:24:33
gestión 00:24:35
de proyectos. Como por ejemplo 00:24:37
Maven 00:24:45
¿Os suena el nombre? 00:24:50
Sí, pero no 00:24:53
hemos empezado a verlo. 00:24:54
Por ejemplo, Gradle 00:24:55
otra también, que son las dos más 00:24:57
comunes. 00:25:00
En Java esencialmente es. 00:25:01
Entonces, estas herramientas 00:25:07
de gestión de proyectos, ¿qué hacen? 00:25:08
Pues es un pequeño software 00:25:12
que hace 00:25:14
algunas tareas por nosotros. 00:25:16
Nosotros la configuramos, 00:25:19
configuramos esa herramienta, 00:25:21
que es un pequeño software, la configuramos 00:25:23
con ficheros de configuración 00:25:25
y esa herramienta 00:25:27
hace ya tareas 00:25:31
por nosotros y nos ahorra trabajo. 00:25:33
Puede hacer tareas como compilar, 00:25:34
puede hacer tareas como pasar test, 00:25:36
puede hacer tareas como esta, 00:25:38
que es la que nos va a venir bien a nosotros, 00:25:41
que es incorporar librerías y arrancar la aplicación, 00:25:42
puede hacer todo eso por nosotros. 00:25:46
Entonces, ahora sí que tiene sentido 00:25:49
que incorporemos a nuestros proyectos 00:25:51
esta pequeña o grande, según el uso que queramos darla, 00:25:54
de gestión de proyectos 00:25:58
y así nos va a facilitar incorporar las librerías 00:25:59
y arrancar el proyecto, nos lo va a facilitar. 00:26:03
Bueno, pues entonces 00:26:05
Vamos a 00:26:09
Arrancar un primer proyecto 00:26:11
Con Mabel 00:26:13
Importando las librerías del JavaFX 00:26:14
Aquí ya, claro 00:26:19
Cuando uno empieza a importar librerías 00:26:21
A partir de ahora ya 00:26:23
Os he dicho librerías hasta ahora todo el rato 00:26:26
Porque es una palabra que nos es más familiar 00:26:28
Una librería es un conjunto de clases 00:26:31
Que voy a usar 00:26:33
pero la palabra que deberíamos usar 00:26:34
y vamos a usar a partir de ahora 00:26:37
porque es la palabra técnica de desarrollo 00:26:39
es dependencia 00:26:41
dependencia es 00:26:43
un conjunto de clases 00:26:45
de los cuales tu aplicación depende 00:26:47
para funcionar porque los usa 00:26:49
entonces 00:26:50
nuestra aplicación va a necesitar 00:26:53
las dependencias 00:26:56
de JavaFX 00:26:57
mejor decirlo así 00:26:58
que decir las librerías de JavaFX 00:27:02
entonces 00:27:04
Maven, para lo que es 00:27:06
maravilloso, imprescindible 00:27:08
ya en cuanto tú empiezas a usar librerías externas 00:27:10
o dependencias, es para 00:27:13
la gestión de dependencias 00:27:14
porque si no tendríamos que estar buscando por el mundo 00:27:16
por internet, por todos lados, los hard 00:27:18
descargarlos, incorporarlos 00:27:20
y eso es un rollo, pues Maven hace 00:27:22
todo eso por nosotros 00:27:24
entonces, usar herramientas de gestión de proyectos 00:27:25
cuando ya el proyecto 00:27:29
incorporar dependencias, tengo que estar 00:27:29
automatizando pruebas o cosas, ya es imprescindible 00:27:32
pues venga 00:27:34
ahora ya precisamente 00:27:36
cuando ya necesitamos dependencias 00:27:38
externas, maven y 00:27:40
rollos de estos, ahora es cuando ya 00:27:42
empiezan a pasar cosas 00:27:44
en función de la versión que tengamos 00:27:46
de Eclipse, de JDK, etc 00:27:48
entonces ahora ya pues 00:27:50
algunos os funcionarán desde el principio 00:27:52
a otros no, tendréis que retocar cosas 00:27:54
etc, veremos, misterio 00:27:56
Claro, Mabel automáticamente 00:27:58
Tú le dices, quiero esto 00:28:03
Y de forma transparente para ti 00:28:04
Se conecta al repositorio suyo de Mabel 00:28:07
Lo descarga y te lo deja 00:28:09
En un repositorio local 00:28:11
Para que no tengas que estar todo el rato 00:28:12
¿Vale? 00:28:14
Cuando tu aplicación arranca, va al repositorio local 00:28:16
Si ve que el repositorio local está vacío 00:28:18
Automáticamente, sin decirte nada, se vuelve a conectar y te lo baja 00:28:20
¿Vale? 00:28:22
Pues venga, vamos a ver si tenemos suerte 00:28:26
Y nos funciona todo desde el principio 00:28:27
que no es tan fácil 00:28:29
que nos funcione todo desde el principio 00:28:32
cuando ya dependemos de cosas raras 00:28:34
vale 00:28:37
a ver, bueno 00:28:39
son las 37, vamos a aprovechar a parar aquí un momento 00:28:50
a ver 00:28:53
un momentito 00:28:55
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:
3
Fecha:
18 de abril de 2026 - 11:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 58″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
173.62 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid