Saltar navegación

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

10 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, vamos a 00:00:00
ejecutar este 00:00:07
main de aquí, que lo único que hace es 00:00:09
inserta dos alumnos en nuestra 00:00:11
lista de alumnos y luego como la aplicación 00:00:13
ya se va, pues los deja 00:00:15
guardados para la próxima vez 00:00:17
pues nada, vamos a ejecutar 00:00:19
esto y no 00:00:21
no ha pasado 00:00:25
pues nada, cuando nos salen cosas 00:00:26
rojas, fundamental es 00:00:29
ver qué tipo de excepción nos da, qué información nos da 00:00:31
y en qué momento ha ocurrido 00:00:36
sí, pero si no se la doy es que es la ruta por defecto, que es la raíz 00:00:38
del proyecto, ¿vale? o sea yo 00:00:45
tengo dos opciones, dar la ruta absoluta partiendo desde mi unidad de disco 00:00:48
en un archivo serializado 00:00:52
de objetos, no hay tipo, claro, entonces yo tengo la opción 00:01:01
de darle una ruta absoluta 00:01:05
y se identifica que es absoluta 00:01:07
porque partes directamente 00:01:09
de una unidad de disco 00:01:11
o si fuera en linux 00:01:12
porque partes directamente de la barra 00:01:15
o puedes no darle una ruta absoluta 00:01:18
como esta en la que no partes de una unidad de disco 00:01:21
si no partes de una unidad de disco 00:01:23
entonces él concatena esto 00:01:25
a la ruta por defecto 00:01:27
que es la raíz del proyecto 00:01:29
entonces como yo no le estoy dando una ruta absoluta 00:01:30
porque no tengo una unidad de disco de partida 00:01:33
él concatena eso a la raíz del proyecto 00:01:35
con lo cual alumnos me lo va a poner en la raíz 00:01:38
que yo le pongo esto 00:01:40
pues me pondría dentro de alumnos 00:01:44
perdón, en la raíz del proyecto 00:01:49
buscaría la subcarpeta SRC 00:01:51
y en esa subcarpeta de la raíz del proyecto 00:01:54
en este fichero 00:01:57
es decir, lo que yo le ponga aquí 00:01:58
lo concatena con 00:02:01
la carpeta raíz del proyecto 00:02:04
a menos que yo le esté dando una unidad de disco 00:02:06
entonces ya es absoluta y desde el disco 00:02:08
¿vale? en este caso 00:02:09
perdón 00:02:12
a ver 00:02:16
con la unidad de disco 00:02:22
más todas las carpetas que van 00:02:24
no, con la unidad de disco no, o sea no 00:02:26
porque no es esto 00:02:27
no concatena con eso, concatena con eso 00:02:29
más users alumno de eso 00:02:32
bla bla bla hasta que llegue a mi proyecto 00:02:34
cada ordenador la que tenga, da igual 00:02:36
el que tenga, por eso es relativa 00:02:38
porque este mismo 00:02:40
este mismo 00:02:41
proyecto en vuestro ordenador 00:02:43
funciona, pero la ruta que va adelante 00:02:46
no tiene nada que ver la mía con la tuya 00:02:48
y sigue funcionando, sin embargo 00:02:50
si yo pongo una ruta absoluta 00:02:52
y yo digo, no, no te la voy a dar así 00:02:54
te la voy a dar, espera, vamos a 00:02:59
poner aquí, vámonos a 00:03:01
mi proyecto que es este 00:03:02
ejemplo, alumnos 00:03:04
Me voy a poner aquí 00:03:10
Control-C 00:03:12
Vale 00:03:16
Yo tengo 00:03:17
Dos maneras de hacer lo mismo 00:03:23
En este caso 00:03:24
Uy, espérate 00:03:26
Control-C 00:03:27
Ya, pero es que hay veces que 00:03:32
A lo mejor hay gente que no lo tiene claro 00:03:36
Y es que esto hay veces que 00:03:37
Ejemplo 00:03:39
Alumnos 00:03:50
Alumnos 00:03:51
Es que muchas veces esto es lo que hace 00:03:52
de una aplicación este bien hecha. 00:04:03
Vale. Entonces, lo de arriba 00:04:04
y lo de abajo es lo mismo. 00:04:07
Me da igual esta sentencia que esta. 00:04:09
Me da igual. Estoy haciendo lo mismo. 00:04:11
Esta ruta y esta ruta son 00:04:13
idénticas. Son la misma. 00:04:15
Está claro, ¿no? 00:04:17
Son la misma. 00:04:19
¿Cuál es la diferencia? Que ahora este proyecto 00:04:20
se va a vuestro ordenador. 00:04:23
Con esta opción 00:04:25
va a seguir funcionando sin ningún problema 00:04:27
y con la de abajo no 00:04:29
porque puede que vosotros 00:04:30
la ruta hasta la raíz de vuestro proyecto 00:04:33
no sea esa, sea otra 00:04:35
pero sin embargo, si yo se la paso así como relativa 00:04:36
él va a coger la que 00:04:39
en vuestro ordenador 00:04:41
lleve a la raíz del proyecto 00:04:42
en mi ordenador a la raíz del proyecto 00:04:44
lleva esta, pero si yo se la casco 00:04:47
aquí, va a llevar esa 00:04:49
a misa, en este ordenador, en el vuestro, en cualquiera 00:04:51
si yo se la casco de esta 00:04:53
manera, va a ser capaz de coger 00:04:55
la local de cada equipo 00:04:57
por eso esta es relativa y esta es absoluta 00:04:58
porque esta cambia dependiendo del equipo 00:05:01
del que se ejecute, esta cambia 00:05:03
esta no cambia, esta me da igual 00:05:04
donde la ejecute, esa va a tomar esa 00:05:06
con lo cual en el mío no fallará, en el vuestro fallará 00:05:08
por eso siempre 00:05:11
hay que 00:05:12
trabajar con rutas absolutas porque si no 00:05:13
en el ordenador solo tienes la garantía 00:05:16
perdón, la aplicación solo tienes la garantía de que te funcione 00:05:18
en local, en el tuyo 00:05:20
si yo lo despliego en el Dell no me va a funcionar 00:05:22
pero esta versión 00:05:25
sí, ¿vale? entonces 00:05:26
esta y esta en mi ordenador 00:05:28
hacen lo mismo, pero en el vuestro 00:05:30
no, en el vuestro esta funciona y esta 00:05:32
no, vale, pues entonces 00:05:34
bueno, pues 00:05:38
entonces estábamos con que me ha dado un error 00:05:46
que tenemos que ver, que error es 00:05:48
que me dice 00:05:49
pues me dice 00:05:50
oye, alumno 00:05:53
no es serializable 00:05:55
vale, claro, efectivamente 00:05:57
porque hay que darle 00:06:00
ah, este es un error, silencio 00:06:02
que se olvida mucho 00:06:04
pues conviene que identifiquéis esta excepción 00:06:05
porque es un error que se olvida mucho 00:06:08
entonces identificarla 00:06:10
¿qué significa esto? 00:06:11
que a la entidad alumno 00:06:12
no se le ha dado el comportamiento 00:06:13
de que sea serializable 00:06:16
no se le ha dado ese comportamiento 00:06:17
y darle un comportamiento a una entidad 00:06:20
¿cómo se consigue? 00:06:22
haciendo la que implemente una interfaz 00:06:24
¿verdad? 00:06:26
para eso son las interfaces 00:06:27
las interfaces fijan 00:06:28
un patrón de comportamiento 00:06:30
a través de sus métodos 00:06:32
patatín, patatín, patatán 00:06:33
el que implementa esa interfaz 00:06:35
automáticamente 00:06:37
adquiere esos métodos 00:06:38
y por tanto puede comportarse ya 00:06:41
de esa manera, los puede sobrescribir 00:06:43
o no, eso ya es otra cosa 00:06:45
bueno, pues entonces, nuestro error 00:06:47
aquí es que 00:06:49
alumno 00:06:51
¿vale? 00:06:54
no implementaba serializable 00:06:57
pues no pasa nada 00:06:58
vamos a hacerle que implemente 00:07:00
la interfaz serializable 00:07:02
lo importáis del paquete correspondiente 00:07:07
que es java.io 00:07:10
y ya está 00:07:11
y ahora ya esta clase ha adquirido 00:07:12
el comportamiento que le da esta interfaz 00:07:15
esta interfaz tiene métodos dentro 00:07:17
con códigos por defecto 00:07:19
con codificación por defecto 00:07:21
ya la ha adquirido 00:07:22
entonces si queremos serializar 00:07:23
objetos de una clase 00:07:26
esa clase tiene que implementar 00:07:28
la interfaz serializable 00:07:30
vale, y no solo esa clase 00:07:32
porque 00:07:35
si esta clase tiene dentro 00:07:36
propiedades de otras clases 00:07:38
como esas propiedades 00:07:41
también se van a tener que visualizar por dentro 00:07:42
esas clases también lo tendrán que ser 00:07:44
pero en este caso 00:07:46
solo tengo string y string 00:07:47
y string 00:07:51
es que ya lo son, si yo me meto en la 00:07:52
declaración de string, ya lo es 00:07:54
ya lo tiene ya puesta 00:07:57
¿vale? 00:07:58
pero si yo aquí en alumno 00:08:01
pues resulta que utilizo una clase 00:08:03
matrícula 00:08:05
en lugar de string 00:08:06
porque tengo una clase matrícula 00:08:09
con las propiedades de la matrícula 00:08:10
pues entonces esta clase matrícula 00:08:12
también tendría que implementar serializable 00:08:14
porque dentro de alumno hay matrículas 00:08:16
y se tiene que serializar todo 00:08:19
el alumno con todos los objetos que hay dentro 00:08:20
pero en este caso 00:08:23
callaos 00:08:25
pero en este caso 00:08:27
string ya lo es 00:08:29
y no tengo otro tipo de dato que no sea 00:08:30
o primitivo 00:08:32
que el primitivo es que se lleva tal cual 00:08:33
no hay que serializar, se lleva tal cual 00:08:36
no tengo otro tipo de dato que no sea primitivo 00:08:37
o serializable de por sí 00:08:39
como string 00:08:42
bueno pues con estos en principio ya hemos dado 00:08:43
todo el comportamiento que hace falta 00:08:46
si lo volvemos a ejecutar 00:08:47
ahora ya error no ha dado 00:08:50
y vamos a ver si ha aparecido el fichero 00:08:54
vale, ha aparecido aquí un fichero 00:08:58
de alumnos 00:09:02
obviamente si abrimos este archivo 00:09:02
no entendemos absolutamente nada 00:09:06
porque ¿qué hacemos al abrirlo? 00:09:08
estamos haciendo 00:09:11
que un editor de texto lo interprete 00:09:11
¿y el editor de texto qué hace? 00:09:15
pues el editor de texto va cogiendo bits de 8 en 8 00:09:16
va a la tabla ASCII 00:09:18
lo convierte al carácter y te lo planta 00:09:20
eso es lo que hace el editor de texto 00:09:22
le hemos dado un fichero con un montón de bits 00:09:23
dice vale, muy bien, yo soy un editor de texto 00:09:25
lo único que yo sé hacer es 00:09:27
te cojo los 8 primeros, tabla ASCII, carácter que toca 00:09:29
te lo planto, te cojo los 8 siguientes 00:09:32
tabla ASCII, carácter que toca 00:09:33
ese fichero no codificaba 00:09:35
ASCII, con lo cual 00:09:37
nos ha sacado cosas 00:09:39
¿vale? algunos caracteres 00:09:40
tienen sentido porque en la serialización 00:09:43
algunas cosas van como char 00:09:45
pero muchas otras no, todos los cuadraditos 00:09:47
se corresponden 00:09:49
a bytes que en la tabla 00:09:51
ASCII no tienen correspondencia, no la tienen, no existen 00:09:53
por eso el leidor 00:09:55
texto pone cuadraditos 00:09:57
luego, este fichero 00:09:58
obviamente no vale para abrirlo con 00:10:01
ninguna aplicación, este fichero está 00:10:03
ahí simplemente para que cuando 00:10:05
mi aplicación Java arranque 00:10:07
otra vez lo deserialice con la clase 00:10:08
correspondiente, con la complementaria 00:10:11
a object output string que es 00:10:13
object input string, es para lo único 00:10:15
que vale este fichero, para ahora 00:10:17
que otra aplicación con object 00:10:19
input string haga la operación inversa 00:10:21
pero no se puede abrir con ningún 00:10:23
otro 00:10:25
aplicación, bueno pues entonces 00:10:25
aquí ahora ya podríamos 00:10:30
en mi clase esta de aquí, operaciones 00:10:33
pues podríamos 00:10:36
hacer un método 00:10:38
para que recuperara 00:10:39
objetos del archivo y los guardara 00:10:41
aquí 00:10:44
y yo ese método le llamo cuando arranca la aplicación 00:10:44
por ejemplo, y así cuando la aplicación 00:10:48
arranca, este list 00:10:50
ya se llena con los objetos 00:10:52
que haya en ese archivo 00:10:54
si es que los hay 00:10:55
pues venga, vamos a hacer 00:10:57
ese método 00:11:00
que sería 00:11:01
en lugar del método guardar datos 00:11:03
pues recuperar datos 00:11:05
y le podemos pasar pues el nombre 00:11:06
del fichero donde 00:11:18
suponemos 00:11:19
que están los alumnos 00:11:21
vale, pues aquí hombre, esto para que fuera más general 00:11:23
podríamos primero mirar a ver 00:11:29
si el archivo existe o no 00:11:31
porque si el archivo no existe 00:11:32
pues entonces no hay alumnos que recuperar 00:11:35
el método ya termina, la lista se habrá 00:11:37
que se quedará vacía como estaba 00:11:39
y ya está 00:11:41
entonces podemos hacerlo primero esto 00:11:42
instanciar un objeto file 00:11:44
asociado 00:11:46
a este nombre 00:11:47
non-fichero 00:11:51
y ahora ya podemos hacer 00:11:58
si resulta que el fichero f no existe 00:12:10
pues no hay nada que hacer 00:12:13
return, no hay nada que recuperar 00:12:14
que se quede la lista como estaba, que era vacía 00:12:16
sin alumnos 00:12:18
esto en función 00:12:19
si es una interfaz gráfica o no lo es 00:12:22
pues se podría avisar, no hay alumnos previos 00:12:27
lo que sea, ya está 00:12:29
si el fichero no existe, return 00:12:31
y ahora ya el fichero existe, pues ahora ya 00:12:32
podemos abrirlo para deserializar 00:12:35
y la clase para deserializar es esta 00:12:38
object 00:12:40
input stream 00:12:42
ya vamos a referencia 00:12:45
como nos dé la gana 00:12:48
y lo mismo que la output 00:12:49
object 00:12:52
input stream está montada 00:12:59
sobre un file input stream 00:13:00
porque object input string 00:13:02
lo que tiene que hacer es 00:13:05
hay de verdad 00:13:06
hay tres bares enfrente 00:13:09
o cuatro, no sé cuántos hay 00:13:11
pues largaos a esos bares 00:13:12
que ahí no van a 00:13:15
no vais a salir el coñazo, bueno, a ver 00:13:17
seguramente también, pero que os aguante 00:13:18
otro, yo no voy a aguantar 00:13:21
entonces esta clase 00:13:22
lo primero que hará será mover los bits 00:13:26
y para mover los bits file input string 00:13:29
no hay otra 00:13:31
y luego ya con esos bits 00:13:31
ahí ya tendrá sus métodos 00:13:34
para deserializarlos, hacer lo que tienen 00:13:36
llevarlos a las propiedades del objeto, hacer todo lo que haga falta 00:13:37
pero hay que 00:13:40
darle el FileInputString sobre el que está montado 00:13:42
pues el FileInputString 00:13:44
sobre el que está montado, pues es un FileInputString 00:13:48
asociado al non-fichero ese 00:13:50
que me han dado, o a F 00:13:52
me da igual 00:13:56
el costo es el mismo 00:13:57
venga, pues nada, tendremos 00:13:59
que importar esto 00:14:02
y esto 00:14:04
y propagar la excepción correspondiente. 00:14:08
¡Hala! 00:14:15
Y ahora, leer es más complicado 00:14:15
que escribir, porque escribir es 00:14:18
escribo y ahí lo mando. Y ya está. 00:14:19
¿La siguiente escritura que haga? Pues se hará justo 00:14:22
debajo. Pero leer, 00:14:24
como no tenemos la información de lo que hay, 00:14:26
tenemos que hacer un bucle, 00:14:28
un bucle que vaya leyendo hasta llegar al final. 00:14:29
No sabemos cuántas lecturas hay que hacer. 00:14:32
5, 20, ni idea. 00:14:33
depende de lo que hay en el archivo 00:14:35
alguna vez 00:14:37
podemos llamar a recuperar datos y a lo mejor hay 30 00:14:40
pues tendremos que darle 30 veces 00:14:42
sin embargo puede ser 00:14:43
que la siguiente vez que lleguemos a recuperar archivo 00:14:46
haya solo 20, pues entonces habrá que hacer 20 veces 00:14:47
entonces será un bucle 00:14:49
que está leyendo mientras 00:14:50
no hayamos llegado al final 00:14:53
y cada lectura es un objeto 00:14:55
cada lectura es un objeto 00:14:57
¿vale? bueno pues aquí 00:14:59
el bucle de fin de archivo no es tan sencillo 00:15:01
como el otro ejemplo que hemos visto 00:15:03
porque leía solamente un int 00:15:05
entonces marcar el fin de archivo era tan sencillo 00:15:07
como decir si ese int es menos uno, llega al final 00:15:09
y si es cualquier otra cosa 00:15:11
no he llegado al final 00:15:14
cojo el menos significativo y listo 00:15:15
aquí la forma más general de plantearlo 00:15:17
el acordarse, el identificar 00:15:20
que hay una excepción 00:15:24
que recoge 00:15:25
el hecho de que cuando uno está 00:15:27
leyendo un archivo, llegue al final 00:15:29
esa 00:15:31
excepción 00:15:32
se llama así 00:15:34
no sé si tiene dos Fs o no, vamos a buscarla 00:15:36
aquí, ya que estamos 00:15:41
tan... 00:15:42
es una excepción que ya está hecha 00:15:47
y está incorporada en la librería 00:15:49
de la máquina virtual 00:15:51
está en java.io, que java.io 00:15:52
está aquí 00:15:55
pues en este paquete 00:15:56
hay una excepción 00:15:59
que se llama 00:16:02
EOF exception, el file me lo he sacado de la manga 00:16:03
EOF exception 00:16:05
vale, pues 00:16:07
en off file exception 00:16:10
vale, pues esta excepción es una excepción 00:16:18
que lanza la máquina 00:16:20
la máquina virtual no la lanza 00:16:22
la lanzará cualquiera de las clases 00:16:23
que hacen lectura, input, file, input 00:16:26
string, cualquiera de las que hacen lectura 00:16:28
si fuéramos a mirar en su código 00:16:30
como lo hacen, veríamos que hace un 00:16:32
throw en off file exception cuando 00:16:34
se detecta una situación de 00:16:36
incapacidad del hardware 00:16:38
de seguir leyendo 00:16:40
vale, pues entonces podemos utilizar 00:16:41
esta excepción 00:16:44
para hacer un bucle 00:16:45
con el try-catch 00:16:46
y decir, mientras yo no entre en el catch 00:16:48
es porque tengo algo más que leer 00:16:51
vale, entonces podríamos 00:16:53
hacerlo de esta manera, y tendríamos el bucle de lectura 00:16:55
más genérico que hay 00:16:57
que es el siguiente, esto lo dejamos aquí 00:16:58
aparcadito, que es 00:17:01
vamos a hacer un bucle, vamos a hacer primero un boolean 00:17:02
para indicar yo si he llegado 00:17:05
al final o no 00:17:07
fin archivo 00:17:08
entonces inicialmente no he llegado al final 00:17:10
falso, y ahora me hago 00:17:13
mi bucle 00:17:15
mientras no haya llegado a fin archivo 00:17:15
vale, pues entonces yo tengo 00:17:19
aquí 00:17:28
este boolean que quiero construir 00:17:28
de tal manera que inicialmente es 00:17:32
falso porque no he llegado al final 00:17:34
pero que aquí dentro 00:17:35
se ponga true cuando he llegado al final 00:17:36
eso es lo que yo quiero 00:17:39
que aquí dentro en algún momento se ponga true 00:17:41
vale, ¿qué voy a querer hacer yo aquí dentro? 00:17:43
leer un objeto alumno 00:17:45
¿Vale? Porque los tengo que ir leyendo uno por uno 00:17:46
Igual que los caracteres, los leía de uno en uno 00:17:49
Los bai de uno en uno 00:17:51
Pues vamos a leer un objeto alumno 00:17:52
Alumno a, ¿y cómo lo leemos? 00:17:54
Pues con el object input string que hemos hecho aquí 00:17:56
Con su método 00:17:59
React object 00:18:01
Ala, con este leemos un alumno 00:18:02
Pero este método 00:18:08
Está programado 00:18:10
Está declarado 00:18:11
De tal manera que te lo devuelve como un object 00:18:12
Porque claro, es un método 00:18:16
que te puede leer cualquier tipo de objeto 00:18:17
está programado para que te lo vuelva como un object 00:18:19
aunque él internamente te hace un instance of 00:18:22
para que el casting funcione, etc. 00:18:24
pero entonces para que el compilador 00:18:27
se quede callado 00:18:28
hay que hacer un casting 00:18:29
para que se quede callado 00:18:31
y oye, esto que estás leyendo 00:18:33
hazme casting alumno 00:18:35
y este casting va a funcionar sin problema 00:18:38
en este caso, pero vamos 00:18:40
va a funcionar sin problema en este caso porque nosotros 00:18:42
somos los que hemos generado 00:18:44
este archivo y sabemos que hay objetos 00:18:46
alumno, si nos pudisiéramos 00:18:48
hacer read object de otro objeto 00:18:50
que no tiene alumno, si hiciéramos el casting 00:18:52
alumno, pues petaría 00:18:54
claro, pero nuestra 00:18:56
aplicación está coordinada 00:18:58
el método de guardar está coordinado 00:18:59
con el de recuperar, es una aplicación 00:19:02
obviamente que está coordinada para que funcione 00:19:03
y sabemos que este 00:19:05
flujo está conectado 00:19:07
a un archivo que tiene objetos 00:19:10
alumno, entonces podemos hacer 00:19:11
el casting sin problema 00:19:14
bueno, pues vamos leyendo de uno en uno 00:19:15
y esto 00:19:17
puede lanzar una excepción 00:19:20
que ponemos en el throw para no molestar 00:19:21
y ahora 00:19:24
el fin archivo este 00:19:25
¿cómo cambiará? 00:19:29
en algún momento tendrá que cambiar y ponerse a true 00:19:31
porque hemos llegado al final 00:19:32
claro, pues nosotros queremos ponerlo a true 00:19:34
cuando este read object 00:19:37
saque una excepción de este tipo 00:19:39
cuando este read object 00:19:41
saque una excepción de este tipo 00:19:43
es porque hemos llegado a fin de archivo 00:19:45
pues entonces vamos a capturar 00:19:47
esta sentencia 00:19:50
vamos a capturarla y vamos a decir 00:19:51
oye, tú intenta hacerla 00:19:53
y si resulta que como consecuencia de hacerla 00:19:55
te encuentras esto 00:19:58
que sale una excepción 00:20:01
en off-file exception 00:20:03
pues la capturas 00:20:06
que no es obligatorio capturarla 00:20:07
por eso yo cuando tenía esto sin el try-catch 00:20:10
ahí el compilador estaba tan tranquilo 00:20:12
no es obligatorio 00:20:13
porque esta es run time exception 00:20:14
esta no es exception 00:20:17
pero a mi me interesa capturarla para detectar 00:20:18
cuando ha salido 00:20:21
porque cuando haya salido entonces lo que yo quiero es 00:20:22
fin archivo 00:20:26
igual a true 00:20:27
y la importo 00:20:28
en not file exception dejaba ahí 00:20:31
vale pues ahora ya 00:20:33
capturando esta excepción 00:20:36
que puedo no capturarla 00:20:38
y si no la capturo cuando salga 00:20:41
pues la vas a ir en rojo ahí 00:20:42
capturando esta excepción 00:20:44
cuando el readObject 00:20:46
no haya podido leer 00:20:48
no haya podido porque está al final 00:20:49
entonces saltará esto 00:20:51
y esto se pondrá true 00:20:53
y ahora el while cuando vuelva arriba dirá 00:20:55
uy, condición false 00:20:57
y ya está, y se acabará 00:20:59
entonces este bucle de lectura 00:21:01
es muy genérico, nos permite usar 00:21:04
con el tryCast de excepción 00:21:06
nos permite hacer lecturas 00:21:08
con cualquier método de lectura 00:21:10
de cualquier clase que haga lecturas 00:21:12
y que me devuelvo un en of file 00:21:14
po venga 00:21:19
y ahora ya está 00:21:20
entonces ahora este objeto 00:21:25
este método está leyendo 00:21:26
y ahora que haré yo aquí con cada objeto alumno 00:21:27
meterlo en la lista 00:21:30
eso es lo que yo querré 00:21:31
en mi lista de alumnos 00:21:32
quiero meter ese alumno 00:21:35
vale pues ya tengo mi método 00:21:36
a falta de cerrar 00:21:42
el flujo que acabo de abrir 00:21:45
ya tengo mi método 00:21:48
que está todo el rato 00:21:52
si el archivo no existe, no hace nada 00:21:54
y si existe, se pone 00:21:58
lee un alumno de él, lo manda a la lista 00:22:00
lee otro alumno, lo manda a la lista, así hasta que no haya más alumnos 00:22:03
bueno, pues entonces ahora ya, mi aplicación arranca 00:22:06
lo primero que yo tendría que hacer 00:22:13
ahora cuando mi aplicación arranca en mi main 00:22:17
sería, antes que nada 00:22:19
voy a recuperar los que haya 00:22:22
Para partir con los que dejé guardados 00:22:24
De la última vez 00:22:26
¿Vale? Recuperar alumnos y le doy el nombre 00:22:27
De archivo con el que voy a trabajar 00:22:37
Pues venga, alumnos 00:22:38
En este caso, alumnos 00:22:39
Y esto 00:22:42
Un throws 00:22:44
Vale, vamos a comprobar si funciona 00:22:46
Poniéndole aquí 00:22:51
Se han recuperado no sé cuántos alumnos 00:22:52
Para ver si los ha recuperado 00:22:55
Se han recuperado 00:22:56
Del 00:22:59
Fichero 00:23:00
Pues cuánto se ha recuperado del fichero 00:23:03
Pues se habrán recuperado 00:23:07
Los que haya en 00:23:08
Alumnos.size 00:23:09
No se llama alumnos 00:23:12
Ah, es que no está aquí, está en operaciones 00:23:21
Sí, está en operaciones la lista, ¿no? 00:23:23
Operaciones 00:23:31
Punto alumnos 00:23:32
Punto size 00:23:34
Estos son los que se han 00:23:36
recuperado, luego él sigue insertando 00:23:38
en este caso no los va a insertar 00:23:40
porque como estos ya están, que los he guardado de antes 00:23:42
pues no los va a insertar 00:23:43
es una lista 00:23:45
ah bueno, sí, porque es una lista 00:23:48
no es un set, luego admite duplicados 00:23:49
vale, los insertaría igual en otra posición 00:23:51
vale 00:23:54
y ahora operación guardar 00:23:55
los volvería a guardar 00:23:57
en este caso los cuatro 00:23:59
vamos a ver primero, antes que nada 00:24:01
si me dice cuando yo ejecute este 00:24:03
que se han recuperado dos, porque antes 00:24:06
hemos insertado estos dos, que yo sepa 00:24:08
vamos a 00:24:10
me parece ahí, que pena 00:24:14
se me ha quitado de ahí 00:24:22
pues efectivamente había dos 00:24:23
que son los que ha recuperado 00:24:33
y yo podría aquí 00:24:35
y ahora 00:24:36
habrá otros cuatro, porque ha insertado 00:24:39
estos, como es una lista, repito, no es un set 00:24:41
aunque están duplicados 00:24:43
los meterá 00:24:45
a menos que en insertar alumno 00:24:45
ese método, mirar a ver si estaba o no, no lo sé 00:24:48
y los ha vuelto a guardar, vamos a volver al main 00:24:51
a ver si me dice ahora, se han recuperado 4 00:24:53
efectivamente, se han recuperado 4 00:24:56
y cada vez que le demos, pues 00:25:01
bueno, le he dado tantas veces 00:25:03
ya que ya le he matado 00:25:08
vale, sí 00:25:09
ya sé lo que ha pasado, esto olvidaros 00:25:11
porque le he dado, vale 00:25:13
bueno, pues este uso, es el uso 00:25:15
más básico que hay de object input string 00:25:19
o de output string, que es el más básico 00:25:21
nos permite al menos 00:25:23
hacer una aplicación 00:25:26
en el cual mis datos estén ahí 00:25:27
la aplicación arrancará 00:25:30
yo decidiré en cómo lo tengo que recuperar 00:25:32
cómo lo tengo que guardar, etc. 00:25:33
¿Vale? 00:25:37
Que no te los recupera 00:25:44
pero te da excepción 00:25:45
Porque el fichero tiene cosas, tiene bytes 00:25:46
aunque no podamos ver 00:25:57
el contenido 00:25:59
tiene 00:26:00
vale 00:26:00
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
25 de mayo de 2024 - 17:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 19″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
120.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid