1
00:00:00,000 --> 00:00:20,000
Venga, pues ala, ejercicio 3, vale, en el proyecto que estoy subiendo la ola virtual,

2
00:00:20,000 --> 00:00:24,000
lo estoy metiendo cada ejercicio ahí en paquetes distintos,

3
00:00:24,000 --> 00:00:27,000
pero insisto, nosotros todavía no sabemos lo que son paquetes,

4
00:00:27,000 --> 00:00:33,000
aunque creáis que lo sabéis, no lo sabéis, lo sabréis en unos días.

5
00:00:33,000 --> 00:00:38,000
Bueno, pues venga, el ejercicio 3, vamos a calentar con él.

6
00:00:38,000 --> 00:00:47,000
En este caso, la aplicación ya me da el análisis hecho,

7
00:00:47,000 --> 00:00:53,000
que va a ser la mayoría de nuestros casos en los exámenes o vídeos que planteemos.

8
00:00:54,000 --> 00:00:57,000
Nosotros en los ejercicios que planteemos y en los exámenes,

9
00:00:57,000 --> 00:01:02,000
ya diremos qué clases hay que programar, pero en una situación real,

10
00:01:02,000 --> 00:01:05,000
en una aplicación real, a uno lo que se le dice es,

11
00:01:05,000 --> 00:01:09,000
tienes que solucionarme el problema de matricular a los alumnos de mi instituto,

12
00:01:09,000 --> 00:01:14,000
y uno ahí tendrá que hacer su análisis y decir, vamos a ver,

13
00:01:14,000 --> 00:01:17,000
qué entidades voy a necesitar, esta, esta, esta,

14
00:01:17,000 --> 00:01:20,000
y empezar a trabajar desde ahí, desde ese punto,

15
00:01:20,000 --> 00:01:23,000
¿vale? Pero toda esa parte de análisis previo, insisto,

16
00:01:23,000 --> 00:01:26,000
nosotros ahora no la estamos haciendo porque nuestros enunciados

17
00:01:26,000 --> 00:01:29,000
ya directamente dicen qué clases tienes que programar,

18
00:01:29,000 --> 00:01:32,000
y luego el programa principal, qué tiene que hacer.

19
00:01:32,000 --> 00:01:36,000
Bueno, pues este es el caso, nos están diciendo, venga,

20
00:01:36,000 --> 00:01:42,000
esta aplicación es el software que va dentro de una cafetera, ¿vale?

21
00:01:42,000 --> 00:01:46,000
Cuando una cafetera, tú le das al botón de llenar agua,

22
00:01:46,000 --> 00:01:52,000
echar café, pues das a botones, esos botones ejecutarán un pequeño programa,

23
00:01:52,000 --> 00:01:56,000
un programa que activará los sensores de abrir la compuerta del agua,

24
00:01:56,000 --> 00:01:59,000
lo que sea, pues lo que te están diciendo es,

25
00:01:59,000 --> 00:02:03,000
haz esa aplicación, esa aplicación.

26
00:02:03,000 --> 00:02:06,000
Bueno, pues esa aplicación, ¿con qué va a trabajar?

27
00:02:06,000 --> 00:02:11,000
Con una cafetera, ¿no? La aplicación del software interno de una cafetera,

28
00:02:11,000 --> 00:02:14,000
la entidad con la que trabajas, la cafetera, pues ya está,

29
00:02:14,000 --> 00:02:16,000
ya te lo dicen aquí.

30
00:02:16,000 --> 00:02:20,000
Bueno, pues entonces vamos a necesitar una clase cafetera, ¿vale?

31
00:02:20,000 --> 00:02:27,000
Pues venga, lo primero entonces es declarar esa clase,

32
00:02:27,000 --> 00:02:32,000
lo primero es declarar esa clase, que es la única entidad

33
00:02:32,000 --> 00:02:38,000
con la que va a trabajar el software, la cafetera, la única,

34
00:02:38,000 --> 00:02:43,000
pues hala, venga, ya está la clase, ¿vale?

35
00:02:43,000 --> 00:02:47,000
El public, yo lo quito porque como no sabemos lo que es,

36
00:02:47,000 --> 00:02:51,000
pues tener algo ahí que no sabemos lo que es, pues no me gusta.

37
00:02:51,000 --> 00:02:55,000
Bueno, ahora la siguiente pregunta que uno se haría en un caso real es,

38
00:02:55,000 --> 00:03:00,000
vale, este software que gestiona el funcionamiento de la cafetera,

39
00:03:00,000 --> 00:03:05,000
este software, ¿qué datos de la cafetera necesita para funcionar?

40
00:03:06,000 --> 00:03:10,000
Pues la capacidad, lo que tiene en ese momento, la marca,

41
00:03:10,000 --> 00:03:13,000
el volumen, el color, ¿qué datos necesita de la cafetera

42
00:03:13,000 --> 00:03:15,000
para gestionar ese software?

43
00:03:15,000 --> 00:03:19,000
Bueno, pues después de haber hecho el análisis de los requisitos

44
00:03:19,000 --> 00:03:22,000
de la aplicación, uno llegaría a la conclusión,

45
00:03:22,000 --> 00:03:26,000
que ya te dan aquí en el enunciado, que te dicen, a ver,

46
00:03:26,000 --> 00:03:30,000
las acciones que hace ese software, que son llenar la cafetera,

47
00:03:30,000 --> 00:03:35,000
servir café, etcétera, los únicos datos que necesitan son

48
00:03:35,000 --> 00:03:43,000
la cantidad máxima de café que cabe y la cantidad actual que tiene.

49
00:03:43,000 --> 00:03:49,000
Solo necesitas esos dos datos, la que tiene y la que cabría como máximo.

50
00:03:49,000 --> 00:03:52,000
Con esas dos informaciones, el software de la cafetera

51
00:03:52,000 --> 00:03:55,000
ya puede hacer todo lo que necesite.

52
00:03:55,000 --> 00:03:58,000
Vale, aquí ya he enunciado, te dice que son esas dos las propiedades

53
00:03:58,000 --> 00:04:02,000
que necesitamos, pero en un caso real, pues uno tendría que haber analizado

54
00:04:02,000 --> 00:04:05,000
en función de los requisitos que tiene que satisfacer,

55
00:04:05,000 --> 00:04:11,000
cuáles son las características que necesita.

56
00:04:11,000 --> 00:04:13,000
¿Vale?

57
00:04:13,000 --> 00:04:20,000
Y Andon y Diego Jiménez no creo que vuelvan a aprobar en su vida.

58
00:04:20,000 --> 00:04:26,000
Porque lo veo venido.

59
00:04:26,000 --> 00:04:32,000
Pues venga, entonces, capacidad máxima y cantidad actual.

60
00:04:32,000 --> 00:04:36,000
Bueno, habría que decidir de esos dos datos qué son los que necesitamos.

61
00:04:36,000 --> 00:04:39,000
Bueno, entero, double, pues bueno, el que más nos guste.

62
00:04:39,000 --> 00:04:45,000
Vamos a suponer que son centímetros cúbicos, porque es un tema de volumen.

63
00:04:45,000 --> 00:04:52,000
Pues venga, entero.

64
00:04:52,000 --> 00:04:58,000
Vale, pues esa es una de las propiedades de cada cafetera, la capacidad máxima.

65
00:04:58,000 --> 00:05:05,000
Vale, y la otra, la cantidad que tiene en ese momento.

66
00:05:05,000 --> 00:05:10,000
Como las dos son enteras, pues nosotros ya sabemos declarar las variables,

67
00:05:10,000 --> 00:05:13,000
si son del mismo tipo, las declaramos ya en la misma línea,

68
00:05:13,000 --> 00:05:14,000
todo esto ya lo sabemos.

69
00:05:14,000 --> 00:05:18,000
Ahora, ya tenemos las propiedades.

70
00:05:18,000 --> 00:05:22,000
Por defecto, uno suele hacer un constructor siempre.

71
00:05:22,000 --> 00:05:27,000
Ya lo dijimos antes de irnos de vacaciones cuando miramos los constructores.

72
00:05:27,000 --> 00:05:35,000
Que por defecto, uno suele hacer un constructor siempre cafetera,

73
00:05:35,000 --> 00:05:41,000
que es el que llamamos, el que se llama constructor con parámetros, ¿verdad?

74
00:05:41,000 --> 00:05:47,000
Es al que se le pasan dos valores y el constructor los usa

75
00:05:47,000 --> 00:05:51,000
para inicializar con ellos esas propiedades.

76
00:05:51,000 --> 00:05:53,000
Ese es el famoso constructor con parámetros.

77
00:05:53,000 --> 00:05:57,000
Entonces uno lo puede escribir a mano o como se suele hacer siempre por defecto,

78
00:05:57,000 --> 00:06:00,000
ya dijimos que el Eclipse y otros entornos de desarrollo

79
00:06:00,000 --> 00:06:04,000
te permiten generarlo automáticamente con el source,

80
00:06:04,000 --> 00:06:08,000
generar constructor usando campos, bla, bla, bla.

81
00:06:09,000 --> 00:06:13,000
Le quito el super porque en este caso no está haciendo nada,

82
00:06:13,000 --> 00:06:15,000
estar y no estar es lo mismo.

83
00:06:15,000 --> 00:06:17,000
Y le quito el public por lo mismo,

84
00:06:17,000 --> 00:06:20,000
porque no sé ninguna de las dos cosas qué significa

85
00:06:20,000 --> 00:06:23,000
y que estén o que no estén da exactamente igual,

86
00:06:23,000 --> 00:06:25,000
porque no la estamos usando.

87
00:06:25,000 --> 00:06:29,000
Este es el constructor con parámetros que se llama,

88
00:06:29,000 --> 00:06:34,000
que es el constructor que suelen incluir todas las clases porque es muy útil.

89
00:06:34,000 --> 00:06:37,000
Si tú tienes este constructor, cuando instancias el objeto,

90
00:06:37,000 --> 00:06:43,000
en el momento de instanciarlo ya aprovechas y le das un primer valor.

91
00:06:43,000 --> 00:06:48,000
Ya aprovechas y le das un primer valor a través de estos parámetros.

92
00:06:50,000 --> 00:06:56,000
¿Recordáis aquí el primero de los 2315 matices distintos

93
00:06:56,000 --> 00:07:01,000
que vais a tener que ir incorporando todos de memoria, no en los papeles?

94
00:07:01,000 --> 00:07:04,000
En esos son los que espero que estéis tomando apuntes.

95
00:07:04,000 --> 00:07:07,000
Bueno, pues aparte de los papeles de los que toméis apuntes,

96
00:07:07,000 --> 00:07:13,000
habrá las 2315 cosas que tendréis que ir incorporando en la cabeza de memoria.

97
00:07:13,000 --> 00:07:16,000
Bueno, pues una de ellas, recordad que era esta.

98
00:07:16,000 --> 00:07:22,000
Cuando yo doy aquí un parámetro y resulta que este parámetro

99
00:07:22,000 --> 00:07:26,000
se llama igual que una propiedad, se llama igual que una propiedad,

100
00:07:26,000 --> 00:07:29,000
de repente aparece una ambigüedad, ¿verdad?

101
00:07:29,000 --> 00:07:32,000
Aparece una ambigüedad. ¿Qué es?

102
00:07:32,000 --> 00:07:35,000
Oye tú, ¿y aquí dentro qué pasa?

103
00:07:35,000 --> 00:07:44,000
Cuando yo ponga capacidad máxima,

104
00:07:44,000 --> 00:07:47,000
¿a quién le estoy haciendo referencia?

105
00:07:47,000 --> 00:07:50,000
¿Al parámetro que le he pasado desde fuera?

106
00:07:50,000 --> 00:07:53,000
¿O a la propiedad interna de la cafetera?

107
00:07:53,000 --> 00:07:56,000
Se acaba de crear una ambigüedad, ¿no?

108
00:07:56,000 --> 00:07:59,000
¿Por qué se llama igual?

109
00:07:59,000 --> 00:08:04,000
Pues esa ambigüedad se resuelve, dijimos, con esto.

110
00:08:04,000 --> 00:08:11,000
Porque si nosotros no ponemos esto, esto se refiere al parámetro que está aquí.

111
00:08:11,000 --> 00:08:15,000
Y si ponemos this significa no, es propiedad del objeto al que estoy,

112
00:08:15,000 --> 00:08:18,000
de este, this, de este.

113
00:08:18,000 --> 00:08:22,000
Entonces el this es opcional cuando no hay ambigüedad.

114
00:08:22,000 --> 00:08:24,000
Cuando no hay ambigüedad es opcional,

115
00:08:24,000 --> 00:08:26,000
porque no hay ningún parámetro que se llame así.

116
00:08:26,000 --> 00:08:28,000
Si a este le hubieran cambiado de nombre,

117
00:08:28,000 --> 00:08:30,000
el Eclipse hubiera decidido dar otro nombre,

118
00:08:30,000 --> 00:08:32,000
no lo ha decidido porque es muy listo,

119
00:08:32,000 --> 00:08:34,000
y lo hubiera decidido llamar así,

120
00:08:34,000 --> 00:08:36,000
entonces no habría ambigüedad

121
00:08:36,000 --> 00:08:47,000
y este constructor podría haberse hecho así.

122
00:08:47,000 --> 00:08:50,000
Ahora no habría ambigüedad, el this sobra.

123
00:08:50,000 --> 00:08:53,000
Sería opcional, porque con capacidad máxima

124
00:08:53,000 --> 00:08:55,000
no hay duda de a qué nos referimos.

125
00:08:55,000 --> 00:08:57,000
Nos referimos a la propiedad porque no hay nadie más

126
00:08:57,000 --> 00:09:00,000
que se llame capacidad máxima, no hay nadie más, no hay duda.

127
00:09:00,000 --> 00:09:03,000
Con lo cual el this es opcional, sobra.

128
00:09:03,000 --> 00:09:07,000
Que lo pongo por claridad, que suele ser habitual ponerlo,

129
00:09:07,000 --> 00:09:10,000
porque queda más bonito, no pasa nada, no sobra.

130
00:09:10,000 --> 00:09:13,000
Ahí está estupendo el this puesto.

131
00:09:13,000 --> 00:09:15,000
Que no me da la gana ponerlo,

132
00:09:15,000 --> 00:09:20,000
porque no me gusta poner cosas opcionales, lo quito.

133
00:09:20,000 --> 00:09:22,000
Da igual, no hay ambigüedad en cualquier caso,

134
00:09:22,000 --> 00:09:24,000
porque solo hay una cosa que se llame capacidad máxima,

135
00:09:24,000 --> 00:09:27,000
que es esto.

136
00:09:27,000 --> 00:09:30,000
Pero si se nos ha ocurrido, como se le ocurre al Eclipse

137
00:09:30,000 --> 00:09:35,000
y a todo el mundo, llamarlo igual,

138
00:09:35,000 --> 00:09:38,000
pues la ambigüedad aparece.

139
00:09:38,000 --> 00:09:46,000
Si la ambigüedad aparece, ahora ya hay que resolverla.

140
00:09:46,000 --> 00:09:50,000
Capacidad máxima, si yo no pongo this, es este.

141
00:09:50,000 --> 00:09:52,000
Con lo cual esto sería absurdo.

142
00:09:52,000 --> 00:09:56,000
Sería, al parámetro capacidad máxima, asígnale el valor del parámetro.

143
00:09:56,000 --> 00:09:59,000
¿Qué tontería es esa? Esto no tendría sentido.

144
00:09:59,000 --> 00:10:04,000
Entonces aquí sí que tenemos que poner el this,

145
00:10:04,000 --> 00:10:11,000
porque yo me quiero referir a la propiedad.

146
00:10:11,000 --> 00:10:13,000
Esto está claro, ¿no?

147
00:10:13,000 --> 00:10:15,000
Este this sirve para eso, para decir,

148
00:10:15,000 --> 00:10:19,000
el objeto en el que estoy, punto la propiedad que yo quiera.

149
00:10:19,000 --> 00:10:23,000
Y es imprescindible cuando hay dos variables que se llaman igual.

150
00:10:23,000 --> 00:10:26,000
Tengo que distinguir si estoy en la propiedad del objeto

151
00:10:26,000 --> 00:10:28,000
o estoy en otra variable.

152
00:10:28,000 --> 00:10:31,000
Este parámetro, lo que sea.

153
00:10:31,000 --> 00:10:33,000
Esa ambigüedad también podría haber aparecido.

154
00:10:33,000 --> 00:10:37,000
Imagínate que yo estos parámetros los quito de ahí

155
00:10:37,000 --> 00:10:43,000
y me he creado aquí una variable,

156
00:10:43,000 --> 00:10:46,000
o sea que los leo por teclado, por ejemplo,

157
00:10:46,000 --> 00:10:54,000
y me creo yo aquí un capacidad máxima,

158
00:10:54,000 --> 00:10:59,000
una variable local que me creo ahí, capacidad máxima,

159
00:10:59,000 --> 00:11:01,000
que la leemos por teclado.

160
00:11:17,000 --> 00:11:22,000
Hacemos el import.

161
00:11:22,000 --> 00:11:27,000
Y ahora yo pongo aquí,

162
00:11:27,000 --> 00:11:35,000
introduzca capacidad máxima.

163
00:11:35,000 --> 00:11:41,000
Y la leo aquí, scan.next int era.

164
00:11:41,000 --> 00:12:10,000
Vale, hago lo mismo con la cantidad actual.

165
00:12:10,000 --> 00:12:12,000
Vale, pues este es otro constructor que me podría a mí

166
00:12:12,000 --> 00:12:13,000
haber dado la gana hacer.

167
00:12:13,000 --> 00:12:14,000
¿Por qué no?

168
00:12:14,000 --> 00:12:16,000
Me da a mí la gana hacer este constructor.

169
00:12:16,000 --> 00:12:19,000
Vale, un constructor al que no le paso parámetros.

170
00:12:19,000 --> 00:12:21,000
¿Y qué es lo que hace cuando se le llama?

171
00:12:21,000 --> 00:12:24,000
Pide él por teclado los valores,

172
00:12:24,000 --> 00:12:27,000
los pide, los guarda en dos variables locales,

173
00:12:27,000 --> 00:12:33,000
y ahora asigna esos valores a las propiedades de la cafetera.

174
00:12:33,000 --> 00:12:38,000
Podría haberme dado a mí la gana hacer ese constructor, ¿no?

175
00:12:38,000 --> 00:12:41,000
Vale, pues de nuevo aquí hay ambigüedad,

176
00:12:41,000 --> 00:12:45,000
porque ahora tengo aquí dos cosas que se llaman capacidad máxima.

177
00:12:45,000 --> 00:12:48,000
Esta variable que acabo de declarar,

178
00:12:48,000 --> 00:12:51,000
esta variable que está dentro de este método,

179
00:12:51,000 --> 00:12:52,000
y la propiedad.

180
00:12:52,000 --> 00:12:54,000
De nuevo he creado una ambigüedad.

181
00:12:54,000 --> 00:12:56,000
Pues ahora de nuevo le doy el dis,

182
00:12:56,000 --> 00:12:59,000
porque si yo quito el dis,

183
00:12:59,000 --> 00:13:01,000
pues estoy haciendo una tontería.

184
00:13:01,000 --> 00:13:03,000
Si yo quito el dis el compilador ha encantado,

185
00:13:03,000 --> 00:13:05,000
dice a mí que más me da, quítalo si quieres.

186
00:13:05,000 --> 00:13:07,000
Pero entonces ¿qué estaríamos haciendo?

187
00:13:07,000 --> 00:13:10,000
Asignar a esta misma variable su propio valor,

188
00:13:10,000 --> 00:13:12,000
o sea, sentencia estúpida.

189
00:13:12,000 --> 00:13:14,000
A la variable n le asigno n,

190
00:13:14,000 --> 00:13:16,000
estaríamos haciendo un n igual a n.

191
00:13:16,000 --> 00:13:19,000
Y a esta variable le estaríamos asignando su propio valor.

192
00:13:19,000 --> 00:13:22,000
¿Para qué voy a hacer yo esa tontería, n igual a n?

193
00:13:22,000 --> 00:13:24,000
Es que no quiero hacer esa tontería.

194
00:13:24,000 --> 00:13:27,000
Lo que quiero es a la propiedad de la cafetera de arriba

195
00:13:27,000 --> 00:13:31,000
asignarle el contenido de esta variable que lo acabo de leer.

196
00:13:31,000 --> 00:13:33,000
Son dos cosas distintas.

197
00:13:33,000 --> 00:13:35,000
Entonces tengo que distinguirlo.

198
00:13:35,000 --> 00:13:38,000
Así que tendría que poner el dis para que esto tenga sentido.

199
00:13:44,000 --> 00:13:47,000
Este es otro constructor que yo puedo hacer si quiero.

200
00:13:47,000 --> 00:13:49,000
De hecho vamos a ir haciendo el main en paralelo.

201
00:13:49,000 --> 00:13:53,000
Vamos a hacer un main en paralelo para irlo viendo.

202
00:13:56,000 --> 00:13:59,000
Pues nos hacemos una clase aquí con método main.

203
00:14:00,000 --> 00:14:08,000
Y ahora vamos a crear aquí un objeto cafetera con ese constructor.

204
00:14:11,000 --> 00:14:13,000
Lo estoy haciendo para ejemplificar lo otro.

205
00:14:13,000 --> 00:14:16,000
Todavía no estoy haciendo exactamente lo que pide el ejercicio.

206
00:14:21,000 --> 00:14:23,000
Por ejemplo, llamo así.

207
00:14:29,000 --> 00:14:32,000
Vale, pues con esto he distanciado el objeto.

208
00:14:33,000 --> 00:14:40,000
Ahora voy a hacer que se muestren los valores que tienen.

209
00:14:41,000 --> 00:14:45,000
Pues cft punto su capacidad actual.

210
00:14:45,000 --> 00:14:52,000
Vamos a ver, vamos a poner la capacidad máxima es.

211
00:14:53,000 --> 00:14:58,000
Y pongo aquí cft punto capacidad máxima.

212
00:15:00,000 --> 00:15:04,000
Y ahora voy a poner aquí.

213
00:15:09,000 --> 00:15:18,000
La cantidad actual es cf punto cantidad actual.

214
00:15:30,000 --> 00:15:32,000
Este trozo de main tiene sentido.

215
00:15:32,000 --> 00:15:36,000
Es un trozo de main que estoy poniendo para ejemplo solo.

216
00:15:36,000 --> 00:15:39,000
Crea un objeto cafetera, lo creas.

217
00:15:39,000 --> 00:15:44,000
Y ahora me muestra la capacidad máxima de esa cafetera que acabas de crear.

218
00:15:44,000 --> 00:15:48,000
Accediendo a su propiedad capacidad máxima como sabemos acceder.

219
00:15:48,000 --> 00:15:50,000
Y luego muestra la cantidad actual que tiene.

220
00:15:50,000 --> 00:15:53,000
Accediendo a su propiedad cantidad actual.

221
00:15:54,000 --> 00:15:56,000
¿Vale?

222
00:15:56,000 --> 00:15:58,000
Entonces este trozo de main.

223
00:16:00,000 --> 00:16:03,000
Bueno, pues vale, ese trozo de main tiene sentido.

224
00:16:03,000 --> 00:16:06,000
Entonces, ¿qué va a pasar cuando lo ejecutemos?

225
00:16:06,000 --> 00:16:09,000
Se va a crear el objeto en memoria.

226
00:16:09,000 --> 00:16:11,000
Y se va a llamar al constructor.

227
00:16:11,000 --> 00:16:14,000
Bueno, pero ¿el constructor qué hace?

228
00:16:14,000 --> 00:16:19,000
Pues el constructor nos va a pedir esto.

229
00:16:19,000 --> 00:16:21,000
Nos va a pedir los valores.

230
00:16:21,000 --> 00:16:25,000
Y se los va a dar a las propiedades de la cafetera.

231
00:16:25,000 --> 00:16:27,000
Todo eso se va a hacer.

232
00:16:27,000 --> 00:16:29,000
Como consecuencia de la instanciación.

233
00:16:29,000 --> 00:16:31,000
Todo eso.

234
00:16:33,000 --> 00:16:34,000
¿Vale?

235
00:16:34,000 --> 00:16:35,000
Está claro lo que va a pasar, ¿no?

236
00:16:35,000 --> 00:16:38,000
Si hacemos esta ejecución de este main.

237
00:16:40,000 --> 00:16:42,000
Lo ejecutamos.

238
00:16:44,000 --> 00:16:47,000
Y aquí efectivamente está dentro del constructor.

239
00:16:47,000 --> 00:16:48,000
Acaba de llamarlo.

240
00:16:48,000 --> 00:16:49,000
Está dentro de él.

241
00:16:49,000 --> 00:16:50,000
Lo acaba de llamar.

242
00:16:50,000 --> 00:16:52,000
Estamos todavía en esta línea.

243
00:16:52,000 --> 00:16:54,000
Estamos aquí todavía.

244
00:16:54,000 --> 00:16:57,000
Acaba de llamar al constructor y está ahí parado.

245
00:16:57,000 --> 00:16:58,000
Está ahí en el next scene.

246
00:16:58,000 --> 00:16:59,000
Está ahí parado.

247
00:16:59,000 --> 00:17:00,000
¿Vale?

248
00:17:00,000 --> 00:17:01,000
Capacidad actual de esta cafetera.

249
00:17:01,000 --> 00:17:03,000
Venga, esta cafetera tiene 100.

250
00:17:03,000 --> 00:17:04,000
Sigue en el constructor.

251
00:17:04,000 --> 00:17:06,000
Sigue ahí dentro parado.

252
00:17:06,000 --> 00:17:07,000
Sigue ahí.

253
00:17:07,000 --> 00:17:08,000
Ahora está aquí en el next scene.

254
00:17:08,000 --> 00:17:09,000
Sigue ahí.

255
00:17:11,000 --> 00:17:12,000
¿Vale?

256
00:17:12,000 --> 00:17:14,000
La cantidad actual que tiene.

257
00:17:14,000 --> 00:17:15,000
50.

258
00:17:15,000 --> 00:17:18,000
Y ahora efectivamente la cafetera ya se crea.

259
00:17:18,000 --> 00:17:20,000
Con estos valores de las propiedades.

260
00:17:20,000 --> 00:17:22,000
100 y 50.

261
00:17:22,000 --> 00:17:25,000
Y ahora ya me dice la capacidad máxima es 100,

262
00:17:25,000 --> 00:17:27,000
porque 100 es lo que tiene esta propiedad.

263
00:17:28,000 --> 00:17:30,000
Y la cantidad actual es 50.

264
00:17:32,000 --> 00:17:34,000
Bueno, está claro, ¿no?

265
00:17:35,000 --> 00:17:38,000
Pero claro, esto mismo uno le quita el dis

266
00:17:39,000 --> 00:17:42,000
y compila estupendamente, pero deja de tener todo el sentido.

267
00:17:43,000 --> 00:17:45,000
Le quitamos el dis.

268
00:17:49,000 --> 00:17:50,000
¿Vale?

269
00:17:50,000 --> 00:17:51,000
Le quito el dis.

270
00:17:51,000 --> 00:17:53,000
Y ahora hago la pregunta.

271
00:17:53,000 --> 00:17:54,000
¿Vale?

272
00:17:54,000 --> 00:17:56,000
A mi aplicación le he quitado el dis.

273
00:17:56,000 --> 00:17:58,000
Y lo dejo así.

274
00:17:58,000 --> 00:18:00,000
Y ahora hago la pregunta.

275
00:18:00,000 --> 00:18:02,000
Yo voy a volver a ejecutar esto.

276
00:18:02,000 --> 00:18:04,000
Voy a volver a ejecutar este main.

277
00:18:04,000 --> 00:18:06,000
Voy a volver a ejecutarlo.

278
00:18:07,000 --> 00:18:09,000
Va a llamar al constructor.

279
00:18:10,000 --> 00:18:11,000
Entonces,

280
00:18:13,000 --> 00:18:14,000
¿qué me va a salir?

281
00:18:14,000 --> 00:18:16,000
O sea, esto me va a salir, lógicamente,

282
00:18:16,000 --> 00:18:17,000
vea el constructor.

283
00:18:17,000 --> 00:18:18,000
Y aquí, ¿qué me va a salir?

284
00:18:18,000 --> 00:18:20,000
La capacidad máxima es ¿cuánto?

285
00:18:20,000 --> 00:18:22,000
Y la cantidad actual es ¿cuánto?

286
00:18:22,000 --> 00:18:23,000
¿Qué me va a salir?

287
00:18:23,000 --> 00:18:26,000
Cuando yo ejecute el programa ahora con este cambio que he hecho.

288
00:18:26,000 --> 00:18:29,000
Quitando el dis porque me he equivocado y he quitado el dis.

289
00:18:30,000 --> 00:18:32,000
Y he dejado así la sentencia.

290
00:18:34,000 --> 00:18:36,000
¿Qué me va a salir ahí?

291
00:18:37,000 --> 00:18:39,000
Cuando yo lo ejecute.

292
00:18:42,000 --> 00:18:44,000
Venga, que alguien me diga algo.

293
00:18:46,000 --> 00:18:48,000
Cuando yo haga la ejecución,

294
00:18:50,000 --> 00:18:53,000
¿qué número me va a salir aquí y qué número me va a salir ahí?

295
00:18:53,000 --> 00:18:55,000
Con este cambio que he hecho.

296
00:18:57,000 --> 00:18:58,000
¿Qué es este?

297
00:18:58,000 --> 00:18:59,000
He hecho este cambio.

298
00:18:59,000 --> 00:19:00,000
He quitado el dis.

299
00:19:00,000 --> 00:19:02,000
Es el único cambio que he hecho.

300
00:19:07,000 --> 00:19:10,000
Venga, con lo que acabo de explicar me lo tendríais que decir.

301
00:19:13,000 --> 00:19:15,000
¿Qué numeritos me van a salir ahí?

302
00:19:16,000 --> 00:19:18,000
¿Qué numeritos me van a salir ahí?

303
00:19:21,000 --> 00:19:22,000
Efectivamente.

304
00:19:23,000 --> 00:19:25,000
El constructor será invocado.

305
00:19:25,000 --> 00:19:26,000
Estupendo.

306
00:19:26,000 --> 00:19:29,000
Cogerá dos valores y guardará estas variables internas.

307
00:19:30,000 --> 00:19:34,000
Y con estas asignaciones será a esta misma variable a la que asigne su valor.

308
00:19:35,000 --> 00:19:38,000
Es una tontería porque ya lo tenía, pero bueno, se lo vuelve a asignar.

309
00:19:38,000 --> 00:19:41,000
Conclusión, las propiedades de arriba no se han enterado de nada.

310
00:19:41,000 --> 00:19:45,000
Las propiedades de arriba, lo que ha hecho el constructor les ha dado exactamente igual.

311
00:19:46,000 --> 00:19:50,000
Luego, a la hora de mostrarlas, aquí el main cuando las muestra,

312
00:19:51,000 --> 00:19:56,000
va a mostrar los valores que tengan por defecto porque nadie les ha asignado nada.

313
00:19:57,000 --> 00:20:01,000
Y ya hemos dicho varias veces que una variable numérica por defecto,

314
00:20:01,000 --> 00:20:04,000
si no se le asigna nada, Java le asigna al cero.

315
00:20:15,000 --> 00:20:18,000
Y efectivamente, pues es lo que me está diciendo.

316
00:20:18,000 --> 00:20:19,000
Cero, cero.

317
00:20:26,000 --> 00:20:32,000
Luego, obviamente, yo no me equivoco y pongo las cosas como las tengo que poner.

318
00:20:34,000 --> 00:20:35,000
Y esto ya sí.

319
00:20:38,000 --> 00:20:42,000
Entonces diríais, jolín, pues qué ganas de complicar las cosas

320
00:20:42,000 --> 00:20:46,000
llamando a variables internas exactamente igual que a las propiedades.

321
00:20:47,000 --> 00:20:51,000
No las llames igual y así si te olvidas del dis no pasa nada.

322
00:20:51,000 --> 00:20:53,000
Bueno, pero es que hay que hacer las cosas bien.

323
00:20:53,000 --> 00:20:58,000
Es que si esa variable lo que significa es la capacidad máxima de la cafetera

324
00:20:58,000 --> 00:21:05,000
que se llame así, las variables tienen que llamarse con un nombre que signifique lo que son.

325
00:21:05,000 --> 00:21:08,000
Porque eso va a hacer que los demás entiendan el programa.

326
00:21:08,000 --> 00:21:11,000
Entonces si esa variable es la capacidad máxima que yo la quiero meter,

327
00:21:11,000 --> 00:21:13,000
que se llame capacidad máxima.

328
00:21:13,000 --> 00:21:16,000
Coño, qué mala suerte, también se llama capacidad máxima la de arriba.

329
00:21:16,000 --> 00:21:19,000
De mala suerte nada, para eso tienes un dis.

330
00:21:19,000 --> 00:21:23,000
Pero a las variables hay que llamarles con un nombre que explique lo que son.

331
00:21:23,000 --> 00:21:26,000
Que coincide con el de otro, con el de la propiedad.

332
00:21:26,000 --> 00:21:31,000
Bueno, por eso está el dis y por eso el Eclipse te genera los parámetros con el mismo nombre.

333
00:21:31,000 --> 00:21:33,000
Lo genera con el mismo nombre a propósito.

334
00:21:33,000 --> 00:21:35,000
Porque así queda más claro el código.

335
00:21:36,000 --> 00:21:38,000
Vale.

336
00:21:38,000 --> 00:21:40,000
Bueno.

337
00:21:40,000 --> 00:21:44,000
Voy a dejar este constructor, como ya lo tengo aquí hecho, voy a dejarlo porque no molesta.

338
00:21:44,000 --> 00:21:50,000
Pero también dijimos antes de vacaciones que uno puede poner todos los constructores que quiera.

339
00:21:50,000 --> 00:21:56,000
Pero tiene que distinguirlos, ya que no se puede distinguir por el nombre.

340
00:21:56,000 --> 00:21:58,000
Porque el nombre tiene que ser todos el mismo.

341
00:21:58,000 --> 00:22:01,000
El de la clase distingámoslo por los parámetros que recibe.

342
00:22:01,000 --> 00:22:03,000
Bueno, este no recibe ninguno.

343
00:22:03,000 --> 00:22:06,000
Pero puede hacer yo el constructor con parámetros.

344
00:22:06,000 --> 00:22:08,000
Por ejemplo este.

345
00:22:10,000 --> 00:22:12,000
Ah, la tengo.

346
00:22:12,000 --> 00:22:15,000
Le quito el public, que no sé lo que es y lo quito.

347
00:22:15,000 --> 00:22:17,000
Vale, ahora tengo dos constructores.

348
00:22:17,000 --> 00:22:19,000
Bueno, no pasa nada, puedo tener todos los que quiera.

349
00:22:19,000 --> 00:22:23,000
Porque son distinguibles por la lista de parámetros.

350
00:22:24,000 --> 00:22:27,000
Vale, tengo mis dos constructores en esta clase cafetera.

351
00:22:27,000 --> 00:22:29,000
Ya tengo las propiedades.

352
00:22:29,000 --> 00:22:31,000
Los constructores.

353
00:22:32,000 --> 00:22:34,000
Y me falta el resto de métodos.

354
00:22:34,000 --> 00:22:36,000
¿Vale?

355
00:22:36,000 --> 00:22:38,000
Para seguir probando.

356
00:22:38,000 --> 00:22:43,000
Por ejemplo, yo aquí he instanciado una cafetera, la cafetera1, con el primer constructor.

357
00:22:43,000 --> 00:22:45,000
¿Qué quiero hacer otra cafetera?

358
00:22:45,000 --> 00:22:47,000
Pues por ejemplo.

359
00:22:52,000 --> 00:22:54,000
¿Qué quiero hacer otra?

360
00:22:54,000 --> 00:22:56,000
Otro objeto cualquiera.

361
00:22:56,000 --> 00:23:00,000
Pues como ejemplo, vamos a hacerlo usando el otro constructor.

362
00:23:02,000 --> 00:23:05,000
Hay otro constructor que tiene que recibir dos parámetros, ¿no?

363
00:23:07,000 --> 00:23:10,000
Vale, cft1,1.

364
00:23:11,000 --> 00:23:14,000
Bueno, pues voy a pedirlos yo aquí en el programa principal.

365
00:23:14,000 --> 00:23:16,000
Voy a pedir en el programa principal y se los paso.

366
00:23:16,000 --> 00:23:18,000
Sería otra forma de hacerlo, otra forma.

367
00:23:18,000 --> 00:23:20,000
Entonces voy a copiar y pegar esto.

368
00:23:32,000 --> 00:23:34,000
Pongo ahí.

369
00:23:48,000 --> 00:23:50,000
Voy a poner aquí para distinguirlo.

370
00:23:50,000 --> 00:23:54,000
Para la segunda cafetera.

371
00:24:01,000 --> 00:24:11,000
Y ahora voy a mostrar aquí lo que tiene la otra también.

372
00:24:14,000 --> 00:24:18,000
Vale, pues por ejemplo, en este main que estoy haciendo para probar simplemente.

373
00:24:18,000 --> 00:24:20,000
He creado dos objetos cafetera.

374
00:24:20,000 --> 00:24:24,000
La primera y este lo he creado con la primera versión del constructor.

375
00:24:24,000 --> 00:24:29,000
La que dentro de ella pide los valores y se los da las propiedades.

376
00:24:29,000 --> 00:24:31,000
Vale, pues ya está.

377
00:24:32,000 --> 00:24:35,000
Y aquí estoy creando otra cafetera.

378
00:24:38,000 --> 00:24:41,000
Pero con la otra versión del constructor.

379
00:24:41,000 --> 00:24:44,000
Con la versión del constructor que necesita dos valores.

380
00:24:45,000 --> 00:24:47,000
¿Qué es esta versión?

381
00:24:47,000 --> 00:24:48,000
Esta.

382
00:24:48,000 --> 00:24:52,000
Necesita dos valores y coge esos valores para dárselos a las propiedades.

383
00:24:53,000 --> 00:24:55,000
Bueno, puede usar el constructor que quiera.

384
00:24:55,000 --> 00:24:57,000
Aquí estoy usando el otro.

385
00:24:57,000 --> 00:25:01,000
Entonces, esos dos valores los tengo que pedir previamente.

386
00:25:01,000 --> 00:25:03,000
Claro, los pido previamente.

387
00:25:03,000 --> 00:25:07,000
Bueno, pues los he pedido aquí previamente y ahora se los paso.

388
00:25:07,000 --> 00:25:09,000
Bueno, es otra forma, otra forma de hacerlo.

389
00:25:09,000 --> 00:25:11,000
Me da igual.

390
00:25:13,000 --> 00:25:16,000
Voy a ejecutar aquí para crear las dos.

391
00:25:17,000 --> 00:25:18,000
Esta es la primera.

392
00:25:18,000 --> 00:25:20,000
Estamos dentro del constructor.

393
00:25:20,000 --> 00:25:23,000
Pues venga, 120 y tiene 20.

394
00:25:24,000 --> 00:25:26,000
Y ahora, para la segunda.

395
00:25:26,000 --> 00:25:28,000
Esto me lo está pidiendo ahora ya desde el programa principal.

396
00:25:28,000 --> 00:25:29,000
Desde el main.

397
00:25:29,000 --> 00:25:31,000
Esto me lo está pidiendo desde el main.

398
00:25:31,000 --> 00:25:34,000
Pues la segunda creo que tenga 100 y 50.

399
00:25:34,000 --> 00:25:36,000
Ahora ya es cuando llama al constructor.

400
00:25:36,000 --> 00:25:40,000
Y lo único que hace el constructor es coger este 100 y 50 y pasárselo.

401
00:25:40,000 --> 00:25:43,000
Bueno, son diferentes formas de hacerlo.

402
00:25:45,000 --> 00:25:47,000
Lo que importa es que lo entendamos.

403
00:25:47,000 --> 00:25:49,000
Esto de los constructores.

404
00:25:49,000 --> 00:25:51,000
Pero repito.

405
00:25:51,000 --> 00:25:57,000
Este constructor es el constructor habitual que aparece en todas las clases.

406
00:25:57,000 --> 00:25:59,000
Porque es muy útil.

407
00:25:59,000 --> 00:26:06,000
Tú le pasas los valores y los usa para asignárselos a las propiedades.

408
00:26:08,000 --> 00:26:12,000
Y luego los valores, la aplicación ya los recoge como le dé la gana.

409
00:26:13,000 --> 00:26:16,000
Porque este constructor es muy poco útil en realidad.

410
00:26:16,000 --> 00:26:20,000
Este constructor te está obligando a que tengas una consola.

411
00:26:20,000 --> 00:26:23,000
Ahí activa para meterlo por teclado.

412
00:26:23,000 --> 00:26:27,000
Y si la aplicación cambia y tú ya no quieres meter los valores por teclado.

413
00:26:27,000 --> 00:26:29,000
Si no los quieres meter a una interfaz gráfica.

414
00:26:29,000 --> 00:26:31,000
Este constructor no vale para nada.

415
00:26:31,000 --> 00:26:33,000
Tendrías que cambiarlo todo otra vez.

416
00:26:34,000 --> 00:26:36,000
Por eso no se hace así.

417
00:26:36,000 --> 00:26:38,000
Por eso se trabaja con este.

418
00:26:39,000 --> 00:26:44,000
Y que sea el programa principal el que tenga la responsabilidad de recoger esto.

419
00:26:44,000 --> 00:26:47,000
Por interfaz gráfica, por consola, como le dé la gana.

420
00:26:48,000 --> 00:26:51,000
El programa principal que decida como lo recoge.

421
00:26:51,000 --> 00:26:54,000
Se lo pasamos al constructor y el constructor ya lo utiliza.

422
00:27:00,000 --> 00:27:05,000
Porque iros quedando con el concepto de desacoplamiento.

423
00:27:05,000 --> 00:27:08,000
Que es una de las cosas que perseguimos en programación.

424
00:27:08,000 --> 00:27:15,000
Que es que las modificaciones de una clase me afecten lo menos posible a otra.

425
00:27:15,000 --> 00:27:19,000
Hay que hacer aplicaciones lo más desacopladas posibles.

426
00:27:19,000 --> 00:27:23,000
Hay que hacer clases lo más desacopladas posibles.

427
00:27:23,000 --> 00:27:29,000
Entonces, este constructor no sigue el principio de desacoplamiento.

428
00:27:29,000 --> 00:27:30,000
¿Por qué?

429
00:27:30,000 --> 00:27:35,000
Porque si de repente el resto de mis clases cambian y empiezan a utilizar interfaces gráficas.

430
00:27:35,000 --> 00:27:41,000
Me tengo que venir yo a esta clase también y tocarle y decirle consola afuera.

431
00:27:42,000 --> 00:27:45,000
Tengo que meter aquí, coger por interfaz gráfica, ya veremos cómo.

432
00:27:45,000 --> 00:27:48,000
Está muy poco desacoplada.

433
00:27:48,000 --> 00:27:52,000
Si cambio a interfaz gráfica tengo que meterme en esta también.

434
00:27:52,000 --> 00:27:55,000
Este constructor muy mal pensado.

435
00:27:57,000 --> 00:27:59,000
Este muy bien pensado.

436
00:27:59,000 --> 00:28:04,000
Porque que las clases de mi aplicación, las otras cambian y empiezan a trabajar por interfaz gráfica.

437
00:28:04,000 --> 00:28:05,000
A este se le apela.

438
00:28:05,000 --> 00:28:07,000
Dice, me da igual, tú pásame los valores.

439
00:28:07,000 --> 00:28:09,000
Me da igual cómo los hayas recogido.

440
00:28:09,000 --> 00:28:11,000
Yo los voy a coger y se los voy a dar a las propiedades.

441
00:28:11,000 --> 00:28:13,000
Con lo cual, esa clase no hay que tocarla.

442
00:28:13,000 --> 00:28:16,000
Esa clase está desacoplada de las demás.

443
00:28:17,000 --> 00:28:22,000
Entonces, las aplicaciones, una misma aplicación se puede hacer de muchas maneras.

444
00:28:22,000 --> 00:28:25,000
Se puede hacer, admite muchos diseños.

445
00:28:25,000 --> 00:28:28,000
Algunos serán buenos, otros malos y otros peores.

446
00:28:28,000 --> 00:28:32,000
Y solo si hace uno los buenos, pues conserva el trabajo.

447
00:28:33,000 --> 00:28:37,000
No se trata de hacer los que funcionen, sino los que están bien diseñados.

448
00:28:37,000 --> 00:28:42,000
Pues la idea es que las clases estén lo más desacopladas posibles.

449
00:28:43,000 --> 00:28:48,000
Si yo tengo que tocar algo, por favor, eso no implique tener que tocar las demás.

450
00:28:49,000 --> 00:28:52,000
Pues ese es el principio de este constructor.

451
00:28:53,000 --> 00:28:57,000
Bueno, pues importante que os vayáis quedando con todo esto que os digo.

452
00:28:58,000 --> 00:29:01,000
Bueno, pues estamos solo con los constructores por ahora.

453
00:29:02,000 --> 00:29:03,000
Vale, ya está.

454
00:29:03,000 --> 00:29:05,000
¿Alguna duda, pregunta?

455
00:29:07,000 --> 00:29:09,000
Venga, pues seguimos con la clase cafetera.

456
00:29:09,000 --> 00:29:10,000
¿Qué más hay que hacer?

457
00:29:10,000 --> 00:29:11,000
Hemos hecho propiedades.

458
00:29:11,000 --> 00:29:13,000
Hemos hecho constructores.

459
00:29:13,000 --> 00:29:16,000
Estos dos, un poquito pues para explicar todo este rollo.

460
00:29:16,000 --> 00:29:18,000
Hemos hecho estos dos.

461
00:29:19,000 --> 00:29:21,000
Y ahora habrá que hacer métodos.

462
00:29:23,000 --> 00:29:28,000
De nuevo, en un caso real, uno estaría analizando la aplicación y diría,

463
00:29:28,000 --> 00:29:32,000
a ver, el software de mi cafetera necesita llenar, vaciar,

464
00:29:32,000 --> 00:29:34,000
pues yo voy a hacer métodos para todo esto.

465
00:29:34,000 --> 00:29:38,000
Esa parte de análisis ya me la tienen hecha y ya me dicen directamente

466
00:29:38,000 --> 00:29:40,000
los métodos que tengo que programar.

467
00:29:40,000 --> 00:29:44,000
Como ya me los dicen, pues ya nos metemos directamente a programar esos métodos.

468
00:29:45,000 --> 00:29:51,000
Y me dicen que son, este método, este método llenar cafetera,

469
00:29:51,000 --> 00:29:54,000
es el método que se va a invocar cuando le demos al botoncito

470
00:29:54,000 --> 00:29:57,000
de llenar de esa cafetera que tiene ese software dentro.

471
00:29:57,000 --> 00:29:59,000
¿Y este método qué hace?

472
00:30:00,000 --> 00:30:04,000
Pues hace que la cantidad actual de la cafetera se ponga igual

473
00:30:04,000 --> 00:30:06,000
que la capacidad máxima.

474
00:30:06,000 --> 00:30:09,000
Eso es lo que hace llenar, hacer que la cantidad actual

475
00:30:09,000 --> 00:30:11,000
se ponga igual que la capacidad.

476
00:30:11,000 --> 00:30:15,000
Entonces ese método será el que se incorpora cuando le demos al botoncito

477
00:30:15,000 --> 00:30:19,000
y claro, ese software estará conectado a unos sensores,

478
00:30:19,000 --> 00:30:21,000
pues para abrir el compartimiento del café o lo que sea,

479
00:30:21,000 --> 00:30:25,000
pero esa parte ya mecánica de los sensores o electrónica no es nada más igual.

480
00:30:25,000 --> 00:30:28,000
Venga, vamos a hacer ese método, el método llenar cafetera.

481
00:30:28,000 --> 00:30:33,000
Lo primero el nombre, en este caso no hay que elegirlo

482
00:30:33,000 --> 00:30:39,000
porque ya nos lo han elegido el nombre, pues no hay nada que elegir.

483
00:30:39,000 --> 00:30:42,000
Pero lo demás ya sí que hay que programarlo, ¿qué es?

484
00:30:42,000 --> 00:30:47,000
Primero, para hacer lo que ese método tiene que hacer,

485
00:30:47,000 --> 00:30:51,000
necesito pasarle alguna información desde fuera,

486
00:30:51,000 --> 00:30:55,000
es decir, aquí en las interrogaciones tengo que poner algo,

487
00:30:56,000 --> 00:31:00,000
pues vamos a ver, ¿qué tiene que hacer ese método?

488
00:31:00,000 --> 00:31:06,000
Ese método tiene que hacer que la propiedad cantidad actual

489
00:31:06,000 --> 00:31:10,000
se ponga con el valor que tiene la propiedad capacidad máxima,

490
00:31:10,000 --> 00:31:12,000
es lo que tiene que hacer, poner la cantidad actual

491
00:31:12,000 --> 00:31:16,000
al valor que tenga la capacidad máxima, eso es llenar.

492
00:31:16,000 --> 00:31:19,000
Si la capacidad es 100 y la cantidad es 50,

493
00:31:19,000 --> 00:31:23,000
llenar es poner ese 50 a 100, eso es llenar.

494
00:31:23,000 --> 00:31:26,000
Bueno, ¡silencio!

495
00:31:26,000 --> 00:31:30,000
María, vale, pues entonces, ahora ya repito la pregunta,

496
00:31:30,000 --> 00:31:34,000
entendiendo lo que significa ese método, lo que tiene que hacer,

497
00:31:34,000 --> 00:31:38,000
¿necesitamos pasar alguna información desde fuera

498
00:31:38,000 --> 00:31:41,000
para que el método pueda hacer eso?

499
00:31:45,000 --> 00:31:46,000
¿Sí o no?

500
00:31:46,000 --> 00:31:49,000
No, porque el método solo trabaja con las propiedades,

501
00:31:49,000 --> 00:31:52,000
pone ésta con el valor que tenga ésta

502
00:31:52,000 --> 00:31:55,000
y las propiedades ya tiene acceso directo a ellas,

503
00:31:55,000 --> 00:31:58,000
no hay que pasarle ninguna información.

504
00:31:58,000 --> 00:32:02,000
Bueno, pues entonces solo trabaja con las propiedades del objeto,

505
00:32:02,000 --> 00:32:05,000
no trabaja con nada externo, solo con las propiedades,

506
00:32:05,000 --> 00:32:08,000
luego esto vacío porque solo trabaja con las propiedades.

507
00:32:08,000 --> 00:32:11,000
Vale, ¿y qué es lo que tiene que hacer?

508
00:32:11,000 --> 00:32:17,000
Hemos dicho que lo que tiene que hacer es poner la capacidad actual

509
00:32:18,000 --> 00:32:21,000
con el mismo valor que tenga, no, cantidad actual,

510
00:32:24,000 --> 00:32:29,000
cantidad actual con el mismo valor que tenga la capacidad máxima,

511
00:32:29,000 --> 00:32:32,000
eso es lo que tiene que hacer el método,

512
00:32:32,000 --> 00:32:36,000
poner esta propiedad con el mismo valor que tenga ésta,

513
00:32:36,000 --> 00:32:40,000
para que se llene, si tenía 50 se llena a 100,

514
00:32:40,000 --> 00:32:42,000
que es la capacidad máxima o lo que sea.

515
00:32:42,000 --> 00:32:46,000
Ahora la siguiente pregunta para completar la declaración del método es,

516
00:32:47,000 --> 00:32:51,000
¿necesita el método devolver algo al exterior?

517
00:32:53,000 --> 00:32:55,000
¿Sí o no?

518
00:32:57,000 --> 00:33:01,000
No, porque el efecto del método queda reflejado ya en las propiedades,

519
00:33:01,000 --> 00:33:05,000
entonces cuando el método lo único que hace es tocar las propiedades,

520
00:33:05,000 --> 00:33:08,000
ya las propiedades ya se quedan tocadas o modificadas,

521
00:33:08,000 --> 00:33:11,000
ya se quedan tocadas, no hay que sacar nada hacia afuera,

522
00:33:11,000 --> 00:33:14,000
porque ya el método ha tocado las propiedades

523
00:33:14,000 --> 00:33:17,000
y ya se quedan ahí esas propiedades modificadas,

524
00:33:17,000 --> 00:33:20,000
no devuelve ningún valor hacia afuera,

525
00:33:20,000 --> 00:33:22,000
luego ponemos aquí void,

526
00:33:25,000 --> 00:33:27,000
vale y este método está,

527
00:33:28,000 --> 00:33:30,000
¿es necesario poner ahí el dis?

528
00:33:30,000 --> 00:33:34,000
Pues no es necesario porque no hay más variables que se llamen así

529
00:33:34,000 --> 00:33:37,000
aparte de las propiedades, no es necesario,

530
00:33:37,000 --> 00:33:41,000
que lo quiero poner porque queda mucho más bonito

531
00:33:42,000 --> 00:33:47,000
y me gusta más, pues lo pongo porque no molesta,

532
00:33:47,000 --> 00:33:49,000
pero en este caso es opcional,

533
00:33:49,000 --> 00:33:51,000
¿vale? en este caso es opcional,

534
00:33:51,000 --> 00:33:54,000
porque no hay más variables que se llamen en cantidad actual.

535
00:33:55,000 --> 00:33:58,000
Bueno, pues el método de llenar cafetera ya está,

536
00:33:58,000 --> 00:34:01,000
más métodos que hay que programar

537
00:34:03,000 --> 00:34:05,000
para ese software de esa cafetera,

538
00:34:05,000 --> 00:34:09,000
¿qué más tenemos que hacer a través de los botoncitos de esa cafetera?

539
00:34:10,000 --> 00:34:11,000
Servir una taza,

540
00:34:12,000 --> 00:34:14,000
vale, pues servir una taza es,

541
00:34:14,000 --> 00:34:16,000
cuando le damos a ese botoncito,

542
00:34:17,000 --> 00:34:22,000
el compartimento del café se vaciará

543
00:34:23,000 --> 00:34:28,000
con la cantidad que tenga, que ocupe la taza,

544
00:34:28,000 --> 00:34:30,000
si yo le paso una taza de 100 mililitros,

545
00:34:31,000 --> 00:34:36,000
pues la cantidad actual de café tendrá que bajar 100 mililitros,

546
00:34:36,000 --> 00:34:38,000
si le paso una taza de 50,

547
00:34:38,000 --> 00:34:41,000
la cantidad de café bajará en 50,

548
00:34:41,000 --> 00:34:42,000
eso es servir taza, ¿no?

549
00:34:44,000 --> 00:34:46,000
Eso es lo que hace el botoncito cuando le damos,

550
00:34:48,000 --> 00:34:49,000
¿vale?

551
00:34:50,000 --> 00:34:54,000
Si la cantidad actual que tiene es más pequeñita

552
00:34:55,000 --> 00:34:57,000
que la cantidad que yo,

553
00:34:58,000 --> 00:35:00,000
si tiene 50 y le paso una taza de 100,

554
00:35:00,000 --> 00:35:02,000
pues dice, vale, pues sirven los 50,

555
00:35:02,000 --> 00:35:04,000
ya está y te quedas a cero, sirven los 50.

556
00:35:05,000 --> 00:35:06,000
Bueno, pues entonces,

557
00:35:07,000 --> 00:35:09,000
he entendido lo que hace el método, ¿no?

558
00:35:09,000 --> 00:35:11,000
Tendrá que disminuir la cantidad actual,

559
00:35:11,000 --> 00:35:16,000
la tendrá que disminuir en un volumen igual al de la taza que yo le paso,

560
00:35:17,000 --> 00:35:19,000
tendrá que disminuir un volumen igual al de la taza que yo le paso,

561
00:35:19,000 --> 00:35:20,000
porque estoy sirviendo esa taza,

562
00:35:21,000 --> 00:35:22,000
que se queda cero,

563
00:35:23,000 --> 00:35:25,000
antes de completar la taza, pues se queda cero,

564
00:35:25,000 --> 00:35:26,000
no puede servir más, obviamente.

565
00:35:27,000 --> 00:35:29,000
Bueno, pues entonces, programando ese método,

566
00:35:30,000 --> 00:35:31,000
de nuevo el nombre,

567
00:35:32,000 --> 00:35:33,000
no tenemos opción de elegirlo,

568
00:35:34,000 --> 00:35:36,000
porque ya está elegido.

569
00:35:39,000 --> 00:35:41,000
Vale, pues la primera pregunta,

570
00:35:42,000 --> 00:35:45,000
después del nombre, es esta, siempre, es,

571
00:35:46,000 --> 00:35:47,000
a ver,

572
00:35:48,000 --> 00:35:50,000
para poder hacer lo que tiene que hacer el método,

573
00:35:50,000 --> 00:35:52,000
que es disminuir la cantidad actual

574
00:35:54,000 --> 00:35:59,000
de la cafetera en el volumen de la taza,

575
00:35:59,000 --> 00:36:02,000
¿necesito pasarle alguna información a ese método desde fuera?

576
00:36:03,000 --> 00:36:05,000
Sí, ¿qué tenemos que pasarle?

577
00:36:06,000 --> 00:36:08,000
El volumen de la taza, claro, porque servirá más o menos,

578
00:36:09,000 --> 00:36:11,000
bajará más o menos en función del volumen de la taza,

579
00:36:12,000 --> 00:36:13,000
pues aquí hay que pasárselo,

580
00:36:17,000 --> 00:36:18,000
hay que pasárselo sí o sí.

581
00:36:19,000 --> 00:36:21,000
Vale, y ahora ya con eso, ya sabemos lo que hace,

582
00:36:22,000 --> 00:36:23,000
porque lo que hará será,

583
00:36:24,000 --> 00:36:27,000
capacidad actual,

584
00:36:29,000 --> 00:36:30,000
menos igual,

585
00:36:34,000 --> 00:36:35,000
volumen taza, ¿no?

586
00:36:36,000 --> 00:36:40,000
Es decir, restará a la cantidad, no capacidad,

587
00:36:46,000 --> 00:36:48,000
restará a la cantidad actual,

588
00:36:49,000 --> 00:36:50,000
el volumen de la taza que yo le paso,

589
00:36:50,000 --> 00:36:51,000
lo resta,

590
00:36:52,000 --> 00:36:53,000
y la cantidad que se queda,

591
00:36:54,000 --> 00:36:55,000
pues es el resultado de la resta,

592
00:36:56,000 --> 00:36:57,000
esto es lo que hará, ¿no?

593
00:36:57,000 --> 00:36:58,000
Esta es la idea.

594
00:37:01,000 --> 00:37:04,000
Ahora sí, hay un matiz ahí que hay que completar, ¿no?

595
00:37:05,000 --> 00:37:06,000
¿Qué dice el enunciado?

596
00:37:12,000 --> 00:37:13,000
Esto, yo no lo he contemplado,

597
00:37:14,000 --> 00:37:16,000
es decir, si la cantidad actual es 5

598
00:37:17,000 --> 00:37:18,000
y le doy una taza de 100,

599
00:37:18,000 --> 00:37:20,000
el resultado de ese método me dejaría

600
00:37:21,000 --> 00:37:22,000
en cantidad actual, menos 95.

601
00:37:27,000 --> 00:37:29,000
Entonces, esto no es exactamente así,

602
00:37:30,000 --> 00:37:31,000
esto será así,

603
00:37:32,000 --> 00:37:34,000
si esto es mayor o igual que cero,

604
00:37:35,000 --> 00:37:37,000
si es menor que cero, tendría que ser cero, ¿verdad?

605
00:37:39,000 --> 00:37:40,000
Entonces, esto ahora ya uno lo programa como quiera,

606
00:37:41,000 --> 00:37:43,000
con un IF, con una, como quiera,

607
00:37:44,000 --> 00:37:45,000
por ejemplo,

608
00:37:46,000 --> 00:37:49,000
podemos poner cantidad actual,

609
00:37:51,000 --> 00:37:52,000
pues cantidad actual,

610
00:37:53,000 --> 00:37:54,000
depende,

611
00:37:56,000 --> 00:37:57,000
su valor final va a depender

612
00:37:58,000 --> 00:37:59,000
de si cantidad actual es mayor o igual

613
00:38:00,000 --> 00:38:01,000
que volumen taza o no,

614
00:38:02,000 --> 00:38:03,000
depende,

615
00:38:03,000 --> 00:38:04,000
bueno, pues esa es la asignación

616
00:38:05,000 --> 00:38:06,000
condicionada de toda la vida,

617
00:38:07,000 --> 00:38:08,000
cantidad actual es mayor

618
00:38:11,000 --> 00:38:12,000
que volumen taza,

619
00:38:16,000 --> 00:38:17,000
es mayor que volumen taza,

620
00:38:18,000 --> 00:38:19,000
si es mayor,

621
00:38:20,000 --> 00:38:21,000
pues entonces la cantidad actual será,

622
00:38:22,000 --> 00:38:23,000
lo pongo aquí abajo para que se vea,

623
00:38:24,000 --> 00:38:25,000
será cantidad actual,

624
00:38:27,000 --> 00:38:28,000
menos volumen taza,

625
00:38:31,000 --> 00:38:32,000
que no lo es,

626
00:38:33,000 --> 00:38:34,000
pues será cero,

627
00:38:35,000 --> 00:38:36,000
vale, ahora ya sí,

628
00:38:37,000 --> 00:38:38,000
ahora ya sí esto refleja

629
00:38:39,000 --> 00:38:40,000
lo que me dice el enunciado,

630
00:38:42,000 --> 00:38:43,000
que la cantidad es mayor

631
00:38:43,000 --> 00:38:44,000
que el volumen que tengo que llenar,

632
00:38:46,000 --> 00:38:47,000
pues la cantidad se queda

633
00:38:48,000 --> 00:38:49,000
como la que tenía,

634
00:38:49,000 --> 00:38:50,000
menos el volumen que he llenado,

635
00:38:51,000 --> 00:38:52,000
que no es mayor,

636
00:38:52,000 --> 00:38:53,000
porque es más pequeña o igual,

637
00:38:53,000 --> 00:38:54,000
se queda cero,

638
00:38:54,000 --> 00:38:55,000
sirve toda la que hay

639
00:38:55,000 --> 00:38:56,000
y se queda cero,

640
00:38:57,000 --> 00:38:58,000
no se queda en negativo,

641
00:38:58,000 --> 00:38:59,000
porque eso no existe,

642
00:38:59,000 --> 00:39:00,000
se queda cero,

643
00:39:01,000 --> 00:39:02,000
vale, pues esto ya recoge

644
00:39:02,000 --> 00:39:03,000
lo que me dice,

645
00:39:04,000 --> 00:39:05,000
y ahora ya la siguiente pregunta,

646
00:39:06,000 --> 00:39:07,000
de nuevo es lo mismo que antes,

647
00:39:08,000 --> 00:39:09,000
¿tiene que devolver algo

648
00:39:09,000 --> 00:39:10,000
como valor de retorno,

649
00:39:10,000 --> 00:39:11,000
este método?

650
00:39:12,000 --> 00:39:13,000
¿Sí o no?

651
00:39:13,000 --> 00:39:14,000
No, porque el efecto del método

652
00:39:16,000 --> 00:39:17,000
se queda en la propiedad,

653
00:39:17,000 --> 00:39:18,000
el efecto del método

654
00:39:18,000 --> 00:39:19,000
es bajar esa propiedad,

655
00:39:20,000 --> 00:39:21,000
que es una propiedad de la clase,

656
00:39:22,000 --> 00:39:23,000
el efecto del método

657
00:39:23,000 --> 00:39:24,000
ya está ahí en esta propiedad,

658
00:39:24,000 --> 00:39:25,000
no tiene que devolver nada,

659
00:39:27,000 --> 00:39:28,000
pues entonces ahí

660
00:39:29,000 --> 00:39:30,000
pongo otro void,

661
00:39:33,000 --> 00:39:34,000
ala, ya tenemos el otro método,

662
00:39:41,000 --> 00:39:42,000
más métodos,

663
00:39:42,000 --> 00:39:43,000
vaciar,

664
00:39:43,000 --> 00:39:44,000
poner la cantidad de café

665
00:39:44,000 --> 00:39:45,000
a cero,

666
00:39:45,000 --> 00:39:46,000
este es fácil de hacer,

667
00:39:46,000 --> 00:39:47,000
y agregar,

668
00:39:48,000 --> 00:39:49,000
añadir la cantidad de café

669
00:39:50,000 --> 00:39:51,000
pasada como parámetro,

670
00:39:51,000 --> 00:39:52,000
aquí habría que añadir,

671
00:39:53,000 --> 00:39:54,000
si paso más

672
00:39:55,000 --> 00:39:56,000
que la capacidad máxima,

673
00:39:57,000 --> 00:39:58,000
pues la dejo en capacidad máxima,

674
00:40:02,000 --> 00:40:03,000
venga, pues vaciar cafetera

675
00:40:04,000 --> 00:40:05,000
lo podemos hacer rápidamente,

676
00:40:08,000 --> 00:40:09,000
no hay ya ni que pensar,

677
00:40:11,000 --> 00:40:12,000
cafetera,

678
00:40:14,000 --> 00:40:15,000
este,

679
00:40:16,000 --> 00:40:17,000
no necesita ningún parámetro

680
00:40:18,000 --> 00:40:19,000
y lo que hace va

681
00:40:20,000 --> 00:40:21,000
es ponerla a cero,

682
00:40:23,000 --> 00:40:24,000
este no tiene nada,

683
00:40:25,000 --> 00:40:26,000
que perra me ha dado con la

684
00:40:27,000 --> 00:40:28,000
cantidad,

685
00:40:28,000 --> 00:40:29,000
vale,

686
00:40:30,000 --> 00:40:31,000
este tiene poco que pensar,

687
00:40:31,000 --> 00:40:32,000
ponerla a cero,

688
00:40:32,000 --> 00:40:33,000
no necesita ningún parámetro,

689
00:40:34,000 --> 00:40:35,000
y ahora la otra que era

690
00:40:39,000 --> 00:40:40,000
agregar café

691
00:40:42,000 --> 00:40:43,000
a cero,

692
00:40:47,000 --> 00:40:48,000
este si necesita

693
00:40:49,000 --> 00:40:50,000
un parámetro de fuera,

694
00:40:51,000 --> 00:40:52,000
porque este es,

695
00:40:52,000 --> 00:40:53,000
vamos a ver,

696
00:40:54,000 --> 00:40:55,000
¿cuánto café

697
00:40:56,000 --> 00:40:57,000
vas a aumentar la cantidad actual?

698
00:40:58,000 --> 00:40:59,000
¿cuánto lo vas a aumentar?

699
00:40:59,000 --> 00:41:00,000
dime cuánto,

700
00:41:00,000 --> 00:41:01,000
para que yo sepa

701
00:41:01,000 --> 00:41:02,000
cuánto tengo que aumentarla,

702
00:41:02,000 --> 00:41:03,000
dime cuánto,

703
00:41:03,000 --> 00:41:04,000
eso hay que pasárselo desde fuera,

704
00:41:04,000 --> 00:41:05,000
es como servir tazas,

705
00:41:05,000 --> 00:41:06,000
dime cuánto quieres que te dé,

706
00:41:07,000 --> 00:41:08,000
tendrás que decírmelo

707
00:41:08,000 --> 00:41:09,000
para saber yo cuánto te doy,

708
00:41:09,000 --> 00:41:10,000
pues este igual,

709
00:41:10,000 --> 00:41:11,000
dime cuánto quieres meter,

710
00:41:12,000 --> 00:41:13,000
pues habrá que pasarle

711
00:41:14,000 --> 00:41:15,000
ese parámetro,

712
00:41:15,000 --> 00:41:16,000
esa cantidad,

713
00:41:20,000 --> 00:41:21,000
y ahora uno podría hacer así,

714
00:41:22,000 --> 00:41:23,000
cantidad

715
00:41:25,000 --> 00:41:26,000
actual

716
00:41:26,000 --> 00:41:27,000
más igual

717
00:41:28,000 --> 00:41:29,000
cantidad,

718
00:41:31,000 --> 00:41:32,000
vale,

719
00:41:32,000 --> 00:41:33,000
pero pasaría lo de siempre,

720
00:41:34,000 --> 00:41:35,000
que,

721
00:41:35,000 --> 00:41:36,000
cuidado,

722
00:41:36,000 --> 00:41:37,000
si la cantidad resultante

723
00:41:38,000 --> 00:41:39,000
después de hacer la suma

724
00:41:39,000 --> 00:41:40,000
es mayor que capacidad máxima,

725
00:41:41,000 --> 00:41:42,000
es mayor,

726
00:41:42,000 --> 00:41:43,000
entonces

727
00:41:43,000 --> 00:41:44,000
cantidad actual

728
00:41:44,000 --> 00:41:45,000
que sea la capacidad máxima,

729
00:41:45,000 --> 00:41:46,000
el resto ha rebosado,

730
00:41:46,000 --> 00:41:47,000
obviamente,

731
00:41:47,000 --> 00:41:48,000
el resto ha rebosado,

732
00:41:49,000 --> 00:41:50,000
entonces, hombre,

733
00:41:50,000 --> 00:41:51,000
para tener eso en cuenta,

734
00:41:51,000 --> 00:41:52,000
pues cambiémoslo

735
00:41:52,000 --> 00:41:53,000
con una asignación condicionada,

736
00:41:54,000 --> 00:41:55,000
porque lo que asigno

737
00:41:55,000 --> 00:41:56,000
a cantidad actual

738
00:41:56,000 --> 00:41:57,000
va a depender

739
00:41:57,000 --> 00:41:58,000
de si

740
00:41:58,000 --> 00:41:59,000
cantidad

741
00:42:01,000 --> 00:42:02,000
actual

742
00:42:02,000 --> 00:42:03,000
más

743
00:42:03,000 --> 00:42:04,000
la cantidad

744
00:42:04,000 --> 00:42:05,000
es mayor

745
00:42:05,000 --> 00:42:06,000
que la capacidad máxima,

746
00:42:07,000 --> 00:42:08,000
va a depender

747
00:42:08,000 --> 00:42:09,000
de esta condición,

748
00:42:09,000 --> 00:42:10,000
va a depender

749
00:42:10,000 --> 00:42:11,000
de esta condición,

750
00:42:13,000 --> 00:42:14,000
si

751
00:42:14,000 --> 00:42:15,000
la cantidad actual

752
00:42:15,000 --> 00:42:16,000
más la cantidad

753
00:42:16,000 --> 00:42:17,000
nueva

754
00:42:17,000 --> 00:42:18,000
es mayor

755
00:42:18,000 --> 00:42:19,000
que la capacidad máxima,

756
00:42:20,000 --> 00:42:21,000
entonces,

757
00:42:23,000 --> 00:42:24,000
cuál va a ser

758
00:42:24,000 --> 00:42:25,000
la cantidad actual,

759
00:42:25,000 --> 00:42:26,000
la capacidad máxima,

760
00:42:27,000 --> 00:42:28,000
porque el resto

761
00:42:28,000 --> 00:42:29,000
habrá rebosado,

762
00:42:29,000 --> 00:42:30,000
que no,

763
00:42:30,000 --> 00:42:31,000
pues entonces

764
00:42:31,000 --> 00:42:32,000
ahora ya sí,

765
00:42:32,000 --> 00:42:33,000
que no es mayor,

766
00:42:33,000 --> 00:42:34,000
pues entonces

767
00:42:34,000 --> 00:42:35,000
ahora

768
00:42:35,000 --> 00:42:36,000
será esto,

769
00:42:45,000 --> 00:42:46,000
y ya tenemos

770
00:42:46,000 --> 00:42:47,000
todos los métodos,

771
00:42:48,000 --> 00:42:49,000
cada uno de ellos

772
00:42:49,000 --> 00:42:50,000
es un sensor

773
00:42:51,000 --> 00:42:52,000
que cuando se da,

774
00:42:52,000 --> 00:42:53,000
pues llama

775
00:42:53,000 --> 00:42:54,000
el método

776
00:42:54,000 --> 00:42:55,000
de ese software,

777
00:42:55,000 --> 00:42:56,000
ese software

778
00:42:56,000 --> 00:42:57,000
que cambia las propiedades

779
00:42:58,000 --> 00:42:59,000
y cambiar

780
00:42:59,000 --> 00:43:00,000
las propiedades

781
00:43:00,000 --> 00:43:01,000
ya estará conectado

782
00:43:02,000 --> 00:43:03,000
a unos sensores

783
00:43:03,000 --> 00:43:04,000
electrónicos

784
00:43:04,000 --> 00:43:05,000
para abrir y cerrar

785
00:43:05,000 --> 00:43:06,000
por las puertas

786
00:43:06,000 --> 00:43:07,000
del café,

787
00:43:07,000 --> 00:43:08,000
pero esa parte

788
00:43:08,000 --> 00:43:09,000
ya de los sensores

789
00:43:09,000 --> 00:43:10,000
electrónicos

790
00:43:10,000 --> 00:43:11,000
ya nos da igual,

791
00:43:11,000 --> 00:43:12,000
lo que hacemos

792
00:43:12,000 --> 00:43:13,000
entonces es la parte

793
00:43:13,000 --> 00:43:14,000
del software

794
00:43:14,000 --> 00:43:15,000
de la cafetera,

795
00:43:15,000 --> 00:43:16,000
que lo que hace

796
00:43:16,000 --> 00:43:17,000
es cambiar

797
00:43:17,000 --> 00:43:18,000
las propiedades,

798
00:43:18,000 --> 00:43:19,000
luego ya otra

799
00:43:19,000 --> 00:43:20,000
la parte

800
00:43:20,000 --> 00:43:21,000
electrónica

801
00:43:21,000 --> 00:43:22,000
que es

802
00:43:22,000 --> 00:43:23,000
cuando esas propiedades

803
00:43:23,000 --> 00:43:24,000
cambien

804
00:43:24,000 --> 00:43:25,000
como resultado

805
00:43:25,000 --> 00:43:26,000
de la ejecución

806
00:43:26,000 --> 00:43:27,000
de esos métodos,

807
00:43:27,000 --> 00:43:28,000
cuando cambien

808
00:43:28,000 --> 00:43:29,000
esos sensores

809
00:43:29,000 --> 00:43:30,000
se activarán

810
00:43:30,000 --> 00:43:31,000
para abrir

811
00:43:31,000 --> 00:43:32,000
y cerrar

812
00:43:32,000 --> 00:43:33,000
la entrada

813
00:43:33,000 --> 00:43:34,000
la clase esta

814
00:43:34,000 --> 00:43:35,000
ya está completa,

815
00:43:36,000 --> 00:43:37,000
vale,

816
00:43:37,000 --> 00:43:38,000
tiene este constructor

817
00:43:38,000 --> 00:43:39,000
un poco

818
00:43:39,000 --> 00:43:40,000
bana,

819
00:43:40,000 --> 00:43:41,000
este

820
00:43:41,000 --> 00:43:42,000
más interesante

821
00:43:42,000 --> 00:43:43,000
y los cuatro

822
00:43:43,000 --> 00:43:44,000
métodos

823
00:43:44,000 --> 00:43:45,000
y las propiedades,

824
00:43:48,000 --> 00:43:49,000
vale,

825
00:43:49,000 --> 00:43:50,000
alguna duda

826
00:43:50,000 --> 00:43:51,000
sobre esta clase,

827
00:43:51,000 --> 00:43:52,000
entonces como este software

828
00:43:52,000 --> 00:43:53,000
solo trabaja

829
00:43:53,000 --> 00:43:54,000
con la entidad cafetera

830
00:43:54,000 --> 00:43:55,000
ya no le hace falta

831
00:43:55,000 --> 00:43:56,000
más clases,

832
00:43:56,000 --> 00:43:57,000
ahora ya la principal,

833
00:43:57,000 --> 00:43:58,000
la principal

834
00:43:58,000 --> 00:43:59,000
que es la que

835
00:43:59,000 --> 00:44:00,000
se ejecuta

836
00:44:00,000 --> 00:44:01,000
y la que instancia

837
00:44:01,000 --> 00:44:02,000
la cafetera,

838
00:44:02,000 --> 00:44:03,000
vale,

839
00:44:03,000 --> 00:44:04,000
vamos a parar aquí

840
00:44:04,000 --> 00:44:05,000
un momentín.