Saltar navegación

20241205 POO-Clases_9 - 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 5 de diciembre de 2024 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

vamos a utilizar este ejercicio 00:00:00
para incorporar otra cosa más 00:00:03
que podemos meter en la declaración de una clase. 00:00:06
Fundamental, los métodos constructores. 00:00:09
¿Vale? 00:00:12
Entonces, nosotros leemos esta aplicación. 00:00:12
Pues llegamos un poco a la conclusión, 00:00:16
no nos detenemos mucho por encima, 00:00:17
que hay una única entidad, 00:00:19
hay una única cosa de la que se ocupa la aplicación, 00:00:20
que es una cafetera. 00:00:22
Una cafetera que lo único que necesitamos saber 00:00:23
para trabajar con ella es 00:00:26
Lo máximo que le cabe 00:00:27
Y lo que tiene en cada momento 00:00:29
Con esas dos propiedades 00:00:31
Ya los métodos 00:00:34
Pues harán lo que tengan que hacer 00:00:35
Sacar la cantidad necesaria 00:00:36
Para llenar una taza 00:00:39
Llenarla, vaciarla, lo que sea 00:00:40
Pues venga 00:00:43
Vamos a hacer entonces la clase cafetera 00:00:45
Porque ya sabemos que solo necesitamos esa clase 00:00:47
Y con las propiedades que nos hacen falta 00:00:49
Pues venga 00:00:51
Hacemos 00:00:53
Clase cafetera 00:00:55
y le quito el public 00:01:01
propiedades 00:01:03
ya sabemos cuáles porque la tarea de análisis 00:01:05
y diseño ya la tenemos hecha 00:01:07
que es 00:01:09
la cantidad 00:01:10
máxima 00:01:13
que tiene 00:01:16
llamémosle capacidad 00:01:17
si la haces con internet 00:01:19
si, da igual 00:01:22
vale 00:01:23
y luego otra propiedad 00:01:24
va a ser lo que tenga en cada 00:01:27
momento, vale 00:01:30
con esas dos propiedades ya lo tenemos todo 00:01:35
y ahora lo siguiente que hemos hecho nosotros 00:01:37
es, vale, ¿qué métodos le interesan 00:01:39
a la aplicación? pues le interesan 00:01:41
a la aplicación 00:01:43
uno, dos, tres y cuatro métodos 00:01:44
uno, llenarla 00:01:47
vale 00:01:49
cuando le demos al botón de llenar 00:01:50
pasarán cosas, se abrirá un sensor, 00:01:53
empezará a entrar agua, 00:01:55
entrará lo que sea, yo que sé 00:01:56
pero la parte 00:01:58
de software, lo único que tiene que hacer 00:02:01
es poner la cantidad actual 00:02:03
con el mismo valor que tenga la capacidad. 00:02:05
La capacidad se supone 00:02:09
que en lugar de llamar la capacidad máxima, 00:02:11
la he llamado capacidad para que la variable sea más corta 00:02:14
y no tener que escribirla todo el rato. 00:02:16
Pero bueno, me refiero a lo máximo que cabe. 00:02:18
Vale, pues eso cuando una cafetera exista, 00:02:21
capacidad tendrá un valor, el que sea. 00:02:24
Cuando creemos una cafetera 00:02:26
cuya capacidad máxima sea en 27, 00:02:28
pues capacidad tendrá 27. 00:02:30
cuando creemos una cafetera cuya capacidad máxima sea 13 00:02:31
pues esta variable tendrá 13 00:02:34
no podemos saber lo que tiene hasta que no exista una cafetera en concreto 00:02:36
pero lo que sí que sabemos es que habrá un método 00:02:41
llenar cafetera 00:02:44
que cuando ese método sea invocado 00:02:46
¿qué va a hacer ese método cuando sea invocado? 00:02:49
pues la cantidad actual de la cafetera 00:02:54
ponerla con el valor de la capacidad 00:02:56
Entonces, las preguntas que nos hacemos. ¿Necesita algún dato desde fuera este método para trabajar? No, porque... 00:03:00
Por eso te van a poder acusar durante mucho tiempo. 00:03:11
Bueno, ¿necesita alguna información desde fuera? 00:03:23
No, porque lo único que tiene que hacer este método es 00:03:28
La propiedad cantidad actual 00:03:30
Y es una propiedad en la que tiene acceso 00:03:33
Porque está ahí arriba 00:03:35
La propiedad cambiarla 00:03:36
Para que se ponga con lo que vale la capacidad 00:03:38
Es lo único que tiene que hacer ese método 00:03:42
Con lo cual no necesita ninguna información desde fuera 00:03:44
Luego esto vacío 00:03:47
¿Tiene que devolver algo? 00:03:49
No, su efecto queda reflejado 00:03:50
Porque la cantidad actual se ve modificada 00:03:52
Se ve modificada 00:03:54
No tiene que devolver nada 00:03:56
Pues entonces aquí voy 00:03:57
Ya está 00:03:59
Vale, pues este método ya estaría 00:04:00
¿Qué más métodos, qué más botones tiene la cafetera 00:04:03
Para hacer cosas con ella? 00:04:06
Pues tiene un botoncito 00:04:07
Servir taza 00:04:09
Entonces cuando se da el botoncito 00:04:12
Servir taza 00:04:14
Cuando se da el botoncito 00:04:16
De servir la taza 00:04:22
¿Qué es lo que va a ocurrir? 00:04:24
Que habrá una taza puesta ahí 00:04:27
Con un volumen 00:04:29
Y entonces la cantidad actual 00:04:30
Se va a ver disminuida 00:04:33
En lo que ocupe la taza 00:04:35
¿Lo que ocupa la taza 00:04:37
Es un dato de la cafetera? 00:04:39
En absoluto 00:04:41
Luego no tiene sentido agregar aquí una propiedad 00:04:42
Que sea lo que cabe en la taza 00:04:45
Vete a saber, cada vez yo lleno tazas de diferente volumen 00:04:46
Bueno, pues entonces 00:04:49
Ahí, eh 00:04:51
No, es una información 00:04:52
Que me tiene que llegar desde el exterior 00:04:55
Tú quieres que yo te sirva una taza, ¿vale? Pues tendrás que decirme qué volumen tiene esa taza para yo saber hasta dónde tengo que estar aquí girando la mano. 00:04:57
Ahí podría haber objeto taza. 00:05:07
No lies, no lies. Poco a poco. 00:05:12
Entonces, lo que necesita este método para trabajar es, ¿cuál va a ser el resultado de este método? 00:05:15
Pues la cantidad actual se va a ver disminuida por lo que ocupe la taza, por el volumen de la taza, ¿verdad? 00:05:21
Se va a ver disminuida por lo que ocupe la taza. 00:05:30
¿Y cuánto ocupa la taza? 00:05:32
Pues depende de la taza que me pasen. 00:05:33
Es una información que me tienes que dar, no lo sé. 00:05:35
Pues ¿dónde está el sitio de meter la información que te tienen que dar desde fuera para trabajar? 00:05:38
El sitio para meter la información que tienen que dar desde fuera para trabajar, 00:05:43
tú aquí dentro está aquí en los parámetros. 00:05:47
Vale, pues me tendrás que dar aquí 00:05:48
Lo que cabe en la taza 00:05:50
¿Qué es esto? 00:05:54
Eso, lo que cabe en la taza me lo tendrás que dar 00:05:57
Entonces cuando ya me lo hayas dado 00:06:00
Pues yo ya podré quitarle 00:06:02
A la cantidad actual 00:06:03
Ya le podré quitar lo que me has pasado 00:06:05
¿Tengo que devolver algo? No 00:06:07
Porque el efecto se queda en la propiedad 00:06:11
Pues entonces aquí voy 00:06:13
Ya está 00:06:15
¿Puedo poner si se queda en negativo? 00:06:18
Sí, porque 00:06:19
vale, se me ha olvidado, aquí dice 00:06:23
si como resultado de servir 00:06:25
la taza, claro, puede ocurrir que la taza 00:06:27
sea más grande que la cantidad que queda 00:06:29
entonces si la taza es más grande 00:06:31
la cafetera se queda a cero 00:06:33
pero nunca se queda a negativo 00:06:35
el software se estaría funcionando mal 00:06:37
si yo pongo, uy, se me ha quedado a menos 7 litros 00:06:39
pues no, pedazo 00:06:42
cafetera, no, sí 00:06:43
entonces, claro 00:06:44
aquí tenemos que poner 00:06:47
bueno, lo podríamos hacer en una única línea 00:06:49
con operador ternario, como sea, pero bueno 00:06:52
si la cantidad 00:06:54
actual que me ha quedado después 00:06:56
de hacer la resta resulta que es menor que cero 00:06:58
pues entonces ponla cero 00:07:00
porque si no la información que estás dejando en la cafetera 00:07:02
es errónea 00:07:04
este método ya estaría 00:07:05
por ejemplo, claro 00:07:08
capacidad taza mayor que cantidad 00:07:15
actual, cantidad actual cero 00:07:17
Es decir 00:07:19
Podríamos hacer en una sola línea 00:07:20
Algo mucho más bonito 00:07:23
Que sería esto 00:07:24
Vamos a suponer que esto 00:07:26
Eso comentado porque es 00:07:27
Nosotros ya estamos por encima de todo esto 00:07:30
Entonces podríamos hacer aquí 00:07:33
Cantidad actual 00:07:35
Capacidad 00:07:36
Taza es mayor 00:07:39
Que la cantidad 00:07:41
Actual 00:07:43
¿Eh? ¿Qué pasa? 00:07:45
Interrogación 00:07:49
Pues entonces me quedo a cero 00:07:50
Entonces me quedo a cero 00:07:52
Y pongo cantidad actual a cero 00:07:54
No he llenado la taza 00:07:56
Uy, perdón, pongo cero 00:07:57
Que no, pues pongo cantidad actual 00:07:59
Menos capacidad taza 00:08:04
Ya, pero 00:08:05
Bueno, o sea 00:08:13
Ese mismo método lo podemos hacer así, ya está, ¿no? 00:08:16
¿Eso qué es? 00:08:19
Lo de hace dos meses y medio 00:08:20
Decírselo por mí 00:08:23
Es el operador ternario 00:08:31
En función de una condición 00:08:35
Lo que pasa es que, a ver, me he bajado la línea de abajo 00:08:37
Para que se vea 00:08:39
Existen los entes 00:08:40
Ahora lo entiendes, ¿no? 00:08:42
Vale, pues ya está 00:08:46
Lo pillas 00:08:47
Hacemos el otro método y ahora ya 00:08:48
incorporamos esa maravilla de los constructores 00:08:51
constructores, vale 00:08:54
el siguiente método 00:08:56
vamos a vaciar la cafetera, ese método es facilísimo 00:08:57
poner la cantidad de café 00:09:00
a cero, entonces 00:09:02
ya ni pongo las interrogaciones 00:09:06
porque ya sabemos que no va a devolver nada 00:09:08
porque el efecto 00:09:10
se queda, ¿necesita algo? no, para vaciar 00:09:12
la cafetera no necesito ninguna información desde fuera 00:09:14
vaciar la cafetera 00:09:16
será esto 00:09:18
capacidad actual igual a cero 00:09:19
Algo escrito mal 00:09:24
Es porque me falta 00:09:27
Capacidad actual igual 00:09:29
Ah, porque es cantidad actual 00:09:31
Eso 00:09:34
Perdón, cantidad actual 00:09:34
Juan ha dado un salto de aprendizaje 00:09:38
En la vida se va, se envejece 00:09:40
Y se aprende a saltos 00:09:43
Pues 00:09:44
Hacer un ejercicio entero 00:09:45
Uno solito es un salto de aprendizaje 00:09:49
Bueno, a ver, espera 00:09:51
Tampoco te pases 00:09:55
Y eso 00:09:57
Tenemos un siguiente examen para demostrarlo 00:10:03
Agregar café 00:10:06
Venga, confianza en uno mismo 00:10:07
Que yo he dicho que mierda de código 00:10:18
¿Cuándo he dicho yo eso? 00:10:20
Pero lo has pensado en general 00:10:23
Ah, no hombre 00:10:25
Siempre os he dicho en los dos exámenes que salí contenta 00:10:26
De corregir 00:10:29
Vale, a ver 00:10:30
Yo creo que sí 00:10:31
A ver, en los últimos 00:10:35
Ha habido hasta la pandemia 00:10:37
Más o menos 00:10:39
Desde la pandemia hasta acá no sé por qué 00:10:40
Han coincidido grupos 00:10:42
Muy regulares 00:10:44
Y este año yo qué sé 00:10:46
Yo creo que hay un poco de 00:10:47
Estáis viendo las orejas al lobo 00:10:49
Estáis viendo que el futuro 00:10:51
Y queréis vivir bajo techado 00:10:52
Y comer caliente 00:10:55
Y entonces igual os estáis poniendo las pilas 00:10:56
Hombre, todos queréis, ¿no? 00:10:59
Tener las necesidades básicas resueltas 00:11:06
Bueno 00:11:08
Agregar café 00:11:11
Agregar café será 00:11:14
A la cantidad actual 00:11:16
le sumas 00:11:18
lo que tú 00:11:21
agregues 00:11:22
¿cuánto le sumas? me lo tendrás que decir 00:11:24
me tendrás que decir cuánto quieres que le sume 00:11:27
luego el sitio para decirme 00:11:29
cuánto café quieres que le sume 00:11:31
a la cafetera 00:11:33
es este, este es el sitio 00:11:33
para decirle 00:11:37
cuánto quieres 00:11:38
vale, ¿tiene que devolver 00:11:40
algo el método? no voy 00:11:45
Bueno 00:11:46
Y si se pasa 00:11:49
Se queda 00:11:52
El otro ha desbordado 00:11:55
Entonces lo mismo 00:11:56
Si la cantidad actual 00:11:58
Es mayor 00:12:10
Que la capacidad 00:12:11
Es mayor que la capacidad 00:12:12
pues entonces 00:12:18
cantidad actual igual a capacidad 00:12:20
y el otro ha desbordado 00:12:22
nos da igual donde ha ido a parar 00:12:25
pero nunca va a caber más 00:12:26
esto lo podréis hacer con un operador ternario 00:12:28
también como aquí arriba, como os dé la gana 00:12:30
a ver tu jefe 00:12:32
que prefiere 00:12:37
bueno 00:12:37
vale, pues ya está, ahora 00:12:40
este es el software de la cafetera 00:12:42
entonces cuando se den los botoncitos 00:12:44
Esos botoncitos abrirán y cerrarán 00:12:46
Sensores y aparte 00:12:49
Cambiarán los datos 00:12:51
¿Vale? Luego este software 00:12:52
Mínimo, pero es un software real 00:12:55
En realidad 00:12:57
Se abrirán y cerrarán sensores, pero esto cambiará 00:12:57
Luego esto pasa 00:13:01
Dentro de una 00:13:03
Cafetera 00:13:05
Claro, tú tienes todos tus 00:13:05
Sensores, células, lo que sea 00:13:11
Claro 00:13:13
Sí, pero un software que actualiza 00:13:14
Los datos, tiene que haber 00:13:17
Claro 00:13:19
Bueno, pues entonces 00:13:20
Ahora ya vamos a hacer la aplicación 00:13:23
La que arranca cuando le damos 00:13:25
El on a la cafetera 00:13:27
Porque ahora mismo no hay ningún 00:13:29
No existe ninguna cafetera, ni le hemos dado el on a nada 00:13:31
Ahora vamos a 00:13:33
Tener ya una cafetera real 00:13:35
A la que le damos el on, para que empiecen a pasar cosas 00:13:37
Dime 00:13:40
Agregar este 00:13:40
Y ahora es cuando ya nos importan los constructores 00:13:45
Vale 00:13:52
Venga, ya está 00:13:54
Vale, ya 00:13:59
Venga, pues hacemos el main 00:14:02
Ahora 00:14:06
¿Eh? 00:14:06
La parte divertida 00:14:08
Que es cuando pasan cosas 00:14:10
Cafetera 00:14:12
Vale, pues aquí 00:14:14
Arrancamos la aplicación 00:14:18
Aquí 00:14:19
Desde el momento en que entramos en el main 00:14:21
Ya hemos dado el on 00:14:23
Al cacharro, a la cafetera 00:14:24
Pues que es lo primero que tenemos que hacer 00:14:27
Crear el objeto cafetera 00:14:29
Con los datos concretos 00:14:31
Entonces, nosotros que hemos hecho hasta ahora 00:14:33
Pues esta es mi cafetera 00:14:35
Esta de aquí 00:14:37
Declaramos la variable cafetera 00:14:38
Y instanciamos el objeto 00:14:41
Vale, entonces que hemos hecho 00:14:43
Nosotros hasta ahora, el objeto creado 00:14:47
Cafetera, todavía no 00:14:49
Tiene los valores 00:14:51
¿Cómo vamos a inicializar la cafetera? 00:14:52
Pues se supone que 00:14:56
Aquí no nos lo dice 00:14:57
Con propiedades de tabas por teclado 00:14:59
Vamos a olvidarnos 00:15:00
Bueno, no, venga 00:15:01
Vamos a pedir la capacidad máxima 00:15:05
Es que claro, en una aplicación real 00:15:07
Cada vez que daslo a la cafetera 00:15:09
No te estará preguntando 00:15:11
Oye, ¿cuál es la capacidad máxima que tengo? 00:15:12
¿Cuánto es la cantidad 00:15:16
Que tengo en este momento? 00:15:17
Lo normal es que lo registre con sensores 00:15:19
Y lo inicialice 00:15:21
pero como en nuestro caso 00:15:22
no hay sensores que vean 00:15:24
cuál es la capacidad que tiene 00:15:26
y lo que tiene en ese momento 00:15:28
en lugar de pedirlo por teclado 00:15:29
que es un rollo, se lo voy a poner a capón 00:15:32
aquí directamente 00:15:34
eso es muy irregular porque el café se evapora 00:15:35
hay pequeños cambios 00:15:38
que te va a descuadrar 00:15:40
pero como no podemos meterle un sensor 00:15:41
pues vamos a 00:15:44
metérselos directamente 00:15:45
y la cafetera cuando le damos salón 00:15:47
arranca siempre con una capacidad máxima de 100 00:15:50
porque esta aplicación es para las cafeteras 00:15:54
Roventa modelo tal 00:15:56
que tienen capacidad de 100 00:15:57
con lo cual cuando el software arranca 00:15:59
cafetera.capacidad 00:16:02
es igual a 100, no hay alternativa 00:16:06
porque todas tienen 100 00:16:07
y además estas cafeteras 00:16:08
antes de apagarla te obliga 00:16:11
a haberla dejado vacía 00:16:13
con lo cual cuando tú la enciendes no hay tutía 00:16:14
la cantidad actual 00:16:17
siempre a cero 00:16:19
esto lo estoy haciendo solo para ahorrarme 00:16:21
leerlo por teclado, ya está 00:16:23
bueno, pues esto es lo que hemos hecho hasta ahora 00:16:25
para inicializar las propiedades 00:16:27
del objeto una vez creado 00:16:29
y esto está bien 00:16:31
pero es 00:16:33
muy feo, horroroso, nunca lo vais a ver así 00:16:34
vale, vamos a aprovechar 00:16:38
entonces esta aplicación 00:16:39
para introducir los constructores 00:16:41
para 00:16:46
introducir los 00:16:53
métodos 00:16:55
constructores 00:16:57
bueno 00:17:00
vamos a volver al momento en el cual 00:17:02
hemos hecho esta sentencia 00:17:05
que yo lo único que he dicho hasta ahora es 00:17:06
que esa sentencia lo único que hace 00:17:08
es crear un espacio en memoria 00:17:10
y ahora ya 00:17:13
ese espacio en memoria dejarlo apuntado 00:17:14
por esta variable 00:17:17
es lo que he dicho 00:17:19
que es lo único que hace 00:17:20
pero 00:17:21
os he mentido 00:17:23
como os miento mucho 00:17:25
porque os tengo que ir ocultando información 00:17:27
no os puedo dar toda la información de golpe 00:17:30
esto es como cuando vas a dejar a tu pareja 00:17:31
vas poco a poco 00:17:34
hasta que al final le dices, te llevo poniendo los cuernos 20 años 00:17:35
pues igual 00:17:38
pues esto es igual 00:17:39
yo voy dándoles la información poco a poco 00:17:42
pues a ver, os he mentido 00:17:44
esto hace algo más 00:17:46
esto llama a un método 00:17:47
de la clase 00:17:50
que es el método que se llama 00:17:51
constructor 00:17:54
y ahora me diréis 00:17:54
pero si aquí no hay más métodos que esto 00:17:57
vale, es que hay un oculto 00:17:59
que no vemos, que está siempre 00:18:02
por defecto, un oculto que no vemos 00:18:04
y es el método 00:18:06
constructor, me explico 00:18:08
vamos a ponerlo aquí y así se queda 00:18:10
recogido en el ejercicio 00:18:12
por si habéis visto el proyecto y lo veis 00:18:13
que es un método 00:18:15
constructor 00:18:18
¿cómo se declara un método constructor? 00:18:19
Aunque no, un método constructor es un método que obligatoriamente se llama igual que la clase, se llama igual a lo que tú quieras. 00:18:21
a ver, el método constructor 00:18:42
se llama igual que la clase, obligatorio 00:18:44
entonces solo hay dos tipos 00:18:47
de métodos, los normales que hago yo 00:18:49
como me dé la gana 00:18:51
y se hacen con las reglas que hemos dicho 00:18:52
parámetros opcionales 00:18:54
siempre tipo de retorno 00:18:57
o void si no devuelve nada 00:18:59
todo eso aplica a todos los métodos 00:19:01
salvo a los métodos 00:19:03
constructores que es una excepción 00:19:05
los métodos constructores 00:19:07
a ver, espera, ahora vamos a entender para qué sirven 00:19:08
primero, se llaman igual que la clase 00:19:10
luego, mi método constructor 00:19:12
se tiene que llamar cafetera 00:19:14
este empieza por mayúscula 00:19:16
ya es una excepción, si la clase se llama 00:19:18
cafetera con mayúscula, este tiene que llamar 00:19:20
cafetera con mayúscula, porque Java es 00:19:22
sensible a mayúsculas y minúsculas 00:19:24
vale, el método constructor se llama igual que la clase 00:19:26
tiene 00:19:28
sus paréntesis aquí, como todos los métodos 00:19:30
ahora veremos 00:19:33
que se ponen estos paréntesis 00:19:34
¿qué valor de retorno devuelve? 00:19:35
El método constructor no puede devolver nada nunca. 00:19:38
Entonces, tanto es así que ni siquiera se le pone el void. 00:19:42
Es el único al que no se le pone nada delante. 00:19:45
Y si yo pongo un void, ¿vale? 00:19:48
Pues, a ver, no es que me dé error. 00:19:51
Es que, claro, me va a decir, este método, cuidado, es un constructor. 00:19:53
Es que no pongas el void. 00:19:58
Esto no se hace nunca así. 00:19:59
No se pone nada. 00:20:01
No se pone nada. 00:20:03
Entonces, no devuelve nada. 00:20:05
Obligatoriamente, no devuelve nada. 00:20:06
vale, pues ya he hecho un método constructor 00:20:08
este método constructor que yo he hecho 00:20:10
estaba oculto 00:20:12
aunque vosotros no lo estuviéramos viendo 00:20:14
estaba oculto 00:20:16
entonces yo lo he escrito 00:20:18
y lo que estoy haciendo es como hacerlo ahí patente 00:20:19
y visible, para que se vea, pero ya estaba 00:20:22
vale, pues ahora volvemos 00:20:24
al new, ¿qué hace el new? 00:20:26
instancia el objeto 00:20:29
el espacio 00:20:31
de memoria se queda apuntado 00:20:32
por esta variable 00:20:34
y ahora llama 00:20:35
al método constructor que esté aquí. 00:20:37
El método constructor 00:20:40
que está oculto, que es el método constructor 00:20:42
por defecto, no hacía nada adentro. 00:20:44
Pero si yo lo sobrescribo, 00:20:46
como dices tú, yo lo sobrescribo, 00:20:48
ahora ya puedo hacer aquí 00:20:50
lo que me dé la gana. 00:20:52
Por ejemplo, 00:20:53
bienvenido a 00:20:58
Inexpreso. 00:21:00
Vale, 00:21:12
pues entonces yo meto en el método 00:21:13
constructor lo que me dé la gana, lo que yo quiera. 00:21:14
Y este método se va a ejecutar cuando se llama al new. 00:21:18
Luego el new hace tres cosas. 00:21:23
Crear el espacio en memoria. 00:21:26
La dirección donde se ha creado, 00:21:28
guardarla en esta variable para que se quede apuntado. 00:21:30
Y luego llamar al método constructor. 00:21:32
Que yo no he hecho un método constructor. 00:21:35
No pasa nada. 00:21:37
Hay un oculto que no hace nada al que se llama por defecto. 00:21:38
Luego es como no llamarlo, pero lo llama. 00:21:42
Y luego, vale. 00:21:46
Y si yo lo he hecho visible, entonces ya el que estaba oculto por defecto ya no existe, porque yo lo he sobrescrito. 00:21:47
Y entonces al que llama es a este, porque yo lo he sobrescrito. 00:21:55
¿Vale? 00:21:59
Entonces, ahora si nosotros ejecutáramos este main, si ejecutáramos este main, ¿qué va a ocurrir? 00:21:59
Pues vamos a ver 00:22:12
Efectivamente 00:22:14
Me saluda 00:22:20
Porque llama al constructor 00:22:21
Me ha saludado 00:22:24
Porque ha llamado al constructor 00:22:25
Y luego ya 00:22:27
Y luego ya ha hecho esto de aquí 00:22:28
Luego ya ha hecho esto 00:22:32
Esto no lo hemos visto nosotros 00:22:33
Pero lo ha hecho 00:22:35
¿Vale? 00:22:36
Luego, repitiendo 00:22:39
El método constructor es un método especial 00:22:44
Que obligatoriamente 00:22:46
tiene el nombre de la clase 00:22:48
¿vale? 00:22:50
si no lo tengo yo escrito 00:22:52
habrá uno oculto, aunque yo no lo vea 00:22:54
como este, pero que no tiene nada 00:22:56
dentro, y si yo 00:22:58
lo hago patente porque lo escribo 00:23:00
piso el que estaba oculto 00:23:02
lo piso y ahora es este el válido 00:23:04
y este método cuando se llama 00:23:06
cuando se hace el new, entonces es un método 00:23:08
especial porque no se llama nunca 00:23:10
por su nombre como los demás 00:23:12
yo aquí podría hacer ahora 00:23:14
pues vamos a servir, vamos a llenar la 00:23:15
cafetera lo primero, porque como me la he 00:23:18
inicializado vacía, 00:23:20
cafetera, lo primero 00:23:22
que vamos a hacer va a ser llenarla. 00:23:24
Pues venga, lo primero que hago es llenarla. 00:23:26
Entonces, el resto de métodos 00:23:28
siempre se hacen 00:23:29
asociados a un objeto. 00:23:31
Un objeto creado llama el método. 00:23:33
Pero los constructores 00:23:37
no se llaman nunca así. 00:23:38
Los constructores son métodos que se llaman 00:23:40
solo cuando se crea un 00:23:41
objeto al momento de construir con el new. 00:23:43
Por eso se llaman constructores. No es un 00:23:45
método que luego yo pueda llamar aquí haciendo 00:23:47
cafetera 00:23:50
punto 00:23:52
cafetera. No puedo. 00:23:53
No me ha dejado, de hecho. Yo no puedo 00:23:59
hacer esto. No puedo 00:24:00
llamar al método constructor 00:24:02
con un objeto. 00:24:04
Aunque ese método está dentro. 00:24:08
Entonces uno podría decir, hombre, es un método que está 00:24:10
dentro, ¿puedo llamarle con el objeto? Pues no. 00:24:12
Este método solo vale 00:24:14
para ser llamado en el momento 00:24:15
del new y va asociado al new. 00:24:18
por eso se le llama constructor 00:24:19
bueno 00:24:21
hasta aquí está claro 00:24:23
vale, pues entonces 00:24:25
¿qué ocurre? yo he dicho que yo aquí meto lo que me dé la gana 00:24:26
vale, pues hombre 00:24:30
meter mensajitos está muy bien 00:24:31
pero ya de paso 00:24:33
ya de paso que tengo un constructor 00:24:35
¿para qué se suelen usar? 00:24:38
¿cuál es el uso habitual de los constructores? 00:24:40
pues oye, ya que tienes 00:24:42
aquí unos paréntesis maravillosos 00:24:44
no los desperdicies 00:24:46
usa esos paréntesis 00:24:47
para pasar unos valores 00:24:49
y úsalos para inicializar 00:24:51
las propiedades, y ya en el momento 00:24:54
de crear el objeto, a la vez que lo 00:24:56
creas, le das un primer valor 00:24:58
a las propiedades, y te ahorras esto 00:24:59
que queda horroroso, y no lo vais a ver 00:25:02
nunca, entonces 00:25:03
vamos a hacer eso 00:25:06
decimos, oye pues 00:25:07
voy a hacer un 00:25:08
constructor 00:25:11
que me muestre el mensajito, el mensaje 00:25:12
lo dejo, y además de mostrarme 00:25:15
el mensajito 00:25:17
que reciba dos parámetros 00:25:18
por aquí, porque yo 00:25:21
en estos paréntesis del constructo puedo poner lo que quiera 00:25:23
y soy libre, aquí delante no 00:25:25
aquí delante no puedo poner nada, eso tiene que estar 00:25:27
vacío, pero 00:25:29
aquí puedo poner lo que yo quiera, tengo libertad 00:25:31
pues vamos a pasarle 00:25:34
dos valores 00:25:35
capacidad 00:25:37
y dos parámetros 00:25:40
cantidad 00:25:46
actual, que los estoy llamando 00:25:47
igual a propósito 00:25:51
no, no, son parámetros 00:25:52
entonces tengo que dar el tipo de dato 00:25:57
claro 00:25:58
sí, sí, sí, entonces yo le voy a pasar 00:26:01
dos parámetros double 00:26:03
porque yo aquí en los paréntesis meto lo que quiera 00:26:04
claro 00:26:07
y ahora, ¿para qué voy a usar esos parámetros double 00:26:08
que yo le paso? 00:26:10
pues para inicializar, dar un primer valor 00:26:12
a esas propiedades y así en el momento 00:26:14
en el que lo construyo 00:26:16
ya de paso le doy un primer valor 00:26:18
vale, pues entonces 00:26:20
¿qué voy a hacer con estos parámetros? 00:26:22
pues capacidad 00:26:25
igual a este 00:26:26
parámetro, uy me viene la ambigüedad 00:26:29
del otro día, ¿os acordáis? 00:26:30
ojo que aquí capacidad 00:26:32
sirve para dos cosas 00:26:33
discapacidad 00:26:36
sirve para la propiedad 00:26:38
del objeto y para el parámetro 00:26:40
pues aquí sí que me viene 00:26:42
estupendo el dis 00:26:44
eso 00:26:45
vale, entonces con esta sentencia 00:26:50
a la propiedad capacidad del objeto 00:26:52
le asigno esta 00:26:55
y ahora 00:26:57
lo mismo 00:26:59
a la propiedad 00:27:00
dis cantidad actual 00:27:02
le asigno 00:27:05
cantidad 00:27:06
actual 00:27:08
vale 00:27:10
pues este es uno del constructo de la propiedad de la gana 00:27:12
pero este es el uso habitual de los constructores 00:27:15
aprovecharse 00:27:18
de que cuando son llamados 00:27:20
los constructores, ahora tenemos que cambiar 00:27:22
aquí algo, pero bueno, ahora lo cambiamos 00:27:24
aprovecharse de que en el momento de 00:27:25
construirlo, que es cuando se llama 00:27:28
el constructor, vamos a aprovechar el momento de 00:27:30
construirlo para darle 00:27:32
unos primeros valores, vamos a aprovecharlo 00:27:34
¿vale? 00:27:36
no es que sea obligatorio usar el constructor 00:27:38
para esto, pero bueno, tiene 00:27:40
sentido, entonces 00:27:42
y repito, estamos 00:27:43
como siempre, no olvidéis 00:27:45
memorizar todo lo que decimos 00:27:48
lo que es el dis, en los casos en los que 00:27:50
hemos usado, todo, todo, todo en la memoria 00:27:52
no se puede olvidar una cosa de una para otra 00:27:54
porque esto va a ser una incorporación 00:27:56
de cosas una tras otra, una tras otra, una tras otra 00:27:58
si olvidamos esta 00:28:00
las cosas posteriores 00:28:02
ya no tienen ningún sentido 00:28:04
y no quiero que baje el nivel de suspenso 00:28:06
uy, perdón 00:28:08
me ha traicionado el subconsciente 00:28:09
me ha traído el sufrimiento 00:28:11
no quiero 00:28:13
que suba 00:28:19
la cantidad de su pelo 00:28:20
un segundo que completemos esto y ya me haces la pregunta 00:28:22
a menos que sea muy urgentísima 00:28:25
vale, pues si no es urgente 00:28:27
y Mario igual, esperamos un momento 00:28:28
vale, entonces 00:28:30
yo he cambiado el constructor 00:28:31
he cambiado y le he dicho 00:28:34
que va a recibir dos parámetros 00:28:36
hombre, pues entonces 00:28:37
cuando yo haga esto 00:28:40
¿para qué estaban aquí estos parámetros? 00:28:43
pues estaban para algo 00:28:45
estaban para poner los posibles 00:28:46
valores que uno 00:28:49
quiere poner en el caso de que 00:28:51
el constructor reciba 00:28:53
yo he hecho un constructor que recibe 00:28:54
valores, porque me ha dado la gana a mí hacerlo 00:28:57
para que reciba valores 00:28:59
y los use para inicializar 00:29:00
pues entonces va a tener que ponerlos aquí 00:29:02
porque ya el compilador se te está quejando, está diciendo 00:29:04
oye, perdona, que al constructor le has dicho que va a recibir 00:29:06
dos de Abel, pues tendrás que pasárselos 00:29:09
vale, pues el primero 00:29:11
que es la capacidad 00:29:13
y el segundo la cantidad actual 00:29:14
pues ala, estas líneas 00:29:16
ya me sobran completamente 00:29:19
no, pero no, esto bien 00:29:21
lo que pasa es que estoy empezando a bailar 00:29:24
para hacer más cosas 00:29:25
claro, pues frena 00:29:27
o no, pero bueno 00:29:29
vale, entonces entendido 00:29:30
ahora que hemos hecho con New Cafetera 00:29:32
hemos creado el objeto, lo hemos dejado apuntado 00:29:34
por cafetera y hemos llamado 00:29:37
a este método 00:29:39
y este método que ha hecho 00:29:41
ha cogido el 100 00:29:43
lo ha guardado 00:29:45
en capacidad, ha cogido 00:29:47
el 0, lo ha guardado 00:29:49
en cantidad actual, luego 00:29:51
ha hecho precisamente esto que íbamos a hacer 00:29:53
luego nosotros, luego esto ya no sobra 00:29:55
ya no nos hace falta 00:29:57
¿no? 00:29:59
o sea, con la llamada 00:30:01
al constructor 00:30:03
ya inicializamos 00:30:04
las propiedades 00:30:13
porque lo hemos programado así nosotros 00:30:14
y entonces nos viene muy bien 00:30:17
¿vale? 00:30:19
¿entendido? 00:30:23
a ver, tú ibas a preguntar algo 00:30:24
si los parámetros no se llamasen 00:30:26
igual que los atributos de cafetera 00:30:31
el dis no te hace falta 00:30:33
no te hace falta, pero lo habitual 00:30:34
es que se llamen igual 00:30:37
Claro, es que se llamen igual porque significan eso. 00:30:38
Entonces, el que te ve el código, pues ve que esto es para inicializar la capacidad, 00:30:41
luego tiene sentido que se llame capacidad, 00:30:45
y esto es para inicializar la cantidad actual, 00:30:46
tiene sentido que se llame así, entonces este es el uso habitual. 00:30:48
Queda más claro que si tú llamas a esto X e Y. 00:30:52
Queda un constructor muy feo si lo llamas X e Y. 00:30:55
Mario, ¿vas a preguntar algo? 00:30:57
Ah, que ya lo has arreglado. 00:30:59
Vale, entonces esto es el uso habitual de los constructores. 00:31:01
de hecho es tan así 00:31:04
que no debería 00:31:06
decirlo desde ya 00:31:08
pero como vosotros otra cosa no 00:31:10
pero las gilipolleces se os dan fenomenal 00:31:12
pues vamos a 00:31:14
es verdad 00:31:16
o sea cual que las cosas 00:31:17
no pero me refiero que para las 00:31:19
pejiguerías 00:31:22
sois buenísimos 00:31:23
entonces si vosotros 00:31:25
de hecho 00:31:28
vamos a 00:31:28
a comentar 00:31:31
este constructor 00:31:34
entonces, el Eclipse 00:31:34
este, tiene un montón 00:31:37
de ayudas sobre la marcha 00:31:40
obviamente, pues para refactorizar 00:31:41
para formatear código 00:31:44
para hacer mil tonterías 00:31:45
entonces para 00:31:47
fijaos, imagina 00:31:48
estamos haciendo la clase 00:31:50
la clase cafetera 00:31:52
ya, me he dado cuenta 00:31:54
pero ahora lo vais a agradecer 00:31:57
estamos haciendo la clase 00:31:59
que si 00:32:00
claro 00:32:01
está la clase y ahora 00:32:06
nosotros ya a partir de ahora cada vez que hagamos 00:32:08
clases vamos a hacer estos constructores 00:32:10
porque nos van a facilitar 00:32:12
la vida cuando instanciemos los objetos 00:32:14
hacemos new con los primeros valores y ya lo 00:32:16
tenemos, lo vamos a hacer ya por 00:32:18
sistema, pues como Eclipse se sabe 00:32:20
que por sistema vamos a usar estos constructores 00:32:22
porque son muy útiles para 00:32:25
luego en el main crear el objeto y darle 00:32:26
valores iniciales, pues él nos 00:32:28
dice, venga, botón 00:32:30
derecho, source, 00:32:32
genera constructor 00:32:36
usando campos. 00:32:37
¿Qué campos quiere usar el constructor? 00:32:39
Capacidad cantidad actual, 00:32:41
géneralo 00:32:43
géneralo. 00:32:46
¿Y qué te ha hecho 00:32:51
el tío? 00:32:53
Pues te ha creado él el mismo 00:32:54
constructor que hemos hecho nosotros. 00:32:56
ya, esto está relacionado con la herencia 00:32:58
super ahora mismo es como 00:33:00
nada 00:33:02
lo puedes quitar, a ver 00:33:03
super es, estás llamando al constructor de la super clase 00:33:06
la super clase de cafeteras object 00:33:09
llamas al constructor de object que no te hace nada 00:33:10
vale, vale, vale 00:33:13
claro 00:33:14
y te pone el public también que todos nos lo hemos puesto 00:33:15
eso es una clase, pero una subclase 00:33:21
¿cómo se hace? 00:33:24
¿Cómo haríamos la cafetera roventa? 00:33:26
Cafetera roventa, 00:33:29
estens, cafetera. 00:33:31
Pondrías aquí 00:33:35
estens 00:33:36
de la cafetera que tú eres. 00:33:38
Cafetera general, genérica, 00:33:40
lo que sea. 00:33:42
Vale. 00:33:45
Vale, pues 00:33:47
entonces, como veis, 00:33:48
este es el uso habitual de los constructores 00:33:51
y es tan así que el propio Eclipse 00:33:52
te permite generar esto 00:33:54
automáticamente, como hemos visto que se hace 00:33:56
te pone el super, el super 00:33:58
lo podéis borrar, no hace nada, ya entenderemos 00:34:00
que es el super, esto es lo que se llama 00:34:02
el constructor con parámetros 00:34:04
porque tiene un constructor 00:34:06
con parámetros que sirven para inicializar 00:34:08
las propiedades 00:34:10
y veis el eclipse 00:34:11
ya esos parámetros se los da con este 00:34:14
nombre, con lo cual luego tiene que poner el dis, etc 00:34:16
y queda todo estupendo 00:34:18
constructores 00:34:20
cuidado con las generaciones de 00:34:25
código que uno ya se acostuma a generar 00:34:32
el código automáticamente y llega un momento que ya no saben lo que está haciendo. 00:34:33
Pues no. 00:34:36
Constructores 00:34:39
puede haber más de uno. 00:34:39
¿En qué se van a diferenciar? 00:34:42
Ya lo vimos 00:34:44
cuando vimos funciones en la 00:34:45
lista de parámetros. 00:34:48
Puede ser que yo en mi aplicación 00:34:49
no quiera crear siempre las 00:34:51
cafeteras dándole valores. A lo mejor 00:34:53
esta es la cafetera 1. 00:34:56
Pero mi aplicación, por lo que sea, 00:34:57
yo quiero hacer otra cafetera 00:35:00
quiero hacer otra, la cafetera 2 00:35:01
vamos a ver lo que pasa 00:35:06
quiero hacer la cafetera 2 00:35:09
pero a esta no quiero 00:35:12
no quiero darle valores iniciales 00:35:14
no quiero darle valores iniciales 00:35:19
quiero que se cree sin valores y luego yo los inicializo 00:35:20
pues el compilador me va a decir, ojo pero no 00:35:23
tú has sobrescrito el constructor 00:35:26
que había, lo has sobrescrito 00:35:30
y le has puesto parámetros. 00:35:32
Bueno, de repente es un mi país y ya está. 00:35:34
No, más fácil que eso. 00:35:36
Entonces el comercio te dice, 00:35:38
lo has sobrescrito y le has puesto parámetros. 00:35:39
Luego lo siento mucho, 00:35:41
pero vas a tener que ponerle parámetros. 00:35:43
No hay tu tía. 00:35:45
Ah, no. 00:35:46
Es que podemos hacer varios constructores. 00:35:47
Uno con parámetros, 00:35:50
otro sin parámetros, 00:35:52
otro con 20.000 parámetros 00:35:53
para que te haga 1.000 cosas. 00:35:54
Podemos hacer tantos constructores como queramos. 00:35:56
El orden de capacidad y cantidad 00:35:58
siempre va a tener que tener el mismo orden. 00:36:00
si pones dos parámetros 00:36:01
y luego en la siguiente pones tres parámetros 00:36:03
Sí, sí, sí, sí, claro, eso es como las funciones 00:36:05
el orden tiene, claro 00:36:08
claro, entonces yo podría 00:36:09
hacer aquí un constructor 00:36:11
cafetera 00:36:13
cafetera 00:36:15
que se limitará a saludar 00:36:17
es que como lo he generado se me ha quitado el saludo 00:36:19
lo tenía yo aquí puesto 00:36:21
podría hacerme yo un constructor 00:36:22
que se limitará a saludar 00:36:25
sin más, este 00:36:27
y no pasa nada 00:36:28
y los dos pueden coexistir perfectamente 00:36:31
porque 00:36:33
se distinguen perfectamente 00:36:34
a cuál estoy llamando, depende de los parámetros 00:36:37
que pase, esto lo vimos cuando hicimos 00:36:39
funciones, puede haber dos funciones 00:36:41
que se llamen igual, cuando sé si estoy llamando 00:36:43
a una o a la otra, depende 00:36:45
de la lista de parámetros 00:36:47
pues aquí no hay ambigüedad 00:36:48
se llaman igual, esto es lo que se llama 00:36:50
sobrecarga de métodos 00:36:53
overload 00:36:55
o como lo queráis llamar 00:36:56
vale, es decir 00:36:58
El constructor este está sobrecargado. 00:37:00
Sobrecargado significa que tiene un huevo de trabajo. 00:37:04
Es decir, aparece muchas veces. 00:37:06
El pobre está sobrecargado. 00:37:08
Tiene dos trabajos, este y este, tiene dos. 00:37:09
Por eso está sobrecargado de trabajo. 00:37:12
¿Cuándo distingue el constructor si le han pedido este trabajo o le han pedido este? 00:37:15
¿Cuándo lo distingue? 00:37:19
Pues si le han pasado parámetros o no le han pasado. 00:37:21
Así distingue el constructor si tiene que hacer este trabajo o tiene que hacer este de los dos que le sobrecargan. 00:37:23
entonces aquí 00:37:29
aquí no hay duda 00:37:30
de que constructor le han pedido 00:37:33
el de arriba 00:37:35
aquí no hay duda de cual le han pedido 00:37:36
el de abajo 00:37:40
vale 00:37:41
aquí estará haciendo el de abajo, aquí el de arriba 00:37:43
entonces constructores puede haber 00:37:46
muchos 00:37:48
pero tienen que cambiar, tienen que variar 00:37:48
en los parámetros 00:37:51
porque es la forma de distinguir 00:37:52
vale, que me calle ya 00:37:54
lo que quiero decir 00:37:59
Bueno 00:38:00
Ya todo el mundo se ha aprendido en la cabeza 00:38:07
Lo que es un constructor, cómo se usa, etc 00:38:10
Y ya no se le va a olvidar nunca jamás 00:38:12
Y si prevé que se le va a olvidar 00:38:13
Se lo va a mirar esta tarde, ¿no? 00:38:15
Vale 00:38:19
Bueno, pues ahora ya 00:38:19
Esta aplicación tampoco merece la pena que hagamos mucho más 00:38:21
Pues uno aquí podría hacer un menú 00:38:24
¿Qué quieres? ¿Llenarla? ¿Servir taza? 00:38:25
Pues ya, llamar a los métodos 00:38:27
Vamos a servir una taza 00:38:28
en la cafetera 00:38:30
la cafetera 2 00:38:33
que está vacía 00:38:38
porque no le hemos inicializado las propiedades 00:38:38
pues podemos servir una taza 00:38:41
que tenga capacidad 45 00:38:44
pues si miramos la 00:38:48
cantidad actual va a seguir a 0 00:38:49
no hemos podido servirla 00:38:51
bueno, ya aquí se trata de probar 00:38:52
los métodos, hacer un mail, lo que queráis 00:38:54
para, ya está 00:38:56
Para ver como, aquí ya podéis hacer un main y probar 00:38:57
Servirla 00:39:01
Una taza, mirar después la cantidad 00:39:02
Que tiene, para ver si realmente 00:39:04
La ha servido esa cantidad o no 00:39:07
Pues ya nada, este main ya lo hacéis 00:39:08
Probáis 00:39:10
Y para ver que funciona 00:39:11
Vale, pues nos vamos al recreo 00:39:14
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:
15
Fecha:
5 de diciembre de 2024 - 18:35
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
167.83 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid