Saltar navegación

20260126 InterfacesEjemplo_4 - 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 27 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Revisándolo por si venimos un poco despistados del recreo. 00:00:00
Vale. 00:00:06
Primero, borrar envío. 00:00:07
¿Borrar por qué? 00:00:10
Por clave primaria. 00:00:10
Por clave primaria. 00:00:12
¿Vale? 00:00:14
En este caso, la clave primaria es el código. 00:00:15
¿Vale? 00:00:18
En este caso, no tiene por qué devolver nada. 00:00:20
Porque el efecto del borrado se queda, lógicamente, en el propio array. 00:00:23
no tiene por qué devolver nada 00:00:29
pero es una pena 00:00:31
desperdiciar ese valor 00:00:33
de retorno poniéndolo en void 00:00:35
cuando realmente sería 00:00:37
interesante que aquel que llama 00:00:39
deleteEnvío tenga alguna realimentación 00:00:41
entonces los métodos 00:00:44
de alguna manera tienen que dar alguna realimentación 00:00:45
sobre si lo que están haciendo está bien 00:00:48
lo han hecho bien, lo han podido hacer 00:00:50
mal o no 00:00:51
entonces aquí la forma más cómoda 00:00:52
de realimentar sobre si 00:00:55
realmente encontraste el envío 00:00:57
y lo borraste, o si no lo encontraste 00:00:59
y pasó algo raro, la mejor 00:01:01
manera de realimentar es devolviendo 00:01:03
un boolean, ¿vale? 00:01:05
Y es, de hecho, la manera 00:01:08
habitual. O también se 00:01:09
podría devolver un int, donde 00:01:11
el int sea el número de 00:01:13
elementos borrados. 00:01:15
Uno, si has borrado alguno, 00:01:18
cero si ninguno. Por ejemplo, 00:01:19
hay muchas formas estándar, entre comillas, 00:01:21
de que un método avise 00:01:24
si lo que tú le has pedido hacer 00:01:25
lo ha podido completar correctamente o no 00:01:28
hay muchas formas estándar 00:01:30
una siempre es devolver un boolean 00:01:31
true si pude hacer lo que me has pedido 00:01:34
false si no lo he podido hacer 00:01:36
hay veces que no vamos a poder 00:01:39
realimentar al usuario 00:01:43
sobre si lo que el emo 00:01:45
nos ha pedido se ha hecho bien o mal 00:01:46
con el boolean 00:01:49
hay veces que no vamos a poder 00:01:50
porque esto ya tiene un uso 00:01:51
Por ejemplo, el método de recuperar, este, el valor de retorno, ya tiene una función, que es cargarse con el envío cuyo código hemos pasado. 00:01:53
Entonces, aquí, lógicamente, no podemos avisar con un Boolean true o false si el envío se encontró o no. Pero, bueno, podemos avisar de otra manera, porque si el envío no se encontró, entonces es null. 00:02:13
¿Vale? De alguna manera tenemos que realimentar siempre al que nos llamó sobre si lo que hacemos está correctamente hecho o no se pudo hacer por algo. ¿Vale? Habrá veces que tengamos que hacerlo de otra manera, que será con una excepción cuando veamos excepciones. 00:02:25
pero en las situaciones 00:02:44
en las que nos hemos planteado a él 00:02:46
ahora, pues aquí 00:02:48
por ejemplo, entonces cuando uno hace estos 00:02:54
métodos para que el universo 00:02:56
entero les use, porque esto 00:02:57
es un repositorio, un array 00:03:00
con envíos y métodos para 00:03:02
acceder a esos envíos 00:03:04
esto es una clase que está ahí para que 00:03:05
el universo entero la use, independientemente 00:03:08
si es gestión de envíos de 00:03:10
una empresa o de otra 00:03:11
o de otra, ¿vale? 00:03:13
Entonces son métodos como 00:03:16
muy genéricos, tú encuentras 00:03:18
guardas, actualizas 00:03:20
entonces como son para un universo entero 00:03:21
lo ideal es que 00:03:23
los documentemos un poquito 00:03:25
de documentación 00:03:27
JavaDoc todavía no habéis visto en entornos de 00:03:30
desarrollo 00:03:32
bueno, es una cosa muy sencilla 00:03:32
nuestro código, sobre todo si es 00:03:35
un código que ofrecemos, claro 00:03:38
debería estar documentado 00:03:39
entonces esta clase, repito, es una clase 00:03:40
ofrecida al universo 00:03:44
que quiera gestionar envíos 00:03:45
me da igual 00:03:47
lo que quiera hacer, porque es muy genérica 00:03:49
mi cajita de envío para guardar 00:03:52
sacar, tú luego haces con ellos lo que quieras 00:03:54
entonces bueno, lo normal es que 00:03:56
uno documente los métodos 00:03:58
para explicar lo que hacen 00:04:00
entonces los comentarios 00:04:01
ya sabéis que en general los comentarios 00:04:04
son con la doble barra 00:04:06
o también es un comentario 00:04:08
algo que empieza así 00:04:10
y termina así 00:04:11
sea en una línea o en varias 00:04:13
si es un comentario de muchas líneas 00:04:15
pues lo podemos empezar así y acabarlo así 00:04:23
si es un comentario de una sola línea hasta el final pues así 00:04:25
pero este estilo de comentarios 00:04:29
es un estilo de comentarios pensado más para el que está escribiendo 00:04:32
el código para que él mismo se aclare 00:04:36
está pensado más un poquito para eso, es estilo de comentarios 00:04:37
luego hay otro estilo de comentarios que está pensado 00:04:41
para generar una documentación estándar 00:04:44
que son los comentarios 00:04:47
javadoc, que cuando hicimos 00:04:50
lo del jar y todo eso, ya lo dijimos 00:04:52
mirad ahora, me aparece 00:04:54
aquí la ayuda, ¿os acordáis? 00:04:56
bueno, pues entonces, si yo hago 00:04:58
estos comentarios javadoc en el método 00:05:00
pues aquí pondría 00:05:02
código, el código de envío 00:05:03
retun, el envío 00:05:05
y aquí pondríamos 00:05:12
null, si no 00:05:13
se encontró 00:05:17
vale, luego el null es aquí 00:05:18
la forma de avisar de que este método 00:05:24
no pudo operar correctamente 00:05:27
porque el código no estaba 00:05:29
null sería 00:05:30
la forma de avisar 00:05:32
en insert envío 00:05:34
en insert envío aquí estamos 00:05:39
desperdiciando el valor de retorno 00:05:40
pero que puede 00:05:43
fallar aquí 00:05:45
que puede fallar aquí para que este método 00:05:45
pueda no haber insertado el envío correctamente 00:05:48
hay algo que puede 00:05:51
fallar pues es que no se me ocurre 00:05:53
porque si envíos está vacío, vale, lo incrementará 00:05:55
en uno, no hay problema 00:05:57
y meterá aux, no hay nada que pueda 00:05:59
fallar, entonces 00:06:01
pues aquí 00:06:02
es que vamos a devolver 00:06:05
true siempre 00:06:07
aquí no se me ocurre un algo que si no funciona 00:06:08
if else entonces return false 00:06:11
aquí va a ser 00:06:13
un return true siempre, entonces aquí 00:06:15
vale, este sí, este es 00:06:17
el método con el que estábamos, que era el raro 00:06:19
que lo revisamos 00:06:21
y vale 00:06:23
borrar envío. Como es por clave primaria 00:06:25
vamos a eliminar solo uno como mucho 00:06:28
luego el array destino definitivo 00:06:31
tendrá un tamaño menos. Ahora vamos recorriendo 00:06:34
el original. Copiamos todos aquellos 00:06:38
cuyo código sea distinto y avanzamos en el array 00:06:41
destino. Cuando encontremos el código 00:06:44
a eliminar, avisamos 00:06:48
y salimos del bucle cuando hayamos terminado de copiar 00:06:50
el array destino. Cuando ya hemos 00:06:54
terminado de copiar el array destino, salimos del 00:06:56
bucle. 00:06:58
Y ahora ya en este único for 00:07:00
tenemos toda la información que necesitamos. 00:07:02
Tenemos 00:07:05
la información sobre si hemos 00:07:05
encontrado el código o no. 00:07:08
Si lo hemos encontrado, sustituimos 00:07:10
el array antiguo por el nuevo. 00:07:12
Y si no lo 00:07:15
hemos encontrado, puede ser que sea el último. 00:07:16
Pues si es 00:07:20
el último, 00:07:20
entonces 00:07:21
también sustituimos 00:07:23
el viejo por el nuevo 00:07:25
y cambiamos 00:07:32
encontrado a true 00:07:37
y ya está, y si no 00:07:38
pues no tenemos que sustituir nada 00:07:40
envío se queda como estaba, no hay que cambiar nada 00:07:42
envío se queda como estaba 00:07:45
y devolvemos esto 00:07:46
que sirve como valor de retorno para que avise 00:07:48
este método sobre si lo pudo borrar o no 00:07:51
vale 00:07:53
Y ya el último método que nos faltaría del CRUD sería el actualizar, que aquí también tendría sentido devolver un boolean para ver si el envío a actualizar existe o no existe, porque si no existe entonces no lo puedo actualizar y aviso con falso que no he podido actualizarlo. 00:07:57
ubdate 00:08:33
envío, y aquí 00:08:35
sí que le pasamos 00:08:37
un envío enterito 00:08:40
no solo un código como aquí, en delete 00:08:41
aquí le pasamos un envío entero 00:08:43
porque dentro de este objeto estará 00:08:47
el código del envío, eliminar 00:08:49
con sus nuevos datos 00:08:51
la clave primaria no se cambia, claro 00:08:53
la clave primaria de un elemento 00:08:57
no se debe cambiar nunca 00:08:59
entonces yo aquí pasaré 00:09:00
un objeto envío 00:09:03
con la clave 00:09:04
del objeto a modificar 00:09:05
lo busca en el array 00:09:08
y le pondré estos nuevos datos 00:09:10
pero supuestamente ahí el código sería el mismo 00:09:11
claro, el código sería el mismo 00:09:19
lo que cambia es el resto de los datos 00:09:21
entonces este método 00:09:22
sería prácticamente 00:09:24
igual que este 00:09:26
lo que pasa es que 00:09:27
en lugar de no copiar 00:09:29
cuando el código es el mismo 00:09:32
lo que hacemos es copiarlo modificado 00:09:34
entonces este 00:09:36
primera cosa que se queda hoy para que lo hagáis vosotros 00:09:38
lo ponemos aquí, que tiene que hacer este método 00:09:45
localiza en el array 00:09:49
el envío con el código 00:09:54
que tenga el objeto 00:10:03
parámetro, envío, y si 00:10:07
lo encuentra, lo sustituye 00:10:21
por el parámetro pasado 00:10:28
cuyo código no cambiará 00:10:32
lógicamente 00:10:36
si no lo encuentra 00:10:36
devuelve false 00:10:39
vale, pues este método tú tienes 00:10:40
tu array de envíos 00:10:47
con un montón de envíos 00:10:48
ahora le pasamos este parámetro 00:10:50
este parámetro tendrá 00:10:52
su código 00:10:54
este parámetro tiene su código 00:10:55
y el resto de los datos que sean. 00:11:03
Entonces, tendrá que localizar en el array 00:11:07
el objeto cuyo código sea este. 00:11:10
Esta es la clave primaria que sirve para búsquedas, para todo. 00:11:15
Imagínate que es este de aquí. 00:11:19
Pues cuando lo ha encontrado, 00:11:21
sustituye este objeto del array 00:11:23
por este enterito que le acabas de pasar. 00:11:26
Que el código no habrá cambiado, el código será el mismo. 00:11:28
¿vale? porque lo que no podemos 00:11:31
cambiar para que esto no pierda 00:11:33
el sentido, esto es como en las bases de datos 00:11:35
igual, tú no te pones a cambiar las claves 00:11:37
primarias de las cosas 00:11:39
eso nunca, eso lo has insertado 00:11:40
con una clave primaria, eso ya lo identifica 00:11:43
y ya puedes cambiar sus datos 00:11:45
sus valores, el resto de campos, pero la clave primaria 00:11:47
no, pues aquí igual 00:11:49
localizas aquel registro 00:11:51
aquel envío 00:11:53
cuyo código 00:11:55
es este de aquí, cuando lo has 00:11:57
encontrado, pum, este sustituye 00:11:59
a este, y el código 00:12:01
sigue siendo el mismo 00:12:02
pues este haría el típico UDATE de un CRUD 00:12:04
normal y corriente 00:12:09
¿y este famoso CRUD no te lo hace el show? 00:12:10
¿perdón? 00:12:14
¿te lo hace el show? 00:12:14
¿si te lo hace qué? 00:12:16
no, no, no 00:12:18
no, hombre, no, porque es que 00:12:20
¿o si te lo hace un número CRUD? 00:12:23
no, no, no, lo que retú un false 00:12:26
vale 00:12:29
no, lo que no te quiero decir 00:12:30
porque es demasiado lío, es que 00:12:32
todo esto está sujeto a estándares 00:12:33
a frameworks, a cosas, entonces todo esto 00:12:36
lo que pasa es que ya, todo esto es del año 00:12:38
que viene, hay frameworks 00:12:40
que te generan 00:12:42
los CRUDs de unos modelos 00:12:44
de un modelo de datos específico, pues como Spring, por ejemplo 00:12:46
pero esas cosas 00:12:48
son complicadas, porque 00:12:50
tienes que conectarlo con la base de datos, gestionar 00:12:51
las transacciones, o sea, no es 00:12:54
no es tan fácil como que un entorno 00:12:56
de desarrollo te lo gestione y ya 00:12:59
Si Dios no lo remedia 00:13:01
Sí 00:13:06
Esperemos que no lo remedie 00:13:07
Pues de algunos sí y otros no 00:13:14
Con suerte 00:13:20
Para mí, para vosotros no sé 00:13:21
Con suerte para mí, de mí no cambiáis 00:13:23
Vale, pues 00:13:25
¿El qué? 00:13:32
Sí, no, ahora vamos a hacer el ejercicio 00:13:39
O sea, es que no lo hemos ni empezado. 00:13:40
Porque estábamos con, vamos a ver, 00:13:43
¿dónde guardamos los datos? 00:13:45
Hemos decidido que lo vamos a guardar en esta variable. 00:13:47
Vale, ¿dónde guardamos los datos? 00:13:53
Pues aquí los guardamos. 00:13:54
Vale, y decía yo que esto es un patrón típico, 00:13:57
un patrón típico, aquí está guardado en su clase. 00:13:59
Variable estática, porque solamente hay un array 00:14:02
al que llamaremos con reproducción de envíos, punto envíos. 00:14:05
Y ahora hemos incorporado con cualquier contenedor de datos, tenemos las opciones básicas de consultar, eliminar, borrar y actualizar. Pues cualquier contenedor de datos como este, que este sería un contenedor de datos, tiene sentido que me ofrezca esas funciones básicas. Y luego ya que se apoyen en ellas, mi aplicación concreta que ya haga lo que sea. 00:14:07
Pues hemos hecho esas cuatro funciones básicas 00:14:29
La última 00:14:32
Pendiente de hacer 00:14:34
Se han complicado 00:14:35
De hacer porque no estamos con colecciones 00:14:38
Sino con Arrays, con colecciones sería mucho más sencillo 00:14:40
Claro 00:14:42
Bueno, pues ahora ya que tenemos nuestro contenedor de datos 00:14:43
Ahora ya vamos a hacer 00:14:46
La aplicación en sí 00:14:48
La funcionalidad, vamos a meterla en un paquete 00:14:49
Que se llame lógica, por ejemplo 00:14:52
Lógica o funciones 00:14:54
Venga, funciones, me gusta más 00:14:58
Las funcionalidades 00:15:00
De la aplicación 00:15:02
Vale, pues la aplicación tiene que hacer todo esto 00:15:03
Registrar, listar, coste total, bla bla bla 00:15:06
Pues venga, vamos a hacernos 00:15:08
Nuestra clase 00:15:11
Que se llama central envíos 00:15:11
O algo así era 00:15:16
El main dice que se llama central 00:15:17
O sea, el enunciado dice que se llama central envíos 00:15:20
A ver, que podemos 00:15:23
Llamarle como queramos 00:15:26
no, central envíos 00:15:27
sí, sí, central envíos es la que tiene 00:15:31
estos métodos de aquí, luego estará el main 00:15:33
claro 00:15:35
no, no, no 00:15:36
central envíos tiene las 00:15:41
funcionalidades, repositorio 00:15:43
tiene los datos y lo que se pueden 00:15:45
hacer con los datos, que es 00:15:47
los saco, los meto, los elimino 00:15:49
o los cambio 00:15:51
son los datos, repositorio son 00:15:52
datos, mi caja de datos con lo que puedo 00:15:55
a hacer con los datos. Ahí está. 00:15:57
Ahora, central envíos es lo que 00:15:59
mi aplicación concreta, esta y así 00:16:01
de mi aplicación, seguro, quiere 00:16:03
hacer con esa caja de datos. 00:16:05
Lo que va a hacer. 00:16:07
Y luego ya tendré el main, 00:16:09
que es la capita que llama a los 00:16:11
métodos de central envíos. 00:16:13
No te convence. 00:16:17
¿Cómo no te va a convencer? ¿Es una separación? 00:16:21
Perfecta. O sea, está 00:16:24
emulando, porque nos ha dado un montón de 00:16:24
información, está emulando un poco 00:16:26
a lo lejos una arquitectura estándar 00:16:28
de una aplicación, la está emulando 00:16:31
todavía muy de lejos, pero al menos 00:16:32
ya empieza a respetar 00:16:34
una pauta básica 00:16:37
que es, vamos a separar datos 00:16:38
de como lo que 00:16:40
hacemos con ellos, datos en 00:16:42
repositorio, la caja con 00:16:44
hombre la opción de hacer cosas con 00:16:46
la caja, las cuatro cosas básicas 00:16:48
punto pelota, caja con su crudo 00:16:50
eso va en datos 00:16:52
en cualquier aplicación 00:16:54
eso va aparte, la caja con su CRUD 00:16:56
y cuando digo CRUD digo las cuatro cosas 00:16:58
y ahora ya, mi aplicación 00:17:00
ya estoy en una aplicación concreta, mi aplicación 00:17:02
registra envíos 00:17:04
localiza el envío de no sé qué 00:17:06
asegura no sé cuántos 00:17:08
esa ya es una aplicación concreta, central envíos 00:17:10
con sus funcionalidades 00:17:12
las hago, que tendrán que llamar 00:17:14
a la parte de datos 00:17:16
y luego yo ya me puedo 00:17:18
hacer un mail 00:17:20
que en el mail ya viene 00:17:21
ya me bajo al 00:17:23
detalle de si voy por consola 00:17:26
voy por interfaz gráfica 00:17:28
esos son los detalles 00:17:30
de la vista del usuario 00:17:31
pero ahora nos vamos con central envíos 00:17:34
que 00:17:36
central envíos 00:17:38
vale, central envíos 00:17:46
que tiene que hacer 00:17:52
mi aplicación 00:17:54
pues 00:17:56
el que la analizó 00:17:58
y se entrevistó con el cliente y lo pensó todo 00:17:59
llegó a la conclusión 00:18:02
de que el tío que iba a estar ahí 00:18:03
haciendo cosas con los envíos 00:18:05
solamente iba a necesitar hacer estas 5 cosas 00:18:07
podríamos incorporar más 00:18:10
o pues el que lo analizó 00:18:11
solamente iba a necesitar hacer estas 5 cosas 00:18:13
pues ya está, vamos a hacer 00:18:16
esas 5 funcionalidades 00:18:17
esos 5 métodos 00:18:19
el lenguaje técnico serían esos 5 servicios 00:18:21
vamos a hacer esos 5 servicios 00:18:24
pues venga 00:18:26
¿qué os pasa? 00:18:28
yo no entendía 00:18:31
Bueno, a ver, no pasa nada 00:18:32
Si la lógica es la misma 00:18:39
Lo estamos empezando a separar un poquito 00:18:39
Para acostumbrarnos un poco 00:18:43
A la arquitectura más 00:18:44
Venga, pues a ver 00:18:46
Central envíos 00:18:48
Boolean 00:18:49
Registrar 00:18:59
Envío 00:19:02
Vale, registrar envío 00:19:03
Registrar envío 00:19:06
¿Vale? 00:19:08
Necesita los datos del envío 00:19:14
El tío aquí 00:19:15
Registrar envío 00:19:16
Vamos, por ejemplo 00:19:18
Así 00:19:22
Podemos registrar cualquier tipo de envío 00:19:27
Ahí 00:19:35
Vale, pues ahora ya 00:19:39
Registrar envío 00:19:45
Ahora ya vemos qué le toca hacer 00:19:47
Tendrá que apoyarse 00:19:48
En los métodos 00:19:50
De mi capita de datos, de mi clase de datos 00:19:52
tendrá que apoyarse, a lo mejor es que es directamente 00:19:54
llamarlo, vale 00:19:56
vale, pues registrar envío, pues entonces 00:19:58
registrar envío, escoger este envío 00:20:01
y meterlo en mi array 00:20:03
pues entonces va a ser tan fácil como 00:20:04
repositorio 00:20:07
repositorio envío 00:20:09
se llama, sí 00:20:13
repositorio envíos 00:20:14
punto 00:20:17
insert envío 00:20:18
envío 00:20:20
Y esto directamente 00:20:21
Le doy un return 00:20:24
Porque este ya me devuelve un boolean 00:20:25
¿Verdad? 00:20:31
Ah, que insert envío 00:20:38
Vale, no 00:20:39
No me devolvía boolean, pues voy directamente 00:20:41
Con lo cual 00:20:44
Aquí no hay return, vale 00:20:48
Ya está 00:20:50
Registrar envío se apoya 00:20:51
En una de las acciones básicas del CRUD 00:20:54
Que es insertar 00:20:56
Vale, podría necesitar 00:20:58
Y aquí ya 00:21:03
por ejemplo, puedo hacer yo cosas 00:21:04
como esta 00:21:06
bueno no, porque esto mejor en el main 00:21:06
porque aquí no quiero comprometerme 00:21:09
todavía a trabajar con consola 00:21:12
este como veis 00:21:13
este no tiene un nombre estándar 00:21:26
yo en este he puesto a propósito 00:21:29
insert, porque son como 00:21:31
los cuatro métodos estándar 00:21:33
insert, delete, update y find 00:21:35
las cuatro 00:21:37
funciones básicas del CRUD 00:21:39
he puesto el nombre estándar 00:21:41
esto ya 00:21:42
es una cosa de mi aplicación 00:21:44
pues yo aquí le doy el nombrecito 00:21:46
ya, registrar envío 00:21:49
si mi aplicación está en castellano 00:21:51
pues en castellano, ya le doy un nombre 00:21:53
no estándar 00:21:55
porque ya es propio de mi aplicación 00:21:56
ya está, pues esta funcionalidad ya está 00:21:58
¿qué más funcionalidades 00:22:01
tiene mi aplicación? 00:22:03
listar los envíos 00:22:06
vale, aquí yo puedo 00:22:07
recorrer el for directamente y ya está 00:22:29
pero 00:22:31
vamos a hacerlo más realista 00:22:33
normalmente 00:22:34
en las clasecitas 00:22:37
estas, en las cajitas que 00:22:40
tienen los cuatro métodos estándar 00:22:42
se suele incorporar también uno 00:22:44
que es el find all 00:22:46
que es, recupéramelos todos 00:22:48
el que, todos los 00:22:50
envíos, claro, entonces 00:22:52
esta cajita tiene mis cuatro 00:22:54
métodos estándar, recupera por código 00:22:56
inserta elemento 00:22:59
borra y 00:23:00
actualiza, que es el CRUD 00:23:02
pero suelen incorporar también 00:23:04
que si lo incorporara este 00:23:07
me vendría estupendo porque lo llamo desde el otro 00:23:08
suelen incorporar un 00:23:10
find all 00:23:12
¿vale? 00:23:14
que sería algo así 00:23:18
y así se quedaría 00:23:20
este me devuelve todos los envíos 00:23:31
me los devuelve todos 00:23:38
y ahora yo me apoyo en este para recorrerlo 00:23:39
son detalles 00:23:47
de diseño, en realidad 00:23:48
se puede hacer de mil maneras 00:23:50
Pero es por irnos aproximando un poco más 00:23:51
A lo que vais a ver 00:23:54
Más que nada para que os entendáis 00:23:55
Con vuestro segundo profe 00:23:57
Bueno, primero, que es ChagPT 00:23:59
Entonces, si le vais entendiendo 00:24:00
Pues mejor 00:24:03
Entonces tendremos que adaptarnos a lo estándar 00:24:05
Porque él habla en términos estándar normalmente 00:24:07
Vale, pues nos vamos a 00:24:09
A central envíos 00:24:13
Y ahora 00:24:17
Vamos a listar todos los envíos 00:24:18
Pues venga, para cada envío 00:24:21
Donde 00:24:26
Repositorio 00:24:28
Envíos 00:24:31
Punto find 00:24:32
¿No le he puesto static al find all? 00:24:34
No, por eso no me lo ofrecía 00:24:41
Static 00:24:43
¿Vale? Pues que tenemos que hacer con cada uno de ellos 00:24:46
Vale 00:24:55
Pero cuidado 00:25:01
Ya sabemos que 00:25:06
cada uno de los envíos de la RAI 00:25:07
es de su padre y de su madre. 00:25:09
Aquí, ¿qué se va a ejecutar? 00:25:13
El toStream. 00:25:15
¿Verdad? El toStream. 00:25:17
Entonces, voy a hacer un toStream. 00:25:18
Voy a asegurarme de que he hecho yo un toStream 00:25:20
específico 00:25:23
para cada clase envío. 00:25:25
Porque si no, va a llamar al toStream 00:25:27
de la superclase. 00:25:29
Y me va a mostrar solo 00:25:32
las propiedades que están en la superclase 00:25:34
en envío. Entonces, vamos a revisar 00:25:36
en nuestra arquitectura si hemos hecho los 00:25:38
toString correctamente. 00:25:40
Yo creo que eso lo hicimos 00:25:43
en envío. 00:25:45
Envío tiene un toString. 00:25:46
Vale. Pero claro, yo quiero 00:25:48
el específico de los demás. 00:25:50
Entonces, 00:25:53
vamos a hacernos 00:25:55
envío 00:25:56
estándar y urgente. 00:25:58
Vamos a hacernos un toString para cada uno 00:26:00
de ellos. Entonces, 00:26:02
Empezamos con envío estándar 00:26:04
Generamos un toString 00:26:08
Con 00:26:12
Los heredados 00:26:15
Que son estado, código, peso 00:26:19
Origen, destino 00:26:21
Y el nuevo, que es días estemados 00:26:23
Un toString con todos esos 00:26:26
Ya tenemos un toString 00:26:27
Para envío estándar 00:26:31
Envío urgente 00:26:33
Que tampoco tenía 00:26:38
Nos hacemos un toString 00:26:40
Con el suyo que recargo 00:26:44
Despliego los heredados 00:26:46
Y con todos los heredados 00:26:47
Y el envío refrigerado 00:26:50
Que tampoco tenía, pues lo mismo 00:26:58
¡Hala! Pues este método ya 00:27:00
Me va a mostrar 00:27:13
Cada envío particular 00:27:15
¿Vale? Porque a la hora de 00:27:17
Así funciona el polimorfismo 00:27:20
A la hora de llamar a toString de aquí 00:27:21
Va a llamar al toString 00:27:24
De como se instanciara el objeto 00:27:25
todos están declarados como envío 00:27:27
todos, pero cada uno está instanciado 00:27:29
a su manera, o refrigerado 00:27:31
o urgente o estándar, pues al tu stream 00:27:33
que se vaya a llamar es como esté instanciado 00:27:35
vale, pues ya está 00:27:37
listar envíos 00:27:39
¿qué otra funcionalidad concreta tiene esta aplicación 00:27:40
mía? 00:27:43
coste total de todos los envíos 00:27:45
el coste era una propiedad 00:27:47
que estaba 00:27:53
¿En dónde está el coste? 00:27:56
Si no hay ninguna variable que sea 00:28:03
Envío, código, peso 00:28:05
Ah, vale, que tenía algún método aquí 00:28:10
Que era calcular coste 00:28:12
Vale, vale 00:28:13
Vale, calcular coste 00:28:14
Pues public 00:28:17
Y calcular coste me devuelve un 00:28:19
Double 00:28:24
Vale, pues entonces el coste es double 00:28:24
coste total 00:28:27
no, no, no, esto es una funcionalidad 00:28:31
específica de mi aplicación 00:28:40
no es una funcionalidad estándar 00:28:42
de acceder a datos, lo estándar de acceder a datos 00:28:44
es el club 00:28:46
cojo, saco, meto o cambio 00:28:47
ya está 00:28:50
esto es una funcionalidad específica que han pedido en esta aplicación 00:28:52
entonces va en la clase específica 00:28:54
de esta aplicación 00:28:57
vale, pues aquí habrá que hacer una suma como siempre 00:28:57
Y ahora ya recorremos 00:29:00
Nuestros envíos 00:29:06
Por ejemplo así 00:29:13
Envío en 00:29:18
Find all 00:29:21
Vale 00:29:31
Pues que hago 00:29:32
Con cada uno de ellos 00:29:35
Suma más igual 00:29:36
E punto 00:29:39
Calcular coste 00:29:40
Y ahora ya 00:29:42
todos tienen su método calcular coste 00:29:46
todos, cada uno su versión 00:29:53
pero todos lo implementan 00:29:55
porque calcular coste estaba aquí 00:29:58
en la superclase envío 00:30:00
calcular coste está en la superclase 00:30:02
arriba del todo, está aquí 00:30:05
con lo cual el compilador 00:30:06
me deja llamarlo sin problema 00:30:10
pero luego ya cada uno tiene su propia versión 00:30:11
hay que asegurarse de que todos la tienen sobrescrita 00:30:15
envío estándar la tiene sobrescrita 00:30:17
sí, envío urgente 00:30:19
la tiene sobrescrita, sí 00:30:21
y envío refrigerado la tiene sobrescrita 00:30:22
también 00:30:25
luego cada uno 00:30:28
llamará aquí a su versión 00:30:31
ahora, siguiente funcionalidad 00:30:32
específica de mi aplicación 00:30:37
el coste total del 00:30:38
seguro 00:30:41
vale 00:30:42
aquí uno podría decir 00:30:59
vale, pues es una suma igual 00:31:01
Pues entonces hago esto y ahora para cada envío, en todos los envíos, y ahora es cuando yo no puedo hacer directamente suma más igual e.calcular coste del seguro. 00:31:02
No puedo porque calcular coste del seguro no es un método de envío. En envío no está ese método, calcular coste del seguro, solo está este. ¿Por qué? Porque calcular coste del seguro está solamente en los asegurables, solo en los asegurables. 00:31:51
Entonces 00:32:09
¿Cuáles son los asegurables? 00:32:10
Los asegurables son 00:32:19
El estándar y el 00:32:21
Mastreable 00:32:22
Ah no, perdón 00:32:26
El urgente 00:32:31
El urgente y el otro 00:32:34
Y el 00:32:37
Eso 00:32:38
Entonces, aquí podríamos poner 00:32:39
Aquí tendríamos que poner 00:32:43
If e 00:32:46
Instance 00:32:50
Envío urgente 00:32:53
Pues entonces ahora ya sí 00:32:58
Suma más igual 00:33:01
Puedo hacer el casting 00:33:02
Sin miedo 00:33:05
Envío urgente de 00:33:06
Es que no va a estar instanciado como 00:33:09
Asegurable 00:33:21
Pero 00:33:22
No, pero 00:33:27
Sí, ahí hay algo, un momentito 00:33:29
Sí 00:33:31
Entonces, ¿qué método tiene EnviUrgente? 00:33:32
Ahora ya EnviUrgente sí que tiene 00:33:36
Ay, ¿por qué no me lo ofrece aquí? 00:33:37
Instance of 00:33:41
Bueno, lo tendría que poner a mano 00:33:42
Claro, findAll 00:33:47
Me devuelve el array 00:33:54
Vale, no lo he puesto 00:33:54
Eso lo iba a decir ahora 00:33:57
Porque si yo recupero directamente 00:33:58
Todo a través de los métodos 00:34:02
Esto ya no tiene por qué ser public 00:34:03
¿Vale? 00:34:06
Y que no sea public tiene sus ventajas 00:34:09
¿Vale? 00:34:12
O la puedo poner private 00:34:16
O no public 00:34:17
En cualquier caso 00:34:20
Como solamente está en este paquete 00:34:20
Da igual 00:34:23
¿Vale? 00:34:25
Claro 00:34:27
Entonces 00:34:27
¿Cómo se llama el método? 00:34:32
Ah, aquí, calcular coste seguro 00:34:46
Que no lo encontraba 00:34:49
Calcular coste 00:34:50
Seguro 00:34:55
Vale 00:34:58
Ahí 00:34:59
He importado lo que 00:35:01
Como estoy en otro paquete 00:35:10
Y aquí podríamos hacer lo mismo 00:35:12
Si es una instancia 00:35:16
De envío 00:35:20
Refrigerado 00:35:23
Pues exactamente lo mismo 00:35:26
Claro, pero es que aquí no hace falta 00:35:28
Porque no vamos a acceder directamente a la variable 00:35:42
Nunca 00:35:44
Y aquí 00:35:45
la llave 00:35:50
vale 00:35:51
y ahora 00:35:52
return suma 00:35:59
una pregunta 00:36:02
si hay 40 clases 00:36:07
que tienen el implement 00:36:10
si no hay una manera 00:36:11
más rápida 00:36:12
porque tendría que meter 00:36:14
una 00:36:15
lo que ha dicho ella 00:36:16
te refieres 00:36:19
poner aquí asegurable 00:36:22
vale 00:36:24
pero no estoy 00:36:25
completamente convencida 00:36:29
de que eso 00:36:30
Lo que ha dicho ella 00:36:32
Lo que pasa es que esto tiene un matiz 00:36:39
Pero bueno, la aplicación que estamos haciendo 00:36:41
Ahora nos va a dar problemas 00:36:44
Sí, pero cualquiera de los dos 00:36:45
Claro, el problema es el casting 00:36:49
Entonces, si es una interfaz de asegurable 00:36:51
Entonces el problema que tienes es que 00:36:55
Entonces, porque calcular coste seguro, ¿vale? 00:36:57
En este ejemplo, ups, en este ejemplo vamos a dejarlo así, ¿vale? 00:37:17
Porque aquí hay una cosa, que hay un matiz extraño, que hasta que no saque en detalle un ejemplo para él, prefiere no sacarlo, ¿vale? 00:37:22
Entonces, por ahora vamos a dejarlo así, que es lo que hemos visto, lo que tenemos todos claro, ¿vale? 00:37:32
vale, pues si es de cualquiera 00:37:38
de las dos instancias 00:37:41
le puedo hacer un casting para 00:37:42
llamar ya al método 00:37:45
lo sumo y se acabó, y devuelvo la suma 00:37:46
calcular coste total y seguros 00:37:49
y ahora ya 00:37:51
¿qué método nos falta? 00:37:55
actualizar 00:37:58
estado de envío, este ya es de uno 00:37:59
en particular, con lo cual hay que pasarle parámetro 00:38:02
ese tendría sentido 00:38:03
que devolviera un boolean para ver si lo pudo actualizar 00:38:10
correctamente o no 00:38:12
Actualizar estado 00:38:13
¿De qué envío? 00:38:17
Del envío 00:38:21
Este 00:38:22
Segunda cosa 00:38:27
Junto con el 00:38:29
Otro que hemos dicho 00:38:30
Que completáis vosotros 00:38:33
Actualizar estado 00:38:36
Apoyándose en los métodos 00:38:39
De la otra clase 00:38:42
Debería, porque no puede acceder 00:38:42
tal y como lo hemos modificado ahora 00:38:46
no puede acceder directamente 00:38:48
a esta variable, que es la idea 00:38:50
sería la idea 00:38:52
con lo cual se tiene que apoyar de los métodos de aquí 00:38:52
pues apoyándose en los métodos 00:38:56
de esa clase, vamos a actualizar 00:38:58
el estado de este envío 00:39:00
pasándole el nuevo estado, claro 00:39:02
estado envío 00:39:03
nuevo estado 00:39:07
vale, entonces 00:39:10
nos faltaría 00:39:24
hacéis vosotros 00:39:26
en el repositorio este 00:39:28
el de actualizar 00:39:31
este de aquí 00:39:36
en el central envíos 00:39:38
este método 00:39:42
y luego habría que hacer el main 00:39:43
ahora voy a subir antes de irme 00:39:53
el proyecto tal y como está 00:39:55
la aula virtual 00:39:56
entonces aquí ya empezáis a ver 00:39:57
y todavía no son muchas 00:40:00
ya empezáis a ver que cualquier aplicación 00:40:01
son muchas clases que intentan separar funciones 00:40:03
y tendréis la sensación de que en realidad 00:40:06
estamos metiendo 00:40:08
un montón de cosas a intermedias 00:40:10
cuando lo podría hacer toda una única clase 00:40:12
claro, yo podría hacer un main 00:40:14
con mi array de envíos 00:40:16
y en ese main ya hacer los métodos 00:40:18
de actualizar, de no sé qué 00:40:20
y la aplicación tiraría igual 00:40:22
hombre, lo que sí que tendría que estar fuera 00:40:24
lógicamente es el modelo, eso sí 00:40:26
envío, envío refrigerado 00:40:28
pero una vez que el modelo está fuera, podría hacer un main 00:40:29
y ahí todo 00:40:32
ahí mi array de envíos como variable local 00:40:33
métodos auxiliares de los que llama 00:40:36
main para hacer las cosas, vale, y la aplicación 00:40:38
tiraría y ya está, pero 00:40:40
no trabajamos así 00:40:42
vale, trabajamos, aunque aparentemente 00:40:43
parezca que es añadirle complejidad 00:40:46
porque estamos metiendo un montón de clases 00:40:48
que al final vienen a hacer lo mismo 00:40:50
llamándose unas a otras 00:40:52
le estamos dando un diseño 00:40:53
que luego va a ser muchísimo 00:40:55
más fácil de entender y va a ser muchísimo 00:40:58
más fácil de cambiar, entonces 00:41:00
¿qué diseño le hemos dado ahora? 00:41:02
pues hemos metido, aparte del modelo 00:41:04
una clase 00:41:06
independiente de la aplicación 00:41:08
completamente independiente 00:41:10
que tiene los datos con las funciones 00:41:11
básicas para hacer con los datos 00:41:14
y los datos están aquí escondidos 00:41:15
aquí escondidos 00:41:18
no tienen ni el public 00:41:20
están ahí escondidos, que es lo natural 00:41:21
porque esto en origen 00:41:24
sería una base de datos, aquí no la tenemos 00:41:26
entonces estamos simulando 00:41:28
como si la base de datos estuviera aquí 00:41:30
lo estamos simulando 00:41:32
y mi aplicación no hace directamente la base de datos 00:41:33
accederá a través de los métodos 00:41:36
Pues es lo que estamos simulando. Mis datos están aquí escondidos y yo los ofrezco al exterior con las funciones básicas, con las del CRUD, estas que hemos dicho, y además un find all, devuélvemelos todos de golpe, que también es típico, devuélvemelos todos. Sería como un get, ¿vale? 00:41:37
ahora ya, una vez que tenemos 00:41:59
esa primera capa, con las 00:42:02
acciones a hacer básicas, con los datos 00:42:04
las básicas, ya ponemos 00:42:06
la capa que es 00:42:08
funciones de mi aplicación 00:42:09
que sería 00:42:11
central de envíos 00:42:14
que van a tirar de la otra 00:42:15
que directamente la llaman sin más 00:42:17
en muchos casos 00:42:20
sí, pero al menos están separadas 00:42:22
conceptualmente separadas 00:42:24
y luego ya está el main 00:42:25
Y el main ya pues hará una consola 00:42:27
Una interfaz gráfica, lo que sea 00:42:30
Y llamará a central envíos 00:42:31
¿Vale? 00:42:33
Entonces, bueno, esto se parece más 00:42:35
A una arquitectura real 00:42:37
De una aplicación 00:42:40
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
27 de enero de 2026 - 12:44
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 42″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
173.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid