1
00:00:00,000 --> 00:00:10,000
Vale, pues en este caso el main sería el software de la cafetera, simplemente.

2
00:00:10,000 --> 00:00:15,000
Entonces, un main realista en este caso sería una interfaz gráfica

3
00:00:15,000 --> 00:00:22,000
con los botoncitos de vaciar, servir taza, agregar.

4
00:00:22,000 --> 00:00:26,000
Ese sería un main realista, una interfaz gráfica.

5
00:00:26,000 --> 00:00:33,000
Como no sabemos hacer interfaces gráficas, pues un main más o menos realista podría ser un menú.

6
00:00:33,000 --> 00:00:37,000
Vamos a hacerlo rápidamente para que se quede esto completo.

7
00:00:37,000 --> 00:00:45,000
Esto lo dejo aquí comentado, que es con lo que hemos ejemplificado de los constructores.

8
00:00:45,000 --> 00:01:04,000
A ver, pues un main realista podría ser un menú para hacer las acciones con la cafetera.

9
00:01:04,000 --> 00:01:17,000
Las cuatro opciones que se pueden hacer son llenarla, servir, vaciar y agregar.

10
00:01:17,000 --> 00:01:35,000
Pues serían llenar cafetera.

11
00:01:35,000 --> 00:01:42,000
Otra opción que se puede dar dando al botoncito de la máquina, vaciarla.

12
00:01:42,000 --> 00:01:55,000
Otra opción que se puede dar dándole al botoncito correspondiente, servir taza.

13
00:01:55,000 --> 00:02:18,000
Y otra opción que se puede hacer, esta era, nos falta agregar café a la cafetera.

14
00:02:18,000 --> 00:02:33,000
Estas serían las cuatro opciones.

15
00:02:33,000 --> 00:02:50,000
Y ahora ya el switch case de toda la vida y en función de la opción que hayamos elegido en la cafetera.

16
00:02:50,000 --> 00:02:55,000
Pues si se ha elegido la opción uno, habrá que llamar al método llenar cafetera.

17
00:02:55,000 --> 00:03:00,000
¿Qué cafetera? Vamos a crearla, la cafetera está sin inicializar.

18
00:03:00,000 --> 00:03:07,000
A ver, Andoni, vente aquí al lado de Adrián que te echa de menos.

19
00:03:07,000 --> 00:03:31,000
Ya, ya, ya están los huevos de vosotros. Vente aquí para adelante.

20
00:03:31,000 --> 00:03:45,000
¿Tú tienes portátil, Diego?

21
00:03:45,000 --> 00:04:00,000
Pues ponte en el de Moisés, por favor.

22
00:04:00,000 --> 00:04:11,000
Bueno, el siguiente candidato es Moisés o María.

23
00:04:11,000 --> 00:04:15,000
Vale, a ver, en el caso uno, la cafetera todavía está sin inicializar.

24
00:04:15,000 --> 00:04:21,000
Entonces cuando arranca este programa, cuando arranca el programa, es el momento en el que encendemos la cafetera.

25
00:04:21,000 --> 00:04:26,000
En el momento de encenderla será cuando la cafetera se inicializa y todo eso.

26
00:04:26,000 --> 00:04:34,000
Pues entonces en el momento de arrancar el programa será cuando ocurra esto.

27
00:04:34,000 --> 00:04:47,000
Vamos a hacerlo, voy a copiar esto mismo.

28
00:04:47,000 --> 00:04:54,000
O sea, cuando arranca el programa, la cafetera se creará y se inicializará con estos valores.

29
00:04:54,000 --> 00:05:02,000
A ver, en una situación real, la cafetera cuando la encendemos no nos pide los valores, los detecta.

30
00:05:02,000 --> 00:05:06,000
Detecta la capacidad máxima y con ella crea la cafetera.

31
00:05:06,000 --> 00:05:12,000
Y detecta la cantidad que haya de café en ese momento y con ella crea la cafetera aquí.

32
00:05:12,000 --> 00:05:15,000
Es decir, esta parte no nos la pedirá a nosotros.

33
00:05:15,000 --> 00:05:23,000
En el momento de arrancar el software, estas dos variables se cargarán con lo que detecte la cafetera que hay en ese momento.

34
00:05:23,000 --> 00:05:27,000
Se cargarán. En nuestro caso no están conectados los sensores que pueden detectar nada.

35
00:05:27,000 --> 00:05:29,000
Por eso no nos los pide.

36
00:05:29,000 --> 00:05:33,000
Lo que importa es que se tiene que crear este objeto.

37
00:05:33,000 --> 00:05:36,000
Ya hemos leído cft sin más.

38
00:05:36,000 --> 00:05:43,000
Y una vez que se ha creado el objeto con los valores, ahora ya el software trabajará y dirá, a ver, ¿qué quieres hacer?

39
00:05:43,000 --> 00:05:45,000
Y así estará todo el rato.

40
00:05:45,000 --> 00:05:48,000
Que lo que queremos es llenar la cafetera.

41
00:05:48,000 --> 00:05:52,000
Pues ala, facilísimo, ya está. Ya está hecho.

42
00:05:53,000 --> 00:05:55,000
Y el break.

43
00:05:57,000 --> 00:06:01,000
Que lo que queremos es vaciar la cafetera.

44
00:06:02,000 --> 00:06:07,000
Pues de nuevo, ya está, facilísimo. Ya está hecho.

45
00:06:11,000 --> 00:06:14,000
Que lo que queremos es servir una taza.

46
00:06:14,000 --> 00:06:18,000
Pues antes de servirla, habrá que preguntar de cuánto volumen es.

47
00:06:18,000 --> 00:06:22,000
En un caso real, la cafetera no nos pregunta de cuánto volumen es.

48
00:06:22,000 --> 00:06:24,000
En el momento de meter la taza, pues lo detectaría.

49
00:06:24,000 --> 00:06:27,000
Y al detectarlo ya, llamaría el método con ese valor.

50
00:06:27,000 --> 00:06:31,000
En nuestro caso no hay ese sensor que detecte, pues nos lo pregunta.

51
00:06:40,000 --> 00:06:42,000
Nos lo pregunta.

52
00:06:45,000 --> 00:06:49,000
Y una vez que tenemos ya ese volumen,

53
00:06:52,000 --> 00:06:57,000
una vez que tenemos ya ese volumen, ahora ya podemos servir la taza.

54
00:07:00,000 --> 00:07:02,000
Ala, ya está.

55
00:07:04,000 --> 00:07:06,000
Y ya estaría.

56
00:07:06,000 --> 00:07:10,000
Y el caso cuatro, que es agregar café, pues lo mismo.

57
00:07:10,000 --> 00:07:15,000
Agregar café, nos tendría que, de alguna manera hay que decirle al software de la cafetera,

58
00:07:15,000 --> 00:07:18,000
hay que decirle cuánto vamos a agregar.

59
00:07:19,000 --> 00:07:23,000
Pues en este caso no hay otro método que nos lo pregunte por consola,

60
00:07:23,000 --> 00:07:26,000
porque tenemos sensor y no tenemos nada.

61
00:07:33,000 --> 00:07:36,000
Bueno, pues una vez que

62
00:07:41,000 --> 00:07:45,000
una vez que ya sabe la cafetera cuánto café va a agregar,

63
00:07:45,000 --> 00:07:48,000
una vez que ya lo sabe, porque lo ha detectado por sus sensores,

64
00:07:48,000 --> 00:07:51,000
porque en este caso nos lo ha preguntado por consola,

65
00:07:51,000 --> 00:07:54,000
pues ya está, ya podemos...

66
00:07:59,000 --> 00:08:02,000
Y ya estaría todo ese software hecho.

67
00:08:02,000 --> 00:08:05,000
Podríamos poner aquí una opción default,

68
00:08:06,000 --> 00:08:09,000
que fuera opción incorrecta y ya está.

69
00:08:11,000 --> 00:08:14,000
Y podríamos poner la opción apagar.

70
00:08:23,000 --> 00:08:26,000
Y si ponemos la opción apagar...

71
00:08:41,000 --> 00:08:44,000
Vale, pues entonces ahora ya con la opción apagar,

72
00:08:44,000 --> 00:08:47,000
este do while acabará aquí, aquí,

73
00:08:47,000 --> 00:08:52,000
mientras la opción sea diferente de la cinco, que es la de apagar.

74
00:08:53,000 --> 00:08:57,000
Cuando ya le hemos dado a apagar, ya el programa sale y el programa termina.

75
00:08:57,000 --> 00:09:01,000
Ya está, pues ya se apaga. Se apaga la cafetera y listo.

76
00:09:01,000 --> 00:09:04,000
Bueno, pues este sería nuestro main.

77
00:09:05,000 --> 00:09:09,000
Entonces nuestro main se limita a inicializar la taza.

78
00:09:10,000 --> 00:09:13,000
Perdón, inicializar la cafetera,

79
00:09:13,000 --> 00:09:17,000
crearla e inicializarla y luego ir a trabajar con ella todo el rato,

80
00:09:17,000 --> 00:09:21,000
llenándola, vaciándola, llamándolo a los métodos que hemos hecho.

81
00:09:22,000 --> 00:09:25,000
Ya está, llama a los métodos y se acabó.

82
00:09:28,000 --> 00:09:33,000
Vale, vamos a probar por si algo se nos ha escapado y no nos funciona.

83
00:09:34,000 --> 00:09:37,000
Claro, para la segunda porque como he hecho un copia y pega,

84
00:09:37,000 --> 00:09:40,000
ahí queda el mensaje muy feo. Vamos a cambiarlo.

85
00:09:40,000 --> 00:09:44,000
La capacidad máxima para la cafetera.

86
00:09:47,000 --> 00:09:49,000
Así mejor.

87
00:09:49,000 --> 00:09:52,000
Vale, vamos a ver si nos funcionaría.

88
00:09:54,000 --> 00:09:58,000
Venga, pues esta cafetera que acaba de arrancar tiene hasta 200.

89
00:09:58,000 --> 00:10:01,000
¿Qué cantidad actual tiene en el momento del arranque?

90
00:10:01,000 --> 00:10:04,000
En el momento del arranque no lo detecta ella sola.

91
00:10:04,000 --> 00:10:07,000
En el momento del arranque tiene 50.

92
00:10:07,000 --> 00:10:10,000
Vale, y ahora ya empieza el software.

93
00:10:10,000 --> 00:10:12,000
Venga, vamos a llenarla.

94
00:10:12,000 --> 00:10:14,000
Pues ya está llenada.

95
00:10:16,000 --> 00:10:19,000
Vamos a... lo que pasa es que como no tenemos una opción de menú,

96
00:10:19,000 --> 00:10:22,000
que sería interesante ver la cantidad que tiene en ese momento,

97
00:10:22,000 --> 00:10:25,000
no podemos comprobar si lo está haciendo bien o mal,

98
00:10:25,000 --> 00:10:27,000
servir taza.

99
00:10:27,000 --> 00:10:30,000
¿De qué vas a servir la taza? Pues la voy a servir de 30.

100
00:10:30,000 --> 00:10:33,000
Pues ya está, ya está servida.

101
00:10:34,000 --> 00:10:38,000
Vamos a agregar café. ¿Cuánto quieres agregar? Pues 50.

102
00:10:39,000 --> 00:10:44,000
Si hubiéramos incorporado un menú que fuera ver la cantidad actual que tiene,

103
00:10:44,000 --> 00:10:48,000
podríamos comprobar si realmente el servir taza y agregar y está funcionando,

104
00:10:48,000 --> 00:10:51,000
pero bueno, es evidente que va a estar funcionando.

105
00:10:51,000 --> 00:10:55,000
Y así ya está. Entonces, bueno, no parece que se nos haya escapado nada.

106
00:11:05,000 --> 00:11:08,000
Bueno, pues esto ya está.

107
00:11:10,000 --> 00:11:14,000
Entonces este ejercicio implica una única clase,

108
00:11:14,000 --> 00:11:17,000
porque solo hay una entidad con la que trabajar, la cafetera,

109
00:11:17,000 --> 00:11:20,000
y ahora ya el main, sí o sí.

110
00:11:20,000 --> 00:11:23,000
Lo normal es que una aplicación tenga muchas más clases

111
00:11:23,000 --> 00:11:26,000
y un main ya que trabaja con muchas de ellas.

112
00:11:31,000 --> 00:11:36,000
La siguiente, por ejemplo, ya he incorporado dos clases.

113
00:11:37,000 --> 00:11:42,000
Se supone que este ejercicio 4 es una aplicación para gestionar

114
00:11:42,000 --> 00:11:49,000
el número de funciones y los precios que tiene un teatro.

115
00:11:50,000 --> 00:11:55,000
Se supone que este ejercicio 4 es una aplicación para gestionar

116
00:11:55,000 --> 00:12:00,000
pues nada, para gestionar el número de funciones

117
00:12:00,000 --> 00:12:05,000
y los precios que tiene un teatro.

118
00:12:07,000 --> 00:12:10,000
Entonces, nos dicen eso así en general.

119
00:12:10,000 --> 00:12:13,000
Pues nada, un teatro puede tener varias funciones,

120
00:12:13,000 --> 00:12:17,000
bueno, en este caso solo 4, va a tener 4 funciones cada día,

121
00:12:18,000 --> 00:12:20,000
cada función va a tener un nombre, un precio,

122
00:12:20,000 --> 00:12:23,000
el teatro a su vez tiene las funciones y tiene el nombre,

123
00:12:23,000 --> 00:12:27,000
y vas a tener que gestionar cositas de eso.

124
00:12:27,000 --> 00:12:30,000
Vale, pues entonces, después de hacer el análisis,

125
00:12:30,000 --> 00:12:32,000
aquí llegaríamos rápidamente a la conclusión

126
00:12:32,000 --> 00:12:34,000
de que aquí hacen falta dos clases,

127
00:12:34,000 --> 00:12:37,000
porque hay dos entidades a gestionar.

128
00:12:37,000 --> 00:12:40,000
El teatro, que tiene nombre y funciones,

129
00:12:40,000 --> 00:12:44,000
pero es que cada función no puede ser un simple string,

130
00:12:44,000 --> 00:12:48,000
o un simple int, no, porque cada función a su vez

131
00:12:48,000 --> 00:12:52,000
tiene dentro nombre y precio,

132
00:12:52,000 --> 00:12:54,000
con lo cual ya son dos entidades,

133
00:12:54,000 --> 00:12:56,000
del momento en que necesitamos algo,

134
00:12:56,000 --> 00:12:58,000
que no puedo describir con un simple string

135
00:12:58,000 --> 00:13:03,000
o con un simple número, pues necesito una clase para ello.

136
00:13:03,000 --> 00:13:05,000
Y función no la puedo describir con un simple string

137
00:13:05,000 --> 00:13:08,000
o un simple número, porque función tiene dentro nombre,

138
00:13:08,000 --> 00:13:12,000
precio, con lo cual función tiene su propia clase.

139
00:13:12,000 --> 00:13:14,000
Y teatro tiene su propia clase,

140
00:13:14,000 --> 00:13:17,000
porque tiene dentro su nombre, sus funciones,

141
00:13:17,000 --> 00:13:19,000
luego ya son dos clases,

142
00:13:19,000 --> 00:13:21,000
cada una de ellas con sus apartaditos dentro,

143
00:13:21,000 --> 00:13:23,000
ya son dos clases.

144
00:13:23,000 --> 00:13:25,000
Vale, pues entonces se empieza a programar

145
00:13:25,000 --> 00:13:27,000
desde la más pequeñita hasta la más grande,

146
00:13:27,000 --> 00:13:30,000
entonces teatro va a contener dentro funciones.

147
00:13:30,000 --> 00:13:33,000
Pues primero programa función, que no depende de nadie.

148
00:13:33,000 --> 00:13:34,000
Y luego ya programa teatro,

149
00:13:34,000 --> 00:13:36,000
que depende de la existencia de funciones,

150
00:13:36,000 --> 00:13:39,000
porque teatro tiene dentro funciones.

151
00:13:39,000 --> 00:13:41,000
Entonces primero programa la que no necesita

152
00:13:41,000 --> 00:13:43,000
de las demás para existir.

153
00:13:43,000 --> 00:13:45,000
Pues aquí función no necesita de las demás,

154
00:13:45,000 --> 00:13:47,000
porque función tiene nombre, que es un string,

155
00:13:47,000 --> 00:13:49,000
y precio, que es un int.

156
00:13:49,000 --> 00:13:50,000
Ya está.

157
00:13:50,000 --> 00:13:52,000
Pues puedo programar función perfectamente,

158
00:13:52,000 --> 00:13:53,000
que no depende de nadie.

159
00:13:53,000 --> 00:13:55,000
Nombre, string, precio, int.

160
00:13:55,000 --> 00:13:57,000
Pues esa es la primera que programamos.

161
00:13:57,000 --> 00:14:00,000
Función, que la tenemos perfectamente caracterizada.

162
00:14:00,000 --> 00:14:04,000
Tiene nombre y precio.

163
00:14:04,000 --> 00:14:06,000
Vale, pues venga.

164
00:14:06,000 --> 00:14:08,000
Cuatro.

165
00:14:17,000 --> 00:14:19,000
Pues venga, la primera que programaríamos

166
00:14:19,000 --> 00:14:21,000
sería esa función.

167
00:14:28,000 --> 00:14:30,000
Public fuera.

168
00:14:32,000 --> 00:14:35,000
¿Qué caracteriza a cada función?

169
00:14:35,000 --> 00:14:38,000
El nombre y el precio, ¿no?

170
00:14:38,000 --> 00:14:40,000
Es lo que decía el enunciado.

171
00:14:40,000 --> 00:14:42,000
Nombre y precio.

172
00:14:42,000 --> 00:14:46,000
Decido yo qué tipo de dato refleja mejor

173
00:14:46,000 --> 00:14:47,000
esas propiedades.

174
00:14:47,000 --> 00:14:50,000
El nombre, un string, está claro.

175
00:14:50,000 --> 00:14:52,000
Ese es el tipo de dato que mejor lo refleja.

176
00:14:52,000 --> 00:14:54,000
El precio, pues un daven.

177
00:14:56,000 --> 00:14:58,000
No hacen falta más propiedades.

178
00:14:58,000 --> 00:14:59,000
Pues ya está.

179
00:14:59,000 --> 00:15:02,000
Las propiedades de función están.

180
00:15:03,000 --> 00:15:06,000
Lo siguiente que hacemos siempre por sistema,

181
00:15:06,000 --> 00:15:08,000
por su utilidad.

182
00:15:08,000 --> 00:15:10,000
El constructor con parámetros.

183
00:15:10,000 --> 00:15:12,000
Para la vez que instanciamos,

184
00:15:12,000 --> 00:15:14,000
dar valor a las propiedades.

185
00:15:21,000 --> 00:15:24,000
Ahora ya tenemos el constructor con...

186
00:15:24,000 --> 00:15:31,000
...el constructor con parámetros.

187
00:15:36,000 --> 00:15:37,000
Vale, a ver.

188
00:15:37,000 --> 00:15:40,000
¿Función es interesante que tenga algún método?

189
00:15:40,000 --> 00:15:43,000
¿O me han dicho aquí que tiene que tener algún método

190
00:15:43,000 --> 00:15:44,000
para hacer cosas?

191
00:15:44,000 --> 00:15:46,000
Porque aquí ya me dan el diseño hecho.

192
00:15:48,000 --> 00:15:49,000
Vale.

193
00:15:50,000 --> 00:15:52,000
El precio de una función

194
00:15:52,000 --> 00:15:55,000
tiene que poder ser cambiado.

195
00:15:55,000 --> 00:15:58,000
Bueno, pues aquí ya identifico una primera acción

196
00:15:58,000 --> 00:16:00,000
a realizar con las funciones.

197
00:16:00,000 --> 00:16:02,000
Cambiar su precio.

198
00:16:02,000 --> 00:16:03,000
¿Vale?

199
00:16:03,000 --> 00:16:06,000
Esa es una acción que afecta a las funciones.

200
00:16:06,000 --> 00:16:08,000
Cambiar el precio de la función.

201
00:16:08,000 --> 00:16:12,000
Luego, como es una acción que afecta a la función,

202
00:16:12,000 --> 00:16:14,000
el mejor sitio para que estés en un método

203
00:16:14,000 --> 00:16:16,000
de la clase función.

204
00:16:16,000 --> 00:16:17,000
¿Vale?

205
00:16:17,000 --> 00:16:20,000
Pero de nuevo insisto lo de siempre.

206
00:16:20,000 --> 00:16:23,000
Diseños para una aplicación hay millones.

207
00:16:23,000 --> 00:16:24,000
¿Vale?

208
00:16:24,000 --> 00:16:25,000
Hay millones.

209
00:16:25,000 --> 00:16:27,000
De alguna manera hay que seguir ciertas pautas,

210
00:16:27,000 --> 00:16:29,000
ciertos estilos de programación.

211
00:16:29,000 --> 00:16:32,000
Entonces las acciones que trabajan con un objeto

212
00:16:32,000 --> 00:16:34,000
dentro de una aplicación,

213
00:16:34,000 --> 00:16:37,000
lo ideal es que yo las recoja todas ellas

214
00:16:37,000 --> 00:16:39,000
en un método de esa clase.

215
00:16:39,000 --> 00:16:40,000
Podría no diseñarlo así.

216
00:16:40,000 --> 00:16:42,000
Y podría hacer un mail que hace todo eso.

217
00:16:42,000 --> 00:16:44,000
Cambiar el precio de la función,

218
00:16:44,000 --> 00:16:46,000
llamando directamente la propiedad precio,

219
00:16:46,000 --> 00:16:48,000
pero sería una aplicación muy mal hecha.

220
00:16:48,000 --> 00:16:50,000
Mejor lo meto en un método.

221
00:16:50,000 --> 00:16:52,000
Y el mail que llame al método y se acabó.

222
00:16:52,000 --> 00:16:54,000
Me va a quedar el mail mucho más claro.

223
00:16:54,000 --> 00:16:56,000
Bueno, pues este es un caso.

224
00:16:56,000 --> 00:16:58,000
Hay una acción que trabaja sobre la función,

225
00:16:58,000 --> 00:17:00,000
que es cambiar un precio.

226
00:17:00,000 --> 00:17:02,000
Pues el sitio ideal para que esté esa acción

227
00:17:02,000 --> 00:17:04,000
es guardadita en un método

228
00:17:04,000 --> 00:17:05,000
dentro de la clase función.

229
00:17:05,000 --> 00:17:07,000
Eso es un sitio ideal para estar.

230
00:17:07,000 --> 00:17:09,000
Y no en un mail, no en el mail.

231
00:17:09,000 --> 00:17:11,000
El sitio ideal es que esté ahí.

232
00:17:11,000 --> 00:17:13,000
Pues venga, vamos a hacer un método.

233
00:17:13,000 --> 00:17:15,000
¡Adiós!

234
00:17:16,000 --> 00:17:18,000
Vamos a hacer un método

235
00:17:18,000 --> 00:17:20,000
dentro de la clase función

236
00:17:20,000 --> 00:17:22,000
para cambiar el precio.

237
00:17:22,000 --> 00:17:24,000
Vale.

238
00:17:25,000 --> 00:17:27,000
Pues el nombre está claro.

239
00:17:27,000 --> 00:17:29,000
¿Necesito alguna información desde fuera

240
00:17:29,000 --> 00:17:31,000
para cambiar el precio?

241
00:17:32,000 --> 00:17:34,000
¿Sí o no?

242
00:17:35,000 --> 00:17:36,000
¿Eh?

243
00:17:36,000 --> 00:17:38,000
No, el precio nuevo, claro.

244
00:17:39,000 --> 00:17:41,000
Pues bueno, imaginemos que...

245
00:17:42,000 --> 00:17:44,000
Lo podríamos llamar precio.

246
00:17:44,000 --> 00:17:46,000
Bueno, por variar lo llamo nuevo precio.

247
00:17:46,000 --> 00:17:48,000
Y en este caso estamos en el de siempre.

248
00:17:49,000 --> 00:17:51,000
El método es esto.

249
00:17:51,000 --> 00:17:52,000
No es más que esto.

250
00:17:52,000 --> 00:17:53,000
¿Vale?

251
00:17:53,000 --> 00:17:54,000
No es más que esto.

252
00:17:54,000 --> 00:17:56,000
Luego no necesita devolver nada

253
00:17:57,000 --> 00:17:59,000
porque el efecto, la acción del método

254
00:17:59,000 --> 00:18:01,000
ya se queda reflejado

255
00:18:02,000 --> 00:18:04,000
en la modificación que hace de este precio.

256
00:18:05,000 --> 00:18:07,000
Esta propiedad se queda modificada.

257
00:18:07,000 --> 00:18:09,000
Se queda modificada.

258
00:18:09,000 --> 00:18:11,000
Se queda modificada y ese es su efecto.

259
00:18:12,000 --> 00:18:14,000
Aquí el dis de nuevo no me hace ninguna falta.

260
00:18:16,000 --> 00:18:18,000
Bueno, pues a la...

261
00:18:18,000 --> 00:18:20,000
Estas funciones

262
00:18:20,000 --> 00:18:22,000
se caracterizan por su nombre y precio

263
00:18:22,000 --> 00:18:24,000
y además puedo cambiarles el precio

264
00:18:24,000 --> 00:18:25,000
si me da la gana.

265
00:18:25,000 --> 00:18:27,000
No puedo cambiarles el nombre,

266
00:18:27,000 --> 00:18:28,000
no puedo hacer otras cosas,

267
00:18:28,000 --> 00:18:30,000
pero cambiar el precio a través de este método sí.

268
00:18:31,000 --> 00:18:32,000
Vale.

269
00:18:32,000 --> 00:18:33,000
Siguiente clase.

270
00:18:33,000 --> 00:18:34,000
Teatro.

271
00:18:34,000 --> 00:18:36,000
Teatro dependía de función

272
00:18:36,000 --> 00:18:38,000
porque teatro tiene dentro objetos función.

273
00:18:38,000 --> 00:18:40,000
Luego, por eso hemos probado función antes,

274
00:18:40,000 --> 00:18:42,000
la que no depende de ninguna otra.

275
00:18:43,000 --> 00:18:45,000
Pues venga, la clase teatro.

276
00:19:02,000 --> 00:19:03,000
Vale.

277
00:19:03,000 --> 00:19:05,000
Pues esta clase, ¿por qué se caracteriza?

278
00:19:06,000 --> 00:19:08,000
Un teatro tiene

279
00:19:08,000 --> 00:19:10,000
su nombre,

280
00:19:10,000 --> 00:19:12,000
eso está claro, un string, no hay tutía.

281
00:19:12,000 --> 00:19:14,000
Y luego tiene dentro

282
00:19:14,000 --> 00:19:16,000
cuatro funciones distintas que representa.

283
00:19:16,000 --> 00:19:18,000
Cuatro funciones, cada una de ellas con su nombre y su precio.

284
00:19:18,000 --> 00:19:20,000
Tiene cuatro funciones.

285
00:19:20,000 --> 00:19:22,000
Entonces, hombre, bueno,

286
00:19:22,000 --> 00:19:24,000
pues tal y como me han planteado este enunciado,

287
00:19:24,000 --> 00:19:26,000
pues puedo resolverlo

288
00:19:26,000 --> 00:19:28,000
de diferentes maneras.

289
00:19:28,000 --> 00:19:30,000
Esta en realidad sería una, ¿verdad?

290
00:19:30,000 --> 00:19:32,000
Su nombre,

291
00:19:32,000 --> 00:19:34,000
está claro, es este.

292
00:19:34,000 --> 00:19:36,000
Y además tiene dentro

293
00:19:36,000 --> 00:19:38,000
cuatro objetos función

294
00:19:38,000 --> 00:19:40,000
que caracterizan a ese teatro.

295
00:19:40,000 --> 00:19:42,000
Pues hombre, podríamos hacer esto, ¿no?

296
00:19:48,000 --> 00:19:50,000
Esto lo puedo hacer, no está mal.

297
00:19:51,000 --> 00:19:53,000
F1 es la primera función,

298
00:19:53,000 --> 00:19:55,000
toda ella, de ese teatro.

299
00:19:55,000 --> 00:19:57,000
F2 es la segunda función, toda ella.

300
00:19:57,000 --> 00:19:59,000
F3 es la tercera función, toda ella.

301
00:19:59,000 --> 00:20:01,000
Y F4 es la cuarta función,

302
00:20:01,000 --> 00:20:03,000
cada una de ellas tiene su nombre y su precio.

303
00:20:04,000 --> 00:20:06,000
Vale, no penséis que, hombre,

304
00:20:06,000 --> 00:20:08,000
queda un poco feo, ¿no?

305
00:20:08,000 --> 00:20:10,000
Cuando ya empiezan a ser una, dos, tres,

306
00:20:10,000 --> 00:20:12,000
queda un poco feo.

307
00:20:12,000 --> 00:20:14,000
Sería casi mejor meterlo en una estructura de datos.

308
00:20:14,000 --> 00:20:16,000
Ahora mismo, como estructura de datos,

309
00:20:16,000 --> 00:20:18,000
solo conocemos el array.

310
00:20:18,000 --> 00:20:20,000
Entonces,

311
00:20:20,000 --> 00:20:22,000
mucho mejor

312
00:20:22,000 --> 00:20:24,000
así, más bonito.

313
00:20:24,000 --> 00:20:26,000
Y así hago esta clase

314
00:20:26,000 --> 00:20:28,000
más genérica.

315
00:20:28,000 --> 00:20:30,000
Porque así de golpe

316
00:20:30,000 --> 00:20:32,000
me he hecho una clase de teatro

317
00:20:32,000 --> 00:20:34,000
que puede contener cuatro.

318
00:20:34,000 --> 00:20:36,000
Pero si en un momento dado

319
00:20:36,000 --> 00:20:38,000
el teatro cambia y puede albergar hasta siete,

320
00:20:38,000 --> 00:20:40,000
pues también caben siete ahí.

321
00:20:40,000 --> 00:20:42,000
Entonces la he hecho

322
00:20:42,000 --> 00:20:44,000
más genérica que la otra

323
00:20:44,000 --> 00:20:46,000
que tenía solo F1, F2, F3 y F4.

324
00:20:48,000 --> 00:20:50,000
Bueno, pues

325
00:20:50,000 --> 00:20:52,000
entonces, esto

326
00:20:52,000 --> 00:20:54,000
es lo que se conoce

327
00:20:54,000 --> 00:20:56,000
como agregación en realidad,

328
00:20:56,000 --> 00:20:58,000
pero es un nombre que no nos dice nada

329
00:20:58,000 --> 00:21:00,000
que nosotros no sepamos.

330
00:21:00,000 --> 00:21:02,000
Una clase puede tener propiedades

331
00:21:02,000 --> 00:21:04,000
que a su vez son de otra clase.

332
00:21:04,000 --> 00:21:06,000
Anda claro, porque las propiedades son variables.

333
00:21:06,000 --> 00:21:08,000
Y las variables pueden ser

334
00:21:08,000 --> 00:21:10,000
primitivo u objeto. Ya lo sabemos

335
00:21:10,000 --> 00:21:12,000
que las variables pueden ser primitiva u objeto.

336
00:21:12,000 --> 00:21:14,000
Pues esta variable es de tipo objeto,

337
00:21:14,000 --> 00:21:16,000
un array de funciones.

338
00:21:16,000 --> 00:21:18,000
Cualquier propiedad puede ser

339
00:21:18,000 --> 00:21:20,000
tipo objeto, tipo primitivo,

340
00:21:20,000 --> 00:21:22,000
la que interese.

341
00:21:22,000 --> 00:21:24,000
Como la clase clientes pedidos

342
00:21:24,000 --> 00:21:26,000
en el ejemplo que arrancamos,

343
00:21:26,000 --> 00:21:28,000
el cliente puede tener

344
00:21:28,000 --> 00:21:30,000
dentro su objeto pedido, claro, ¿por qué no?

345
00:21:30,000 --> 00:21:32,000
Es una variable más.

346
00:21:34,000 --> 00:21:36,000
Bueno, pues eso

347
00:21:36,000 --> 00:21:38,000
se le da nombre, porque a todos se le da nombre.

348
00:21:38,000 --> 00:21:40,000
Y ese nombre es

349
00:21:40,000 --> 00:21:42,000
o agregación o composición, cualquiera de los dos

350
00:21:42,000 --> 00:21:44,000
lo podéis encontrar.

351
00:21:48,000 --> 00:21:50,000
Es decir,

352
00:21:50,000 --> 00:21:52,000
un objeto tenga dentro otro,

353
00:21:52,000 --> 00:21:54,000
es una agregación o una composición.

354
00:21:58,000 --> 00:22:00,000
Vale, entonces el teatro este,

355
00:22:00,000 --> 00:22:02,000
pues,

356
00:22:02,000 --> 00:22:04,000
como siempre, lo ideal es que uno haga un constructor.

357
00:22:24,000 --> 00:22:26,000
Vale, a ver,

358
00:22:26,000 --> 00:22:28,000
ya está enunciado, ¿hay algún otro método

359
00:22:28,000 --> 00:22:30,000
que interese poner en función para que luego

360
00:22:30,000 --> 00:22:32,000
llame el main?

361
00:22:34,000 --> 00:22:36,000
Cambiar,

362
00:22:36,000 --> 00:22:38,000
cambiar el nombre del teatro.

363
00:22:38,000 --> 00:22:40,000
Bueno, pues venga, vamos a

364
00:22:42,000 --> 00:22:44,000
cambiar el nombre del teatro. Pues cambiar el nombre

365
00:22:44,000 --> 00:22:46,000
del teatro tiene poco que

366
00:22:46,000 --> 00:22:48,000
poner.

367
00:22:50,000 --> 00:22:52,000
Cambiar nombre,

368
00:22:52,000 --> 00:22:54,000
pues habrá que pedir el nombre nuevo,

369
00:22:54,000 --> 00:22:56,000
habrá que pasarle el nombre nuevo

370
00:22:56,000 --> 00:22:58,000
y ya está.

371
00:22:58,000 --> 00:23:00,000
Y dárselo.

372
00:23:04,000 --> 00:23:06,000
Vale,

373
00:23:06,000 --> 00:23:08,000
entonces vamos a añadir algún otro método

374
00:23:08,000 --> 00:23:10,000
para poder hacer algún main un poco más operativo.

375
00:23:10,000 --> 00:23:12,000
Vale, y para trabajar

376
00:23:12,000 --> 00:23:14,000
un poco con este array.

377
00:23:14,000 --> 00:23:16,000
Porque si no,

378
00:23:16,000 --> 00:23:18,000
se nos queda aquí el main

379
00:23:18,000 --> 00:23:20,000
que le va a tocar hacerlo todo el main.

380
00:23:20,000 --> 00:23:22,000
Bueno.

381
00:23:24,000 --> 00:23:26,000
Vale,

382
00:23:26,000 --> 00:23:28,000
vamos a agregar por ejemplo

383
00:23:28,000 --> 00:23:30,000
este método.

384
00:23:32,000 --> 00:23:34,000
Bueno,

385
00:23:34,000 --> 00:23:36,000
no los pongo así, así mejor.

386
00:23:36,000 --> 00:23:38,000
Vale.

387
00:23:44,000 --> 00:23:46,000
Que agrega una

388
00:23:46,000 --> 00:23:48,000
función

389
00:23:48,000 --> 00:23:50,000
al teatro.

390
00:23:50,000 --> 00:23:52,000
Vale, vamos a

391
00:23:52,000 --> 00:23:54,000
cambiar, vamos a

392
00:23:56,000 --> 00:23:58,000
enriquecer

393
00:23:58,000 --> 00:24:00,000
un poco este ejercicio,

394
00:24:00,000 --> 00:24:02,000
vamos a enriquecerlo un poco

395
00:24:02,000 --> 00:24:04,000
y vamos a plantearlo de esta manera.

396
00:24:04,000 --> 00:24:06,000
Vamos a hacer otro constructor diferente,

397
00:24:06,000 --> 00:24:08,000
porque constructores puede haber

398
00:24:08,000 --> 00:24:10,000
todos los que uno quiera.

399
00:24:10,000 --> 00:24:12,000
Vamos a hacer otro constructor que reciba solo el nombre.

400
00:24:16,000 --> 00:24:18,000
Vale, este es otro constructor.

401
00:24:18,000 --> 00:24:20,000
Entonces, este constructor

402
00:24:20,000 --> 00:24:22,000
es muy útil cuando hay

403
00:24:22,000 --> 00:24:24,000
clases que tienen

404
00:24:24,000 --> 00:24:26,000
como propiedades

405
00:24:26,000 --> 00:24:28,000
conjuntos de otras cosas.

406
00:24:28,000 --> 00:24:30,000
Entonces primero creas el objeto

407
00:24:30,000 --> 00:24:32,000
y luego

408
00:24:32,000 --> 00:24:34,000
las funciones que ya se vayan agregando después.

409
00:24:34,000 --> 00:24:36,000
Bueno, pues tiene sentido

410
00:24:36,000 --> 00:24:38,000
ese constructor.

411
00:24:38,000 --> 00:24:40,000
Este constructor lo usaremos

412
00:24:40,000 --> 00:24:42,000
cuando queramos crear

413
00:24:42,000 --> 00:24:44,000
el teatro, primero lo creamos vacío

414
00:24:44,000 --> 00:24:46,000
sin funciones.

415
00:24:46,000 --> 00:24:48,000
Y luego ya a través de un método abajo

416
00:24:48,000 --> 00:24:50,000
vamos agregando funciones

417
00:24:50,000 --> 00:24:52,000
según vayamos queriendo.

418
00:24:54,000 --> 00:24:56,000
¿Vale?

419
00:24:56,000 --> 00:24:58,000
Pues nada, yo aquí tengo, bueno,

420
00:24:58,000 --> 00:25:00,000
me faltaría obviamente completar

421
00:25:00,000 --> 00:25:02,000
el constructor.

422
00:25:06,000 --> 00:25:08,000
Vale, y ahora

423
00:25:08,000 --> 00:25:10,000
vamos a hacer un método que agrega

424
00:25:10,000 --> 00:25:12,000
una función

425
00:25:12,000 --> 00:25:14,000
al teatro. Entonces

426
00:25:14,000 --> 00:25:16,000
devolvería void

427
00:25:16,000 --> 00:25:18,000
porque el resultado de este método

428
00:25:18,000 --> 00:25:20,000
es que este array

429
00:25:20,000 --> 00:25:22,000
incorpore esa otra función.

430
00:25:22,000 --> 00:25:24,000
Entonces el resultado del método

431
00:25:24,000 --> 00:25:26,000
se queda en ese array.

432
00:25:26,000 --> 00:25:28,000
Vale, voy a

433
00:25:28,000 --> 00:25:30,000
agregar función.

434
00:25:32,000 --> 00:25:34,000
¿Qué parámetro le pasamos?

435
00:25:34,000 --> 00:25:36,000
El nuevo objeto

436
00:25:36,000 --> 00:25:38,000
función que hay que agregar a ese array.

437
00:25:38,000 --> 00:25:40,000
Es una variable,

438
00:25:40,000 --> 00:25:42,000
objeto normal de corriente.

439
00:25:42,000 --> 00:25:44,000
Bueno, pues así.

440
00:25:44,000 --> 00:25:46,000
¿Verdad?

441
00:25:48,000 --> 00:25:50,000
Tenemos que

442
00:25:50,000 --> 00:25:52,000
empezar ya a manejar variables primitivas,

443
00:25:52,000 --> 00:25:54,000
variables objeto, en plano

444
00:25:54,000 --> 00:25:56,000
de igualdad completamente.

445
00:25:56,000 --> 00:25:58,000
Me da igual que una variable sea int,

446
00:25:58,000 --> 00:26:00,000
sea función, a la hora

447
00:26:00,000 --> 00:26:02,000
de declararla, a la hora de pasarla como parámetro,

448
00:26:02,000 --> 00:26:04,000
me da igual.

449
00:26:04,000 --> 00:26:06,000
Su funcionamiento no es el mismo

450
00:26:06,000 --> 00:26:08,000
porque esto es una dirección de memoria

451
00:26:08,000 --> 00:26:10,000
que tiene dentro función punto

452
00:26:10,000 --> 00:26:12,000
precio, función punto.

453
00:26:12,000 --> 00:26:14,000
Pero a la hora de declararla y pasarla,

454
00:26:14,000 --> 00:26:16,000
o sea, esta cabecera

455
00:26:16,000 --> 00:26:18,000
a nadie le

456
00:26:18,000 --> 00:26:20,000
produce problemas. Tengo que pasar un objeto

457
00:26:20,000 --> 00:26:22,000
función. Y ahora

458
00:26:22,000 --> 00:26:24,000
este método

459
00:26:26,000 --> 00:26:28,000
tendrá que

460
00:26:28,000 --> 00:26:30,000
agregar esa función

461
00:26:30,000 --> 00:26:32,000
a este array.

462
00:26:32,000 --> 00:26:34,000
Es decir,

463
00:26:34,000 --> 00:26:36,000
hacer el rollo de siempre,

464
00:26:36,000 --> 00:26:38,000
aumentarlo en una posición

465
00:26:38,000 --> 00:26:40,000
y en la posición nueva que he creado

466
00:26:40,000 --> 00:26:42,000
¿vale?

467
00:26:42,000 --> 00:26:44,000
Pues ya está. Podría ser un método.

468
00:26:46,000 --> 00:26:48,000
Vamos a dejarlo hecho

469
00:26:48,000 --> 00:26:50,000
rápidamente. Entonces esto

470
00:26:50,000 --> 00:26:52,000
lo hemos hecho un montón de veces.

471
00:26:52,000 --> 00:26:54,000
Esto sería, haríamos

472
00:26:54,000 --> 00:26:56,000
un array auxiliar de funciones

473
00:27:00,000 --> 00:27:02,000
que

474
00:27:04,000 --> 00:27:06,000
sería así.

475
00:27:06,000 --> 00:27:08,000
Un array de funciones

476
00:27:08,000 --> 00:27:10,000
con una posición más que este otro.

477
00:27:14,000 --> 00:27:16,000
Funciones

478
00:27:16,000 --> 00:27:18,000
punto length

479
00:27:18,000 --> 00:27:20,000
más uno.

480
00:27:20,000 --> 00:27:22,000
¿Verdad? Hacemos un array con una

481
00:27:22,000 --> 00:27:24,000
posición adicional

482
00:27:24,000 --> 00:27:26,000
al de funciones.

483
00:27:26,000 --> 00:27:28,000
Hacemos un array con una posición adicional.

484
00:27:28,000 --> 00:27:30,000
Copiamos uno

485
00:27:30,000 --> 00:27:32,000
en el otro.

486
00:27:32,000 --> 00:27:34,000
Menor que

487
00:27:34,000 --> 00:27:36,000
funciones

488
00:27:36,000 --> 00:27:38,000
punto length.

489
00:27:38,000 --> 00:27:40,000
Incrementando

490
00:27:40,000 --> 00:27:42,000
y

491
00:27:42,000 --> 00:27:44,000
aux de y

492
00:27:44,000 --> 00:27:46,000
igual a

493
00:27:46,000 --> 00:27:48,000
funciones

494
00:27:48,000 --> 00:27:50,000
de y.

495
00:27:50,000 --> 00:27:52,000
Una vez que hemos terminado de copiar

496
00:27:52,000 --> 00:27:54,000
uno en el otro, en la posición adicional

497
00:27:54,000 --> 00:27:56,000
de aux que hemos creado

498
00:27:56,000 --> 00:27:58,000
que es

499
00:27:58,000 --> 00:28:00,000
aux punto length

500
00:28:00,000 --> 00:28:02,000
menos uno. Es su última

501
00:28:02,000 --> 00:28:04,000
posición. Ponemos

502
00:28:04,000 --> 00:28:06,000
la última función creada.

503
00:28:08,000 --> 00:28:10,000
Y ahora ya

504
00:28:10,000 --> 00:28:12,000
asignamos a funciones aux.

505
00:28:18,000 --> 00:28:20,000
Lo que hemos hecho siempre.

506
00:28:24,000 --> 00:28:26,000
Crea un array adicional con una posición

507
00:28:26,000 --> 00:28:28,000
más. Copia

508
00:28:28,000 --> 00:28:30,000
el viejo en el nuevo, posición

509
00:28:30,000 --> 00:28:32,000
por posición. En la posición

510
00:28:32,000 --> 00:28:34,000
adicional copia el nuevo objeto,

511
00:28:34,000 --> 00:28:36,000
el nuevo elemento y ahora

512
00:28:36,000 --> 00:28:38,000
reasigna para que

513
00:28:38,000 --> 00:28:40,000
funciones ahora pase a ser

514
00:28:40,000 --> 00:28:42,000
el nuevo array.

515
00:28:42,000 --> 00:28:44,000
Este método es un método

516
00:28:44,000 --> 00:28:46,000
que nos permite... Le das un objeto

517
00:28:46,000 --> 00:28:48,000
de función y te lo agrega

518
00:28:48,000 --> 00:28:50,000
el array.

519
00:28:54,000 --> 00:28:56,000
Chao.

520
00:28:58,000 --> 00:29:00,000
Sobre este código en particular.

521
00:29:00,000 --> 00:29:02,000
¿Alguien prevé que en algún

522
00:29:02,000 --> 00:29:04,000
momento, alguna situación pueda haber algún problema?

523
00:29:06,000 --> 00:29:08,000
Seguro que sí, ¿no?

524
00:29:16,000 --> 00:29:18,000
Que la primera vez

525
00:29:18,000 --> 00:29:20,000
que llamemos a agregar función

526
00:29:20,000 --> 00:29:22,000
funciones es null todavía.

527
00:29:22,000 --> 00:29:24,000
La primera vez que lo llamemos.

528
00:29:24,000 --> 00:29:26,000
Entonces funciones punto length

529
00:29:26,000 --> 00:29:28,000
nos va a dar un null pointer exception.

530
00:29:30,000 --> 00:29:32,000
¿No?

531
00:29:32,000 --> 00:29:34,000
Cuando se crea el objeto teatro por primera vez

532
00:29:34,000 --> 00:29:36,000
este array es null.

533
00:29:36,000 --> 00:29:38,000
Ese array es null cuando se crea

534
00:29:38,000 --> 00:29:40,000
por primera vez. Es null.

535
00:29:40,000 --> 00:29:42,000
Con lo cual por...

536
00:29:42,000 --> 00:29:44,000
Si ese array es null

537
00:29:44,000 --> 00:29:46,000
yo no puedo llamar

538
00:29:46,000 --> 00:29:48,000
a funciones punto length

539
00:29:48,000 --> 00:29:50,000
porque esto es null y me va a decir

540
00:29:50,000 --> 00:29:52,000
no puedes hacer llamar a nada de un null.

541
00:29:52,000 --> 00:29:54,000
Te da un null pointer exception.

542
00:29:54,000 --> 00:29:56,000
¿Vale?

543
00:29:56,000 --> 00:29:58,000
Claro, es que aquí

544
00:29:58,000 --> 00:30:00,000
tendríamos que distinguir

545
00:30:00,000 --> 00:30:02,000
si funciones es null

546
00:30:02,000 --> 00:30:04,000
entonces funciones

547
00:30:06,000 --> 00:30:08,000
si funciones

548
00:30:08,000 --> 00:30:10,000
es null

549
00:30:12,000 --> 00:30:14,000
entonces

550
00:30:14,000 --> 00:30:16,000
ahora ya le creamos su primera

551
00:30:16,000 --> 00:30:18,000
posición

552
00:30:20,000 --> 00:30:22,000
y única new

553
00:30:22,000 --> 00:30:24,000
función de uno

554
00:30:32,000 --> 00:30:34,000
y a esa única posición

555
00:30:38,000 --> 00:30:40,000
a esa única posición que acabo de crear

556
00:30:40,000 --> 00:30:42,000
le asignamos esto.

557
00:30:42,000 --> 00:30:44,000
¿Vale? Le asignamos esto.

558
00:30:44,000 --> 00:30:46,000
Y si no

559
00:30:46,000 --> 00:30:48,000
si no es null

560
00:30:48,000 --> 00:30:50,000
entonces ahora ya

561
00:30:50,000 --> 00:30:52,000
sí que

562
00:30:52,000 --> 00:30:54,000
aplica todo esto de aquí.

563
00:30:56,000 --> 00:30:58,000
¿Vale?

564
00:30:58,000 --> 00:31:00,000
Si es la primera vez

565
00:31:00,000 --> 00:31:02,000
que llamo a agregar

566
00:31:02,000 --> 00:31:04,000
función, esto es un null

567
00:31:04,000 --> 00:31:06,000
entonces si es null

568
00:31:06,000 --> 00:31:08,000
lo creo dándole una única

569
00:31:08,000 --> 00:31:10,000
posición y a esa única posición

570
00:31:10,000 --> 00:31:12,000
le asigno esta. Pero si no es

571
00:31:12,000 --> 00:31:14,000
null porque ya tiene posiciones, pues ahora ya

572
00:31:14,000 --> 00:31:16,000
sí. Le doy

573
00:31:16,000 --> 00:31:18,000
un auxiliar con una posición más

574
00:31:18,000 --> 00:31:20,000
copio

575
00:31:20,000 --> 00:31:22,000
el viejo en el nuevo

576
00:31:22,000 --> 00:31:24,000
asigno a la última

577
00:31:24,000 --> 00:31:26,000
posición creada

578
00:31:26,000 --> 00:31:28,000
la función nueva y reasigno.

579
00:31:44,000 --> 00:31:46,000
¿Vale? Esto es

580
00:31:46,000 --> 00:31:48,000
el repaso de lo que hemos

581
00:31:48,000 --> 00:31:50,000
hecho otras veces. ¿Vale? Para que

582
00:31:50,000 --> 00:31:52,000
no se nos olvide programar en general.

583
00:31:52,000 --> 00:31:54,000
Programar en general.

584
00:31:54,000 --> 00:31:56,000
¿Vale? Aquí este else

585
00:31:56,000 --> 00:31:58,000
queda un poco feo porque es un else que

586
00:31:58,000 --> 00:32:00,000
tiene un montón de cosas ahí dentro.

587
00:32:00,000 --> 00:32:02,000
Es un else que queda un poco feo. Entonces me puedo

588
00:32:02,000 --> 00:32:04,000
aprovechar de una cosa

589
00:32:04,000 --> 00:32:06,000
y es acordaros del retune.

590
00:32:06,000 --> 00:32:08,000
¿Para qué me servía el retune en los métodos?

591
00:32:08,000 --> 00:32:10,000
El retune servía cuando yo quería

592
00:32:10,000 --> 00:32:12,000
devolver un valor. Pero es que además

593
00:32:12,000 --> 00:32:14,000
de devolver un valor, finaliza

594
00:32:14,000 --> 00:32:16,000
el método. El método se acaba. Y se acabó.

595
00:32:16,000 --> 00:32:18,000
El método se acaba. Claro, pero es que

596
00:32:18,000 --> 00:32:20,000
el retune lo podemos utilizar también

597
00:32:20,000 --> 00:32:22,000
para salir de un método

598
00:32:22,000 --> 00:32:24,000
void poniendo retune sin nada más.

599
00:32:24,000 --> 00:32:26,000
Entonces

600
00:32:26,000 --> 00:32:28,000
si yo hago aquí un retune

601
00:32:30,000 --> 00:32:32,000
el retune lo puedo poner sin

602
00:32:32,000 --> 00:32:34,000
nada detrás cuando el método

603
00:32:34,000 --> 00:32:36,000
devuelve void. Cuando devuelve

604
00:32:36,000 --> 00:32:38,000
void puedo poner el retune sin nada.

605
00:32:38,000 --> 00:32:40,000
Si el método devuelve int, double,

606
00:32:40,000 --> 00:32:42,000
debo poner el retune con el valor que sea. Con el int,

607
00:32:42,000 --> 00:32:44,000
con el dado, el obligatorio.

608
00:32:44,000 --> 00:32:46,000
Pero si el método devuelve void, pongo el retune sin nada.

609
00:32:46,000 --> 00:32:48,000
¿Y para qué me ha servido

610
00:32:48,000 --> 00:32:50,000
poner aquí el retune? Pues cuando yo

611
00:32:50,000 --> 00:32:52,000
pongo un retune, el método

612
00:32:52,000 --> 00:32:54,000
termina. El método

613
00:32:54,000 --> 00:32:56,000
termina. Con lo cual me ahorro

614
00:32:56,000 --> 00:32:58,000
el tener que poner este else y la

615
00:32:58,000 --> 00:33:00,000
tabulación.

616
00:33:00,000 --> 00:33:02,000
Porque yo ahora ya

617
00:33:02,000 --> 00:33:04,000
quito esto y me queda más bonito.

618
00:33:04,000 --> 00:33:06,000
¿Por qué?

619
00:33:10,000 --> 00:33:12,000
¿Por qué ahora qué ocurre?

620
00:33:12,000 --> 00:33:14,000
Si funcionas es igual a null.

621
00:33:14,000 --> 00:33:16,000
Haces esto y terminas.

622
00:33:16,000 --> 00:33:18,000
Se acabó. No hay más que hacer.

623
00:33:18,000 --> 00:33:20,000
Método acabado. Retune fuera. Se acabó.

624
00:33:20,000 --> 00:33:22,000
Con lo cual nunca llegarías aquí.

625
00:33:22,000 --> 00:33:24,000
Si entró en el if

626
00:33:24,000 --> 00:33:26,000
nunca vas a llegar ahí. Luego no hace falta

627
00:33:26,000 --> 00:33:28,000
ponerlo en un else. No hace falta.

628
00:33:28,000 --> 00:33:30,000
Porque si entró en el if, ahí, paf.

629
00:33:30,000 --> 00:33:32,000
Método terminado. Se acabó.

630
00:33:32,000 --> 00:33:34,000
Entonces no hace falta que yo meta esto en un else.

631
00:33:34,000 --> 00:33:36,000
Porque si ha llegado aquí

632
00:33:36,000 --> 00:33:38,000
es porque no entró en el if.

633
00:33:38,000 --> 00:33:40,000
Si ha llegado aquí es porque no entró en el if.

634
00:33:40,000 --> 00:33:42,000
Luego es como ponerlo en un else. Es igual.

635
00:33:42,000 --> 00:33:44,000
Y así me queda más bonito. No puedo poner

636
00:33:44,000 --> 00:33:46,000
todo eso ahí metido.

637
00:33:50,000 --> 00:33:52,000
¿Vale? Pues entonces

638
00:33:52,000 --> 00:33:54,000
el retune, por tanto,

639
00:33:54,000 --> 00:33:56,000
se puede poner

640
00:33:56,000 --> 00:33:58,000
en un método que devuelva void también.

641
00:33:58,000 --> 00:34:00,000
No es obligatorio.

642
00:34:00,000 --> 00:34:02,000
Como en los métodos que devuelven algo.

643
00:34:02,000 --> 00:34:04,000
En los métodos que devuelven algo el retune es obligatorio.

644
00:34:04,000 --> 00:34:06,000
Hay que poner retune y el valor que siga.

645
00:34:06,000 --> 00:34:08,000
Es obligatorio.

646
00:34:08,000 --> 00:34:10,000
Pero en los métodos que devuelven void el retune

647
00:34:10,000 --> 00:34:12,000
lo puedo poner o no. Porque ya el método va a acabar

648
00:34:12,000 --> 00:34:14,000
en cualquier caso, al final.

649
00:34:14,000 --> 00:34:16,000
Si lo pongo

650
00:34:16,000 --> 00:34:18,000
significa ahí se acaba.

651
00:34:18,000 --> 00:34:20,000
Y lo que hay después

652
00:34:20,000 --> 00:34:22,000
no se va a ejecutar nunca.

653
00:34:22,000 --> 00:34:24,000
Pues en este caso, ¿para qué me sirve ponerlo?

654
00:34:24,000 --> 00:34:26,000
Para ahorrarme el else.

655
00:34:26,000 --> 00:34:28,000
Y para que quede más bonito el código.

656
00:34:28,000 --> 00:34:30,000
Solo para eso. Para que quede más bonito el código.

657
00:34:30,000 --> 00:34:32,000
Me está siguiendo. ¿Vale?

658
00:34:34,000 --> 00:34:36,000
Porque si entró aquí

659
00:34:36,000 --> 00:34:38,000
nunca va a llegar ahí.

660
00:34:38,000 --> 00:34:40,000
Y si llega aquí es que nunca entró aquí.

661
00:34:40,000 --> 00:34:42,000
Entonces me ahorro.

662
00:34:42,000 --> 00:34:44,000
¿Vale?

663
00:34:44,000 --> 00:34:46,000
Vale, entonces

664
00:34:46,000 --> 00:34:48,000
para comprobar

665
00:34:48,000 --> 00:34:50,000
que este agregar función nos funciona

666
00:34:50,000 --> 00:34:52,000
deberíamos hacer un método

667
00:34:52,000 --> 00:34:54,000
que muestre las funciones que tiene el teatro.

668
00:34:54,000 --> 00:34:56,000
Porque si no, vamos a hacer un método

669
00:34:56,000 --> 00:34:58,000
de mostrar funciones.

670
00:35:00,000 --> 00:35:02,000
El método de mostrar funciones

671
00:35:02,000 --> 00:35:04,000
pues vamos a hacerlo con un for each

672
00:35:04,000 --> 00:35:06,000
de estos. Para cada

673
00:35:06,000 --> 00:35:08,000
función f

674
00:35:08,000 --> 00:35:10,000
en las

675
00:35:10,000 --> 00:35:12,000
funciones del teatro

676
00:35:12,000 --> 00:35:14,000
pues vamos a mostrar

677
00:35:16,000 --> 00:35:18,000
nombre

678
00:35:18,000 --> 00:35:20,000
de la función

679
00:35:22,000 --> 00:35:24,000
f.nombre

680
00:35:26,000 --> 00:35:28,000
y precio.

681
00:35:38,000 --> 00:35:40,000
Precio de esa función

682
00:35:40,000 --> 00:35:42,000
f.precio

683
00:35:46,000 --> 00:35:48,000
¿Vale? F es

684
00:35:48,000 --> 00:35:50,000
todas y cada una de las funciones

685
00:35:50,000 --> 00:35:52,000
de ese array.

686
00:35:52,000 --> 00:35:54,000
Pues para cada función

687
00:35:54,000 --> 00:35:56,000
me va a mostrar su nombre

688
00:35:56,000 --> 00:35:58,000
y su precio. Porque f es un objeto.

689
00:35:58,000 --> 00:36:00,000
F es un objeto.

690
00:36:00,000 --> 00:36:02,000
Luego de f lo que tiene sentido mostrar son

691
00:36:02,000 --> 00:36:04,000
sus propiedades internas.

692
00:36:04,000 --> 00:36:06,000
Es lo que tiene sentido mostrar.

693
00:36:06,000 --> 00:36:08,000
Entonces de cada función f de este array

694
00:36:08,000 --> 00:36:10,000
muestro su nombre y su precio.

695
00:36:10,000 --> 00:36:12,000
¿Vale?

696
00:36:14,000 --> 00:36:16,000
¿Vale? Pues ya tenemos la clase

697
00:36:16,000 --> 00:36:18,000
teatro con

698
00:36:18,000 --> 00:36:20,000
eh

699
00:36:22,000 --> 00:36:24,000
me falta la

700
00:36:24,000 --> 00:36:26,000
esta.

701
00:36:28,000 --> 00:36:30,000
¿Vale? Ya tenemos la clase teatro

702
00:36:30,000 --> 00:36:32,000
con un constructor

703
00:36:32,000 --> 00:36:34,000
que le da nombre

704
00:36:34,000 --> 00:36:36,000
con el método agregar función

705
00:36:36,000 --> 00:36:38,000
y mostrar función.

706
00:36:38,000 --> 00:36:40,000
Vamos a hacer un main rápidamente

707
00:36:40,000 --> 00:36:42,000
para ver que esto funciona.

708
00:36:44,000 --> 00:36:46,000
Nos vamos.

709
00:36:46,000 --> 00:36:48,000
Vamos a hacer rápidamente un main. A ver.

710
00:36:56,000 --> 00:36:58,000
Pues venga, vamos a crear el teatro

711
00:36:58,000 --> 00:37:00,000
lo primero.

712
00:37:04,000 --> 00:37:06,000
Vamos a crear el teatro.

713
00:37:06,000 --> 00:37:08,000
Para no perder el tiempo pidiendo

714
00:37:08,000 --> 00:37:10,000
por teclado lo voy a

715
00:37:10,000 --> 00:37:12,000
dar directamente el nombre.

716
00:37:16,000 --> 00:37:18,000
Uy.

717
00:37:30,000 --> 00:37:32,000
Vale.

718
00:37:32,000 --> 00:37:34,000
Entonces el teatro está creado con ese nombre.

719
00:37:34,000 --> 00:37:36,000
Pero su array de funciones es nulo.

720
00:37:36,000 --> 00:37:38,000
No tiene ninguna función.

721
00:37:38,000 --> 00:37:40,000
Venga, pues vamos a ir agregándole funciones

722
00:37:40,000 --> 00:37:42,000
y luego mostrándolas a ver si las agrega.

723
00:37:42,000 --> 00:37:44,000
Pues por ejemplo, vamos a crear aquí

724
00:37:44,000 --> 00:37:46,000
una función primero.

725
00:37:46,000 --> 00:37:48,000
Una función

726
00:37:48,000 --> 00:37:50,000
F1 a través del constructor.

727
00:37:52,000 --> 00:37:54,000
La voy a crear

728
00:37:54,000 --> 00:37:56,000
en lugar de pedir por teclado para que sea más rápido

729
00:37:56,000 --> 00:37:58,000
le voy a dar directamente los valores.

730
00:37:58,000 --> 00:38:00,000
Pues venga.

731
00:38:02,000 --> 00:38:04,000
Función 1 y el precio

732
00:38:04,000 --> 00:38:06,000
va a ser 54.

733
00:38:06,000 --> 00:38:08,000
Este es un objeto función.

734
00:38:08,000 --> 00:38:10,000
Pues vamos a agregárselo al teatro.

735
00:38:10,000 --> 00:38:12,000
Teatro punto

736
00:38:12,000 --> 00:38:14,000
agregar función F1.

737
00:38:14,000 --> 00:38:16,000
Y vamos a ver si realmente

738
00:38:16,000 --> 00:38:18,000
la ha agregado mostrándolas.

739
00:38:18,000 --> 00:38:20,000
Mostrar funciones.

740
00:38:20,000 --> 00:38:22,000
Vamos a hacer

741
00:38:22,000 --> 00:38:24,000
lo mismo con otra función.

742
00:38:28,000 --> 00:38:30,000
Vamos a crear otro objeto

743
00:38:30,000 --> 00:38:32,000
función F2

744
00:38:32,000 --> 00:38:34,000
función 2

745
00:38:34,000 --> 00:38:36,000
precio 64.

746
00:38:36,000 --> 00:38:38,000
Este objeto función 2

747
00:38:38,000 --> 00:38:40,000
lo vamos a agregar al teatro.

748
00:38:40,000 --> 00:38:42,000
Se supone

749
00:38:42,000 --> 00:38:44,000
que lo agregará al array.

750
00:38:44,000 --> 00:38:46,000
Y ahora vamos a mostrar los que tiene.

751
00:38:46,000 --> 00:38:48,000
A ver si ahora en ese segundo mostrar funciones

752
00:38:48,000 --> 00:38:50,000
nos muestra las dos.

753
00:38:50,000 --> 00:38:52,000
¿Vale? Está claro lo que

754
00:38:52,000 --> 00:38:54,000
hemos hecho. Un teatro

755
00:38:54,000 --> 00:38:56,000
con nombre y funciones nul

756
00:38:56,000 --> 00:38:58,000
por ahora. Agregamos

757
00:38:58,000 --> 00:39:00,000
una primera y mostramos.

758
00:39:00,000 --> 00:39:02,000
Agregamos una segunda

759
00:39:02,000 --> 00:39:04,000
y mostramos. A ver si

760
00:39:04,000 --> 00:39:06,000
nos sale algún null point de

761
00:39:06,000 --> 00:39:08,000
deceptio, no lo hace bien.

762
00:39:10,000 --> 00:39:12,000
Pues lo ha hecho bien.

763
00:39:12,000 --> 00:39:14,000
Este es el resultado del primer mostrar

764
00:39:14,000 --> 00:39:16,000
donde solo tenía uno.

765
00:39:16,000 --> 00:39:18,000
Y este es el resultado del

766
00:39:18,000 --> 00:39:20,000
segundo mostrar donde ahora tiene las dos.

767
00:39:20,000 --> 00:39:22,000
Entonces pues sí.

768
00:39:22,000 --> 00:39:24,000
Lo ha hecho bien, ahora tiene

769
00:39:24,000 --> 00:39:26,000
las dos y así podríamos seguir agregando

770
00:39:26,000 --> 00:39:28,000
todas las funciones que hicieran falta.

771
00:39:28,000 --> 00:39:30,000
E ir incorporando métodos

772
00:39:30,000 --> 00:39:32,000
pues la función más cara, suma

773
00:39:32,000 --> 00:39:34,000
de todas las funciones, yo que sé. Ahí esta

774
00:39:34,000 --> 00:39:36,000
aplicación ya podría extenderse

775
00:39:36,000 --> 00:39:38,000
con un montón de métodos, funcionalidades

776
00:39:38,000 --> 00:39:40,000
para el teatro, para las

777
00:39:40,000 --> 00:39:42,000
funciones, para lo que fuera.

778
00:39:42,000 --> 00:39:44,000
¿Vale? Pero su diseño de clases

779
00:39:44,000 --> 00:39:46,000
pues sería este.

780
00:39:46,000 --> 00:39:48,000
Que era lo interesante

781
00:39:48,000 --> 00:39:50,000
de este ejercicio, ver un diseño de este tipo

782
00:39:50,000 --> 00:39:52,000
que puede tener unas propiedades que es

783
00:39:52,000 --> 00:39:54,000
de tipo objeto.

784
00:39:54,000 --> 00:39:56,000
Y a partir

785
00:39:56,000 --> 00:39:58,000
de ahí se puede extender.

786
00:39:58,000 --> 00:40:00,000
Pues función más cara.

787
00:40:00,000 --> 00:40:02,000
Mostrar

788
00:40:02,000 --> 00:40:04,000
el nombre de la

789
00:40:04,000 --> 00:40:06,000
función cuyo precio

790
00:40:06,000 --> 00:40:08,000
rebase no sé qué cantidad.

791
00:40:08,000 --> 00:40:10,000
Pues lo que sea, las funcionalidades que se vayan

792
00:40:10,000 --> 00:40:12,000
necesitando.

793
00:40:14,000 --> 00:40:16,000
¿Vale? ¿Alguna pregunta?

794
00:40:18,000 --> 00:40:20,000
Bueno.

795
00:40:24,000 --> 00:40:26,000
¿Habíais hecho esto en Navidad?

796
00:40:26,000 --> 00:40:28,000
¿Alguien?

797
00:40:28,000 --> 00:40:30,000
¿Miguel?

798
00:40:30,000 --> 00:40:32,000
No te des miedo que te vayan a

799
00:40:32,000 --> 00:40:34,000
fusilar.

800
00:40:36,000 --> 00:40:38,000
Bueno. Pues a ver.

801
00:40:38,000 --> 00:40:40,000
Tenéis esto de aquí

802
00:40:40,000 --> 00:40:42,000
para hacer esta tarde.

803
00:40:42,000 --> 00:40:44,000
Esto que eran

804
00:40:44,000 --> 00:40:46,000
son un poco más sencillos.

805
00:40:46,000 --> 00:40:48,000
Estaban puestos ahí con la idea de

806
00:40:48,000 --> 00:40:50,000
hacer hoy el repaso.

807
00:40:50,000 --> 00:40:52,000
Espero que lo hemos

808
00:40:52,000 --> 00:40:54,000
hecho corrigiendo esto.

809
00:40:54,000 --> 00:40:56,000
Conclusión, que lo estudiéis todo, que lo hagáis todo,

810
00:40:56,000 --> 00:40:58,000
que lo repaséis todo, porque tenemos que contar

811
00:40:58,000 --> 00:41:00,000
muchísimas, muchísimas cosas más.

812
00:41:00,000 --> 00:41:02,000
Muchas más.

813
00:41:02,000 --> 00:41:04,000
Y hay que ir avanzando.

814
00:41:04,000 --> 00:41:06,000
Pues venga.

815
00:41:06,000 --> 00:41:08,000
A estudiarlo todo.