Saltar navegación

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

Clase 13-02-24 - 2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 15 de febrero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues os habréis quedado efectivamente 00:00:00
con la gran incógnita de qué pasa aquí. 00:00:02
Y es que efectivamente es una situación 00:00:04
que se nos puede dar. 00:00:06
Necesitamos un dato 00:00:09
que el mejor sitio para guardarlo 00:00:10
es una variable primitiva, 00:00:14
como un numerito entero, 00:00:15
como un numerito decimal. 00:00:17
El mejor sitio es una variable primitiva, 00:00:19
un int, un short, un byte, un double. 00:00:21
Pero también quiero poder guardar 00:00:24
la posibilidad de que esa variable 00:00:27
no tenga nada, esté vacía 00:00:29
eso con una variable 00:00:31
primitiva no se puede, si yo declaro 00:00:33
un int, ese int siempre va a tener algo 00:00:35
porque va a tener bits, va a tener ceros 00:00:37
o uno o menos dos, no existe 00:00:39
el concepto de nada 00:00:41
en una variable primitiva, sí que 00:00:43
existe en variable objeto, pero no existe en variable 00:00:45
primitiva, luego en situaciones 00:00:47
como esta nos quedamos que no tenemos 00:00:49
una variable que se adapta 00:00:51
no pasa nada, se inventa 00:00:53
se inventa 00:00:55
¿vale? pues eso es lo que se ha hecho Java 00:00:57
inventarse esto, se ha inventado una cosa 00:00:59
que se llaman 00:01:01
creo que lo mencionamos alguna vez al principio de curso 00:01:02
cuando vimos las primitivas, pero lógicamente 00:01:05
lo tendréis olvidado 00:01:07
dije, ya esto ya volveremos 00:01:08
a ello cuando veamos objetos, bueno, pues 00:01:11
hemos vuelto a ello el 13 de febrero 00:01:13
bueno, pues Java 00:01:15
efectivamente, para solucionar este tipo 00:01:17
de situaciones, todo tiene 00:01:19
una motivación, todo se hace por algo 00:01:21
¿vale? no estudiéis diciendo esto, esto 00:01:22
esto, no, todo está motivado por una razón 00:01:25
si entendemos por qué está motivado 00:01:27
se nos encenderá la lucecita 00:01:29
de cuándo aplicarlo más rápido 00:01:31
¿vale? tú me vas a decir algo 00:01:32
que te he congelado, ¿verdad? 00:01:34
perdón 00:01:37
quítate 00:01:37
vale 00:01:40
bueno, pues Java entonces 00:01:43
motivado por esta situación 00:01:45
se inventa 00:01:47
los 00:01:51
wrappers 00:01:58
o envolventes, como os guste a vosotros llamarles. 00:02:01
¿Y qué son los envolventes? 00:02:05
Pues son tipos objetos 00:02:07
diseñados 00:02:09
para guardar dentro 00:02:11
variables primitivas. 00:02:12
Entonces, cada tipo primitivo 00:02:15
tiene un tipo objeto envolvente 00:02:17
asociado, por ejemplo 00:02:19
vamos a 00:02:21
me voy a hacer yo aquí 00:02:22
en paralelo mi main de pruebas 00:02:24
para las chorraditas que nos vayan saliendo 00:02:27
me voy a hacer aquí mi main 00:02:28
de pruebitas para las chorraditas 00:02:33
¿vale? jolines 00:02:35
tengo que quitar esto para que no me saque el constructor 00:02:38
todo el rato 00:02:41
vale, pues entonces 00:02:41
está claro esto como se usa 00:02:45
yo tengo una variable entera 00:02:47
en la que puedo meter un numerito entero, lo que quiera. 00:02:49
Eso está claro. 00:02:51
Vale, pero es que tengo asociado a cualquier tipo primitivo, 00:02:52
in double float, tengo el envolvente correspondiente, 00:02:56
el grouper. 00:02:59
¿El envolvente de lint cuál es? 00:02:59
Este. 00:03:02
Este es. 00:03:05
Este es el tipo de dato y este es un tipo de dato objeto. 00:03:07
Un tipo de dato objeto. 00:03:11
Y yo puedo declararme una variable objeto así. 00:03:13
¿Vale? 00:03:16
Entonces esta es una variable de tipo objeto 00:03:16
¿Y para qué sirve? 00:03:19
Sirve para guardar un número entero 00:03:21
Para eso sirve 00:03:23
Pero aquí lo guardaré en modo objeto 00:03:24
Y aquí lo guardo en modo primitivo 00:03:27
Pero el valor que guarda es lo mismo 00:03:29
Es un número 00:03:31
Lo que pasa es que aquí lo guarda en modo objeto 00:03:32
¿Qué gano? 00:03:34
Gano dos cosas 00:03:36
Primero, poder guardar la idea de que ahí no hay nada 00:03:37
Aquí es imposible 00:03:40
Guardar la idea de que ahí no hay nada 00:03:42
No se puede 00:03:45
en una variable primitiva no puedo meterle 00:03:45
nada, pero en una variable 00:03:48
objeto como esta sí 00:03:50
y yo puedo hacer 00:03:52
n2 igual a nul 00:03:53
esto sí que puedo 00:03:56
porque n2 00:03:58
es un tipo objeto 00:04:00
esto sí que puedo hacerlo 00:04:01
y con esto diré, oye que el numerito n2 no tiene nada 00:04:02
fenomenal, no tiene nada 00:04:06
aquí el numerito n no podría 00:04:07
decir, ¿tiene algo? ¿no tiene nada? 00:04:10
no, siempre va a tener algo, siempre 00:04:12
es un tipo objeto, o sea, no es como un string 00:04:14
porque guarda otra cosa, pero efectivamente 00:04:18
es un tipo objeto como un string 00:04:20
entonces, gano la posibilidad de que tenga null 00:04:22
como el string, que también puede tener null 00:04:24
puede decir, no tengo nada, no tengo ningún texto 00:04:26
pues esto igual, esto puede 00:04:28
no tener nada 00:04:30
y también gana el que 00:04:31
al ser objeto, tiene métodos 00:04:34
el que hizo la clase integer, ya de hecho le metió métodos 00:04:36
pues si uno quiere hacer cosas con numeritos 00:04:38
entonces, pues si uno 00:04:40
los cotillea, pues bueno 00:04:42
aquí tiene métodos para hacer cosas 00:04:44
con los enteros, ya hemos usado 00:04:46
uno, muchas veces 00:04:48
¿no recordáis que 00:04:50
a veces cuando queríamos convertir 00:04:52
una cadena a entero 00:04:54
hacíamos esto? 00:04:56
pues este es 00:05:05
un método estático 00:05:06
de la clase íntegra 00:05:08
es estático porque lo llamo con el nombre de la clase 00:05:10
¿y qué hace este método estático de la clase 00:05:12
íntegra? le paso una cadena 00:05:14
y me lo devuelve en el 00:05:16
número entero que representa 00:05:18
entonces, esta llamada 00:05:20
ya la hemos usado otras veces cuando 00:05:22
leíamos del teclado y queríamos pasar a entero 00:05:24
o algo así 00:05:26
vale, ya lo hemos hecho otras veces 00:05:27
entonces, la clase íntegra 00:05:32
esta de aquí me vale para dos cosas 00:05:34
primero, para guardar un número 00:05:36
entero pero en modo objeto 00:05:38
de forma que yo pueda 00:05:39
meterle un null también si me da la gana 00:05:41
y también me vale 00:05:43
porque tiene métodos dentro para hacer cosas 00:05:45
entonces mi objeto 00:05:47
n de arriba no puede 00:05:49
llamar a métodos, es imposible porque es una variable 00:05:51
primitiva y las variables primitivas no pueden 00:05:53
llamar a métodos, pero mi variable 00:05:55
claro que puede llamar a métodos 00:05:58
entonces tengo 00:06:01
utilidades ahí, que me he sacado de la manga 00:06:03
solo porque n2 está en tipo objeto 00:06:05
entonces yo a n2 00:06:07
por ser de tipo objeto 00:06:08
aunque sea un numerito lo que tiene 00:06:12
porque tiene un número 00:06:14
n2 tiene cosas a las que puedo llamar 00:06:15
pues convertirlo 00:06:18
en double 00:06:20
ver si es igual que otro número 00:06:21
pero bueno eso con el doble igual del primitivo 00:06:24
también, pues bueno tiene unos metoditos para hacer 00:06:26
cosas con él, convertirlo a float 00:06:28
cosas que yo no puedo hacer con la 00:06:30
variable primitiva n 00:06:32
bueno pues con esta variable por ser objeto 00:06:33
puedo hacer dos o tres chorradas 00:06:35
pero a ver, sobre todo la utilidad 00:06:37
también son los métodos estáticos 00:06:39
la clase ínteger 00:06:41
tiene 00:06:43
métodos estáticos hechos 00:06:45
para ver cositas 00:06:47
¿no? pues me permite aquí comparar 00:06:50
dos números, a ver cuál es mayor o menor 00:06:53
chorradas 00:06:55
¿vale? me permite con esto 00:06:56
obtener el máximo valor entero a codificar 00:06:59
o el mínimo 00:07:01
la clase ínteger, bueno pues ya que 00:07:02
está hecha esa clase 00:07:05
Pues esa clase me permite 00:07:06
Acceder a utilidades 00:07:09
¿Vale? 00:07:11
Esta clase si uno la cotillea por aquí 00:07:12
Integer, pues bueno, tiene todas sus cosas 00:07:15
Y esta clase para lo que vale 00:07:17
Es para guardar en realidad 00:07:20
Un numerito 00:07:22
Un numerito que irá guardado en una variable 00:07:23
Que estará por ahí 00:07:26
Una int 00:07:28
Que estará por ahí 00:07:30
Que es la que guarda el numerito 00:07:32
¿Vale? 00:07:33
bueno 00:07:34
pues entonces 00:07:36
y lo que aplica para integer 00:07:38
aplica para cualquier variable primitiva 00:07:40
silencio 00:07:42
también existe el tipo envolvente 00:07:44
este de aquí 00:07:46
también existe este tipo 00:07:47
este tipo vale 00:07:49
para guardar un número double 00:07:51
pero guardarlo en modo objeto 00:07:53
guardarlo en modo objeto también 00:07:55
de forma que yo le pueda asignar un null 00:07:57
entonces los tipos integer 00:07:59
en realidad, o sea, todos los tipos 00:08:02
primitivos tienen todo su envolvente 00:08:04
que en todos los casos 00:08:06
el nombre de la clase es la misma que el primitivo 00:08:07
pero con mayúscula 00:08:11
salvo esta, que esta cambia un poco más 00:08:12
pasa de índa a íntegra 00:08:15
pero las demás son el short, tiene el short 00:08:16
con la S mayúscula, el float tiene el float 00:08:18
con la F mayúscula 00:08:20
esta es la única que cambia un poco el nombre 00:08:22
¿vale? entonces, trabajar 00:08:24
con los, la clase está hecha 00:08:26
para que uno pueda pasar 00:08:28
fácilmente de uno a otro, incluso 00:08:30
sin casting y sin nada 00:08:32
igual que al string 00:08:33
al string le podemos asignar una cadena de texto 00:08:36
aunque sea objeto, sin ponerle new string 00:08:38
pues integer también está hecha 00:08:40
para permitir trabajar 00:08:42
con primitivos 00:08:44
integrar fácilmente 00:08:45
por ejemplo yo a este 00:08:49
le puedo asignar el n 00:08:51
directamente 00:08:52
puedo hacer esto 00:08:53
n es un primitivo 00:08:56
y se lo estoy asignando a este tipo entero 00:08:58
pero esta clase ya está pensada 00:09:00
para que lo que hace entonces es 00:09:02
coge este número primitivo 00:09:04
crea el objeto, crea el objeto 00:09:06
integer y mete este numerito 00:09:08
dentro, vale, ya está 00:09:10
pensada para darnos esa facilidad de uso 00:09:12
no tener que instanciarlo 00:09:14
todo el rato con new integer y nada de eso 00:09:16
como la string, que no la instanciamos 00:09:18
con new string porque es un rollo 00:09:21
a la string 00:09:22
le hacemos esto 00:09:24
siempre 00:09:26
¿Verdad? 00:09:30
Podríamos hacer esto también. 00:09:32
Y estaríamos haciendo lo mismo que arriba. 00:09:42
Lo mismo. 00:09:44
Pero, hombre, la clase string, ya dijimos que como se usa tanto, 00:09:46
nos facilita las cosas para poder yo instanciarla así. 00:09:49
Pues, está igual. 00:09:53
No es necesario que yo haga el new integer ni nada. 00:09:54
la puedo instanciar directamente dándole 00:09:56
el número entero que contiene 00:09:59
y así sobre la marcha uno puede comprobar 00:10:01
que es muy flexible 00:10:03
que puede comparar y integrar 00:10:04
y enteritos 00:10:07
sin hacer casting 00:10:09
con otro, etcétera 00:10:11
bueno, pues entonces 00:10:13
esta, esto nos resuelve 00:10:15
este problema 00:10:18
que teníamos aquí 00:10:19
¿verdad? 00:10:20
¿qué tipo de dato le ponemos 00:10:22
a este método? 00:10:25
yo tengo que volver un número 00:10:26
o también la posibilidad de volver null 00:10:28
si es que 00:10:30
no se cumple la condición 00:10:32
pues ya está, entonces ínteger es la que le pega 00:10:34
¿vale? 00:10:36
es la que le pega y un pedazo de ínteger 00:10:38
pues venga 00:10:39
le ponemos un 00:10:41
ínteger y listo 00:10:46
¿vale? 00:10:48
solucionado ese ínteger será null 00:10:50
o será un valor entero 00:10:52
que es el número de habitaciones reservadas 00:10:54
para esta fecha 00:10:56
¿vale? y ahora ya ese método 00:10:57
la clase principal main lo usará 00:11:00
como quiera, pues tendrá 00:11:02
un montón de reservas, para cada reserva 00:11:04
comprobará la disponibilidad para cada una 00:11:06
de ellas, para una fecha 00:11:08
obtendrá las habitaciones para esa fecha 00:11:10
ya la clase main lo que sea 00:11:12
ahora mismo lo que vemos 00:11:14
es simplemente es un método que 00:11:16
dada una reserva concreta, dada una reserva 00:11:17
mira si para esa reserva 00:11:21
la fecha es esta 00:11:22
si lo es devuelve las habitaciones 00:11:23
y si no lo es, devuélvelo, ya está 00:11:25
pues hala 00:11:28
la clase reserva 00:11:31
parece que 00:11:36
está 00:11:39
vale, comprueba disponibilidad 00:11:41
ya está, ahora ya viene 00:11:48
el hotel 00:11:50
pues bueno, el hotel 00:11:51
lo mismo, después de hacer el análisis 00:11:56
toda la historieta nos dicen 00:11:58
del hotel lo único que nos interesa 00:11:59
guardar es 00:12:01
el conjunto de habitaciones que tiene 00:12:03
y el conjunto de reservas que tiene 00:12:06
el único que nos interesa es el hotel, nos da igual la dirección 00:12:08
donde está, el nombre 00:12:10
la verdad es que es un poco feo eso 00:12:11
vamos a ponerle un nombre por lo menos 00:12:14
es que tanto tanto simplificar 00:12:15
vamos a darle un sentido más real 00:12:18
venga, vamos a añadirle un nombrecito 00:12:19
más que nada por facilitar, si luego hacemos un main de prueba 00:12:21
para probar esto, que aquí no está incorporado 00:12:24
si luego hacemos un main de prueba 00:12:26
pues hombre, crear un hotel con un nombre, algo así 00:12:27
venga, vamos a hacer 00:12:30
la clase hotelillo 00:12:32
a ver 00:12:33
La clase hotel 00:12:49
La clase hotel, vamos a ponerle un nombre 00:12:55
No hijo, no, eso eran tus sueños 00:12:57
Ah no, habitación, perdón 00:13:03
Vale, nombre del hotel 00:13:05
Eh, jolines, es que 00:13:10
No quito eso en la pestaña 00:13:13
Y me sale y lo meto siempre donde no es 00:13:16
Ahí, vale, ya está 00:13:19
Vale, hotel 00:13:21
Tampoco hereda de nadie 00:13:23
Esto es un desmadre 00:13:24
Pues venga, vamos a ponerle un constructor 00:13:26
Ah, bueno, me faltan los otros dos parámetros 00:13:28
Número de habitaciones 00:13:30
Vale, a ver si ya 00:13:33
Ahora mismo 00:13:35
A ver si nos quitamos ya los arrays de encima 00:13:36
Ahora mismo 00:13:39
No nos queda más remedio que guardar 00:13:41
Un conjunto de cosas en un array 00:13:43
Porque es que no sabemos otra cosa 00:13:44
Pues ala 00:13:45
Las habitaciones ahí 00:13:48
Y las reservas 00:13:50
Ahí 00:13:54
Reservas 00:13:59
El hotel solo nos interesa eso 00:14:04
Su nombre, las habitaciones que tiene 00:14:08
Y las reservas que tiene 00:14:10
Se acabó 00:14:11
Vale, aquí de nuevo 00:14:12
los famosos 00:14:14
null pointer exception 00:14:16
cuando el hotel arranca 00:14:18
si no inicializamos esto 00:14:22
a través del constructor 00:14:24
porque lo instanciamos por ejemplo así 00:14:25
pues 00:14:28
su conjunto de habitaciones 00:14:30
es un objeto null 00:14:32
y su conjunto de reservas es un objeto null 00:14:33
no es que tenga un número de habitaciones 00:14:36
cero 00:14:38
y un número de reservas cero, no 00:14:39
es que directamente es null 00:14:41
no tiene ni capacidad para tener habitaciones y reservas 00:14:43
no pasa nada 00:14:46
el momento en el que le agreguemos la primera habitación 00:14:47
le creamos esa capacidad 00:14:50
le hacemos que ya no sea null 00:14:51
podría ocurrir 00:14:53
pero hombre, si ya directamente 00:14:55
inicializamos con un array 00:14:58
que aunque no tenga posiciones no sea null 00:14:59
pues seguramente nos evitemos 00:15:01
null pointer exception si es que 00:15:04
algo se nos escapa 00:15:06
más adelante y no reservamos 00:15:07
el objeto, etcétera 00:15:09
entonces hombre 00:15:12
no es que las cosas haya que hacerlas así 00:15:12
porque yo lo diga, yo lo que os trato 00:15:15
es de que entendáis las cosas 00:15:17
luego cada uno va seleccionando 00:15:19
en un momento determinado, en un contexto 00:15:21
determinado, pues qué es lo que quiere 00:15:23
hacer, bueno pues yo voy aquí 00:15:25
a crear ya 00:15:27
instanciar ya un array 00:15:29
instanciarlo ya, aunque no le voy a dar 00:15:30
todavía espacio para ninguna 00:15:33
habitación, porque el hotel de partida 00:15:35
no tiene habitaciones, ya se las iré yo 00:15:37
incorporando 00:15:39
lo único que he arreglado con esto 00:15:40
evito lo único que arreglo 00:15:43
es que ese objeto habitaciones 00:15:44
no sea null 00:15:47
y al no ser null 00:15:48
si alguien le hace un punto lenza así rápidamente 00:15:50
lo que sea, pues no le va a salir null.except 00:15:53
y la aplicación no se va a parar 00:15:55
porque el problema de las excepciones es 00:15:56
que si no se capturan con try-catch 00:15:59
correctamente 00:16:01
detienen la aplicación 00:16:02
y eso es lo último que queremos en una aplicación 00:16:04
lo que queremos en una aplicación es que 00:16:06
como mucho te diga 00:16:08
pues inténtalo más adelante 00:16:09
hay un error, pero que la aplicación no se pare 00:16:11
entonces no, queremos evitar 00:16:13
las excepciones 00:16:15
pues nada, aquí lo mismo, voy a evitar 00:16:16
un null, porque el null 00:16:19
pointer exception es 00:16:21
silencio por ahí 00:16:22
atrás, el null pointer exception 00:16:25
es muy desagradable 00:16:27
es muy desagradable 00:16:28
vale, venga, nos vamos a hacer un constructor 00:16:31
con parámetros, por si alguien quiere de partida 00:16:33
crear un hotel ya con 00:16:35
con su array de habitaciones, su array de reservas, etc. 00:16:37
Bueno, vamos a hacer un constructor con parámetros. 00:16:42
Este sería para hacer un hotel ya con un array enterito, 00:16:47
pisando entonces el que acabo de inicializar. 00:16:50
Con este array enterito, pisando el que acabo de inicializar. 00:16:53
Bueno, si alguien quiere hacer un hotel de partida ya con dos arrays concretos, 00:16:55
pues puedo usar este constructor. 00:16:58
Y aquí, en este caso, tendría muchísimo sentido 00:16:59
sentido hacer un constructor 00:17:05
solo con el nombre 00:17:07
para yo crear un hotel 00:17:09
con su nombre, por ahora sin 00:17:12
habitaciones ni reservas, que ya las haré más 00:17:13
adelante 00:17:15
¿vale? 00:17:16
bueno, y Getty Set, pues eso 00:17:20
sí que sí, si las he puesto privadas 00:17:21
ahí sí que 00:17:23
no hay otra 00:17:25
y bueno 00:17:27
vamos a hacer un to stream solo con el nombre 00:17:30
el hotel es patatín, que no 00:17:31
muestro lista de habitaciones y reservas 00:17:33
Porque nos vamos a volver locos 00:17:35
Vamos a hacer un toestring solo con el nombre 00:17:37
Le quitamos habitaciones y reservas 00:17:39
Un toestring 00:17:43
Que me muestre el nombre del hotel 00:17:45
Y ya está 00:17:47
Vale, esto describe el hotel 00:17:48
Lo describe 00:17:52
Nombre, habitaciones, reservas 00:17:53
Vale, pero que queremos hacer con el hotel 00:17:55
Que queremos hacer, queremos hacer reservas 00:17:57
Queremos meter las habitaciones, que queremos hacer con el hotel 00:17:59
Lo habremos decidido 00:18:01
después de toda esa sesión 00:18:03
de todas esas reuniones 00:18:05
con los que van a hacer la aplicación 00:18:08
y los que la han pedido, lo habremos decidido 00:18:10
y como aquí ya se ha decidido 00:18:11
pues nos dicen aquí 00:18:13
una serie de métodos para hacer 00:18:15
vale, a ver 00:18:17
tiene dos 00:18:21
tiene busca disponibilidad 00:18:24
y tiene un método 00:18:28
disponibilidad 00:18:32
son las dos únicas 00:18:32
funcionalidades que tiene el hotel 00:18:37
disponibilidad 00:18:38
recibe 00:18:41
una cantidad de personas 00:18:43
y un día 00:18:46
y tiene que mirar 00:18:47
si hay habitaciones libres 00:18:50
para todas las personas 00:18:52
es decir, si todas las personas tienen acomodo 00:18:54
no hace falta que sean la misma habitación 00:18:56
no hace falta 00:18:58
sino si tienen acomodo 00:19:00
en dos habitaciones diferentes, en lo que sea 00:19:01
¿vale? tienen acomodo 00:19:03
si no hay habitaciones, devuélvenlo 00:19:05
y si no, devuelve 00:19:10
una reserva, a ver, con una reserva 00:19:12
¿qué quiere decir esto? 00:19:13
bueno, devuelve una reserva o varias 00:19:19
con lo que yo he dicho, si yo interpreto 00:19:21
de ahí, si yo interpreto 00:19:23
que hay acomodo para todas 00:19:25
devolvería varias, podría devolver 00:19:27
varias, ¿verdad? No sé cómo lo habéis 00:19:29
hecho Miguel y Diego 00:19:31
este método. Habéis mirado si hay solo 00:19:33
una habitación para todas, ¿no? 00:19:35
No. Ah, vale, vale. 00:19:38
Ah, vale, sí, perdón, perdón, perdón, perdón, sí que 00:19:41
si hablar y pensar 00:19:43
me cuesta. O hablo 00:19:45
o pienso. Vale. 00:19:47
Vale, pues 00:19:51
entonces, buscar disponibilidad. 00:19:51
La reserva te dice 00:19:53
si hay 00:19:54
habitaciones libres y te devuelve 00:19:57
perdón, efectivamente una sola reserva 00:19:59
con las habitaciones que sean, las que hayan hecho falta 00:20:01
1, 2, 3, las que sean 00:20:03
¿vale? venga, pues entonces 00:20:04
busca disponibilidad 00:20:07
la cabecera del método será 00:20:08
la cabecera del método 00:20:11
será 00:20:15
te devuelve una reserva, que puede ser nulo o no 00:20:15
claro, te devuelve una reserva 00:20:21
eso está claro 00:20:23
busca disponibilidad 00:20:23
Y que recibe un número de personas. 00:20:29
Y recibe una fecha. 00:20:36
Fecha. 00:20:51
Recibe esto. 00:20:54
Entonces. 00:20:57
Tendrá que buscar 00:20:59
A ver 00:21:02
Cada habitación tiene 00:21:05
En función de las habitaciones que sea 00:21:11
Las camas que tiene y todo eso 00:21:14
Entonces 00:21:15
Y tendrá que buscar 00:21:17
La reserva tiene 00:21:18
El número de habitación 00:21:20
Vale 00:21:23
Pues tendrá que buscar 00:21:25
Si hay 00:21:27
en esa fecha 00:21:28
habitaciones dentro de la RAI 00:21:31
de habitaciones que no tengan 00:21:33
reserva en las que quepan todas esas 00:21:35
personas, ¿vale? 00:21:37
Es decir, no es un método 00:21:39
fácil de plantear. 00:21:40
Es un método retorcido, ¿vale? 00:21:44
Vale, pues entonces 00:21:47
ahora 00:21:48
más o menos yo creo que 00:21:51
la estructura de la aplicación, las clases que tiene 00:21:54
y lo que tiene que hacer este método está claro. 00:21:57
Ahora lo que hay que pensar es cómo plantearía uno ese método. 00:22:00
¿Cómo lo plantearía uno? 00:22:02
Con los datos que tiene. 00:22:04
El hotel, para buscar la disponibilidad, 00:22:05
tiene estos datos. 00:22:09
Tiene 00:22:10
el número de personas a alojar, 00:22:10
el número de personas y la fecha. 00:22:17
Y tiene que navegar 00:22:20
por sus habitaciones 00:22:21
en las que sabe cuántas personas caben 00:22:23
en cada habitación, dependiendo de si 00:22:26
las que saben en cada habitación 00:22:28
y por las reservas 00:22:30
tiene que navegar por ambas cosas, por habitaciones y reservas 00:22:32
¿vale? 00:22:35
y si encuentra acomodo 00:22:36
creará una reserva nueva 00:22:38
creará una reserva nueva 00:22:40
¿vale? creará una reserva nueva 00:22:42
con las 00:22:44
habitaciones 00:22:47
y personas ¿vale? 00:22:48
un momentito que me entra a mi la duda de si 00:22:51
el número de habitaciones es de las habitaciones de la reserva 00:22:52
o el número de habitación de la reserva 00:22:54
un momentito, a ver 00:22:56
claro, es que me ha entrado 00:22:58
mi duda al verlo, a ver 00:23:00
reserva 00:23:03
no, habitaciones reservadas 00:23:08
claro, ah, habitaciones 00:23:10
reservadas, vale, vale, vale, habitaciones 00:23:12
reservadas 00:23:15
vale, habitaciones reservadas 00:23:16
entonces es 00:23:18
varias, pero el número de 00:23:19
cada una, ¿cómo guardaríamos esta propiedad? 00:23:22
Sí, o sea, yo la he interpretado 00:23:26
así muy alegremente según lo iba leyendo 00:23:31
¿Número de habitaciones? Pues tres habitaciones reservadas 00:23:33
Pero no 00:23:35
Habitaciones reservadas entiendo que se refiere 00:23:39
a la habitación 00:23:41
1, la 7 y la 12 00:23:43
Luego habitaciones reservadas 00:23:45
¿En qué tipo de datos 00:23:48
lo tendríamos que guardar? 00:23:51
En una raíz de enteros 00:23:54
¿Verdad? 00:23:55
Habitaciones reservadas son la 7, la 12 y la 15 00:23:56
La 4, la 9 o la 10 00:23:58
La 3 y la 8 00:24:00
La 9 y la 5 00:24:02
¿Verdad? 00:24:03
Es decir, una raíz de números 00:24:07
Una raíz de números de habitaciones 00:24:08
¿Verdad? 00:24:10
¿Sí? ¿Vale? 00:24:12
Habitaciones reservadas 00:24:17
Fecha y número de personas 00:24:19
Vale, pues entonces 00:24:22
esto 00:24:23
tendría que ser 00:24:29
así 00:24:36
y ahora esto simplemente cambia 00:24:40
el constructor 00:24:46
le tengo que pasar esto 00:24:49
aquí le tengo que pasar 00:24:55
esto 00:24:58
vale 00:24:59
y aquí le tengo que pasar esto 00:25:02
comprueba disponibilidad 00:25:04
devuelve 00:25:11
vale, vale, vale 00:25:12
entonces 00:25:14
devuelve la habitación de reserva 00:25:16
entonces aquí lo que devolvería sería 00:25:18
numHabitaciones.length 00:25:20
¿verdad? 00:25:25
Sí, también está cambiado. 00:25:27
Dime. 00:25:29
Es el método. 00:25:30
¿Cuál? 00:25:32
O sea, este, 00:25:34
claro, 00:25:35
este lo tengo que cambiar 00:25:36
a que me devuelva 00:25:38
el tamaño de ese array. 00:25:39
Bueno, le puedes poner un disk delante 00:25:46
si quieres, pero vamos, opcional. 00:25:47
¿Vale? 00:25:50
Vale, creo que la clase reserva 00:25:50
Creo 00:25:54
Que ya estaría toda modificada 00:25:54
Número de habitaciones 00:25:57
Está todo cambiado a RAI 00:25:59
Comprueba disponibilidad 00:26:05
Te devuelven uno de habitaciones reservadas 00:26:07
O nulo 00:26:09
Vale 00:26:09
Y esto a habitación no le afecta 00:26:10
A hotel tampoco le afecta 00:26:14
¿Verdad? 00:26:17
Y ahora ya se nos queda este método 00:26:19
Vale, esta sería 00:26:20
Esto que hemos hecho hasta ahora 00:26:21
Pues podría ser un examen normal y corriente 00:26:24
Este podría ser el proceso 00:26:27
Vuestro de un examen, vais haciendo las clases 00:26:29
Vais viendo, uno puede tener 00:26:30
Un main al lado para ir probando 00:26:32
A ver si algún método que ha hecho, por ejemplo 00:26:35
Aquí podría probar 00:26:37
Uy, si es que no lo sabe ya 00:26:38
¿Qué método era el que comparábamos fechas? 00:26:40
Estaba en reserva, ¿verdad? 00:26:45
Sí, aquí, uy, realmente 00:26:46
¿Y cuál será el que yo le doy dos locales y no son iguales? 00:26:49
Pues a lo mejor lo podría comprobar en un main 00:26:51
Pero vamos, ya os digo yo que sí 00:26:53
De hecho se puede meter uno en el equals de local date 00:26:54
¿Veis? 00:26:57
Este es el equals de local date 00:26:59
Que sobrescribe el equals de object 00:27:01
Que lo sobrescribe 00:27:03
Y fijaos como está hecho 00:27:04
Pues está llamando al compare to 00:27:06
Que el compare to si os metéis 00:27:08
Veréis que devuelve cero si las fechas son iguales 00:27:11
Pues sí, tiene toda la pinta de que el equals 00:27:14
Si dos objetos fecha 00:27:15
en direcciones distintas 00:27:18
contiene en el mismo día, mes y año 00:27:20
contiene en el mismo, pues te va a dar 00:27:22
el equals true, tiene toda la pinta de que sí 00:27:24
pero uno podría comprobarlo en un main aparte 00:27:26
si tiene dudas, lo que sea 00:27:28
¿vale? bueno, entonces 00:27:30
y ahora ya llegaría a la parte más 00:27:32
complicada, que yo no sé si 00:27:34
pondríamos quizá algo tan complicado 00:27:36
en un examen, depende de cómo salga, a lo mejor luego lo hacéis 00:27:38
y os sale facilísimo, no lo sé 00:27:40
¿vale? pues venga 00:27:42
poneos a ello, a ver cómo sale este método 00:27:44
que aquí ya sí que hay que ponerse a pensar 00:27:46
cómo recorro el array, cómo lo miro 00:27:48
cómo 00:27:51
venga 00:27:52
Hay que intentar entenderlo yo también 00:28:16
Porque no te creas que me ha quedado muy claro 00:28:26
Lo que tiene que hacer 00:28:27
¿Tú lo has completado este método, Miguel? 00:28:29
Es que no te creas que está muy claro lo que tiene que hacer 00:28:37
Pero vamos 00:28:39
Gracias. 00:28:46
Gracias. 00:29:16
asumimos claro que las personas 00:29:46
da igual en qué habitaciones caigan 00:29:55
o sea, si caen todas 00:29:58
en una 00:30:00
de tres personas, o sea, son tres 00:30:01
y hay una de tres personas ahí 00:30:04
vale, da igual 00:30:05
no hay que buscarles 00:30:07
no hay, no pueden elegir 00:30:10
pues no sería muy complicado 00:30:12
pero bueno, sí 00:30:13
Yo creo que sí, que no es tan complicado 00:30:15
Ahí la idea sería 00:30:17
El hotel tiene una serie de reservas 00:30:24
Tenéis una fecha 00:30:26
Pues habría que ir reserva por reserva 00:30:27
Viendo las habitaciones que quedan libres 00:30:30
Y ver si las que quedan libres 00:30:33
Suman 00:30:35
Un total de plazas disponibles 00:30:36
Para lo cual hay un método de plazas disponibles 00:30:40
Superior o igual a las personas que hay 00:30:41
Aquí está. 00:30:45
¿Vale? 00:31:11
Es decir, ahí te dan una fecha. 00:31:11
O sea, cada reserva tiene las habitaciones ocupadas 00:31:13
o no tiene ninguna. 00:31:17
Y luego, además, el hotel tiene una serie de habitaciones 00:31:19
donde cada habitación tiene el número de plazas disponibles 00:31:22
en su método. 00:31:27
Entonces, la idea sería para este método 00:31:29
de disponibilidad, que era una fecha, 00:31:32
pues tú vas 00:31:35
reserva por reserva, ¿vale? 00:31:36
en cuanto te encuentres 00:31:43
una que es null 00:31:45
pues tú vas cogiendo habitaciones 00:31:47
hasta completar las personas que hay 00:31:51
en cada habitación tienes placas disponibles 00:31:52
las vas cogiendo 00:31:54
¿vale? 00:31:55
y si no es null pues las que quedan libres 00:31:58
que no están ahí 00:32:00
que no están en su array 00:32:01
aquí 00:32:02
entonces bueno hay que 00:32:05
es un código que hay que organizar un poquito 00:32:07
pero el punto de partida es ese 00:32:09
es ir viendo las habitaciones que quedan libres 00:32:11
en ese día 00:32:15
entonces, si todas las reservas 00:32:16
te han dado null 00:32:19
pues las tienes todas libres, las vas cogiendo y ya está 00:32:20
si hay una reserva que no te ha dado null 00:32:23
pues tendrás que verlas 00:32:25
que las habitaciones que quedan libres 00:32:26
yo me haría 00:32:28
una array habitaciones libres 00:32:34
¿vale? una array habitaciones libres 00:32:37
que inicializaría con las totales 00:32:40
de habitaciones del hotel 00:32:44
y luego iría recorriendo las reservas 00:32:45
e iría quitando las que tienen cada reserva 00:32:48
para ese día, iría quitando 00:32:51
luego con las que me quedan 00:32:52
miraría si caben las personas que hay 00:32:54
y ya está 00:32:56
es como yo lo haría 00:32:57
un array de habitaciones disponibles 00:32:59
recorro las reservas 00:33:02
y para las reservas de esa fecha 00:33:03
para lo cual tenemos un método 00:33:06
le voy quitando las ocupadas 00:33:08
y con las que me queden 00:33:10
al final del recorrido con las reservas 00:33:13
miro a ver si caben las personas que tengo 00:33:15
pero seguramente lo podéis plantear 00:33:16
de otras maneras, de otras formas 00:33:21
a ver como se os ocurre 00:33:22
yo lo voy a hacer a mi manera 00:33:24
a ver como sale 00:33:26
Gracias. 00:33:38
Gracias. 00:34:08
Gracias. 00:34:38
Claro, es un método que tendrás que usar 00:35:08
Sí, a ver cómo lo organizáis vosotros 00:35:13
La idea es, con lo que tenemos 00:35:15
cómo construís el código 00:35:17
para construir una reserva 00:35:18
si es que se puede, que aloje a esas personas 00:35:21
Si tenéis que hacer 00:35:38
Tampoco os pongáis como locos 00:35:45
Metiendo métodos 00:35:47
Porque no se trata en las clases 00:35:48
Si tenéis que hacer algún método auxiliar 00:35:49
Que tenga sentido, que esté justificado 00:35:51
Donde va 00:35:54
No un método que de repente 00:35:54
Aparece como un parche en una clase 00:35:56
Que no, pues lo hacéis 00:35:59
Para que no queden códigos largos 00:36:01
Pero tratad de hacerlos con criterio 00:36:03
Gracias. 00:36:06
Seguimos. 00:36:36
Gracias. 00:37:06
Gracias. 00:37:36
Gracias. 00:38:06
Gracias. 00:38:36
¿Qué pasa? 00:39:06
Gracias. 00:39:36
¿Qué pasa? 00:40:06
Esto estaría en realidad mucho mejor descrito, es que el enunciado no lo dejaba muy claro. 00:40:36
Si la reserva lo que tuviera aquí es el array directamente de las habitaciones. 00:40:40
Ya que tenemos una clase habitación, no solamente el número, porque si tenemos el número luego tendríamos que irnos al array a buscar. 00:40:46
Estaría mucho mejor descrito si la reserva tiene la fecha, el número de personas y el array de las habitaciones. 00:40:54
¿Verdad? Estaría mejor descrito 00:41:05
Yo creo, ¿no os parece? 00:41:07
Ya, pero el tipo de dato 00:41:14
¿El tipo de dato tienes puesto? 00:41:16
¿Un array de int o un array de habitación? 00:41:18
Vale, pero que quizá 00:41:22
Así solamente guardas 00:41:23
El número de la habitación 00:41:25
Pero si lo declaramos 00:41:26
Como array de habitación 00:41:29
Guardas todos los datos de la habitación 00:41:30
Directamente en ese array 00:41:32
Lo digo porque podéis también cambiar el diseño si queréis 00:41:33
Como yo lo he empezado así, yo lo voy a dejar así 00:41:39
Pero es por hacer comentarios al respecto 00:41:43
Gracias. 00:42:03
Gracias. 00:42:33
Gracias. 00:43:03
Gracias. 00:43:33
Un momento. 00:44:03
Gracias. 00:44:33
Gracias. 00:45:03
Gracias. 00:45:33
3, 2, 1. 00:46:03
Bueno, pues yo ya he hecho mi versión 00:46:33
Uh, esto estaba sin parar 00:46:39
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
15 de febrero de 2024 - 19:46
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
46′ 42″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
210.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid