Saltar navegación

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

Clase 8-01-24 - 4 - Contenido educativo

Ajuste de pantalla

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

Subido el 8 de enero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues en este caso el main sería el software de la cafetera, simplemente. 00:00:00
Entonces, un main realista en este caso sería una interfaz gráfica 00:00:10
con los botoncitos de vaciar, servir taza, agregar. 00:00:15
Ese sería un main realista, una interfaz gráfica. 00:00:22
Como no sabemos hacer interfaces gráficas, pues un main más o menos realista podría ser un menú. 00:00:26
Vamos a hacerlo rápidamente para que se quede esto completo. 00:00:33
Esto lo dejo aquí comentado, que es con lo que hemos ejemplificado de los constructores. 00:00:37
A ver, pues un main realista podría ser un menú para hacer las acciones con la cafetera. 00:00:45
Las cuatro opciones que se pueden hacer son llenarla, servir, vaciar y agregar. 00:01:04
Pues serían llenar cafetera. 00:01:17
Otra opción que se puede dar dando al botoncito de la máquina, vaciarla. 00:01:35
Otra opción que se puede dar dándole al botoncito correspondiente, servir taza. 00:01:42
Y otra opción que se puede hacer, esta era, nos falta agregar café a la cafetera. 00:01:55
Estas serían las cuatro opciones. 00:02:18
Y ahora ya el switch case de toda la vida y en función de la opción que hayamos elegido en la cafetera. 00:02:33
Pues si se ha elegido la opción uno, habrá que llamar al método llenar cafetera. 00:02:50
¿Qué cafetera? Vamos a crearla, la cafetera está sin inicializar. 00:02:55
A ver, Andoni, vente aquí al lado de Adrián que te echa de menos. 00:03:00
Ya, ya, ya están los huevos de vosotros. Vente aquí para adelante. 00:03:07
¿Tú tienes portátil, Diego? 00:03:31
Pues ponte en el de Moisés, por favor. 00:03:45
Bueno, el siguiente candidato es Moisés o María. 00:04:00
Vale, a ver, en el caso uno, la cafetera todavía está sin inicializar. 00:04:11
Entonces cuando arranca este programa, cuando arranca el programa, es el momento en el que encendemos la cafetera. 00:04:15
En el momento de encenderla será cuando la cafetera se inicializa y todo eso. 00:04:21
Pues entonces en el momento de arrancar el programa será cuando ocurra esto. 00:04:26
Vamos a hacerlo, voy a copiar esto mismo. 00:04:34
O sea, cuando arranca el programa, la cafetera se creará y se inicializará con estos valores. 00:04:47
A ver, en una situación real, la cafetera cuando la encendemos no nos pide los valores, los detecta. 00:04:54
Detecta la capacidad máxima y con ella crea la cafetera. 00:05:02
Y detecta la cantidad que haya de café en ese momento y con ella crea la cafetera aquí. 00:05:06
Es decir, esta parte no nos la pedirá a nosotros. 00:05:12
En el momento de arrancar el software, estas dos variables se cargarán con lo que detecte la cafetera que hay en ese momento. 00:05:15
Se cargarán. En nuestro caso no están conectados los sensores que pueden detectar nada. 00:05:23
Por eso no nos los pide. 00:05:27
Lo que importa es que se tiene que crear este objeto. 00:05:29
Ya hemos leído cft sin más. 00:05:33
Y una vez que se ha creado el objeto con los valores, ahora ya el software trabajará y dirá, a ver, ¿qué quieres hacer? 00:05:36
Y así estará todo el rato. 00:05:43
Que lo que queremos es llenar la cafetera. 00:05:45
Pues ala, facilísimo, ya está. Ya está hecho. 00:05:48
Y el break. 00:05:53
Que lo que queremos es vaciar la cafetera. 00:05:57
Pues de nuevo, ya está, facilísimo. Ya está hecho. 00:06:02
Que lo que queremos es servir una taza. 00:06:11
Pues antes de servirla, habrá que preguntar de cuánto volumen es. 00:06:14
En un caso real, la cafetera no nos pregunta de cuánto volumen es. 00:06:18
En el momento de meter la taza, pues lo detectaría. 00:06:22
Y al detectarlo ya, llamaría el método con ese valor. 00:06:24
En nuestro caso no hay ese sensor que detecte, pues nos lo pregunta. 00:06:27
Nos lo pregunta. 00:06:40
Y una vez que tenemos ya ese volumen, 00:06:45
una vez que tenemos ya ese volumen, ahora ya podemos servir la taza. 00:06:52
Ala, ya está. 00:07:00
Y ya estaría. 00:07:04
Y el caso cuatro, que es agregar café, pues lo mismo. 00:07:06
Agregar café, nos tendría que, de alguna manera hay que decirle al software de la cafetera, 00:07:10
hay que decirle cuánto vamos a agregar. 00:07:15
Pues en este caso no hay otro método que nos lo pregunte por consola, 00:07:19
porque tenemos sensor y no tenemos nada. 00:07:23
Bueno, pues una vez que 00:07:33
una vez que ya sabe la cafetera cuánto café va a agregar, 00:07:41
una vez que ya lo sabe, porque lo ha detectado por sus sensores, 00:07:45
porque en este caso nos lo ha preguntado por consola, 00:07:48
pues ya está, ya podemos... 00:07:51
Y ya estaría todo ese software hecho. 00:07:59
Podríamos poner aquí una opción default, 00:08:02
que fuera opción incorrecta y ya está. 00:08:06
Y podríamos poner la opción apagar. 00:08:11
Y si ponemos la opción apagar... 00:08:23
Vale, pues entonces ahora ya con la opción apagar, 00:08:41
este do while acabará aquí, aquí, 00:08:44
mientras la opción sea diferente de la cinco, que es la de apagar. 00:08:47
Cuando ya le hemos dado a apagar, ya el programa sale y el programa termina. 00:08:53
Ya está, pues ya se apaga. Se apaga la cafetera y listo. 00:08:57
Bueno, pues este sería nuestro main. 00:09:01
Entonces nuestro main se limita a inicializar la taza. 00:09:05
Perdón, inicializar la cafetera, 00:09:10
crearla e inicializarla y luego ir a trabajar con ella todo el rato, 00:09:13
llenándola, vaciándola, llamándolo a los métodos que hemos hecho. 00:09:17
Ya está, llama a los métodos y se acabó. 00:09:22
Vale, vamos a probar por si algo se nos ha escapado y no nos funciona. 00:09:28
Claro, para la segunda porque como he hecho un copia y pega, 00:09:34
ahí queda el mensaje muy feo. Vamos a cambiarlo. 00:09:37
La capacidad máxima para la cafetera. 00:09:40
Así mejor. 00:09:47
Vale, vamos a ver si nos funcionaría. 00:09:49
Venga, pues esta cafetera que acaba de arrancar tiene hasta 200. 00:09:54
¿Qué cantidad actual tiene en el momento del arranque? 00:09:58
En el momento del arranque no lo detecta ella sola. 00:10:01
En el momento del arranque tiene 50. 00:10:04
Vale, y ahora ya empieza el software. 00:10:07
Venga, vamos a llenarla. 00:10:10
Pues ya está llenada. 00:10:12
Vamos a... lo que pasa es que como no tenemos una opción de menú, 00:10:16
que sería interesante ver la cantidad que tiene en ese momento, 00:10:19
no podemos comprobar si lo está haciendo bien o mal, 00:10:22
servir taza. 00:10:25
¿De qué vas a servir la taza? Pues la voy a servir de 30. 00:10:27
Pues ya está, ya está servida. 00:10:30
Vamos a agregar café. ¿Cuánto quieres agregar? Pues 50. 00:10:34
Si hubiéramos incorporado un menú que fuera ver la cantidad actual que tiene, 00:10:39
podríamos comprobar si realmente el servir taza y agregar y está funcionando, 00:10:44
pero bueno, es evidente que va a estar funcionando. 00:10:48
Y así ya está. Entonces, bueno, no parece que se nos haya escapado nada. 00:10:51
Bueno, pues esto ya está. 00:11:05
Entonces este ejercicio implica una única clase, 00:11:10
porque solo hay una entidad con la que trabajar, la cafetera, 00:11:14
y ahora ya el main, sí o sí. 00:11:17
Lo normal es que una aplicación tenga muchas más clases 00:11:20
y un main ya que trabaja con muchas de ellas. 00:11:23
La siguiente, por ejemplo, ya he incorporado dos clases. 00:11:31
Se supone que este ejercicio 4 es una aplicación para gestionar 00:11:37
el número de funciones y los precios que tiene un teatro. 00:11:42
Se supone que este ejercicio 4 es una aplicación para gestionar 00:11:50
pues nada, para gestionar el número de funciones 00:11:55
y los precios que tiene un teatro. 00:12:00
Entonces, nos dicen eso así en general. 00:12:07
Pues nada, un teatro puede tener varias funciones, 00:12:10
bueno, en este caso solo 4, va a tener 4 funciones cada día, 00:12:13
cada función va a tener un nombre, un precio, 00:12:18
el teatro a su vez tiene las funciones y tiene el nombre, 00:12:20
y vas a tener que gestionar cositas de eso. 00:12:23
Vale, pues entonces, después de hacer el análisis, 00:12:27
aquí llegaríamos rápidamente a la conclusión 00:12:30
de que aquí hacen falta dos clases, 00:12:32
porque hay dos entidades a gestionar. 00:12:34
El teatro, que tiene nombre y funciones, 00:12:37
pero es que cada función no puede ser un simple string, 00:12:40
o un simple int, no, porque cada función a su vez 00:12:44
tiene dentro nombre y precio, 00:12:48
con lo cual ya son dos entidades, 00:12:52
del momento en que necesitamos algo, 00:12:54
que no puedo describir con un simple string 00:12:56
o con un simple número, pues necesito una clase para ello. 00:12:58
Y función no la puedo describir con un simple string 00:13:03
o un simple número, porque función tiene dentro nombre, 00:13:05
precio, con lo cual función tiene su propia clase. 00:13:08
Y teatro tiene su propia clase, 00:13:12
porque tiene dentro su nombre, sus funciones, 00:13:14
luego ya son dos clases, 00:13:17
cada una de ellas con sus apartaditos dentro, 00:13:19
ya son dos clases. 00:13:21
Vale, pues entonces se empieza a programar 00:13:23
desde la más pequeñita hasta la más grande, 00:13:25
entonces teatro va a contener dentro funciones. 00:13:27
Pues primero programa función, que no depende de nadie. 00:13:30
Y luego ya programa teatro, 00:13:33
que depende de la existencia de funciones, 00:13:34
porque teatro tiene dentro funciones. 00:13:36
Entonces primero programa la que no necesita 00:13:39
de las demás para existir. 00:13:41
Pues aquí función no necesita de las demás, 00:13:43
porque función tiene nombre, que es un string, 00:13:45
y precio, que es un int. 00:13:47
Ya está. 00:13:49
Pues puedo programar función perfectamente, 00:13:50
que no depende de nadie. 00:13:52
Nombre, string, precio, int. 00:13:53
Pues esa es la primera que programamos. 00:13:55
Función, que la tenemos perfectamente caracterizada. 00:13:57
Tiene nombre y precio. 00:14:00
Vale, pues venga. 00:14:04
Cuatro. 00:14:06
Pues venga, la primera que programaríamos 00:14:17
sería esa función. 00:14:19
Public fuera. 00:14:28
¿Qué caracteriza a cada función? 00:14:32
El nombre y el precio, ¿no? 00:14:35
Es lo que decía el enunciado. 00:14:38
Nombre y precio. 00:14:40
Decido yo qué tipo de dato refleja mejor 00:14:42
esas propiedades. 00:14:46
El nombre, un string, está claro. 00:14:47
Ese es el tipo de dato que mejor lo refleja. 00:14:50
El precio, pues un daven. 00:14:52
No hacen falta más propiedades. 00:14:56
Pues ya está. 00:14:58
Las propiedades de función están. 00:14:59
Lo siguiente que hacemos siempre por sistema, 00:15:03
por su utilidad. 00:15:06
El constructor con parámetros. 00:15:08
Para la vez que instanciamos, 00:15:10
dar valor a las propiedades. 00:15:12
Ahora ya tenemos el constructor con... 00:15:21
...el constructor con parámetros. 00:15:24
Vale, a ver. 00:15:36
¿Función es interesante que tenga algún método? 00:15:37
¿O me han dicho aquí que tiene que tener algún método 00:15:40
para hacer cosas? 00:15:43
Porque aquí ya me dan el diseño hecho. 00:15:44
Vale. 00:15:48
El precio de una función 00:15:50
tiene que poder ser cambiado. 00:15:52
Bueno, pues aquí ya identifico una primera acción 00:15:55
a realizar con las funciones. 00:15:58
Cambiar su precio. 00:16:00
¿Vale? 00:16:02
Esa es una acción que afecta a las funciones. 00:16:03
Cambiar el precio de la función. 00:16:06
Luego, como es una acción que afecta a la función, 00:16:08
el mejor sitio para que estés en un método 00:16:12
de la clase función. 00:16:14
¿Vale? 00:16:16
Pero de nuevo insisto lo de siempre. 00:16:17
Diseños para una aplicación hay millones. 00:16:20
¿Vale? 00:16:23
Hay millones. 00:16:24
De alguna manera hay que seguir ciertas pautas, 00:16:25
ciertos estilos de programación. 00:16:27
Entonces las acciones que trabajan con un objeto 00:16:29
dentro de una aplicación, 00:16:32
lo ideal es que yo las recoja todas ellas 00:16:34
en un método de esa clase. 00:16:37
Podría no diseñarlo así. 00:16:39
Y podría hacer un mail que hace todo eso. 00:16:40
Cambiar el precio de la función, 00:16:42
llamando directamente la propiedad precio, 00:16:44
pero sería una aplicación muy mal hecha. 00:16:46
Mejor lo meto en un método. 00:16:48
Y el mail que llame al método y se acabó. 00:16:50
Me va a quedar el mail mucho más claro. 00:16:52
Bueno, pues este es un caso. 00:16:54
Hay una acción que trabaja sobre la función, 00:16:56
que es cambiar un precio. 00:16:58
Pues el sitio ideal para que esté esa acción 00:17:00
es guardadita en un método 00:17:02
dentro de la clase función. 00:17:04
Eso es un sitio ideal para estar. 00:17:05
Y no en un mail, no en el mail. 00:17:07
El sitio ideal es que esté ahí. 00:17:09
Pues venga, vamos a hacer un método. 00:17:11
¡Adiós! 00:17:13
Vamos a hacer un método 00:17:16
dentro de la clase función 00:17:18
para cambiar el precio. 00:17:20
Vale. 00:17:22
Pues el nombre está claro. 00:17:25
¿Necesito alguna información desde fuera 00:17:27
para cambiar el precio? 00:17:29
¿Sí o no? 00:17:32
¿Eh? 00:17:35
No, el precio nuevo, claro. 00:17:36
Pues bueno, imaginemos que... 00:17:39
Lo podríamos llamar precio. 00:17:42
Bueno, por variar lo llamo nuevo precio. 00:17:44
Y en este caso estamos en el de siempre. 00:17:46
El método es esto. 00:17:49
No es más que esto. 00:17:51
¿Vale? 00:17:52
No es más que esto. 00:17:53
Luego no necesita devolver nada 00:17:54
porque el efecto, la acción del método 00:17:57
ya se queda reflejado 00:17:59
en la modificación que hace de este precio. 00:18:02
Esta propiedad se queda modificada. 00:18:05
Se queda modificada. 00:18:07
Se queda modificada y ese es su efecto. 00:18:09
Aquí el dis de nuevo no me hace ninguna falta. 00:18:12
Bueno, pues a la... 00:18:16
Estas funciones 00:18:18
se caracterizan por su nombre y precio 00:18:20
y además puedo cambiarles el precio 00:18:22
si me da la gana. 00:18:24
No puedo cambiarles el nombre, 00:18:25
no puedo hacer otras cosas, 00:18:27
pero cambiar el precio a través de este método sí. 00:18:28
Vale. 00:18:31
Siguiente clase. 00:18:32
Teatro. 00:18:33
Teatro dependía de función 00:18:34
porque teatro tiene dentro objetos función. 00:18:36
Luego, por eso hemos probado función antes, 00:18:38
la que no depende de ninguna otra. 00:18:40
Pues venga, la clase teatro. 00:18:43
Vale. 00:19:02
Pues esta clase, ¿por qué se caracteriza? 00:19:03
Un teatro tiene 00:19:06
su nombre, 00:19:08
eso está claro, un string, no hay tutía. 00:19:10
Y luego tiene dentro 00:19:12
cuatro funciones distintas que representa. 00:19:14
Cuatro funciones, cada una de ellas con su nombre y su precio. 00:19:16
Tiene cuatro funciones. 00:19:18
Entonces, hombre, bueno, 00:19:20
pues tal y como me han planteado este enunciado, 00:19:22
pues puedo resolverlo 00:19:24
de diferentes maneras. 00:19:26
Esta en realidad sería una, ¿verdad? 00:19:28
Su nombre, 00:19:30
está claro, es este. 00:19:32
Y además tiene dentro 00:19:34
cuatro objetos función 00:19:36
que caracterizan a ese teatro. 00:19:38
Pues hombre, podríamos hacer esto, ¿no? 00:19:40
Esto lo puedo hacer, no está mal. 00:19:48
F1 es la primera función, 00:19:51
toda ella, de ese teatro. 00:19:53
F2 es la segunda función, toda ella. 00:19:55
F3 es la tercera función, toda ella. 00:19:57
Y F4 es la cuarta función, 00:19:59
cada una de ellas tiene su nombre y su precio. 00:20:01
Vale, no penséis que, hombre, 00:20:04
queda un poco feo, ¿no? 00:20:06
Cuando ya empiezan a ser una, dos, tres, 00:20:08
queda un poco feo. 00:20:10
Sería casi mejor meterlo en una estructura de datos. 00:20:12
Ahora mismo, como estructura de datos, 00:20:14
solo conocemos el array. 00:20:16
Entonces, 00:20:18
mucho mejor 00:20:20
así, más bonito. 00:20:22
Y así hago esta clase 00:20:24
más genérica. 00:20:26
Porque así de golpe 00:20:28
me he hecho una clase de teatro 00:20:30
que puede contener cuatro. 00:20:32
Pero si en un momento dado 00:20:34
el teatro cambia y puede albergar hasta siete, 00:20:36
pues también caben siete ahí. 00:20:38
Entonces la he hecho 00:20:40
más genérica que la otra 00:20:42
que tenía solo F1, F2, F3 y F4. 00:20:44
Bueno, pues 00:20:48
entonces, esto 00:20:50
es lo que se conoce 00:20:52
como agregación en realidad, 00:20:54
pero es un nombre que no nos dice nada 00:20:56
que nosotros no sepamos. 00:20:58
Una clase puede tener propiedades 00:21:00
que a su vez son de otra clase. 00:21:02
Anda claro, porque las propiedades son variables. 00:21:04
Y las variables pueden ser 00:21:06
primitivo u objeto. Ya lo sabemos 00:21:08
que las variables pueden ser primitiva u objeto. 00:21:10
Pues esta variable es de tipo objeto, 00:21:12
un array de funciones. 00:21:14
Cualquier propiedad puede ser 00:21:16
tipo objeto, tipo primitivo, 00:21:18
la que interese. 00:21:20
Como la clase clientes pedidos 00:21:22
en el ejemplo que arrancamos, 00:21:24
el cliente puede tener 00:21:26
dentro su objeto pedido, claro, ¿por qué no? 00:21:28
Es una variable más. 00:21:30
Bueno, pues eso 00:21:34
se le da nombre, porque a todos se le da nombre. 00:21:36
Y ese nombre es 00:21:38
o agregación o composición, cualquiera de los dos 00:21:40
lo podéis encontrar. 00:21:42
Es decir, 00:21:48
un objeto tenga dentro otro, 00:21:50
es una agregación o una composición. 00:21:52
Vale, entonces el teatro este, 00:21:58
pues, 00:22:00
como siempre, lo ideal es que uno haga un constructor. 00:22:02
Vale, a ver, 00:22:24
ya está enunciado, ¿hay algún otro método 00:22:26
que interese poner en función para que luego 00:22:28
llame el main? 00:22:30
Cambiar, 00:22:34
cambiar el nombre del teatro. 00:22:36
Bueno, pues venga, vamos a 00:22:38
cambiar el nombre del teatro. Pues cambiar el nombre 00:22:42
del teatro tiene poco que 00:22:44
poner. 00:22:46
Cambiar nombre, 00:22:50
pues habrá que pedir el nombre nuevo, 00:22:52
habrá que pasarle el nombre nuevo 00:22:54
y ya está. 00:22:56
Y dárselo. 00:22:58
Vale, 00:23:04
entonces vamos a añadir algún otro método 00:23:06
para poder hacer algún main un poco más operativo. 00:23:08
Vale, y para trabajar 00:23:10
un poco con este array. 00:23:12
Porque si no, 00:23:14
se nos queda aquí el main 00:23:16
que le va a tocar hacerlo todo el main. 00:23:18
Bueno. 00:23:20
Vale, 00:23:24
vamos a agregar por ejemplo 00:23:26
este método. 00:23:28
Bueno, 00:23:32
no los pongo así, así mejor. 00:23:34
Vale. 00:23:36
Que agrega una 00:23:44
función 00:23:46
al teatro. 00:23:48
Vale, vamos a 00:23:50
cambiar, vamos a 00:23:52
enriquecer 00:23:56
un poco este ejercicio, 00:23:58
vamos a enriquecerlo un poco 00:24:00
y vamos a plantearlo de esta manera. 00:24:02
Vamos a hacer otro constructor diferente, 00:24:04
porque constructores puede haber 00:24:06
todos los que uno quiera. 00:24:08
Vamos a hacer otro constructor que reciba solo el nombre. 00:24:10
Vale, este es otro constructor. 00:24:16
Entonces, este constructor 00:24:18
es muy útil cuando hay 00:24:20
clases que tienen 00:24:22
como propiedades 00:24:24
conjuntos de otras cosas. 00:24:26
Entonces primero creas el objeto 00:24:28
y luego 00:24:30
las funciones que ya se vayan agregando después. 00:24:32
Bueno, pues tiene sentido 00:24:34
ese constructor. 00:24:36
Este constructor lo usaremos 00:24:38
cuando queramos crear 00:24:40
el teatro, primero lo creamos vacío 00:24:42
sin funciones. 00:24:44
Y luego ya a través de un método abajo 00:24:46
vamos agregando funciones 00:24:48
según vayamos queriendo. 00:24:50
¿Vale? 00:24:54
Pues nada, yo aquí tengo, bueno, 00:24:56
me faltaría obviamente completar 00:24:58
el constructor. 00:25:00
Vale, y ahora 00:25:06
vamos a hacer un método que agrega 00:25:08
una función 00:25:10
al teatro. Entonces 00:25:12
devolvería void 00:25:14
porque el resultado de este método 00:25:16
es que este array 00:25:18
incorpore esa otra función. 00:25:20
Entonces el resultado del método 00:25:22
se queda en ese array. 00:25:24
Vale, voy a 00:25:26
agregar función. 00:25:28
¿Qué parámetro le pasamos? 00:25:32
El nuevo objeto 00:25:34
función que hay que agregar a ese array. 00:25:36
Es una variable, 00:25:38
objeto normal de corriente. 00:25:40
Bueno, pues así. 00:25:42
¿Verdad? 00:25:44
Tenemos que 00:25:48
empezar ya a manejar variables primitivas, 00:25:50
variables objeto, en plano 00:25:52
de igualdad completamente. 00:25:54
Me da igual que una variable sea int, 00:25:56
sea función, a la hora 00:25:58
de declararla, a la hora de pasarla como parámetro, 00:26:00
me da igual. 00:26:02
Su funcionamiento no es el mismo 00:26:04
porque esto es una dirección de memoria 00:26:06
que tiene dentro función punto 00:26:08
precio, función punto. 00:26:10
Pero a la hora de declararla y pasarla, 00:26:12
o sea, esta cabecera 00:26:14
a nadie le 00:26:16
produce problemas. Tengo que pasar un objeto 00:26:18
función. Y ahora 00:26:20
este método 00:26:22
tendrá que 00:26:26
agregar esa función 00:26:28
a este array. 00:26:30
Es decir, 00:26:32
hacer el rollo de siempre, 00:26:34
aumentarlo en una posición 00:26:36
y en la posición nueva que he creado 00:26:38
¿vale? 00:26:40
Pues ya está. Podría ser un método. 00:26:42
Vamos a dejarlo hecho 00:26:46
rápidamente. Entonces esto 00:26:48
lo hemos hecho un montón de veces. 00:26:50
Esto sería, haríamos 00:26:52
un array auxiliar de funciones 00:26:54
que 00:27:00
sería así. 00:27:04
Un array de funciones 00:27:06
con una posición más que este otro. 00:27:08
Funciones 00:27:14
punto length 00:27:16
más uno. 00:27:18
¿Verdad? Hacemos un array con una 00:27:20
posición adicional 00:27:22
al de funciones. 00:27:24
Hacemos un array con una posición adicional. 00:27:26
Copiamos uno 00:27:28
en el otro. 00:27:30
Menor que 00:27:32
funciones 00:27:34
punto length. 00:27:36
Incrementando 00:27:38
aux de y 00:27:42
igual a 00:27:44
funciones 00:27:46
de y. 00:27:48
Una vez que hemos terminado de copiar 00:27:50
uno en el otro, en la posición adicional 00:27:52
de aux que hemos creado 00:27:54
que es 00:27:56
aux punto length 00:27:58
menos uno. Es su última 00:28:00
posición. Ponemos 00:28:02
la última función creada. 00:28:04
Y ahora ya 00:28:08
asignamos a funciones aux. 00:28:10
Lo que hemos hecho siempre. 00:28:18
Crea un array adicional con una posición 00:28:24
más. Copia 00:28:26
el viejo en el nuevo, posición 00:28:28
por posición. En la posición 00:28:30
adicional copia el nuevo objeto, 00:28:32
el nuevo elemento y ahora 00:28:34
reasigna para que 00:28:36
funciones ahora pase a ser 00:28:38
el nuevo array. 00:28:40
Este método es un método 00:28:42
que nos permite... Le das un objeto 00:28:44
de función y te lo agrega 00:28:46
el array. 00:28:48
Chao. 00:28:54
Sobre este código en particular. 00:28:58
¿Alguien prevé que en algún 00:29:00
momento, alguna situación pueda haber algún problema? 00:29:02
Seguro que sí, ¿no? 00:29:06
Que la primera vez 00:29:16
que llamemos a agregar función 00:29:18
funciones es null todavía. 00:29:20
La primera vez que lo llamemos. 00:29:22
Entonces funciones punto length 00:29:24
nos va a dar un null pointer exception. 00:29:26
¿No? 00:29:30
Cuando se crea el objeto teatro por primera vez 00:29:32
este array es null. 00:29:34
Ese array es null cuando se crea 00:29:36
por primera vez. Es null. 00:29:38
Con lo cual por... 00:29:40
Si ese array es null 00:29:42
yo no puedo llamar 00:29:44
a funciones punto length 00:29:46
porque esto es null y me va a decir 00:29:48
no puedes hacer llamar a nada de un null. 00:29:50
Te da un null pointer exception. 00:29:52
¿Vale? 00:29:54
Claro, es que aquí 00:29:56
tendríamos que distinguir 00:29:58
si funciones es null 00:30:00
entonces funciones 00:30:02
si funciones 00:30:06
es null 00:30:08
entonces 00:30:12
ahora ya le creamos su primera 00:30:14
posición 00:30:16
y única new 00:30:20
función de uno 00:30:22
y a esa única posición 00:30:32
a esa única posición que acabo de crear 00:30:38
le asignamos esto. 00:30:40
¿Vale? Le asignamos esto. 00:30:42
Y si no 00:30:44
si no es null 00:30:46
entonces ahora ya 00:30:48
sí que 00:30:50
aplica todo esto de aquí. 00:30:52
¿Vale? 00:30:56
Si es la primera vez 00:30:58
que llamo a agregar 00:31:00
función, esto es un null 00:31:02
entonces si es null 00:31:04
lo creo dándole una única 00:31:06
posición y a esa única posición 00:31:08
le asigno esta. Pero si no es 00:31:10
null porque ya tiene posiciones, pues ahora ya 00:31:12
sí. Le doy 00:31:14
un auxiliar con una posición más 00:31:16
copio 00:31:18
el viejo en el nuevo 00:31:20
asigno a la última 00:31:22
posición creada 00:31:24
la función nueva y reasigno. 00:31:26
¿Vale? Esto es 00:31:44
el repaso de lo que hemos 00:31:46
hecho otras veces. ¿Vale? Para que 00:31:48
no se nos olvide programar en general. 00:31:50
Programar en general. 00:31:52
¿Vale? Aquí este else 00:31:54
queda un poco feo porque es un else que 00:31:56
tiene un montón de cosas ahí dentro. 00:31:58
Es un else que queda un poco feo. Entonces me puedo 00:32:00
aprovechar de una cosa 00:32:02
y es acordaros del retune. 00:32:04
¿Para qué me servía el retune en los métodos? 00:32:06
El retune servía cuando yo quería 00:32:08
devolver un valor. Pero es que además 00:32:10
de devolver un valor, finaliza 00:32:12
el método. El método se acaba. Y se acabó. 00:32:14
El método se acaba. Claro, pero es que 00:32:16
el retune lo podemos utilizar también 00:32:18
para salir de un método 00:32:20
void poniendo retune sin nada más. 00:32:22
Entonces 00:32:24
si yo hago aquí un retune 00:32:26
el retune lo puedo poner sin 00:32:30
nada detrás cuando el método 00:32:32
devuelve void. Cuando devuelve 00:32:34
void puedo poner el retune sin nada. 00:32:36
Si el método devuelve int, double, 00:32:38
debo poner el retune con el valor que sea. Con el int, 00:32:40
con el dado, el obligatorio. 00:32:42
Pero si el método devuelve void, pongo el retune sin nada. 00:32:44
¿Y para qué me ha servido 00:32:46
poner aquí el retune? Pues cuando yo 00:32:48
pongo un retune, el método 00:32:50
termina. El método 00:32:52
termina. Con lo cual me ahorro 00:32:54
el tener que poner este else y la 00:32:56
tabulación. 00:32:58
Porque yo ahora ya 00:33:00
quito esto y me queda más bonito. 00:33:02
¿Por qué? 00:33:04
¿Por qué ahora qué ocurre? 00:33:10
Si funcionas es igual a null. 00:33:12
Haces esto y terminas. 00:33:14
Se acabó. No hay más que hacer. 00:33:16
Método acabado. Retune fuera. Se acabó. 00:33:18
Con lo cual nunca llegarías aquí. 00:33:20
Si entró en el if 00:33:22
nunca vas a llegar ahí. Luego no hace falta 00:33:24
ponerlo en un else. No hace falta. 00:33:26
Porque si entró en el if, ahí, paf. 00:33:28
Método terminado. Se acabó. 00:33:30
Entonces no hace falta que yo meta esto en un else. 00:33:32
Porque si ha llegado aquí 00:33:34
es porque no entró en el if. 00:33:36
Si ha llegado aquí es porque no entró en el if. 00:33:38
Luego es como ponerlo en un else. Es igual. 00:33:40
Y así me queda más bonito. No puedo poner 00:33:42
todo eso ahí metido. 00:33:44
¿Vale? Pues entonces 00:33:50
el retune, por tanto, 00:33:52
se puede poner 00:33:54
en un método que devuelva void también. 00:33:56
No es obligatorio. 00:33:58
Como en los métodos que devuelven algo. 00:34:00
En los métodos que devuelven algo el retune es obligatorio. 00:34:02
Hay que poner retune y el valor que siga. 00:34:04
Es obligatorio. 00:34:06
Pero en los métodos que devuelven void el retune 00:34:08
lo puedo poner o no. Porque ya el método va a acabar 00:34:10
en cualquier caso, al final. 00:34:12
Si lo pongo 00:34:14
significa ahí se acaba. 00:34:16
Y lo que hay después 00:34:18
no se va a ejecutar nunca. 00:34:20
Pues en este caso, ¿para qué me sirve ponerlo? 00:34:22
Para ahorrarme el else. 00:34:24
Y para que quede más bonito el código. 00:34:26
Solo para eso. Para que quede más bonito el código. 00:34:28
Me está siguiendo. ¿Vale? 00:34:30
Porque si entró aquí 00:34:34
nunca va a llegar ahí. 00:34:36
Y si llega aquí es que nunca entró aquí. 00:34:38
Entonces me ahorro. 00:34:40
¿Vale? 00:34:42
Vale, entonces 00:34:44
para comprobar 00:34:46
que este agregar función nos funciona 00:34:48
deberíamos hacer un método 00:34:50
que muestre las funciones que tiene el teatro. 00:34:52
Porque si no, vamos a hacer un método 00:34:54
de mostrar funciones. 00:34:56
El método de mostrar funciones 00:35:00
pues vamos a hacerlo con un for each 00:35:02
de estos. Para cada 00:35:04
función f 00:35:06
en las 00:35:08
funciones del teatro 00:35:10
pues vamos a mostrar 00:35:12
nombre 00:35:16
de la función 00:35:18
f.nombre 00:35:22
y precio. 00:35:26
Precio de esa función 00:35:38
f.precio 00:35:40
¿Vale? F es 00:35:46
todas y cada una de las funciones 00:35:48
de ese array. 00:35:50
Pues para cada función 00:35:52
me va a mostrar su nombre 00:35:54
y su precio. Porque f es un objeto. 00:35:56
F es un objeto. 00:35:58
Luego de f lo que tiene sentido mostrar son 00:36:00
sus propiedades internas. 00:36:02
Es lo que tiene sentido mostrar. 00:36:04
Entonces de cada función f de este array 00:36:06
muestro su nombre y su precio. 00:36:08
¿Vale? 00:36:10
¿Vale? Pues ya tenemos la clase 00:36:14
teatro con 00:36:16
me falta la 00:36:22
esta. 00:36:24
¿Vale? Ya tenemos la clase teatro 00:36:28
con un constructor 00:36:30
que le da nombre 00:36:32
con el método agregar función 00:36:34
y mostrar función. 00:36:36
Vamos a hacer un main rápidamente 00:36:38
para ver que esto funciona. 00:36:40
Nos vamos. 00:36:44
Vamos a hacer rápidamente un main. A ver. 00:36:46
Pues venga, vamos a crear el teatro 00:36:56
lo primero. 00:36:58
Vamos a crear el teatro. 00:37:04
Para no perder el tiempo pidiendo 00:37:06
por teclado lo voy a 00:37:08
dar directamente el nombre. 00:37:10
Uy. 00:37:16
Vale. 00:37:30
Entonces el teatro está creado con ese nombre. 00:37:32
Pero su array de funciones es nulo. 00:37:34
No tiene ninguna función. 00:37:36
Venga, pues vamos a ir agregándole funciones 00:37:38
y luego mostrándolas a ver si las agrega. 00:37:40
Pues por ejemplo, vamos a crear aquí 00:37:42
una función primero. 00:37:44
Una función 00:37:46
F1 a través del constructor. 00:37:48
La voy a crear 00:37:52
en lugar de pedir por teclado para que sea más rápido 00:37:54
le voy a dar directamente los valores. 00:37:56
Pues venga. 00:37:58
Función 1 y el precio 00:38:02
va a ser 54. 00:38:04
Este es un objeto función. 00:38:06
Pues vamos a agregárselo al teatro. 00:38:08
Teatro punto 00:38:10
agregar función F1. 00:38:12
Y vamos a ver si realmente 00:38:14
la ha agregado mostrándolas. 00:38:16
Mostrar funciones. 00:38:18
Vamos a hacer 00:38:20
lo mismo con otra función. 00:38:22
Vamos a crear otro objeto 00:38:28
función F2 00:38:30
función 2 00:38:32
precio 64. 00:38:34
Este objeto función 2 00:38:36
lo vamos a agregar al teatro. 00:38:38
Se supone 00:38:40
que lo agregará al array. 00:38:42
Y ahora vamos a mostrar los que tiene. 00:38:44
A ver si ahora en ese segundo mostrar funciones 00:38:46
nos muestra las dos. 00:38:48
¿Vale? Está claro lo que 00:38:50
hemos hecho. Un teatro 00:38:52
con nombre y funciones nul 00:38:54
por ahora. Agregamos 00:38:56
una primera y mostramos. 00:38:58
Agregamos una segunda 00:39:00
y mostramos. A ver si 00:39:02
nos sale algún null point de 00:39:04
deceptio, no lo hace bien. 00:39:06
Pues lo ha hecho bien. 00:39:10
Este es el resultado del primer mostrar 00:39:12
donde solo tenía uno. 00:39:14
Y este es el resultado del 00:39:16
segundo mostrar donde ahora tiene las dos. 00:39:18
Entonces pues sí. 00:39:20
Lo ha hecho bien, ahora tiene 00:39:22
las dos y así podríamos seguir agregando 00:39:24
todas las funciones que hicieran falta. 00:39:26
E ir incorporando métodos 00:39:28
pues la función más cara, suma 00:39:30
de todas las funciones, yo que sé. Ahí esta 00:39:32
aplicación ya podría extenderse 00:39:34
con un montón de métodos, funcionalidades 00:39:36
para el teatro, para las 00:39:38
funciones, para lo que fuera. 00:39:40
¿Vale? Pero su diseño de clases 00:39:42
pues sería este. 00:39:44
Que era lo interesante 00:39:46
de este ejercicio, ver un diseño de este tipo 00:39:48
que puede tener unas propiedades que es 00:39:50
de tipo objeto. 00:39:52
Y a partir 00:39:54
de ahí se puede extender. 00:39:56
Pues función más cara. 00:39:58
Mostrar 00:40:00
el nombre de la 00:40:02
función cuyo precio 00:40:04
rebase no sé qué cantidad. 00:40:06
Pues lo que sea, las funcionalidades que se vayan 00:40:08
necesitando. 00:40:10
¿Vale? ¿Alguna pregunta? 00:40:14
Bueno. 00:40:18
¿Habíais hecho esto en Navidad? 00:40:24
¿Alguien? 00:40:26
¿Miguel? 00:40:28
No te des miedo que te vayan a 00:40:30
fusilar. 00:40:32
Bueno. Pues a ver. 00:40:36
Tenéis esto de aquí 00:40:38
para hacer esta tarde. 00:40:40
Esto que eran 00:40:42
son un poco más sencillos. 00:40:44
Estaban puestos ahí con la idea de 00:40:46
hacer hoy el repaso. 00:40:48
Espero que lo hemos 00:40:50
hecho corrigiendo esto. 00:40:52
Conclusión, que lo estudiéis todo, que lo hagáis todo, 00:40:54
que lo repaséis todo, porque tenemos que contar 00:40:56
muchísimas, muchísimas cosas más. 00:40:58
Muchas más. 00:41:00
Y hay que ir avanzando. 00:41:02
Pues venga. 00:41:04
A estudiarlo todo. 00:41:06
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
8 de enero de 2024 - 13:33
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
783.36 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid