Saltar navegación

Java Swing 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 11 de abril de 2023 por Stefano C.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, estoy grabando, por lo tanto si habláis me estáis dando vuestro consentimiento a que se grabe vuestra voz 00:00:00
Entonces, lo que vamos a empezar hoy es interfaces gráficas 00:00:11
Y hemos dicho más o menos que es esto de la interfaz gráfica 00:00:16
Es sostancialmente tener una serie de elementos que yo pueda utilizar como botones, como campo de textos, como área de texto y cosas por el estilo 00:00:20
que permitan sustancialmente transformar mis programas, los programas que he hecho hasta ahora, 00:00:29
porque todo lo que hemos hecho hasta ahora se podría seguir haciendo así, pero no es muy amigable para el usuario. 00:00:35
Nosotros cuando utilizamos teclado, cuando utilizamos línea de texto, siempre es algo un poquito más engorroso, 00:00:43
se necesita más conocimiento, se necesita a lo mejor un teclado o algo por el estilo que es más complejo de utilizar 00:00:51
En algunos contextos, en algunos entornos 00:00:58
Por lo tanto, para que esto sea más fácil 00:01:01
Y para que también gente que no sea informática 00:01:04
Pueda utilizar nuestros programas 00:01:06
Se suele dotar de una interfaz gráfica 00:01:08
¿Vale? 00:01:10
Eso es lo mismo que pasa con los sistemas operativos 00:01:11
Windows, al fin y al cabo 00:01:14
Es una gran interfaz gráfica 00:01:16
De lo que es el CMD 00:01:18
Cuando vosotros sabéis el CMD 00:01:20
Le dais comandos directamente al sistema operativo 00:01:22
Con el intérprete de comandos 00:01:25
Pues esto era como estaban hechos los sistemas operativos antes 00:01:27
El MS-DOS, algunos de vosotros a lo mejor lo habréis visto en algún lado 00:01:31
Yo era el que lo utilizaba 00:01:34
Pues era la intérprete de comandos y nada más 00:01:36
A partir de Windows 3.11, en la rama de Windows 00:01:39
Se empezaron a poner interfaces gráficas 00:01:43
Hasta lo que utilizamos ahora 00:01:45
Que es, sustancialmente, Windows casi entero con interfaces gráficas 00:01:47
Podemos hacer, o sea, normalmente no utilizamos algo que no sean ventanas en Windows 00:01:50
Teniendo en cuenta también que añadir interfaces gráficos siempre añade un nivel de complejidad a mi programa 00:01:56
O sea, un programa que funcione sin interfaces gráficos posiblemente es más robusto que uno que tiene interfaces gráficos 00:02:04
Interfaces gráficos no dejan de ser un programa, a su vez, es un programa para hacer un interfaz gráfico para otro programa 00:02:12
Y por lo tanto si yo hago 00:02:20
Si yo tengo el programa de base 00:02:22
El que hace las cosas de verdad 00:02:23
Que funciona perfectamente 00:02:25
Y pongo un error en el interfaz gráfico 00:02:26
Ahora tengo un error en mi programa general 00:02:28
¿Vale? 00:02:31
Porque he añadido complejidad al programa original 00:02:33
No sé si me entendéis con lo que quiero 00:02:36
¿Vale? 00:02:38
Tened en cuenta también que 00:02:42
Añadir estos niveles 00:02:43
Y más programas y más códigos 00:02:46
También me puedes poner a eventuales 00:02:48
Vulnerabilidades a nivel de seguridad 00:02:50
¿Vale? Y a lo mejor he hecho un programa 00:02:52
Súper seguro, luego le añado un interfaz gráfico 00:02:54
Que utiliza algún tipo 00:02:57
De librería o utiliza algún tipo 00:02:58
De otro módulo hecho por otros 00:03:00
Y que estos módulos con alguna razón 00:03:02
Tienen algún problema de seguridad 00:03:04
Y ahora mi programa tiene ese problema 00:03:06
De seguridad 00:03:08
Se intenta evitar, pero siempre está allí 00:03:09
La posibilidad. Y la tercera cosa 00:03:12
De tener en cuenta del interfaz gráficos 00:03:14
Es que mientras que yo 00:03:16
Por ejemplo en un sistema operativo 00:03:18
Utilizo la línea de comando 00:03:20
Típica en Linux 00:03:23
¿Habéis utilizado un poco de Linux? 00:03:24
En Linux se hacen comandos grandes así 00:03:26
Y tú en Linux puedes hacer lo que te da la gana 00:03:28
Puedes hacer todo lo que te da la gana 00:03:30
Con comandos gigantes 00:03:33
Y súper complejos 00:03:35
¿Vale? 00:03:37
Pero te permite hacer prácticamente todo 00:03:37
En el momento que tú dices 00:03:40
Vale, ahora yo hago una abstracción 00:03:42
¿Vale? 00:03:45
Y creo una interfaz gráfica 00:03:45
Por encima de lo que pueda hacer 00:03:48
Mi sistema operativo debajo 00:03:49
Estoy en un cierto sentido limitando 00:03:51
Porque ahora te estoy creando una 00:03:53
Interfaz gráfica, si mi interfaz gráfica 00:03:55
Te permite hacer una determinada acción 00:03:58
Pues el interfaz gráfica por debajo 00:03:59
Lo traducirá en el comando gigante 00:04:02
Que tengo que lanzar a mi sistema operativo 00:04:04
Para que lo haga 00:04:06
Si yo en el sistema operativo 00:04:06
Por qué se me ha olvidado, por qué no quiero 00:04:08
O por cualquier otra razón 00:04:11
Perdón, en la interfaz gráfica 00:04:12
No pongo la posibilidad de hacer algo 00:04:14
Pues entonces ya 00:04:16
Tú no sabes cómo hacerlo 00:04:18
Porque no tienes acceso a lo que está detrás 00:04:20
No sé si me explico lo que quiero decir 00:04:22
¿Vale? 00:04:25
Es un poco la diferencia de filosofía fundamental 00:04:25
Entre Windows y Linux 00:04:28
En un cierto sentido 00:04:30
En el sentido Windows es muy fácil de utilizar 00:04:31
Pero cuando no te proporciona 00:04:33
La forma de hacer algo 00:04:36
Hacerlo es un infierno 00:04:37
Mientras Linux hacer hasta la cosa más básica es un infierno 00:04:38
Pero luego puedes hacer todo 00:04:42
Cuando tú ya sabes utilizar Linux 00:04:44
Es mucho más flexible con respecto a Windows 00:04:45
También todos estos elementos 00:04:48
De la interfaz gráfica, de botones 00:04:53
Y cosas por el estilo, tenemos que 00:04:55
Aprender a posicionarlos 00:04:57
A organizarlos 00:04:59
Para que salga una interfaz gráfica 00:05:01
Que sea bonita 00:05:03
Que sea fácil de utilizar 00:05:05
¿Vale? Y esto 00:05:07
Es sustancialmente el concepto del layout 00:05:08
De cómo dispongo 00:05:11
Estos elementos que van a componer 00:05:13
Mi interfaz gráfica 00:05:15
Para que queden 00:05:16
Fácilmente utilizables 00:05:18
Hay algunas convenciones 00:05:20
Y cosas por el estilo 00:05:23
Que probablemente conocéis de Linux o Windows 00:05:24
En plan, cuando yo tengo una interfaz gráfica 00:05:26
Si quiero cerrar esta interfaz gráfica 00:05:29
¿Qué hago? 00:05:31
La X arriba a la derecha 00:05:33
Yo me hago una interfaz 00:05:35
Donde pongo la X abajo a la izquierda 00:05:36
Y lo estoy haciendo mal 00:05:38
¿Funciona? Sí, funciona perfectamente 00:05:39
Se puede hacer 00:05:42
Pero luego cuando un usuario llegara allí y dirá, quiero cerrar esto, pues empezará a mirar arriba a la derecha y no encontrará nada, ¿sí? 00:05:44
Para hacer un ejemplo muy obvio, ¿vale? 00:05:51
Otras cosas, si hay botones de guardar a forma de disquetito, que ahora ya no existe, ¿vale? 00:05:54
Floppy disk de cuando yo era joven, ¿vale? 00:06:01
Pues ahora mismo cuando tú quieres guardar, buscas ese icono allí. 00:06:04
Si yo de repente te lo cambio de posición 00:06:07
Y te pongo un bolígrafo 00:06:09
Tú entras en el pánico 00:06:11
Porque bolígrafo para ti es 00:06:13
Editar 00:06:14
Entonces, hay estos tipos de convenciones 00:06:16
Y cosas por el estilo 00:06:20
Aún así, nosotros no veremos muchas de esas 00:06:20
Y haremos un poco la cosa como nos da la gana 00:06:23
¿Qué son las interfaces gráficas? 00:06:25
Parte del programa que interactúa con el usuario 00:06:28
Utilizando objetos gráficos e imágenes 00:06:30
¿Vale? 00:06:32
Es bonito, es sustancialmente 00:06:32
una capa más que yo añado 00:06:34
a mi programa, mi programa está funcionando 00:06:37
ya funcionaría en línea de comando 00:06:39
perfecto, le pongo una capa por encima 00:06:41
de abstracción para que esconda 00:06:43
toda la parte aburrida 00:06:45
que hay por debajo y la parte 00:06:47
más técnicas y le ponga 00:06:49
ventanitas y botoncitos fáciles 00:06:50
para que el usuario pueda utilizar 00:06:53
mi programa de forma más sencilla 00:06:55
que no necesite ser un informático 00:06:57
para poder utilizar el programa que estoy 00:06:59
creando 00:07:00
Proporcionan un entorno gráfico sencillo e intuitivo, evolucionan las líneas de comando y se suelen llamar GUI 00:07:01
o no se como se pronuncia esto en ingles, GUI, no lo se, Graphical User Interface 00:07:11
Como se construyen interfaces en Java? 00:07:17
Hay un par de paquetes que se pueden utilizar que incluyen toda la información que nosotros necesitamos, en particular nosotros utilizaremos Swing. 00:07:23
Tened en cuenta también que esto del mundo de los interfaces gráficos es el punto de evaluación y hay cosas más avanzadas para hacer esto. 00:07:38
Esta es una cosa un poco básica 00:07:46
Java probablemente no es 00:07:49
El mejor lenguaje 00:07:51
O el mejor entorno donde se proporcionan 00:07:53
Cosas para hacer 00:07:55
Ventanas y interfaces 00:07:56
Bonitas 00:07:59
Hay otros programas 00:08:00
Y otros lenguajes y otros entornos 00:08:02
Como .NET por ejemplo 00:08:04
En DAW lo veréis el próximo año 00:08:05
Donde posiblemente 00:08:08
Es lo que más estáis familiarizados 00:08:09
En Windows 00:08:12
Por ejemplo con el tipo de ventanas 00:08:14
Veréis que las ventanas que creemos ahora 00:08:16
Gráficamente son un poco distintas 00:08:17
Son un poco más feas 00:08:20
Pero bueno, esto es para que sepáis 00:08:20
Cómo programar 00:08:24
Interfaces gráficas también desde Java 00:08:26
Y desde la base 00:08:28
Desde 00:08:29
Programación pura 00:08:30
Luego haremos un saltito adelante 00:08:33
Veremos el window builder 00:08:35
Que nos da una mano para hacer 00:08:36
Interfaces bonitas, un poquito más bonitas 00:08:39
Sin perder la vida en ello 00:08:42
Pero por ahora estamos a un nivel 00:08:44
El más profundo posible 00:08:46
Siempre manteniendo un nivel de abstracción 00:08:50
Porque estamos en Java y estamos haciendo 00:08:52
Interfaces, pero lo más profundo posible 00:08:54
Para este tipo de cosas 00:08:56
Antes de Swing 00:08:58
Habría otro paquete que era 00:08:59
AWT 00:09:01
Del que hereda Swing 00:09:02
En un cierto sentido 00:09:06
Swing es la evolución del AWT 00:09:07
El AWT 00:09:10
Era el anterior 00:09:12
Tenía mucha 00:09:13
Integración 00:09:16
Con lo que era el sistema operativo 00:09:19
Por lo tanto 00:09:22
Lo que se hizo es crear un nuevo 00:09:23
Entorno, nuevos componentes 00:09:25
Que fueran un poco más independientes 00:09:28
Del sistema operativo que hay por debajo 00:09:30
Porque una de las cosas más importantes 00:09:32
De Java era intentar 00:09:34
Ser independiente de la plataforma 00:09:36
Tú haces un programa en Java 00:09:38
Y luego lo ejecutas tanto en Linux 00:09:40
Como en Windows, como en Solaris 00:09:41
Como en IOX 00:09:43
Y debería funcionar 00:09:45
¿Vale? Entonces un poquito así 00:09:47
Aún así, algunos componentes 00:09:48
En realidad, algunos contenedores 00:09:51
Que veremos, contenedores de componentes 00:09:53
Pues siguen siendo 00:09:56
Del paquete AWT 00:09:57
¿Esto que nos interesa a nosotros en realidad? 00:09:58
Pues simplemente cuando vamos a 00:10:02
Importar las cosas 00:10:03
Tenemos que importar 00:10:04
Con el nombre correcto 00:10:07
Si pertenecen al paquete swing 00:10:08
Será javax.swing 00:10:11
punto, lo que sea 00:10:12
si importamos de AVT 00:10:14
será Java punto AVT 00:10:16
punto lo que sea, vale 00:10:18
esto nos interesa relativamente poco 00:10:20
porque normalmente, sabéis, botón 00:10:22
izquierdo encima de 00:10:24
la cosa que no funciona y te dice 00:10:26
¿cómo lo quieres solucionar? ¿importas esta 00:10:28
y lo hace 00:10:30
el Eclipse 00:10:33
y no tengo problemas 00:10:34
ejemplo de clases 00:10:35
que están dentro de Javax Swing 00:10:38
vale, es decir, este 00:10:40
Este paquete, javax.swing 00:10:42
Que contiene 00:10:44
Pues estos son 00:10:46
Elementos, componentes 00:10:48
Que se puedan utilizar para hacer 00:10:50
Interfaces 00:10:52
¿Vale? 00:10:55
Por ejemplo está el jlabel 00:10:56
Que serían prácticamente 00:10:57
Etiquetas, es un componente 00:11:01
Que no hace absolutamente nada 00:11:02
Es para dar nombres a las cosas 00:11:04
Obviamente si pensáis en una interfaz 00:11:06
Lo que tenéis es un nombre 00:11:08
Luego una casilla donde 00:11:10
Un título digamos 00:11:11
Y una casilla donde escribir algo 00:11:12
Tú si tienes una casilla en blanco 00:11:14
No sabes que poner allí 00:11:16
Le pones delante edad 00:11:18
Y sabes que dentro de esta casilla va edad 00:11:19
Esa edad es una ley 00:11:21
Entonces es para escribir cosas 00:11:24
Pero como funcionalidad no tiene prácticamente ninguna 00:11:27
Reboot button 00:11:29
Es un botón 00:11:31
Entonces es un cuadradito 00:11:33
Donde tú lo clicas y él hará algo 00:11:34
La cosa interesante 00:11:37
Será luego ver como le hacemos 00:11:39
Hacer las cosas 00:11:40
Pero este de aquí me crea un componente 00:11:41
Que es un cuadradito, un rectángulo 00:11:44
Con escrito dentro un nombre 00:11:46
De guardar, cargar 00:11:47
De destruir todo 00:11:50
Pues no lo sé 00:11:52
Y cuando tú lo pinchas 00:11:53
Veremos como lo hacemos 00:11:55
JTextField es un campo de texto 00:11:56
Un campo de una única línea 00:11:59
JTextArea es una área de texto 00:12:01
Normalmente un rectángulo más grande 00:12:05
Donde hay varias líneas 00:12:07
Donde se puede escribir 00:12:08
Por ejemplo, pensar en un mail 00:12:09
Podría ser el JTextField 00:12:11
Donde está el 00:12:13
Donde mando el mail 00:12:14
Y el JTextArea 00:12:16
Podría ser el texto del mail 00:12:19
Tú das 00:12:23
Luego está JTextBox 00:12:24
Que sería una casilla de verificación 00:12:28
Son los cuadraditos 00:12:31
Cuando vosotros tenéis 00:12:33
Una interfaz y tenéis esa cosa cuadrada 00:12:35
Y pincháis y sale V 00:12:37
Y que normalmente se puede solucionar más de una 00:12:38
Pues es este aquí 00:12:40
Os lo recordaré de HTML 00:12:42
Mismas cosas 00:12:44
JRadioButton 00:12:45
Es el radio button 00:12:48
Que es el redondito que normalmente tienes varios 00:12:49
Y tú puedes elegir solo uno de ellos 00:12:52
La diferencia entre estos dos 00:12:55
JList son para hacer listas 00:12:56
JScrollBar para que haya una barra 00:13:01
De desplazamiento para que puedas bajar 00:13:03
Si hay muchas líneas 00:13:05
Y cosas por el estilo 00:13:07
Estos son ejemplos de componentes que hay allí 00:13:08
Algunos de ellos los veremos, algunos de ellos no los veremos 00:13:11
Algunos son más avanzados, algunos son más sencillos 00:13:14
Realmente nosotros empezaremos jugando con estos 00:13:17
Jugando con botones, campos de texto 00:13:20
Y cuando yo pincho el botón hace algo con este campo de texto 00:13:23
Me lo escribe por pantalla, lo cambia, lo modifica 00:13:26
Lo guarda o lo añade a un array o lo que sea 00:13:29
La metáfora que se utiliza a la hora de crear un interfaz gráfico es la idea de que tengo una pared 00:13:34
Y yo voy colocando en esta pared los varios componentes que yo tengo que posicionar 00:13:48
Entonces, esta de aquí será una ventana, la pared sería una ventana del ordenador 00:13:57
Y yo, cuando creo un nuevo objeto, tengo que decirle dónde quiero este nuevo objeto, dónde quiero este nuevo elemento. 00:14:04
Esta foto podría ser un botón, esta de aquí podría ser un campo de texto, no lo sé. 00:14:13
La idea es que yo pueda crear dentro de la pared otros paneles para que pueda organizar dentro de estos paneles los elementos en una determinada forma 00:14:18
Y luego este panel ponerlo en la pared 00:14:32
No sé si me explico lo que queda 00:14:34
Y esto cuantas veces queráis 00:14:37
Componiendo estas cosas de aquí 00:14:38
O sea, tanto elementos metidos directamente en la pared 00:14:42
Como paneles que puedan ayudarme a organizar 00:14:44
Los elementos que están dentro de ese panel 00:14:48
Pues lo que voy creando es zonas de mi interfaz gráfica 00:14:50
Y con el tiempo, o sea, con un poco de curro 00:14:55
Hacer la interfaz gráfica que yo quiero 00:14:58
Tened en cuenta que las interfaces gráficas 00:15:00
Las conocéis 00:15:03
Porque todos habéis utilizado algo 00:15:06
Un formulario, una aplicación 00:15:08
Un algo 00:15:10
Entonces tenéis más o menos en mente la idea 00:15:10
Vosotros sabéis reconocer 00:15:13
Un interfaz gráfico hecho bien 00:15:15
De un interfaz gráfico hecho mal 00:15:16
Si vosotros abrís una aplicación y os sale 00:15:18
Alguien ha dicho IRPF 00:15:20
Os sale 00:15:23
Mil miles de campos 00:15:24
Pequeñitos 00:15:26
Con un montón de label 00:15:28
Un botón escondido y cosas por el estilo 00:15:30
Pues esta no es una interfaz gráfica 00:15:32
Hecha aquí 00:15:34
Entonces normalmente tienen que ser 00:15:35
Relativamente limpias, tienen que ser 00:15:38
Con no muchos 00:15:40
Elementos dentro porque 00:15:42
Si no se confunde el usuario 00:15:44
Si la interfaz gráfica 00:15:45
Es más compleja que escribirlo 00:15:48
Directamente en línea de texto 00:15:50
Habéis hecho un mal trabajo 00:15:51
¿Sí? 00:15:54
Entonces esto es 00:15:56
El equivalente sería que esta que era la pared ahora es una ventana 00:15:57
En automático cuando creo una ventana se me crean estos botoncitos de aquí 00:16:02
Que son los típicos de una ventana para cerrar, para minimizar, para maximizar 00:16:07
Y luego aquí dentro una ventana siempre tiene un panel 00:16:11
Un Jpanel, por defecto 00:16:15
Donde cuando yo pongo los elementos, estos elementos se van colocando aquí 00:16:18
Hay varias formas de colocar los elementos y dependen de lo que es el layout 00:16:23
Yo puedo o decidir que no hay layout 00:16:30
Entonces tengo que poner yo físicamente estos en algunas coordinadas 00:16:34
Por ejemplo, puedo decir esta imagen tiene que ir en la coordinada y esta de aquí 00:16:39
Las coordinadas empiezan siempre que arriba a la izquierda es 0,0 00:16:42
Y entonces tengo que contar los píxeles y los píxeles para mover cuantos píxeles 00:16:46
Con respecto a este punto de aquí, tiene que ir esta imagen 00:16:52
Y si no, hay algunas formas de layout ya predefinidos 00:16:57
Una forma de organizar los datos más o menos predefinida 00:17:03
Y que me da, en vez de tener que estar contando los píxeles, zonas 00:17:07
Por ejemplo, la zona aquí arriba, la zona aquí lateral, la zona abajo 00:17:12
Y yo le digo, mira, este botón 00:17:16
Me lo tienes que poner abajo 00:17:18
Si añado un botón abajo 00:17:19
Me pondrá un botón grande abajo 00:17:21
En toda la zona 00:17:23
Si yo quiero dos botones 00:17:24
¿Qué haré? 00:17:26
Exacto, me creo un panel 00:17:33
Dentro del panel le coloco los dos botones 00:17:35
Y luego aquí abajo añado ese panel 00:17:38
Easy 00:17:40
Lo veremos 00:17:42
Y aquí 00:17:45
Un ejemplo 00:17:49
¿Vale? Entonces, este ejemplo casi ahora lo vamos a hacer físicamente 00:17:50
Pero, o sea, con el eclipse 00:17:57
Pero, sostancialmente, nosotros lo que utilizaremos es el JFrame 00:18:00
¿Vale? JFrame es una ventana, en un cierto sentido 00:18:03
Cuando tú creas un frame, lo que estás creando es una ventana 00:18:08
Se te abre una ventana vacía 00:18:16
Teniendo en cuenta que normalmente 00:18:18
Bueno, hay varias formas de hacer esto 00:18:22
¿Vale? Pero como lo intentaremos 00:18:24
Hacer nosotros es que nuestro 00:18:26
Código, nuestra clase 00:18:27
Que será una ventana, lo que hace 00:18:30
Es extender JFrame 00:18:32
Entonces, cuando yo creo un objeto 00:18:33
Ejemplo, estoy creando 00:18:36
Un objeto JFrame y por lo tanto 00:18:37
Me aparece una ventana 00:18:40
Y en esta ventana 00:18:42
Yo coloco todos los 00:18:44
Elementos y algo 00:18:46
Todas las funcionalidades que yo quiero 00:18:48
¿Vale? Extendiendo un GFrame 00:18:50
Que es una ventana genérica 00:18:52
Y haciendo mi 00:18:54
Interfaz gráfica personalizada 00:18:55
¿Si? 00:18:58
Normalmente 00:19:02
El GFrame tiene un content pane 00:19:03
Bueno, esto es un nombre 00:19:05
Que es un GPanel 00:19:06
Es el fondo de la pared, digamos así 00:19:07
Que yo tengo que utilizar 00:19:10
Para poderle añadir allí 00:19:12
Las cosas que yo quiero 00:19:14
¿Qué puedo añadir allí? Elementos, componentes o otros paneles que han sido creados anteriormente con sus componentes organizados de alguna forma y yo le pego el panel allí. 00:19:15
Es como si yo tengo un tablón de corcho, antes aquí me creo el layout de ese tablón de corcho poniendo las cosas como yo quiero y luego lo pongo en la pared en el sitio donde yo quiero dentro de la pared. 00:19:28
Aquí vienen algunas 00:19:42
Cosillas 00:19:51
Interesantes 00:19:52
Esta de aquí, que dice 00:19:54
Sustancialmente cuando yo 00:19:57
Creo un frame 00:19:59
Este frame es invisible 00:20:00
Y normalmente la buena práctica 00:20:02
Me dice que yo pillo mi frame 00:20:04
Lo construyo entero 00:20:06
Y una vez que he construido entero 00:20:08
Le he añadido las cosas, le he añadido todo lo que tenía que ser 00:20:10
A ese punto lo hago visible 00:20:12
Para hacerlo visible 00:20:15
Frame.setVisible 00:20:16
¿Si? 00:20:20
Esto debería ser 00:20:22
Un comando que yo hago 00:20:24
Cuando ya he hecho todo lo que quería hacer 00:20:26
Para crear mi interfaz gráfica 00:20:29
¿Si? 00:20:31
No al principio, al final 00:20:32
¿Dudas? 00:20:33
Vamos a verlo en acción 00:20:36
¡Opa! 00:20:38
Me voy al Eclipse, me creo un nuevo proyecto Java, lo llamo Windows 1, y aquí me creo una nueva clase. 00:20:40
La clase la llamaré principal. 00:21:06
Esta es la clase principal, que es la que inicia al principio. 00:21:15
vale, entonces yo aquí 00:21:21
le puedo hacer por ejemplo 00:21:24
jframe 00:21:25
win 00:21:28
es igual a new jframe 00:21:29
se me enfada porque 00:21:31
jframe no existe, le digo importar 00:21:35
jframe de javaswim 00:21:38
y ahora existe 00:21:39
he creado un nuevo objeto 00:21:41
jframe 00:21:44
lo lanzo 00:21:45
y voilà 00:21:46
la nada 00:21:49
Porque 00:21:51
Probablemente no es visible 00:21:53
Vale, win 00:21:59
Punto 00:22:00
Set visible 00:22:02
A true 00:22:05
Dale ahora 00:22:06
Aguita 00:22:10
Mi fantástica 00:22:13
Micro ventana 00:22:15
Que no puedo abrir 00:22:17
Ahí 00:22:18
Claro, porque yo he creado una ventana 00:22:18
No le he dicho el tamaño 00:22:22
No le he dicho donde crearla 00:22:24
No le he dicho como se llama 00:22:25
No le he dicho absolutamente nada 00:22:26
Y él lo que me hace es crearme una ventanita 00:22:28
Ahí 00:22:30
¡Voilá! Ya tenéis vuestra interfaz 00:22:31
¿Sí? Venga, ejercicios, mañana examen 00:22:34
Eh... 00:22:38
Puede hacer cosas con esto, ¿vale? 00:22:39
Entonces vamos a hacer cosillas 00:22:42
Como por ejemplo, fijaos en una cosa importante 00:22:44
Ah, no tengo la consola 00:22:47
Cuando vosotros cerráis esto 00:22:48
Fijaos aquí 00:22:51
Chan, chan, chan, chan 00:22:58
¿Qué quiere decir esto? 00:23:02
Que está todavía funcionando 00:23:06
¿Vale? 00:23:08
Yo he lanzado un proceso 00:23:09
Este proceso es mi programa principal 00:23:10
Pero el problema que tenemos aquí 00:23:13
Es que cuando he cerrado la ventana 00:23:15
El proceso sigue allí 00:23:18
Sigue funcionando 00:23:19
¿Vale? 00:23:20
Entonces, si no quiero esto 00:23:22
Solo tengo que decir 00:23:24
Y ahora vamos a ver un poquito 00:23:25
De qué podemos hacer 00:23:27
Sobre esta ventana 00:23:29
¿Vale? 00:23:32
Entonces, por ejemplo 00:23:34
Damosle un nombre 00:23:36
Nombre 00:23:37
¿Vale? ¿Dónde aparece este nombre? 00:23:40
Se lo lanzo 00:23:45
¡Voilá! Aquí tengo mi ventana 00:23:46
Que se llama nombre 00:23:50
¿Lo veis? 00:23:51
Aquí pequeñito 00:23:53
Da nombre 00:24:00
El que le paso por defecto 00:24:01
Es el nombre que se llamará esta interfaz 00:24:04
¿Vale? Entonces aquí estará el nombre 00:24:07
De mi programa 00:24:08
Fijaos, lo cierro y esto no se cierra 00:24:09
Vale, fenomenal 00:24:12
Quiero que nada más 00:24:13
Hacerlo, encenderlo, pues se ve algo 00:24:15
Porque esta es demasiado pequeñita 00:24:19
Vale, le voy a dar un tamaño 00:24:20
¿Cómo se hará darle un tamaño? 00:24:22
Win, punto 00:24:24
Y fijaos que aquí vienen todos 00:24:26
Los miles de cosas 00:24:28
Que puedo hacer con este 00:24:30
Con este 00:24:32
Objeto de aquí, ¿vale? 00:24:35
Estos son todos los métodos que se pueden hacer 00:24:37
Sobre 00:24:39
Un frame, sobre un JFrame 00:24:40
¿Cómo haré 00:24:43
Para 00:24:46
¿Cómo se dice? 00:24:46
Definir el tamaño de una ventana 00:24:50
¿Qué método usaríais vosotros? 00:24:52
Por ejemplo 00:24:56
Set, porque quiero 00:24:57
Configurar algo 00:24:59
Y entre todos los set, pues 00:25:00
Algo que quiere decir tamaño 00:25:03
O sea, no lo sé 00:25:05
Set size 00:25:06
¿Vale? 00:25:07
Existen varios set size 00:25:09
Dos, uno que pilla un objeto dimension 00:25:12
Y uno que pilla dos enteros 00:25:14
Que son width y height 00:25:16
Pues el segundo 00:25:19
¿Vale? 00:25:20
Entonces, ¿cuánto ancho lo quiero? 00:25:23
200 píxeles 00:25:26
¿Cuánto alto lo quiero? 00:25:27
300 píxeles 00:25:31
entonces ahora cuando lanzó este señor mi ventana y hasta no es pequeña como 00:25:33
antes si no es 200 por 300 si esto lo pongo más grande como 500 por 500 00:25:39
claramente ahora me la hace más grande mi ventana 500 píxeles por 500 píxeles 00:25:52
sobre esto depende de la de la interfaz que yo hago vale si yo quiero una 00:26:02
interfaz, tened en cuenta que cuando luego 00:26:06
la hago 00:26:08
más grande o más pequeño 00:26:09
mis objetos aquí dentro 00:26:12
se deberían adaptar 00:26:15
al nuevo tamaño de la ventana 00:26:17
si yo no quiero que esto 00:26:18
sea posible, quiero que la ventana sea 00:26:20
fija, porque si tú me lo haces más grande 00:26:22
o más pequeño, se me descolaja todo 00:26:24
pues puedo aceptar que esta ventana no 00:26:26
sea resizable 00:26:28
¿cómo acepto que la ventana 00:26:29
no sea resizable? 00:26:35
ideas 00:26:41
Exacto, win punto, que más 00:26:42
Podría ser is 00:26:47
Pero cuando algo es is 00:26:51
Es para que tú me devuelvas un booleano 00:26:53
De si es o no es 00:26:56
No para setar 00:26:57
Para setar lo es 00:26:58
Set 00:27:01
Y ahora que quiero 00:27:03
Por ejemplo, habrá resizable 00:27:05
Pues set resizable 00:27:09
Set resizable 00:27:11
Resizable 00:27:15
Es decir, es 00:27:18
Retamañizable 00:27:19
Y yo le digo false 00:27:21
Entonces no eres retamañizable 00:27:23
Por lo tanto, sale así 00:27:26
Y se queda así 00:27:28
Y eso es obligatorio 00:27:29
No, son cosas, parámetros 00:27:32
Que yo puedo poner 00:27:34
Ahora yo la he creado, veis que antes la podía hacer más pequeña 00:27:35
Más grande, ahora no me da la opción 00:27:38
¿Vale? Porque resizable 00:27:40
Lo he puesto false 00:27:42
No es humanamente posible que yo os explique esto 00:27:43
No lo voy a hacer, ¿vale? 00:27:56
¿Cómo vamos a jugar con esto? 00:28:03
Pues la idea es que vosotros entendáis la filosofía que está por detrás 00:28:06
Cómo se juega con estas cosas 00:28:11
Y luego lo vayáis aplicando como os da la gana 00:28:14
Investigando vosotros 00:28:18
Está claro que cuando yo me pregunto 00:28:19
Oye, mira, ¿se puede hacer que esta ventana no cambie de trabajo? 00:28:21
Pues me voy a Google, busco 00:28:25
¿Cómo no cambiar de tamaño? 00:28:26
Y me sale, ponle 6 bolas a false 00:28:29
Y ya está, o me voy al API 00:28:31
En el API viene todo 00:28:33
O lo intento sabiendo un mínimo de inglés 00:28:35
Que necesitéis saber porque si no, no aprobáis 00:28:37
Este curso el próximo año 00:28:39
Que hay inglés 00:28:41
Por lo tanto, eso se necesita 00:28:42
Vamos a hacer otras cosillas 00:28:46
Por ejemplo, hemos dicho que tenemos el problema que cuando cierro la ventana 00:28:50
Lo demuestro otra vez 00:28:55
No se me cierra el programa 00:28:56
A lo mejor es algo que yo quiero 00:28:59
Yo quiero que mi ventana sea mi programa 00:29:03
Cuando cierro esta ventana, quiero acabar el programa 00:29:06
¿Cómo podría hacer esto? 00:29:09
pues me voy otra vez a win, punto, o sea, siempre mi JFrame, y entre todos los métodos que tenemos, hay uno, 00:29:11
on, non, bo, bo, no me acuerdo, ahora lo buscamos un poco, lo tengo allí, pero las cosas se me olvidan, 00:29:24
Set, esto, setDefault 00:29:37
Esto, setDefault 00:29:41
SetDefault 00:29:43
Ahí 00:29:45
Esto, setDefaultCloseOperation 00:29:46
¿Vale? 00:29:51
O sea 00:29:53
¿Cuál es la operación por defecto cuando la ventana se cierra? 00:29:54
Configura 00:30:03
la operación 00:30:04
de cierre por defecto 00:30:09
y sobre esta base de aquí, aquí le puedo poner varios valores 00:30:12
que harán cosas distintas 00:30:17
en particular, si yo hago jFrame 00:30:20
punto, aquí me vienen una serie de valores 00:30:25
¿qué son estos valores de aquí? 00:30:29
¿Qué he hecho? 00:30:31
¿Qué es esto? 00:30:33
Métodos de la clase 00:30:37
Métodos estáticos de la clase 00:30:38
En mayúsculas 00:30:42
Estos quizás sí 00:30:43
Esto es un método estático de la clase 00:30:50
Esto no 00:30:52
¿Qué son estos? 00:30:53
¿Subclases? 00:31:05
Estos de aquí con paréntesis son métodos 00:31:06
Métodos estáticos 00:31:13
¿Cómo sé que son estáticos? 00:31:14
Porque los estoy llamando sobre la clase 00:31:17
No sobre el objeto 00:31:25
No estoy haciendo win punto 00:31:26
Estoy haciendo jframe punto 00:31:27
¿Eh? 00:31:29
Y son estáticos 00:31:32
Métodos estáticos 00:31:33
Vale, fenomenal 00:31:34
¿Y estos? 00:31:34
¿Más métodos? 00:31:42
No son métodos 00:31:44
Entonces si no son métodos 00:31:45
Son atributos 00:31:46
Pero fijaos 00:31:47
¿Cómo se escriben los atributos? 00:31:49
En minúsculas 00:31:50
En minúsculas 00:31:51
¿Y cuando son mayúsculas? 00:31:51
Efectivamente 00:31:55
Estos son constantes 00:31:55
¿Vale? 00:31:57
Son final 00:31:58
¿Sí? 00:31:58
Lo pone aquí 00:31:59
Estos son static final int 00:32:00
Aboard 00:32:03
Estos son valores 00:32:04
Son numeritos 00:32:07
3, 7, 4, 96 00:32:08
Pero en vez de tenerle aquí que poner 00:32:10
JFrame 00:32:13
Set close operation 3 00:32:14
No tengo ni idea 00:32:17
De que es 3 00:32:19
Porque no lo tengo idea 00:32:20
Pues lo que hacen ellos es 00:32:22
Definir una serie de variables 00:32:24
Finales 00:32:26
Que son ese numerito 00:32:28
Que describen 00:32:29
Que hacer 00:32:32
Aquí, por ejemplo 00:32:33
Dispose on close 00:32:35
Cuando cierre, haga dispose 00:32:36
Para él es el número 4 00:32:40
Algo para decir 00:32:42
Si yo escribo 4, hace exactamente lo mismo 00:32:43
Pero para mí es más claro 00:32:46
Saber que esta ventana 00:32:48
Cuando se cierra, se disposa al cerrarse 00:32:49
Quiere decir, idea 00:32:52
Vamos a usar 00:32:54
Exit on close 00:32:56
Entonces, ¿cuál es 00:32:57
La operación por defecto 00:32:59
Al cerrar 00:33:04
Este frame 00:33:06
Pues el que está codificado 00:33:07
El numerito que está codificado 00:33:10
Dentro del JetFrame 00:33:12
Como exit on close 00:33:14
O sea que al cerrarlo quiero hacer una exit 00:33:15
O sea salir del programa 00:33:18
Podría hacer otra cosa 00:33:20
No, porque si fuera por defecto 00:33:23
Cuando yo lo cierro se habría cerrado 00:33:28
Entonces por defecto es otro 00:33:29
¿Cuál es por defecto? No lo sé, vete al app y míralo 00:33:35
No puedo saber todo yo 00:33:38
Y ahora si os fijáis 00:33:39
Lanzo este señor 00:33:43
Fijaos que está ranando 00:33:45
Porque aquí está rojo 00:33:47
¿Sí? 00:33:48
En el momento en que cierro la ventana 00:33:50
Fijaos que ahora 00:33:53
Se ha parado 00:33:54
Nota, cuidado a no hacer esto 00:33:55
Y luego empezar a probar 00:34:02
62.000 veces vuestro programa 00:34:04
Y tener al final 62.000 00:34:06
Procesos 00:34:10
Activados en vuestro ordenador 00:34:11
Mientras vosotros continuáis 00:34:13
A probar y probar y probar 00:34:15
El mismo programita 00:34:16
¿Si? Cuidado 00:34:18
Cerrar la ventana 00:34:20
No implica que se cierre 00:34:23
El programa si tu no lo has dicho 00:34:25
¿Si? 00:34:26
¿Que mas podemos hacer nosotros? 00:34:31
Ah no me acuerdo el método 00:34:33
pero bien punto locatio no casete lo que es un relativo si tengo este programa está aquí 00:34:35
está aquí set location relative tú y le digo nul esto es configura la locación de este frame con 00:34:45
Con respecto a 00:34:59
Null 00:35:01
Tú lo haces con respecto a otra cosa 00:35:02
Con respecto a otra cosa 00:35:05
Si tú le pones null 00:35:07
El efecto que haces es que se te abre 00:35:08
En el medio 00:35:11
Es una forma fácil 00:35:13
Para que la ventana no se te abra aquí 00:35:18
Si no se te abre en el medio 00:35:20
Tú configurando 00:35:22
Location que habéis visto 00:35:24
Que si hago 00:35:26
Que si hago win 00:35:27
punto set location 00:35:30
aquí hay 00:35:32
varios set location 00:35:34
¿vale? by platform 00:35:36
directamente location 00:35:38
relative to cosas de este 00:35:40
estilo ¿vale? yo puedo 00:35:42
hacer que esta se abra en una 00:35:44
coordinada cualquiera de mi 00:35:46
pantalla ¿vale? la 00 00:35:48
¿cuál será? arriba 00:35:50
a la izquierda, si yo pongo 00:35:52
200, 700 se me abrirá 00:35:54
200, 700, si yo le 00:35:56
Pongo 00:35:58
Pilla el tamaño de mi monitor 00:35:59
Y divídelo por dos 00:36:02
Y luego pilla la altura de mi monitor 00:36:04
Y divídelo por dos 00:36:05
Pues también lo pondré más o menos centrado 00:36:06
O si no 00:36:11
Uso esto 00:36:12
Pasándole un null 00:36:14
Y si le paso eso a null 00:36:15
Él en automático 00:36:17
Pilla el tamaño de mi monitor 00:36:18
Y me lo pone en el centro 00:36:20
Cuidado 00:36:20
Y ya lo habéis visto en 00:36:24
Lenguaje Marcas 00:36:26
Con eso de los 00:36:29
De los píxeles 00:36:31
Porque como cada pantalla 00:36:32
Tiene una resolución distinta 00:36:35
Un número de píxeles distinto 00:36:37
Lo que se ve bien en tu pantalla 00:36:38
800x600 00:36:41
Se ve fatal en una 4K 00:36:42
Entonces cuidado 00:36:45
En HTML es CSS 00:36:49
Y eso se soluciona 00:36:54
Un poquito con el porcentaje 00:36:56
Pero no mucho 00:36:58
¿Vale? 00:37:01
Y luego hay problemas también con el porcentaje 00:37:02
Pues aquí se soluciona de otras formas 00:37:05
Que a lo mejor veremos un poquito más adelante 00:37:07
El importante es 00:37:09
Que al final acabe bien 00:37:11
Ya esto 00:37:13
El poner resize de bola false 00:37:14
Es una ventaja 00:37:17
Porque impide 00:37:18
Que la gente cambie el tamaño 00:37:20
Y se te estropee toda tu interfaz 00:37:23
¿Vale? 00:37:25
Ese es el tamaño 00:37:26
Ahora, si yo hago una ventana 00:37:27
Que por defecto es 00:37:30
2000x2000 00:37:31
Y luego la intento abrir 00:37:32
En una pantalla 800x300 00:37:34
Tengo un problema 00:37:37
¿Sí? 00:37:38
¿Dudas? 00:37:45
¿Sí? 00:37:48
Entonces 00:37:49
Si os fijáis aquí yo tengo una clase principal 00:37:50
Estoy utilizando directamente JFrame 00:37:53
¿Vale? 00:37:55
JFrame tiene sus características 00:37:56
Y si yo quiero crear mi propia ventana 00:37:58
Hacer una ventana mía 00:38:02
Que yo pueda utilizar 00:38:04
Entonces me creo mi ventana 00:38:06
New 00:38:08
Class 00:38:10
Mi ventana 00:38:11
Esta clase 00:38:14
Mi ventana para que sea 00:38:18
Un JFrame 00:38:19
Vale 00:38:21
Y ahora esta 00:38:30
¿Qué hago aquí? 00:38:32
Public 00:38:36
Mi ventana 00:38:37
Constructor 00:38:39
Con string 00:38:40
N, por ejemplo 00:38:43
¿Qué hago? 00:38:44
¡Súper! 00:38:49
Antes 00:38:53
Lanzo el constructor del GFrame 00:38:53
Que es el que me construye la ventana 00:38:56
¿Sí? 00:38:58
Y después hago lo que quiero hacer 00:38:59
Para mi ventana 00:39:02
Que en general es 00:39:03
¡Esto! 00:39:05
Pero fijaos 00:39:11
Ahora uso win 00:39:12
¿Qué uso? 00:39:13
Mi ventana 00:39:15
Nope 00:39:24
Porque para hacer eso, setSize debería ser 00:39:28
Static 00:39:33
Pero antes no lo he usado como static 00:39:35
SetSize no es un método estático 00:39:37
Entonces, ¿sobre qué lo uso? 00:39:39
Ay, señores 00:39:48
Las torrijas 00:39:49
Claro, me tengo que crear un objeto 00:39:51
Nope 00:39:55
No, lo estoy construyendo el objeto 00:39:55
Estoy en el constructor de este objeto 00:39:57
¿Qué hago? Me construyo otro objeto 00:39:59
Que luego necesito otro objeto 00:40:00
Que luego necesito otro objeto 00:40:01
Entro en un loop infinito 00:40:02
Super 00:40:04
Soy una ventana 00:40:06
Por lo tanto puedo 00:40:13
Setar mi size 00:40:14
Soy una ventana 00:40:15
Es más 00:40:17
Voila 00:40:19
Este método 00:40:21
Está en mi clase 00:40:25
Lo he extendido desde aquí que está en mi clase 00:40:27
Entonces este es un método que está en mi clase 00:40:30
Está aquí abajo, no lo veis 00:40:32
Pero porque no veis la extensión 00:40:33
Entonces lo puedo llamar 00:40:35
Directamente así 00:40:38
Y ahora tengo mi ventana 00:40:39
Que es mi interfaz gráfica que puedo lanzar 00:40:47
Está claro que 00:40:49
Fijaos que aquí no hay un main 00:40:50
Cuando estoy en el principal 00:40:52
Para lanzar 00:40:54
Una de estas ventanas 00:40:56
Lo único que tendré que hacer es que 00:40:58
Mi ventana win 00:41:00
Es igual a new 00:41:02
Mi ventana 00:41:04
Y si no la quiero 00:41:06
Utilizar aquí dentro 00:41:15
Porque este programa lo único que hace 00:41:16
Lanzarme la interfaz gráfica y luego sea lo que sea 00:41:19
Hasta puedo hacer así 00:41:21
Creo un objeto nuevo 00:41:23
En mi ventana 00:41:28
¿Qué hará? Pues lanzará esto 00:41:29
Crea la ventana 00:41:32
Y acepta todo lo que sea 00:41:33
Y luego se pone en vídeo 00:41:35
Exactamente lo mismo que antes 00:41:36
Solo que ahora he separado 00:41:42
Lo que es mi lanzador 00:41:46
De lo que es el objeto ventana 00:41:47
Que es mi interfaz 00:41:50
¿Dudas? 00:41:50
Si cierro, cierra 00:41:54
Porque siempre éxito en Clubs 00:42:04
Dudas 00:42:05
Preguntas 00:42:12
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
9
Fecha:
11 de abril de 2023 - 14:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 18″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
353.84 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid