Saltar navegación

20260422 JavaFX_Combo_ActionEvent - 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 27 de abril de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues la aplicación esta de países que hicisteis el otro día nos permitió incorporar, pues un elemento nuevo, nos permitió incorporar este desplegable de aquí, ¿vale? 00:00:01
Entonces este desplegable de aquí 00:00:14
Como tiene la notación 00:00:17
FXML 00:00:20
Se instancia automáticamente 00:00:21
Por eso aquí 00:00:24
Ni lo inicializamos a New Combo Box 00:00:24
Ni nada 00:00:28
Este se instancia automáticamente 00:00:28
En cuanto se carga la vista 00:00:31
En cuanto se carga 00:00:33
La vista aquí 00:00:36
Con esto 00:00:36
Pues lo que haya en esa vista 00:00:39
Que es el Combo Box, todo lo que haya 00:00:41
automáticamente se instancia este combo box 00:00:43
y esta etiqueta en ese caso con los elementos de la vista 00:00:48
y ya están permanentemente conectados 00:00:51
y ahora ya nuestro controlador pues que hacía 00:00:54
pues primero a través de este método opcional 00:00:57
inicializaba cosas en la vista 00:01:03
en particular lo que hacía en este caso era 00:01:06
cargar los datos de la aplicación 00:01:08
y ponérselos 00:01:11
a el combo box 00:01:14
¿vale? se los ponía al combo box 00:01:15
mediante el método setItems 00:01:18
el combo box tiene muchos más métodos 00:01:20
si uno quiere ya jugar con él, hacer lo que sea 00:01:21
¿vale? 00:01:23
entonces 00:01:25
para añadirle ítems al combo box 00:01:26
creábamos una lista 00:01:30
un ArrayList normal y corriente 00:01:31
un ArrayList a partir 00:01:33
de los países de nuestro fichero 00:01:35
pero ese ArrayList en lugar de ser 00:01:37
un ArrayList normal y corriente 00:01:39
lo hacíamos 00:01:42
fuera de la clase ObservableList 00:01:43
que se especifica de JavaX 00:01:46
la clase ObservableList 00:01:49
permite que 00:01:51
esta lista esté automáticamente conectada 00:01:53
a la vista. 00:01:56
Entonces, si hay cambios 00:01:58
en esta lista, algún 00:01:59
otro evento hace cambios en esta lista, 00:02:01
el ComboBox 00:02:04
que lo tiene asociado, cambia 00:02:05
automáticamente. 00:02:07
esa es la ventaja de usar una observable list 00:02:08
en lugar de una array list 00:02:12
directamente para el combo box 00:02:13
bueno pues 00:02:15
esta aplicación nos permitió por tanto 00:02:17
incorporar este elemento 00:02:19
incorporar esta lista 00:02:20
que se asocia a muchos otros controles 00:02:22
que son para mostrar datos 00:02:25
el combo box es un control para mostrar datos 00:02:27
muy bueno el desplegable 00:02:30
pero también hay el list view 00:02:31
que es una lista, la típica lista que uno puede 00:02:32
seleccionar elementos, también hay un table view 00:02:34
que es una tabla para seleccionar 00:02:37
elementos, pues todos ellos pueden 00:02:39
tener asociadas listas observables 00:02:41
de estas 00:02:43
vale, además nuestra aplicación que hacía 00:02:44
pues ya cuando pulsábamos en el combo box 00:02:47
hacía algo 00:02:49
entonces pulsaba en el combo box, dijimos 00:02:50
uy, será el onAction, que es el método por defecto 00:02:53
lo probamos, pues sí 00:02:55
era el onAction, el onAction nos llevaba aquí 00:02:56
y de aquí sacábamos los 00:02:59
habitantes asociados 00:03:01
a ese nombre de país que estaba 00:03:03
en el combo box seleccionado 00:03:05
y listo, vale 00:03:07
bueno, pues esta aplicación 00:03:08
ya nos permitió incorporar alguna otra cosa 00:03:11
vale 00:03:13
pues venga, vamos a hacer otra 00:03:14
para incorporar alguna cosa 00:03:17
básica también 00:03:18
vale 00:03:21
nosotros, con lo que hemos 00:03:23
hecho hasta ahora 00:03:25
cada control tiene un método 00:03:26
asociado 00:03:29
luego si mi aplicación tiene mil 00:03:30
controles 00:03:33
mil métodos en el controller 00:03:34
vale, pues no pasa nada 00:03:37
pues se puede sobrevivir así 00:03:39
pero bueno, a lo mejor 00:03:41
podríamos optimizar el código si ocurre lo siguiente 00:03:43
uy, tengo 00:03:45
cuatro controles que 00:03:47
responden prácticamente con el mismo 00:03:49
código, solo cambia 00:03:51
una cosita mínima 00:03:53
entonces, voy a poner cuatro 00:03:54
métodos prácticamente iguales 00:03:57
en los que solo cambia una cosita mínima 00:03:59
asociados a los cuatro controles 00:04:01
no podría yo hacer un único método 00:04:04
y que ese método decida 00:04:07
que control lo llamó 00:04:09
y en función del control 00:04:11
que lo llamara a hacer una cosa u otra 00:04:13
sería lo ideal ¿no? 00:04:15
y así no tengo que copiar el mismo código 00:04:17
en cuatro sitios distintos 00:04:18
¿entendéis a lo que me refiero? 00:04:21
por ejemplo 00:04:26
lo vamos a ver 00:04:27
en el caso básico y luego ya lo hacemos 00:04:29
en una aplicación un poco más esta 00:04:31
Bueno, esta calculadora como era de texto 00:04:32
La dejamos, vamos a hacer la calculadora 2 00:04:36
Así rápidamente 00:04:38
Pues venga, nuestro maven project 00:04:40
Si hoy nos da tiempo 00:04:42
Y si no el viernes, ponemos el plugin de Eclipse 00:04:44
Para que no lo tengáis que hacer como proyecto maven 00:04:46
Si os es más rápido 00:04:49
Vale, pues venga 00:04:50
Hacemos un proyecto maven normal 00:04:54
Esto ya lo hacéis todo de carrerilla sin equivocaros 00:04:55
Un proyecto nuevo 00:04:58
calculadora 2, para ver esto que os digo 00:05:05
muy cortito 00:05:07
para ver esto, vale 00:05:10
pues yo que sé, calculadora 00:05:11
teclas, le voy a poner 00:05:14
porque la otra, tú ponías los numeritos 00:05:15
en el área de texto, en esta los numeritos 00:05:17
los vas a pulsar por teclas 00:05:19
o las operas 00:05:20
ah, no, no, no, perdón, perdón 00:05:21
lo vamos a hacer, vamos a reutilizar 00:05:25
la anterior, porque 00:05:27
así no metemos más basurilla 00:05:28
vamos a reutilizar la anterior, vamos a ver como era 00:05:31
la anterior. ¿Vale? Abortar 00:05:33
el proceso de hacer proyecto nuevo y así ahorramos 00:05:37
tiempo. La anterior, vamos a 00:05:39
recordar cómo funcionaba. 00:05:41
Vale, esta funcionaba. Tú ponías 00:05:50
45 más 00:05:51
igual a lo que fuera. 00:05:56
Habíamos 00:05:59
habilitado solo el botón más, ¿verdad? 00:05:59
El menos no hacía nada. Vamos a 00:06:01
habilitar el botón menos. 00:06:03
Vamos a ampliar la calculadora 00:06:05
habilitándole el botón menos. 00:06:07
Pues entonces, ¿qué haríamos? 00:06:09
con lo que sabemos hasta ahora 00:06:11
pues entonces nos iríamos a nuestro controlador 00:06:14
con lo que sabemos hasta ahora nos iríamos a nuestro controlador y diríamos 00:06:18
venga 00:06:22
pues un nuevo evento 00:06:23
en otro control distinto pues un nuevo método botón igual botón suma pues 00:06:25
botón menos 00:06:29
entonces voy a copiar y pegar porque son casi iguales 00:06:33
botón suma 00:06:37
botón resta 00:06:39
eeeh 00:06:46
vale 00:06:48
vale, sí, es que este en particular da igual porque es que es el mismo código clavado, ni siquiera cambia nada, con lo cual es que ni siquiera puede ser el mismo botón para ambos, porque solo, vale, el botón igual, vale, vale, vale, no, es que, vale, nada, no, a ver, tal y como está hecha la calculadora, botón igual, tienes que haber cual dado la operación, 00:06:58
Claro, es que el botón igual 00:07:21
Hacia la suma 00:07:23
Entonces tú le dabas a la resta 00:07:25
Vale, vale, entonces 00:07:26
Claro, sí 00:07:28
Sí, es que por eso no sé si este es un 00:07:37
Buen ejemplo 00:07:39
Si tú le das a 00:07:40
Más 00:07:43
Vale, entonces 00:07:45
Vamos a cambiar un poquito esta calculadora 00:07:46
Para que aplique un poco más esto que vamos a hacer 00:07:49
Entonces 00:07:50
¿Eh? 00:07:51
Venga, vale 00:07:56
¿Sabes qué pasa? Que es que esta está mal 00:07:57
Porque es que el botón igual 00:08:01
Lo único que hace es sumar 00:08:02
Entonces ya está mal 00:08:03
La calculadora tiene que guardar 00:08:05
O sea, el botón igual 00:08:08
Hace una cosa o hace otra 00:08:10
En función de la operación previa 00:08:12
Entonces esta calculadora está mal 00:08:14
¿Vale? 00:08:16
Entonces, ¿vosotros la tenéis 00:08:19
Igual que yo? 00:08:20
Es que claro, si me pongo ya a modificar 00:08:22
Cosas, vosotros tenéis otra cosa 00:08:25
Entonces por eso es casi, para que os enteréis 00:08:26
Como, para que os enteréis 00:08:28
de lo que vamos a meter ahora, es casi mejor 00:08:30
hacer un proyecto nuevo, porque si no, como cada uno 00:08:32
tú tienes ya el tuyo completo bien 00:08:34
entonces 00:08:36
si yo me puedo cambiar esto 00:08:37
pues voy a ir un poco por libre 00:08:40
y no es plan, vale, pero ahora 00:08:41
entendéis el problema de esta calculadora 00:08:44
los que la tengáis copiada tal cual 00:08:46
pues vosotros ya podéis hacer la modificación por vuestra 00:08:48
cuenta como ha hecho él, para que tenga sentido 00:08:50
o sea, esta calculadora le dabas igual y te sumaba 00:08:52
era absurdo, o sea, el menos 00:08:54
tenías que haberlo guardado en algún sitio 00:08:56
idealmente el objeto 00:08:57
En algún sitio lo tienes que haber guardado 00:08:59
Vale, entonces 00:09:02
Esto lo voy a poner 00:09:03
Aquí 00:09:05
La calculadora 00:09:07
Suma siempre 00:09:13
Entonces habría que cambiar esto 00:09:18
La aplicación 00:09:24
Para que distinga 00:09:28
En función de la operación 00:09:30
De la operación previa 00:09:31
Vale, pero este cambio no implica 00:09:34
Esto nuevo que quiero contar yo ahora 00:09:39
Con lo cual eso se queda aquí planteado 00:09:41
Cada uno que lo cambie como haya querido 00:09:43
Y ahora ya sí que vamos a hacer 00:09:45
Venga, pues a ver 00:09:47
Venga, entonces vamos a 00:09:49
Vale, a ver 00:10:01
Estoy pensando algo más bonito que 00:10:12
Venga, una calculadora 2 00:10:14
Aunque sea una chorrada 00:10:28
Vale, calculadora 00:10:29
Calculadora teclado 00:10:35
Le vamos a llamar 00:10:40
Para que... 00:10:42
No, no. 00:10:44
Calculadora 2. 00:10:45
Bueno, pues os acordáis 00:11:00
de cambiar la máquina virtual. 00:11:01
Sí, al final he hecho otra calculadora. 00:11:07
Después de muchas idas y venidas 00:11:09
me he decidido. 00:11:10
Venga, pues a ver. 00:11:14
Cambiamos el nivel de compilación. 00:11:15
Ahora. 00:11:26
Cuidado. 00:11:29
Ahora el POM 00:11:30
lo copiamos de un archivo 00:11:32
que nos funcione. 00:11:35
desde descripción hacia abajo 00:11:38
dígame 00:11:40
si, no, no, no te preocupes por eso 00:11:45
a ver, no necesariamente 00:11:51
esa línea en particular 00:11:58
no necesariamente 00:12:01
vale, entonces, ahora 00:12:01
me abro el POM de mi 00:12:04
calculadora 2 00:12:06
copio eso 00:12:08
cambio los rojitos y nos da 00:12:11
talk y 00:12:15
revisamos 00:12:18
que el plugin tiene la clase 00:12:20
main correctamente puesta 00:12:23
venga, la vamos a llamar así 00:12:25
yo la voy a llamar así, así no tengo ni que 00:12:27
cambiar 00:12:29
vale, entonces guardando esto 00:12:29
pues efectivamente ahora ya 00:12:33
venga, vale 00:12:35
pues entonces mi calculadora 2 00:12:45
verificamos que 00:12:47
las maven dependencias se han 00:12:49
cargado, bien 00:12:51
y ahora ya, venga, nos vamos a hacer 00:12:52
un modelo con un objeto calculadora 00:12:55
igual que el otro, entonces vamos a hacer nuestra primera 00:12:58
aplicación, nuestro primer paquete 00:13:00
nuestro primer 00:13:01
paquete 00:13:03
es .dump1 00:13:05
.model 00:13:08
y en este paquete de modelo va a ir 00:13:09
la entidad 00:13:14
con la que va a trabajar 00:13:16
mi aplicación, que yo he decidido que sea una 00:13:18
calculadora, mi aplicación va a trabajar con una 00:13:20
calculadora, pues la meto aquí 00:13:22
voy a copiar y pegarla del otro sitio 00:13:24
y le voy a añadir la operación resta que no tenía 00:13:26
copiar, copiar 00:13:30
venga, la pego ahí 00:13:37
esta es mi calculadora 00:13:44
se caracteriza 00:13:48
por los operandos 00:13:50
y por las operaciones que puede hacer 00:13:52
sumar y restar 00:13:54
¿vale? 00:13:56
se podría poner en un método que es 00:13:58
un único método 00:14:00
operar 00:14:02
y que reciba por parámetro la operación 00:14:03
Reciba el más, el menos 00:14:06
Se podría hacer de diferentes formas 00:14:08
Y ya está 00:14:11
Mi calculadora con dos operaciones 00:14:14
Y dos operandos 00:14:16
Este es el modelo que decido yo 00:14:18
Por los requisitos de mi aplicación 00:14:20
De lo que voy a hacer 00:14:21
De lo que me he hablado con el cliente, etc. 00:14:22
Sí, están por ahí abajo 00:14:26
Constructor no le he puesto 00:14:28
Vale, pues entonces ahora ya vamos a hacernos 00:14:31
La aplicación 00:14:35
el paquete 00:14:37
es que me pasa por ir rápido 00:14:53
y hablar 00:14:55
y hacerlo todo a la vez 00:14:56
que no me sale 00:14:59
entonces no pasa nada 00:15:00
le cambio el nombre ahora 00:15:03
y ahora ya si que me hago la clase 00:15:04
pero está bien que estéis atentos 00:15:07
app con el main 00:15:12
aquí debajo 00:15:16
el main tiene 00:15:17
el land 00:15:19
arts 00:15:20
y esta hereda 00:15:25
de application 00:15:28
extends application 00:15:29
vale, y ahora 00:15:39
me tengo que hacer yo mi método start 00:15:47
para que este se calle 00:15:49
y porque lo tengo que hacer lógicamente 00:15:50
primero importo 00:15:53
y ahora añado el start 00:15:56
y ahora en el start 00:15:59
cargo la vista 00:16:01
que todavía la tengo por hacer 00:16:03
y me hago mi primera escena con esa vista 00:16:04
entonces esto de nuevo copio y pego 00:16:09
del otro 00:16:11
copio y pego de la otra que tenía 00:16:13
vale, pues lo primero 00:16:17
que vamos a hacernos, pues esta vista 00:16:34
y luego ya nos hacemos el controller, porque en función de los 00:16:35
controles que tengamos, pues ya habrá unos métodos 00:16:38
o habrá otros 00:16:40
venga, pues hala 00:16:41
voy a abrir el 00:16:43
este de aquí 00:16:50
pues hala 00:16:52
Me hago 00:17:09
Mi área de texto 00:17:10
Podría haber copiado la otra 00:17:12
Sin más 00:17:17
Voy a copiar la misma otra vista 00:17:18
Como lo que cambia es el control 00:17:24
En lugar de hacer una de nuevas 00:17:25
La otra vista que tenía 00:17:26
En la otra calculadora 00:17:30
La voy a reutilizar aquí 00:17:32
La otra vista que tenía que estaba en resources 00:17:34
Esta vista la copio 00:17:37
Y la pego aquí también 00:17:39
En los resources de este 00:17:43
Vale pues 00:17:44
Y ahora esta vista 00:17:49
Que es una copia 00:17:52
Idéntica de la de la otra calculadora 00:17:54
La voy a editar 00:17:56
Ahora ya si con el steam builder 00:17:57
Vale 00:17:59
Si hacéis open with 00:18:01
Pues buscáis la aplicación 00:18:03
Si pero 00:18:06
No es que yo no quiero esto 00:18:07
Donde pone steam builder 00:18:10
Yo no lo veo ahí 00:18:11
Ah, vale, vale 00:18:12
Ya, ya, ya 00:18:22
El eclipse no... 00:18:22
Venga 00:18:27
Vale, a ver 00:18:28
Aquí 00:18:51
a ver donde lo tengo 00:18:52
archivo encendido 00:18:54
pues espérate 00:18:55
a ver que averigüe yo donde estaba este 00:19:09
vale 00:19:11
appdata 00:19:21
pues venga 00:19:22
si lo tengo 00:19:26
si no ya lo ha visto donde 00:19:27
en appdata 00:19:30
no no lo tengo ahí 00:19:31
vale 00:19:33
aquí 00:19:33
Vale, estaba un poco escondida, venga, pues a ver, calculadora 2, vale, entonces, ahora, 00:19:41
Vamos a poner el controller, el controller está aquí ya puesto como es Danbuno controller, 00:20:37
este ya tiene un nombrecito puesto aquí en code, este ya tiene su nombre que se llamaba dato, 00:20:48
este tiene un onAction y este no lo tiene, entonces vamos a suponer que digo, bueno, yo quiero restar también, 00:20:58
yo también quiero restar 00:21:05
pues entonces vamos a ponerle aquí un onAction 00:21:07
que sea botón resta 00:21:09
botón resta 00:21:11
y el igual tiene botón igual 00:21:16
entonces estos son los tres que van a recibir evento 00:21:17
este, este y este 00:21:20
este no va a recibirlo 00:21:22
pero si necesitamos saber su nombre 00:21:24
y ya está, tiene el controlador, lo tiene todo 00:21:25
en la vista ya en principio no tengo nada más 00:21:28
que tocar 00:21:30
vale, pues ya está, ahí se queda cerrado 00:21:31
ahora 00:21:34
ahora nos toca hacer el controller 00:21:35
entonces voy a copiar y pegar 00:21:37
el otro controller para ahorrarme tiempo 00:21:39
el otro controller, el paquete entero 00:21:41
de hecho 00:21:43
copiar 00:21:44
vale, pues nada 00:21:46
el controller 00:21:56
el controller necesita el objeto calculadora 00:21:59
necesita el dato y a los 00:22:01
eventos, vale, entonces 00:22:03
esto lo quitamos 00:22:05
tiene un inicialice arrancando calculadora 00:22:06
ya está y ahora vamos a 00:22:11
añadirle, ahora mismo solamente tengo 00:22:12
el evento de botón 00:22:14
suma 00:22:16
entonces 00:22:17
vale, si yo le he dado 00:22:19
al botón suma, que es lo que estoy haciendo 00:22:22
cargar en la calculadora 00:22:24
el operando 1 00:22:26
y tengo que cargar también 00:22:30
en algún sitio la operación para que se quede 00:22:34
en memoria, para luego cuando le dé 00:22:36
al botón igual 00:22:38
para que se quede en memoria 00:22:39
entonces 00:22:42
que opción 00:22:42
podríamos optar aquí, muchas 00:22:45
podríamos poner aquí por ejemplo 00:22:47
pues 00:22:48
en el propio controller 00:22:50
podríamos poner la operación 00:22:52
o en la calculadora 00:22:54
vale 00:22:56
vamos a ponerla en el controller 00:22:58
he quitado el botón igual 00:23:01
vale, he quitado el botón igual 00:23:26
porque ese método 00:23:29
estaba mal, porque sumaba siempre 00:23:31
He dejado solo botón suma que tenemos que tocar 00:23:32
Vale, entonces string operación 00:23:35
Vale, entonces 00:23:37
Cuando yo le doy al botón suma 00:23:38
Operación 00:23:40
Se guarda así 00:23:42
Por ejemplo 00:23:44
Botón resta 00:23:45
Va a hacer lo mismo 00:23:48
Lo mismo 00:23:52
Salvo esta cosita pequeña de aquí 00:23:55
Salvo esta 00:23:59
Poner la operación a menos 00:24:00
Va a hacer lo mismo 00:24:02
Que este de aquí 00:24:03
¿Vale? 00:24:04
Aquí 00:24:10
Y ahora 00:24:10
Ahora ya me hago el botón igual 00:24:15
Igual 00:24:18
Y el evento del botón igual 00:24:35
Pues ahora ya sí que será 00:24:37
Coger el segundo operador 00:24:39
Coge el segundo operador 00:24:41
Del área de texto 00:24:52
Y ahora ya en función de la operación 00:24:53
Hace una cosa u otra 00:24:57
¿Vale? En el caso de que sea más 00:24:58
Pues entonces hace poner el área de texto 00:25:19
Voy a abrir otro controller para copiarlo 00:25:23
Dato se llama 00:25:26
Pues dato.setText 00:25:36
Y ahora calc.sumar 00:25:42
Más esto 00:25:48
Y ahora 00:25:50
En el caso de que sea menos 00:25:54
pues llama a restar 00:25:59
y lo pone en dato 00:26:07
y ya está 00:26:17
y si le damos al botón igual 00:26:20
sin que la operación 00:26:23
se haya cargado antes con nada 00:26:25
pues vamos a hacer 00:26:28
que no haga nada 00:26:30
ya está, no hace nada 00:26:32
nada más que 00:26:36
poner a cero la 00:26:38
poner a cero la 00:26:40
ventanita y ya está 00:26:42
default 00:26:43
Vale, pues tenemos los tres eventos 00:26:45
Los tres eventos asociados 00:27:03
Vamos a ver si esto funciona 00:27:04
Sí 00:27:05
Solamente cambia esto 00:27:08
Solo cambia eso 00:27:19
Cada uno de los dos eventos 00:27:21
De suma y resta 00:27:23
Solo cambia eso 00:27:24
Y luego 00:27:25
Llamas a calculadora 00:27:30
en función del operando, haces una cosa u otra 00:27:33
o si hubiéramos 00:27:35
tenido un único método operación 00:27:38
pasándole el operando, pues operación 00:27:39
pasándole el operando 00:27:41
o podríamos haber puesto en la calculadora 00:27:42
operando activo, bueno, muchos diseños posibles 00:27:48
pero bueno, ahora no nos importa mucho 00:27:50
vale 00:27:52
vamos a ver si esto funcionara 00:27:53
mabil 00:27:55
run 00:28:07
vale, 23 00:28:08
más 2 00:28:18
uy, más 12 00:28:19
igual a 35 00:28:21
vale, y ahora 00:28:22
más 00:28:28
uy, quería yo menos, bueno, da igual 00:28:30
1 igual 00:28:32
a 57 00:28:35
y ahora 00:28:36
se le podría añadir un botón de clear 00:28:38
pero bueno, y ahora 00:28:41
34 menos 00:28:42
1 igual 00:28:44
a 33, vale 00:28:47
bueno, la calculadora funciona 00:28:48
con cositas que se le podrían añadir 00:28:50
que borrar automáticamente 00:28:52
pero ahora 00:28:53
lo que nos importa a nosotros 00:28:56
bueno, hasta aquí bien 00:28:59
no, no tengo que entender 00:29:01
cuando llamas 00:29:03
cuando tú pillas 00:29:06
ese text te fija en esta etiqueta lo que tú le pongas 00:29:10
sí, pero digo 00:29:13
cuando tú sacas el segundo operador 00:29:15
yo saco el segundo operador 00:29:17
y se lo meto a la calculadora 00:29:19
y ahora le digo a la calculadora que sume 00:29:20
y suma 00:29:23
La calculadora la hemos puesto en el paquete modelo y se limita a sumar los dos operadores que le hemos fijado previamente, claro. 00:29:25
Vale, pues entonces, ¿qué ocurre? Ahora ya nos ponemos a revisar esta aplicación y decimos, a ver, controller, ¿dónde estás? Aquí. 00:29:35
Vamos a ver, tenemos dos métodos que son prácticamente idénticos, prácticamente idénticos, solo cambian en esta línea y en esta línea, al menos son cortos pero son idénticos y si pusiéramos más operaciones, multiplicación, división, empezarían a aparecer aquí un montón de métodos, todos prácticamente iguales salvo una línea. 00:29:50
bueno, esta situación se puede dar 00:30:14
en mil situaciones equivalentes 00:30:17
este es el ejemplo más sencillo que se me ha ocurrido 00:30:19
los botones de una calculadora 00:30:21
pero una situación así se puede dar en mil situaciones 00:30:23
en mil aplicaciones distintas 00:30:25
entonces 00:30:27
nosotros pensamos, jolines 00:30:29
y si yo hago un único evento 00:30:30
y que el evento dentro 00:30:33
distinga a quien le llamó 00:30:35
y en función de quien le llamara 00:30:36
ponga el más o ponga el menos 00:30:38
sería ideal 00:30:40
que yo desde un método 00:30:43
de evento, de respuesta a evento 00:30:45
tenga yo acceso a la información 00:30:47
de quien me ha llamado 00:30:49
porque ahora mismo con lo que tenemos aquí 00:30:50
yo llego a este punto y yo aquí por código 00:30:53
no tengo información de quien me ha llamado 00:30:55
no la tengo 00:30:57
no, vale 00:30:59
entonces, que podemos 00:31:01
hacer, pues bueno 00:31:03
a estos métodos de 00:31:05
evento, los que están anotados 00:31:07
con fxml 00:31:09
y que luego está en el onAction 00:31:10
en el onDrag, en no sé qué 00:31:12
se les puede pasar opcionalmente 00:31:14
si uno quiere, opcionalmente 00:31:16
un objeto que se llama 00:31:18
de muchas formas posibles 00:31:20
ActionEvent, MouseEvent, KeyEvent 00:31:22
ahora vemos, pero 00:31:24
el por defecto es ActionEvent, me explico 00:31:25
vamos a comentar estos 00:31:28
estos que son mucha duplicidad 00:31:30
de código, estos no me gustan 00:31:32
están duplicando 00:31:35
código, voy a hacer uno solo 00:31:36
voy a hacer uno solo 00:31:38
pues venga, vamos a hacer uno solo 00:31:39
venga, pues ese solo 00:31:42
fxml 00:31:45
que se llame por ejemplo 00:31:49
public void 00:31:51
botón 00:31:53
operación 00:31:55
es decir, este va a ser 00:31:56
el evento que va a responder 00:31:59
a pulsar cualquier botón 00:32:01
operación, me da igual cual sea 00:32:03
vale, entonces vamos a abrir 00:32:05
otra vez el modelo 00:32:07
vale, pues entonces ese evento que yo estoy 00:32:09
haciendo que responda 00:32:15
tanto al más como al menos 00:32:18
porque total el código es casi igual 00:32:20
entonces si el código es 00:32:22
casi igual que me responda tanto al más 00:32:24
como al menos 00:32:26
pues venga voy a cambiar 00:32:27
en el onAction del más 00:32:29
ahora ya no quiero que sea botón suma 00:32:31
sino botón 00:32:33
operación 00:32:34
botón operación 00:32:37
y en el menos igual 00:32:38
botón operación 00:32:41
los dos el mismo 00:32:44
total, son prácticamente iguales 00:32:45
vale, pues si lo he escrito bien 00:32:50
ahora ya 00:32:52
sea cual sea el botón que yo dé 00:32:53
sea más o sea menos 00:32:55
las librerías de JavaFX 00:32:56
me enchufan aquí 00:32:59
vale, pues ahora vamos 00:33:00
¿qué hay que hacer? 00:33:03
pues que hay que hacer, fijar el primero operando 00:33:05
eso me da igual el botón 00:33:07
que haya pulsado, me da exactamente igual 00:33:12
haya pulsado el más, el menos 00:33:13
esto hay que hacerlo, fijar el primero operando 00:33:15
ahora ya que me pongo 00:33:17
limpiar la ventana 00:33:20
perdón, el área de texto 00:33:22
limpiarla, eso los dos, da igual el que lo haga 00:33:23
y ahora es cuando me viene el problema 00:33:26
y ahora la sentencia 00:33:28
que me falta es op igual 00:33:30
a qué 00:33:32
pues es que no lo sé 00:33:34
depende como haya llegado yo hasta aquí 00:33:36
si yo he llegado hasta aquí habiendo pulsado 00:33:38
el más, esto sería 00:33:40
un más, pero si yo he llegado 00:33:42
hasta aquí habiendo pulsado el menos 00:33:44
que es otro control distinto, esto sería un menos 00:33:46
con lo cual no sé qué poner aquí, aquí hay un if 00:33:49
si te pulso más pon más, si te pulso menos 00:33:52
pon menos, claro, ¿cómo puedo saber yo 00:33:55
quién me ha pulsado para ponerlo en el if? 00:33:58
no tengo ni idea, bueno pues puedo saberlo 00:34:01
porque los métodos de controlador pueden recibir 00:34:03
si yo quiero y si me da la gana 00:34:07
un objeto de tipo action event 00:34:09
de JavaFX, cuidado, recordad que os ofrece siempre las dos 00:34:12
no importéis la que no es 00:34:21
y este objeto diréis vosotros 00:34:23
y este objeto quien lo genera, quien lo aparece 00:34:26
recordad que a este método no lo llamáis vosotros por código 00:34:28
a este método lo llama automáticamente 00:34:31
la librería de JavaFX cuando un humano 00:34:34
o una máquina hace pum 00:34:37
entonces las librerías de JavaFX 00:34:40
cuando detectan que se ha pulsado el botón 00:34:43
construyen ellas un objeto Action Event 00:34:46
con toda la información del control que ha sido accionado 00:34:49
lo construyen ellas 00:34:53
ellas van al método de evento 00:34:55
que es este 00:34:57
y le pasan ese objeto 00:34:59
luego ese objeto 00:35:00
lo construye automáticamente JavaFX 00:35:02
cuando detecta que se ha accionado un control 00:35:05
lo construye empaquetando dentro mucha información 00:35:07
relacionada con el control que ha recibido la acción 00:35:11
y se lo pasa a este método 00:35:14
botón operación para que se ejecute 00:35:17
bueno, pues entonces yo puedo, si yo habilito 00:35:19
la recepción de ese objeto, que no es obligatorio 00:35:23
puedo no habilitarla, aquí por ejemplo no he habilitado 00:35:26
la recepción de ese objeto, lo va a crear igual 00:35:29
la interfaz, pero cuando llame al método 00:35:32
no se lo va a pasar, pero aquí si lo he habilitado 00:35:35
entonces cuando java.fx cree ese objeto 00:35:37
como resultado de haber hecho el click 00:35:40
va a llamar al método y además le va a pasar 00:35:42
el objeto, bueno pues de este objeto 00:35:44
nosotros podemos sacar mucha información 00:35:46
si uno hace . aquí tiene para aburrir 00:35:48
entre otras 00:35:50
cosas tiene 00:35:52
getSource y getSource 00:35:54
te dice quien generó 00:35:56
el evento 00:35:58
entonces yo aquí puedo hacer 00:35:59
oye, si 00:36:02
e.getSource 00:36:06
podría poner 00:36:10
es igual 00:36:12
al botón suma 00:36:14
tengo un pequeño problema 00:36:17
que no le he dado referencia al botón suma 00:36:18
porque hasta ahora no lo necesitaba 00:36:21
bueno, podría solucionarlo 00:36:22
y poner aquí 00:36:25
el botón suma fxml 00:36:27
con un nombrecito y habilitarlo aquí 00:36:29
el botón suma en fxid 00:36:31
darle un nombrecito 00:36:33
aquí en encode 00:36:35
vale 00:36:37
podría hacer eso 00:36:38
pero ni siquiera necesito meter tanta 00:36:40
morraya, porque 00:36:43
puedo decir, oye, si el botón que me llamó 00:36:44
voy a sacar de él, por ejemplo 00:36:47
el texto que tiene puesto 00:36:49
por ejemplo, e.getSource 00:36:50
que estoy aquí, es el 00:36:53
objeto que me ha llamado, es este 00:36:55
de este objeto a su vez 00:36:57
yo puedo sacar un montón de cosas 00:36:59
yo sé que es un botón 00:37:01
porque solamente puedo llegar a operación 00:37:02
con un botón, venga, pues le voy a 00:37:05
hacer un casting a button 00:37:07
Lo voy a guardar aparte fuera del if 00:37:08
Para que se vea más claro 00:37:14
Voy a sacar el botón que me llamó 00:37:15
Botón, botón pulsado 00:37:18
El botón pulsado 00:37:21
Es este 00:37:22
E.get source 00:37:23
Este es el botón pulsado 00:37:27
Tengo que hacer el casting 00:37:30
A, bueno primero importarlo 00:37:32
Y luego hacer el casting 00:37:34
Este es un casting controlado, no hay que temerle 00:37:35
Porque yo sé que a botón operación 00:37:41
solo voy a llegar 00:37:43
si he pulsado este o este, solo 00:37:45
porque son los únicos controles que tienen puesto aquí 00:37:47
botón operación, los únicos 00:37:49
entonces este es un casting necesario, imprescindible 00:37:50
pero controlado 00:37:54
vale, es el botón pulsado 00:37:55
y ahora, yo ahora ya podría 00:37:57
hacer, if botón pulsado 00:38:00
equals 00:38:02
el botón suma 00:38:07
repito, pero 00:38:11
claro, tendría que tener yo botón 00:38:13
suma, habilitado 00:38:15
como referencia aquí arriba 00:38:17
tendría que tenerlo habilitado como referencia 00:38:18
aquí arriba, no pasa nada, lo puedo habilitar 00:38:21
como referencia aquí arriba, igual que habilite 00:38:23
el text fill, igual, lo puedo 00:38:25
habilitar y entonces no se 00:38:27
me olvida aquí ponerle 00:38:29
su fxid 00:38:31
aquí 00:38:33
pero ni siquiera me hace falta 00:38:33
ni siquiera me hace falta pringarme tanto 00:38:36
digo, oye 00:38:38
si el botón que has pulsado 00:38:40
el texto que 00:38:43
tiene encima, porque el botón tiene aquí 00:38:45
un montón de métodos para sacar cosas sobre él 00:38:47
pues por ejemplo 00:38:49
tiene un gettest 00:38:50
tiene un gettest que te saca el texto que tiene 00:38:52
pues si el texto que tiene encima 00:38:54
resulta que es 00:38:57
igual a más 00:38:59
ala 00:39:00
pues ya tienes lo que queríamos 00:39:03
que es igual a más, pues ya está 00:39:04
operación entonces 00:39:09
igual a más 00:39:11
y si no, operación 00:39:12
igual a menos, tiene que ser el otro 00:39:18
porque solo hay dos que respondan con eso 00:39:19
el, a ver, botón 00:39:21
hasta aquí 00:39:31
a ver, entiendes 00:39:33
que este objeto, esta referencia 00:39:35
es una referencia directamente 00:39:37
al botón que ha sido pulsado 00:39:39
o sea, esta línea sí, ¿no? 00:39:40
vale, pues ese objeto botón es un objeto 00:39:43
que tiene propiedades, muchas cosas 00:39:45
entre ellas, una de las 00:39:47
propiedades que caracterizan a botón 00:39:49
es el texto que tiene encima 00:39:51
que lo puedes sacar con el método 00:39:53
getTest 00:39:55
entonces tú si del objeto 00:39:56
button, claro, esa clase button tú no la has 00:39:58
hecho, entonces tú no sabes que tiene dentro 00:40:00
pero si tú buceas dentro del objeto 00:40:02
button, ves que tiene un montón de cosas 00:40:04
entre ellas un gettest que es justo 00:40:05
el texto que tiene encima post 00:40:08
claro 00:40:09
entonces si el botón pulsado tiene un más 00:40:11
encima, el texto 00:40:14
que tiene encima es este 00:40:16
de hecho 00:40:17
es que no nos hace falta 00:40:19
ni el if, podemos hacer 00:40:21
op igual a botón pulsado 00:40:24
punto get test, y ya está 00:40:26
tal y como lo hemos hecho, incluso 00:40:28
nos armaríamos, vale 00:40:30
pero en cualquier caso lo que me importa a mi 00:40:32
de todo esto es este objeto 00:40:34
y es que 00:40:36
el método que responde 00:40:38
al evento 00:40:40
a la acción sobre la interfaz 00:40:42
ese método puede opcionalmente 00:40:43
si yo lo habilito, recibir 00:40:46
un objeto con mucha información 00:40:48
de quien ha recibido 00:40:50
esa acción 00:40:52
¿vale? y ese objeto 00:40:53
con toda esa información de quien ha recibido 00:40:56
esa acción es este objeto E 00:40:58
y ese objeto E seguramente en muchas 00:40:59
situaciones me va a ser necesario 00:41:02
a mí usarlo aquí 00:41:04
en este caso me ha sido necesario 00:41:05
para juntar en un único 00:41:07
método las respuestas 00:41:10
a los dos botones y así no he tenido que 00:41:12
hacer un método por separado 00:41:14
¿vale? entonces el ActionEvent 00:41:15
es el objeto que se genera 00:41:21
en los métodos 00:41:23
que onAction, que son los que 00:41:25
estamos usando hasta ahora 00:41:27
los métodos onAction son los que 00:41:28
se ejecutan cuando se da 00:41:31
la acción por defecto 00:41:33
la de por defecto de un botón es 00:41:34
pulsar, la de por defecto de un 00:41:37
combo box es 00:41:39
pulsar, ya lo hemos comprobado, la de por defecto 00:41:41
de un text field sería 00:41:43
darle al enter, sería el onAction 00:41:45
también puede saltar algo 00:41:46
pero hay controles que no tienen onAction 00:41:47
no tienen acción por defecto 00:41:50
o podemos querer capturar en un control 00:41:52
otros eventos relacionados 00:41:55
con ratón, con teclado 00:41:57
entonces no sería el onAction 00:41:59
sería el onKeyPrest 00:42:01
onMouseDrag 00:42:03
un montón de métodos que hay 00:42:05
que el Steam Builder me ayuda porque me los muestra a todos 00:42:07
si yo capturo un evento 00:42:09
del tipo onKeyPrest, onKey no sé qué 00:42:11
este sería key event 00:42:13
no sería acción event 00:42:15
y si yo capturo 00:42:16
un evento del tipo 00:42:19
onMouseDrag, onMouseDroped 00:42:20
onMouse no sé qué, este sería mouse 00:42:23
event 00:42:25
y si yo capturo un evento del tipo 00:42:25
onDrag no sé qué, onDrag no sé cuánto 00:42:29
que también los hay, esto sería drag event 00:42:31
¿vale? 00:42:33
pero como estamos capturando 00:42:35
el onAction que es el por defecto 00:42:37
pues es action event el que se genera 00:42:39
¿vale? 00:42:42
entonces eso me permite 00:42:45
en este caso 00:42:47
agrupar varios métodos en uno 00:42:48
o me permite cosas mucho 00:42:51
más interesante. Es como si tengo 00:42:53
varias ventanas, 00:42:55
varios stages, 00:42:57
porque quiero 00:42:59
cerrar uno y abrir otro, quiero cerrar 00:43:01
una escena y abrir otra, pues 00:43:03
ese me permite navegando hacia 00:43:04
arriba, luego lo vemos, acceder a la ventana en la que 00:43:07
estoy, en la que ese control está. 00:43:09
Muchas cosas. 00:43:12
¿Vale? 00:43:14
Vamos a probar si funciona antes de 00:43:14
parar. 00:43:17
Vale, pues 00:43:28
12 más 00:43:29
12 igual a 24 00:43:31
la suma va 00:43:34
y 23 menos 00:43:36
2 igual a 21 00:43:38
vale 00:43:41
venga, vamos a parar aquí unos minutejos 00:43:42
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:
27 de abril de 2026 - 13:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
187.77 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid