Saltar navegación

Clase 06-05-24 - 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 6 de mayo de 2024 por Raquel G.

22 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces se supone que esto es un editor de texto, es decir, para hacer cosas con ficheros de texto. 00:00:01
Entonces, hay que entender siempre bien la aplicación completa, el contexto de la aplicación antes de plantearse hacer algo. 00:00:11
Hay que entenderla bien, hay que tenerla bien descrita. 00:00:17
Entonces, esta aplicación va a trabajar con ficheros de texto. 00:00:21
ese es 00:00:25
su contenido de trabajo 00:00:28
igual que otro podía ser cliente 00:00:32
otros facturas, este es ficheros de texto 00:00:34
entonces 00:00:36
antes de empezar a trabajar 00:00:38
con datos 00:00:40
y hacer funcionalidades hay que plantearse 00:00:41
dónde van a estar guardados 00:00:45
cómo van a estar guardados esos datos para trabajar con ellos 00:00:46
entonces el diseño 00:00:49
de los datos, la parte de diseño 00:00:50
de los datos tiene muchísima importancia 00:00:52
como os he dicho muchas veces 00:00:54
Con la parte de diseño me refiero a 00:00:55
Dónde y cómo van a estar guardados los datos 00:00:58
Cuando ya lo tengamos claro 00:01:02
Uno ya hace funcionalidades 00:01:03
Que en última instancia 00:01:05
Las funcionalidades de una aplicación 00:01:08
Son siempre coger datos 00:01:09
Hacer tonterías con ellos 00:01:11
Y guardarlos otra vez 00:01:13
O llevarlos de un sitio a otro 00:01:14
Eso es una aplicación en realidad 00:01:17
Coger datos y llevarlos de un lado para otro 00:01:18
Por tanto es importantísimo 00:01:21
Tener clarísimo cuando uno hace una aplicación 00:01:23
esos datos, cuáles son 00:01:25
dónde van a estar almacenados y cómo 00:01:27
lo habitual es una base de datos 00:01:29
pero en nuestro caso ahora no lo es 00:01:31
bueno, pues estos datos de esta aplicación 00:01:32
cuáles son 00:01:35
ficheros de texto, son ficheros de texto 00:01:37
porque es una aplicación que trabaja con ficheros 00:01:40
de texto para visualizarlos 00:01:41
en la pantalla 00:01:44
permitirme cambiar su 00:01:45
contenido 00:01:47
para que tenga otro 00:01:48
contenido 00:01:51
cuando habrá utilidades por ahí 00:01:52
cuando selecciono estas utilidades 00:01:55
pues las mayúsculas 00:01:57
que tenga pasarlas a minúsculas 00:01:59
es decir, con lo que 00:02:01
trabaja esta aplicación son ficheros 00:02:03
de texto, que es sobre 00:02:05
los que hace cosas 00:02:07
una vez que está claro con qué 00:02:08
trabajamos, con qué material trabajamos 00:02:11
¿dónde lo vamos a guardar? 00:02:14
hombre, en una aplicación real 00:02:16
los ficheros de texto se guardarían en el 00:02:17
disco duro, en un fichero con un 00:02:19
nombre. Pero aquí nosotros no podemos tenerlos ahí porque no sabemos todavía cómo coger 00:02:21
datos de un fichero que está en un disco duro. Nosotros solo sabemos trabajar hasta 00:02:29
ahora solo con la información que está en variables. Y esa información que está en 00:02:33
variables se la damos nosotros en el momento en que la aplicación se ejecuta, en el momento 00:02:38
en que se ejecuta y solo en ese momento, se la damos o bien por consola con el escáner 00:02:44
o bien en una interfaz gráfica 00:02:49
donde metemos en áreas de texto 00:02:52
y la interfaz la recoge 00:02:54
¿vale? hasta ahora es nuestra 00:02:55
única manera de tener datos 00:02:58
en variables que rellenamos 00:02:59
en el momento en el que la aplicación arranca 00:03:02
no tenemos 00:03:04
no somos capaces de coger datos de ficheros 00:03:06
luego esta aplicación tenemos 00:03:08
que simular como si nuestros datos 00:03:10
estuvieran en ficheros pero no lo van a estar 00:03:12
bueno pues ¿dónde van a estar? 00:03:14
pues la propuesta que se hace en el ejercicio 00:03:16
los ficheros van a estar en un 00:03:19
map, cada fichero recibe 00:03:22
un nombre, eso está claro 00:03:24
cada fichero recibe un nombre 00:03:26
y todos los ficheros de un sistema 00:03:28
operativo tienen que tener nombres distintos 00:03:30
con nombres me refiero 00:03:32
si consideramos como nombre la ruta entera 00:03:34
¿vale? si están en diferentes carpetas 00:03:36
cuando tenemos nombre, pero bueno 00:03:38
bueno, pues entonces el nombre del fichero es la clave 00:03:40
¿vale? pues la clave es el nombre 00:03:42
del fichero, y el contenido del 00:03:44
fichero si es de textos, una cadena de textos 00:03:46
Que se puede meter en un string 00:03:48
Luego estupendo 00:03:50
Nuestros ficheros vamos a simular 00:03:51
Que están en un map 00:03:53
Vale 00:03:56
Entonces cuando la aplicación arranque 00:03:56
Inicialmente no habrá ningún archivo 00:03:59
Pero no pasa nada porque podemos empezar a crearlos 00:04:01
A través de la opción new 00:04:04
De esta de aquí 00:04:05
Entonces ya podemos hacer 00:04:07
Nuestro primer boceto de la aplicación 00:04:09
Que tiene los datos en un map 00:04:11
Nos construimos la interfaz 00:04:14
Y una vez que nos la hemos construido 00:04:16
Pues nos ponemos ya a dar 00:04:18
Funcionalidades 00:04:20
A esto de aquí 00:04:21
¿Vale? 00:04:23
Bueno, pues entonces 00:04:26
Vamos a ir 00:04:28
Haciendo esta aplicación 00:04:35
Vale, pues a ver, entonces 00:04:36
Venga 00:04:56
Aplicación, editor de texto 00:05:03
Por ejemplo, como la queráis llamar 00:05:06
Vale, pues venga 00:05:08
Los datos nuestros 00:05:23
Vamos a hacer 00:05:25
Un paquete aparte 00:05:28
que sea, vamos a llamarlo ficheros 00:05:29
porque ahí es donde van a estar los ficheros 00:05:32
un paquete de ficheros 00:05:33
y ahora, los ficheros van a estar 00:05:36
en un map, ese map tendrá que estar 00:05:38
en alguna clase, pues venga 00:05:39
nos hacemos una clase 00:05:41
que se llame ficheros, por ejemplo 00:05:43
y ahora nuestros datos 00:05:47
nuestros datos, que son 00:05:56
los ficheros, que son el map, pueden ir aquí 00:05:58
por ejemplo 00:06:00
a ver, ala 00:06:01
aquí tenemos, aquí van a ir 00:06:17
nuestros ficheros, inicialmente vacío 00:06:26
¿vale? entonces 00:06:29
para facilitarnos 00:06:30
el acceso a estos datos, como solamente 00:06:32
va a haber un map de ficheros en toda 00:06:34
la aplicación, solo va a haber un map de ficheros 00:06:36
pues vamos 00:06:38
a hacerlo, variable public 00:06:40
y static 00:06:42
pero claro, static porque 00:06:43
solamente va a haber 00:06:46
una colección de ficheros en la aplicación 00:06:48
que es esta, una colección, la que hemos ubicado 00:06:50
aquí, entonces la podemos hacer 00:06:52
static 00:06:54
y al hacerla public 00:06:55
facilitamos el acceso a esta colección 00:06:57
de ficheros con el nombre de la clase 00:06:59
punto ficheros, lo que hemos hecho siempre 00:07:01
vale, pues ya está 00:07:03
aquí están estos datos 00:07:05
luego aquí, según uno vaya haciendo la aplicación 00:07:07
a lo mejor aquí 00:07:10
esto queda más bonito 00:07:11
si vamos haciendo 00:07:13
métodos que me permitan hacer cosas con estos 00:07:15
ficheros, vale 00:07:17
pues por ejemplo 00:07:19
recuperar fichero dado clave 00:07:20
que tendrá dentro un get 00:07:23
pues 00:07:25
cualquier funcionalidad 00:07:26
que vayamos identificando que luego la aplicación 00:07:29
va a hacer, con los ficheros 00:07:31
si la metemos aquí como método 00:07:33
pues luego la aplicación nos va a quedar más bonita 00:07:35
porque ya vamos a ese método y ya está 00:07:37
entonces aquí en principio irían 00:07:39
si luego va surgiendo 00:07:41
irían 00:07:43
métodos para hacer 00:07:44
cosas 00:07:47
con los ficheros del map 00:07:48
que cosas 00:07:51
las que la aplicación vaya necesitando hacer 00:07:54
¿vale? que siempre será mejor 00:07:55
que esté aquí recogido eso 00:07:59
que no que esté en la interfaz gráfica 00:08:01
todo lo que se haga con los ficheros, que esté ahí todo metido 00:08:03
porque entonces está junto 00:08:05
la vista con la lógica 00:08:07
bueno, pues aquí irían esos 00:08:09
métodos que ya veremos a ver si nos va 00:08:13
interesando meter alguno 00:08:14
y ahora vamos a hacer la vista 00:08:16
que la vista ahora ya sí que es 00:08:19
hacer este menú 00:08:20
hacer este menú y luego habrá que darle 00:08:21
el comportamiento, que es darle opciones 00:08:24
a los botones 00:08:26
bueno, vamos a hacernos en el paquete 00:08:27
vista 00:08:30
nuestro frame 00:08:32
pues si lo 00:08:41
hacemos con el builder, por comodidad 00:08:43
pues ya sabemos 00:08:45
como hacerlo 00:08:47
vale, ya vamos a la 00:08:47
ventana, editor, texto 00:08:54
jolín, pues si que está cargando 00:08:56
eso 00:09:27
vale, pues el frame 00:09:28
ya nos ha hecho lo estándar de toda la vida 00:09:51
ya nos ha hecho 00:09:53
lo estándar 00:09:55
crear un panel vacío 00:09:56
y ya está 00:09:59
y dar la opción de que cuando cerremos 00:10:01
el frame, la aplicación cierre 00:10:03
le fija un tamaño, una colocación 00:10:05
inicial al frame, etc 00:10:10
vale, ahora es 00:10:11
cuando tenemos que reproducir 00:10:17
nuestra vista, que es 00:10:19
poner este menú, por ahora sin comportamiento 00:10:20
vale, pues 00:10:22
entonces 00:10:25
estos 5 o 10 00:10:25
minutos de ahora, dedicadlos a ver 00:10:29
si encontráis 00:10:30
cómo construir ese menú ahí 00:10:31
y ahora lo 00:10:34
vale 00:10:37
Miguel, de todas formas si me lo vas 00:10:53
subiendo 00:10:55
el proyecto, para cuando pueda mirarlo 00:10:56
que me decías que no te funcionaba 00:10:59
del este, porque 00:11:00
si lo miro en tu este, voy a ver ahí 00:11:03
200.000 cosas escritas y no voy a saber ni de qué 00:11:05
me estás hablando, entonces aquí me voy a organizar 00:11:07
mejor, ¿vale? 00:11:09
ay, que estaba aquí grabando 00:12:08
repito 00:12:09
vale, pues esto después de uno 00:12:12
buscar, averiguar, mirar por ahí 00:12:14
en documentaciones, en Spacoverflow 00:12:16
donde sea, pues ya 00:12:18
ve que un menú está formado 00:12:19
por tres tipos de 00:12:22
componentes, la 00:12:23
barra de menú, que va asociado 00:12:25
un panel, un panel puede tener 00:12:27
una barra de menú 00:12:29
la barra de menú que es el 00:12:30
JMenuBar, luego a la barra 00:12:33
de menú se pueden anclar 00:12:35
diferentes menús, este 00:12:37
es uno, este es otro, eso 00:12:39
será el JMenu y luego 00:12:41
a cada menú 00:12:43
ahora ya se agregan los diferentes 00:12:45
ítems, que estos ya sí que son 00:12:47
los que recogen el evento 00:12:49
normalmente, entonces tres 00:12:51
componentes, la barra de menú JMenuBar 00:12:53
que se acopla a un panel 00:12:56
a la JMenuBar 00:12:57
van los JMenus 00:12:59
que son estos 00:13:01
y luego a cada JMenu 00:13:02
van los 00:13:03
los ítems 00:13:04
entonces 00:13:07
de hecho 00:13:09
una vez que uno ya 00:13:10
más o menos ha visto 00:13:11
que son tres componentes 00:13:12
los que hacen falta 00:13:14
pues los busca aquí 00:13:14
entonces estos son 00:13:17
ahora 00:13:18
cuando uno 00:13:18
como surgió con lo de 00:13:20
FileChooser y todo 00:13:21
cuando uno se pone a buscar 00:13:22
en la paleta ahí 00:13:24
como loco 00:13:24
a ver, en la paleta que hay 00:13:25
unos cuantos 00:13:27
componentes, contenedores 00:13:29
no está todo, que es lo que está 00:13:31
está la mayor parte de los 00:13:33
componentes y además los que 00:13:35
uno pone ahí y van a estar ahí 00:13:37
todo el tiempo de vida 00:13:39
la aplicación, no son 00:13:41
componentes pensados para que 00:13:45
aparezcan o desaparezcan como resultado 00:13:47
de eventos, como el jOptionPane 00:13:49
como el FileChooser, por eso no los ponemos 00:13:51
desde aquí, esos son los 00:13:53
instanciamos a consecuencia de la captura 00:13:55
de un evento, entonces este menú 00:13:57
si que va a estar ahí todo el rato, entonces tiene sentido 00:13:59
que lo busquemos en la paleta 00:14:01
pues de hecho vemos que hay una carpetita 00:14:03
que pone menú donde ya está directamente 00:14:05
todos los elementos relacionados con el menú 00:14:07
entonces viene un JMenuBar 00:14:09
que uno puede 00:14:11
cogerlo y arrastrarlo, yo es que ya 00:14:13
tengo un agregado 00:14:15
lo arrastra al panel, se le pone la 00:14:16
rayita y ahí ya 00:14:19
tiene el menú bar arrastrado, luego 00:14:21
al menu bar puede ir arrastrándolo 00:14:23
por ejemplo yo ya tengo dos 00:14:25
pero podría poner otro más 00:14:27
ahí ya tengo otro 00:14:28
que quiero otro elemento de menú más 00:14:30
pues ahí tengo otro 00:14:32
una vez que los tengo, claro, los selecciono 00:14:33
para cambiar aquí las propiedades 00:14:37
que en este caso 00:14:39
son el nombre de la variable 00:14:41
deseable, si se lo cambio 00:14:43
y sobre todo el texto que hay encima 00:14:44
eso lo cambiamos aquí en properties 00:14:46
ahí el nombre de la variable 00:14:49
y aquí en text 00:14:51
el texto que queremos que aparezca 00:14:53
vale, a cada menú 00:14:55
ahora ya le quiero añadir ítems 00:14:57
pues jMenuItems, lo voy a 00:14:59
este ya tiene uno, que quiero que tenga 00:15:01
que quiero que tenga otro más 00:15:03
ya tiene otro 00:15:06
jolín, que estoy haciendo, ahí 00:15:08
vale 00:15:10
a cada ítem de menú de nuevo 00:15:12
pues lo natural es que 00:15:15
yo en las propiedades le cambie el nombre 00:15:17
de la variable y el nombre del texto 00:15:19
que está encima, que está en text 00:15:21
y ya está, y así puedo ir formando 00:15:22
un menú, vale, voy a quitar 00:15:25
estos 00:15:27
que he hecho nuevos 00:15:29
y este de aquí 00:15:30
entonces, en la estructura 00:15:39
esta jerárquica 00:15:44
de la izquierda, donde nos aparece la jerarquía 00:15:45
de componentes que tenemos 00:15:49
que esta no la perdamos de vista porque es 00:15:50
la mejor foto de lo que tenemos 00:15:52
pues se ve todo claro 00:15:54
tenemos el frame 00:15:56
la barra de menú 00:15:58
de la barra de menú 00:15:59
cuelga el menú archivo 00:16:02
estos son los nombres que yo le he ido dando a las variables 00:16:03
y al texto 00:16:06
menú archivo 00:16:06
de menú archivo cuelgan 5 00:16:09
ítems 00:16:11
los nombres de variables que yo le he dado son estos 00:16:12
pero podéis darle que os dé la gana 00:16:15
ahora de la barra de menú 00:16:16
también cuelga menú de utilidades 00:16:19
con 4 ítems 00:16:21
vale entonces 00:16:23
aquí 00:16:25
se ve todo lo que hemos colocado 00:16:26
entonces si yo miro a ver 00:16:31
qué aspecto tiene, pues bueno, vale justo 00:16:34
es el menú que quería 00:16:36
archivo con cuatro opciones 00:16:37
y utilidades 00:16:40
con otras cuatro 00:16:42
¿vale? entonces la vista está 00:16:44
ah bueno, no, a ver, la vista 00:16:50
no está porque me falta el área de texto 00:16:53
para visualizar los archivos 00:16:55
claro, el área de texto 00:16:57
está en la vista, casi está 00:16:59
vale 00:17:02
¿qué nos falta? 00:17:04
nos falta este panel 00:17:05
este área de texto en blanco 00:17:08
que es el área de visualización de los archivos 00:17:13
entonces el área de visualización 00:17:15
de los archivos 00:17:17
un textfield no tiene sentido que sea 00:17:18
porque un textfield es solo para una línea 00:17:20
de contenido, para una línea 00:17:22
no admite saltos de línea 00:17:24
entonces para un contenido con saltos de línea 00:17:25
tiene que ser un textarea 00:17:29
entonces eso es lo que nos falta 00:17:30
un textarea y ya está 00:17:32
nuestro editor de texto tiene todos los elementos 00:17:34
que necesita 00:17:36
Pues le vamos a poner un text area 00:17:37
Al panel 00:17:41
Bueno, al panel le voy a poner el 00:17:41
El layout 00:17:50
Absoluto, que no se lo había puesto todavía 00:17:51
Así que por eso no me deja 00:17:54
Colocar el área de texto donde a mi me dé la gana 00:17:56
Así que a ver 00:17:58
Que no quiero 00:18:01
A ver 00:18:02
Vale, vamos a poner el panel 00:18:07
Que no se nos olvide, absoluto 00:18:10
Y ahora aquí ya está el panel 00:18:12
con el layout absoluto, vamos a llevar 00:18:15
un área de texto 00:18:17
muy grandota 00:18:18
ahí, por ejemplo 00:18:20
ala, ahí van a ir 00:18:26
los archivos, en esa área de texto blanca 00:18:36
apenas se distingue del fondo 00:18:38
si le pusiéramos poner al panel 00:18:42
a ver 00:18:44
es que nunca 00:18:48
nunca acierto en la 00:19:13
En la variable hay que cambiar 00:19:15
Para cambiar el color del panel 00:19:18
Porque el foreground no 00:19:20
A ver, background, ¿será este? 00:19:23
¿O no? 00:19:30
Ah, sí, vale 00:19:37
Vale, así se ve un poco más el 00:19:38
Este, entonces 00:19:47
Bueno, pues nada 00:19:52
La vista ya está 00:19:57
Ahora ya hay que dar funcionalidad 00:19:58
A los componentes que la tengan 00:20:01
En este caso 00:20:03
¿Qué componentes van a tener funcionalidad? 00:20:05
Estos 5 de archivo 00:20:09
Y estos 4 de utilidades 00:20:11
Vamos a ver el diseño de fuente 00:20:12
Cómo nos ha generado 00:20:16
El código fuente 00:20:18
Para estos componentes que hemos añadido 00:20:20
Silencio 00:20:22
Eso es de atrás 00:20:24
Vale, pues efectivamente nos ha creado 00:20:24
Una barra de menú 00:20:28
Y al frame le ha puesto 00:20:29
La barra de menú 00:20:32
Esto es como si fuera un disk 00:20:33
Como ya sabéis, si no aparece nada es que es un dis 00:20:34
¿Vale? Es que antes, perdonad, antes 00:20:36
Estaba diciendo panel cuando quería decir frame 00:20:38
O sea, la barra de menú va a un frame 00:20:40
¿Veis? Al frame, que es a este 00:20:42
Va a la barra de menú 00:20:44
¿Vale? 00:20:46
Vale, tenemos la barra de menú 00:20:48
Ahora, a la barra de menú se le va añadiendo 00:20:49
Cada uno de los menús que hemos hecho 00:20:51
El archivo, el nuevo 00:20:54
El abrir, el guardar 00:20:56
Como y el cerrar 00:20:58
¿Veis? 00:21:00
A la barra de menú le añade el menú archivo 00:21:04
Y al menú archivo 00:21:06
Que es este, le va añadiendo 00:21:08
Cada uno de los ítems 00:21:10
Eso es lo que nos ha generado, es fácil de entender 00:21:11
¿Vale? Y aquí lo mismo 00:21:14
Este es menú utilidades, que se lo ha puesto 00:21:20
A la barra de menús 00:21:22
Y ahora a menú utilidades le va añadiendo 00:21:23
Cada uno de ellos, de los ítems 00:21:26
Cada uno de los ítems 00:21:27
Y ya está, y luego ya le ha puesto 00:21:28
El colorcito al panel 00:21:31
Que la de foreground esta no valía para nada, creo 00:21:33
Vale 00:21:36
Era la de background la que lo daba 00:21:38
Esta 00:21:40
Y ya está, no he hecho nada más 00:21:40
Bueno, pues entonces, los elementos que reciben eventos 00:21:44
Son estos, son 00:21:46
Cada uno de los ítems 00:21:48
Cada uno de los ítems 00:21:52
Son 00:21:54
Estos de aquí 00:21:54
Archivo 1, archivo 2, archivo 3 00:21:57
Entonces 00:22:01
Podemos 00:22:02
Ir un poco a lo vago 00:22:03
y desde aquí 00:22:05
a cada uno de estos 00:22:09
hacerle un add event handler 00:22:13
y un action performed y ya está 00:22:16
a cada uno de ellos y ya hacemos en cada uno de ellos lo que toque 00:22:18
o podríamos hacer 00:22:22
una única clase interna y que esa clase 00:22:25
interna como tenemos un montón distinga 00:22:28
cual de ellos es el que ha 00:22:31
el que ha llamado a 00:22:34
Al evento 00:22:37
¿Vale? 00:22:39
Lo podríais hacer un poco como quisierais 00:22:41
Si fuera una unidad de clase interna, pues quedaría muy larga 00:22:42
Porque tendría ahí un switch case muy enorme 00:22:45
En el caso de que el botoncito 00:22:47
Que se activó 00:22:49
Fuera igual al ítem nuevo 00:22:51
Bla, bla, bla 00:22:53
En el caso de que fuera igual al ítem en abril, bla, bla, bla 00:22:53
¿Vale? 00:22:56
A mí casi me gusta más así 00:23:04
Y de hecho 00:23:08
pero no es que tenga 00:23:10
un criterio muy definido porque 00:23:13
efectos prácticos es lo mismo en realidad 00:23:14
efectos de computacionales 00:23:16
es igual, es como te guste a ti más el código 00:23:19
entonces 00:23:21
normalmente con el plugin del builder 00:23:22
te permite generarlo fácilmente, de la otra manera 00:23:24
uno lo hace así y no se lo plantea 00:23:27
pero para variar, para no hacerlo 00:23:28
siempre como te lo hace el builder, vamos a hacerlo 00:23:31
nosotros con una única clase interna 00:23:33
recogiendo cada botón, pero no porque 00:23:34
yo diga si es mejor, porque tampoco es que 00:23:37
tenga un criterio definido porque depende muchas veces 00:23:39
de el tipo de software que estés haciendo 00:23:41
con quien estés trabajando, etc. 00:23:43
¿Vale? Entonces repito 00:23:46
¿Qué alternativas tendría uno? Pues a cada 00:23:47
uno de ellos le hace esto y le dice 00:23:49
venga, añádeme un gestor de 00:23:51
¿Cómo es el evento por defecto? 00:23:52
De un ítem de menú 00:23:55
podemos dar por hecho que el evento por 00:23:56
defecto de un ítem de menú es hacer click 00:23:59
Entonces aquí con 00:24:00
seleccionar la acción performance, ese sería 00:24:02
el que estamos buscando, porque 00:24:05
el ActionPerformance es el evento por defecto 00:24:06
y en un ítem de menú 00:24:09
cuál va a ser por defecto, sino el de 00:24:11
hacer clic, entonces si fuéramos 00:24:13
vagos, pues eso, vamos uno por uno 00:24:15
haríamos esto 00:24:16
y ya está, y este efectivamente 00:24:20
cuando ha creado el menú de ítem 00:24:22
archivo 1, en ese me hace la clase interna 00:24:24
entonces si lo hacemos con el 00:24:26
Builder, esto 00:24:28
me lo va a hacer para todos 00:24:30
archivo 1, archivo 2, archivo 3 00:24:32
entonces bueno, está bien 00:24:34
o mal, a mí es que se me hace un poco pesado 00:24:36
ver tantas clases anónimas 00:24:38
dentro del constructor 00:24:40
una por cada archivo 1 00:24:41
ahora otra para archivo 2, otra para archivo 3 00:24:44
entonces vamos a hacer una única clase interna 00:24:46
aparte, que distinga 00:24:48
quien llamó al evento 00:24:50
y en función de eso haga unas cosas 00:24:52
o haga otras, vale 00:24:54
entonces vamos a deshacer esto 00:24:55
que ha hecho él, esto fuera 00:24:58
el AddActionListener 00:25:00
lo deshacemos 00:25:02
lo dejamos como estaba, que estaba así 00:25:03
y ahora vamos a hacernos una clase 00:25:08
interna que 00:25:11
para gestionar los 00:25:13
eventos, captura 00:25:15
menú, para todos los eventos del menú 00:25:23
vale, esta si 00:25:25
tiene que ser capaz de estar a la espera 00:25:28
de que salte un evento de interfaz 00:25:30
pues 00:25:33
tiene que implementar un listener 00:25:34
y si en particular el evento 00:25:36
que va a capturar es el por defecto 00:25:38
pues el listener que tiene que implementar es el action 00:25:40
vale, entonces 00:25:42
se implementa la ActionListener 00:25:44
pues entonces tenemos que 00:25:45
añadir los métodos que 00:25:48
ActionListener incluye vacíos 00:25:50
este 00:25:52
bueno, pues aquí, ¿qué hay que hacer? 00:25:52
depende 00:25:57
depende de este evento 00:25:58
de donde vino, si vino de nuevo 00:26:00
si vino de abrir, si vino de cerrar, etc 00:26:02
etc, sabemos que en cualquier 00:26:04
caso vino de un JMenuItem 00:26:06
seguro, entonces 00:26:08
vamos a cogerlo, vamos a decir 00:26:10
venga 00:26:11
Vamos a coger el ítem de menú 00:26:13
Que lanzó el evento 00:26:19
¿Y cómo lo vamos a coger? 00:26:21
Pues de .getSource 00:26:23
Este es el componente que lanzó el evento 00:26:25
Este es el componente, nos lo da en modo object 00:26:28
Pero sabemos que va a ser 00:26:30
Un jMenuItem fijo 00:26:32
Pues venga, le hacemos el casting 00:26:33
Este es el ítem 00:26:40
De menú 00:26:42
Que hizo que se lanzara 00:26:43
Este método 00:26:47
Este es, porque está recogido aquí 00:26:48
en este objeto, está recogido aquí 00:26:51
ahora ya 00:26:52
sí que podemos ya 00:26:54
empezar a distinguir 00:26:56
si el ítem este 00:26:58
vamos a 00:27:03
resulta 00:27:06
que es igual a 00:27:08
archivo 1, aquí por eso 00:27:11
es importante haber cambiado el nombre de las variables 00:27:14
porque si no, uno se vuelve loco 00:27:16
y yo los he cambiado, a cada ítem de menú 00:27:17
los he llamado archivo 1, archivo 2, archivo 3 00:27:20
archivo 4, archivo 5 y a los de utilidades 00:27:22
útil 1, útil 2, útil 3, útil 4 00:27:23
los he llamado así para no liarme 00:27:26
cada ítem 00:27:31
del menú archivo los he llamado así 00:27:33
este, este, este 00:27:35
y cada ítem del menú utilidades 00:27:35
los he llamado útil 1, útil 2, útil 3, útil 4 00:27:39
bueno pues entonces 00:27:41
en el caso de que sea este 00:27:44
archivo 1 00:27:46
este será 00:27:48
cuando le hayamos dado a la opción 00:27:49
nuevo, será este 00:27:54
la opción 00:27:58
9 y así tenemos todos 00:28:00
los demás 00:28:06
si tenéis igual 00:28:07
archivo 2 00:28:10
o unos cuantos y luego cambio 00:28:11
entonces será archivo 1, archivo 2 00:28:25
archivo 3 00:28:28
archivo 4 00:28:29
y archivo 5 00:28:31
porque de archivo tenía 5 y ahora útil 00:28:33
útil 1 00:28:35
efectivamente, ahora si voy a hacer 00:28:36
la pregunta de por qué me lo pone en rojo 00:28:49
efectivamente, te has adelantado 00:28:51
claro 00:28:53
vale, efectivamente, esta sería la estructura 00:28:55
si el ítem ha sido archivo 1, opción nuevos 00:28:59
ha sido archivo 2, opción abrir, etc 00:29:02
y aquí tendría que poner lo que quiero que se haga 00:29:04
en cada opción, pero efectivamente me está diciendo 00:29:08
uy, no conozco archivo 1, no reconozco archivo 2, no lo reconozco 00:29:10
claro, esto rápidamente ya 00:29:14
no nos volvemos a decir, claro, ¿cómo lo vas a reconocer? 00:29:16
son variables locales al constructor 00:29:20
y la clase interna 00:29:22
está fuera del constructor 00:29:24
dentro de la clase pero fuera del constructor 00:29:25
con lo cual no tiene visibilidad 00:29:27
de esas variables, no las tiene 00:29:30
¿qué solución adoptamos ahí? 00:29:33
pues lógicamente subir esas variables 00:29:36
esos ítems de variables 00:29:38
de constructor, variables locales 00:29:40
del método a variables de clase 00:29:42
¿lo hago a mano en el código? 00:29:43
sí, lo puedo hacer a mano en el código 00:29:45
pero si no ya sabéis que tenemos una forma más cómoda 00:29:47
y más rápida de hacerlo 00:29:49
Que es esta 00:29:50
Me voy al componente que quiero yo subir 00:29:54
Me voy aquí y digo 00:29:56
Oye, súbeme a campo 00:29:57
De variable local a campo 00:29:59
Y así voy uno por uno 00:30:01
A la subida a campo 00:30:02
Me voy a la siguiente 00:30:03
También 00:30:04
Súbela 00:30:05
Siguiente 00:30:06
Para afuera 00:30:08
Siguiente para afuera 00:30:11
Y siguiente 00:30:14
Para arriba 00:30:16
Y con esta es lo mismo 00:30:18
Tamaño para afuera 00:30:20
Esta 00:30:25
Para afuera 00:30:27
Esta para afuera 00:30:29
Y esta para afuera 00:30:33
Vale, entonces esos errores 00:30:37
De compilación 00:30:39
Deberían haber desaparecido 00:30:41
Y efectivamente han desaparecido 00:30:43
Vale 00:30:46
Y ahora ya 00:30:47
Ahora ya sí que es cuando 00:30:49
Ya toca programar 00:30:50
Ahora ya toca decir, venga 00:30:52
Para la opción nuevo 00:30:54
¿Qué tenemos que hacer aquí? 00:30:56
Opción nuevo 00:30:59
Pues tenemos que crear un archivo 00:31:00
Con el nombre que me digan 00:31:03
Crearlo inicialmente vacío 00:31:06
Sin nada 00:31:08
Y ya está creado vacío con su nombre 00:31:09
Luego aquí lo que habrá que hacer 00:31:12
Será meter en el map 00:31:14
Un archivo con el nombre que me digan 00:31:15
Luego la clave será el nombre que me digan 00:31:18
Y el contenido en ese momento vacío 00:31:19
Un string vacío 00:31:21
Eso es lo que habrá que meter 00:31:22
meter en el map un archivo con ese nombre 00:31:24
pero claro, habrá que solicitar el nombre del archivo 00:31:27
nuevo 00:31:29
¿qué nombre de archivo desea? 00:31:30
para eso la aplicación dice 00:31:33
que cuando tenga que pedir datos 00:31:35
cuando tenga que pedirlos 00:31:36
los pida siempre con ventanitas emergentes 00:31:38
de estas, entonces habrá que seleccionar 00:31:40
un jOptionPanel 00:31:43
de los que permite meter 00:31:44
información, porque el jOptionPanel 00:31:46
te ofrece muchas 00:31:49
diferentes emergentes, de las que 00:31:50
solo te muestran un mensaje, a las que te permiten 00:31:52
meter datos, pues habrá que 00:31:55
seleccionar una opción pane de estas 00:31:56
coge el nombre de archivo 00:31:59
y con ese nombre de archivo 00:32:00
¿vale? entonces 00:32:01
opción nuevo, pues habrá que 00:32:04
solicitar nombre para nuevo archivo 00:32:06
¿cómo hemos dicho que lo solicitamos? 00:32:09
con el jOptionPane 00:32:21
pues venga, vamos a buscar 00:32:22
que jOptionPane 00:32:24
tiene pinta de devolverme a mi 00:32:26
un string de respuesta 00:32:29
pena no, pena no, damos 00:32:30
nosotros, a ver 00:32:33
opción pane, pues venga 00:32:37
vale, vamos a llamar cuadro 00:32:38
porque es el cuadrito que sale 00:32:43
uy, que tonta, perdón, estoy haciendo 00:32:45
el idiota, vale, vamos a ver 00:32:47
que, que opciones 00:32:49
nos da 00:32:57
a ver si nos gusta alguna de las que nos da 00:32:57
pues nos da, vamos a ver 00:33:00
nos vamos a todos los show 00:33:04
nos da uno de confirmación 00:33:06
que me devuelve 00:33:08
ah, pues hay uno 00:33:10
que nos devuelve 00:33:11
como valor de retorno un string 00:33:13
pues tiene toda la pinta de que este es el que queremos 00:33:15
porque este nos muestra una ventana de diálogo 00:33:17
como todas las demás 00:33:20
pero nos devuelve un string como valor de retorno 00:33:21
pues tiene pinta que entonces 00:33:24
ese es el que queremos 00:33:25
y que el string que nosotros metamos 00:33:27
ahí es el que nos va a devolver 00:33:29
tiene toda la pinta de que es este 00:33:31
y el mensaje de aquí pues tiene toda la pinta 00:33:33
de que el mensaje de aquí 00:33:36
es el mensajito de queremos que se ponga en el option pane 00:33:37
como veis 00:33:40
hay varias variantes de show input dialog 00:33:41
porque es más personalizable 00:33:43
vamos a coger la más sencilla 00:33:45
que es esta 00:33:47
a ver que nos sale 00:33:48
y ya 00:33:50
vale, vamos a ponerle aquí 00:33:52
introduzca 00:33:59
nombre archivo 00:34:06
y ahora 00:34:08
ese nombre de archivo 00:34:13
no lo devuelve, valor de retorno aquí 00:34:15
vale, entonces uno 00:34:17
¿qué haría? 00:34:24
Pues comprobaría 00:34:25
Vamos a ver si realmente esto funciona como yo quiero 00:34:27
Vamos a mostrarlo por la consola 00:34:30
La consola ahora mismo 00:34:31
En tiempo de desarrollo la usamos como comprobaciones 00:34:33
Voy a mostrar a ver si 00:34:35
Realmente me ha guardado en esta variable 00:34:37
De retorno nombre lo que yo le haya metido 00:34:40
Entonces si yo 00:34:42
Vamos a ver 00:34:44
Voy a probar yo esta aplicación rápida 00:34:45
A ver si en el menú nuevo me sale el jOptionPane 00:34:47
Pues no me sale el jOptionPane 00:34:53
¿Por qué será que no me sale el jOptionPane? 00:34:57
Porque no se lo ha añadido al ítem. 00:35:05
Le he creado la clase interna, 00:35:07
pero luego no le he añadido el listener. 00:35:08
Error típico que uno lo hace aquí y se le olvida. 00:35:10
Pues venga, vámonos a archivo 1. 00:35:13
A este vamos a archivo 1. 00:35:17
Punto addActionListener. 00:35:21
Como vamos a añadir a todos el mismo actionListener, 00:35:24
vamos a crear aquí un objeto capturaMenu. 00:35:27
Y ese es el que le vamos a añadir a todos los ítems. 00:35:30
Ahora, captura. 00:35:43
ala, el menú nuevo ya tiene 00:35:45
un capturador asociado 00:35:50
vamos a ver si ahora ya nos 00:35:51
saca el archivo 00:35:53
nuevo, sí 00:35:56
vamos a meterle un nombrecito 00:35:57
efectivamente 00:36:01
lo recoge con 00:36:03
order return, vale, pues estupendo 00:36:05
entonces ahora, claro, no hemos terminado 00:36:12
lo de capturar nuevo, porque ahora lo que tendremos es 00:36:14
que crear un archivo nuevo vacío y meterlo 00:36:16
en la estructura de archivos 00:36:18
vale 00:36:20
si le damos a cancelar 00:36:22
no devuelve nada, claro 00:36:24
devuelve null, no le hemos metido nada 00:36:25
venga, vamos a parar aquí 00:36:27
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
22
Fecha:
6 de mayo de 2024 - 19:40
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 32″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
167.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid