Saltar navegación

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

8 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, vamos a completar lo que nos queda, pero muy por encima, que es acceso a ficheros desde Java, hasta ahora nuestra información siempre la teníamos que meter en el momento, sobre la marcha la aplicación arrancaba y la aplicación arranca siempre limpia, 00:00:00
Claro, las variables, cuando una aplicación arranca, las variables están siempre limpias 00:00:42
Y una aplicación solo puede trabajar con los datos que tengan las variables, solamente 00:00:46
Entonces, de algún sitio tienen que llenarse esas variables, de algún lado 00:00:51
Porque si no, la aplicación no puede trabajar, sus datos tienen que estar siempre ahí 00:00:57
Me da igual que esas variables sean primitivas, sean objetos, sean colecciones de objetos, que es lo habitual 00:01:01
pero los datos tienen que estar ahí en esas variables 00:01:07
para que el proceso 00:01:10
la aplicación trabaje con él 00:01:13
bueno, hasta ahora para llenar 00:01:14
esas variables 00:01:16
nosotros solo hemos tenido dos caminos 00:01:17
o en el momento en el que arrancaba 00:01:20
la aplicación, con la aplicación arrancando 00:01:22
estábamos sentados delante 00:01:24
metiéndolo por teclado y la aplicación 00:01:26
lo iba cogiendo con escáner 00:01:28
o teníamos una interfaz gráfica 00:01:30
y había alguien sentado delante 00:01:33
que iba metiendo las áreas de texto 00:01:34
es decir, siempre tenía que haber alguien 00:01:36
en el momento en que la aplicación había arrancado 00:01:39
ahí presente para meter los datos 00:01:41
porque si no la aplicación no puede trabajar 00:01:43
lógicamente 00:01:45
bueno, esa obviamente 00:01:46
no es la forma 00:01:49
no es la única forma de trabajar 00:01:50
los datos con los que una aplicación trabaja 00:01:52
pueden estar perfectamente 00:01:55
en un fichero o en una base de datos 00:01:57
y la aplicación arranca y los recoge de ahí 00:01:59
si hay mil usuarios 00:02:01
con los que trabaja la aplicación 00:02:04
y el usuario me refiero 00:02:05
pues un conjunto de datos grande 00:02:06
pues claro, cada vez que arranca la aplicación 00:02:09
no va a estar alguien sentado delante 00:02:11
para meter todos los datos 00:02:12
oye, que vas a trabajar con estos mil nombres 00:02:14
venga, voy a meterte los mil nombres 00:02:16
y luego tú ya trabajas 00:02:18
pues no, esos nombres estarán en un fichero 00:02:19
en una base de datos 00:02:22
y la aplicación los recogerá cuando arranque 00:02:23
y una vez que los ha volcado a variables 00:02:26
ya podrá trabajar con ellos 00:02:29
¿vale? 00:02:31
pero nunca se trabaja con los datos 00:02:32
directamente en el fichero 00:02:35
o directamente en la base de datos 00:02:37
nunca porque la aplicación no puede 00:02:39
la aplicación solo puede trabajar 00:02:41
lo que esté en la memoria principal 00:02:43
en la RAM 00:02:45
y lo que está en la RAM son las variables 00:02:46
aparecen cuando el proceso 00:02:48
arranca, esas variables en la RAM 00:02:51
se llenan de cosas 00:02:53
y cuando el proceso 00:02:54
termina desaparecen 00:02:57
si lo que había en las variables 00:02:58
no queremos que se pierda 00:03:01
pues habrá que volcarlo otra vez luego a un fichero o a una base de datos 00:03:02
claro, nosotros hasta ahora 00:03:07
cuando la aplicación terminaba, sus resultados, si no había alguien ahí delante 00:03:10
para verlos con sus ojos, pues no servían para nada, los resultados se veían 00:03:14
y ya está, pero normalmente no estará alguien siempre 00:03:19
ahí para ver el resultado y tomar nota, ese resultado 00:03:23
tiene todo el sentido del mundo, que se vuelque desde las variables 00:03:27
a un fichero, una base de datos y ahí se queda 00:03:31
para luego ya nosotros ver ese resultado 00:03:33
¿vale? 00:03:35
bueno pues entonces 00:03:37
ficheros o bases de datos 00:03:39
son 00:03:40
las dos estructuras en las cuales 00:03:42
se guarda esa información 00:03:45
de forma permanente 00:03:47
ficheros y bases de datos 00:03:48
acceso a bases de datos pues ya 00:03:50
se verá extensamente el año que viene 00:03:53
y a ficheros también 00:03:55
pero vamos a ver 00:03:57
hacer una primera introducción 00:04:00
la que corresponde a primero ahora 00:04:02
entonces, vamos a ver 00:04:04
muy pocas clases de acceso a ficheros 00:04:06
porque el acceso a ficheros como todo 00:04:09
ahora ya en Java se trata de 00:04:10
seleccionar las clases que ya 00:04:12
están hechas, que hacen lo que yo quiero 00:04:14
y usarlas 00:04:16
cuando hemos hecho la interfaz gráfica, ¿qué hemos hecho? 00:04:17
hemos construido algo nosotros, no hemos construido nada 00:04:20
hemos usado clases que ya estaban hechas 00:04:22
el frame, el button, el no sé qué 00:04:24
y las hemos reutilizado 00:04:26
con herencia el JFrame 00:04:28
con composición el JButton 00:04:30
porque lo hemos metido en el JFrame 00:04:32
se trata ahora ya para nosotros 00:04:33
de construir nuestras aplicaciones 00:04:36
reutilizando lo que ya está 00:04:37
pues el acceso a ficheros igual 00:04:39
habrá clases 00:04:41
que tienen ya código hecho 00:04:42
para acceder a ficheros 00:04:44
código hecho 00:04:46
y nosotros tenemos ya que 00:04:46
utilizarlas correctamente 00:04:48
para meterlas en nuestros programas 00:04:49
utilizarlas correctamente 00:04:53
no se trata solo de que sepamos 00:04:54
qué métodos tienen y usarlos, no, eso no 00:04:55
eso es una tontería 00:04:57
eso está en la documentación, se trata de que 00:04:59
nosotros sepamos hacer nuestro programa, programar 00:05:01
programar y programar es 00:05:03
primer trimestre, sentencias 00:05:05
de decisión, bucles, etcétera 00:05:08
construir nuestros algoritmos 00:05:09
y alguna de esas sentencias ya usarán 00:05:11
puntualmente métodos de clases que ya están hechas 00:05:13
¿vale? 00:05:16
bueno, pues entonces vamos a ver 00:05:17
algunas clases, pocas 00:05:19
de acceso a ficheros y sobre todo 00:05:21
lo vamos a orientar 00:05:24
a usarlas en ejercicios 00:05:25
que nos puedan servir un poco de repaso 00:05:27
de todo lo anterior 00:05:29
un poquito de repaso, pues de cara 00:05:31
a los exámenes de recuperación 00:05:33
próximos que quedan, etcétera 00:05:35
¿vale? poquitas clases 00:05:37
y los ejercicios orientados 00:05:38
a repasar lo importante 00:05:41
de alguna manera, ¿vale? a reforzar 00:05:43
lo importante 00:05:45
para que, bueno, pues 00:05:46
mejoren los resultados 00:05:48
para los próximos exámenes 00:05:51
Venga, pues a ver 00:05:53
Clases que vamos a ver 00:05:55
Relacionadas con ficheros 00:05:56
Hay una clase 00:05:58
Que es básica 00:06:00
Que es esta clase 00:06:02
La clase File 00:06:05
Entonces la clase File 00:06:07
Es una clase 00:06:10
Que sirve para guardar 00:06:12
Una referencia 00:06:14
A una ubicación 00:06:16
De nuestro sistema de archivos 00:06:18
Simplemente para eso 00:06:20
cuando digo sistema de archivos 00:06:21
digo el sistema de archivos 00:06:45
local 00:06:47
del equipo donde se esté ejecutando 00:06:48
el proceso 00:06:51
porque para acceder 00:06:52
a otros ordenadores 00:06:57
hay que hacerlo mediante sockets 00:06:58
eso es otra cosa, eso es otro rollo 00:07:00
que también veréis el año que viene 00:07:02
para hacer otro equipo tengo que establecer una conexión de red 00:07:04
no hay tutía, una conexión de red 00:07:07
pues siempre va a ser mediante sockets 00:07:09
si es TCP al menos 00:07:10
vale, nosotros no estamos en eso 00:07:12
ahora, nosotros estamos accediendo 00:07:15
al sistema de archivos local 00:07:16
del equipo donde 00:07:18
se ha arrancado la aplicación 00:07:20
bueno, el sistema de archivos 00:07:23
local tiene una forma de referirnos a sus 00:07:25
ubicaciones que todos conocemos de toda la vida 00:07:27
en Linux pues con la barra para un lado 00:07:29
y en Windows pues con la barra para otro 00:07:31
en Windows además con unidades 00:07:32
con letras y en Linux no 00:07:35
entonces todos 00:07:37
sabemos que los sistemas de archivos sean 00:07:39
tipo Linux, tipo Windows tienen una 00:07:40
forma de referirse a las rutas 00:07:42
¿verdad? a través de 00:07:45
el camino, luego el fichero, etc 00:07:46
bueno, pues cada una 00:07:49
de esas posibles rutas 00:07:51
de nuestro sistema de archivo, podemos asociarla 00:07:52
a un objeto file 00:07:55
y ya está 00:07:56
y ahora ya, ese objeto file 00:07:57
lo puede usar la aplicación para algunas 00:08:00
cosas, para sacar información 00:08:02
sobre esa ruta, para algunas cositas 00:08:04
muy pocas, porque 00:08:07
para hacer otras cosas ya están otras clases 00:08:08
¿vale? 00:08:10
Entonces, esa ruta a la que hace referencia el objeto file es una ruta que puede existir, puede no existir. 00:08:12
O sea, el objeto existe haciendo referencia a una ruta. 00:08:19
Luego ya la ruta puede que exista, puede que no exista, puede que sea un directorio, 00:08:22
puede que no sea un directorio, sino que sea un fichero. 00:08:26
Puede que tenga permisos de lectura, que no los tenga. 00:08:28
Entonces, toda esa información la podemos sacar a partir de esa referencia. 00:08:31
Bueno, pues entonces 00:08:35
Si nos vamos aquí, por ejemplo 00:08:37
Un proyecto 00:08:47
Ejemplos 00:08:50
Entrada 00:08:55
Salida 00:08:56
De clase 00:08:57
Vale, pues vamos a hacer 00:08:59
Un primer paquete 00:09:05
Que se llame file 00:09:07
Porque son ejemplos con la clase file 00:09:09
Venga, pues nos hacemos una clase 00:09:12
Vale, pues entonces 00:09:18
File es una clase 00:09:47
Si queremos declarar un objeto de esa clase, obviamente, como siempre, pues el nombre de la clase y el nombre de, pues yo qué sé, de la referencia. 00:09:48
Vale. 00:10:00
Entonces, la clase File la tenemos que importar ¿de dónde? 00:10:01
De Java.io. 00:10:09
En Java.io, Java.io es un paquete básico, un paquete básico dentro de la máquina virtual, dentro de la librería JRE. 00:10:10
Es un paquete básico que tiene un montón de clases relacionadas con acceso a ficheros. 00:10:17
es el de toda la vida, no es el único 00:10:21
luego está Java Neo 00:10:24
Java Neo que tiene otras 00:10:26
clases que se han ido 00:10:28
incorporando 00:10:30
también para acceso a ficheros 00:10:31
pero ese es el básico, es como las fechas 00:10:33
pues Java útil tiene 00:10:36
las clases de toda la vida para fechas 00:10:38
y luego está Java Time que se incorpora 00:10:40
más tarde para cosas más específicas 00:10:42
bueno, hay de todo, miles de clases 00:10:44
que si uno alguna vez quiere hacer algo 00:10:46
concreto, pues busca y dice 00:10:48
a ver si tengo clases relacionadas con esto 00:10:50
las busca, las utiliza y ya está 00:10:52
lo que importa es que luego sepa programar 00:10:54
para decidir dónde va cada cosa 00:10:56
pero las clases ya lo tienen 00:10:58
todo hecho dentro 00:11:00
bueno, pues entonces 00:11:01
ahora mismo la variable está declarada 00:11:04
¿cómo la instanciamos? 00:11:06
pues file se instancia 00:11:08
con el constructor 00:11:10
normalmente esto ya 00:11:12
como curiosidad 00:11:14
el instanciar los objetos con constructores 00:11:15
Con el new, perdón 00:11:18
Porque siempre instancian con constructores 00:11:20
Instanciarlos con el new 00:11:22
Es una cosa que se ha ido perdiendo 00:11:24
Vale 00:11:27
Y se ha ido cambiando 00:11:29
Por otro patrón de diseño distinto 00:11:31
Que es 00:11:33
Yo te prohíbo el constructor 00:11:40
Es decir, lo hago privado 00:11:42
Entonces si yo lo hago privado 00:11:44
Si file tuviera dentro el constructor privado 00:11:46
Que no es el caso 00:11:49
Esta es la clase file 00:11:50
Vale 00:11:52
pues el constructor de la clase file 00:11:54
que está en algún sitio 00:11:56
estará, veis 00:11:58
pues es público 00:12:11
es un constructor 00:12:13
público y al ser público el constructor 00:12:15
de la clase file, eso me permite a mí instanciar 00:12:17
el objeto file haciendo new 00:12:19
vale, bueno pues cada vez 00:12:20
está cuando uno hace clases para que 00:12:23
otros las usen, cada vez se está 00:12:25
perdiendo más este patrón de diseño 00:12:27
porque es peligroso el permitir al usuario 00:12:29
que él use directamente el constructor 00:12:31
sino que lo que se suele hacer es 00:12:33
lo hago privado 00:12:35
porque constructor tiene que haber 00:12:37
lo hago privado 00:12:38
aunque sea el por defecto 00:12:40
sin parámetros 00:12:42
que no tiene nada dentro 00:12:42
constructor tiene que haber 00:12:43
porque de hecho 00:12:44
si uno hace una clase 00:12:45
y no le pone un constructor 00:12:46
ya hemos dicho 00:12:47
que entonces 00:12:48
hay uno por defecto 00:12:49
sin parámetros 00:12:50
que no hace nada 00:12:51
que se está siempre 00:12:51
aunque yo no escriba nada 00:12:52
pero el constructor tiene que haber 00:12:53
porque si no 00:12:55
no se puede instanciar el objeto 00:12:55
bueno pues entonces 00:12:56
un patrón de diseño 00:12:58
cada vez más habituales 00:12:59
vamos a hacerlo privado 00:13:01
prohíbo al que use mis clases 00:13:02
instanciarme con el new file 00:13:05
y me hago yo un método aparte 00:13:07
que sea crear objeto 00:13:09
y te obligo a que 00:13:10
tú instancies el objeto llamando a crear 00:13:12
objeto y ese crear objeto 00:13:15
ya te llama el constructor 00:13:17
hace dentro todas las verificaciones 00:13:19
de seguridad, se asegura de que tienes 00:13:21
permisos para no sé qué, patatín patatán 00:13:23
y te devuelve el objeto ya creado 00:13:25
¿vale? 00:13:27
entonces 00:13:30
una forma a veces de ver si una librería 00:13:30
es de las de toda la vida o no 00:13:33
es si permite 00:13:35
o es más moderna, es si permite 00:13:37
instanciar objetos 00:13:39
de esa clase con new o no lo permite 00:13:41
vale, new lo permite porque es que 00:13:43
es una librería que lleva desde Java 2 00:13:45
me parece, entonces por compatibilidad 00:13:47
no ha perdido la posibilidad de instanciar 00:13:49
directamente con el constructor 00:13:51
bueno, pues entonces 00:13:52
para instanciar el objeto file 00:13:54
el de toda la vida 00:13:57
Este objeto es el que se usa siempre 00:13:57
Y vais a ver en todas las aplicaciones 00:14:02
Cuando una aplicación quiere referirse a un fichero 00:14:03
O a una ruta 00:14:06
Pues hay que crear una referencia 00:14:06
A esa ruta 00:14:10
Entonces, en el constructor que tenemos que poner 00:14:11
Pues esa ruta 00:14:14
Se puede poner de dos maneras 00:14:15
Absoluta o relativa 00:14:18
¿Vale? Por ejemplo, si yo quiero hacer referencia 00:14:20
A mi escritorio 00:14:24
Mi escritorio 00:14:25
Pues no, quería esto, espérate 00:14:29
Bueno, pues vengámonos aquí 00:14:36
Una carpeta cualquiera 00:14:45
Venga, voy a hacer una carpeta 00:14:50
Prueba, ficheros 00:15:02
Aquí en el escritorio 00:15:03
Vale, a ver si 00:15:09
Ahora, esto sí quería 00:15:10
Vale, pues ya he puesto la ruta 00:15:13
He puesto la ruta 00:15:22
de esta ubicación, que en particular 00:15:23
es un directorio, pero podría ser un fichero 00:15:26
da igual, es una ruta 00:15:28
un punto del sistema de archivos, un punto de mi árbol 00:15:30
bueno, pues 00:15:32
el objeto file tiene que 00:15:35
ser referencia a un punto del árbol 00:15:36
a un punto de un árbol, un punto de mi árbol 00:15:38
¿vale? 00:15:40
esta es una ruta absoluta, porque 00:15:42
parte de C, que es la raíz 00:15:44
de los 00:15:46
archivos 00:15:48
de la unidad C 00:15:50
¿por qué aparece 00:15:51
dos barritas? 00:15:54
bueno, aparece dos barritas 00:15:57
porque si pusiéramos solamente una 00:15:58
si pusiéramos solamente una barrita 00:16:00
esta barra, que es 00:16:06
para un paese 00:16:10
esto significa 00:16:12
ojo, que empieza un carácter especial 00:16:14
con lo cual, tómame 00:16:16
con la siguiente letra y yo voy a ser 00:16:18
el carácter especial barra U 00:16:20
si es que existe, que igual no existe 00:16:21
los especiales que existen, pues barra T 00:16:23
existe, que es el tabulador 00:16:26
barra S creo que es el espacio, no lo sé 00:16:27
entonces, en la tabla 00:16:30
ASTI hay una serie de caracteres especiales 00:16:32
claro, como el espacio, el tabulador 00:16:34
algunos otros más 00:16:36
y esos caracteres especiales no se pueden escribir 00:16:37
pues la forma de escribirlos 00:16:40
es como carácter de escape, que es la barrita 00:16:42
y una letra 00:16:44
¿vale? 00:16:46
barra N es el carácter 00:16:47
ASTI salto de línea 00:16:49
entonces el carácter ASTI salto de línea 00:16:52
lo escribimos como barra de escape 00:16:54
y N 00:16:56
entonces si yo aquí dejo solo una barra 00:16:57
esto lo interpreta como 00:17:00
oye, que me refiero a la letra que viene después 00:17:02
cógeme junto con ella y ese es el carácter 00:17:04
ASTI barra U, existe, por otro lado 00:17:06
si existe o no, pero si existiera 00:17:08
pues se referiría a ese carácter 00:17:09
y aquí lo mismo, carácter de escape 00:17:12
barra A, y no, yo no me quiero referir a eso 00:17:14
yo me estoy refiriendo a la barra divisora 00:17:16
de las rutas, a la barra divisora 00:17:18
entonces 00:17:20
como lo indicamos, poniéndole a esa 00:17:21
barra divisora otro carácter 00:17:24
de escape, otra barra de escape 00:17:26
¿vale? entonces ahora ya 00:17:27
esto sí que lo interpreta como 00:17:40
oye carácter de escape, cógeme con el siguiente 00:17:41
y el siguiente ahora ya sí 00:17:44
que es esta barra, entonces esto lo interpreta 00:17:46
como una única barra, bueno pues 00:17:48
con esto hemos especificado una ubicación 00:17:51
una ubicación 00:17:52
válida sintácticamente 00:17:54
válida sintácticamente 00:17:57
Ahora ya esa ubicación 00:17:59
Puede referirse a una ruta que existe 00:18:01
Que no existe 00:18:04
Que es directorio, que no lo es 00:18:05
De aquí ya podemos sacar un montón de información 00:18:07
Y podemos sacarla 00:18:10
A través de 00:18:12
Los métodos de la clase file 00:18:15
¿Vale? 00:18:17
O sea, si vemos los métodos que tiene ahora esta clase 00:18:32
Pues tiene un montón de métodos 00:18:34
Para hacer cosas con este fichero 00:18:36
Este te devuelve un true 00:18:38
si tienes permisos y el usuario 00:18:40
que arrancó el proceso 00:18:42
si tiene permisos de ejecución sobre el fichero 00:18:43
este tiene permisos de lectura 00:18:46
si tienes permisos de escritura 00:18:48
este método 00:18:50
compara con otro fichero 00:18:52
para ver si es igual o no es igual 00:18:54
para crear 00:18:57
un nuevo fichero 00:18:59
en esa root 00:19:00
un nuevo fichero con ese nombre 00:19:01
directamente ese 00:19:04
para borrarlo 00:19:06
que este funciona o no funciona 00:19:07
dependiendo de nuestro sistema operativo 00:19:09
y de los permisos que tenga el proceso 00:19:11
no, depende de nuestra 00:19:13
situación, puede funcionar o no 00:19:15
de nuestro equipo, de nuestro usuario, con el que hayamos 00:19:16
arrancado, de muchas cosas 00:19:19
¿vale? si existe o no existe 00:19:20
te saca el nombre, el nombre sin más 00:19:22
sin la ruta anterior, aquí te saca 00:19:27
la ruta, bueno, pues diferentes cosas 00:19:29
pero tampoco 00:19:31
el tamaño 00:19:33
el tamaño 00:19:37
esto solamente si es fichero 00:19:39
si es directorio, no, la fecha de la última 00:19:42
modificación, te crea 00:19:43
un directorio 00:19:47
con ese nombre 00:19:48
bueno, muchas cosas que puede hacer 00:19:50
¿vale? 00:19:52
entonces 00:19:57
por ejemplo 00:19:58
vamos a ver 00:20:01
vamos a ver, ¿existe? 00:20:03
pues entonces podemos poner 00:20:09
la ruta o 00:20:10
Como lo queréis llamar, existe 00:20:18
¿Qué es un directorio? 00:20:20
Pues podemos poner 00:20:36
La ruta 00:20:37
Es un directorio 00:20:39
¿Qué no? Pues no será un directorio 00:20:42
Entonces será un fichero 00:20:45
¿Vale? Podríamos sacar información 00:20:46
Vamos a poner una más solo y ya está 00:20:57
Por ejemplo, vamos a ver el length 00:20:59
Que nos saca 00:21:04
En este caso, como es un directorio, a saber lo que nos saca 00:21:05
¿Vale? 00:21:11
Pues vamos a ejecutar esto 00:21:22
He puesto el main mal 00:21:34
Voy a salir voy main 00:21:44
Porque no me deja ejecutar 00:21:46
Hay algo que 00:21:53
Eso está bien escrito, ¿verdad? 00:22:08
Bueno, es que si no me daría error de 00:22:17
No me da ningún rojo 00:22:19
No me da ningún error de 00:22:20
Ah, no está bien escrito 00:22:21
Si es que 00:22:25
cuando os digo que os fijéis 00:22:26
por mí, no me hacéis caso 00:22:28
vale, ahora ya sí 00:22:29
vale, la ruta existe 00:22:31
es un directorio, tamaño 0 00:22:37
porque es que no es un fichero 00:22:39
vamos a suponer que nos hemos equivocado 00:22:40
y ponemos esto 00:22:42
la ruta es un fichero, pero no me dice la ruta existe 00:22:44
no había un else, ¿no? 00:22:51
vale, entonces me dice 00:22:53
aquí ha entrado en el else 00:22:55
porque eso ha sido un false 00:22:57
entonces no me ha dicho ruta existe 00:22:58
aquí ha entrado en el else 00:23:00
Porque no es un directorio 00:23:01
Entonces por eso me ha dicho la ruta es un fichero 00:23:04
¿Vale? 00:23:06
Porque ha entrado en el else 00:23:07
Porque un directorio no es 00:23:09
Y luego, pues ruta.len 0 00:23:11
Pero no tiene nada, ni siquiera existía 00:23:14
Si le ponemos un fichero 00:23:16
Por ejemplo 00:23:17
Voy a meter en 00:23:20
Mi carpeta 00:23:21
Prueba ficheros 00:23:23
Un fichero cualquiera 00:23:25
Un fichero cualquiera de texto 00:23:26
Bueno, con un nombre que me pueda acordar luego para escribir 00:23:29
Cambiar nombre 00:23:34
Fichero.txt 00:23:40
Vale, vamos a ponerle algo 00:23:45
Para que tenga bytes 00:23:46
Vale, pues voy a ejecutar esto mismo 00:23:49
Poniéndole 00:23:56
La ruta del fichero que tiene dentro 00:23:59
Fichero.txt 00:24:01
vale, a ver ahora 00:24:07
¿qué me dice? 00:24:09
le he dado otra ruta, ahora esta es un fichero en concreto 00:24:10
existe, si no la he escrito mal, existe 00:24:13
lo ejecutamos 00:24:15
vale, existe, es un fichero 00:24:18
y tiene 7 bytes 00:24:21
vale, y tendrá 00:24:22
porque creo que he escrito 7 caracteres 00:24:25
y en un fichero de texto hecho con el blog de notas 00:24:26
cada carácter se escribe 00:24:29
en un único byte 00:24:30
vale, entonces 00:24:33
así estaría la ruta absoluta 00:24:37
¿vale? entonces las rutas 00:24:39
absolutas tienen problemas 00:24:46
claro, que si esta aplicación 00:24:48
yo la muevo 00:24:50
a otro ordenador para ejecutarla 00:24:51
en ese ordenador 00:24:54
será mucha casualidad que el fichero esté 00:24:55
en el mismo sitio, será mucha casualidad 00:24:58
entonces si 00:25:00
y que ese ordenador a lo mejor 00:25:02
el usuario que está trabajando no es admin 00:25:04
está trabajando el usuario Pepito 00:25:05
entonces esta misma aplicación la trato de ejecutar 00:25:07
en otro equipo 00:25:10
y esta ruta ya no se corresponde. 00:25:11
A lo mejor el usuario tiene el archivo de trabajo, lo tiene. 00:25:15
Pero no lo tiene en esta ruta, lo tiene en otra. 00:25:17
Entonces, las rutas absolutas tienen ese peligro. 00:25:20
Entonces, hay otra forma de referirnos, 00:25:24
de darle aquí una ruta, 00:25:27
que es darle una ruta relativa. 00:25:29
Entonces, ¿la ruta relativa es relativa a qué? 00:25:34
Si es relativa, ¿es relativa a algún punto? 00:25:37
Bueno, pues el punto respecto al cual es relativa 00:25:39
la ruta para Java, para la aplicación 00:25:42
es la raíz del proyecto 00:25:45
en el que estás 00:25:47
entonces, a partir de ese punto 00:25:47
tú ya puedes poner 00:25:59
una ruta, por ejemplo 00:26:01
vamos a poner 00:26:03
aquí otra 00:26:04
entonces, yo quiero que esta 00:26:09
aplicación sea 00:26:12
portable, es decir 00:26:13
que cuando alguien la coja 00:26:16
y la lleve a su ordenador y la ejecute 00:26:18
le funcione y encuentre 00:26:20
el fichero, porque si no encuentra el fichero 00:26:22
obviamente no le va a funcionar 00:26:24
bueno 00:26:27
pues entonces 00:26:28
lo habitual es que yo 00:26:30
ponga ese fichero 00:26:32
dentro del proyecto, donde a mi me dé 00:26:33
la gana, por ejemplo 00:26:36
voy a crear dentro 00:26:38
del proyecto una nueva carpeta 00:26:40
una nueva carpeta 00:26:42
la voy a llamar fichero, o sea esa carpeta 00:26:50
si en new folder me he 00:26:54
situado en la raíz del proyecto 00:26:58
lo que se nombra el proyecto 00:27:00
¿vale? y aquí en mi raíz del proyecto he creado 00:27:01
una carpeta, que esa carpeta 00:27:08
pues está aquí, claro, si yo me voy ahora 00:27:10
al sistema de archivos 00:27:12
pues aquí está mi 00:27:14
proyecto, este de aquí 00:27:16
ejemplos, entrada, salida 00:27:18
y dentro de ejemplos 00:27:19
entrada, salida, pues está 00:27:22
esta carpeta que me acabo de crear, junto 00:27:24
con la fuente de los 00:27:26
la bin, las que están siempre, pues también está 00:27:27
esta, y aquí por ejemplo 00:27:30
me voy a hacer un archivo 00:27:32
cualquiera 00:27:33
al que le meto datos 00:27:35
lo que yo quiera 00:27:42
bueno 00:27:43
si se te ha hecho dentro de src 00:27:51
igual es porque has hecho el new 00:27:53
aquí, entonces hace el new 00:27:55
pinchando aquí 00:27:59
vale, pues entonces 00:27:59
ahora ya sí que nos podemos referir 00:28:10
vamos a crear una referencia 00:28:12
file a esa ruta 00:28:14
pero ya de forma relativa 00:28:16
entonces como la raíz 00:28:17
es donde está mi proyecto 00:28:20
yo ahora ya pongo directamente 00:28:22
la subcarpeta de mi raíz que es ficheros 00:28:24
y pongo el 00:28:26
fichero 00:28:28
entonces esta ruta se refiere 00:28:29
a que todo esto 00:28:33
la máquina virtual asume que está 00:28:34
colgando 00:28:37
de la raíz del proyecto 00:28:38
asume que está colgando de ahí 00:28:41
lo concatena a la raíz del proyecto 00:28:43
y en este caso 00:28:45
efectivamente le lleva a un sitio que existe 00:28:47
si no existe no pasa nada 00:28:49
la referencia se crea igual 00:28:52
pero simplemente esa referencia no existe 00:28:53
y si yo le doy a exist me dirá 00:28:55
no existe esa referencia 00:28:57
bueno es relativa 00:28:58
pero es 00:29:04
relativa porque no 00:29:07
cuelga del raíz 00:29:09
ni de ninguna 00:29:10
pero no cuelga de la raíz suprema 00:29:15
claro por eso es relativa 00:29:18
o sea, las absolutas son las que cuelgan 00:29:22
de la raíz del sistema operativo 00:29:25
las relativas son las que cuelgan de un punto intermedio 00:29:26
sea el que sea, un punto intermedio 00:29:29
es así, o sea 00:29:31
las raíces absolutas son las unidades 00:29:32
fe, de, esas raíces absolutas 00:29:34
raíz relativa, cualquiera entre medias 00:29:36
cualquiera entre medias, entonces la de arriba 00:29:38
cuelga de la raíz absoluta 00:29:41
de una de las que hay 00:29:43
si hay varias unidades, en Linux solo hay una 00:29:44
raíz absoluta 00:29:46
y esta relativa porque te 00:29:49
cuelga de un punto intermedio 00:29:51
entonces, él aquí 00:29:52
no ve que haya una ruta absoluta 00:29:55
porque no está viendo ni C, ni D, ni nada 00:29:58
entonces dice, ah, tú no eres ruta absoluta 00:30:00
eres relativa, es relativa 00:30:02
¿y de dónde cuelgas? porque si es relativa 00:30:03
falta una información, que es el punto de cuelgue 00:30:06
cuando es absoluta no falta ninguna 00:30:08
información, está aquí 00:30:10
pero cuando es relativa, te falta una información 00:30:11
¿y tú de dónde cuelgas? 00:30:14
esa información es raíz del proyecto 00:30:15
raíz del proyecto 00:30:18
esta información adicional no le hace falta 00:30:19
¿vale? 00:30:22
bueno pues entonces 00:30:27
esta cuelga de la raíz del proyecto 00:30:28
y concatenada 00:30:30
que igual es lo que te confunde 00:30:32
cuando él ya la concatena internamente 00:30:33
a la raíz del proyecto 00:30:36
obviamente la que forma él es absoluta 00:30:37
porque está colgada de la raíz 00:30:40
pero la que tú escribes aquí 00:30:42
la que ves con tus ojos 00:30:43
esta es relativa 00:30:44
Porque esta es 00:30:46
Necesita una información adicional 00:30:48
Que tú no le estás dando 00:30:49
Esta no necesita ninguna información adicional 00:30:50
La estás dando toda 00:30:53
Por eso es absoluto, no necesitas nada más 00:30:54
Esta necesitas algo más 00:30:57
Si no está incompleta 00:30:59
Por eso es relativa, porque está incompleta 00:31:00
Y ese algo más, ¿cuál es? 00:31:02
La raíz del proyecto, por convenio 00:31:05
Podría ser otra cosa, pero por convenio la raíz del proyecto 00:31:07
Vale, bueno, pues entonces 00:31:09
Si hacemos esto mismo con ruta 2 00:31:13
no le he puesto el punto y coma 00:31:17
vale, pues existe, es un fichero 00:31:29
y tiene seis, los que he metido 00:31:39
vale, en este caso es un fichero y ya está 00:31:40
vale 00:31:43
bueno, pues entonces 00:31:44
esta clase es la clase que se usa 00:31:46
para desde una aplicación 00:31:49
referirse a un fichero 00:31:50
no es la clase que se usa para leer de él 00:31:51
y escribir en él, para leer de él 00:31:54
y escribir en él se usan otras clases que veremos 00:31:56
ahora, esta se usa para referirse 00:31:59
a un fichero 00:32:01
¿Y por qué es importante referirse a un fichero? 00:32:01
Porque muchas veces las aplicaciones 00:32:04
Los métodos de las aplicaciones 00:32:06
Necesitan que tú le pases como parámetros ficheros 00:32:08
Para trabajar con ellos 00:32:10
Pues cuando tú pasas como parámetro un fichero 00:32:11
Cuando entregas un fichero 00:32:14
Para decir, trabaja con él 00:32:16
¿Dónde lo pasas? 00:32:18
En un objeto file 00:32:21
¿Vale? En un objeto file 00:32:22
Por ejemplo, vamos a hacer un método que nos dice 00:32:23
Método que 00:32:26
Necesita una funcionalidad que sea 00:32:28
te voy a pasar un array de ficheros 00:32:30
que veremos a ver de dónde lo sacamos 00:32:32
ahora, pero el método se le pasa 00:32:34
un array de ficheros 00:32:36
y ahora me tienes que decir 00:32:37
el que tiene más bytes 00:32:40
de todos, por ejemplo, ¿vale? 00:32:42
entonces, ese método 00:32:45
que te pueden haber 00:32:46
pedido un método, que sea 00:32:48
el método 00:32:49
recibe un 00:32:51
array de 00:32:54
ficheros 00:32:56
y devuelve 00:32:57
el fichero 00:33:04
de mayor tamaño 00:33:07
¿vale? por ejemplo, pues yo que sé 00:33:09
puede ser interesante hacer un método que 00:33:13
oye, estos son los ficheros que he encontrado en esta carpeta 00:33:15
devuélveme el que sea mayor 00:33:18
porque el que sea mayor es el que tengo que eliminar 00:33:19
o el que tengo que tener en cuenta o lo que sea 00:33:21
bueno, pues podría 00:33:23
uno necesitar hacer un método así 00:33:25
¿vale? porque las funcionalidades que uno hace 00:33:27
siempre las meten métodos 00:33:30
claro, uno hace un método con las funcionalidades 00:33:32
ahí encapsula la funcionalidad en un método 00:33:34
y luego ya la aplicación llama a los métodos que van 00:33:36
interesando 00:33:39
bueno, pues vamos a encapsular esta funcionalidad 00:33:39
concreta de coger una raíz de ficheros 00:33:43
y devolver el más grande de todos, el de más 00:33:45
tamaño, vamos a encapsularla 00:33:47
en este método, para que la llame quien quiera 00:33:49
bueno, pues 00:33:51
siempre que hacemos un método, como de costumbre 00:33:53
nombre lo mejor 00:33:55
elegido posible, aunque sea muy largo 00:33:57
pues 00:33:59
fichero 00:34:01
Mayor tamaño 00:34:05
Bueno, es que 00:34:09
Las señas no las quiero poner 00:34:11
Fichero más grande 00:34:13
Aunque sea un poco feo 00:34:18
Vale 00:34:20
Bueno, pues ahora 00:34:22
Parámetros que recibe este método 00:34:23
Este método tiene que 00:34:26
Recibir 00:34:28
Muchos ficheros 00:34:30
Muchos podría meterlo 00:34:33
En una lista, podría meterlo en un array 00:34:35
Podría meterlo en cualquier cosa 00:34:36
un array 00:34:37
no es una opción que tengamos 00:34:40
que desestimar solo 00:34:42
porque da pereza insertar 00:34:44
y sacar cosas de ella y porque 00:34:46
sea estática 00:34:48
es decir, los arrays dan pereza 00:34:49
dan pereza por esas dos razones 00:34:52
porque 00:34:55
una vez 00:34:56
que están instanciados 00:34:58
el tamaño con el que se ha instanciado 00:35:01
no puede variar, entonces por eso dan 00:35:03
pereza, que quiero meter algo adicional 00:35:04
tengo que crear uno nuevo 00:35:06
más grande y copiar y pegar 00:35:08
¿vale? una vez que están instanciados 00:35:10
es por lo único 00:35:13
por lo que dan pereza 00:35:15
pero por lo demás son todo, todo, todo 00:35:15
ventajas, en cuanto a que son 00:35:18
la estructura nativa 00:35:20
de la aplicación, las listas, los conjuntos 00:35:21
son clases que se han construido por encima 00:35:24
y tienen un montón de morralla 00:35:26
¿vale? eso sí 00:35:28
son muy fáciles de usar 00:35:30
son facilísimos de usar 00:35:31
pero claro, por detrás 00:35:34
hay un montón de lógica que es morraya 00:35:36
pero tú no la usas muy fácilmente 00:35:38
el array es lo mejor del mundo 00:35:40
lo que pasa es que da pereza usarlo 00:35:42
por eso que decimos, porque tiene un tamaño 00:35:44
fijo, pero bueno, en este caso 00:35:46
en un método 00:35:48
te pasan el parámetro 00:35:50
bueno, pues estupendo, pásame 00:35:52
un array, ya está, y el array 00:35:54
tú me lo pasas del tamaño que quieras 00:35:56
7, 12, 15, del que quieras 00:35:58
y yo ya como tengo el método 00:36:00
el parámetro length para ver 00:36:02
su tamaño, pues porque no voy a 00:36:04
elegir un array, si es lo mejor del mundo 00:36:06
pues venga 00:36:08
vamos, en este 00:36:10
caso entonces, haríamos 00:36:12
esto, vale 00:36:14
este sería el parámetro 00:36:17
un montón 00:36:20
de objetos file 00:36:22
este un montón 00:36:24
puede ser de cualquier referencia, ya lo sabemos 00:36:27
este un montón podría 00:36:29
ser de alumno, de string, de lo 00:36:31
que sea, pues en este caso este un montón 00:36:33
es de file 00:36:36
¿Vale? File es otra clase más 00:36:37
¿Vale? 00:36:39
Que 00:36:42
Queremos que se pase en una lista 00:36:43
Por alguna razón, pues es exactamente igual 00:36:47
La lista estaría 00:36:49
Parametrizada a file 00:36:51
File es una clase más 00:36:53
Como si fuera string, alumno, cliente, factura 00:36:54
Es una clase más que ahora ya sabemos 00:36:56
Lo que significa 00:36:58
Pero lo que queremos es pasar un array 00:36:59
De ficheros 00:37:03
que a la hora de pasar por parámetros 00:37:03
se usa más 00:37:06
porque cuando yo paso por parámetro 00:37:07
aquí 00:37:10
el problema de que el tamaño sea 00:37:11
no lo pueda cambiar 00:37:14
aquí no afecta 00:37:16
porque aquí el parámetro es el que 00:37:17
a mí me están dando, que ya está hecho 00:37:19
entonces yo ya no tengo ese problema 00:37:21
de con qué tamaño instanciarlo 00:37:24
es que ya me lo están dando, con el tamaño que sea 00:37:26
entonces para paso por parámetro 00:37:28
es una situación en la que 00:37:30
vemos más a menudo que cuando tengo que pasar 00:37:32
muchos de algo 00:37:34
se pasa como array, muchos de algo 00:37:35
porque para el método es mucho más cómodo 00:37:38
recorrerlo como array que como lista 00:37:40
que como, vale 00:37:42
bueno, pues nada 00:37:43
hemos elegido array, pues hemos elegido array 00:37:46
vale, y que va a devolver 00:37:48
este, un objeto fichero 00:37:49
con el fichero más grande, pues si va a devolver un objeto 00:37:52
fichero, pues esto 00:37:54
ahora la cabecera del método ya está 00:37:55
public 00:37:58
Si es que yo quiero que se use desde fuera de la clase 00:38:00
En este caso 00:38:02
Como la voy a usar 00:38:04
Aquí dentro de este método 00:38:05
La voy a usar aquí dentro de este método 00:38:07
La voy a poner static 00:38:09
Para poder usarla 00:38:11
Desde aquí dentro 00:38:14
Porque si no le pongo el static 00:38:15
Y yo la quiero usar 00:38:19
Desde aquí dentro 00:38:22
¿Qué tendría que hacer? 00:38:23
Para que no me dé error de compilación 00:38:29
Voy a poner return null para que se quede tranquilo 00:38:31
El compilador 00:38:33
vale 00:38:34
así el método ya está bien 00:38:36
return null y ahora pregunto 00:38:38
repito que todo esto 00:38:40
lo estoy utilizando 00:38:42
para reforzar o repasar 00:38:43
las cosas que 00:38:46
tenemos que saber 00:38:48
vale 00:38:50
si yo a este método no le pongo static 00:38:52
porque no me da la gana ponerlo static 00:38:53
y quiero usarlo desde aquí 00:38:55
dentro 00:38:58
¿qué tendría que hacer? 00:38:58
dictadme que tendría que hacer para poder llamar a ese método 00:39:03
desde aquí, está claro que esto 00:39:06
no puedo, ¿verdad? 00:39:12
espera, voy a 00:39:19
para que el compilador se calle 00:39:19
voy a hacer aquí 00:39:21
una referencia 00:39:22
efectivamente 00:39:25
vale, entonces 00:39:34
si yo lo llamo así 00:39:35
obviamente me está diciendo 00:39:39
no puedes hacer 00:39:43
no puedes llamar 00:39:44
a un método o a un recurso 00:39:46
no estático desde este contexto 00:39:49
tuyo en el que estás que es estático 00:39:51
el error que ya sabemos 00:39:53
entonces si yo hago estático esto 00:39:54
pues entonces es magnífico 00:39:57
ya puedo, vale, pero yo no quiero 00:39:59
hacerlo estático, no quiero hacerlo estático porque este 00:40:01
método, por la razón que sea 00:40:03
no quiero hacerlo estático, vale, pues entonces 00:40:05
¿cómo puedo arreglar esto? 00:40:07
para poder seguirlo llamando 00:40:09
instanciando un objeto de qué clase 00:40:10
vale 00:40:15
miento, no 00:40:15
la clase que contiene 00:40:18
efectivamente, efectivamente 00:40:20
efectivamente, tendríamos que instanciar 00:40:22
un objeto de esta clase 00:40:24
y ahora ya un objeto concreto 00:40:25
de esa clase puede llamar a todos un método 00:40:28
sean estáticos o no, pero necesito un objeto 00:40:30
de esa clase, vale, entonces tendría 00:40:32
que instanciar 00:40:34
un new ejemplo 00:40:36
file, vale 00:40:38
y ahora ya con este objeto 00:40:41
instanciado, ya puedo llamar a sus 00:40:43
propiedades que no tiene 00:40:46
a sus métodos, a lo que yo 00:40:47
quiera, vale 00:40:50
Eso si es que yo 00:40:51
No quiero hacer esto estático 00:40:53
Pero 00:40:54
De hecho lo voy a dejar así 00:40:56
En el proyecto para que no 00:40:58
Sigáis 00:41:01
Teniendo presente estas cosas 00:41:03
Bueno pero ahora volvemos ya a nuestro método 00:41:05
¿Vale? A nuestro método 00:41:07
Pues venga 00:41:09
¿Lo hacéis? 00:41:10
Sí, venga 00:41:17
Lo hacéis 00:41:18
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
25 de mayo de 2024 - 17:47
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
167.22 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid