Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 13-02-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 15 de febrero de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

bueno, pues en un caso real 00:00:00
cuando uno quiere hacer las cosas bien 00:00:04
insisto, uno se lee esto 00:00:06
detenidamente para entender 00:00:08
qué necesidad va a cubrir esto 00:00:11
¿por qué? ¿qué razón de ser tiene esta aplicación? 00:00:12
¿vale? 00:00:15
a ver, en un examen 00:00:16
en un examen no podemos 00:00:18
pedir eso, no podemos pedir una aplicación 00:00:21
así para que uno primero se la lea 00:00:23
entienda, haga todo el esfuerzo de análisis y diseño 00:00:24
porque no tenemos ese tiempo 00:00:27
pero lo que sí que es importante 00:00:28
es que quede claro 00:00:33
que eso forma parte del trabajo 00:00:35
del desarrollo y es la parte 00:00:37
en la que hay que dedicar, en la que no hay que 00:00:39
escatimar ningún esfuerzo si luego queremos 00:00:41
que el resto del código nos quede 00:00:43
manejable, entendible 00:00:45
escalable, etcétera, lo que siempre decía 00:00:47
no hay que escatimar esfuerzos 00:00:49
en esa parte de analizar 00:00:50
y diseñar, ahora mismo nosotros 00:00:53
en este ejercicio 00:00:55
lo vamos a pasar un poco por alto 00:00:56
y vamos a ir haciendo 00:00:58
corrida 00:01:00
pero en un caso real 00:01:01
repito, uno lo leería y diría 00:01:05
¿qué necesidad está cubriendo esto? pues en este caso 00:01:06
entiendo, por lo que veo que esto está 00:01:09
cubriendo la necesidad de en un hotel 00:01:10
gestionar 00:01:13
las reservas de habitaciones 00:01:14
pues si están disponibles, si no están disponibles, etc. 00:01:16
entonces va a cubrir 00:01:20
esa necesidad, gestionar reservas 00:01:21
para eso 00:01:22
uno 00:01:24
se va al cliente que le ha pedido la aplicación 00:01:26
y habla con él una y mil veces 00:01:29
hasta que entienda 00:01:31
perfectamente que necesita 00:01:33
ese cliente 00:01:35
necesito poder hacer una reserva 00:01:36
necesito poder cancelar reserva 00:01:39
necesito poder dar de alta habitación 00:01:41
necesito poder cambiar 00:01:43
tipo de habitación, se pone de acuerdo con el cliente 00:01:45
y una vez que ya 00:01:47
ha entendido la necesidad 00:01:49
y ha entendido exactamente 00:01:51
todo lo que el cliente quiere 00:01:53
poder hacer, hacer reservas 00:01:54
cancerales, etcétera, ya se pone 00:01:57
a hacer un diseño 00:01:59
de las clases 00:02:00
que de alguna manera representan 00:02:02
eso, vale, pues 00:02:05
si trabajo con habitaciones, una clase de habitación 00:02:07
seguramente me haga falta 00:02:09
si además voy a manejar reservas, pues una clase 00:02:10
de reservas seguramente me haga falta 00:02:13
si además voy a manejar 00:02:14
clientes, pues una clase 00:02:16
de clientes puede que me haga falta 00:02:19
aquí no parece el caso, entonces uno ya hace su diseño 00:02:20
luego en ese primer diseño 00:02:23
empiezo a incorporar conceptos como 00:02:26
la herencia, que si 00:02:27
ve que lo representan 00:02:29
son fundamentales y se van a facilitar en la vida 00:02:31
tengo diferentes tipos de habitaciones 00:02:34
ah vale, voy a incorporar 00:02:36
en el diseño la herencia, tengo diferentes tipos 00:02:37
de clientes, pues voy a irlo 00:02:39
incorporando 00:02:42
vale, entonces toda esa parte 00:02:42
de diseño ya conduce a un primer 00:02:45
mapa de clases, estas son mis clases 00:02:47
voy a hacerlas 00:02:50
y voy a empezar ya a escribir código en ellas. 00:02:51
Bueno, pues aquí se supone que ya ese diseño ya está hecho 00:02:55
y nos dicen que lo vayamos haciendo tal cual. 00:02:57
Pues venga, nosotros ya directamente vamos a ir haciendo las clases 00:03:00
y ya nos irán surgiendo cosas, dudas, historias, 00:03:03
como os habrán surgido a los que lo habréis hecho 00:03:06
y vamos resolviendo sobre la mancha. 00:03:09
Y a ver qué código nos sale. 00:03:12
Y ya está. 00:03:14
Venga, pues entonces, aquí en este primer diseño 00:03:15
tenemos habitación 00:03:17
con, me nos dicen ya 00:03:18
unas propiedades y métodos 00:03:21
y luego habitación familiar 00:03:23
que ya hereda de esta 00:03:24
pues venga, vamos a hacer rápidamente habitación 00:03:26
vale, imaginaos que estáis 00:03:29
pues en una especie de 00:03:31
examen de un par de orillas 00:03:33
y hay que hacer esta aplicación 00:03:36
hay que hacer esta aplicación 00:03:37
pues venga, pues hala, nos hacemos 00:03:38
nuestro proyecto de Java 00:03:41
normalito y corrientito 00:03:43
Bueno, a ver, yo no lo voy a hacer en un proyecto aparte 00:03:44
Porque los estoy haciendo en el proyecto de ejercicios herencia 00:03:49
Para subirlo luego a la aula virtual 00:03:55
Entonces lo meto en un paquete que sea ejercicio hoteles 00:03:58
Voy a meter todas las clases allá a lo bestia 00:04:02
vale, pero insisto 00:04:14
yo hago este empaquetado así pataterillo 00:04:23
por comodidad para subir 00:04:26
luego un único proyecto al aula virtual 00:04:27
cada ejercicio en un paquete 00:04:29
pero no es el procedimiento 00:04:31
el procedimiento es que 00:04:34
una aplicación vaya 00:04:35
en su proyecto y yo 00:04:37
decida una estructura de paquetes 00:04:39
acorde con 00:04:42
para lo que sirve cada clase 00:04:43
clases de entidad o modelo 00:04:45
clases de utilidades 00:04:47
clases de lógica 00:04:50
pues lo que vaya surgiendo, ahora mismo pues 00:04:51
entidad y lógica, no tenemos más conceptos 00:04:53
el año que viene pues sí que habrá más cosas 00:04:56
clases de persistencia, clases de no sé qué 00:04:57
vale, pues venga 00:04:59
yo las voy a meter todas a lo bestia en ejercicio teles 00:05:01
que es 00:05:03
repito, una práctica muy fea 00:05:05
pero bueno 00:05:07
pues venga, clase habitación 00:05:08
propiedades que va a tener 00:05:11
porque se va a caracterizar la habitación 00:05:20
esto vendría después de haber hablado con el tío y haberle dicho 00:05:22
oye, que necesitas tú 00:05:24
tener registrado 00:05:27
de cada habitación 00:05:29
que información te interesa 00:05:30
y después de haber hablado con él 00:05:32
habríamos hecho ya el diseño 00:05:33
y ese diseño ya me viene aquí hecho 00:05:35
de la habitación solamente te hace falta conocer 00:05:37
cuál es su número, las camas que tiene 00:05:40
y su precio, y ya está 00:05:43
es la única información que te interesa 00:05:44
pues hala, estupendo 00:05:46
el número de habitación 00:05:48
el número 00:05:50
de camas 00:05:58
y el precio 00:06:01
venga, nos hacemos 00:06:01
constructor 00:06:07
Estoy metiendo esto, perdón, en el constructor 00:06:08
Ahí, que ya tenía yo un constructor 00:06:21
Ahí fuera, vale 00:06:24
Constructor sin parámetros, ya lo tengo yo aquí hecho 00:06:25
Constructor con 00:06:28
y respondemos al patrón habitual de que los atributos o propiedades sean privadas 00:06:38
y yo doy acceso a ellas mediante los get y set correspondientes. 00:06:49
Vale, y bueno, aquí además sería interesante hacer un método toString porque no molesta, 00:07:01
el toString no molesta. 00:07:07
el twist no molesta y me sirve 00:07:08
si yo le paso a un system.out.println 00:07:10
porque voy a verificar algo 00:07:13
voy a comprobar 00:07:14
pues si se lo paso a un system.out.println 00:07:15
me va a mostrar la habitación 00:07:18
vale 00:07:20
me la va a mostrar más bonita que si no le he 00:07:22
sobrescrito el twist string 00:07:24
que me gusta a mi esa salida 00:07:25
para el twist string 00:07:29
la dejo tal cual 00:07:29
que no me gusta esa salida para el twist string 00:07:31
pues la cambio 00:07:33
vale 00:07:35
A mí no me gusta que no lleve tilde 00:07:36
Pero bueno 00:07:39
El Eclipse no entiende de tildes 00:07:39
Bueno, método sobrescrito de object 00:07:43
¿Vale? Todos recordamos que esto 00:07:49
En realidad está heredando 00:07:51
Aunque no lo veamos 00:07:53
Esto está heredando de object, todos lo recordamos 00:07:54
Pero 00:07:56
Vale, get set to string 00:07:59
Y ya está 00:08:03
Y, a ver, ya directamente, como nos dan un diseño hecho al que nos ceñimos sin más, pues ya nos han dicho, oye, a ver, nos va a interesar un método que se llame plazas totales, que devuelva cuántas personas caben en la habitación, cuántas personas caben, porque es una funcionalidad que después de haber hablado con el cliente nos hemos dado cuenta que necesitamos, nos interesa. 00:08:06
entonces como esa funcionalidad 00:08:33
está relacionada exclusivamente con las habitaciones 00:08:35
o sea saber 00:08:38
cuánta gente cabe en una habitación 00:08:39
está relacionada con la habitación 00:08:41
pues tiene sentido que ese método vaya ahí 00:08:43
porque es un método 00:08:45
relacionado con un objeto habitación 00:08:47
pues metemos ahí ese método 00:08:49
pero vamos 00:08:51
el diseño es que ya está, nosotros ahora estamos haciendo 00:08:53
lo que ya nos han dicho, pero estoy justificando 00:08:55
porque tendría sentido que estuviera ahí 00:08:57
ese método 00:08:59
Pues hala, venga 00:09:00
¿Cuántos caben en cada cama? 00:09:02
Pues uno, pues hala 00:09:04
Entonces, aquí tendríamos 00:09:05
Las personas 00:09:10
Son enteras 00:09:13
No puede volver una persona y media 00:09:14
Pues entonces 00:09:16
Get personas totales 00:09:17
lo de siempre 00:09:29
aquí no necesitamos 00:09:31
no necesitamos 00:09:33
parámetros para trabajar 00:09:34
porque la información 00:09:37
si sería 00:09:38
el de las, lo voy a llamar igual que dice aquí 00:09:41
plazas, vale, vale, no es que no recordaba 00:09:43
no, no, no, es que no recordaba 00:09:45
como, venga, sí 00:09:48
vale, entonces 00:09:49
no tenemos más información, no necesitamos 00:09:51
más información que las personas, que las camas 00:09:53
no es la única que necesitamos 00:09:55
Y si cabe solo una en cada cama 00:09:56
Pues esto es una tontería 00:09:58
Esto es 00:10:01
Esto de aquí 00:10:01
Ala 00:10:03
Bueno 00:10:06
El que hizo el diseño después de hablar con el cliente 00:10:08
No parece haber identificado 00:10:11
Ninguna funcionalidad más 00:10:13
Exclusivamente relacionada con una habitación 00:10:15
Porque si la hubiera identificado 00:10:17
Limpiar habitación 00:10:19
Vaciar habitación 00:10:22
lo que fuera si lo hubiera identificado 00:10:25
habría metido ahí ese método 00:10:27
¿vale? porque es una funcionalidad 00:10:28
relacionada con un objeto habitación en concreto 00:10:31
si no nos han pedido más 00:10:33
métodos es porque dice el diseño 00:10:35
no ha identificado más funcionalidades relacionadas 00:10:37
con una habitación, salvo devolver las plazas 00:10:39
y ya está 00:10:41
pues hala, esta clase si lo estoy 00:10:41
leyendo bien 00:10:45
que como voy leyendo sobre la marcha 00:10:46
si algo 00:10:49
no leo mal o lo que sea me lo decís 00:10:50
vale, esta clase 00:10:53
ya estaría, ya tenemos la habitación 00:10:55
y esta no nos ha complicado la vida 00:10:56
ahora, resulta que hay un tipo 00:10:58
de habitaciones, de nuevo 00:11:00
el que estudió la situación 00:11:02
vio que había 00:11:04
un tipo de habitaciones concretas 00:11:06
que se manejaban 00:11:09
que se trabajaba con ellas de forma diferente 00:11:10
parece ser, que se trabajaba con ellas 00:11:13
de forma diferente, entonces tiene 00:11:14
sentido plantearse que haya dos tipos 00:11:16
de objetos, la habitación 00:11:18
que no es especial, la habitación 00:11:21
genérica y la habitación 00:11:23
que es específica 00:11:25
familiar 00:11:27
y que tendrá unas características propias 00:11:28
bueno, pues una vez que hemos 00:11:31
identificado esas dos cosas 00:11:33
decimos, ah vale, pero la habitación 00:11:34
que tiene unas características propias específicas 00:11:37
porque es familiar, también es 00:11:39
habitación genérica, vale 00:11:41
pues mi diseño va a ser más bonito seguramente 00:11:43
y más eficiente si yo hago que una 00:11:45
herede de la otra, vale 00:11:47
todas estas cosas se van 00:11:48
identificando en la fase de diseño de la que 00:11:51
hablamos. Bueno, pues 00:11:53
entonces, primero, hemos 00:11:54
identificado que necesitamos 00:11:56
una nueva clase para una habitación específica. 00:11:58
Y segundo, 00:12:01
hemos identificado que la habitación específica 00:12:03
tiene todo lo de 00:12:05
la genérica, tiene todo. Pues 00:12:06
entonces, automáticamente, ahí 00:12:08
hacemos la herencia, identificamos la herencia. 00:12:10
Podríamos 00:12:14
haber hecho otro diseño, que fuera 00:12:14
habitación normal, habitación 00:12:16
familiar, dos clases por libre, 00:12:18
ninguna hereda de la otra. Bueno, 00:12:21
Nos conduce a otra aplicación, pero hombre, a lo mejor este diseño, 00:12:23
si la familiar también es genérica, pues incorporar la herencia 00:12:28
seguramente nos facilite mucho las cosas. 00:12:32
De hecho, nos va a facilitar tratar todas las habitaciones por igual, 00:12:36
sean familiares o no. 00:12:39
Pues venga, después de haber analizado y pensado esto, 00:12:41
uno ha llegado a la conclusión de que necesita una clase habitación familiar. 00:12:44
Pues se hace su clase nueva 00:12:47
Habitación familiar 00:12:50
Y esta habitación familiar 00:12:57
Como tiene todo lo que tiene la genérica 00:13:01
Número de habitación, las camas y el precio 00:13:03
Pues la hacemos heredera de esta otra 00:13:06
Y al hacerla heredera de esta otra 00:13:09
pues tiene ya 00:13:17
el número 00:13:22
las camas 00:13:23
el precio y los getter y los setter 00:13:26
y los getter y los setter 00:13:29
los constructores no 00:13:30
porque 00:13:32
los constructores no se heredan 00:13:33
también tiene el tuestrin 00:13:35
pero tiene el tuestrin de habitación 00:13:37
tiene este 00:13:41
que yo quiero hacerle un tuestrin específico 00:13:41
para ella, pues se lo hago 00:13:45
vale, pues la habitación familiar 00:13:46
se supone que es una habitación concreta 00:13:50
más específica y tendrá por tanto 00:13:52
atributos añadidos 00:13:54
efectivamente, añade uno 00:13:55
que es número de camas dobles 00:13:58
adicionales que tiene 00:14:00
bueno, pues el número de camas 00:14:01
dobles adicionales que tiene será otro atributo 00:14:04
que 00:14:06
en principio, salvo 00:14:08
que haya algún diseño que me exija lo contrario 00:14:10
por lo que sea, en principio 00:14:12
privado como siempre 00:14:14
y esto podría ser 00:14:16
nunca más dobles 00:14:21
entonces 00:14:22
tendría sentido incorporar un get y un set 00:14:24
para este 00:14:27
y un constructor con parámetros 00:14:31
también por comodidad 00:14:35
siempre viene bien 00:14:36
y si lo hago encima apoyándome en los 00:14:37
En los constructores de arriba 00:14:41
Mucho mejor 00:14:44
¿Vale? 00:14:45
Vale 00:14:55
Entonces, aquí habitación familiar 00:14:56
Este con parámetros 00:14:59
Le tendremos que pasar 00:15:00
Todos los parámetros que tiene 00:15:02
Que va a tener 00:15:03
Nunca más 00:15:05
num habitación 00:15:09
a ver, lo parto aquí 00:15:13
aunque quede feo para que se vea 00:15:17
habitación familiar tendrá cuatro parámetros 00:15:20
las camas, la habitación, el precio 00:15:22
y las camas dobles 00:15:25
entonces hay tres parámetros 00:15:29
que los voy a inicializar llamando al constructor de arriba 00:15:33
en el orden correcto 00:15:36
habitación, camas y precio 00:15:38
pues llamo al constructor de arriba 00:15:39
y le paso 00:15:42
habitación 00:15:43
camas y precio 00:15:46
con esta llamada 00:15:50
super ya estoy inicializando 00:15:52
las tres propiedades 00:15:55
de habitación familiar que no estoy viendo 00:15:57
físicamente 00:15:59
están ahí pero no las estoy viendo 00:15:59
están ahí pero no las veo 00:16:02
pues llamando al constructor de arriba 00:16:03
las estoy ya inicializando 00:16:06
y cuando yo haga el get de habitación 00:16:07
familiar, pues tendré 00:16:10
sus valores, etcétera, y luego la adicional 00:16:12
el parámetro 00:16:14
el parámetro adicional, que es el que le paso 00:16:15
aquí, el parámetro adicional 00:16:18
ese sí que lo especifico directamente 00:16:19
porque ese no está en habitación 00:16:22
luego no se lo puedo pasar a super, lógicamente 00:16:24
bueno, pues nada, ya tenemos 00:16:26
el constructor con y sin parámetros 00:16:28
de habitación familiar, el get y el set que 00:16:30
falta, podemos rehacer 00:16:32
el toString para que 00:16:34
también me muestre las camas dobles de esta habitación, repito 00:16:36
porque si no lo rehago, el tuestrín de habitación familiar 00:16:40
es este, que solo me muestra los tres primeros 00:16:44
entonces lo podemos rehacer, lo podemos sobrescribir 00:16:47
vale, entonces 00:16:51
lo podemos sobrescribir usando 00:16:55
Aquí no sé si 00:17:03
No, aquí me lo va a hacer 00:17:07
Solamente con este 00:17:11
Entonces, espera, no, lo voy a 00:17:12
Copiar y pegar 00:17:15
De arriba 00:17:16
Por lo tanto, aquí 00:17:18
Copiamos y pegamos este 00:17:21
Para sobrescribirlo 00:17:26
Y le vamos a añadir 00:17:27
¿Vale? 00:17:30
le vamos a añadir 00:17:33
el parámetro 00:17:39
Sí, un segundito, déjame añadir 00:17:40
el, o sea, te refieres aquí 00:17:51
Sí 00:17:52
No sé lo que me estás preguntando 00:17:54
en la herramienta dices, cuando yo lo gero automáticamente 00:18:01
Sí, aquí 00:18:03
Aquí te refieres, ¿dónde? 00:18:05
Cuando yo le doy a generar, ¿te refieres? 00:18:16
Sí 00:18:20
Sí 00:18:20
Ah, bueno, ya, sí, sí 00:18:23
Vale, vale 00:18:28
Bueno, tú haz el que quieras 00:18:33
Pero vamos, que yo quiero hacer 00:18:37
Pero vamos a ver qué pone 00:18:38
Déjame ver qué pone 00:18:40
Sí, pero voy a comentar este 00:18:41
Para que el error no me 00:18:44
Voy a ver qué pone 00:18:45
Porque no lo he generado nunca así 00:18:47
A ver 00:18:49
Yo hago esto 00:18:53
Y marco todos, te refieres 00:18:56
Los que quiero 00:18:58
Al que quiero implementar 00:19:01
Que yo quiero implementar el toString, ¿no? 00:19:02
Por ejemplo, vale 00:19:04
Entonces, aquí en el toString 00:19:05
Me marca 00:19:09
Bueno, esto lo que está haciendo es llamar 00:19:10
Al toString del de arriba 00:19:12
O sea, es 00:19:14
En realidad no lo está 00:19:15
Pero 00:19:17
No consigo nada haciendo esto 00:19:18
Me refiero, o sea, luego sí que le puedo 00:19:22
Añadir el otro 00:19:24
Aquí tendría sentido que yo hiciera 00:19:25
Super toString y ahora además 00:19:27
Concatenarlo con la que falta 00:19:30
vale, eso sí que lo podría hacer 00:19:31
tendría su interés 00:19:34
lo único es que bueno, que como el tu string de arriba 00:19:35
me hace una cadena que cierra con corchetes 00:19:38
pues quizá luego aquí quede feo 00:19:40
el string que sale 00:19:42
pero sí, esto te llama 00:19:43
al de arriba y si al de arriba 00:19:46
le quieres añadir algo, pues le añades 00:19:48
vale 00:19:50
siempre que se use 00:19:51
el término super, lo que pasa es que 00:19:56
para no liar mucho con el dis, el constructor 00:19:58
no lo he mencionado, pero siempre que se use 00:20:00
su persona en una clase 00:20:02
se refiere a la clase de la que heredas 00:20:04
¿vale? 00:20:07
entonces puedes usarlo para llamar 00:20:09
tanto a propiedades como métodos 00:20:10
siempre y cuando sean visibles, porque tengan el 00:20:12
no tengan el privado, claro, siempre y cuando sean visibles 00:20:14
lo puedes usar, yo podría poner aquí 00:20:16
super punto, nunca más 00:20:18
por ejemplo 00:20:21
si es que nunca más no fuera privado 00:20:22
¿vale? podría, si es que 00:20:24
lo necesito, pero para eso tengo el 00:20:26
nunca más también 00:20:28
en fin, conclusión 00:20:29
que el super en una clase 00:20:31
el super tiene dos usos 00:20:33
uno, como llamada al método constructor 00:20:35
y si es como llamada al método constructor 00:20:37
le tienes que llamar pasándole parámetros 00:20:40
claro, que es este uso que hemos hecho aquí 00:20:41
este 00:20:44
este es un super, que es un super 00:20:45
que es llamada al constructor 00:20:48
y luego hay otra acepción de super 00:20:49
que es 00:20:52
objeto del que heredas 00:20:52
ya no es llamada a método 00:20:55
sino objeto, por eso no tiene parámetros 00:20:57
por eso no tiene paréntesis 00:21:00
¿vale? ¿dónde lo tengo? 00:21:01
¿ves? este no tiene paréntesis 00:21:05
porque este no es llamado 00:21:06
a un método, esto es 00:21:08
me refiero a la clase 00:21:09
de la querido, me refiero 00:21:12
y entonces, si te refieres a la clase 00:21:13
al objeto de la clase de la queridas 00:21:15
pues un objeto te hace desapropiadas y métodos 00:21:17
con punto, y podrás 00:21:20
a todos los que te los permitan 00:21:21
porque el modificador no se ha privado 00:21:23
Entonces siempre puedes recurrir a esto 00:21:25
Si lo necesitas para algo 00:21:28
¿Vale? 00:21:29
Pero bueno 00:21:31
Tiene cierto peligro 00:21:32
En algunos contextos 00:21:35
Pero puedes estar llamando a cosas que no quieres llamar 00:21:36
Entonces yo voy a hacer 00:21:40
El tuestrin a mano 00:21:44
¿Vale? 00:21:44
Entonces yo le añadiría aquí 00:21:51
Nunca más precio 00:21:53
Y le falta por añadir 00:21:55
Nunca más dobles 00:21:58
Igual 00:22:03
Y le concatenaría 00:22:09
Con num 00:22:11
K más dobles 00:22:13
Vale, y ahora tendría que concatenar aquí 00:22:16
con esto 00:22:22
esto 00:22:23
vale, entonces ya está 00:22:25
es hacerse un toString, simplemente que el toString 00:22:28
es solamente, ya sabéis para qué 00:22:30
pues si hay alguien que necesita alguna vez 00:22:32
pasar a versión 00:22:35
texto, pasar a versión texto 00:22:37
para consola, para lo que sea 00:22:39
un objeto, pues el método toString 00:22:40
te lo pasa a versión texto, pero que 00:22:43
su utilidad es solo para que tú lo veas 00:22:44
en la consola, es la única utilidad 00:22:47
que tiene, pasarla a versión texto 00:22:48
bueno, pues ya está, lo paso a versión texto 00:22:50
pero esto ya no es un objeto, es una cadena 00:22:52
de texto, es una cadena, esto ya no es un objeto 00:22:54
ni es nada, es una cadena, pero bueno, tiene su utilidad 00:22:56
tiene su utilidad un objeto 00:22:58
pasarlo a cadena para visualizar 00:23:00
un poquito lo que tiene, pero es la única utilidad 00:23:02
que tiene, ¿vale? aquí como era 00:23:04
de prever, esto se ha puesto rojo, ¿no? 00:23:06
¿no? 00:23:09
¿por qué se ha puesto rojo? Claudia, por ejemplo 00:23:10
la pregunta de siempre 00:23:12
¿por qué no lo estás llamando? 00:23:14
claro, porque es privado 00:23:17
Entonces o le pongo protected 00:23:18
O lo llamo con el get 00:23:20
¿Vale? 00:23:22
Vale 00:23:46
Vale, ya tengo el toString 00:23:46
Bueno, pues nada 00:23:47
un toString, si me gusta bien 00:23:48
y si no lo cambio, hago lo que quiera 00:23:50
venga, pues 00:23:52
ala, esta habitación específica 00:23:54
añade este atributo y claro 00:23:56
al añadir un nuevo atributo 00:23:58
ese atributo es relacionado con nuevas camas 00:24:00
como esta clase 00:24:02
hereda todo 00:24:04
lo de la clase anterior, también 00:24:06
le he dado getPlazasTotales 00:24:08
pero claro, getPlazasTotales 00:24:10
esta versión no vale 00:24:12
abajo, no vale, obviamente 00:24:14
porque precisamente lo que ha añadido esta habitación 00:24:16
es un número de camas adicionales 00:24:19
entonces esta versión 00:24:21
heredada no vale 00:24:23
entonces siempre hay que revisar cuando se hereda de algo 00:24:24
si lo que heredamos nos vale o no 00:24:27
o hay que cambiarlo, en este caso 00:24:29
el toString no nos gustaba y lo hemos sobrescrito 00:24:31
y el getPlazasTotales 00:24:33
tampoco nos gusta, hay que sobrescribirlo 00:24:35
pues sobrescribir un método 00:24:37
implicará hacer otro con exactamente 00:24:39
la misma cabecera, la misma 00:24:41
enterita 00:24:43
Porque si no tiene la misma 00:24:45
No estoy sobre escribiendo 00:24:46
Estoy haciendo uno nuevo 00:24:47
Y eso puede generar confusión 00:24:49
Pues venga 00:24:51
Sobre escribimos este método 00:24:53
Porque ahora ya 00:24:56
Las plazas totales serán 00:24:58
Las camas 00:24:59
Normales 00:25:02
Más 00:25:03
Las camas 00:25:04
Dobles 00:25:08
Por dos 00:25:09
¿Verdad? 00:25:11
Y de nuevo esto aquí 00:25:13
Que lo pongo muy alegremente 00:25:15
Pues así 00:25:16
¿Vale? 00:25:21
Como el get se puede hacer un poco coñacete 00:25:24
Tirar del get todo el rato 00:25:27
Por eso en realidad es por lo que 00:25:28
Existe el protect 00:25:30
Por lo que se inventó, entre comillas 00:25:31
Pues para no tener que estar tirando del get 00:25:34
Todo el rato desde las herederas 00:25:36
Es decir, mira, anda, ponte protect 00:25:37
Y las estás dejando igual de ocultas 00:25:39
Solamente 00:25:42
Las estás abriendo a las herederas 00:25:44
Entonces, hombre, tampoco es que estés abriendo tanto 00:25:46
Pero, jolín 00:25:49
Nos ahorramos tanto get, tanto get 00:25:51
¿Verdad? 00:25:53
Aquí que hemos tenido tanto get 00:25:55
Que era un rollo 00:25:57
Pues, hombre, podríamos haber cambiado esto de aquí 00:25:58
Ya que nunca hemos usado el protector 00:26:01
Vamos a cambiarlo y lo usamos 00:26:03
Y así no le perdemos miedo 00:26:05
Podríamos haber puesto esto así 00:26:06
y ahora 00:26:09
el get y el set tienes que ofrecerlo igualmente 00:26:13
porque las clases 00:26:16
que no sean herederas de habitación 00:26:17
no van a poder acceder a esto, no van a poder 00:26:19
o sea, el get y el set tienes que ofrecerlo igualmente 00:26:21
pero al menos las que hereden de ti 00:26:23
como habitación familiar 00:26:26
pues hombre, ya no tienen que estar 00:26:28
con el get ahí todo el rato arrastrándolo 00:26:30
que queda más feo que nada 00:26:31
Así más bonito y más claro 00:26:33
Que tanto 00:26:40
¿Vale? Esa es la utilidad 00:26:41
Del protected 00:26:50
No hay que tenerle miedo 00:26:51
con el protected ya me olvido 00:26:53
de los get en las clases herederas 00:27:03
solo en las herederas 00:27:06
vale, la habitación familiar necesita 00:27:07
algo más, aparte de las camas dobles 00:27:11
biberones, cambiadores 00:27:13
pues no, camas dobles, ya está 00:27:17
ya hemos acabado con la habitación familiar 00:27:19
vale, sobre habitaciones parece ser 00:27:21
que no necesita más este 00:27:24
gestionador de aplicaciones 00:27:26
pero resulta que lo que sí que tiene que hacer 00:27:27
es gestionar reservas 00:27:30
parece ser, pues venga 00:27:31
la reserva 00:27:34
¿por qué se caracteriza? uno con su papel y su boli 00:27:36
y con los otros al lado 00:27:38
va pensando, a ver, realmente que me interesa 00:27:40
a mí de las reservas 00:27:42
y trata de llegar a 00:27:43
conclusiones 00:27:45
realistas, no meter propiedades 00:27:47
que luego no interesan o no quedarse 00:27:50
sin una propiedad que falte, no, no 00:27:51
hacer un buen análisis, fundamental 00:27:53
bueno, pues el que hizo el análisis 00:27:55
llegó a la conclusión de que con la fecha 00:27:57
el número de habitaciones 00:27:59
reservadas y el número de personas 00:28:01
tenía suficiente 00:28:03
para dar completamente por caracterizada 00:28:05
una reserva 00:28:08
con eso, ya está 00:28:09
fecha, habitación y número de personas 00:28:10
ni nombre, ni teléfono, ni nada 00:28:13
con eso ya lo tiene todo, caracterizan 00:28:15
la reserva, venga, pues ahora 00:28:17
Vamos a hacernos reserva 00:28:19
Reserva ni hereda de habitación ni heredada de nada 00:28:20
Porque reserva es un concepto que no tiene nada que ver 00:28:23
Con habitación 00:28:26
Luego reserva es una clase que va por libre 00:28:26
Pues a la reserva 00:28:28
Hemos dicho que la reserva 00:28:33
Se caracteriza por 00:28:42
La fecha 00:28:44
¿Vale? 00:28:45
de nuevo 00:28:49
la fecha 00:28:52
este sería el objeto estándar 00:28:53
¿vale? 00:28:57
que es fecha 00:29:00
luego está este también 00:29:01
¿vale? 00:29:04
que tenéis especificado 00:29:07
un poquito como funciona 00:29:10
aquí ¿vale? 00:29:12
un poquito como funciona 00:29:14
lo que pasa es que 00:29:15
local date no se nutre 00:29:18
de un string como date 00:29:19
date se nutre de un string, entonces construirlo 00:29:22
desde el teclado 00:29:24
es más fácil, este no se nutre 00:29:26
de un string, se nutre de 00:29:28
unos números por separado 00:29:29
que representan el año 00:29:32
el mes y el día 00:29:34
son clases distintas, clases distintas 00:29:35
para trabajar con fechas, vale 00:29:38
entonces bueno, como esta está especificada aquí 00:29:40
y date ya la hemos usado en el otro ejercicio 00:29:42
pues vamos a usar local date 00:29:44
vale 00:29:46
local date es una clase 00:29:47
local date es una clase más 00:29:49
de todas las que hay 00:29:51
para guardar objetos fecha 00:29:53
pues esto es la fecha de la reserva 00:29:55
a la fecha 00:29:58
reserva local date, ya está 00:29:59
entonces local date 00:30:01
habrá que importarlo del paquete correspondiente 00:30:05
¿vale? que está en 00:30:08
java time 00:30:09
cuando el tema es que cuando en java útil 00:30:12
es el paquete de toda la vida 00:30:15
hay un montón de cosas en Java útil 00:30:17
un montón de cosas, está el escáner 00:30:19
está el date, hay una especie de 00:30:21
caja en la que hay un montón de utilidades 00:30:24
luego claro, según van evolucionando 00:30:25
los JDKs 00:30:28
desde el 2, que fue el primer 00:30:29
Java ya que se implantó, el Java 2 00:30:31
original, hasta el 21 00:30:33
que hay ahora 00:30:36
pues en la caja empezaron a 00:30:37
entrar cosas 00:30:39
y a salir, por ejemplo, uuuh cuánta morralla 00:30:40
fuera, fuera, entrar y a salir 00:30:43
entonces cuando ya, pues se vio que es que 00:30:45
lo de las fechas, se podían incorporar 00:30:47
muchas funcionalidades, muchas historias 00:30:49
pues ya se dijo, mira 00:30:51
vamos a hacer un paquete específico para fechas y horas 00:30:53
que se llame JavaTime 00:30:56
y hacemos un específico para fechas y horas y se meten en JavaTime 00:30:57
¿vale? pero JavaUtil sigue siendo 00:31:00
una caja en la que hay utilidades de todo tipo 00:31:01
de fechas, de lecturas, de todo 00:31:03
¿vale? y no se pueden sacar las cosas 00:31:05
alegremente, porque todos los proyectos que había 00:31:07
con Date, ¿qué haces? 00:31:09
¿fuerzas todos a recompilarlos? pues a lo mejor 00:31:11
no es tan fácil 00:31:13
Entonces si uno hace un proyecto nuevo 00:31:14
Pues sería deseable que usara Java Time 00:31:19
Pero se va a encontrar 00:31:21
Muchísimos con Date 00:31:23
Porque es la de toda la vida que está en Java útil 00:31:25
Esa caja genérica 00:31:27
Que tiene de todo 00:31:29
Venga, pues ala, fecha reserva 00:31:30
¿Qué más cosas había ahí? 00:31:33
Número de personas 00:31:37
Y no sé qué otras historias 00:31:38
Ya está 00:31:40
Ah, bueno, el número de habitaciones y número de personas 00:31:46
Venga 00:31:49
Vale 00:32:00
Vale, en los nombres de variables 00:32:00
No seáis rácanos 00:32:01
Vale, yo ya soy a veces demasiado 00:32:03
¿Perdón? 00:32:05
No te he oído 00:32:09
Ah, ya, ya 00:32:09
Sí, o sea, justo estaba diciendo 00:32:15
Que yo estoy siendo un poco rácana 00:32:17
Incluso para no 00:32:18
Hombre, para no estar aquí escribiendo dos horas 00:32:20
Porque ahora mismo lo que estamos haciendo es sobre la marcha 00:32:23
Un poco todo conjuntamente 00:32:25
Pero en general no sois rácanos 00:32:27
Si creéis que un nombre de 80 caracteres 00:32:30
Es más claro 00:32:32
Que uno de 40, pues elegís el de 80 00:32:34
No pasa nada 00:32:36
Pero si luego con autocompletar se va a escribir todo solo 00:32:38
Pero bueno, lo vamos a ver 00:32:40
Yo lo voy a dejar así y ya está 00:32:42
Venga, constructores con parámetros 00:32:44
Y Getty Set 00:32:49
¡Hala! Ya está 00:32:56
y los constructores 00:33:04
venga, paso de tu stream 00:33:10
porque es que estamos aquí dos horas con cada cosa 00:33:13
y como ya sabéis de que va el rollo 00:33:16
venga, pues ala 00:33:17
la reserva se acabó 00:33:19
constructores, pues ya los tenemos 00:33:20
vale, que funcionalidades 00:33:22
de esta aplicación después de haber 00:33:26
hecho el análisis 00:33:27
tienen que ver exclusivamente 00:33:28
con la reserva o tienen que ver directamente 00:33:31
con la reserva 00:33:33
pues me dice aquí comprobar disponibilidad. 00:33:34
A ver. 00:33:40
Si entendemos este método. 00:33:44
Recibe una fecha. 00:33:47
Habitaciones reservadas. 00:33:52
El método no me gusta a mí mucho como está elegido, 00:33:54
pero comprobar disponibilidad. 00:33:57
bueno, venga, como está así pedido 00:33:58
vamos a dejarlo así 00:34:06
la idea de comprobar disponibilidad es 00:34:06
te da una fecha 00:34:09
y te dice 00:34:11
si la reserva 00:34:14
que llama a comprobar disponibilidad 00:34:16
es para esa fecha 00:34:18
o no 00:34:20
y en el caso de que 00:34:21
sea para esa fecha, te dice las habitaciones 00:34:24
reservadas 00:34:26
¿Vale? Bueno, un poquito raro 00:34:26
Pero 00:34:29
Se me hace a mí al menos un poquito raro 00:34:30
Pero bueno 00:34:35
Venga, pues método, comprobar disponibilidad 00:34:35
Comprueba disponibilidad 00:34:38
Recibe una fecha 00:34:47
Y te dice, a ver, la idea es ver 00:34:50
Si la reserva 00:34:53
si tú tienes un montón de reservas 00:34:55
y te dan una fecha 00:34:57
pues la idea sería que tú vas iterando en las reservas 00:34:59
a ver si encuentras una para esa fecha 00:35:01
y si la encuentras, pues cuántas habitaciones 00:35:03
tiene ocupadas, y si no encuentras ninguna 00:35:05
porque todas son null, pues te dices, a ver, esta fecha 00:35:07
efectivamente no tiene ninguna reserva 00:35:09
es la idea de este método, en principio 00:35:11
¿no? 00:35:13
que no es tanto usarlo para una sola 00:35:15
reserva, sino te dan una fecha, tienes tu 00:35:17
array de reservas y vas 00:35:19
comprobando una por una, esta reserva 00:35:21
está disponible, está, está, está 00:35:23
es la idea 00:35:25
pero claro, hay que pasar la fecha para comprobarlo 00:35:26
hay que pasar la fecha 00:35:29
bueno, pues si estamos trabajando con local date 00:35:30
pues ala 00:35:33
local date 00:35:35
pasamos la fecha a comprobar 00:35:36
y ahora 00:35:38
lo que me dice el método 00:35:40
es para esta reserva, tengo que comprobar 00:35:43
si está hecha en esa fecha, ¿verdad? 00:35:45
¿vale? si está hecha en esa fecha 00:35:50
si no lo es 00:35:51
devuelve null 00:35:59
y si lo es, devuelve habitaciones reservadas 00:36:01
vale, pues aquí 00:36:02
¿qué es lo que haríais? 00:36:04
¿qué es lo que haríais? 00:36:08
¿qué es lo que has hecho aquí en este método? 00:36:09
Diego, vamos, no estoy poniendo nada raro 00:36:11
¿qué es lo que haríais? 00:36:12
comparar esto 00:36:16
con la fecha de arriba 00:36:17
¿no? 00:36:19
Compararlos 00:36:20
¿Cómo lo compararíais? 00:36:22
Claro, son objetos 00:36:27
Cuidado, no los compararíamos con doble igual 00:36:29
Obviamente, son objetos 00:36:31
Entonces, queremos creer 00:36:32
Queremos creer 00:36:36
Que la clase local date 00:36:37
Tendrá un equals 00:36:39
Correctamente sobre escrito de object 00:36:41
De tal forma que 00:36:43
Si yo le paso una fecha local date por aquí 00:36:45
Y otra fecha local date por aquí 00:36:47
objetos distintos, se los paso 00:36:49
ese equals 00:36:51
se me va a volver true 00:36:53
si mes, día y año son iguales 00:36:54
queremos creer que haya 00:36:57
habrá un equals sobrescrito en 00:36:59
local date, ¿no? 00:37:01
es de esperar 00:37:04
que el que hizo la clase local date 00:37:05
y la metió en java time, el que hizo la clase 00:37:07
pensó 00:37:09
a ver, ¿cuál es el criterio de igualdad de fechas? 00:37:10
pues el criterio de igualdad de fechas es que 00:37:14
sean iguales meses, días, años, pues me voy a 00:37:15
sobrescribir el equals de object 00:37:17
porque local date le dará 00:37:19
entre, al menos de object 00:37:21
otra cosa es que hay algunas entre medias 00:37:23
pero de object le dará, pues queremos 00:37:25
creemos, queremos creer 00:37:27
que hay un equals aquí, que yo le paso 00:37:29
dos objetos fecha y me devuelva 00:37:31
si son iguales comparándome el día y año 00:37:33
¿verdad? entonces aquí 00:37:35
uno podría confiar en el sentido común 00:37:37
y aplicarlo sin más y seguramente 00:37:39
acertemos, o podría uno 00:37:41
ante la más mínima duda, cuando 00:37:43
se están usando clases que no ha hecho él 00:37:45
que es el 90% del tiempo 00:37:47
irse a la documentación y buscarlo 00:37:48
¿cómo comparo yo dos local date entre sí? 00:37:51
y seguramente te diga, hombre, pues un equals 00:37:53
que para eso está 00:37:55
¿vale? 00:37:56
entonces 00:38:00
aquí por ejemplo, en esto que está incorporado 00:38:00
¿vale? 00:38:03
y lo miro 00:38:14
porque si sale de... 00:38:15
Pues, venga, entonces, ¿qué haríais aquí? 00:38:17
Si la fecha que me han dado resulta que es igual a, ¿quién? 00:38:19
A fecha de la reserva, entonces, ¿qué tenemos que hacer? 00:38:27
Dime. 00:38:32
No, no, no, a ver, es que ahora mismo no, no. 00:38:34
Lo que he dicho antes del for es que se supone que el uso de esto será para eso. 00:38:37
Pero este método, pero este método ahora mismo está en la clase reserva. 00:38:41
Y este método aplica para una única reserva. 00:38:44
O sea, este método le va a llamar una reserva, le va a llamar una. 00:38:47
Otra cosa es que luego tú llames ese método para todas las de una 00:38:49
RAID, pero eso ya en un main cuando se haga. 00:38:53
Este método está en la clase reserva para que le llame una 00:38:56
reserva. 00:38:58
Y entonces comprobará la fecha parámetro con la fecha de esa 00:38:59
reserva. 00:39:04
Si son iguales, es que entonces tenemos esa fecha reservada 00:39:05
para esta reserva y tendremos que devolver, hemos dicho, 00:39:10
el número de habitaciones reservadas, ¿verdad? 00:39:14
el número de habitaciones reservadas que lo tenemos aquí 00:39:17
era eso el número de personas 00:39:20
vamos a ver lo que nos devolvía el método 00:39:22
devuelve las habitaciones 00:39:24
no las personas 00:39:33
pues entonces 00:39:34
este método nos devuelve 00:39:36
num 00:39:39
no me acuerdo como se llama, si que lo hago con dis 00:39:40
para que me salga 00:39:43
num habitaciones 00:39:44
¿Vale? 00:39:46
Y si no 00:39:50
Y si no 00:39:51
¿Qué ha dicho que devuelve? 00:39:54
El método este no lo he puesto a propósito 00:39:59
Este no lo he puesto a propósito 00:40:01
Porque es que ahora viene la amiga 00:40:02
¿Vale? 00:40:04
Ha dicho, devuelve 00:40:05
¿Dónde estamos? 00:40:07
Null 00:40:13
Si la reserva no es de ese día 00:40:14
o habitaciones reservadas 00:40:15
que es un número entero 00:40:18
si la fecha indicada es la que pertenece 00:40:19
a esta reserva 00:40:22
entonces, si no 00:40:23
devuelve null 00:40:25
y aquí lo dejo apuntado solo 00:40:27
y paramos, y aquí ya es donde 00:40:30
se nos cruzan un poco los cables, ¿no? 00:40:32
o no se os han cruzado 00:40:34
a lo que lo habéis hecho, a ti Diego 00:40:35
aquí se nos han cruzado porque decimos, vamos a ver 00:40:37
esta habitación devuelve 00:40:39
perdón, este método devuelve 00:40:42
un entero, si esto coincide. 00:40:44
Estamos sobreentendiendo 00:40:46
que el equals hace lo que yo creo. 00:40:48
Si luego vemos que no lo hace, pasando las pruebas, 00:40:49
el test y lo que sea, tendremos que buscar otro método 00:40:51
que compara las fechas. Tendremos que buscarlo. 00:40:53
¿Vale? 00:40:56
Entonces, estamos 00:40:58
que si la fecha reservada 00:40:59
es igual que la que me pasan, 00:41:01
devuelvo un numerito entero. Entonces, esto nos haría 00:41:03
pensar que el valor 00:41:06
de retorno es int, ¿verdad? 00:41:08
Que lo que yo tengo que poner aquí es int. 00:41:10
Nos haría pensar esto. 00:41:12
pero me están diciendo 00:41:14
oye, si no coincide devuélveme un nul 00:41:17
aquí es donde se nos va la olla 00:41:20
y decimos, pero espérate, ¿cómo que nul? 00:41:22
una variable primitiva nunca puede tener nul 00:41:24
porque nul es un valor solo para tipos objetos 00:41:27
solo las variables objetos pueden ser nul 00:41:31
solo, las variables primitivas no 00:41:33
entonces, ¿cómo podemos resolver esto? 00:41:36
¿cómo lo podemos resolver? 00:41:40
si yo necesito devolver un número entero 00:41:41
pero quiero a veces indicar 00:41:44
que eso sea nul, que esté vacío 00:41:46
con una variable primitiva no podemos 00:41:48
indicar vacío, una variable primitiva 00:41:50
siempre va a tener algo, o menos 1 o menos 2 00:41:52
o 0 o 3 o 4, no puede tener vacío 00:41:54
a diferencia de un objeto 00:41:56
que un objeto sí puede tener vacío 00:41:58
entonces aquí se nos presenta un problema 00:41:59
y es 00:42:01
el tipo de dato que ponemos aquí 00:42:03
para que le caiga tanto un numerito entero 00:42:06
como un nul que es incompatible con el primitivo 00:42:08
¿A alguien alguno se le ha ocurrido una forma de solucionarlo? 00:42:10
¿Alguien que lo haya hecho? 00:42:20
Diego, por ejemplo. 00:42:22
No, tiene que ser lo que devuelva. 00:42:29
Pues no. 00:42:31
Pues efectivamente hay que resolver esto. 00:42:31
Y para resolver esto, para resolver esto, están los envolventes. 00:42:33
o los rappers 00:42:39
que 00:42:40
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
15 de febrero de 2024 - 19:45
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
42′ 46″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
204.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid