Saltar navegación

20250304 GUI_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 8 de marzo de 2025 por Raquel G.

18 visualizaciones

Más información Transcripción

Descargar la transcripción

No me va a gustar esto. 00:00:00
A ver. 00:00:01
Bueno, pues venga. 00:00:03
Saltamos a, como ya tenemos unos conocimientos de base, 00:00:05
más o menos apañados, decentes, 00:00:07
como para poder hacer aplicaciones un poquito más complejas, 00:00:09
que tengan más funcionalidades, 00:00:14
pues dejarlas con la consola todo el rato, 00:00:15
pues es muy patatero, ¿no? 00:00:19
Ya que podemos hacer una verdadera aplicación de gestión, 00:00:21
de nóminas, de no sé qué, 00:00:24
pues Pablo Ramos y su amigo. 00:00:25
ya que podemos hacer una 00:00:28
ya que podemos hacer una aplicación 00:00:30
podríamos ya si quisiéramos 00:00:36
ya si quisierais en realidad 00:00:38
con los conocimientos que queréis 00:00:39
podéis hacer una aplicación 00:00:43
que gestione cualquier cosa, lo que sea 00:00:44
claro, que nos falta 00:00:47
pues nos falta 00:00:48
la persistencia de los datos, que todos los datos 00:00:50
los vais a tener que coger 00:00:53
sobre la marcha en el momento en que la aplicación arranca 00:00:54
y cuando la aplicación se cierre van a desaparecer. 00:00:56
Pues sí, esa parte os faltaría. 00:00:59
La de los datos persistentes, 00:01:01
poder cogerlos de una base de datos o de lo que sea. 00:01:03
Pero lo que es la lógica, la gestión, 00:01:05
tenéis todo lo necesario para hacer cualquier tipo 00:01:07
de tratamiento de los datos de gestión 00:01:09
de todo lo que es una aplicación. 00:01:11
Os falta simplemente la parte de conectarlo con el exterior, 00:01:12
nada más. 00:01:15
Y también nos falta la parte de hacerla un poquito 00:01:16
a lo mejor más amigable. 00:01:18
Si hacemos una aplicación de gestión de personal, 00:01:19
de usuarios, de nóminas, de lo que sea, 00:01:21
pues hombre, estar todo el rato pidiéndoselo por consola 00:01:23
pues es un rollo, es implanteable 00:01:26
¿no? cuando tú eliges, elige usuario 00:01:28
pues hombre, lo normal es que quieras mostrarle 00:01:30
un desplegable con todo usuario posible 00:01:32
él lo elija, etcétera, y esa aplicación 00:01:34
ya si la vas a poder vender, una aplicación por consola 00:01:36
pues no vas a poder venderla 00:01:39
bueno, vas a poder venderla 00:01:40
o no, pero bueno 00:01:42
entonces, vamos a 00:01:44
ver los principios de 00:01:47
el diseño 00:01:48
de diseño 00:01:51
de creación de interfaces gráficas 00:01:52
Entonces, vamos a ver 00:01:54
¿En qué se basan las interfaces gráficas en Java? 00:01:57
Esencialmente es 00:02:03
Un método muy breve y nos ponemos en 00:02:04
Y nos ponemos en faena 00:02:07
Por ejemplo, pero no me peta 00:02:26
Pantalla LED 00:02:36
Bucles 00:02:38
Guay 00:02:40
Así que ha sacado un 10 en bases de datos 00:02:41
La única en las tres clases 00:02:58
Fíjate 00:03:03
Pero no seas tan modesta 00:03:08
no la conozco 00:03:10
muy modesta no es 00:03:20
si desde luego 00:03:21
la modestia 00:03:29
no es tu punto fuerte 00:03:31
pero no pasa nada 00:03:32
no necesitas ser modesta 00:03:33
pues ya está 00:03:35
toma ya 00:03:36
eso es bueno 00:03:39
ya, lo que pasa es que 00:03:41
bueno, y si realmente 00:03:49
son tan inteligentes, lo ideal es cuando 00:04:06
se dan cuenta las veces de que no la llevan 00:04:08
no, no hablo de ella 00:04:10
no, no hablo de ella 00:04:13
hablo general 00:04:14
claro, no hay mayor 00:04:15
signo de inteligencia 00:04:18
que saber cuándo estás equivocado 00:04:19
que no es el caso 00:04:22
ella no está equivocada 00:04:24
faltaría más 00:04:26
hay que afirmar cuando estás en lo correcto 00:04:27
y también saber equivocarte con otros valores 00:04:30
efectivo 00:04:32
bueno, a ver, entonces 00:04:33
Bueno, la filosofía... 00:04:36
¡Ah! Ya se me ha ocurrido 00:04:54
una cosa. 00:04:56
¿Qué otra cosa 00:04:59
vamos a meter este año? 00:05:00
Lo voy a decir luego a Estefan. 00:05:01
¿Se trata de iluminarte? 00:05:02
Sí. 00:05:04
Bueno, si lo voy a hacer 00:05:04
Y os va a gustar 00:05:13
Bueno, si, Estefano 00:05:14
Bueno, esa es la formación de interfaces gráficas 00:05:15
Un poquito más profesional 00:05:20
Bueno, pues los videojuegos antiguos estaban en FX 00:05:21
Había la saga esta 00:05:23
FX se llamaba 00:05:24
Sí, no sé si será el mismo FX 00:05:26
Que los paquetes FX de Java 00:05:28
Puede ser 00:05:30
Bueno, pues 00:05:30
vale, a ver 00:05:31
interfaces gráficas o Java 00:05:34
la filosofía de creación 00:05:35
de interfaces gráficas 00:05:39
es la misma en cualquier lenguaje 00:05:40
es todo muy parecido 00:05:43
entonces 00:05:44
Java ya en la máquina virtual 00:05:45
trae su paquete 00:05:49
con todas las clases 00:05:51
que tenemos que usar, callaos ya de una vez 00:05:53
Jesús, que calles 00:05:55
bueno 00:06:01
pues ya trae 00:06:05
un montón de clases en un paquete 00:06:08
que es este 00:06:10
el JavaXSwing, un montón de clases 00:06:11
ya hechas que nosotros utilizamos 00:06:14
y por supuesto 00:06:16
la base de la arquitectura 00:06:18
de cualquier aplicación con interfaz gráfica 00:06:20
como siempre 00:06:22
es la herencia 00:06:23
y la implementación 00:06:26
Vale, silencio 00:06:30
Entonces 00:06:42
Vale, pues entonces 00:06:42
Java Xfin tiene un montón de clases 00:06:49
Los marcos 00:06:52
Los paneles, los botones 00:06:54
Los desplegables, las barritas 00:06:55
Trae un montón de clases 00:06:57
Y nosotros construimos heredando 00:06:58
Sobre ellas 00:07:02
y en el momento de heredar personalizamos 00:07:02
personalizamos lo que nosotros 00:07:05
queramos, cosas como la 00:07:07
posición, el color, etc 00:07:09
¿vale? 00:07:11
luego eso es lo primero, con herencia 00:07:12
y implementación 00:07:15
construimos 00:07:16
versiones 00:07:18
personalizadas 00:07:24
de las clases 00:07:27
que ya nos da ese paquete 00:07:29
¿vale? 00:07:30
y con eso ya 00:07:36
creamos nuestra interfaz 00:07:40
lógicamente 00:07:41
no podemos conocernos las tropecientas 00:07:44
clases que hay en java xswing 00:07:46
conocemos las básicas, luego si queremos hacer 00:07:47
alguna cosa en concreto, pues nos vamos y miramos 00:07:50
¿hay un componente para esto? 00:07:52
si lo hay, lo usamos, lo incorporamos, etc 00:07:53
bueno, pues construimos nuestra versión 00:07:56
personalizada 00:07:58
y luego hay otra segunda parte 00:07:59
que es 00:08:02
la interfaz, no es solo construir 00:08:03
un cuadro bonito, con botones, etiquetas 00:08:06
no sé qué, tiene que tener un comportamiento 00:08:08
yo hago mi interfaz con sus botones 00:08:10
sus etiquetas, sus desplegables 00:08:14
pero luego 00:08:16
el usuario cuando accione 00:08:17
esos componentes tiene que pasar algo 00:08:20
luego hay otra segunda 00:08:22
parte, que es la 00:08:24
parte del comportamiento 00:08:26
eso 00:08:27
luego 00:08:29
la interfaz 00:08:34
o sea la aplicación 00:08:37
más que la interfaz 00:08:39
la aplicación 00:08:40
tiene que dar respuesta 00:08:45
a las acciones que el usuario haga 00:08:48
sobre la interfaz 00:08:50
a las acciones del usuario 00:08:51
luego son dos cosas separadas 00:09:10
las que tenemos que programar 00:09:18
por un lado construimos la interfaz 00:09:20
para eso hay incluso aplicaciones 00:09:21
el famoso Pencil 00:09:26
que no tenemos ni que usar Java ni nada 00:09:27
aplicaciones para que tú construyas 00:09:30
un prototipo del aspecto de la interfaz 00:09:32
se la enseñas al usuario 00:09:34
¿Este es el aspecto que quieres que tenga tus pantallas? 00:09:36
Ah, sí, las pantallas de la aplicación creo que tengan 00:09:38
este aspecto. Ah, fenomenal. 00:09:40
Y esas aplicaciones valen solo para construir 00:09:42
aspectos de pantalla 00:09:45
para que tú se los vayas enseñando al usuario 00:09:46
y no tienes que programar en Java todavía. 00:09:48
Cuando él te dice, sí, sí, mis pantallas 00:09:51
la pantalla de login, la pantalla de crear 00:09:53
pedido, no sé qué, estas me gustan, quiero que sean estas. 00:09:55
Pues ya está. 00:09:58
entonces tú ya programas eso en Java 00:09:58
que es muy sencillo, lo pones ahí, se acabó 00:10:01
y ahora empieza la segunda parte 00:10:03
que es la parte de 00:10:05
vale, ahora el usuario va a llegar y de forma 00:10:06
completamente asíncrona 00:10:09
va a accionar estos comandos 00:10:10
entonces ahora mi aplicación tiene que dar una respuesta 00:10:12
concreta a la acción 00:10:15
del usuario 00:10:16
pues ahora del botoncito añadir usuario 00:10:17
pues tendrá que dar una respuesta que sea 00:10:21
instanciar un objeto 00:10:22
usuario, meterlo en la colección 00:10:24
a su vez refrescar 00:10:27
la interfaz para que te aparezca 00:10:28
en el desplegable, lo que sea 00:10:30
luego una parte es 00:10:31
el diseño de la interfaz 00:10:33
y luego otra parte es 00:10:35
la programación de la respuesta 00:10:37
a los eventos del usuario 00:10:40
y eso ya es un primer cambio extraño 00:10:42
porque hasta ahora nuestros programas 00:10:44
eran todos secuenciales 00:10:46
iba una cosa tras otra, todo 00:10:48
yo iba cambiando de método, ahora me iba esta 00:10:50
ahora me iba esta, pero siempre se hacía una cosa 00:10:52
tras la otra, luego era todo 00:10:54
síncrono, que se llama 00:10:56
todo era síncrono, es decir 00:10:57
no había ningún evento que llegara 00:11:00
fuera de control 00:11:02
incluso cuando se lanzaba una excepción 00:11:03
también era síncrona, porque la excepción 00:11:06
se lanzaba cuando 00:11:08
llegaba una sentencia throw que se había hecho 00:11:10
después de otra, que había detectado no sé qué 00:11:12
todo es una línea así 00:11:14
pues ahora 00:11:15
ya entra un comportamiento 00:11:18
asíncrono, el programa 00:11:20
muestra su interfaz 00:11:22
y se queda ahí esperando, no termina 00:11:23
Hasta ahora cuando un programa acababa 00:11:26
De ejecutar todo su código 00:11:28
Terminaba 00:11:30
Ahora el programa habrá terminado 00:11:31
De poner sus componentes 00:11:33
Pero no habrá acabado el mail 00:11:35
Aunque no haya más sentencias 00:11:37
Bueno, más que como switch case 00:11:39
Como una sentencia de lectura de read 00:11:47
Si tú haces un read 00:11:49
Eso se queda ya a la espera 00:11:51
Pero se queda bloqueado 00:11:52
en esa sentencia 00:11:53
claro, aquí no se queda bloqueado 00:11:56
el programa, no es que se quede bloqueado 00:11:58
sino que no ha terminado 00:12:00
y ahí está, entonces cuando de repente 00:12:01
el usuario 00:12:04
hace una acción 00:12:06
el programa se da cuenta 00:12:07
¿cómo se da cuenta? pues yo creo que lo hay que programar 00:12:09
hay que ver cómo lo hacemos, se da cuenta 00:12:12
y responde con un código 00:12:14
por ahora lo único que quiero decir es que hay dos partes muy separadas 00:12:15
la construcción de la interfaz 00:12:18
lo que es el aspecto que le podemos dar 00:12:20
Luego, ¿cómo damos comportamiento a los eventos que decidamos que son los que importan? 00:12:22
Pues darle a un botón, o abrir un desplegable, o abrir un menú, o lo que sea. 00:12:27
Bueno, en cuanto a construir la interfaz. 00:12:35
Principios muy básicos de cómo se construye una interfaz. 00:12:41
Bueno, pues la arquitectura de una interfaz gráfica en Java. 00:12:55
una interfaz gráfica en Java 00:13:05
se apoya 00:13:08
en una especie de marco 00:13:09
general, lo que se llama 00:13:13
la ventana 00:13:15
un marco general que es la ventana 00:13:16
que tiene lo básico 00:13:18
que es los botoncitos estos de minimizar 00:13:21
maximizar 00:13:23
y la cruz en el orden que sea 00:13:24
aquí esta barrita 00:13:27
y ya está 00:13:29
esta sería la raíz 00:13:30
de cualquier interfaz gráfica esta es la raíz 00:13:33
es como si fuera el marco principal 00:13:35
bueno pues esto afortunadamente ya está hecho 00:13:37
lo tenemos que hacer nosotros 00:13:40
y esto es la clase JFrame 00:13:42
vale 00:13:44
luego 00:13:47
la clase JFrame tiene que tener al menos 00:13:49
una cosa que se llama un contenedor 00:13:53
los contenedores son los que tienen los componentes 00:13:56
los contenedores tienen los componentes 00:14:00
bueno pues el JFrame 00:14:01
tiene un contenedor 00:14:03
que es el contenedor principal 00:14:06
y este pertenece a la clase JPanel 00:14:09
luego ya tenemos dos clases que identificamos 00:14:17
JFrame que es el marco principal 00:14:21
todo eso es en general 00:14:23
luego tú puedes hacer un JFrame asociado a una de diálogo 00:14:24
con lo cual esto no lo ves 00:14:27
luego aparentemente no tienes esto 00:14:28
luego hay Swim 00:14:30
hay libros de Swim de 3.000 páginas o 4.000 00:14:31
luego hay muchas 00:14:34
sí, estará bien por lo caso aquí 00:14:35
no sé 00:14:42
Bueno, ya tenemos dos clases 00:14:43
El JPanel es un contenedor 00:14:57
El JPanel va asociado a un frame 00:14:58
No va nunca solo 00:15:00
El siempre va asociado a un frame 00:15:02
Y este ya es un contenedor 00:15:04
Que ya puede tener cosas 00:15:07
¿Y qué puede tener? 00:15:08
componentes, como un botoncito 00:15:10
esto es un componente 00:15:13
o puede tener a su vez otros contenedores 00:15:14
contenedores secundarios 00:15:19
es decir, un 00:15:21
contenedor, este contenedor principal 00:15:23
puede tener a su vez otro contenedor 00:15:25
que sea otro JPanel 00:15:27
un contenedor secundario que tiene aquí 00:15:28
otros 00:15:31
¿Y para el diseño de que salga al medio, que salga a la derecha y todo eso? 00:15:31
Sí, ahora 00:15:34
¿Vale? Entonces 00:15:35
luego tenemos el marco 00:15:36
contenedores 00:15:39
el principal y secundario 00:15:41
si quiero, y luego 00:15:44
componentes, que ya son los elementos 00:15:45
que reciben los eventos en general, los botones 00:15:47
los desplegables, los menús 00:15:49
y esos van en los contenedores 00:15:51
van en los contenedores 00:15:54
esa es la idea muy general 00:15:55
de construcción 00:15:57
componente típico, pues el botoncito 00:15:58
ese, vale 00:16:02
ahora, efectivamente 00:16:05
como se ponen 00:16:07
tosa y amogollón 00:16:09
hombre, pues no 00:16:10
entonces, para colocarlos 00:16:12
hay otras clases que se llaman 00:16:15
gestores de ubicación 00:16:17
que uno las configura 00:16:19
y a través 00:16:21
de la configuración que hayamos eso 00:16:23
en esos gestores de ubicación 00:16:25
pues se colocan las cosas de una manera o de otra 00:16:26
o también tenemos la alternativa 00:16:29
de pasar de los gestores de ubicación 00:16:31
y colocarlo por 00:16:33
coordenadas, cada vez que añadimos un componente 00:16:35
decirle al tener el componente la coordenada 00:16:37
x y con alto y ancho tal 00:16:39
¿vale? pasamos de gestores 00:16:41
y entonces cada colocación de componente 00:16:43
hay que decirle, coordenada x 00:16:45
coordenada y, ancho del componente y alto 00:16:47
del componente, y ya está 00:16:49
¿vale? colocación absoluta, efectivamente 00:16:51
entonces la solución 00:16:53
de la gestión de la ubicación de los componentes 00:16:55
es lógica y también hay que darle, o bien 00:16:57
absoluta de esta manera o bien con un gestor 00:16:59
de ubicación, y luego una vez que 00:17:01
esto está, pues ahora ya hay que 00:17:03
ver, y ahora ya esto lo tengo, muy bien 00:17:05
muy bonito, vale, ahora 00:17:07
ya como hago para que si el usuario llega 00:17:09
de repente y hace plag 00:17:11
pase algo 00:17:12
bueno, pues ahora tendremos que ver 00:17:14
como hacemos eso, pero bueno 00:17:17
vamos a hacer la 00:17:19
primera cosa esta 00:17:20
¿Vale? 00:17:28
¿Vale? 00:17:29
¿Vale? 00:17:29
Pues esta es la idea 00:17:29
y sobre esta idea ya podéis hacer 00:17:33
lo que os dé la gana 00:17:35
bueno, luego aparte hay otra cosa 00:17:36
está el paquete gráficos 00:17:38
que eso es otra cosa, que eso es para hacer dibujos 00:17:40
círculos, animaciones 00:17:42
que eso bueno, también lo mencionaremos 00:17:44
y lo veremos, ahora estamos hablando de interfaces 00:17:46
gráficas para comunicarte con el usuario 00:17:48
el año que viene, sí 00:17:50
una optativa de 3 horas 00:17:57
que la da Estefan 00:17:59
o al menos 00:18:02
me lo ha prometido 00:18:04
así que 00:18:05
pues vas a aprender a programar 00:18:06
y a hacer videojuegos 00:18:15
y acabaste encontrando un nuevo corte 00:18:16
que es más valioso 00:18:20
bueno 00:18:21
pues ala 00:18:24
vamos a hacernos 00:18:30
Primera interfaz gráfica 00:18:35
Vamos a ser organizados con los proyectos 00:18:39
Porque como es vuestro principal material 00:18:42
Pues vamos a ser organizados 00:18:46
Primera interfaz gráfica 00:18:48
Primera GUI 00:18:57
Que así la vamos a encontrar antes 00:19:01
GUI 00:19:03
vamos a hacer la primera GUI 00:19:08
que es un hombre profesional 00:19:10
¿no? 00:19:12
venga, pues yo tengo aquí 00:19:31
me voy a hacer mi programa 00:19:33
venga 00:19:35
a mi me dicen 00:19:44
haz un programa 00:19:45
con dos botones 00:19:47
y según el botón 00:19:51
que des, pues te diga 00:19:53
hola o te diga adiós, por ejemplo 00:19:54
depende de si quieres irte o llegar 00:19:56
o sea es un botoncito 00:19:58
vamos a hacer 00:20:01
una aplicación 00:20:03
para que yo me pueda despedir 00:20:04
de vosotros 00:20:07
o saludar sin tener que hacer 00:20:08
el esfuerzo de hablar, ¿no? 00:20:11
Si yo doy al botón de hola, pues aparece 00:20:13
un hola ahí gigante. 00:20:15
Y si doy al botón de adiós, pues aparece un adiós gigante. 00:20:17
Así no tengo que hablar. 00:20:19
Vale, pues me han plantado esa situación. 00:20:21
Bueno, pues lo primero 00:20:24
es que 00:20:25
tengo que construir, tengo que pensar. 00:20:25
Vale, ¿qué interfaz gráfica voy a necesitar 00:20:29
para eso? 00:20:31
Me han dicho, bueno, es una cosita con 00:20:32
dos botoncitos. 00:20:35
bueno, dos botones tiene que haber 00:20:36
y luego 00:20:38
la respuesta del programa va a ser 00:20:39
mostrar un hola 00:20:42
mostrar un adiós 00:20:44
ese hola y ese adiós, ¿dónde lo voy a mostrar? 00:20:46
bueno, pues me voy a buscar un componente 00:20:48
que sirva para 00:20:50
buscar texto, para poner 00:20:52
texto, perdón, y cuando encuentre un componente 00:20:54
que sirva para poner texto, pues lo pongo 00:20:56
también a interfaz, vale, pues mi interfaz 00:20:58
va a ser un botón 00:21:00
hola, un botón adiós 00:21:02
y un componente en el que yo pueda 00:21:04
escribir texto 00:21:06
cuando le de a hola pues aparecerá hola 00:21:07
y cuando le de a dios aparecerá dios 00:21:10
por ejemplo y ya está 00:21:12
vale, bueno pues entonces ya 00:21:13
tenemos la idea de la interfaz 00:21:16
ahora ya vamos a construirla 00:21:18
lo primero que necesitamos 00:21:21
si o si 00:21:23
es un objeto 00:21:24
de tipo 00:21:26
jframe que es el básico 00:21:28
vale 00:21:30
pero un JFrame tal cual 00:21:32
me vale 00:21:35
un frame así sin más 00:21:35
pues hombre, un JFrame 00:21:38
veis que se importa de aquí 00:21:49
un JFrame así sin más 00:21:51
pues no me vale 00:21:53
porque 00:21:55
vale, yo lo puedo instanciar 00:21:56
lo puedo crear y lo puedo hacer 00:21:59
visible 00:22:02
con el método setVisible 00:22:02
a true 00:22:05
vale, pues habré creado 00:22:06
un frame, lo habré hecho visible 00:22:09
pero este frame no es el que estoy buscando 00:22:11
¿no? bueno, le vamos a dar 00:22:14
un tamaño, pues le damos un tamaño 00:22:16
el frame 00:22:17
vamos a ver qué frame me aparece aquí 00:22:19
¡qué pequeñajo! 00:22:21
vamos a darle un tamaño 00:22:27
frame. 00:22:28
frame. 00:22:32
setSize 00:22:34
setShape, no 00:22:35
¿le puedo darle redondito? no lo puedo creer, ¿en serio? 00:22:37
bueno, igual le puedo 00:22:41
hacer redondo si tiene un setShape 00:22:42
set size 00:22:43
100, 100 00:22:49
vale, pues yo mi main 00:22:51
pulgadas 00:22:53
son muchas, ¿verdad? 00:22:59
es que píxeles es muy poco, ¿no? 00:23:04
no, no, no, eso es por título 00:23:06
es en píxel, ¿verdad? 00:23:07
sí, es en píxel 00:23:10
vale, bueno, vais a notar 00:23:11
que a mí lo de las interfaces gráficas 00:23:18
me la trae bastante floja 00:23:20
me refiero 00:23:21
que no es algo 00:23:25
en lo que yo haya 00:23:26
investigado nunca 00:23:28
porque es que no me aporta mucho en mi vida 00:23:30
aparte, vale, lo digo porque 00:23:32
aquí sois vosotros 00:23:34
aquí sois vosotros los que tenéis que investigar 00:23:35
me refiero 00:23:39
aquí cualquier cosa que os inspire curiosidad 00:23:42
adelante con vuestra curiosidad 00:23:44
¿vale? 00:23:46
adelante con vuestra curiosidad, yo os voy a examinar eso sí 00:23:48
de lo que yo os cuente 00:23:50
pero cualquier cosa que os inspire curiosidad, pues venga 00:23:50
no la cercenéis 00:23:54
y si luego encima lo contéis a los demás, fenomenal 00:23:55
vale, pues ya está, yo con esto 00:23:57
he hecho mi primera interfaz gráfica 00:24:00
pero sí, preciosa 00:24:02
pero es que yo quería que aquí hubiera dos botones 00:24:03
y un espacio 00:24:06
para texto, aquí no hay nada 00:24:08
con lo cual este frame, muy bonito 00:24:09
pero no me vale 00:24:11
vale 00:24:12
entonces fijaos 00:24:14
que yo me creo 00:24:17
que he cerrado el programa dándole a la X 00:24:18
y no he cerrado el programa, he cerrado la ventana 00:24:21
pero aquí sigue mi botoncito rojo 00:24:23
mi proceso no ha acabado 00:24:25
¿os dais cuenta? 00:24:27
y sigue, y el otro que he cerrado también 00:24:30
y el otro 00:24:32
fijaos todos los que tengo aquí abiertos 00:24:34
vale 00:24:36
¿os habéis dado cuenta de esto? 00:24:37
¿el qué? 00:24:42
¿Cómo, eh? 00:24:43
¿Qué ha pasado? 00:24:45
¿Os habéis dado cuenta de esto? 00:24:48
He lanzado el programa. 00:24:50
Lo lanzo. 00:24:52
Vale. 00:24:55
Y ahí está mi ventanita. 00:24:56
Vale, que no me vale para nada porque no tiene 00:24:58
los botones que yo quiero dar. 00:24:59
Entonces yo no me vale. 00:25:01
Y le doy a la X. 00:25:03
He cerrado el programa, 00:25:06
el proceso, no he cerrado nada. 00:25:07
Lo que he hecho es 00:25:09
hacer desaparecer el frame. 00:25:11
Pero mi programa aquí sigue 00:25:13
De hecho aquí está 00:25:14
Esta cosa roja y aquí no pone terminate 00:25:16
En ningún momento 00:25:19
Entonces el proceso sigue ahí 00:25:20
Claro 00:25:23
Es como el set visible 00:25:25
Lo he vuelto a poner a false 00:25:27
Y ahora es que no la puedo volver a hacer aparecer 00:25:28
Porque la ventana 00:25:31
La interfaz ha desaparecido 00:25:32
Es que no tengo opción 00:25:33
Uy de verdad me vas a hacer 00:25:34
Que debugue 00:25:39
Debugue a tu vale 00:25:39
vale 00:25:42
entonces 00:25:45
primera cosa que quiero que tengáis en cuenta 00:25:47
cerrar la interfaz no significa que el proceso 00:25:50
haya parado 00:25:52
lo he tenido que forzar así a lo bestia 00:25:53
claro, es que ahora mismo estoy programando en plan patatero 00:25:55
luego lo que haremos es 00:25:58
incorporar una sentencia que asocie 00:26:00
darle a la X con cerrar el proceso 00:26:02
y todas esas cosas hay que depurarlas 00:26:04
claro, vale 00:26:06
vale, pues primera cosa 00:26:08
este frame no me gusta 00:26:12
vale, pues entonces 00:26:14
vamos a construirnos 00:26:15
uno que herede de este 00:26:17
y que ya sí que tenga lo que yo quiero 00:26:19
este no me gusta 00:26:21
vale, pues me voy a construir uno 00:26:23
me voy a construir uno 00:26:24
mi ventana, por ejemplo 00:26:27
mi ventana 00:26:29
como lo queréis llamar 00:26:33
mi ventanita 00:26:34
ah, eso lo vamos a hacer 00:26:37
que siempre me gusta hacerlo 00:26:44
Que según le vas dando la X te la mueva 00:26:45
Y entonces te vas a ir persiguiendo 00:26:47
Pues eso 00:26:48
Podemos hacer muchos puteos 00:26:52
Vale 00:26:54
Ha sido sincero 00:26:56
Venga 00:26:59
Venga, a ver 00:26:59
Vamos a hacernos otro 00:27:02
Porque el Jotaframe no nos gusta 00:27:03
Vamos a hacernos otro 00:27:05
Pero claro 00:27:06
Queremos reutilizarlo 00:27:07
Que ya está en Jotaframe 00:27:10
Pues menos mal que somos unos 00:27:11
expertos en la herencia 00:27:14
y ahora nos vamos a hacer 00:27:15
bueno 00:27:17
si me podrás dar un braguetazo 00:27:19
y heredar 00:27:26
de la pensión de viudedad 00:27:30
vale, pues vamos a heredar de 00:27:31
este 00:27:34
y ahora ya tenemos 00:27:35
ya tenemos 00:27:38
un frame 00:27:44
que tiene todo lo de frame y ahora aquí ya podemos poner lo 00:27:45
que nos dé la gana. 00:27:50
Aquí ya ponemos lo que queramos, ¿vale? 00:27:52
O sea, la aplicación ahora mismo sigue siendo la misma. 00:27:55
Si la vuelvo a ejecutar, sigue saliendo mi frame porque es que 00:27:58
no la he personalizado. 00:28:01
Está sin personalizar. 00:28:02
Sigue siendo mi frame. 00:28:04
Pero vamos a personalizarlo, ¿vale? 00:28:06
¿Vale? 00:28:11
¿En qué momento lo personalizamos? 00:28:11
pues el momento de 00:28:14
construirlo, cuando se construye 00:28:16
pues vamos a poner el constructor 00:28:18
¿con quién hablas? 00:28:19
vale 00:28:33
esto, lo que 00:28:33
pase aquí 00:28:36
lo que yo ponga aquí 00:28:37
lo que yo ponga aquí es lo que ocurre 00:28:39
cuando hagamos este new, ¿verdad? 00:28:42
cuando hagamos este new ocurrirá lo que 00:28:44
yo ponga aquí, pues entonces aquí 00:28:46
voy a poner, crear el botón 00:28:48
ponerlo, etcétera, etcétera 00:28:50
aquí, o bueno 00:28:52
o lo puedo hacer si no quiero hacer un constructor 00:28:54
muy feo, en un método 00:28:56
adicional y lo llamo desde ahí. 00:28:58
Por ejemplo, vamos a hacer un 00:29:00
construye 00:29:02
interfaz. 00:29:07
Construye interfaz. 00:29:12
Y a construir interfaz no tengo que llamar el constructor. 00:29:12
Es que ahí no me escapo. 00:29:15
Claro, claro. Es que yo no le he quitado 00:29:31
el set visible, claro. 00:29:32
claro, vale 00:29:35
no, no, no, no, bueno yo puedo 00:29:36
meter en el new el set visible y entonces 00:29:41
lo tengo que poner fuera, vale, yo lo que 00:29:43
he cambiado aquí respecto a la versión anterior es 00:29:45
me he hecho un frame personalizado, pero luego le he 00:29:47
seguido dando el tamaño que sea y haciéndolo 00:29:49
visible, vale, entonces 00:29:51
cuando hagamos el new mi ventana 00:29:52
el new mi ventana, ese no me 00:29:55
puede escapar, va a ir ahí 00:29:57
entonces lo he hecho a través de un método auxiliar 00:29:58
pero como si lo meto todo ahí dentro 00:30:01
como luego vamos a usar el plugin 00:30:02
para poder arrastrar y que no sea tan pesado 00:30:05
pues el plugin 00:30:07
si te lo meten un método auxiliar, etc 00:30:09
vale, el consejo de interfaz 00:30:11
¿qué hemos dicho que queremos hacer? queremos dos botones 00:30:13
uno para saludar y otro 00:30:15
para despedirse, pues como 00:30:17
ya me sé porque lo he usado mucho 00:30:19
que el componente botón se llama jbutton 00:30:21
pues ya está 00:30:23
pues me lo instancio 00:30:25
el constructor de JButton 00:30:29
pues 00:30:36
está sobrecargado pero admite 00:30:37
que tú le des directamente el texto 00:30:39
que quieres que vaya arriba, si no se lo pones después 00:30:42
con un set test, como quiera 00:30:44
pues este va a ser 00:30:46
el botón de saludar 00:30:48
importamos 00:30:49
JButton 00:30:52
y saludar como clase 00:30:53
ya hecha que es, tiene un montón de métodos 00:30:58
este botón para cambiarle 00:31:00
colores, bordes, para hacerle un montón 00:31:02
de mamonadas. Pero por ahora no le vamos 00:31:04
a cambiar nada y ya está. 00:31:06
Nuestra interfaz necesitaba dos, porque yo quiero 00:31:11
tanto saludar como despedirme. 00:31:13
Pues venga. 00:31:18
Despedir, vale. 00:31:22
Y hemos dicho que mi 00:31:24
interfaz también necesita 00:31:25
un área donde poder poner 00:31:28
texto para que cuando yo 00:31:29
dé a saludar en el texto me ponga hola 00:31:31
y cuando dé a despedir, pues adiós. 00:31:33
Vale, pues yo busco por ahí 00:31:35
¿Dónde puedo ponerte esto? 00:31:36
Bueno, en muchos sitios 00:31:38
Pero un sitio muy típico es una etiqueta 00:31:39
Uno busca JLabel 00:31:41
Vale, luego JFrame 00:31:44
JButton, JLabel 00:31:48
Ya no se nos puede olvidar, son los básicos 00:31:50
Claro 00:31:52
Esto y otros 00:31:52
Solo 50 más 00:31:55
Bien, bien 00:31:58
Los 200.000 más que hay ya se quedan ahí 00:31:59
Para que uno los busque cuando 00:32:01
Vale, no, vamos a llegar a 50 rápido 00:32:02
vamos a llegar pero nos vamos a acordar de los 50 00:32:05
si porque tenéis unas memorias 00:32:10
jóvenes y frescas 00:32:12
JLabel pues ya está 00:32:14
claro que hay que importarlo todo 00:32:20
te van a quedar unos sim por ahora 00:32:23
gigantescos 00:32:26
vale 00:32:26
bueno los objetos están 00:32:29
instanciados 00:32:33
pero no están pegados en ningún lado 00:32:35
los tengo que pegar en la interfaz 00:32:37
no están en ninguna parte 00:32:39
los puedo pegar al frame directamente 00:32:40
que en este caso sería el objeto dis 00:32:43
porque estoy directamente en él 00:32:45
los puedo pegar directamente dis 00:32:47
añádele, pega 00:32:49
el botón, saluda 00:32:51
no puedo al frame directamente ponérselos 00:32:55
porque los componentes van en los contenedores 00:32:57
vale, van en los contenedores 00:32:59
el frame 00:33:01
trae un contenedor principal por defecto 00:33:03
siempre 00:33:05
ese contenedor principal por defecto 00:33:06
se saca a través del método 00:33:10
getContentPanel 00:33:13
getContentPanel es un método 00:33:14
que te saca el contenedor por defecto 00:33:19
que te trae cualquier frame 00:33:22
no hace falta que hagas tú un jPanel específico 00:33:23
y se lo pongas al frame, si no quieres 00:33:25
puedes hacer muchos, secundarios 00:33:27
pero él te trae ya uno por defecto 00:33:28
tan grande como el propio frame 00:33:30
a un panel le puedes poner otro panel 00:33:33
claro, al contenedor por defecto lo normal es que tú 00:33:35
a lo mejor le hicieras, pues cuatro paneles 00:33:37
que haremos para diferentes cosas, pues insertar 00:33:39
no sé qué, lo que toque 00:33:41
vale, pues entonces a este que es el panel 00:33:42
por defecto ya le podemos añadir cosas 00:33:45
por ejemplo, vamos a añadirle 00:33:47
el botón saluda 00:33:49
vamos a añadirle 00:33:50
¿vale? añadirle botones 00:33:54
¿eh? 00:33:56
puedes añadir botones 00:33:59
cualquier componente 00:34:00
cualquier cosa que sea componente 00:34:02
le añadimos 00:34:04
el otro 00:34:09
eso, gracias 00:34:10
venga 00:34:17
y a este otro 00:34:22
le añadimos ya la etiqueta 00:34:25
pues ya está construida mi interfaz 00:34:31
he instanciado los tres objetos 00:34:37
y los he pegado al contenedor por defecto 00:34:40
y ya no hay más que hacer aquí 00:34:43
el frame una vez construido 00:34:46
pues ya le daremos un tamaño 00:34:50
y visible 00:34:51
pues venga 00:34:52
vamos a ejecutar esto 00:34:55
¿qué? 00:34:59
no me va 00:35:02
¿qué has hecho? 00:35:03
hay que ponerlo en visible 00:35:07
no, no, no 00:35:09
¿qué es lo que hemos hecho mal? 00:35:12
que los hemos puesto a lo bestial 00:35:16
¿qué has preguntado tú antes de los gestores de ubicación? 00:35:19
claro, que nos hemos puesto 00:35:24
a añadir directamente las cosas 00:35:25
¿vale? 00:35:27
y ¿qué ha hecho? 00:35:28
las ha añadido 00:35:31
pero como no hemos hecho gestor de ubicación 00:35:32
si no hay gestor de ubicación, ni le hemos puesto aquí coordenadas 00:35:34
ni nada 00:35:37
¿él qué hace? añade una encima de la otra 00:35:38
se ve la etiqueta 00:35:42
Sí, vamos a cambiar de hecho el orden 00:35:44
Voy a poner la etiqueta 00:35:47
¿Se ve? Lo que pasa es que la etiqueta no tiene ningún texto 00:35:49
Está vacía, por eso no la vemos 00:35:51
Vamos a poner la etiqueta primero 00:35:52
¡Hala! Mira el cacho botón que está ahí 00:35:55
Añadido uno encima del otro 00:36:00
Y estirado al tamaño del contenedor 00:36:05
He cambiado el orden 00:36:08
Entonces primero la etiqueta 00:36:11
luego el botón salude y luego el botón decide 00:36:13
con lo cual lo único que he visto 00:36:15
es lo último que he añadido 00:36:17
porque están unos encima del otro 00:36:20
tengo aquí 200.000 abierto 00:36:22
vale 00:36:27
un float 00:36:35
con lo cual 00:36:36
si no hay gestor de ubicación 00:36:39
pone los componentes 00:36:42
uno encima del otro y estirados 00:36:44
al tamaño del contenedor. No nos vale para nada. 00:36:46
¿Vale? No nos vale para nada. 00:36:49
Vale. Pero antes 00:36:51
de poner el gestor de ubicación, 00:36:52
vamos a llamar 00:36:54
al método, darle la sentencia que necesita 00:36:56
para que cuando le demos a la X, también cierre 00:36:58
el programa. Pero es que si no, vais a 00:37:00
tener que estar parando todo el rato con esto y es un 00:37:02
rollo. ¿Vale? 00:37:04
Porque no es plan de acumular miles de procesos. 00:37:06
Entonces, vamos cuanto antes a incorporar eso y ya está. 00:37:08
Entonces, hay 00:37:10
un método para el frame 00:37:12
mi frame dis 00:37:14
que es el 00:37:16
a ver 00:37:18
como se llama ese método 00:37:22
este, vale 00:37:24
que es 00:37:30
que acción quieres que ocurra cuando le des 00:37:31
a la x 00:37:34
pues queremos 00:37:35
exit 00:37:37
y esta exit es una macro 00:37:40
JFrame 00:37:43
puede ser la macro 00:37:49
de JFrame 00:37:50
sí, exit on close 00:37:53
se llama la macro, ¿verdad? 00:37:57
exit on 00:37:58
close se llama 00:37:59
sí, vale 00:38:02
vale 00:38:04
sí 00:38:06
no, no te tienes que acordar de todo 00:38:09
luego ya veremos como no 00:38:14
vale, esto es solamente 00:38:15
para decirle al frame 00:38:18
que cuando se le dé a la X 00:38:19
cierre el proceso 00:38:22
solo es para eso 00:38:24
entonces 00:38:26
incorporemoslo siempre porque si no 00:38:28
entonces ahora ya cuando le demos a la X 00:38:30
el proceso 00:38:33
se cierra también, ya no tenemos que estar 00:38:34
parándolo ahí todo el rato 00:38:36
vale, bueno pues entonces 00:38:37
estábamos con que 00:38:42
el main no tiene nada 00:38:44
no lo he cambiado 00:38:47
el main es el del principio 00:38:48
pues igual 00:38:50
no estará 00:38:57
vale pues venga 00:38:58
vamos a hacernos un gestor de ubicación 00:39:02
vamos a hacernos un gestor 00:39:04
de ubicación patatero 00:39:09
gestores de ubicación 00:39:11
son objetos 00:39:13
que los hay de diferentes tipos 00:39:14
en función del tipo de colocación 00:39:16
que tú quieras, como los quieras colocar 00:39:19
por ejemplo 00:39:21
vamos a suponer que queremos colocarlos 00:39:23
en filita, uno tras otro 00:39:25
pues si los queremos colocar en filita 00:39:27
hay un gestor de ubicación 00:39:29
que es el flow layout 00:39:31
que es el objeto que se mete ahí 00:39:33
y te los pone en filita 00:39:37
pues venga, vamos a crear 00:39:39
el gestor de ubicación este 00:39:41
flow layout 00:39:42
los gestores de ubicaciones 00:39:52
vienen 00:39:54
de este paquetito, del Java 00:39:56
vale, Java WT es el 00:40:00
primer paquete que se hizo 00:40:03
de interfaces gráficas y los gestores 00:40:05
de ubicaciones siguen siendo de él 00:40:07
vale, pues entonces 00:40:09
antes de colocar los componentes 00:40:11
antes de colocarlos, vamos a coger el árbitro 00:40:13
vamos a crearlo, que es el árbitro 00:40:15
que es capaz de decir, no, no, poneros en fila 00:40:17
uno tras otro, aquí nada, unos encima de otros 00:40:19
no, en fila, pues creamos 00:40:20
este objeto que es el capaz de ponerlos en fila 00:40:23
Pero claro, hay que decirle al panel, oye tú, panel, tu árbitro de colocación va a ser este. Pues venga, vamos a decirle al panel con el que estamos trabajando, vamos a decirle que su layout sea ese. 00:40:25
No hemos hecho una todavía 00:40:47
Esto normalmente son 200.000 líneas de código 00:40:51
Que no, que luego es muy rápido 00:40:55
Hay un plugin para vagos 00:41:00
Y ya 00:41:07
Hablan tratándose de vosotros 00:41:09
Pues habrá que usarlo 00:41:13
Vale, pues esto 00:41:15
Pero a ver 00:41:18
Uno se puede permitir ser vago 00:41:19
Cuando conoce 00:41:22
Los principios de funcionamiento de cualquier cosa 00:41:24
Entonces ya puede 00:41:26
Vaguear y usar el chat GPT 00:41:28
Usar a cualquier esclavo 00:41:30
Se permite el uso de cualquier esclavo 00:41:32
Cuando tú sabes los principios de funcionamiento 00:41:34
De las cosas 00:41:36
Y ahora estamos en la base de conocer los principios 00:41:37
De funcionamiento de las cosas 00:41:40
Vale, pues 00:41:41
este tío 00:41:42
lo creamos y le decimos 00:41:44
al panel, este va a ser 00:41:46
el que ponga orden 00:41:48
vale, y ahora ya 00:41:49
cuando ya le hemos dicho al panel quien es el que le pone orden 00:41:52
los añadimos 00:41:54
y ahora ya los vemos 00:41:55
la etiqueta está aquí, aunque no la veamos 00:41:58
la etiqueta está aquí 00:42:00
y ya están 00:42:02
en orden lo que tú les has dicho 00:42:04
¿y si agrandas el componente? 00:42:06
no te agrandan los componentes 00:42:08
no te agrandan. Te pone el tamaño 00:42:10
por defecto. 00:42:12
Sí, porque el flow por defecto es 00:42:14
center. Le puedes, el 00:42:16
constructor este tiene sobrecarga, el constructor 00:42:18
pues para que sea north o otras cosas. 00:42:20
Porque no hay texto. 00:42:24
Es una etiqueta para contener texto 00:42:26
pero todavía no lo tiene. 00:42:28
Entonces, este gestor de ubicación es muy 00:42:30
patatero. 00:42:32
Podríamos. 00:42:35
¿Vale? 00:42:37
Podríamos, ¿qué otra opción para colocar componentes he dicho antes que podemos usar? 00:42:40
Pasar de los gestores de ubicación, pasar de ellos y colocarlos a mano. 00:42:57
Una opción podría ser, paso de los gestores de ubicación y los coloco a mano. 00:43:01
entonces 00:43:04
en lugar de darle un gestor de ubicación 00:43:05
le diríamos 00:43:09
no tienes gestor de ubicación y tienes nada 00:43:10
hay un por defecto 00:43:13
hay un, no hay gestor de ubicación 00:43:14
pero entonces 00:43:19
ahora tienes que 00:43:21
decirle 00:43:23
colócate aquí 00:43:24
aquí con ancho esto 00:43:27
y ancho esto 00:43:29
¿vale? 00:43:31
bueno 00:43:34
aquí es que es un lío 00:43:34
hay que meterlo con el objeto 00:43:43
aquí, a ver 00:43:46
en saluda 00:43:48
en el botoncito saluda 00:43:50
tú le puedes poner 00:43:51
set bounce 00:43:54
¿veis? hay un set bounce 00:43:56
y tú aquí le pones 00:43:59
le pones en set bounce 00:44:01
le dices 00:44:04
pues 00:44:06
10 y 10 y a ver donde nos lo pone 00:44:13
y vamos a ponerle a los otros también 00:44:15
porque si no 00:44:21
despide.setbounds 00:44:22
set bounds 00:44:29
es Irene 00:44:31
perdonad 00:44:39
un segundito 00:44:40
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:
18
Fecha:
8 de marzo de 2025 - 19:13
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
633.17 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid