Saltar navegación

20260123 InterfacesEjemplo_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 enero de 2026 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, entonces ahí rápidamente diríamos, hombre, hay tres envíos, todos compartirán cosas. Como dirección, origen, dirección, destino, habrá cosas que tienen todas. Entonces, hay una herencia, tiene que haber sí o sí. No solo una implementación de interfaces, porque también comparten contenido. No solo comparten comportamientos, ser enviados, ser tirados a la basura, también comparten descripción. Entonces, una herencia tiene que haber. 00:00:02
y de hecho, vale, nos dice 00:00:28
todos son envío, muy bien 00:00:31
vale, luego además 00:00:33
habrá envíos 00:00:35
con algunos envíos se tendrá que hacer algunas cosas 00:00:36
y con otros no, por ejemplo 00:00:38
hay envíos que se pueden 00:00:41
asegurar 00:00:42
envíos que se pueden 00:00:43
rastrear y ya está 00:00:46
entonces, no todos 00:00:48
los envíos se tienen que asegurar 00:00:50
solamente se 00:00:52
aseguran los urgentes y los refrigerados 00:00:55
con lo cual esto hay que sacarlo como una interfaz 00:00:57
no podemos meter 00:00:59
calcular coste seguro en la superclase 00:01:01
y rastrear 00:01:03
no todos los envíos 00:01:06
se pueden rastrear, el refrigerado no se puede rastrear 00:01:07
luego obtener estado 00:01:10
y actualizar estado no lo puedo meter 00:01:12
en la superclase envío 00:01:13
porque el refrigerado no lo tiene 00:01:14
entonces me tengo que hacer otra distinta 00:01:17
entonces aquí tenemos 00:01:19
superclase, tres subclases y dos interfaces 00:01:21
y luego ya 00:01:23
una main que lo gestiona 00:01:25
donde ya podemos ver 00:01:27
la flexibilidad 00:01:29
de que haya esas diferentes 00:01:31
jerarquías 00:01:33
pues venga, primero uno haría 00:01:36
la super clase, el envío 00:01:38
una clase normal y corriente 00:01:39
el envío que tiene 00:01:44
el envío tiene 00:01:48
todos los envíos, todos 00:01:49
se caracterizan por 00:01:53
código, peso 00:01:56
origen y destino, todos 00:01:57
tienen eso 00:01:59
pues venga 00:02:00
y luego además todos los envíos 00:02:02
tienen que poder calcular 00:02:05
un coste 00:02:07
pues ahora vamos a hacer esto, con esas restricciones 00:02:08
estas restricciones 00:02:11
aquí nos las han dado escritas 00:02:13
pero claro, estas 00:02:15
vendrían en una situación normal 00:02:16
de haber hecho un análisis previo 00:02:19
con un tío que ha venido y me ha dicho 00:02:21
quiero una aplicación para gestionar los envíos de mi empresa 00:02:22
y así se ha quedado 00:02:24
entonces tienes que empezar, vale 00:02:26
pero, ¿qué envíos tiene? 00:02:27
de qué tipo, qué necesitas saber 00:02:30
de ellos, qué no sé qué 00:02:32
y tú ahí tomando notas, qué no sé cuántos 00:02:34
y después de todo eso 00:02:36
de haber entendido bien lo que necesita 00:02:38
de haberle hecho preguntas 00:02:40
de haberle hecho algún prototipo de aplicación 00:02:42
que todavía no hace nada pero le 00:02:44
muestra las posibilidades 00:02:46
pues después de todo eso 00:02:48
ya uno 00:02:49
deduce que es esto lo que necesita 00:02:51
ahora ahí viene la parte fácil 00:02:54
que es la nuestra, este curso 00:02:56
ahora ya lo escribo 00:02:58
Pero después de haber hecho todo ese proceso anterior, en el cual, en entornos de desarrollo, ¿habéis visto UML y cositas de esas ya? 00:03:00
Vale, pues están relacionadas con eso. 00:03:12
Vale, pues entonces estábamos con que el envío era código, peso, origen y destino. 00:03:19
Pues el envío es 00:03:26
Código 00:03:29
El peso lo voy a poner en entero 00:03:34
Para ahorrarme líneas 00:03:40
Para ahorrarme tiempo de escritura 00:03:41
Y origen y destino 00:03:43
Ahora, normalmente siempre 00:03:45
Hacemos constructor 00:03:56
Con sin parámetros 00:03:57
Porque nos va a facilitar mucho la vida en la aplicación principal 00:03:59
Tener las dos opciones 00:04:01
Y para las subclases también 00:04:03
Generar constructor 00:04:05
Con parámetros 00:04:07
Generar constructor sin parámetros 00:04:09
Total, como no tenemos que hacer nada 00:04:13
Lo hace el todo 00:04:14
Generar getter y setter 00:04:15
¿Eh? 00:04:19
One moment 00:04:26
Pero si hay botón derecho pa pa pa 00:04:27
Pues ¿qué estabas haciendo? 00:04:29
Porque te he oído hablar con un compañero 00:04:34
Sobre GitHub 00:04:35
Con lo cual estabas hablando de otras cosas 00:04:36
Sí, porque cuando te falla 00:04:39
un sentido, acentúas el otro 00:04:45
entonces si no ves, pues desarrollas el oído 00:04:47
ya está, ya puedo seguir 00:04:49
tengo tu permiso 00:04:53
vale, entonces este decía 00:04:54
el toString 00:04:57
venga, vamos a hacer un toString 00:05:00
con todas las propiedades 00:05:04
toString 00:05:08
vale 00:05:09
bueno, por ahora la dejamos así 00:05:13
luego la aplicación principal la voy a 00:05:15
tunear, hoy no nos va a dar tiempo, no 00:05:18
sufráis, la voy a tunear 00:05:20
para que nos pida 00:05:22
meter aquí un equals, que eso del equals 00:05:24
os suena, ya lo hemos mencionado, pero ahora mismo 00:05:26
como yo no he hecho la aplicación principal, todavía no 00:05:28
soy consciente de que tenga necesidad de hacer 00:05:30
aquí un equals, hago lo estándar 00:05:32
getSetToString 00:05:34
y constructores 00:05:36
y ya está, bueno 00:05:38
pues entonces, además aquí 00:05:39
tengo un método que es 00:05:42
calcular coste del envío 00:05:44
y calcular coste 00:05:45
del envío, que eso lo pueden hacer 00:05:48
todos, pues yo me hago 00:05:50
aquí un calcular coste 00:05:52
coste del envío, yo que sé 00:05:58
dependerá, el envío refrigerado 00:06:00
tendrá un coste, es que de hecho 00:06:02
no tengo ni la información 00:06:04
yo que sé como se calcula el coste 00:06:05
del envío, no sé que me ha hecho este 00:06:08
si era void o que me ha pedido 00:06:10
que fuera, método abstracto calcular coste 00:06:12
vamos a ponerlo que devuelva el coste 00:06:13
en lugar de mostrarlo con el system out 00:06:15
calcular coste 00:06:17
pues yo que sé 00:06:20
ni idea de cómo calcularlo 00:06:23
pues ahí se queda 00:06:26
ahí se queda vacío 00:06:26
como un método abstracto 00:06:29
porque no tengo ni idea de cómo se calcula 00:06:32
el coste, con lo cual 00:06:34
si no tengo ni idea de cómo se calcula el coste 00:06:36
y lo dejo vacío 00:06:38
automáticamente la clase ya 00:06:39
se convirtió en abstracta 00:06:42
no le queda más remedio 00:06:45
¿Pasa algo por haberla convertido en abstracta? 00:06:48
No pasa nada 00:06:52
Salvo que mi aplicación no puede tener 00:06:53
No puede trabajar con envíos genéricos 00:06:56
¿Pasa algo? 00:06:59
Me dice el cliente 00:07:00
No, si yo solamente tengo refrigerados o estándar 00:07:01
O urgentes 00:07:04
Pues entonces, fenomenal 00:07:04
Ala, los otros 00:07:08
Envío urgente 00:07:10
El envío urgente es un envío 00:07:12
Normal y corriente 00:07:24
Entre otras cosas es un envío 00:07:26
Pues ala, envío urgente 00:07:28
hereda de envío, entonces tiene todo lo que 00:07:30
tiene urgente 00:07:32
menos los constructores porque no los 00:07:33
hereda y añade 00:07:36
alguna otra cosa nueva, pues sí 00:07:38
el envío urgente 00:07:40
los constructores no se heredan 00:07:41
el envío 00:07:46
urgente tiene un recargo 00:07:48
vale 00:07:50
pues el envío urgente tiene un recargo 00:07:52
por urgencia 00:07:54
pues habrá que poner el recargo 00:07:56
Que es lo que le caracteriza a él 00:07:58
Recargo 00:08:00
Entonces al añadir una propiedad 00:08:03
Tengo que añadir el get y el set de esa propiedad 00:08:05
Sí, sería recomendable 00:08:07
Porque si no lo cambiamos 00:08:21
Desde aquí solamente podemos hacer las propiedades de arriba 00:08:22
Con el get y el set 00:08:26
Y es incómodo 00:08:27
Entonces como es incómodo 00:08:28
Vale, muy bien visto. 00:08:31
Para ser viernes está bien. 00:08:38
Vale, entonces, envíe urgente, añade un recargo. 00:08:42
Si yo no le pongo constructores, tiene uno sin parámetros. 00:08:47
Uno sin parámetros que internamente llama al super 00:08:51
y el super no pasa nada porque no hace nada tampoco. 00:08:54
Entonces, además quiero uno con parámetros, hombre, pues sí, 00:08:58
vamos a ponerle uno con parámetros. 00:09:02
Entonces source, generate constructor 00:09:04
Quiero los de envío que me aparecen aquí arriba 00:09:07
Y también quiero el nuevo 00:09:11
Ala, chulísimo, ya está 00:09:13
Y ahora voy a hacer unos sin parámetros 00:09:16
Que siempre viene bien 00:09:18
Lo desmarco todo 00:09:20
Y ala, ya tengo uno sin parámetros 00:09:26
Ala, muy bien 00:09:29
¿Y he terminado? No, porque al heredar de envío 00:09:31
Tiene que implementar el método abstracto 00:09:34
Tiene que implementar envío urgente 00:09:38
Pues venga 00:09:40
Y ahora 00:09:43
¿Cómo implementa envío urgente? 00:09:47
Pues no sé, como me digan 00:09:49
El tío me dice 00:09:50
El envío urgente su coste es 00:09:52
5 por el doble del peso 00:09:54
Más el recargo 00:09:57
Ese es el coste del envío urgente 00:09:58
Pues entonces 00:10:00
Retún 00:10:03
Más 00:10:07
Dos por el peso 00:10:09
Aquí es donde sin el protected 00:10:12
Habríamos tenido que llamar a getPeso 00:10:15
Y habría sido un rollo 00:10:16
Mejor peso 00:10:17
Más el recargo 00:10:18
Bueno, pues envío urgente ya está 00:10:21
Pues venga, envío refrigerado 00:10:31
Rápidamente 00:10:35
Refrigerado o el otro, el que quieras 00:10:36
Que se ha prescrito 00:10:48
El envío fresco 00:10:50
Como vosotros 00:10:54
Stents 00:10:56
Envío 00:10:58
Está en el código Word 00:11:00
Se supone que lo estáis haciendo 00:11:07
Un poco en paralelo conmigo 00:11:12
Que tampoco estáis 00:11:14
¿En serio? 00:11:15
¿Dónde os habéis perdido? 00:11:25
¿Cómo no vas a saberlo? 00:11:28
no, envío urgente, en envío urgente 00:11:31
que es lo único que he hecho, poner el 00:11:34
adicional, recargo 00:11:36
con lo cual los get y los set 00:11:37
porque si hay uno ahora los get y set 00:11:39
y luego le he puesto los dos constructores 00:11:41
con parámetros y sin parámetros 00:11:44
¿cómo se hace esto a lo rápido? a las balas 00:11:47
¿cómo dices tú? o lo escribes 00:11:49
a mano que es un rollo 00:11:51
o botón derecho 00:11:53
source 00:11:55
botón derecho, source 00:11:56
generar constructor usando campos 00:12:00
y ahora aquí arriba 00:12:03
pones de los constructores de la superclase 00:12:05
en cuál te quieres apoyar 00:12:10
y qué parámetros vas a incorporar 00:12:12
marcas esto y ya está, ya te lo hace 00:12:15
y con este me echo el de con parámetros 00:12:18
que ahora quiero el sin parámetros 00:12:22
lo mismo pero lo desmarco todo 00:12:31
el sin parámetros 00:12:33
escribirlo a mano es casi más rápido 00:12:35
que hacer el botón derecho 00:12:37
es casi más rápido 00:12:39
¿vale? y luego que he hecho 00:12:41
en envío urgente 00:12:43
el método que no me quedaba más remedio que sobreescribir 00:12:44
al heredar de envío 00:12:47
bueno, refrigerado que metía 00:12:49
la temperatura 00:12:56
6 más el peso por 2,5 00:12:59
y si la temperatura es menor de 0 00:13:02
recargo de 4 00:13:06
Bueno, pues entonces refrigerado 00:13:07
Una temperatura 00:13:11
La temperatura 00:13:14
A la que tiene que estar refrigerado 00:13:22
Temperatura 00:13:24
El get y el set del nuevo 00:13:26
A ver 00:13:29
En este en particular 00:13:40
Pero lo normal es que sí 00:13:41
porque estén asociadas a un patrón de diseño 00:13:44
en las cuales las interfaces 00:13:47
o bien se ocupen de la parte de acceso 00:13:49
a datos o bien de la parte de interfaz gráfica 00:13:51
entonces eso 00:13:53
se pone en paquetes aparte para que sea más 00:13:54
claro, aquí vamos a poner 00:13:57
en paquete aparte, pero sí, lo normal es que vayan 00:13:58
en un paquete aparte porque sean como cosas 00:14:01
al margen de tu 00:14:03
modelo, que es los roles que hay 00:14:05
roles a los que se puede escribir 00:14:07
este modelo o este otro 00:14:09
vale 00:14:10
vale, temperatura 00:14:11
que le he puesto el get y el set 00:14:15
le voy a poner el constructor con la trampa 00:14:16
y le voy a poner el sin parámetros 00:14:18
y ahora 00:14:25
el envío 00:14:33
refrigerado, tengo que sobre escribir el método 00:14:35
vale 00:14:38
entonces, ya le he puesto 00:14:40
el, aquí 00:14:43
esto 00:14:44
yo es que estas cosas, prefiero que por lo menos 00:14:47
ahora las escribáis a mano, pero que sois 00:14:49
lo más vago del universo, que ya lo haréis 00:14:51
imagino 00:14:53
que ya lo hacéis así, porque otra cosa 00:14:54
no sé, pero encontrar atajos 00:14:57
del teclado 00:14:59
y cosas en eso 00:15:00
vamos, me dais 00:15:02
dos mil millones de vueltas 00:15:05
todo lo que implique 00:15:06
cosas que te hagan los demás las cosas 00:15:09
bueno, pues aquí, para que nos hagan los demás 00:15:11
las cosas, seguramente 00:15:15
ya lo usáis, pero bueno 00:15:17
envío refrigerado al heredar de envío 00:15:18
está obligada a implementar 00:15:21
el método, me lo dice el compilador 00:15:23
me lo está diciendo aquí, me dice 00:15:24
me está diciendo, me dice 00:15:26
cuidado que tienes que 00:15:31
que tienes que implementar 00:15:32
el método heredado abstracto 00:15:35
y el 00:15:37
el entorno de desarrollo 00:15:38
Eclipse y el Intel IE 00:15:42
y todos te ofrece soluciones 00:15:43
te ofrece una lista larga 00:15:45
normalmente, en muchos 00:15:47
casos, ninguna de ellas 00:15:49
es correcta. 00:15:51
Pero nosotros debemos 00:15:53
tener el criterio para saber cuándo 00:15:55
alguna de ellas es correcta. 00:15:57
En este caso, la de añade el método 00:15:59
que estás a implementar. Pues esto es 00:16:01
lo que quiero. Pues le hacéis el 00:16:03
doble clic, pipí, 00:16:05
y ya está. Y ya os lo añade. 00:16:07
Es otra más que no he hecho todavía. 00:16:15
Es que he empezado por abajo, no sé por qué. 00:16:17
vale 00:16:18
entonces, me lo ha añadido así 00:16:19
me lo ha añadido sin código, claro, el código 00:16:23
lo tengo que hacer yo, lógicamente 00:16:24
entonces, calcular coste 00:16:26
para el envío refrigerado 00:16:29
¿qué dice el enunciado? 00:16:30
sumarle 00:16:34
4 o no a 6 00:16:35
más el peso por 2,5 00:16:37
dependiendo si objetivo es menor que 0 00:16:39
o vamos a hacerlo así a lo bestia 00:16:41
retun 00:16:43
¿Temperatura menor que cero? 00:16:45
Sí, es menor que cero 00:16:53
Pues entonces, como la temperatura es menor que cero 00:16:54
El coste del envío refrigerado es 00:16:58
6 más 2,5 por el peso 00:17:00
Más el recargo 00:17:03
Más el recargo de 4 00:17:08
vale, más 4 00:17:13
más 1 más 4 00:17:15
si, pero te lo dice que 4 00:17:16
o sea, más un recargo de 4 00:17:19
vale, entonces será 00:17:21
temperatura será 6 00:17:23
más 2,5 00:17:25
por el peso 00:17:27
era, ¿no? por el peso 00:17:29
más el 4 00:17:31
yo he puesto aquí una coma 00:17:33
esto en el caso de que 00:17:34
la temperatura objetivo sea menor que 0 00:17:37
si no, es 6 más 2,5 00:17:39
por el peso 00:17:42
Ya está 00:17:42
¡Hala! Ya está sobrescrito el método 00:17:46
Calcular coste para el refrigerado 00:17:50
Vale 00:17:52
Y ahora 00:18:00
Venga, vamos a hacer envío estándar 00:18:02
Las interfaces 00:18:04
Envío estándar 00:18:05
El envío estándar que añade 00:18:10
Añade días 00:18:22
Añade días estimados 00:18:26
Que es un entero 00:18:31
Y todo el rollo de siempre 00:18:35
Get, set, constructores 00:18:44
Y el método que falta 00:18:46
Vale, el constructo 00:18:47
Ah, que no he puesto el stents 00:18:59
No he puesto el stents 00:19:01
Stents envío 00:19:03
Ahora ya hago el constructor 00:19:07
Constructor getSet 00:19:11
Y el método que me falta 00:19:24
Que el método es parecido al otro 00:19:26
Si los días estimados 00:19:31
Son menores o iguales que 2 00:19:33
Menor o igual que 2 00:19:35
Entonces 00:19:42
El coste que hay que devolver 00:19:44
3 más 1 con 2 00:19:47
por el peso, más 2,5 00:19:51
3 más 00:19:54
1,2 por el 00:20:00
peso, más 00:20:02
2,5 00:20:04
que es el recargo por ir rápido 00:20:06
y si no, pues 00:20:09
3 más 00:20:10
1,2 00:20:12
por el 00:20:15
peso, y me falta 00:20:16
la interrogación 00:20:20
y los dos 00:20:22
y me sobran los dos puntos 00:20:27
¡Hala! Pues las clases están todas 00:20:29
ahora, los envíos ya está, uno podría 00:20:34
hacer envíos, mostrar propiedades 00:20:37
de envíos, mostrar el coste de los envíos 00:20:39
ya con polimorfismo, cada uno calcula 00:20:41
su coste propio 00:20:43
pero además la 00:20:44
aplicación esta tiene que 00:20:47
poder hacer cosas 00:20:49
asegurar 00:20:51
y no sé qué otra cosa 00:20:52
asegurar y 00:20:55
y rastrear 00:20:57
entonces asegurar y rastrear 00:21:00
implica métodos relacionados 00:21:03
con asegurar y rastrear, implica métodos 00:21:05
que no tiene sentido que meta aquí 00:21:07
porque no todo es asegurable 00:21:09
y no todo es rastreable, entonces podría ir uno por uno 00:21:11
metiéndole a cada uno lo suyo 00:21:14
pero sería muy feo, entonces vamos 00:21:15
a hacer una interfaz 00:21:17
de todo lo relacionado con asegurar 00:21:18
pues nada, nos hacemos 00:21:21
new 00:21:23
interfaz 00:21:24
a ver 00:21:26
ahora sí porque como es como un ejemplo 00:21:29
en una aplicación grande, como un diseño ya grande 00:21:31
lo normal es que las interfaces 00:21:34
tengan su propio paquete, es lo que le decía 00:21:36
ella, porque desempeñen 00:21:38
sus roles, independiente del modelo 00:21:39
luego ya cada uno 00:21:42
pero bueno 00:21:43
sabe mucho, sí 00:21:45
asegurable 00:21:49
vale, pues ya está 00:21:51
¿qué métodos tienen que implementar 00:21:54
los envíos asegurables? 00:21:56
pues me dicen aquí que 00:21:58
los envíos asegurables tienen que poder implementar 00:22:00
calcular coste seguro 00:22:02
y ya está 00:22:04
calcular coste del seguro 00:22:06
pues entonces la interfaz asegurable 00:22:07
solamente tiene 00:22:09
un calcular 00:22:11
coste seguro 00:22:14
pero claro 00:22:17
¿cuál será el coste del seguro? depende 00:22:21
si es refrigerado es uno 00:22:23
si es urgente es otro 00:22:24
entonces esto es una interfaz 00:22:27
se queda ahí vacía y se acabó 00:22:29
¿qué otros roles posibles pueden desempeñar 00:22:30
los envíos de mi aplicación? 00:22:33
Pues rastreables 00:22:35
Pues me hago otra interfaz rastreable 00:22:36
Y ahora los envíos rastreables 00:22:39
¿Qué tienen que poder hacer? 00:22:49
Los envíos rastreables 00:22:51
Tienen que poder 00:22:52
Obtener estado y actualizar estado 00:22:53
Dado un string 00:22:57
Que se le pasa como parámetro 00:22:58
Envío rastreable 00:22:59
¿Dónde he hecho un envío rastreable? 00:23:06
He hecho una interfaz rastreable 00:23:08
Vale, el rastreable 00:23:11
Tiene dos métodos 00:23:14
Obtener estado 00:23:15
Y actualizar estado dado un string 00:23:18
Y obtener estado 00:23:19
Vale, pues obtener estado 00:23:22
El estado que sea un string 00:23:26
Obtener estado 00:23:27
Ar, class, interface 00:23:35
La he hecho como class 00:23:37
Interface, vale 00:23:40
Y ahora 00:23:43
Actualizar estado, era la otra, creo 00:23:44
Actualizar estado al que le pasamos el nuevo estado 00:23:47
Estas son las dos cosas que tienen que poder hacer los métodos rastreables 00:23:51
Obtener estado y actualizar el estado 00:23:59
Dado un nuevo estado, pues sale otro 00:24:02
Venga, pues vamos a un main 00:24:04
Un main cualquiera 00:24:33
No, claro, tienes razón, no lo he hecho 00:24:35
Ahora lo que tenemos es que envíe urgente 00:24:45
Envío urgente 00:24:49
Es asegurable 00:24:51
¿Verdad? 00:24:54
Pero este no era rastreable 00:24:56
Que habrá que incorporar 00:24:58
Los que sean rastreables 00:25:13
Tienen que tener un estado 00:25:15
No, lo tendremos que incorporar ahora 00:25:16
¿Vale? 00:25:20
Entonces, parte de la interfaz no puede ser 00:25:22
Porque las interfaces no tienen estado 00:25:24
Solo tienen métodos 00:25:26
Entonces aquí no podemos poner una propiedad 00:25:28
estado dentro de la interfaz que la le den lo demás 00:25:30
no podemos 00:25:33
claro 00:25:34
habría que ponerla, yo es que esto 00:25:36
quizá a lo mejor lo habría hecho 00:25:39
como clase abstracta para poder meter el estado 00:25:41
pero 00:25:43
porque tal y como está aquí propuesto 00:25:45
tienes que meterlo en las 00:25:47
otras, en envío estándar y envío urgente 00:25:48
entonces envío urgente 00:25:51
implementa las dos, es asegurable 00:25:53
y rastreable 00:25:55
entonces envío urgente implementa 00:25:56
Asegurable, implementa, rastreable. 00:25:59
Entonces, el urgente se puede asegurar y se puede rastrear. 00:26:04
Con lo cual, tenemos que implementar los métodos de las tres. 00:26:10
Tres métodos. 00:26:20
Me podéis dar aquí al botoncito, añadir, y ala, estos tres. 00:26:22
Claro. 00:26:38
vale, pues el envío urgente 00:26:38
tiene tres métodos 00:26:41
que tengo que completar 00:26:43
vale 00:26:44
obtener estado 00:26:46
obtener estado me tiene que devolver 00:26:48
el estado de ese envío 00:26:51
el estado 00:26:52
es una propiedad que tengo que añadir aquí 00:26:54
y como me dice 00:26:57
que inicialmente creado 00:27:02
aquí le pegaría que lo hicierais 00:27:04
con un enum, un enum porque 00:27:10
los estados se supone que hay 00:27:11
Lo hacemos 00:27:13
Es que como has puesto cara de 00:27:17
Que poco me gustan los enum 00:27:20
Vale, lo estoy metiendo todo en modelo 00:27:21
Vale, todo en modelo para que 00:27:25
Venga, pues nos vamos a hacer un enum 00:27:28
Que 00:27:30
Vamos a llamarle estado a ese enum 00:27:32
Estado envío 00:27:38
Para que quede más claro, estado envío 00:27:39
Y ahora, estado envío 00:27:41
qué estados creemos 00:27:43
que nos gustan 00:27:45
creado, enviado 00:27:46
y recibido 00:27:49
¿vale? 00:27:54
¿se podría poner? 00:27:55
sí, devuelto 00:27:57
bueno 00:27:59
la verdad es que 00:28:02
sí, lo que pasa es que 00:28:05
podríamos extendernos hasta el infinito 00:28:07
perdido, escupido 00:28:09
mojado, deteriorado 00:28:11
pero bueno 00:28:14
vamos a quedarnos con 4 00:28:15
vale, pues entonces 00:28:18
ahora ya 00:28:21
mi envío urgente 00:28:22
su estado ya no va a ser 00:28:25
un string, sino que 00:28:27
su estado va a ser un 00:28:29
envío 00:28:31
estado 00:28:32
he puesto 00:28:34
creado, enviado, recibido, devuelto 00:28:36
vale, entonces ahora ya 00:28:39
mi envío estado 00:28:42
Mi propiedad estado de envío urgente 00:28:46
Ahora va a ser del tipo envío estado 00:28:49
Y como inicialmente es creado 00:28:52
Pues yo inicialmente le doy este valor 00:28:54
Envío estado 00:29:02
Que he escrito mal 00:29:05
Ah, ya decía yo 00:29:07
Vale, vale 00:29:16
Estado envío 00:29:17
Vale, estado envío 00:29:18
Punto creado 00:29:25
Ese es el estado inicial 00:29:32
Y ahora, ¿qué nos cambia? Aquí estado envío. Pues vámonos a los métodos que tenemos que hacer. Obtener estado ya no me va a devolver un string. Obtener estado me devuelve un estado envío. Eso es lo que me devuelve obtener estado, estado envío. 00:29:35
y que me devuelve 00:29:57
me devuelve la propiedad 00:30:00
estado envío, que es 00:30:02
estado 00:30:04
y alguna otra cosa he escrito mal 00:30:05
así que en la interfaz 00:30:10
en la interfaz la tengo que cambiar 00:30:12
en mi interfaz 00:30:13
el método que yo lo había 00:30:16
puesto como 00:30:18
asegurable rastreable 00:30:19
aquí, en la interfaz 00:30:22
en obtener estado 00:30:23
ya como hemos decidido, metieron en un 00:30:25
porque es que lo habéis pedido a gritos 00:30:27
pues como hemos decidido poner un enum 00:30:29
iros a la antifaz rastreable 00:30:32
a cambiarlo 00:30:35
actualizar estado 00:30:37
pues hay que darle de nuevo 00:30:40
un estado envío 00:30:42
y actualizar estado que nos devuelva 00:30:44
void, no tiene que hacer nada 00:30:50
actualizar el estado y ya está 00:30:51
con el enum así se quedan los dos 00:30:53
métodos de rastreable 00:30:55
obtener estado 00:30:58
que me da el estado del envío 00:30:59
y actualizar estado que me he dado un estado 00:31:00
nuevo me lo guarda. Así se quedan. Y ahora ya en envío urgente, estado envío me devuelve 00:31:03
el estado y actualizar estado voy a cambiarlo. Esto aquí, esto aquí, esto voy. Actualizar 00:31:13
estado no tiene un retún y actualizar estado ¿qué hace? Pues dis.estado, aunque el dis 00:31:30
me sobra, igual a nuevo estado. Eso me hace la actualiza estado. ¿Calcular coste del 00:31:36
seguro? Pues, ¿cómo se calcula el coste 00:31:49
del seguro para un envío urgente? 00:31:51
Me lo dirá el enunciado. 00:31:53
Coste del seguro 00:31:56
se calcula 00:31:57
como 1,5 por el 00:31:59
peso multiplicado por 0,8. 00:32:01
El coste del seguro es 00:32:04
1,5 00:32:07
más 00:32:11
1,5 más 00:32:11
el peso 00:32:15
por 0,8. 00:32:16
¿Vale? Entonces, 00:32:25
El rastreable va a tener la misma implementación, la misma. 00:32:28
Entonces diríais, jo, ¿no se puede poner como una implementación default en la interfaz? 00:32:33
Pues no se puede, ¿por qué? 00:32:39
Porque depende de peso. 00:32:40
Y peso es una propiedad que está solo en la subclase, no está en la interfaz. 00:32:42
Entonces no lo puedo poner como default, porque depende del estado del objeto. 00:32:48
vale, que ahora 00:32:52
el enunciado me dice que el coste del seguro 00:32:56
es igual para todos, envío 00:32:58
urgente, es el coste del seguro 00:33:00
entonces podríais pensar, cuando 00:33:02
hagamos el envío 00:33:04
refrigerado, que también 00:33:06
al implementar rastreable 00:33:08
perdón, al implementar asegurable 00:33:10
tendrá que calcular coste seguro 00:33:12
vamos a hacerlo rápidamente, que esto no tardamos 00:33:14
nada, cuando el envío 00:33:16
refrigerado hagamos que también implemente 00:33:18
asegurable, vale 00:33:20
Al implementar asegurable, nos va a obligar a implementar el coste del seguro. 00:33:24
Bueno, pues implementamos el coste del seguro. 00:33:29
¿Y cómo lo va a hacer? 00:33:32
Exactamente igual que el otro. 00:33:34
Podemos hacer un copia y pega. 00:33:35
Un copia y pega del retun. 00:33:38
Igual. 00:33:39
En el envío refrigerado, lo mismo. 00:33:41
Exactamente igual. 00:33:44
Y ahora es cuando vosotros me diríais. 00:33:48
Pero vamos a ver. 00:33:50
Si calcular coste seguro es igual en envío refrigerado que en urgente, es que es igualito. 00:33:51
No lo puedo poner como versión default en la interfaz. 00:33:59
No podemos, porque depende del peso, de la variable peso. 00:34:04
Y la variable peso no puede estar en la interfaz. 00:34:11
No puede. 00:34:16
pues lo que diga esto 00:34:17
el refrigerado 00:34:21
solo implementa 00:34:24
la asegurable 00:34:26
el urgente las dos y el estándar 00:34:27
la rastreable 00:34:30
es una propiedad 00:34:31
que está en la clase 00:34:36
no la podemos poner 00:34:37
aquí 00:34:39
yo aquí no puedo poner el código 00:34:40
no puedo poner aquí una propiedad peso 00:34:43
no puedo ponerlo de ninguna manera 00:34:45
sí, pero no es grave 00:34:47
no pasa nada, coincide que 00:34:51
cada uno se implementa 00:34:53
de la misma manera, pero puntualmente 00:34:55
a lo mejor mañana resulta que el coste 00:34:57
del seguro refrigerado sube, pues ya está 00:34:59
lo cambias, no pasa nada 00:35:01
porque sea el mismo en ambos 00:35:03
lo importante aquí 00:35:04
es que los dos están obligados a ponerlo 00:35:07
vale 00:35:10
y yo, aunque 00:35:14
Esto sé que os engancha mucho 00:35:17
Os voy a echar 00:35:19
¿Vale? 00:35:21
Sí 00:35:25
Que aunque sé que esto 00:35:25
Os engancha mucho 00:35:28
No, no es la hora en realidad 00:35:30
Pero os voy a echar 00:35:31
Porque me tengo que ir 00:35:33
No, os he hecho por mí 00:35:34
Por mi culpa y os pido disculpas por echaros 00:35:38
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:
2
Fecha:
25 de enero de 2026 - 17:40
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 41″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
158.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid