Saltar navegación

20250306 - 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 6 de marzo de 2025 por Stefano C.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, estoy empezando la grabación y si habláis en clase me estáis autorizando a que quede recogido en dicha grabación. 00:00:00
Bueno, vamos a ver. 00:00:10
Bueno, el otro día empezamos hablando de que efectivamente hasta ahora todas las aplicaciones que estáis haciendo 00:00:14
y todos los programas y bueno, pues todo el código lo estáis enfocando a que los usuarios, pues os haré decir, 00:00:21
a la hora de interactuar con el usuario lo hagáis a través de un texto en una consola y bueno, pues eso puede ser eficiente 00:00:30
según qué proyectos, pero por lo general nosotros siempre vamos a intentar que el usuario pues tenga, bueno, 00:00:39
pues unos componentes y haya un diseño un poco más agradable y sobre todo más intuitivo para ellos 00:00:48
y que sea también más funcional, es decir, que puedan interactuar con nuestra aplicación 00:00:56
pues para meter datos, para mostrárselos, para ordenar la información, etc. 00:01:01
Entonces para eso pues hay una serie de formularios que suelen, 00:01:06
Porque casi todos los programas suelen estar con, o sea, suelen constar de formularios y de pantallas que tienen diferentes elementos, ¿no? 00:01:09
Que nos van o bien a mostrar o bien a recoger toda la información. 00:01:21
Sí. Bueno, y como os estaba contando, pues eso, hay una serie de elementos con los que, bueno, pues a través de la GUI, que, bueno, pues los usuarios van a poder interactuar con vuestro programa y vosotros también con ellos. Es una forma de comunicarnos mucho más accesible. 00:01:26
Bueno, estos son los objetivos de la unidad 00:01:51
Como bien decía antes 00:01:54
Estefano 00:01:57
GUI quiere decir Graphical User Interface 00:01:57
Interfaz de gráfica de usuario 00:02:01
Y bueno 00:02:05
Se supone que 00:02:06
Una de las ventajas es que es más intuitiva 00:02:10
Y accesible, como decía 00:02:12
Utiliza elementos gráficos como 00:02:13
Ventanas, botones y menús 00:02:16
Y están diseñadas para tareas interactivas y visuales. Interactivas quiere decir entre el usuario y la aplicación y el código que les demos. 00:02:20
Algunas de las desventajas es que obviamente es mucho más pesada y consume más memoria y el desarrollo es un poquito más complejo ya que hay que configurar también todo lo que es el diseño gráfico, que hasta ahora no lo hemos tenido que realizar. 00:02:32
Bueno, hablábamos de, bueno, recordad que estuvimos instalando, creo que lo tenéis todos instalado, el plugin Window Builder. ¿Tú lo tienes? Ah, lo instalaste ya. Ah, muy bien. Pues muchas gracias por instalárselo, porque así no perdemos tiempo ahora instalándolo. 00:02:50
Entonces, bueno, pues esto es un plugin con el que tenemos una serie de paquetes en el cual podemos diseñar interfaces gráficas y esto qué quiere decir, pues que tenemos un montón de elementos gráficos que se pueden ir arrastrando y soltando en nuestras plantillas y poder configurarlos. 00:03:10
Y bueno, se va a utilizar la biblioteca Swin, comentábamos que hay algunas más nuevas, más modernas, como JavaFX, pero estuvimos hablando de que Swin para el tema del aprendizaje era bastante más interesante, 00:03:35
ya que vais a poder, bueno, con ello vais a poder asimilar los conceptos de una manera mucho más clara 00:03:54
y luego os vais a poder adaptar a cualquier otra biblioteca, ya sea JavaFX o alguna que venga en un futuro próximo. 00:04:03
Luego, pues lo que decía, instalamos Windows Builder, recordad que algunos tuvieron, bueno, tuvieron, no tuvimos, 00:04:14
porque aquí no pudimos instalarlo, fue un rollo porque las versiones estaban, bueno, teníamos una versión antigua y entonces pues no encajaba bien el Windows Builder y bueno, hablamos también un poco de algunas de las clases y de los elementos que tiene Java Swing y con los que vamos a trabajar. 00:04:20
Uno era el JLabel, que sería como el label en el lenguaje de marcas, es decir, en HTML y demás, JButton, JTextField, que serían los campos de texto, el JTextArea, el JCheckBox, el JRadioButton, 00:04:43
De hecho, luego pusimos algún ejemplo con RadioButton en el que algunos consiguieron poder capturar, bueno, poder replicar lo que es la funcionalidad de hacer tan solo una selección de todos los elementos que mostremos en el RadioButton. 00:05:01
El JList, que son las listas donde vamos a poder mostrar un montón de elementos. 00:05:19
Y el JScrollBar, que serían las barras de desplazamiento. 00:05:28
Al igual que hay estas, hay muchísimas más. Hicimos un ejemplo automático con Jpanel y bueno, no sé si normalmente en los repasos abrís el... 00:05:30
Sí, lo tengo por aquí. Y aquí yo creo que tuvimos los ejemplos. Sí, bueno, pues aquí teníamos algunos ejemplos y bueno, pues aquí en la presentación podéis ver que hay un código en el cual, bueno, pues está explicado un poquito, bueno, pues como aquí, por ejemplo, creamos la clase ventana del tipo JFrame. 00:05:47
Para eso, recordad que lo que teníamos que hacer era irnos, por ejemplo, aquí, le dábamos a New y una vez ya le teníamos instalado el Window Builder, le dábamos a Other y aquí teníamos diferentes opciones, ¿vale? Podíamos abrirlo con el Application Window y el JFrame. 00:06:41
Yo os recomiendo que normalmente lo abráis con JFrame porque ya directamente hereda de ahí y ya, bueno, pues es directamente abrir una, lo que sería una ventana. Los JFrames son ventanas, ¿vale? Y, bueno, pues, por ejemplo, podríamos crear uno para que se vea. 00:07:02
Como podéis ver, se nos ha creado el ejercicio 1, el ejemplo 1, extiende de JFrame y nos crea un main y un constructor de lo que es el ejemplo número 1 de lo que hemos creado. 00:07:18
Aquí, si os fijáis, se crea la ventana frame como nueva ventana, etcétera, etcétera, etcétera, dentro de lo que es el main. 00:07:46
El constructor sería este, en el cual viene los setbounds, que aquí lo podéis ver. Setbounds hacía referencia, si recordáis, un poco al posicionamiento de los elementos. 00:07:55
Siempre, cada vez que colocamos un botón, una ventana, un panel, una lista, cualquiera de los elementos van a tener unas coordenadas dentro de lo que es el contenedor donde lo pongamos. 00:08:08
Entonces el primer número haría referencia a la coordenada X, el segundo a la coordenada Y, el tercero al alto y el cuarto al ancho. 00:08:23
Vale, como bien os comentaba antes, la parte de fuera, lo que sería la ventana, sería el JFrame y luego dentro se crea un JPanel, que es el contenedor donde nosotros vamos a trabajar y donde vamos a poner todos los elementos. 00:08:34
recordad que en todo momento yo a veces me refería al panel principal o al contenedor 00:08:58
principal es indiferente es decir tanto uno como otro son terminologías que se aplican a los dos 00:09:05
y es digamos nuestra bueno pues como si tuviéramos un corcho en la pared donde vamos poniéndole cosas 00:09:11
no pues sería el corcho digamos y el jota frame igual sería la pared entonces nosotros para poner 00:09:18
una nota no lo vamos a poner en la pared con una chincheta lo pondremos en el corcho no pues el 00:09:24
corcho es nuestro contenedor o nuestro panel vale cuando intentamos añadir cualquier elemento al 00:09:32
panel principal nos dábamos cuenta que ya estaba conformado con una estructura un tanto extraña 00:09:42
que se trata de, bueno, que realmente esa estructura es lo que se llama layout o lo que entenderíamos en castellano como plantilla, ¿vale? 00:09:50
Entonces, para quitarlo y poder tenerlo de una manera más liberada, vamos a abrir el diseño, vale. 00:10:00
Si tenemos aquí el panel, el Jpanel, siempre un inciso, siempre que pulsamos sobre alguno de los elementos que tenemos aquí, aquí a la izquierda, a continuación tenemos el properties y entonces aquí hay una serie de propiedades que siempre se van a poder modificar. 00:10:11
O bien a través de esta paleta de propiedades, properties, o bien a través del código. Pero es muy útil el poder utilizar estas propiedades para cambiar. Como bien os decía antes y os mostraba en la presentación, cada vez que vamos a intentar colocar algún elemento, nos va a aparecer esta estructura, ¿vale? 00:10:33
que es la que viene por defecto, que sería el flow layout, entonces si vamos a ir por ejemplo a poner un botón, a la hora de ir a soltarlo y ponerlo, nosotros si lo ponemos, pues se ha quedado, vale, porque lo tengo yo así puesto, disculpad que esto supone que está el flow layout, a ver, un segundito, pues debería estar mostrándome todo el, el, 00:10:58
Vamos a añadir otro. 00:11:39
Ah, vale, porque está puesto como flow layout. 00:11:45
Y el que tenía que estar por defecto era el border layout, 00:11:47
yo creo, el que estaba puesto ayer por... 00:12:01
Ah, sí. 00:12:05
Entonces ahora ya sí vamos con... 00:12:06
Ah, esto es lo que os comentaba. 00:12:07
Entonces está normalmente ayer la que nos salía por defecto. 00:12:09
No sé por qué hoy está saliendo el border layout. 00:12:12
O sea, está saliendo el flow layout cuando ayer nos mostraba 00:12:15
el border layout, da igual 00:12:18
la cuestión es que siempre vais a tener una serie de plantillas 00:12:21
y son como plantillas ya preestablecidas 00:12:26
para que coloquéis los elementos 00:12:30
recordad que estuvimos mirando el grid layout, que era como tablas 00:12:34
para poder colocar todos los elementos, incluso estuvisteis 00:12:37
metiendo botones 00:12:42
en las celdas de la misma tabla del grid y bueno pues el recordar siempre que podemos poner el 00:12:43
absolute y entonces esto nos permite nos permite poder moverlo por donde queramos 00:12:54
y podemos poner un combo box y lo ponemos aquí podemos colocar donde queramos vale 00:13:05
Es decir, los elementos ahora se pueden mover a donde queramos. Si os fijáis aquí, cuando ponemos el combo box, aquí salen también otra serie de propiedades que son completamente diferentes a las que tiene NewButton. 00:13:12
Bueno, habrá una en común y otras que no, pero cada elemento es un objeto y cada objeto, pues como bien sabéis, es un objeto de una clase y tiene una serie de propiedades que le hacen ser único e individual. 00:13:29
Entonces, vamos a pasar aquí y continuamos. Hablábamos de colocar la plantilla en absolute para poder ser libres, que es lo que os acabo de contar. 00:13:45
hablábamos también de que automáticamente cuando hemos cambiado antes al layout en absolute si nos 00:14:00
vamos al código aquí va aquí porque con con esto tan grande yo no lo veo bien a ver dónde estás 00:14:12
A ver, a ver, a ver, ¿dónde estás? Aquí podemos ver que el content panel, que es el contenedor, el panel principal que tenemos, nos pone el layout a null. Este es el absoluto. Si lo cambiáramos a otro tipo, comentábamos que ahí automáticamente se actualiza. 00:14:19
Es decir, si lo ponemos en FlowLayout, nos vamos ahora al código y aquí tenemos SetLayout y es un New FlowLayout, ¿de acuerdo? Y nos viene con una serie de propiedades ya establecidas, si modificáramos en el diseño esas propiedades, automáticamente se va a modificar en el código, ¿vale? 00:14:43
Al igual que nos pasa esto con el panel, tener siempre claro que esto nos pasa cuando modificamos cualquier botón, cuando añadimos cualquier cosa, cuando le cambiamos una propiedad, un nombre, un tamaño, una ubicación, automáticamente se va a actualizar en el código. 00:15:07
Eso nos pone las cosas muy fáciles porque al final no tenemos que andar nosotros codificando toda esa información que a veces es muy complicado. Sobre todo el tema de coordenadas y demás. 00:15:25
Mira, aquí de lo que estábamos hablando es eso 00:15:38
Aquí no tenemos, aquí si quitamos el botón 00:15:53
Obviamente cuando lo añadimos 00:15:56
Aquí, vale, nos vamos al código 00:15:59
Y aquí tenemos el botón 00:16:03
Ya nos han hecho directamente la instancia del nuevo botón 00:16:06
y nos lo ha incluido dentro del content panel, es decir, dentro del panel principal, ¿vale? 00:16:11
Es decir, lo que vamos haciendo en diseño se va haciendo siempre, que se os quede esa idea, 00:16:18
se va haciendo paralelo en el código. 00:16:22
También hay que tener siempre mucho, o sea, hay que tenerlo muy en cuenta 00:16:25
para que nuestro código, si lo escribimos a mano, no se contradiga con cosas 00:16:29
que estamos configurando con la parte de diseño. 00:16:34
añadíamos un container secundario o un panel secundario también en uno de los ejemplos y en 00:16:38
este en este panel bueno aquí veíamos que se creaba y demás y añadíamos un elemento a ese 00:16:51
panel bueno cuando nosotros añadíamos ese elemento a ese panel secundario realmente se estaba añadiendo 00:16:59
al panel secundario en el código, no se estaba añadiendo al panel principal. 00:17:07
Es decir, se crea como una especie de herencia de tenemos el, es como si en el corcho 00:17:12
que estábamos poniendo antes como ejemplo, ponemos otro corcho dentro 00:17:16
y entonces pinchamos dentro de ese corcho. 00:17:21
Es decir, en función de la posición en la que estén, van a pertenecer a un panel o a otro. 00:17:23
Esto es importante sobre todo para agrupar los componentes y los elementos que añadamos a nuestro formulario por el significado que puedan tener o el sentido que puedan tener para el usuario. 00:17:30
Es decir, puede ser por un lado datos de usuario en el cual tenemos nombre, apellidos, DNI, bla, bla, bla, bla, fecha de nacimiento y en otra podemos tener otro panel en el que venga una lista con gustos musicales o aficiones o lo que sea. 00:17:45
Y otra con, bueno, no sé, pues unos datos de matrícula, por ejemplo, ¿no? Entonces, podríamos dividir un mismo container principal, pues a lo mejor en tres zonas. Uno, aficiones, datos personales y datos de matrícula, ¿vale? Es decir, esa es un poco la gracia de poder agrupar todo en paneles y en zonas diferentes. 00:18:02
Vale, vale, vale, vale, hablábamos también de que para recoger el, bueno, con algunas propiedades, algunos métodos de los elementos se pueden recoger algunos datos, por ejemplo, hablábamos del text field, que para recoger el contenido de lo que haya escrito el usuario, pues simplemente con un set text, pues ya, o sea, con un get text, 00:18:26
ya lo obtendríamos. Aquí lo tenemos, ¿ves? Con el GetText. Voy a poner un ejemplo. Si, por ejemplo, ponemos un JTextField, ¿vale? 00:19:01
Y vamos a poner un JTextField. Y entonces, perdón, si nosotros queremos recoger el contenido del JTextField, aquí lo tenemos, 00:19:17
simplemente creando una, hablábamos de que, vamos a ver, este que le llama así, se llama, nuestra caja de texto se llama text field, 00:19:32
tenemos una propiedad que es get text y aquí nos podemos fijar que lo que nos va a dar es un string, lo que va a coger de esa caja de texto. 00:19:49
Entonces, por ejemplo, esto lo podríamos recoger con una variable de triple string. 00:20:03
Por ejemplo, nombre. 00:20:10
Vale, con esto podríamos recoger el nombre. 00:20:16
Esto va a ser útil, sobre todo este tipo de cosas, con el getText, setText, etc. 00:20:18
Con los eventos, que va a ser algo que vamos a empezar a ver ahora 00:20:24
y que es realmente la funcionalidad potente de todo esto. 00:20:31
porque el tener una serie de elementos con los que puede interactuar el usuario está muy bien, 00:20:34
pero si el usuario no interactúa realmente con ese formulario, no nos vale absolutamente para nada. 00:20:41
Entonces, es un poco lo que vamos a ver ahora a continuación. 00:20:46
Veíamos un poco la jerarquía de clases también, en la cual, pues como siempre, hereda de object, 00:20:51
y luego dentro de container pues podríamos encontrar tanto j component que son todos los 00:20:56
elementos que podemos añadir a un panel como el window que serían los frames y los diálogos es 00:21:03
decir los lugares donde podemos ubicar los recordar que el jota frame son las ventanas 00:21:11
Es decir, sería JFrame siempre son estas, estos principales, la parte de fuera. 00:21:18
Y si os fijáis, esto va por un lado y no tiene nada que ver con los componentes que ya estarían dentro. 00:21:27
De hecho, tenemos aquí el JPanel que a su vez puede recoger JTex, JComboBox, etc. 00:21:33
Hablamos también de los layouts. Estuvimos mirando que las plantillas pueden ser diferentes. 00:21:41
Como os decía antes, puede ser tipo FlowLayout, que nos pone todos los botones o todos los elementos, nos los pone en fila, o sea, todos seguidos. 00:21:48
Puede ser en modo Grid, el GridLayout, que lo que nos hace es colocar una tabla con diferentes celdas y entonces dentro se ubican todos los elementos. 00:21:59
Y, bueno, pues hasta aquí un poco el repaso. No sé si hay alguna duda así a priori que surgiera el otro día con los ejemplos que vimos. ¿Me dais permiso para continuar con los eventos? 00:22:11
Bueno, pues bueno, como podréis imaginar, los eventos es un poco, se trata de la interacción que va a tener el usuario con respecto al programa 00:22:28
que le estamos mostrando y que le hemos desarrollado, ¿no? 00:22:41
Entonces, tened en cuenta que siempre el usuario va a tener que o bien obtener información o bien aportársela a nuestro programa 00:22:46
para que toda esa información se pueda luego procesar. 00:22:55
Todo esto, como ellos tienen una serie de elementos con los que pueden interactuar, 00:23:04
pues todos esos elementos se van a manejar con eventos. 00:23:15
Es decir, nosotros si pulsa un botón tenemos que controlar esa pulsación del botón. 00:23:19
Y a esto le vamos a llamar evento. Entonces, bueno, como bien decía, pues eso, el usuario realiza las acciones que generaría este evento. Esto podría ser pulsar un botón, por ejemplo, o seleccionar un objeto de una lista o seleccionar un radio button, marcar unos checks. 00:23:25
Es decir, en función de lo que queramos hacer, el evento será de una manera o de otra. 00:23:49
Todos estos componentes han de permanecer atentos o estar a la espera. 00:23:55
Es decir, esto, ¿qué quiere decir realmente? 00:24:03
Pues quiere decir que nosotros ya lo tenemos configurado esperando, o sea, es decir, si ponemos un botón, efectivamente tendremos que ponerle una serie de acciones. 00:24:06
se van a tener que realizar una serie de acciones una vez nosotros pulsemos ese botón 00:24:15
pues el preparar el programa para que eso suceda 00:24:22
es por eso que queremos llamarlo permanecer atento o estar a la espera 00:24:29
es decir, prepararlo para que cuando ese botón se pulse 00:24:35
efectivamente todo ese todo ese código se pueda procesar y pueda funcionar y luego una vez ya se 00:24:40
ha procesado pues lo suyo es que le mandemos alguna respuesta al usuario pues eso con el 00:24:49
resultado de su acción pues si un botón directamente lo que hace es guardarnos un 00:24:57
elemento en una lista pues a lo mejor mandarle un mensaje de elemento guardado en la lista 00:25:04
Por ejemplo, cuando hacéis una compra en internet y añadís un elemento al carrito de la compra, normalmente el carrito de la compra se actualiza y pone un número o pone un dos para que podáis pulsar y podáis ver. 00:25:10
Bueno, pues eso sería el evento de pulsar en el producto que queréis, por detrás va a recoger esa petición de ese elemento, lo va a tratar, lo va a meter en la lista del carrito de la compra y la respuesta a ese procesamiento va a ser que va a aparecer al usuario, le va a aparecer el carrito de la compra con el 1, el 2 o los productos que se hayan añadido. 00:25:24
Bueno, para recibirlos y para controlar, cuando hablamos de recibir y de escuchar, para controlar todos los eventos que se producen en estos elementos, tenemos una serie de interfaces que se llaman Listener, ¿vale? 00:25:56
Todos los elementos, si queremos trabajar con ellos, con lo que son las acciones que pueden hacer, siempre lo vamos a tener que hacer a través de un Listener. 00:26:14
Bueno, están incluidas en el paquete Java AVT Event 00:26:24
Y bueno, hay que importar el paquete 00:26:32
Import Java AVT Event 00:26:36
Tenemos la interfaz ActionListener 00:26:40
Que va a ser la que nosotros podemos implementar también en nuestra 00:26:48
O sea, la que vamos a tener que implementar en nuestro código y en nuestras clases 00:26:52
para que podamos recoger todos estos eventos. 00:26:57
Ahora vamos a ver un ejemplito y lo vais a ver más claro, 00:27:02
aunque suene así todo un poco abstracto y un poco raro. 00:27:04
Y cuando hacemos referencia al ActionListener, 00:27:08
automáticamente se nos va a crear el método ActionPerform. 00:27:12
Dentro de este ActionPerform, 00:27:23
perform, que querría decir algo así como la acción ejecutada o algo así, pues ahí es donde nosotros vamos a trabajar con lo que se hace una vez se ha recogido 00:27:25
esa acción por parte del usuario. Vamos a ver un ejemplito. Por ejemplo, si nosotros ahora mismo, vamos a quitar esto de aquí, si nosotros por ejemplo 00:27:37
Añadimos un botón. Si nosotros hacemos doble clic sobre el botón, automáticamente se nos ha generado, si os fijáis, dentro del New Button que teníamos nosotros, 00:27:54
Nos ha añadido el ActionListener, con sustancia, y se nos genera el propio método ActionPerform, ¿ok? 00:28:17
Entonces, si nosotros, muchas gracias por el apunto, la verdad que me viene muy bien, yo si todo lo que queráis aportar, igual que ha hecho el alumno Estefano, vuestro compañero, pues podéis aportar todo lo que queráis, ¿vale? 00:28:34
Entonces, por ejemplo, hemos dicho que aquí dentro de lo que era la acción perform es donde nosotros realmente vamos a poder, bueno, pues recoger cualquier tipo de acción, ¿vale? 00:29:36
Por ejemplo, si queremos que cuando pulsemos al botón, aquí en el ejemplo lo he puesto como aquí, por ejemplo, le vamos a poner al botón, le vamos a llamar aceptar. 00:29:54
Vais a ver que al cambiar estas propiedades se cambian automáticamente en nuestro código, ¿vale? 00:30:12
Ahora lo vais a ver, ¿vale? 00:30:20
Entonces ya se queda como tal. 00:30:29
Entonces, si os fijáis, ahora ya el botón es el botón aceptar 00:30:30
Nos ha cambiado en todas partes, es decir, directamente hace lo que sería el refactor y el rename 00:30:38
Cuando hemos cambiado, es decir, lo hace automáticamente, no tendríamos que 00:30:46
Es decir, cuando queréis cambiar el nombre de un elemento, el código lo va a actualizar 00:30:49
Y, por ejemplo, vamos a hacer que, uy, vale, y aquí porque no sale, ah, vale, que es SISO, ¿cómo es el, eh, system? A ver, ¿me lo recordáis alguno que mando yo siempre .out, .println? 00:30:56
Y aquí, por ejemplo, vamos a poner como, vale, aceptar, ¿vale? Entonces, si ejecutamos, si le damos al aceptar, automáticamente nos está mostrando el mensaje de aceptar pulsado, ¿vale? 00:31:22
Entonces, a ver, a ver, voy a parar un momentito. Ahora, por ejemplo, vamos a añadir otro botón y vamos a hacer exactamente lo mismo, ¿vale? Si podéis ir haciéndolo conmigo también, ir añadiendolo y le vais a poner el nombre de cancelar, el nombre de cancelar, ¿vale? Al botón. 00:32:00
Ahora una vez ya lo tenéis creado el botón, le hacéis doble clic y efectivamente se os ha generado el mismo código con la clase anónima y con el action perform dentro. 00:32:32
entonces vamos a coger el mensaje de antes, lo vamos a poner aquí, pero con cancelar pulsado, vale, lo ejecutamos y entonces cuando pulsamos aceptar aparece aceptar pulsado 00:33:18
y cuando pulsamos cancelar, aparece cancelar pulsado, ¿vale? Estos mismos, si os fijáis, aquí los tenéis los dos, los que hemos creado, tanto el de aceptar y el de cancelar, ¿vale? 00:33:45
Y ahora lo que vamos a hacer, para no tener que andar, porque vamos a poner que tenemos muchísimos elementos dentro de nuestro formulario. 00:34:10
Y nosotros realmente, ¿qué queremos? Queremos, como decir, que cada evento se recoja con un método o tener un método que en función del tipo de elemento y demás, pues nos vaya mostrando diferentes opciones. 00:34:25
Pues vamos a hacerlo de la siguiente manera. Como bien hablábamos antes, oye, estaba comentando, estaba comentando Estefano, nosotros directamente podemos extender lo que es el, nuestra clase, la podemos extender directamente al, al, o sea, podemos, pero oye, esto yo, podemos implementar la interfaz ActionListener, ¿ok? 00:34:48
Entonces, con esto, si la implementamos, vamos a poder... 00:35:15
Si os fijáis, aquí nos está dando un error. 00:35:24
Entonces cuando nos ponemos está diciendo que le hacen falta unos métodos que no están implementados todavía. Entonces le vamos a dar a implementar y como veis ya no nos muestra el error y aquí abajo nos ha generado un action perform. 00:35:49
¿Vale? Que si recordáis, nosotros aquí por cada elemento, cuando lo hemos pulsado, hemos hecho doble clic, nos ha generado esta clase anónima con el action perform dentro, ¿vale? 00:36:11
Entonces ahora esto ya, esto lo vamos a copiar por tenerlo, ¿vale? Lo voy a dejar aquí de momento para luego tenerlo, pero digamos que esto ya no nos va a servir de momento. 00:36:25
Ahora lo que queremos es controlar cuándo estamos manejando el evento del botón aceptar o cuándo estamos manejando el evento del botón cancelar, ¿verdad? 00:36:39
Entonces, lo que vamos a hacer es eliminar el cancelar. 00:36:50
Estoy eliminando... 00:36:56
Este no, aquí. 00:36:58
Cancelamos el código que nos ha generado antes. 00:37:00
Está aquí al inicio. 00:37:06
Perdona que voy un poquito mal con este teclado, que no lo conozco. 00:37:08
Y aquí igual. Del botón aceptar, el código que se nos ha generado, lo eliminamos. Si os fijáis, ¿ves? Hay que eliminarlo, que bueno, lo he puesto en los apuntes un poco para que sigáis ese procedimiento, ¿vale? 00:37:11
vale entonces como estábamos hablando se nos implementa este este método abstracto de que 00:37:32
se llama acción perform vale para nos segundo nosotros ahora dentro de lo que son cada botón 00:37:41
es decir para nosotros relacionar este botón aceptar y este botón cancelar con el acción 00:37:56
perform con este de aquí vamos a tener que hacer lo siguiente fijáis aquí le hemos dado al ad 00:38:03
acción listener entonces entonces que le estamos diciendo que le estamos diciendo que utilice un 00:38:24
un ActionListener, ¿vale? Y que acuda al ActionPerform. 00:38:40
Entonces, aquí en este null, lo que le marcamos, es decir, los parámetros del ActionListener, 00:38:46
lo que le tenemos que marcar es el elemento que queremos mandarle. 00:38:54
En este caso, es el propio botón aceptar. Entonces, le haríamos un Dish, ¿de acuerdo? 00:38:56
De hecho, si nosotros queremos hacer algo así y le ponemos aquí aceptar, ya con este código debería funcionar. 00:39:02
Si nosotros le damos a aceptar, nos viene el aceptar pulsado, es decir, ya está funcionando, ¿vale? 00:39:18
Pero nosotros hemos dicho que lo que queríamos realmente era controlar cuando pulsamos el aceptar y cuando pulsamos el cancelar, ¿no? 00:39:24
y que todo esté funcionando dentro de la acción perform muy bien pues para eso tendríamos que lo 00:39:32
primero darle aquí al botón cancelar hacer lo mismo hacerle acción listener igual le vamos a 00:39:38
poner el dis porque queremos que sea el evento de este mismo de este mismo botón el que nosotros 00:39:53
estemos mandando al perform ok entonces una vez tenemos esto nosotros ahora tenemos que 00:40:01
aprender a distinguir cuando estamos llamando a un botón oa otro botón entonces para ello si 00:40:09
os fijáis aquí donde lo tengo hemos utilizado esta podemos obtener el get source del evento 00:40:18
es decir, del objeto que está del tipo action event, es decir, el evento, de qué tipo de objeto es. 00:40:34
Y entonces nosotros aquí le ponemos source y aquí le podemos poner, por ejemplo, el botón, o sea, no, aquí sería el equals y le ponemos el botón. 00:40:43
¿Vale? Aquí nos está dando un error, que ahora veremos por qué es, y a ver si alguien sabe por qué está dando este error. ¿Vale? ¿De acuerdo? Cerramos paréntesis, pero sigue dando error. ¿Por qué? 00:41:06
efectivamente es decir nosotros el botón aceptar cuando lo tenemos aquí creado lo tenemos como lo 00:41:31
tenemos aquí en jota button pero es el es del constructor pero no está fuera entonces tendríamos 00:41:50
que aquí arriba donde tenemos private jota panel puedes crearlo ahí vale estamos aquí le quitaríamos 00:41:57
el tipo aceptar y aquí al botón cancelar igual vale entonces lo vamos a crear aquí 00:42:08
un botón y hemos dicho que era vete 00:42:28
n aceptar y aquí cancelar, vale, entonces ahora si os fijáis aquí abajo ya nos lo permite, vale, 00:42:34
entonces aquí por ejemplo lo que estamos queriendo decir es que efectivamente si el evento que está llegando 00:43:07
es de este tipo, del tipo botón, botón aceptar 00:43:17
que le hemos dado antes, entonces, haznos lo siguiente, y si no 00:43:22
save, source, punto equals 00:43:25
y botón cancelar 00:43:39
vale, y le ponemos 00:43:43
cancelar pulsado, bueno, pues con esto, más o menos se entiende este código 00:44:07
¿sí? vale, pues 00:44:17
cuando lo generamos 00:44:20
vale, si pulsamos aceptar 00:44:22
nos pone aceptar pulsado 00:44:27
y si pulsamos cancelar 00:44:28
nos mostraría 00:44:30
el mensaje de cancelar pulsado 00:44:33
vale, entonces esto está muy bien 00:44:35
que nos muestre 00:44:37
todo este tipo de resultados, que nos lo muestre 00:44:37
por consola, pero 00:44:41
estaremos de acuerdo que para el usuario es un poco 00:44:42
cutre, no, esto no es 00:44:45
no sé 00:44:47
decirle has comprado esto 00:44:48
y ponérselo ahí en un texto 00:44:50
estaría bien poder actualizar o poder hacerlo a través de otro elemento 00:44:51
que tengamos en nuestro formulario, por ejemplo un label 00:44:57
y que muestre ese mismo mensajito 00:45:00
entonces si os parece vamos a ponerle un label 00:45:02
esto lo voy a dejar porque es bastante sencillo 00:45:05
entonces lo que quiero es que ahora mismo pongáis un label aquí 00:45:11
y en lugar de mostrarme el código, donde tengo yo el código, aquí 00:45:16
en lugar de mostrármelo con el System.out.println, quiero que me lo pongáis en la propiedad text del label, ¿vale? 00:45:23
Así es que nada, pegaros un poquito con esto que es muy sencillito, y ahora lo vemos si queréis. 00:45:38
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Autor/es:
Raúl López
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
8
Fecha:
6 de marzo de 2025 - 14:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
45′ 54″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
143.16 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid