1
00:00:02,419 --> 00:00:08,800
¿Alguna preguntilla tenéis preparada para hacerme antes de arrancar a contar cosas nuevas?

2
00:00:10,060 --> 00:00:16,859
Si tenéis alguna duda por ahí del tema 7, que es el que tenemos abierto o de alguno anterior,

3
00:00:22,399 --> 00:00:29,640
bueno, si no me decís nada, pues había pensado hoy, como solemos hacer, en resolver,

4
00:00:29,640 --> 00:00:34,539
ya que la semana pasada no pudimos la tarea del tema 6, lo hacemos un poquillo rápido

5
00:00:34,539 --> 00:00:38,320
y luego bueno pues hacemos alguna otra cosita por ahí adicional

6
00:00:38,320 --> 00:00:42,619
tema 7 no tengo ahora mismo no me acuerdo exactamente en qué momento termina

7
00:00:42,619 --> 00:00:47,780
a ver si termina el día 3 todavía nos quedan unas cuantas semanas

8
00:00:47,780 --> 00:00:52,060
para luego hablar de algunas cosas del tema 7

9
00:00:52,060 --> 00:00:57,759
dedicar alguna tutoría entonces hoy trabajamos ya os digo sobre la tarea del tema 6

10
00:00:57,759 --> 00:01:02,140
y alguna otra cosita por ahí que hablemos y la semana que viene

11
00:01:02,140 --> 00:01:04,599
la dedicamos a hacer repaso

12
00:01:04,599 --> 00:01:06,219
de los conceptos que hay en el tema 7

13
00:01:06,219 --> 00:01:08,400
y así con una semanita más

14
00:01:08,400 --> 00:01:10,579
pues tenéis oportunidad de echar un ojo

15
00:01:10,579 --> 00:01:11,400
a los contenidos

16
00:01:11,400 --> 00:01:13,680
me escucháis bien verdad

17
00:01:13,680 --> 00:01:15,799
luego confirmarme por ahí

18
00:01:15,799 --> 00:01:17,760
si vale

19
00:01:17,760 --> 00:01:19,439
perfecto

20
00:01:19,439 --> 00:01:22,519
bueno pues nada la práctica

21
00:01:22,519 --> 00:01:24,280
esta de la tarea de la cocina

22
00:01:24,280 --> 00:01:25,760
tenéis ya como siempre

23
00:01:25,760 --> 00:01:28,659
una solución

24
00:01:28,659 --> 00:01:30,540
puesta en el aula

25
00:01:30,540 --> 00:01:31,579
virtual disponible

26
00:01:31,579 --> 00:01:35,640
y vamos un poco despacito como solemos hacer

27
00:01:35,640 --> 00:01:38,260
repasando los conceptos a hacer el ejercicio.

28
00:01:39,700 --> 00:01:43,640
Básicamente es una segunda versión

29
00:01:43,640 --> 00:01:47,099
de precisamente este ejercicio que hicimos ya en su momento

30
00:01:47,099 --> 00:01:51,560
antes de haber trabajado con Arrays y aquí básicamente lo que aporta

31
00:01:51,560 --> 00:01:55,459
es un poquito el trabajar eso con Arrays porque a la hora de

32
00:01:55,459 --> 00:01:58,739
estamos considerando una única cocina en el ejercicio

33
00:01:58,739 --> 00:02:02,760
pero estamos teniendo en cuenta que esa cocina podría tener

34
00:02:02,760 --> 00:02:06,099
una serie de frigoríficos y una serie de placas

35
00:02:06,099 --> 00:02:10,360
cuando en el ejercicio anterior decíamos que

36
00:02:10,360 --> 00:02:14,300
teníamos la posibilidad de que hubiera un único frigorífico y una única placa

37
00:02:14,300 --> 00:02:19,159
en este caso una cocina podría disponer de cero o varios frigoríficos

38
00:02:19,159 --> 00:02:22,800
y de cero o varias placas, es un poco lo que nos aporta

39
00:02:22,800 --> 00:02:26,759
de nuevo, entonces el método este que proponemos

40
00:02:26,759 --> 00:02:30,639
para la clase cocina, lo que hace es que una vez recogida

41
00:02:30,639 --> 00:02:34,539
la información de nombre de la cocina, los frigoríficos

42
00:02:34,539 --> 00:02:37,759
y placas que puedan existir, pues nos saca

43
00:02:37,759 --> 00:02:42,120
un mensajito informándonos de si hay cocinas

44
00:02:42,120 --> 00:02:45,159
de qué marcas son y si hay placas de qué colores.

45
00:02:47,039 --> 00:02:49,259
Vamos a ponernos manos a la obra.

46
00:02:50,919 --> 00:02:57,090
Entonces vamos a crear un proyecto que podemos llamar

47
00:02:57,090 --> 00:03:08,650
cocina y la clase

48
00:03:08,650 --> 00:03:10,750
y el proyecto este está formado

49
00:03:10,750 --> 00:03:12,530
por tres

50
00:03:12,530 --> 00:03:14,650
clases según propone el

51
00:03:14,650 --> 00:03:16,469
enunciado. Algunos

52
00:03:16,469 --> 00:03:18,590
no es mal criterio cuando

53
00:03:18,590 --> 00:03:20,729
hacéis las prácticas, dedicáis

54
00:03:20,729 --> 00:03:22,490
una clase para el main

55
00:03:22,490 --> 00:03:24,050
y ahí es donde

56
00:03:24,050 --> 00:03:26,490
incorporáis una cuarta clase

57
00:03:26,490 --> 00:03:28,530
una clase que digamos principal

58
00:03:28,530 --> 00:03:30,449
que la consideréis como inicio del programa

59
00:03:30,449 --> 00:03:32,750
y ahí estanciáis la cocina y luego la cocina

60
00:03:32,750 --> 00:03:34,509
empieza a tener información

61
00:03:34,509 --> 00:03:52,550
Bueno, yo según lo proponía en el enunciado, como está en el enunciado así lo desarrollamos, la misma clase cocina es la que tiene el main. Bueno, si suponemos que pudiese haber más de una cocina, pues igual sería buena cosa que el main estuviera en una clase diferente.

62
00:03:52,550 --> 00:03:57,250
por ejemplo podría ser cadena de comercios o lo que sea

63
00:03:57,250 --> 00:04:00,870
o cadena de restaurantes y ahí podríamos a su vez

64
00:04:00,870 --> 00:04:04,889
volver a tener un array por ejemplo de cocinas para que esa

65
00:04:04,889 --> 00:04:09,030
cadena tuviese una o varias cocinas y cada una de esas cocinas

66
00:04:09,030 --> 00:04:12,930
tuviera la oportunidad de tener uno o varios frigoríficos y una o varias placas

67
00:04:12,930 --> 00:04:16,829
Bueno, no hemos sido tan ambiciosos en este ejercicio

68
00:04:16,829 --> 00:04:20,350
entonces vamos a crear las clases, la clase cocina

69
00:04:20,350 --> 00:04:27,810
vamos a crear la clase frigorífico

70
00:04:27,810 --> 00:04:30,410
vamos a crear las tres clases, luego vamos metiendo

71
00:04:30,410 --> 00:04:35,470
código y la clase

72
00:04:35,470 --> 00:04:45,490
placa. La clase frigorífico y la clase placa

73
00:04:45,490 --> 00:04:48,490
no veo que tengamos por aquí justo el ejercicio

74
00:04:48,490 --> 00:04:51,449
hecho anterior, aunque sí que hicimos la práctica

75
00:04:51,449 --> 00:04:54,170
bueno, pues en realidad no han cambiado

76
00:04:54,170 --> 00:04:55,910
mucho del ejercicio anterior

77
00:04:55,910 --> 00:04:59,569
la idea es que la placa pues tenga una marca

78
00:04:59,569 --> 00:05:02,589
como vamos a crear un setter y un

79
00:05:02,589 --> 00:05:04,810
y un getter, pues la podemos definir

80
00:05:04,810 --> 00:05:06,769
esa marca como privada,

81
00:05:06,870 --> 00:05:08,670
private, la marca es

82
00:05:08,670 --> 00:05:10,889
un string, bueno, pues ese marca.

83
00:05:12,189 --> 00:05:12,850
Y luego,

84
00:05:13,069 --> 00:05:14,689
pues tiene su getter y su setter,

85
00:05:14,949 --> 00:05:16,629
que lo podríamos escribir o podemos

86
00:05:16,629 --> 00:05:17,810
intentar aprovechar

87
00:05:17,810 --> 00:05:21,009
el id para que no los genere.

88
00:05:21,370 --> 00:05:22,410
Vamos a buscar por aquí,

89
00:05:23,410 --> 00:05:24,910
generar getters y setters,

90
00:05:25,029 --> 00:05:26,769
nos da aquí el id de la opción, si no lo podríamos

91
00:05:26,769 --> 00:05:28,730
escribir claro a mano, digamos que

92
00:05:28,730 --> 00:05:30,529
para el atributo ese marca,

93
00:05:30,529 --> 00:05:31,649
decimos que los genere,

94
00:05:32,589 --> 00:06:00,680
Y bueno, pues ahí están. La clase frigorífico creo que no tenía mucho más que esto. El acceso a la marca solo se puede hacer desde la propia clase, al haberlo definido como privado, entonces tendremos que acceder a la marca a través de estos dos métodos que en este caso son públicos, con lo cual tendrían visibilidad desde cualquier parte del proyecto, aunque hubiese diferentes paquetes, no sería necesario ni siquiera definirlos como públicos.

95
00:06:00,680 --> 00:06:07,860
si lo definiésemos sin ningún indicador, recordad que esto implica que la visibilidad es visibilidad de paquete

96
00:06:07,860 --> 00:06:11,939
y como todo el código lo tenemos en el mismo paquete, sería igualmente válido.

97
00:06:12,579 --> 00:06:17,819
Vamos a ponerlo público, que es como nos lo ha generado, pero podríamos ser un poquito más restrictivos

98
00:06:17,819 --> 00:06:20,720
si nos seguiría funcionando el programa de igual forma.

99
00:06:22,240 --> 00:06:29,920
Y por otra parte la placa tenía un atributo, vamos a definirlo también private,

100
00:06:29,920 --> 00:06:33,680
para que su acceso sea único y exclusivamente desde esta clase

101
00:06:33,680 --> 00:06:39,939
en el cual identificamos el color.

102
00:06:44,040 --> 00:06:47,459
Vamos a definir un setter y un getter, pero en lugar de

103
00:06:47,459 --> 00:06:51,199
llamar al setter desde por ahí fuera, lo que vamos a hacer va a ser llamarlo

104
00:06:51,199 --> 00:06:55,240
de forma interna también. Entonces vamos a crear los getter y los setter

105
00:06:55,240 --> 00:07:01,139
como antes, vamos a aprovecharnos del IDE, decimos que nos genere el getter

106
00:07:01,139 --> 00:07:04,939
y el setter, y en realidad el color

107
00:07:04,939 --> 00:07:09,139
se lo vamos a asignar en este ejercicio de forma automática

108
00:07:09,139 --> 00:07:11,980
desde el constructor entre tres posibles

109
00:07:11,980 --> 00:07:17,360
que de forma probabilística tenga cualquiera de los tres valores

110
00:07:17,360 --> 00:07:20,560
por igual. Entonces fijaros como este setColor

111
00:07:20,560 --> 00:07:24,480
lo vamos a aprovechar el constructor de la clase placa

112
00:07:24,480 --> 00:07:28,560
para llamarlo y que asigne el color y el constructor está en la propia clase

113
00:07:28,560 --> 00:07:32,680
podríamos incluso este setColor en este ejercicio también ponerlo como private

114
00:07:32,680 --> 00:07:39,420
porque en realidad no vamos a acceder a este método desde fuera de esta clase

115
00:07:39,420 --> 00:07:43,319
podríamos ponerlo, vamos a mantenerlo, aunque en público un getter y un setter

116
00:07:43,319 --> 00:07:47,399
típicamente, pues bueno, que tengan visibilidad pública no es una cosa

117
00:07:47,399 --> 00:07:51,399
para nada descabellada, ¿vale? Entonces ponemos

118
00:07:51,399 --> 00:07:55,399
el constructor para cuando creemos una nueva clase, vamos a definir

119
00:07:55,399 --> 00:07:59,199
el constructor como public, recordad que los constructores no devuelven nada

120
00:07:59,199 --> 00:08:03,000
pero nos indica, al contrario que el resto de los métodos

121
00:08:03,000 --> 00:08:25,899
Los constructores se tienen que llamar de la misma forma que la clase, con lo cual, respecto a esos convenios que tenemos a la hora de nombrar a los constructores, hacemos una pequeña excepción porque típicamente los métodos, tenemos el convenio, el acuerdo de que empiecen con minúsculas, las clases con mayúsculas, el constructor, recordad que no deja de ser un método.

122
00:08:25,899 --> 00:08:32,700
Entonces, para seguir el convenio tendría que ser minúscula, pero como se tiene que llamar como la clase, tenemos que romper una de las dos reglas.

123
00:08:33,000 --> 00:08:42,679
Entonces mantenemos la P mayúscula para el constructor y aquí lo que vamos a hacer va a ser cuando construyamos una nueva placa,

124
00:08:42,919 --> 00:08:49,639
hagamos el new y llamamos al constructor, lo que vamos a hacer va a ser aprovechar este momento para asignar ya un color

125
00:08:49,639 --> 00:08:57,639
y como queremos hacerlo entre tres que tengan un valor aleatorio, hay diferentes formas para hacerlo.

126
00:08:57,639 --> 00:09:01,379
la que yo os proponía en el ejercicio

127
00:09:01,379 --> 00:09:03,600
pues era definir aquí un par de constantes

128
00:09:03,600 --> 00:09:06,879
que fueran a un tercio y a dos tercios

129
00:09:06,879 --> 00:09:09,960
entonces si luego con una función

130
00:09:09,960 --> 00:09:12,919
aleatoria obtenemos un valor

131
00:09:12,919 --> 00:09:16,340
que va entre 0 y 1, pues entre 0,3

132
00:09:16,340 --> 00:09:19,220
periodo, consideraríamos uno de los

133
00:09:19,220 --> 00:09:22,259
tres posibles valores, si esa función random

134
00:09:22,259 --> 00:09:25,720
nos da un valor entre 0 y 0,3

135
00:09:25,720 --> 00:09:29,720
periodo, si va entre 0,3 periodo y 0,6 periodo, pues

136
00:09:29,720 --> 00:09:33,860
consideraríamos el segundo color y entre 0,6 hasta completar

137
00:09:33,860 --> 00:09:37,299
el 1, pues consideraríamos el tercero. De alguna forma ahí conseguimos

138
00:09:37,299 --> 00:09:39,899
que los tres colores tengan los mismos valores.

139
00:09:41,419 --> 00:09:45,700
Entonces, ¿cómo podemos hacer eso? Pues aquí lo que hacemos en el

140
00:09:45,700 --> 00:09:54,710
constructor es llamar al método setColor. En realidad,

141
00:09:54,710 --> 00:09:58,049
no vamos a llamar al método setColor

142
00:09:58,049 --> 00:10:02,750
como clásicamente se hace en los setters

143
00:10:02,750 --> 00:10:05,909
pasándole el valor, sino que lo que vamos a hacer va a ser dentro del setColor

144
00:10:05,909 --> 00:10:10,610
utilizar el método random, con lo cual este setColor, vamos a modificarlo

145
00:10:10,610 --> 00:10:12,970
así un poquito, vamos a decir que no reciba nada

146
00:10:12,970 --> 00:10:18,190
y aquí lo que vamos a hacer va a ser precisamente hacer ese cálculo

147
00:10:18,190 --> 00:10:22,289
entonces, utilizando de la librería

148
00:10:22,289 --> 00:10:25,570
de Java Math, el método

149
00:10:25,570 --> 00:10:32,559
random, este método fijaros que es un método

150
00:10:32,559 --> 00:10:36,340
disponible en la clase mat, no hemos instanciado ningún objeto

151
00:10:36,340 --> 00:10:39,879
de la clase mat, por lo que entendemos que esto se

152
00:10:39,879 --> 00:10:43,740
tratará de un método estático, porque lo podemos llamar con el nombre de la clase

153
00:10:43,740 --> 00:10:48,559
punto nombre del método, en la librería donde esté definido su código

154
00:10:48,559 --> 00:10:51,740
se lo habrán trabajado de forma estática

155
00:10:51,740 --> 00:10:58,120
y este método nos devuelve un valor entre

156
00:10:58,120 --> 00:11:08,080
devuelve un valor entre 0 y 1, en principio pues con el mismo porcentaje de posibilidades

157
00:11:08,080 --> 00:11:16,279
y el valor que devuelve, mirad si ponemos de nuevo aquí math.random, fijaros que lo que

158
00:11:16,279 --> 00:11:23,019
devuelve aquí nos indica el id es un valor de tipo double, entonces definimos aquí un double

159
00:11:23,019 --> 00:11:28,840
de result, pues aquí tendremos un valor

160
00:11:28,840 --> 00:11:32,840
que en unas ejecuciones estará siempre entre 0 y 1

161
00:11:32,840 --> 00:11:37,600
y caerá una vez entre 0 y 0,33, otra vez entre 0,33

162
00:11:37,600 --> 00:11:41,840
y 0,66 y otra entre 0,66 y 0,69

163
00:11:41,840 --> 00:11:45,360
entonces vamos a hacer esa comprobación, decimos if

164
00:11:45,360 --> 00:11:51,509
si de result es menor

165
00:11:51,509 --> 00:11:59,889
que 0,33, pues ahí haremos

166
00:11:59,889 --> 00:12:10,980
algo. El shift podríamos poner de result es menor que

167
00:12:10,980 --> 00:12:15,039
0,66. Fijaros que esto sería periodo, en verdad. Podríamos poner

168
00:12:15,039 --> 00:12:18,080
aquí más 6 y más 3.

169
00:12:19,179 --> 00:12:22,259
Lógicamente no podemos poner infinitos. Tendríamos que considerar

170
00:12:22,259 --> 00:12:26,940
el rango de valores que aceptan los double. Vamos a poner ahí unos cuantos

171
00:12:26,940 --> 00:12:33,720
y ya está. Y si no else, pues resultará que me habrá

172
00:12:33,720 --> 00:12:37,559
dado la tercera de las opciones. Fijaros que si vale

173
00:12:37,559 --> 00:13:07,100
0,1 también es menor de 0,66 pero como el if es excluyente si valiese menor de 0,3 ya habría ejecutado esta parte con lo cual tenemos la garantía de que por aquí pasará solamente dado que aquí lo que hemos comprobado es que sea menor de 0,33 solamente pasará en el caso de que sea de que esté entre 0,33 y 0,66 y ya si no es menor de 0,66 pues estará entre 0,66 y 1 y pasaremos por el último else.

174
00:13:07,559 --> 00:13:34,019
Bueno, pues aquí podemos poner el valor ese color, ponemos el valor que sea, cualquiera de los tres, no me acuerdo, era marrón, verde y azul, creo recordar, o rojo, no me acuerdo, bueno, es igual, marrón, verde y azul.

175
00:13:35,080 --> 00:13:45,259
Bueno, aquí tendríamos el método, el setter, un poquito particular porque no recibimos ningún atributo y además lo hemos definido como private porque su acceso se hace desde la propia clase.

176
00:13:46,200 --> 00:14:00,240
Luego en el ejercicio, por trabajar algunas cosas más de las que estábamos viendo, creo recordar que habíamos definido unas constantes para estos valores, pues bueno, podríamos ponerlo y así lo trabajamos también.

177
00:14:00,980 --> 00:14:20,309
Recordad, fijaros, eso es un valor de tipo double, podríamos poner double, podríamos poner d un tercio y decir que esto sea igual a, perdón, es un número 0.3333.

178
00:14:21,029 --> 00:14:25,669
entonces aquí la comprobación, bueno, pues la podríamos hacer justo con esta variable

179
00:14:25,669 --> 00:14:28,990
¿qué sucede en este caso? que hemos definido la variable

180
00:14:28,990 --> 00:14:33,409
o sea, hemos definido de un tercio como una variable

181
00:14:33,409 --> 00:14:37,830
entonces por aquí podríamos, en cualquier sitio del código

182
00:14:37,830 --> 00:14:41,409
ya que lo hemos definido como parte de un atributo de la clase

183
00:14:41,409 --> 00:14:45,610
podríamos decir que un tercio sea igual a 2, es decir, nos permite modificar

184
00:14:45,610 --> 00:14:51,559
su valor, en el contexto de este ejercicio un tercio nunca debería cambiar

185
00:14:51,559 --> 00:14:54,299
su valor, entonces si lo convertimos en final

186
00:14:54,299 --> 00:14:59,279
lo que es una variable se convierte en una constante y ahora ya

187
00:14:59,279 --> 00:15:03,320
fijaros que ya el propio IDE se da cuenta y no me compila porque dice

188
00:15:03,320 --> 00:15:07,379
oye mira, si has puesto finales porque es una constante no intentes cambiar su valor porque no

189
00:15:07,379 --> 00:15:15,259
ha lugar. Y para completar, fijaros que

190
00:15:15,259 --> 00:15:19,279
no le importa este nombre para una

191
00:15:19,279 --> 00:15:23,360
constante de tipo double, pero sí que habíamos llegado a un convenio también

192
00:15:23,360 --> 00:15:26,539
igual que los métodos empiezan por minúscula y las clases por mayúscula,

193
00:15:27,100 --> 00:15:33,659
de que las constantes aparezcan con todas sus letras en mayúscula.

194
00:15:33,779 --> 00:15:38,100
Entonces, bueno, pues lo correcto, según lo que tenemos acordado, sería algo así.

195
00:15:39,220 --> 00:15:43,200
Y luego, pues podríamos crear una constante para dos tercios,

196
00:15:43,200 --> 00:15:51,259
igual que hemos hecho para uno, dos tercios.

197
00:15:57,919 --> 00:15:59,580
Y aquí hacemos esta comprobación.

198
00:15:59,580 --> 00:16:03,830
fijaros, si queremos ser puristas incluso

199
00:16:03,830 --> 00:16:06,669
para seguir un poco lo que venimos hablando a veces

200
00:16:06,669 --> 00:16:10,509
una placa está caracterizada como atributo

201
00:16:10,509 --> 00:16:12,710
por su color, bueno pues

202
00:16:12,710 --> 00:16:16,090
si fuera la clase más extensa tendría su marca, su peso

203
00:16:16,090 --> 00:16:19,750
sus dimensiones, lo que fuese, eso caracterizaría a una placa

204
00:16:19,750 --> 00:16:22,210
pero bueno, no tiene mucho sentido quizás

205
00:16:22,210 --> 00:16:25,309
que utilicemos un tercio y dos tercios

206
00:16:25,309 --> 00:16:26,210
como atributos

207
00:16:26,210 --> 00:16:43,090
Entonces, quizás ya que son dos variables locales, no son algo que caracterizan en sí a la placa y son dos constantes que vamos a utilizar en el contexto de este método, quizás vendría mejor definirlas aquí.

208
00:16:43,090 --> 00:17:02,690
No recuerdo ahora mismo dónde están definidas en el ejemplo que os he pasado, pero quizás dentro de SetColor, siendo puristas en lo que es el diseño de la placa, ya que un tercio y dos tercios no son características propias de una placa, y si información necesaria para aplicar el color, igual podría venir mejor definirlo aquí que allí arriba.

209
00:17:02,690 --> 00:17:26,789
Y con esto, bueno, pues yo creo que ya tendríamos acabado lo que es. Bueno, esto ya sobra, claro. Esto en realidad no está haciendo nada porque ese color venía del setter de cuando teníamos aquí el parámetro del método setColor y se lo aplicaba al de clase.

210
00:17:26,789 --> 00:17:31,569
entonces esto lo quitamos y aquí lo tendríamos

211
00:17:31,569 --> 00:17:35,920
la placa y el frigorífico. Vámonos a la cocina

212
00:17:35,920 --> 00:17:39,599
según el ejercicio que estamos desarrollando ahora aquí

213
00:17:39,599 --> 00:17:44,819
nos hemos propuesto hacer que la cocina sea el punto de arranque

214
00:17:44,819 --> 00:17:48,039
del programa, con lo cual será la que tenga el método main

215
00:17:48,039 --> 00:17:52,920
entonces ponemos aquí public

216
00:17:52,920 --> 00:17:57,000
static void main, como siempre

217
00:17:57,000 --> 00:18:04,500
todas estas sintaxis que utilizamos para el main string recibe puede recibir como atributos el

218
00:18:04,500 --> 00:18:10,359
método main como métodos el método main una raíz de strings en algún momento hemos hablado de

219
00:18:11,500 --> 00:18:18,319
de cómo de cómo se mete esta información al main y aquí lo tenemos el punto de arranque

220
00:18:18,319 --> 00:18:26,539
os ha denunciado un momento dice la cocina inicia el programa y tendrá las siguientes

221
00:18:26,539 --> 00:18:34,880
características, nombre de la cocina, si tiene o no tiene frigorífico, si tiene o no tiene placa, el

222
00:18:34,880 --> 00:18:42,640
número de frigoríficos, el número de placas y el array de frigoríficos y de placas que donde vamos

223
00:18:42,640 --> 00:18:50,619
a ir guardando esa información. Pues ahora vamos a ello. Nos dice que tiene un string, ese nombre de

224
00:18:50,619 --> 00:19:07,440
la cocina un boolean ve frigorífico tiene frigorífico o no tiene un boolean que nos indique

225
00:19:07,440 --> 00:19:13,819
si tiene placa o no tiene placa esto podríamos si queréis inicializar la falsa los boolean en

226
00:19:13,819 --> 00:19:20,859
verdad si no decimos nada si está están inicializados por defecto a falsa luego hablaba

227
00:19:20,859 --> 00:19:28,400
del número de frigoríficos y numfrig número de frigoríficos lo podemos inicializar a cero aunque

228
00:19:28,400 --> 00:19:32,900
de igual forma que esto se inicializa a false, un número se inicializa

229
00:19:32,900 --> 00:19:35,960
por defecto a cero, placas,

230
00:19:38,180 --> 00:19:40,920
frigoríficos, número de frigoríficos, número de placas

231
00:19:40,920 --> 00:19:45,200
y luego los arrays. En los arrays

232
00:19:45,200 --> 00:20:07,009
tenemos un array de frigoríficos y un array de placas.

233
00:20:09,440 --> 00:20:12,240
Fijaros que no estamos dimensionando aquí todavía con

234
00:20:12,240 --> 00:20:19,410
un new, como típicamente haríamos. No estamos

235
00:20:19,410 --> 00:20:24,690
haciendo esto todavía poniendo aquí un determinado valor porque no sabemos si en esta ejecución la

236
00:20:24,690 --> 00:20:29,170
cocina va a tener frigoríficos o no. Habrá un momento en el que lo pediremos por teclado y

237
00:20:29,170 --> 00:20:35,690
tendremos que hacer esta acción y de la misma forma sucede con las placas. Luego cuando lleguemos a

238
00:20:35,690 --> 00:20:46,210
ello lo repasamos. Bueno, todos en principio todas estas variables vamos a trabajar sobre ellas

239
00:20:46,210 --> 00:20:48,309
principalmente desde el método main.

240
00:20:48,589 --> 00:20:52,349
Recordad, el método main es static, es decir, es único.

241
00:20:52,549 --> 00:20:57,509
Entonces, o bien, tendríamos que trabajar instanciando una cocina

242
00:20:57,509 --> 00:21:02,430
para que desde un sitio static podamos hacer referencia

243
00:21:02,430 --> 00:21:05,490
a la cocina con la que queremos trabajar.

244
00:21:05,670 --> 00:21:11,500
Fijaros, si ponemos aquí ese nombre directamente al valor que sea,

245
00:21:11,619 --> 00:21:14,359
luego lo trabajamos según el ejercicio, se me queja.

246
00:21:14,359 --> 00:21:15,200
¿Por qué se queja?

247
00:21:15,200 --> 00:21:19,559
porque dice, este método que sería común

248
00:21:19,559 --> 00:21:23,779
es el main, pero podría ser cualquier otro, por ser static

249
00:21:23,779 --> 00:21:27,680
a la clase cocina, se puede estar ejecutando

250
00:21:27,680 --> 00:21:31,640
para cualquier cocina el mismo código, entonces se está ejecutando para cualquier

251
00:21:31,640 --> 00:21:35,680
cocina el mismo código, y me pones aquí ese nombre, resulta que tú en el

252
00:21:35,680 --> 00:21:39,539
programa podrías tener 5, 6, 7, 8 cocinas, el enunciado dice que trabajemos

253
00:21:39,539 --> 00:21:42,619
con una solo, entonces para todas esas cocinas

254
00:21:42,619 --> 00:21:47,279
de todas esas cocinas, ¿a qué nombre quieres que le dé el A?

255
00:21:47,420 --> 00:21:50,240
El A del nombre de cuál de todas esas cocinas.

256
00:21:52,079 --> 00:21:55,700
En este ejercicio, la verdad es que, según está definido,

257
00:21:55,960 --> 00:21:58,200
no tenemos más de una cocina, con lo cual,

258
00:21:58,700 --> 00:22:02,000
la única cocina que hay tendrá un nombre y no habrá más.

259
00:22:02,160 --> 00:22:05,180
El único frigorífico que hay tendrá este boolean

260
00:22:05,180 --> 00:22:06,819
y así para todas las variables.

261
00:22:07,619 --> 00:22:10,420
Como no hay más de una cocina y no hay lugar a discrepancias

262
00:22:10,420 --> 00:22:13,259
sobre qué cocina queremos trabajar, podríamos ponerlo como static.

263
00:22:13,660 --> 00:22:16,319
Si lo ponemos static, aunque hubiese

264
00:22:16,319 --> 00:22:18,920
más de una cocina, todas tendrían el mismo nombre, pero

265
00:22:18,920 --> 00:22:22,440
justo en este contexto hay una sola cocina, con lo cual el nombre

266
00:22:22,440 --> 00:22:25,599
que se aplicaría a todas las cocinas es el nombre que se aplica

267
00:22:25,599 --> 00:22:27,740
a la única cocina con la que queremos trabajar.

268
00:22:28,299 --> 00:22:31,519
Por eso nos vale poner aquí static y no tenemos que instanciar

269
00:22:31,519 --> 00:22:33,259
ninguna cocina en particular.

270
00:22:34,599 --> 00:22:37,259
Si no trabajásemos con static, ¿qué sucedería?

271
00:22:37,539 --> 00:22:39,140
Pues entonces, para poder hacer esto,

272
00:22:40,420 --> 00:22:44,440
Al no ser el nombre estático, podría pertenecer a muchas cocinas.

273
00:22:44,779 --> 00:22:48,940
Entonces, tendríamos que identificar el nombre de qué cocina sería.

274
00:22:48,940 --> 00:22:58,819
Entonces, diríamos cocina, micod, 1, igual, año, cocina.

275
00:23:00,359 --> 00:23:04,680
Y ahora, sí que entre todas las posibles cocinas tenemos identificada una

276
00:23:04,680 --> 00:23:09,359
y vamos a asignar a A justo a una determinada cocina.

277
00:23:09,359 --> 00:23:17,150
y aquí ya me compilaría. Aquí no habría discrepancias, no pone ese nombre, un ese nombre genérico

278
00:23:17,150 --> 00:23:23,589
que puede ser para muchas cocinas, ya que cada cocina tiene un nombre distinto al no ser estático.

279
00:23:23,930 --> 00:23:29,730
Ahora ya quedaría claro que estamos asignando a A al nombre de una cocina en particular, que es miCoz1.

280
00:23:29,730 --> 00:23:35,069
Otra cocina, que instanciásemos otro objeto, pues tendría un nombre diferente probablemente.

281
00:23:37,839 --> 00:23:42,740
Como en este ejercicio trabajamos con una sola cocina, vamos a hacer que todos estos atributos

282
00:23:42,740 --> 00:23:46,819
estén compartidas, compartidos por todas las cocinas, que al final, como es

283
00:23:46,819 --> 00:23:49,799
única, pues van a ser los atributos de esa única cocina.

284
00:23:51,000 --> 00:23:58,240
Si lo ponemos static todos, serían atributos

285
00:23:58,240 --> 00:24:01,759
compartidos con todas las posibles cocinas que diéramos de alta en el programa,

286
00:24:02,539 --> 00:24:05,839
como solo hay una, pues para esa cocina en particular

287
00:24:05,839 --> 00:24:10,359
todos los atributos. Entonces aquí ya podríamos

288
00:24:10,359 --> 00:24:18,430
poner un ese nombre igual a lo que sea. Por cerrar esto

289
00:24:18,430 --> 00:24:22,730
que os cuento, esto del static, dependiendo del contexto del enunciado

290
00:24:22,730 --> 00:24:26,569
y cómo vayamos a hacer el programa, es posible o no es posible. Si hubiera más de una cocina

291
00:24:26,569 --> 00:24:30,529
no podríamos decir, bueno, para que me compile sin instanciar un objeto lo pongo static

292
00:24:30,529 --> 00:24:34,950
porque cada cocina tendría su nombre. Hay que tener en cuenta un poco las circunstancias

293
00:24:34,950 --> 00:24:37,829
de lo que nos pide el ejercicio y lo que nos demanda.

294
00:24:40,140 --> 00:24:43,559
Pues ya tenemos ahí definidos todos estos e incluso

295
00:24:43,559 --> 00:24:47,720
fijaros, vamos a darle carácter de privados a todos

296
00:24:47,720 --> 00:24:58,440
si luego alguno necesitamos acceder a él desde algún otro sitio, diferente de que desde la clase, pues le cambiamos la visibilidad.

297
00:24:58,759 --> 00:25:05,559
Pero en principio yo creo que todos los accesos lo vamos a hacer desde la clase cocina a estos elementos, con lo cual podrían ser incluso private

298
00:25:05,559 --> 00:25:15,440
para dar seguridad a nuestra clase y que no pueda ser accedida desde otras futuras clases que quizás quisieran modificar estos datos

299
00:25:15,440 --> 00:25:24,019
y a lo mejor podría no interesarnos vale pues nada la información se va recogiendo para ir

300
00:25:24,019 --> 00:25:29,759
trabajando con el programa desde teclado entonces si se va recogiendo el de teclado vamos a definir

301
00:25:29,759 --> 00:25:45,119
un objeto de la clase escáner es la clase escáner que está definida en la librería mira que no lo

302
00:25:45,119 --> 00:25:50,640
lleve por aquí en la java útil las cosas que están definidas en las librerías java lang no

303
00:25:50,640 --> 00:25:54,220
es necesario importarlas porque las consideran todos los proyectos

304
00:25:54,220 --> 00:25:58,779
dado que se entiende que son funciones de uso tan común

305
00:25:58,779 --> 00:26:02,779
que dicen, pues mira, directamente las integramos en cualquier proyecto con el que

306
00:26:02,779 --> 00:26:06,740
se trabaje. El resto de librerías que tenemos disponibles

307
00:26:06,740 --> 00:26:10,759
de Java, pues cada una la tenemos que importar en caso de necesitarlas.

308
00:26:10,960 --> 00:26:14,480
Lógicamente no sería razonable integrar todas las librerías

309
00:26:14,480 --> 00:26:18,599
porque sería mucho código que probablemente nuestros programas no iríamos

310
00:26:18,599 --> 00:26:22,680
utilizando. En este caso, como vamos a usar Scanner y está en Java útil, que no está en

311
00:26:22,680 --> 00:26:26,980
Java lang, tenemos que importarlo. Pues nada, ya nos va compilando.

312
00:26:27,720 --> 00:26:29,400
Todavía por aquí no, pero ya por aquí sí.

313
00:26:30,960 --> 00:26:34,839
Con Scanner tenemos la posibilidad de leer flujos

314
00:26:34,839 --> 00:26:38,779
de datos. Los flujos de datos, luego cuando hablemos de los

315
00:26:38,779 --> 00:26:42,819
ficheros, trataremos los flujos de datos y en una asignatura

316
00:26:42,819 --> 00:26:46,380
que tendréis, probablemente si os matriculáis el año que viene, que es

317
00:26:46,380 --> 00:26:50,240
programación de servicios y procesos, hablaremos de más flujos de datos

318
00:26:50,240 --> 00:26:54,460
de otros tipos. Lo que nos permite es comunicar nuestro programa

319
00:26:54,460 --> 00:26:57,759
con el exterior. Y esta comunicación, pues fijaros, puede ser

320
00:26:57,759 --> 00:27:02,140
bien desde teclado, cosa que vamos a hacer ahora, el flujo de datos desde el teclado

321
00:27:02,140 --> 00:27:05,920
hasta nuestro programa, o los de salidas cuando hacemos un system of println

322
00:27:05,920 --> 00:27:09,980
y sacamos por pantalla, pues es un flujo de datos de salida desde el programa

323
00:27:09,980 --> 00:27:14,079
a la pantalla. También tenemos la posibilidad de tener flujos de datos

324
00:27:14,079 --> 00:27:18,279
a ficheros, para leer o guardar ficheros, o flujo de datos

325
00:27:18,279 --> 00:27:21,759
también a sockets, que es esto que os digo que veréis el año que viene

326
00:27:21,759 --> 00:27:25,700
en la asignatura de PSP. Scanner nos permite manejar

327
00:27:25,700 --> 00:27:30,039
información recibida en el programa a través de un determinado

328
00:27:30,039 --> 00:27:33,960
flujo de datos, que este curso lo estamos utilizando desde teclado

329
00:27:33,960 --> 00:27:37,819
siempre, pero podría ser información que estamos leyendo, por ejemplo,

330
00:27:37,819 --> 00:27:41,400
desde un fichero. Para identificar el flujo,

331
00:27:41,400 --> 00:27:48,140
o desde dónde nos van a llegar los datos al programa a través de este flujo, se lo decimos en el constructor de escáner.

332
00:27:48,339 --> 00:27:54,759
Entonces, en este caso decimos que en particular queremos gestionar con el objeto MyScan de la clase escáner

333
00:27:54,759 --> 00:27:58,519
información que nos va a ir llegando desde el flujo de datos SystemIn.

334
00:28:01,009 --> 00:28:07,509
Y una buena costumbre es que los flujos de datos que abramos terminemos cerrándolos

335
00:28:07,509 --> 00:28:11,470
para que no se queden ahí abiertos y consumiendo recursos

336
00:28:11,470 --> 00:28:14,170
cuando dejemos de trabajar con ese flujo de datos.

337
00:28:14,410 --> 00:28:17,089
Si estamos leyendo un fichero, cuando terminemos de leerlo,

338
00:28:17,710 --> 00:28:20,390
en lugar de dejarlo ahí al aire y consumiendo recursos,

339
00:28:20,549 --> 00:28:21,369
pues vamos a cerrarlo.

340
00:28:22,190 --> 00:28:26,509
Si estamos leyendo el teclado, pues cuando terminemos vamos a cerrarlo.

341
00:28:26,690 --> 00:28:30,369
Entonces ponemos aquí, ponemos la opción Close y aquí me lo cierra.

342
00:28:32,150 --> 00:28:35,609
Daros cuenta que aquí estoy poniendo el Close al final del Main,

343
00:28:35,990 --> 00:28:37,289
que ya estamos terminando el programa,

344
00:28:37,509 --> 00:28:52,890
Si no lo pusiéramos, es verdad que me da un warning aquí, creo, mirad, me da un aviso aquí diciendo, oye, no me gusta mucho que no lo hayas cerrado, fijaros, dice mi scan is never closed, pero como ya se acaba el programa, al finalizar el programa se cerraría en cualquier caso.

345
00:28:52,890 --> 00:28:57,490
pero podría darse la situación de que terminásemos de utilizar mi scan

346
00:28:57,490 --> 00:29:01,049
y por aquí todavía siguiésemos con código de Java haciendo cosas

347
00:29:01,049 --> 00:29:04,289
a lo mejor es un programa 24-7 que no cierra nunca

348
00:29:04,289 --> 00:29:10,230
y si no lo cerramos, pues aquí dejaríamos un recurso consumiéndose de forma innecesaria

349
00:29:10,230 --> 00:29:14,250
entonces, bueno, pues buena costumbre cerrar los flujos de datos

350
00:29:14,250 --> 00:29:18,430
ahí lo tenemos

351
00:29:18,430 --> 00:29:22,650
y ahora bueno, pues vamos a empezar a trabajar con ello

352
00:29:22,650 --> 00:29:25,309
lo primero que nos pide es el nombre de la cocina

353
00:29:25,309 --> 00:29:35,450
Entonces, nos mandamos un mensaje por aquí, println, y solicitamos el nombre de la cocina.

354
00:29:35,930 --> 00:29:39,329
Dime cómo se llama tu cocina.

355
00:29:40,269 --> 00:29:48,109
Si ponemos un system.out.println y utilizamos este método de la clase out que está colgando de system,

356
00:29:49,170 --> 00:29:52,930
resulta que nos pondría este texto por consola y nos saltaría una línea.

357
00:29:52,930 --> 00:30:09,910
Pues en este caso vamos a utilizar el System of Print que nos saca por consola esto y se queda en la misma línea porque no mete el LN. Me parece más cómodo, más razonable el que te aparezca el texto y el cursor se quede aquí para que pongas el nombre.

358
00:30:09,910 --> 00:30:18,950
bueno pues el nombre en principio va a ser un stream pues que vamos a querer cargar en el

359
00:30:18,950 --> 00:30:23,210
nombre que lo tenemos aquí definido como un atributo de la cocina entonces podemos utilizarlo

360
00:30:23,210 --> 00:30:35,019
directamente en este caso ponemos mi scan punto next line ahora ya tenemos aquí el nombre lo

361
00:30:35,019 --> 00:30:41,559
siguiente que hacemos es por recuperar los frigoríficos las placas entonces

362
00:30:41,559 --> 00:30:48,660
por aquí nos dice el número de frigoríficos, nos indica si hay frigoríficos

363
00:30:48,660 --> 00:30:52,319
por aquí, pues vamos a cargar estos datos y lo vamos a instanciar

364
00:30:52,319 --> 00:30:56,480
tanto frigoríficos como vayamos recibiendo por teclado

365
00:30:56,480 --> 00:31:02,400
entonces podemos poner aquí un system.out.println

366
00:31:02,400 --> 00:31:08,750
dime o indica o como queráis el número

367
00:31:08,750 --> 00:31:12,150
de frigoríficos

368
00:31:12,150 --> 00:31:14,910
de la cocina

369
00:31:14,910 --> 00:31:20,609
y si queréis que os quede un poquito más chulito ya que tenemos aquí el nombre

370
00:31:20,609 --> 00:31:23,829
pues podemos decirle, indicarle pues que nos diga

371
00:31:23,829 --> 00:31:30,900
de la cocina esta y le ponemos así, dime el nombre

372
00:31:30,900 --> 00:31:35,019
el número de frigoríficos de la cocina y así nos sale el nombre

373
00:31:35,019 --> 00:31:38,660
que tiene la cocina en la pregunta que lo acabamos de cargar aquí

374
00:31:38,660 --> 00:31:41,079
a través del escáner

375
00:31:41,079 --> 00:31:45,039
aquí es previsible que recibamos un número

376
00:31:45,039 --> 00:31:49,099
y bueno, en un programa que hiciésemos

377
00:31:49,099 --> 00:31:52,599
en los próximos temas, pues a lo mejor correspondería

378
00:31:52,599 --> 00:31:56,759
validar este número, bien por código o bien a través de excepciones

379
00:31:56,759 --> 00:32:01,240
hay un tema de excepciones que viene a suponer

380
00:32:01,240 --> 00:32:05,240
cuando las excepciones son estos mensajes que a veces nos dan aquí de error

381
00:32:05,240 --> 00:32:08,940
cuando una de ellas muy típica es cuando intentamos acceder a

382
00:32:08,940 --> 00:32:14,980
un elemento de un objeto que no hemos instanciado mirad por ejemplo aquí si cogemos y decimos

383
00:32:14,980 --> 00:32:28,349
frigorífico a y nos lo hacemos un new y ahora ponemos aquí a punto ese nombre frigorífico

384
00:32:28,349 --> 00:32:36,210
no tiene nombre es a punto ese marca bueno ese marca es privado pues vamos a utilizar vaya setter

385
00:32:36,210 --> 00:32:57,390
es setter pues venga set marca que sucede que al frigorífico vamos a poner así null incluso como

386
00:32:57,390 --> 00:33:01,329
no lo hemos hecho un new, tiene un null, no tiene reserva de espacio en memoria, entonces

387
00:33:01,329 --> 00:33:05,549
al intentar acceder a uno de sus métodos, pues nos da un fallo. Fijaros, si hacemos aquí la ejecución,

388
00:33:08,529 --> 00:33:11,450
bueno, aquí nos da un fallo. Fijaros que los mensajes que nos saca es

389
00:33:11,450 --> 00:33:15,609
de excepción, bueno, en particular de null pointer exception,

390
00:33:16,170 --> 00:33:19,329
el a apunta a null, entonces da

391
00:33:19,329 --> 00:33:23,009
una excepción de null pointer exception, entonces estas excepciones

392
00:33:23,009 --> 00:33:26,630
se pueden trabajar desde el código,

393
00:33:26,630 --> 00:33:29,750
no las puedes evitar si se dan, pero

394
00:33:29,750 --> 00:33:33,829
puedes hacer que el programa no se termine y gestionar

395
00:33:33,829 --> 00:33:37,089
cómo quieres tú procesar cuando se dé una de esas excepciones.

396
00:33:37,630 --> 00:33:41,589
Lo veremos en algún otro tema. Otro caso típico, este es uno muy típico para

397
00:33:41,589 --> 00:33:45,650
provocar una excepción y que lo podáis ver y que se os puede dar, y otro es

398
00:33:45,650 --> 00:33:49,289
si por ejemplo se produce una división entre cero. Si tú cualquier número

399
00:33:49,289 --> 00:33:52,930
lógicamente lo divides entre cero, pues el número que te da es infinito.

400
00:33:52,930 --> 00:33:58,049
entonces el procesador no es capaz de gestionar un número

401
00:33:58,049 --> 00:34:00,390
que sea infinito y nos da una excepción

402
00:34:00,390 --> 00:34:05,049
entonces esta excepción nos daría un mensaje de este tipo

403
00:34:05,049 --> 00:34:06,470
y cuando se produce una excepción

404
00:34:06,470 --> 00:34:09,210
si no está controlada el programa se termina

405
00:34:09,210 --> 00:34:14,050
suponed que es un programa 24-7

406
00:34:14,050 --> 00:34:15,010
está ahí en un cajero

407
00:34:15,010 --> 00:34:17,869
que queremos que esté trabajando de forma continuada

408
00:34:17,869 --> 00:34:21,829
y hay una situación en la que en base a unos datos

409
00:34:21,829 --> 00:34:24,690
que puedas meter tú por teclado, podría darse una excepción.

410
00:34:25,670 --> 00:34:27,750
Cuando metes otros datos, que son los razonables,

411
00:34:27,869 --> 00:34:30,510
el programa hace el procesamiento que corresponda,

412
00:34:30,670 --> 00:34:34,130
pero bajo ciertos datos sí que da esa excepción.

413
00:34:34,389 --> 00:34:36,150
Si no la tienes controlada, ¿qué sucedería?

414
00:34:36,210 --> 00:34:38,250
Que acabaría el programa y nos quedaríamos sin cajero

415
00:34:38,250 --> 00:34:40,869
hasta que fuera a reiniciarlo algún operario.

416
00:34:41,190 --> 00:34:45,409
Si lo tienes controlado, puedes gestionar lo que tiene que pasar

417
00:34:45,409 --> 00:34:48,429
cuando se dé esa excepción y mantener el programa en funcionamiento.

418
00:34:50,230 --> 00:35:01,769
Otra posible excepción es que si vamos a intentar cargar en una variable numérica un dato alfanumérico, pues nos da una excepción también y el programa se terminaría, pues otra de otro tipo.

419
00:35:02,190 --> 00:35:13,670
Que sería lo que nos podría suceder aquí en caso de que si vamos a cargar en una variable de tipo numérico una cadena de caracteres y decimos que el número de frigoríficos es hola, pues nos daría una excepción.

420
00:35:13,670 --> 00:35:20,889
Vamos a hacer el programa sin errores y pues ponemos la gestión de excepciones para cuando lleguemos a su tema.

421
00:35:23,349 --> 00:35:36,889
Entonces bueno, pues para cargar el número de frigoríficos, pues fijaros, podríamos poner que el número de frigoríficos sea igual a mi scan.nestint.

422
00:35:36,889 --> 00:35:53,059
esto me devuelve un entero que lo cargaría

423
00:35:53,059 --> 00:35:56,980
aquí y me dejaría en el buffer de lectura todavía

424
00:35:56,980 --> 00:36:01,000
disponible el enter, cuando yo escribo aquí en la

425
00:36:01,000 --> 00:36:04,880
consola el número, pues pondré un 4, un 3 y luego

426
00:36:04,880 --> 00:36:08,920
le daré enter, este NSINT me leerá el 3 y ese

427
00:36:08,920 --> 00:36:12,599
enter quedará pendiente en el buffer de lectura y bueno, pues

428
00:36:12,599 --> 00:36:16,880
en ciertas circunstancias podría llegar a darnos algún problema, una posibilidad

429
00:36:16,880 --> 00:36:20,820
hace es limpiar el buffer de lectura, haciendo un nestline aquí

430
00:36:20,820 --> 00:36:25,039
sin cargárselo a nadie, con lo cual esto me cargaría

431
00:36:25,039 --> 00:36:28,900
el 4 y esto me cargaría el enter sin metérselo a nadie, pero limpio el buffer

432
00:36:28,900 --> 00:36:32,860
de lectura. Y otra alternativa, bueno, pues la que yo estoy

433
00:36:32,860 --> 00:36:35,920
acostumbrado a hacer, que os digo siempre, es leerlo siempre con

434
00:36:35,920 --> 00:36:42,900
un nestline y luego hacer la conversión que corresponda. Cualquiera de las dos opciones

435
00:36:42,900 --> 00:36:48,269
en verdad están bien. Pues yo defino por aquí una variable SAUS

436
00:36:48,269 --> 00:36:52,050
aunque aquí estoy leyendo un número

437
00:36:52,050 --> 00:36:56,710
voy a leer de escáner un next line

438
00:36:56,710 --> 00:37:12,110
con lo cual aquí podría tener algo que es un número

439
00:37:12,110 --> 00:37:16,130
pero en realidad es una cadena de caracteres, sería el 3 como cadena de caracteres o el 2

440
00:37:16,130 --> 00:37:19,650
o lo que correspondiese y ahora para pasar esto a número

441
00:37:19,650 --> 00:37:24,280
utilizamos integer.

442
00:37:25,539 --> 00:37:30,949
Recordad que el número de frigoríficos es de tipo int

443
00:37:30,949 --> 00:37:44,730
que es un dato primitivo y los datos primitivos pues tienen sus características particulares, no es necesario hacer el new, pero no tienen como cuando definimos un dato referenciado, por ejemplo un frigorífico, ciertos métodos propios de una clase.

444
00:37:44,730 --> 00:37:55,929
Entonces, para poder trabajar con métodos, hacer acciones que tengan que ver con el entero, que el int en particular no tiene esos métodos, utilizamos su clase graper o envoltoria.

445
00:37:56,489 --> 00:38:03,250
Entonces, todas las clases en verdad tienen estas primitivas, tienen su clase envoltorio, la int pues tiene la integer.

446
00:38:03,250 --> 00:38:07,630
entonces esta sí que tiene una serie de métodos entonces el método parseInt

447
00:38:07,630 --> 00:38:11,929
que ya lo conocemos recibe como atributo un string

448
00:38:11,929 --> 00:38:17,570
y devuelve hacia la izquierda una variable de tipo

449
00:38:17,570 --> 00:38:21,389
como nos chiva aquí, como nos chiva eclipse

450
00:38:21,389 --> 00:38:24,409
una variable de tipo entero, veis por aquí

451
00:38:24,409 --> 00:38:30,920
con lo cual aquí ya tendríamos el frigorífico y como hemos hecho una lectura con nestline

452
00:38:30,920 --> 00:38:35,599
aparte de coger el número pues ha limpiado el buffer porque ha considerado

453
00:38:35,599 --> 00:38:43,199
el enter. En definitiva aquí de esta parte de la ejecución

454
00:38:43,199 --> 00:38:46,940
tendremos que tenemos o cero frigoríficos o n frigoríficos

455
00:38:46,940 --> 00:38:51,280
pues podríamos decir sí. El número

456
00:38:51,280 --> 00:38:57,179
de frigoríficos es mayor que cero

457
00:38:57,179 --> 00:39:05,190
bueno pues vamos a trabajar con los frigoríficos. Una primera cosa

458
00:39:05,190 --> 00:39:09,110
que podemos hacer es decir que si el número de frigoríficos es mayor

459
00:39:09,110 --> 00:39:12,929
que cero vamos a indicar en este boolean que hay frigoríficos por si queremos

460
00:39:12,929 --> 00:39:18,820
utilizar esto luego en algún momento para algo. Bueno, como el número de frigoríficos

461
00:39:18,820 --> 00:39:22,599
ha sido mayor que cero, vamos a, tendemos

462
00:39:22,599 --> 00:39:26,639
el número de frigoríficos, el boolean ya indicando que es cero y el otro

463
00:39:26,639 --> 00:39:30,699
lo que vamos a hacer va a ser construir el array, dimensionarlo

464
00:39:30,699 --> 00:39:34,619
según el número de frigoríficos y meter la información

465
00:39:34,619 --> 00:39:38,699
que corresponda. Recordad que para los frigoríficos la información era indicar

466
00:39:38,699 --> 00:39:43,619
su marca. Bueno, pues podemos utilizar un bucle

467
00:39:43,619 --> 00:39:47,099
y aprovecharnos de los datos que tenemos.

468
00:39:47,360 --> 00:39:50,880
Entonces decimos int i igual a cero, vamos a recorrer todo el bucle,

469
00:39:52,719 --> 00:40:02,599
mientras i sea menor que el número de frigoríficos, i más más.

470
00:40:09,420 --> 00:40:12,559
Y aquí vamos a ir trabajando en el array construyéndolo.

471
00:40:12,860 --> 00:40:15,059
Una primera cosa que podemos hacer aquí, como ya sabemos,

472
00:40:15,059 --> 00:40:18,219
el número de frigoríficos es dimensionar el array.

473
00:40:18,719 --> 00:40:22,960
Entonces podemos coger y decir que mi array de frigoríficos

474
00:40:22,960 --> 00:40:29,599
new frigorífico

475
00:40:29,599 --> 00:40:37,989
inundefrigoríficos. Fijaros que aquí lo que hemos hecho ha sido

476
00:40:37,989 --> 00:40:42,250
fijaros que esto no es el constructor del frigorífico, hemos puesto los corchetes

477
00:40:42,250 --> 00:40:46,050
y no los paréntesis, lo que significa que no estamos

478
00:40:46,050 --> 00:40:50,190
dando de alta el espacio de memoria para un determinado frigorífico, lo que estamos

479
00:40:50,190 --> 00:40:53,690
construyendo es un array de referencias a frigoríficos

480
00:40:53,690 --> 00:40:58,269
tantas referencias como hayamos indicado de frigoríficos que hay, pero cada uno

481
00:40:58,269 --> 00:41:04,030
esos frigoríficos todavía no tiene su espacio en particular donde por ejemplo aplicar la marca

482
00:41:04,030 --> 00:41:12,550
que tiene ese frigorífico ese frigorífico entonces aquí lo que hemos dado es dimensionado en la red

483
00:41:12,550 --> 00:41:18,670
de frigoríficos y ahora en este ford lo que vamos a hacer es lo que hacemos es recorrer cada uno de

484
00:41:18,670 --> 00:41:24,260
los frigoríficos para ir trabajando con él. Entonces cogemos y decimos

485
00:41:24,260 --> 00:41:25,980
mi

486
00:41:25,980 --> 00:41:33,409
arfrig y daros cuenta que esto

487
00:41:33,409 --> 00:41:38,210
en la primera iteración del bucle for será cero, en la segunda

488
00:41:38,210 --> 00:41:42,090
como incrementamos será uno, la tercera será dos, la cuarta será tres

489
00:41:42,090 --> 00:41:46,210
y nos saldremos del for cuando hayamos recorrido todos los

490
00:41:46,210 --> 00:41:52,530
frigoríficos y ahora hacemos un new frigorífico

491
00:41:52,530 --> 00:42:16,329
Y aquí sí que ponemos el constructor del frigorífico. Aquí estamos pidiendo al sistema operativo espacio de memoria donde guardar información de esto, que esto es un frigorífico en particular, uno de todo ese grupo de frigoríficos que están recogidos dentro y quito el corchete de este nombre que es una red de frigoríficos.

492
00:42:16,329 --> 00:42:48,599
Esto es, mi ARFRIG es un array de frigoríficos, mi ARFRIG, y entre corchetes con un número ahí, es un frigorífico en particular, y para ese frigorífico en particular llamamos al constructor, igual que lo haríamos si definiésemos un frigorífico fuera del array, diríamos frigorífico A, esto es un frigorífico, igual que esto es un frigorífico, igual a new frigorífico.

493
00:42:49,599 --> 00:42:54,059
y para este frigorífico A en particular

494
00:42:54,059 --> 00:42:57,360
lo que estamos haciendo es llamar al constructor del frigorífico

495
00:42:57,360 --> 00:42:59,820
después del new, para este frigorífico en particular

496
00:42:59,820 --> 00:43:02,519
estamos llamando al constructor del frigorífico después del new

497
00:43:02,519 --> 00:43:05,539
aquí que no llamamos al constructor

498
00:43:05,539 --> 00:43:09,239
lo que hacíamos era dimensionar el array de frigoríficos

499
00:43:09,239 --> 00:43:11,719
pero un array de referencias a frigoríficos

500
00:43:11,719 --> 00:43:15,619
no de frigoríficos ya con todo su cuerpo

501
00:43:15,619 --> 00:43:23,239
digamos, vale pues una vez hecho esto

502
00:43:23,239 --> 00:43:28,300
lo que tenemos que hacer para cada uno de los frigoríficos es pedir por teclado su marca.

503
00:43:28,699 --> 00:43:41,989
Entonces decimos system.out.println, dime la marca del frigorífico.

504
00:43:49,380 --> 00:43:52,039
Ponemos un system.out.print para que nos quede la misma línea.

505
00:43:53,699 --> 00:43:56,460
Y aquí, bueno, con escáner podemos recuperar la marca.

506
00:43:58,380 --> 00:44:02,199
Fijaros, si queremos que este nombre en cada una de las iteraciones,

507
00:44:02,199 --> 00:44:31,960
pues vaya un poquito más acorde a, ya estoy pidiendo la marca del primero de los frigoríficos, del array y del segundo, pues tenemos la i que nos va recorriendo en cada ejecución del bucle tiene un valor diferente, la primera será 0, pues si el frigorífico del array 0 lo queremos enumerar como primero de los frigoríficos, pues aquí podríamos poner, dime la del frigorífico y aquí poner, si ponemos i nos diría el frigorífico 0,

508
00:44:32,199 --> 00:44:35,360
Y si queremos que el frigorífico 0 en el mensaje sea el frigorífico 1,

509
00:44:35,880 --> 00:44:37,380
pues podemos poner i más 1.

510
00:44:38,139 --> 00:44:43,260
Para que 0 más 1 se convierta en 1 y nos diga, dime la marca del frigorífico 1.

511
00:44:43,980 --> 00:44:48,000
En la siguiente iteración, que i valga 1, pues ya este i más 1 será 2.

512
00:44:48,139 --> 00:44:50,400
Entonces dirá, dime la marca del frigorífico 2.

513
00:44:55,199 --> 00:44:57,719
Y después de eso ponemos los dos puntos, un espacio aquí,

514
00:44:57,719 --> 00:45:01,860
y dejamos el cursor, porque hemos puesto el método print en lugar de println,

515
00:45:02,420 --> 00:45:04,800
justo en esa línea a continuación para meter la marca.

516
00:45:04,800 --> 00:45:11,809
la marca en principio va a ser un string y vamos a querer que termine guardada

517
00:45:14,190 --> 00:45:19,869
la variable se marca que es un atributo de que tienen todos los frigoríficos fijaros que como

518
00:45:21,090 --> 00:45:24,869
bueno pues que es un atributo de clase pues entonces podríamos si queréis cargarlo

519
00:45:24,869 --> 00:45:31,610
directamente en este atributo entonces decimos mi frío y esto que es un frigorífico el que está

520
00:45:31,610 --> 00:45:35,849
en esta iteración trabajando, setMarca

521
00:45:35,849 --> 00:45:44,349
y aquí podríamos poner, ahora después la rompemos esta línea

522
00:45:44,349 --> 00:45:48,250
en varios, myScan.nextLine

523
00:45:53,159 --> 00:45:57,969
¿Cómo se ejecutaría esta línea?

524
00:45:58,909 --> 00:46:02,510
Después de esto se quedaría parada aquí esperando a recibir una información

525
00:46:02,510 --> 00:46:06,349
esto devuelve un string que se pasaría al método setMarca

526
00:46:06,349 --> 00:46:10,650
y el método setMarca se lo asignaría a

527
00:46:10,650 --> 00:46:14,110
ese marca atributo de la clase frigorífico.

528
00:46:15,530 --> 00:46:19,489
Si esto os cuesta verlo todavía un poco, algunos, pues lo que

529
00:46:19,489 --> 00:46:22,889
podríamos hacer es decir, pues mira, vamos a coger en la variable

530
00:46:22,889 --> 00:46:26,789
esta SAUS que habíamos utilizado por aquí, la tenemos, fijaros

531
00:46:26,789 --> 00:46:34,030
aquí, podemos decir SAUS igual a mi scan punto next line, aquí

532
00:46:34,030 --> 00:46:38,469
cojo la marca del frigorífico y la tengo en SAUS y ahora podría

533
00:46:38,469 --> 00:46:41,809
llamar al método setMarca del frigorífico

534
00:46:41,809 --> 00:46:51,139
pasándole ese aus.

535
00:46:52,500 --> 00:46:54,739
Esta línea recoge

536
00:46:54,739 --> 00:46:58,699
estas dos en una sola, como más os guste.

537
00:47:01,429 --> 00:47:02,929
Y bueno, yo creo que no habría mucho más que hacer

538
00:47:02,929 --> 00:47:05,949
con los frigoríficos. Si el número de frigoríficos es mayor que 0

539
00:47:05,949 --> 00:47:08,909
que no lo he archivado aquí, si es 0, no hace

540
00:47:08,909 --> 00:47:12,210
el if, ve frigorífico, lo hemos inicializado

541
00:47:12,210 --> 00:47:15,210
por aquí a false, con lo cual no habría frigoríficos

542
00:47:15,210 --> 00:47:18,590
y el número de frigoríficos sería cero, como hay cero

543
00:47:18,590 --> 00:47:22,869
pues no hemos dimensionado el array de frigoríficos

544
00:47:22,869 --> 00:47:26,269
pues no habría que hacer nada si es cero, y si es mayor que cero

545
00:47:26,269 --> 00:47:30,869
pues entonces es cuando hay algún frigorífico, decimos que si hay algún frigorífico

546
00:47:30,869 --> 00:47:34,989
dimensionamos el array para un frigorífico, para 10, para 20, para los que sea

547
00:47:34,989 --> 00:47:38,909
y con este bucle para cada uno de ellos, creamos

548
00:47:38,909 --> 00:47:41,869
cada uno de los frigoríficos y cogemos su marca

549
00:47:41,869 --> 00:48:11,920
nombre de la cocina recuperar información de frigoríficos vale ahí tenemos el nombre los

550
00:48:11,920 --> 00:48:21,590
frigoríficos pues vamos a por las placas recuperar información de placas vamos a utilizar un poquito

551
00:48:21,590 --> 00:48:31,019
todo lo que podamos por aquí con los copies pegas entonces dice dime el número de placas lo cargamos

552
00:48:31,019 --> 00:48:35,619
y en lugar de guardar la variable de número de frigoríficos lo vamos a guardar en el de número

553
00:48:35,619 --> 00:48:39,179
de placas. Tendremos 0

554
00:48:39,179 --> 00:48:43,559
o n placas. No validamos que sea un número, ya os digo, ya lo haremos

555
00:48:43,559 --> 00:48:47,500
cuando toque eso. Y para cargar información

556
00:48:47,500 --> 00:48:51,739
de las placas, vamos a hacer copy-paste de esto y lo vamos modificando

557
00:48:51,739 --> 00:48:55,239
que va a ser más rápido. Entonces, si el número de placas es mayor que 0

558
00:48:55,239 --> 00:49:04,630
si el número de placas no es mayor que 0, no se ejecuta este

559
00:49:04,630 --> 00:49:08,650
if, el código se vendría por aquí. Entonces ya el número

560
00:49:08,650 --> 00:49:10,769
de placas lo habíamos inicializado por aquí

561
00:49:10,769 --> 00:49:11,869
a cero

562
00:49:11,869 --> 00:49:14,670
y la existencia o no existencia de

563
00:49:14,670 --> 00:49:15,869
placas la habíamos puesto a false.

564
00:49:17,250 --> 00:49:18,429
Si resulta que el número

565
00:49:18,429 --> 00:49:20,530
no es cero, pues entonces

566
00:49:20,530 --> 00:49:22,670
el boolean este de placas

567
00:49:22,670 --> 00:49:24,210
lo primero que hacemos es decir que

568
00:49:24,210 --> 00:49:25,869
hoy hay alguna placa ya

569
00:49:25,869 --> 00:49:28,670
y aquí en el caso

570
00:49:28,670 --> 00:49:31,090
anterior habíamos dimensionado el array de frigoríficos

571
00:49:31,090 --> 00:49:32,550
pues vamos a dimensionar el array

572
00:49:32,550 --> 00:49:36,230
de placas. Decimos

573
00:49:36,230 --> 00:49:38,309
el array de placas

574
00:49:38,309 --> 00:49:40,250
new, pero ahora no, new de

575
00:49:40,250 --> 00:49:51,949
frigoríficos, a ver, perdón, el array de placas aquí y no hacemos un new de frigoríficos

576
00:49:51,949 --> 00:49:57,909
sino que hacemos un new de placas y ahora el número de placas que tenemos es el que

577
00:49:57,909 --> 00:50:03,929
tenemos aquí. Se llama placa la clase, fijaros, placa por aquí, entonces por eso se queja,

578
00:50:03,929 --> 00:50:33,159
placa, tan, ahí lo tenemos, aquí acabamos de dimensionar el número de placas, hacemos un recorrido por cada una de las placas, desde I0 hasta el número de placas y más más y en cada una de estas vueltas estamos trabajando con cada una de las placas, entonces para cada una de las placas que tenemos en el array, hacemos un new para esa placa en particular,

579
00:50:36,980 --> 00:50:44,519
Igual que comentábamos antes para los frigoríficos, aquí fijaros que estamos dimensionando el array, son corchetes, no son paréntesis, no es el constructor.

580
00:50:45,159 --> 00:50:54,239
Y aquí para cada una de ellas, esto es una placa, esto sería el array de placas, si le metemos los corchetes y el i, esto sería una placa en particular.

581
00:50:54,239 --> 00:51:00,400
Esta placa en particular, para ella no hemos hecho el new, porque esto es un array de referencias a placa, lo que acabamos de dimensionar aquí.

582
00:51:00,579 --> 00:51:04,619
Para esta placa le hacemos un new y ahora sí que llamamos al constructor de la placa.

583
00:51:04,619 --> 00:51:13,659
fijaros que aquí es más sencillo que en el caso de los frigoríficos porque hemos hecho el trabajo ya previamente

584
00:51:13,659 --> 00:51:19,079
cuando estamos haciendo el new de la placa, llamamos al constructor que no recibe parámetros

585
00:51:19,079 --> 00:51:23,860
y aquí el constructor que no recibe parámetros, recordad que lo que hacía era llamar al método setColor

586
00:51:23,860 --> 00:51:31,400
y el método setColor de forma aleatoria a través del método random de la clase mat

587
00:51:31,400 --> 00:51:35,460
aplicaba al color de la placa un determinado color, marrón, verde o azul

588
00:51:35,460 --> 00:52:00,030
Con lo cual, para las placas poco más que hacer yo creo por aquí. Y ahora lo que nos decía por aquí el ejercicio es que la clase cocina tendrá como método, este método, el método informof, que es el que nos saca estos resultados en base a, bueno, por la información que tengan los arrays que tiene como atributos.

589
00:52:00,030 --> 00:52:02,349
vamos a construir este método

590
00:52:02,349 --> 00:52:08,239
aquí lo llamamos informof

591
00:52:08,239 --> 00:52:12,760
no me compila de momento

592
00:52:12,760 --> 00:52:13,820
porque no lo tengo construido

593
00:52:13,820 --> 00:52:18,460
el método informof

594
00:52:18,460 --> 00:52:21,539
a ver si nos dice que tiene que devolver el string

595
00:52:21,539 --> 00:52:23,059
o no nos lo indica

596
00:52:23,059 --> 00:52:25,400
habría dos opciones, que el método informof

597
00:52:25,400 --> 00:52:26,900
devuelva un string con esto

598
00:52:26,900 --> 00:52:29,659
y luego mostrarlo desde el main

599
00:52:29,659 --> 00:52:31,440
o que el método informof

600
00:52:31,440 --> 00:52:33,300
directamente haga el system of println

601
00:52:33,300 --> 00:52:37,500
de esto, no veo por aquí

602
00:52:37,500 --> 00:52:38,480
que lo diga o si

603
00:52:38,480 --> 00:52:46,539
construye bueno no parece que sea un requisito ni de una forma ni de otra

604
00:52:47,539 --> 00:52:53,900
bueno vamos a hacer lo que lo escriba directamente informó y luego si no que lo devuelva después si

605
00:52:53,900 --> 00:53:00,980
lo escribe directamente ponemos aquí un public void si lo escribe directamente no necesitamos

606
00:53:00,980 --> 00:53:13,840
que devuelva nada informó hemos decidido en principio que no reciba ningún atributo o sea

607
00:53:13,840 --> 00:53:17,840
ningún parámetro, este método en principio no parece que vaya a ser necesario

608
00:53:17,840 --> 00:53:21,699
porque vamos a trabajar con los atributos de la clase

609
00:53:21,699 --> 00:53:26,219
cocina y precisamente este es un método de la clase cocina, estos atributos

610
00:53:26,219 --> 00:53:29,699
están disponibles para cualquier método de la clase, ¿por qué? porque

611
00:53:29,699 --> 00:53:33,980
pertenecen al ámbito de la cocina y el ámbito de la cocina empieza ahí

612
00:53:33,980 --> 00:53:37,639
y termina aquí, con lo cual están dentro.

613
00:53:39,059 --> 00:53:40,239
Es cierto que

614
00:53:40,239 --> 00:53:45,800
aquí nos está dando un error y el motivo es lo mismo que nos pasaba antes

615
00:53:45,800 --> 00:53:49,280
cuando estábamos hablando de utilizar de forma estática

616
00:53:49,280 --> 00:53:53,780
estos métodos, el nombre de la cocina cuando empezábamos a desarrollar

617
00:53:53,780 --> 00:53:57,699
el main. Y lo que está pasando aquí es que desde el método

618
00:53:57,699 --> 00:54:01,739
main, que según está definido en el ejercicio es un método de la

619
00:54:01,739 --> 00:54:05,340
clase cocina, es estático, con lo cual se podría estar ejecutando

620
00:54:05,340 --> 00:54:09,760
para cualquier cocina. Y aquí estamos llamando a un método

621
00:54:09,760 --> 00:54:13,619
informof que no es estático, es decir, cada cocina en particular

622
00:54:13,619 --> 00:54:17,340
tendría su método informof. Entonces dice, informof

623
00:54:17,340 --> 00:54:21,940
exactamente de qué cocina quieres informarme. Fijaros, aquí

624
00:54:21,940 --> 00:54:26,199
podríamos tener cocina, coz1

625
00:54:26,199 --> 00:54:29,400
igual año cocina

626
00:54:29,400 --> 00:54:36,650
el ejercicio solo nos pide una cocina, pero bueno, para justificar

627
00:54:36,650 --> 00:54:41,269
por qué no nos está compilando. Fijaros que aquí tenemos dos cocinas y podríamos

628
00:54:41,269 --> 00:54:45,150
tenemos que tener claro, definidas muchas más, cada una de estas dos cocinas

629
00:54:45,150 --> 00:54:49,489
al no ser este método estático, tendrá, digamos, la posibilidad

630
00:54:49,489 --> 00:54:53,289
de ejecutar su propio método informof. Y aquí estamos llamando a un

631
00:54:53,289 --> 00:54:57,510
informof y hay ambigüedad, porque dice de la cocina 1, de la cocina 2,

632
00:54:57,969 --> 00:55:01,150
de otras cocinas que puedas definir por ahí, no tengo ni idea.

633
00:55:02,250 --> 00:55:06,690
Si pusiéramos esto, pues ya me compilaría y diría

634
00:55:06,690 --> 00:55:10,489
ya no hay lugar a dudas, este método informof está diciendo que es

635
00:55:10,489 --> 00:55:13,429
que se ejecute justo el método relativo a la cocina 1

636
00:55:13,429 --> 00:55:15,690
no a la cocina 2, no hay ambigüedad, compilo

637
00:55:15,690 --> 00:55:20,090
en este ejercicio nos podemos permitir el lujo

638
00:55:20,090 --> 00:55:23,550
de convertir este método también en static

639
00:55:23,550 --> 00:55:27,010
entonces ya me compila perfectamente

640
00:55:27,010 --> 00:55:29,929
porque hay ambigüedades ahora de que método

641
00:55:29,929 --> 00:55:33,190
informof se va a ejecutar si lo llamo aquí

642
00:55:33,190 --> 00:55:36,110
sin indicar un objeto de la clase cocina

643
00:55:36,110 --> 00:55:39,590
no, ninguno, si este método es común absolutamente a todas las cocinas

644
00:55:39,590 --> 00:55:41,369
pues ya está, es el único que hay

645
00:55:41,369 --> 00:55:45,889
desde un sitio estático, estamos llamando a un sitio estático

646
00:55:45,889 --> 00:55:49,650
no hay problema en ningún caso porque todo pertenece a la clase cocina

647
00:55:49,650 --> 00:55:53,829
pues ya está, este es el método que pertenece a la clase cocina y está compartido con

648
00:55:53,829 --> 00:55:57,429
todos los objetos posibles que tengamos definidos de cocinas

649
00:55:57,429 --> 00:56:05,199
dentro del código. Una vez que me compila, pues nada, pues a trabajar

650
00:56:05,199 --> 00:56:08,539
un poco con el ejercicio. Aquí

651
00:56:08,539 --> 00:56:14,460
lo que podemos hacer es poner un system.out.println

652
00:56:14,460 --> 00:56:33,480
Bueno, pues podemos primero definir un string aquí, ese mensaje o esa información, ese mens, y decir que es lo que voy a escribir aquí.

653
00:56:35,599 --> 00:56:44,420
Y ahora podríamos dentro de aquí entre medias construir el mensaje que quiero escribir por pantalla y mostrarlo aquí al final.

654
00:56:44,420 --> 00:56:52,760
por ser los atributos de clases

655
00:56:52,760 --> 00:56:57,420
compila aunque no los inicialices, pero las variables locales tienes que

656
00:56:57,420 --> 00:56:59,059
inicializarlas, si no, no compila

657
00:56:59,059 --> 00:57:04,340
aquí se queja y dice, oye, está sin asignar ningún valor

658
00:57:04,340 --> 00:57:11,519
si ya tienes los inicializados, pues ya dice, vale, me parece bien

659
00:57:11,519 --> 00:57:17,449
compilo, me gusta, entonces bueno, el mensaje

660
00:57:17,449 --> 00:57:21,469
si os acordáis, por aquí tenemos

661
00:57:21,469 --> 00:57:25,670
diferentes opciones de mensaje. Todos los mensajes tienen aquí un bloque

662
00:57:25,670 --> 00:57:28,750
que es común y siempre aparece porque todas las cocinas tienen

663
00:57:28,750 --> 00:57:33,269
un nombre. Ya está, pues podemos empezar construyéndolo con esto

664
00:57:33,269 --> 00:57:37,630
y luego ya en función de si hay frigoríficos o no hay placas y el número de frigoríficos

665
00:57:37,630 --> 00:57:41,250
y placas que hay, pues construimos el resto

666
00:57:41,250 --> 00:57:45,489
del mensaje. Pero este bloque sí que es común. Entonces, como

667
00:57:45,489 --> 00:57:49,309
ese bloque es común y siempre va a salir una vez que hagamos el System of Println

668
00:57:49,309 --> 00:58:00,849
pues lo podemos poner aquí decimos la cocina y el nombre de la cocina lo tenemos aquí en esta

669
00:58:00,849 --> 00:58:14,090
variable y luego podemos aquí poner un espacio que nos separe el nombre de la cocina es lo que

670
00:58:14,090 --> 00:58:25,840
le está pasando aquí más aquí después del nombre de la cocina siempre hay un espacio y bueno hay

671
00:58:25,840 --> 00:58:32,199
un espacio bueno pone tiene o no tiene o sea que ahí habría que jugar con esto este mensaje ahora

672
00:58:32,199 --> 00:58:36,340
vamos a construir el mensaje de no tiene frigoríficos o tiene el número

673
00:58:36,340 --> 00:58:40,059
de frigoríficos que sea. Y luego ya después, pues trabajaremos

674
00:58:40,059 --> 00:58:43,559
para construir la parte de las placas.

675
00:58:48,659 --> 00:58:52,280
Para el número de frigoríficos, pues tendremos que comprobar

676
00:58:52,280 --> 00:58:56,579
si hay frigoríficos. Tenemos la verdad duplicada de información

677
00:58:56,579 --> 00:59:00,460
aquí, porque aquí sabemos si hay frigoríficos o no, pero ya que hemos definido

678
00:59:00,460 --> 00:59:03,599
esta variable de si hay frigoríficos booleana, vamos a utilizarla.

679
00:59:03,599 --> 00:59:07,800
estas variables en verdad, hubieran sido

680
00:59:07,800 --> 00:59:11,260
prescindibles, porque el dato de si lo hay o no lo hay, lo tenemos aquí

681
00:59:11,260 --> 00:59:15,119
mirando a ver si el número de frigoríficos y de placas es cero o no lo es

682
00:59:15,119 --> 00:59:19,820
pero bueno, ya que lo tenemos, vamos a decir, si hay frigoríficos

683
00:59:19,820 --> 00:59:26,480
pues tendrá que pasar algo, y si no hay frigoríficos

684
00:59:26,480 --> 00:59:40,579
pues tendrá que pasar algo también, a ver como es

685
00:59:40,579 --> 00:59:47,500
el mensaje, si no tiene frigoríficos nos iremos por el else

686
00:59:47,500 --> 00:59:50,360
y si tiene frigoríficos, pues dice

687
00:59:50,360 --> 00:59:54,099
tiene el número de frigorífico, bueno si es uno

688
00:59:54,099 --> 00:59:57,760
frigorífico y si son varios, frigoríficos

689
00:59:57,760 --> 01:00:00,780
bueno, pues esto podemos ir trabajándolo con if else

690
01:00:00,780 --> 01:00:03,480
vamos a, desde luego

691
01:00:03,480 --> 01:00:06,139
habremos ido por la zona de frigoríficos

692
01:00:06,139 --> 01:00:08,579
para todas estas, tiene que poner tiene

693
01:00:08,579 --> 01:00:11,280
un y frigorífico, frigoríficos

694
01:00:11,280 --> 01:00:17,019
si llegamos aquí, podemos decir ese mensaje

695
01:00:17,019 --> 01:00:22,639
será igual a ese mensaje, ¿verdad? Para no perder lo que tenemos hasta ahora.

696
01:00:23,559 --> 01:00:27,059
Aquí, si he entrado por aquí y resulta que tiene frigoríficos, pues ponemos

697
01:00:27,059 --> 01:00:32,489
tiene más y el número de frigoríficos

698
01:00:32,489 --> 01:00:50,659
lo tenemos en esta variable. Y ahora, después

699
01:00:50,659 --> 01:00:57,510
de este número, hay que poner o frigorífico o frigoríficos.

700
01:00:57,670 --> 01:01:01,250
Si es uno, será frigorífico. Si es más de uno, sería frigoríficos.

701
01:01:25,619 --> 01:01:28,340
El espacio se lo he puesto ya aquí, entonces no se lo pongo aquí.

702
01:01:28,340 --> 01:01:35,119
y si le voy a poner un espacio para luego después

703
01:01:35,119 --> 01:01:38,760
y si no, pues aquí sería frigoríficos

704
01:01:38,760 --> 01:01:44,260
y si nos hemos venido por aquí, que este es el else

705
01:01:44,260 --> 01:01:49,699
entonces el mensaje tendrá que ser

706
01:01:49,699 --> 01:01:51,260
que no tiene frigoríficos

707
01:01:51,260 --> 01:01:57,159
a ver cómo es exactamente, no lo dice el enunciado

708
01:01:57,159 --> 01:02:01,300
no tiene frigoríficos

709
01:02:01,300 --> 01:02:16,269
hasta aquí hemos construido por aquí el nombre

710
01:02:16,269 --> 01:02:20,130
y yo creo que aquí tenemos construido los frigoríficos

711
01:02:20,130 --> 01:02:31,269
no sé si nos falta algo, si no luego con la ejecución

712
01:02:31,269 --> 01:02:44,400
lo retocamos. Y ahora vamos a trabajar

713
01:02:44,400 --> 01:02:48,269
con las placas. Decimos

714
01:02:48,269 --> 01:02:52,349
if, vamos a ver si tiene placas o no

715
01:02:52,349 --> 01:02:55,269
bPlaca

716
01:02:55,269 --> 01:02:57,349
aquí

717
01:02:57,349 --> 01:03:01,170
tenemos garantía de que hay alguna

718
01:03:01,170 --> 01:03:04,130
placa, una o varias, pero hay placas

719
01:03:04,130 --> 01:03:16,829
y por aquí no hay placas. Vamos primero

720
01:03:16,829 --> 01:03:26,650
que es más cortito por aquí tendríamos toda la jugada de los frigoríficos y no tiene placas

721
01:03:26,650 --> 01:03:37,380
si no hay placas pues por aquí tenemos que poner y no tiene placas pues ahora vamos a ponerlo por

722
01:03:37,380 --> 01:03:50,000
aquí y por aquí estamos donde sí que hay placas bueno aquí nos falta por poner las marcas es

723
01:03:50,000 --> 01:03:59,659
verdad en caso de que tenga frigoríficos no sé si tiene un frigorífico de marca favor de marcas

724
01:03:59,659 --> 01:04:09,360
vaya vale ahí bueno pues tenemos que poner esto de las marcas frigorífico de marca tiene un

725
01:04:09,360 --> 01:04:20,780
frigorífico de marca vamos a abrir el paréntesis y por aquí tenemos que recorrer el bueno si es

726
01:04:20,780 --> 01:04:26,619
un solo frigorífico entonces sería mucho más directo en el caso de ser uno porque diríamos

727
01:04:26,619 --> 01:04:34,960
esto más está en la posición como son solo frigorífico pues será la posición 0 de la

728
01:04:34,960 --> 01:04:47,849
raíz primero de los frigoríficos posición 0 punto get perdón frigorífico no eso es el nombre de la

729
01:04:47,849 --> 01:05:05,719
clase mirar fríos de frigoríficos posición 0 punto get marca y luego cerramos esto es así

730
01:05:05,719 --> 01:05:20,059
es como queda con un frigorífico solo y luego un espacio para lo de las placas, espacio y si tienen

731
01:05:20,059 --> 01:05:32,460
más de un frigorífico pues sería frigoríficos de marcas y aquí tendremos que hacer un recorrido

732
01:05:32,460 --> 01:05:51,449
por el bucle, con un for, le decimos for inti igual a cero mientras i sea menor que el número

733
01:05:51,449 --> 01:06:03,219
de frigoríficos y más más. Y cada uno de los frigoríficos pues tendrá que añadir su marca.

734
01:06:03,219 --> 01:06:11,119
pues lo que cogeremos será esto

735
01:06:11,119 --> 01:06:15,530
aquí en lugar de 0 tendrá que ser i

736
01:06:15,530 --> 01:06:18,570
esto habrá que añadirlo al mensaje

737
01:06:18,570 --> 01:06:28,869
y a ver cómo es el texto exactamente

738
01:06:28,869 --> 01:06:33,869
y hay un espacio por lo que veo por aquí

739
01:06:33,869 --> 01:06:35,710
para cada uno de estos hay un espacio

740
01:06:35,710 --> 01:06:37,170
pues vamos a meterle un espacio

741
01:06:37,170 --> 01:06:39,809
para separar cada uno de ellos

742
01:06:39,809 --> 01:06:45,519
más un espacio

743
01:06:45,519 --> 01:06:51,360
y luego el mensaje

744
01:06:51,360 --> 01:06:53,920
cuando ya han terminado todos

745
01:06:53,920 --> 01:07:07,380
que cierre el paréntesis, es cierto, luego si queréis

746
01:07:07,380 --> 01:07:10,980
incluso lo intentamos manejar, algún paréntesis me falta

747
01:07:10,980 --> 01:07:15,159
que el último no tendría este espacio para que cierre el paréntesis junto a la marca

748
01:07:15,159 --> 01:07:19,280
del último, lo podemos intentar luego si os parece

749
01:07:19,280 --> 01:07:22,659
lo manejamos aquí o lo dejamos así tal cual, a ver

750
01:07:22,659 --> 01:07:35,900
que es lo que me pasa por aquí, este me sobra, bueno vamos a meter

751
01:07:35,900 --> 01:07:39,880
las placas, dice aquí no tiene placas, en caso de tener placas pues será algo

752
01:07:39,880 --> 01:07:48,820
parecido a esto, en verdad, voy a hacer un copia y pega y lo adaptamos

753
01:07:48,820 --> 01:07:58,110
en lugar de decir aquí tiene inund de frigoríficos, habrá que decir el número

754
01:07:58,110 --> 01:08:04,239
de placas, aquí lo cogemos, el número de placas

755
01:08:04,239 --> 01:08:13,500
tiene estas placas, si es un solo frigorífico

756
01:08:13,500 --> 01:08:17,720
a ver, el formato para poner el color también es así, es

757
01:08:17,720 --> 01:08:24,449
el mismo estilo, entonces array de frigoríficos no

758
01:08:24,449 --> 01:08:31,140
sino tendrá que ser el array de placas, mi array de

759
01:08:31,140 --> 01:09:12,029
placas por aquí, placa de color y en lugar de get marca, punto get color, ahí está y si tiene más, tiene placas de colores y hacemos un recorrido en el bucle igual que habíamos hecho antes con los frigoríficos, sobre el array de frigoríficos recuperando sus colores, se van asignando al mensaje y luego cerramos por aquí,

760
01:09:12,050 --> 01:09:20,149
bueno, podemos hacer un intento de ejecución, a ver qué pasa

761
01:09:20,149 --> 01:09:26,920
en otras tutorías os he dicho que quizás no sea lo más recomendable

762
01:09:26,920 --> 01:09:29,739
bueno, pues como lo hago yo aquí en las tutorías

763
01:09:29,739 --> 01:09:34,600
de meter todo el código y no lanzar ninguna ejecución, siempre es mucho más

764
01:09:34,600 --> 01:09:38,560
aconsejable, sobre todo cuando estéis empezando, ir haciendo ejecuciones

765
01:09:38,560 --> 01:09:42,579
parciales para ir detectando posibles errores que vayáis teniendo

766
01:09:42,579 --> 01:09:46,500
y así normalmente los errores que vayan apareciendo

767
01:09:46,500 --> 01:09:50,520
de una ejecución a otra, pues estarán integrados dentro

768
01:09:50,520 --> 01:09:54,479
del último código que habéis puesto. Si hacéis todo y ahora no funciona, pues

769
01:09:54,479 --> 01:09:58,239
en verdad tenemos mucho código donde mirar para intentar resolverlo. Mejor ir haciendo

770
01:09:58,239 --> 01:10:02,020
ejecuciones parciales e ir probando cosas poco a poco. Bueno,

771
01:10:02,260 --> 01:10:08,220
ya que no lo he hecho, pues vamos a ver qué pasa. Dice, ¿cómo se llama

772
01:10:08,220 --> 01:10:13,420
la cocina? Es la cocina primavera, vamos a llamarla.

773
01:10:19,020 --> 01:10:22,880
La cocina primavera tiene, vamos a decir que no tiene frigoríficos de momento.

774
01:10:23,880 --> 01:10:28,119
Fijaros, he puesto un System of Print LN aquí, que decía que no lo iba a poner.

775
01:10:29,039 --> 01:10:32,340
Y dice, dime el número de placas de primavera. Decimos que no tiene tampoco placas.

776
01:10:34,439 --> 01:10:38,479
Bueno, y de momento, este primer mensaje parece que ha salido como esperábamos.

777
01:10:40,479 --> 01:10:45,659
A ver, ahora, en cambio, la cocina otoño tiene un frigorífico.

778
01:10:46,699 --> 01:10:49,880
Y la marca del frigorífico es Fagor.

779
01:10:49,880 --> 01:10:53,399
y tiene una placa

780
01:10:53,399 --> 01:10:56,430
entonces le dicen

781
01:10:56,430 --> 01:10:58,729
Toño tiene un frigorífico de marca Fagor

782
01:10:58,729 --> 01:11:01,029
nos hemos comido un i

783
01:11:01,029 --> 01:11:02,989
que había en el otro sitio pero bueno sería cuestión

784
01:11:02,989 --> 01:11:04,989
de ponerlo en el texto justo antes del

785
01:11:04,989 --> 01:11:06,930
del tiene y tiene

786
01:11:06,930 --> 01:11:08,149
una placa de color verde

787
01:11:08,149 --> 01:11:13,470
la verano

788
01:11:13,470 --> 01:11:16,050
resulta que tiene tres

789
01:11:16,050 --> 01:11:18,970
frigoríficos de marca Fagor

790
01:11:18,970 --> 01:11:21,550
Zanussi

791
01:11:21,550 --> 01:11:23,350
y vos

792
01:11:23,350 --> 01:11:29,840
y va a tener tres placas también, pues nada, no sale bien

793
01:11:29,840 --> 01:11:34,140
fijaros este espacio, nos falta el i, aquí justo no lo he separado y aquí

794
01:11:34,140 --> 01:11:38,300
hay un espacio de más, bueno, pues sería cosa que podríamos manejar

795
01:11:38,300 --> 01:11:42,319
ahí dentro del código, y vamos a hacer

796
01:11:42,319 --> 01:11:46,319
alguna prueba con la combinación de que tenga frigoríficos y no tenga

797
01:11:46,319 --> 01:11:54,760
placas y de que tenga placas y no tenga frigoríficos, la invierno

798
01:11:54,760 --> 01:12:02,359
pues esta si va a tener frigoríficos, vamos a decir que tiene dos frigoríficos

799
01:12:02,359 --> 01:12:04,340
Zagor

800
01:12:04,340 --> 01:12:06,899
y Zanussi

801
01:12:06,899 --> 01:12:09,380
no sé si Zanussi es con dos S ahora mismo

802
01:12:09,380 --> 01:12:11,380
pero bueno, y cero placas

803
01:12:11,380 --> 01:12:13,539
parece que le va

804
01:12:13,539 --> 01:12:19,210
y luego

805
01:12:19,210 --> 01:12:21,850
vamos a crear una

806
01:12:21,850 --> 01:12:23,789
cocina para nosotros, para Adam

807
01:12:23,789 --> 01:12:25,770
que no tenga frigoríficos

808
01:12:25,770 --> 01:12:27,909
y en cambio tiene seis placas

809
01:12:27,909 --> 01:12:30,029
uno, dos, tres

810
01:12:30,029 --> 01:12:31,710
cuatro, cinco, seis, el random también

811
01:12:31,710 --> 01:12:34,229
funciona, hay variedad aquí de colores

812
01:12:34,229 --> 01:12:37,810
y dice que no tiene frigoríficos por aquí.

813
01:12:38,750 --> 01:12:41,090
Bueno, pues parece que en general funciona el programa.

814
01:12:42,949 --> 01:12:45,229
Con algún pequeño ajuste por aquí.

815
01:12:47,920 --> 01:12:50,600
Aquí habría que poner un y no tiene frigoríficos.

816
01:13:02,510 --> 01:13:06,130
No, y no tiene frigoríficos, no sé, y no tiene placas, perdón.

817
01:13:09,630 --> 01:13:11,069
Ah, pues y no tiene placas.

818
01:13:11,510 --> 01:13:13,270
¿No ha salido la i antes? No sé.

819
01:13:15,069 --> 01:13:17,329
Y placas, este de aquí. Y placas de colores.

820
01:13:17,329 --> 01:13:52,569
Bueno, había un espacio por ahí también. No vale la pena mucho enredar con esto. ¿Alguna preguntilla tenéis? ¿Más o menos se entiende bien todo el desarrollo? ¿No? ¿Todo bien? ¿Seguís por ahí, verdad? Vale, pues nada, la tarea esta la dejamos ya cerrada.

821
01:13:52,569 --> 01:13:54,529
si queréis

822
01:13:54,529 --> 01:13:56,689
un ratito más

823
01:13:56,689 --> 01:13:58,569
porque todavía son menos cuarto

824
01:13:58,569 --> 01:14:00,789
si no tenéis ninguna pregunta

825
01:14:00,789 --> 01:14:02,369
de esto en general

826
01:14:02,369 --> 01:14:04,810
pues si queréis podemos

827
01:14:04,810 --> 01:14:06,869
plantear un poco

828
01:14:06,869 --> 01:14:09,210
el ejercicio, no sé los que estuvisteis

829
01:14:09,210 --> 01:14:10,829
de vosotros, algunos

830
01:14:10,829 --> 01:14:12,970
que estuvisteis, de los que estáis

831
01:14:12,970 --> 01:14:14,989
en la tutoría, si queréis podemos

832
01:14:14,989 --> 01:14:17,329
plantear un poco, por ejemplo, el segundo ejercicio

833
01:14:17,329 --> 01:14:19,289
que había

834
01:14:19,289 --> 01:14:20,409
para desarrollar que

835
01:14:20,409 --> 01:14:25,850
se recibía un array de personas me parece o el primero de ellos que entre un número había que

836
01:14:25,850 --> 01:14:33,909
buscar aquellos que era múltiplo de 7 y que terminaban en 4 alguno de esos podemos hacer

837
01:14:33,909 --> 01:14:41,689
si queréis y con eso ya hacemos un ratito más y terminamos la tutoría si no te si no tenéis nada

838
01:14:41,689 --> 01:14:52,199
así en particular que queráis ver bueno vamos a hacer eso vamos a utilizar este proyecto mismo

839
01:14:52,199 --> 01:15:06,939
lo borro directamente

840
01:15:06,939 --> 01:15:09,619
bueno, lo mantengo

841
01:15:09,619 --> 01:15:11,680
por si acaso queremos retomar el ejercicio

842
01:15:11,680 --> 01:15:12,380
en algún momento

843
01:15:12,380 --> 01:15:15,560
bueno, pues

844
01:15:15,560 --> 01:15:17,539
uno de los ejercicios planteaba

845
01:15:17,539 --> 01:15:20,460
pedir números

846
01:15:20,460 --> 01:15:23,000
era pedir números

847
01:15:23,000 --> 01:15:23,640
hasta

848
01:15:23,640 --> 01:15:26,380
no me acuerdo

849
01:15:26,380 --> 01:15:27,600
cómo era el enunciado, la verdad

850
01:15:27,600 --> 01:15:30,220
entre dos

851
01:15:30,220 --> 01:15:31,899
determinados valores

852
01:15:31,899 --> 01:15:33,600
bueno, pero eso era muy fácil, yo creo

853
01:15:33,600 --> 01:15:36,680
un ejercicio pedía

854
01:15:36,680 --> 01:15:40,539
acumular el valor

855
01:15:40,539 --> 01:15:44,659
de números que estuvieran entre un rango o algo así

856
01:15:44,659 --> 01:15:47,800
había que hacer un método, me parece recordar

857
01:15:47,800 --> 01:15:56,039
vamos a definir aquí un método, por ejemplo, y si no es justo el del examen

858
01:15:56,039 --> 01:15:59,260
es que no me acuerdo exactamente del enunciado, pues algo parecido y ya está

859
01:15:59,260 --> 01:16:02,739
vamos a llamarlo método

860
01:16:02,739 --> 01:16:06,079
y que reciba int

861
01:16:06,079 --> 01:16:08,520
y val uno

862
01:16:08,520 --> 01:16:13,960
int y val dos

863
01:16:13,960 --> 01:16:21,750
que no devuelva nada

864
01:16:21,750 --> 01:16:30,189
yo creo que he borrado cosas de más

865
01:16:30,189 --> 01:16:32,109
es que he borrado el main

866
01:16:32,109 --> 01:16:49,539
lo he comentado

867
01:16:49,539 --> 01:16:50,180
ahí está

868
01:16:50,180 --> 01:16:53,500
bueno entonces vamos a definir

869
01:16:53,500 --> 01:16:54,520
lo static también

870
01:16:54,520 --> 01:16:57,420
y vamos a llamar al método

871
01:16:57,420 --> 01:16:58,220
con dos valores

872
01:16:58,220 --> 01:17:15,979
luego hacemos variantes si es necesario

873
01:17:15,979 --> 01:17:46,229
Entonces uno de los ejercicios pedía que sacáramos el resultado de sumar valores comprendidos entre estos dos, que fuesen o bien múltiplo de un número, vamos a poner 7, o que terminase en 4, algo así.

874
01:17:47,489 --> 01:17:56,229
Pues lógicamente lo primero que tenemos que hacer es, bueno, pues vamos a definir una variable donde ir guardando el resultado final.

875
01:17:56,949 --> 01:18:15,329
El enunciado, yo leyéndolo me daba la impresión de que podía dar la interpretación de que o bien terminar de hacer un resultado para los que terminasen en 4 y otro resultado para los que terminasen en 7 o que simultáneamente tuviera que cumplir los dos valores.

876
01:18:15,329 --> 01:18:20,550
como él me parecía que estaba un poquito ambiguo el denunciado pues a los que lo habéis planteado

877
01:18:20,550 --> 01:18:24,390
de una forma me lo he puesto como bien y en los que lo habéis planteado de otra forma pues también

878
01:18:24,390 --> 01:18:29,569
como bien al final el trabajo en la algoritmia con el programa era muy parecido y bueno pues

879
01:18:29,569 --> 01:18:36,199
era un poco lo que buscaba no entonces bueno pues mirad podemos definir una variable una

880
01:18:36,199 --> 01:18:44,409
variable resultado digamos que vale 0 y esta palabra va a ser donde vamos a ir acumulando

881
01:18:44,409 --> 01:18:52,489
pues en los vamos a ir sumando aquellos valores que estén comprendidos entre estos dos y que y

882
01:18:52,489 --> 01:19:00,630
que cumplan esta condición como vamos a recorrer todo ello pues podemos definir un bucle que

883
01:19:00,630 --> 01:19:10,210
típicamente inicializamos los for lo hemos hecho por aquí para los arrays entre voy a tener que

884
01:19:10,210 --> 01:19:16,460
quitar todo esto, porque si no, no me va a permitir ejecutarlo.

885
01:19:16,840 --> 01:19:19,180
Lo solemos inicializar desde cero, en este caso

886
01:19:19,180 --> 01:19:20,699
como queremos ir desde este valor

887
01:19:20,699 --> 01:19:25,520
mientras i sea menor que el valor definitivo

888
01:19:25,520 --> 01:19:27,920
aquí vamos a ir entre estos dos valores

889
01:19:27,920 --> 01:19:30,039
justo, que es una de las cosas que nos pide

890
01:19:30,039 --> 01:19:33,899
y como queremos recorrer todos ellos, pues le hacemos

891
01:19:33,899 --> 01:19:41,520
un i++. Y ahora, bueno, pues tenemos que buscar

892
01:19:41,520 --> 01:19:44,560
la condición de que o bien sea

893
01:19:44,560 --> 01:19:47,239
múltiplo de 7 o bien termine en 0.

894
01:19:47,760 --> 01:20:05,020
Entonces la forma de comprobar si un número es múltiplo de otro, pues es dividir entre ese número y en lugar de fijarnos en el resultado de la división, pues no vamos al resto. Si el resto es cero, pues resulta que es que efectivamente ese número es divisible por el que estamos dividiendo.

895
01:20:05,020 --> 01:20:08,359
entonces podríamos coger y decir if

896
01:20:08,359 --> 01:20:12,399
sí, y en particular con el que estemos trabajando ahora

897
01:20:12,399 --> 01:20:15,859
tanto por ciento, que es el que nos da el resto

898
01:20:15,859 --> 01:20:20,539
siete, claro esto no va a dar un número y aquí necesitamos

899
01:20:20,539 --> 01:20:23,380
una condición que se pueda evaluar como verdadera o falsa

900
01:20:23,380 --> 01:20:28,779
entonces, si esto resulta que es igual a cero

901
01:20:28,779 --> 01:20:35,609
quiere decir que este número, el que estamos

902
01:20:35,609 --> 01:20:39,970
con el que estamos trabajando en esta iteración del for, es divisible entre 7.

903
01:20:42,470 --> 01:20:52,159
Entonces podríamos coger y decir aquí result, es igual a result más i.

904
01:20:56,520 --> 01:21:01,600
Bueno, aquí lo tendríamos si es divisible entre 7.

905
01:21:03,100 --> 01:21:07,579
Y para ver si termina en 4, pues lo que podríamos hacer es,

906
01:21:07,579 --> 01:21:25,260
Entonces la forma más rápida que se me ocurre a mí es muy parecida a esta, ¿verdad? Poner aquí un else if y lo que podemos hacer es sacar el resto pero dividirlo por 10.

907
01:21:25,260 --> 01:21:28,800
entonces el resto si es igual a 4

908
01:21:28,800 --> 01:21:32,100
pues quiere decir que el número con el que estamos trabajando es un 4

909
01:21:32,100 --> 01:21:36,640
si el i en este caso vale 34

910
01:21:36,640 --> 01:21:40,359
pues al dividir entre 10 nos quedará 3

911
01:21:40,359 --> 01:21:44,260
y el resto 4, esto como nos devuelve el resto

912
01:21:44,260 --> 01:21:48,779
si resulta que el resto ha sido igual a 4, pues resulta que ese número termina en 4

913
01:21:48,779 --> 01:21:52,020
de la forma yo creo más rápida

914
01:21:52,020 --> 01:21:55,859
luego hay alternativas, ahora después de hacer esta

915
01:21:55,859 --> 01:22:02,239
intentamos probar alguna otra, bueno, en este caso también

916
01:22:02,239 --> 01:22:06,220
le sumaríamos esto, fijaros aquí lo que estamos haciendo es

917
01:22:06,220 --> 01:22:10,039
poner, con las dos alternativas

918
01:22:10,039 --> 01:22:13,720
estas denunciado que os decía, estamos acumulando el resultado

919
01:22:13,720 --> 01:22:18,039
tanto si es divisible por 7 como si

920
01:22:18,039 --> 01:22:22,260
termina en 4, en ambos casos lo que hacemos es acumular

921
01:22:22,260 --> 01:22:24,079
el valor que tenga ahí en esta

922
01:22:24,079 --> 01:22:26,659
iteración del for al resultado.

923
01:22:26,880 --> 01:22:29,960
Se lo sumamos. Si por el

924
01:22:29,960 --> 01:22:31,899
contrario decidiésemos que es que tiene que

925
01:22:31,899 --> 01:22:33,720
cumplir las dos condiciones, porque así lo

926
01:22:33,720 --> 01:22:35,880
interpretamos del enunciado, pues entonces habría que poner

927
01:22:35,880 --> 01:22:36,319
un if

928
01:22:36,319 --> 01:22:38,539
de este tipo.

929
01:22:39,579 --> 01:22:40,640
Si el número

930
01:22:40,640 --> 01:22:42,960
es divisible por 7

931
01:22:42,960 --> 01:22:48,439
y termina en 4,

932
01:22:55,069 --> 01:22:56,250
en ese caso sería cuando

933
01:22:56,250 --> 01:22:57,829
acumularíamos el resultado.

934
01:22:58,310 --> 01:23:00,149
En este caso tendrían que ser las dos condiciones

935
01:23:00,149 --> 01:23:02,350
simultáneas. Ya os digo, depende

936
01:23:02,350 --> 01:23:06,210
de cómo se interpreta el enunciado a la hora de leerlo.

937
01:23:06,729 --> 01:23:10,489
Estas son las dos simultáneas y en esta una u otra.

938
01:23:11,810 --> 01:23:15,130
Si resulta que no es divisible por 7 ni termina en 4,

939
01:23:15,609 --> 01:23:17,569
pues nada, no se ejecuta ni el if ni el else,

940
01:23:17,689 --> 01:23:20,949
con lo cual no se acumula nada por aquí,

941
01:23:20,949 --> 01:23:22,590
y no se acumula nada, pues ya está.

942
01:23:23,689 --> 01:23:27,930
Y luego el método, si queremos que saque por pantalla el resultado,

943
01:23:27,930 --> 01:23:30,970
pues una vez acabado el for

944
01:23:30,970 --> 01:23:34,329
pues podríamos hacer aquí un system.out.println

945
01:23:34,329 --> 01:23:50,500
o que terminen

946
01:23:50,500 --> 01:23:54,439
en 4 entre

947
01:23:54,439 --> 01:24:06,729
si alguien pregunta que no entiende para qué estamos acumulando

948
01:24:06,729 --> 01:24:08,750
porque ha denunciado

949
01:24:08,750 --> 01:24:12,670
que estamos planteando para el ejercicio que igual no era justo

950
01:24:12,670 --> 01:24:15,770
el del examen pero el que estoy planteando yo a la hora de hacerlo

951
01:24:15,770 --> 01:24:18,569
aquí es que el resultado a sacar

952
01:24:18,569 --> 01:24:29,550
sea la suma de todos los números comprendidos entre estos dos

953
01:24:29,550 --> 01:24:33,010
y que cumplan esta condición.

954
01:24:33,770 --> 01:24:36,210
Entonces, para que sea la suma, al principio es 0

955
01:24:36,210 --> 01:24:40,590
y luego ya vamos acumulando el número que toca al resultado

956
01:24:40,590 --> 01:24:43,930
para que con todo acumulado termine saliendo por aquí.

957
01:24:48,659 --> 01:24:52,920
Vale, pues entonces sería la suma de los números divisibles por 7 y por 4.

958
01:24:52,920 --> 01:24:57,739
Bueno, esto es para adornar el resultado que quede un poquito más acorde a lo que dice el enunciado.

959
01:24:59,380 --> 01:25:24,239
Entre, y ponemos, y, ponemos aquí, es, y ahora ya por fin ponemos lo que de verdad es el resultado.

960
01:25:24,680 --> 01:25:25,619
Es aquí el irresol.

961
01:25:25,899 --> 01:25:33,680
Aquí me falta un más y, bueno, pues vamos a hacer una ejecución.

962
01:25:33,680 --> 01:25:41,710
dice los números, entre 4 y 100 es, bueno, pues nos da este número

963
01:25:41,710 --> 01:25:45,869
que en principio no lo tenemos que creer, vamos a hacer una llamada

964
01:25:45,869 --> 01:25:50,010
con unos números que se pueda calcular, por ejemplo, vamos a poner

965
01:25:50,010 --> 01:25:57,529
entre 3, que aparece el 4, y entre 8, con lo cual tenemos un 4

966
01:25:57,529 --> 01:26:02,130
y tenemos el 7, 7 más 4, 11 debería dar de resultado, yo creo esto.

967
01:26:02,130 --> 01:26:27,029
Bueno, pues nos dice el 11. Vamos a poner entre 3 y 14. El 14 es divisible por 7 y además termina en 4. Entonces tendríamos el 4, tendríamos el 7 y el 14.

968
01:26:27,029 --> 01:26:31,649
4, 7 y 14, entonces sería 14 más 4, 18 más 7

969
01:26:31,649 --> 01:26:37,260
yo creo que debería dar 25, vamos a ver, pues no

970
01:26:37,260 --> 01:26:50,760
es 11, debería dar el 4, el 7

971
01:26:50,760 --> 01:26:55,720
ah vale, bien, ya sé lo que ha pasado

972
01:26:55,720 --> 01:26:59,779
lo que ha pasado es que aquí le he puesto la condición

973
01:26:59,779 --> 01:27:04,060
de que i sea menor que i val 2, con lo cual como he puesto menor

974
01:27:04,060 --> 01:27:07,979
no está considerando el 14, se ha quedado en el 13

975
01:27:07,979 --> 01:27:12,829
tendré que poner aquí que sea menor o igual para que considere

976
01:27:12,829 --> 01:27:16,130
para que este lo opere

977
01:27:16,130 --> 01:27:22,039
vamos a ejecutar, efectivamente 25

978
01:27:22,039 --> 01:27:27,579
entiendo que en entornos, la asignatura, no sé si la habéis

979
01:27:27,579 --> 01:27:32,880
cursado ya, hay un momento en el que se hacen las pruebas de caja blanca

980
01:27:32,880 --> 01:27:37,119
pruebas de caja negra, una serie de cosas ahí, y dentro de las pruebas

981
01:27:37,119 --> 01:27:40,659
hay que decidir qué valores probar, entonces entre los que

982
01:27:40,659 --> 01:27:44,420
se suelen probar, siempre hay que mirar los números límite.

983
01:27:45,000 --> 01:27:48,800
Entonces, si la ejecución la hacemos a 14, pues uno de los valores

984
01:27:48,800 --> 01:27:52,560
a probar sería aquí, o sea, utilizar la prueba

985
01:27:52,560 --> 01:27:55,899
14 porque es un valor límite de los que cumplen la condición.

986
01:27:58,039 --> 01:28:01,399
Bueno, pues ya está, mirad, aquí ha salido este. Y si

987
01:28:01,399 --> 01:28:05,840
tuviéramos la otra consideración que habíamos dicho, que tengan que ser

988
01:28:05,840 --> 01:28:10,140
de forma simultánea las dos cosas, pues justo con estos datos

989
01:28:10,140 --> 01:28:14,760
el 14 vale para los dos, entonces podríamos poner aquí if

990
01:28:14,760 --> 01:28:17,880
vamos a comprobar que también funciona eso

991
01:28:17,880 --> 01:28:28,520
si es igual a 7 y and

992
01:28:28,520 --> 01:28:40,180
la otra condición está, pues acumulamos

993
01:28:40,180 --> 01:28:44,119
en este caso, en este caso ya se tienen que dar las dos condiciones

994
01:28:44,119 --> 01:28:47,220
para que se acumule, entonces si se tienen que dar las dos condiciones

995
01:28:47,220 --> 01:28:52,159
con estos datos, el 4 que está entre el camino

996
01:28:52,159 --> 01:28:56,180
del 3 y el 14 cumple que acaba en 4 pero no es divisible entre 7

997
01:28:56,180 --> 01:29:00,000
el 7 es divisible entre 7 pero no acaba en 4

998
01:29:00,000 --> 01:29:04,479
entonces el único valor que sería correcto sería el 14, entonces con esta nueva condición

999
01:29:04,479 --> 01:29:08,460
es de esperar que el resultado que nos salga es en lugar de 25

1000
01:29:08,460 --> 01:29:12,020
14, efectivamente por aquí nos da los

1001
01:29:12,020 --> 01:29:23,189
y nada, pues esto era uno de los ejercicios que pedíamos

1002
01:29:23,189 --> 01:29:26,310
fijaros que al final

1003
01:29:26,310 --> 01:29:27,670
pues es esto

1004
01:29:27,670 --> 01:29:30,250
en lo que consiste el ejercicio

1005
01:29:30,250 --> 01:29:32,210
también es cierto que hay que caer

1006
01:29:32,210 --> 01:29:34,350
y estáis ahora entrenando pero que

1007
01:29:34,350 --> 01:29:36,550
cuando a veces os dábamos

1008
01:29:36,550 --> 01:29:38,369
poco espacio

1009
01:29:38,369 --> 01:29:39,869
ahí en el folio

1010
01:29:39,869 --> 01:29:41,649
en realidad se resolvía

1011
01:29:41,649 --> 01:29:44,329
pedía el método, incluso este que es un poquito

1012
01:29:44,329 --> 01:29:48,270
más largo, bueno pues

1013
01:29:48,270 --> 01:29:50,210
se resolvía en este trocito

1014
01:29:50,210 --> 01:30:13,039
si, vamos a

1015
01:30:13,039 --> 01:30:14,800
repasarlo, si queréis más o menos

1016
01:30:14,800 --> 01:30:16,779
como más o menos me acuerdo yo que no estará

1017
01:30:16,779 --> 01:30:18,420
muy lejos de como era el enunciado

1018
01:30:20,439 --> 01:30:33,460
Vamos a definir una clase Persona, y en esta clase Persona ponemos dos atributos.

1019
01:30:33,460 --> 01:30:46,529
No me acuerdo, era int dni, vamos a poner el dni como un número, y luego int edad, int y dni.

1020
01:30:47,069 --> 01:31:03,000
Entonces resulta que había un método que recibía un array de personas y un número.

1021
01:31:03,000 --> 01:31:09,689
static, vamos a llamar al método

1022
01:31:09,689 --> 01:31:10,470
por ejemplo per

1023
01:31:10,470 --> 01:31:35,640
yo creo que el enunciado venía a decir algo como que se recibía un array

1024
01:31:35,640 --> 01:31:40,079
y había que mostrar algo así como el valor

1025
01:31:40,079 --> 01:31:43,960
también acumulado de las edades que tenían todas las personas

1026
01:31:43,960 --> 01:31:47,739
cuyo DNI acabase en un determinado valor

1027
01:31:47,739 --> 01:31:58,010
vamos a poner inum, entonces fijaros que

1028
01:31:58,010 --> 01:32:07,170
las personas tienen un dni y una edad es esto lo que lo que se pide es este desarrollo que

1029
01:32:07,170 --> 01:32:13,689
en algún momento le llegará el array y el número en algún sitio habría construido un array o sea

1030
01:32:13,689 --> 01:32:27,220
definir aquí una rey persona de personas igual año persona o sea a dimensionar el array por

1031
01:32:27,220 --> 01:32:33,640
ejemplo con tres personas y ahora para cada una de las tres personas vamos a darle uno de unos

1032
01:32:33,640 --> 01:32:39,560
determinados valores esto no tenéis que hacer tenéis que hacer esta parte ya se recibía la

1033
01:32:39,560 --> 01:32:44,380
raíz y el número pero bueno para la ejecución pues es necesario también hacer esta parte para

1034
01:32:44,380 --> 01:32:51,819
la ejecución aquí dentro del ide entonces cogemos y ponemos a arpear la posición 0 aquí podríamos

1035
01:32:51,819 --> 01:32:55,560
hacer un bucle, ¿verdad? Pero bueno, no nos enredamos con eso ahora, persona

1036
01:32:55,560 --> 01:33:02,109
lo construimos y decimos que

1037
01:33:02,109 --> 01:33:05,850
arp0.idni, vamos a decir que

1038
01:33:05,850 --> 01:33:09,850
tiene el dni 14, el número sería

1039
01:33:09,850 --> 01:33:13,949
no es un dni real, pero bueno, para persona 1

1040
01:33:13,949 --> 01:33:17,930
y vamos a poner un nombre también, no, es una edad

1041
01:33:17,930 --> 01:33:23,930
arp0.iedad

1042
01:33:23,930 --> 01:34:05,500
punto, y edad, yo que sé, que deciros, pues que tiene de edad 10 años, como hemos dimensionado esto para 3, vamos a dar valores a 3 personas, voy a ponerle 24, para que el DNI coincida el último número, que es la condición que dice el enunciado, vamos a decir edad 11, esta, segunda persona, y luego la tercera de las personas, este lo vamos a poner diferente, vamos a hacer que su DNI no acabe en 4, vamos a hacer coincidir el último número del DNI de 2 de ellas,

1043
01:34:05,640 --> 01:34:42,119
Y de una no, luego si acaso lo cambiamos, ¿vale? Y hacemos diferentes pruebas con diferentes valores. Y este que tenga una edad de 12. Y lo que vamos a hacer va a ser llamar a este método, ver, le vamos a pasar el array y el número que queremos que valide como último del DNI para, como criterio para acumular las edades.

1044
01:34:42,119 --> 01:34:44,399
entonces he aprovechado para poner

1045
01:34:44,399 --> 01:34:46,380
este de 14 y este de 24 para que

1046
01:34:46,380 --> 01:34:48,479
dos acaben en 4 y ahora vamos a

1047
01:34:48,479 --> 01:34:49,739
hacer una primera ejecución aquí

1048
01:34:49,739 --> 01:34:52,439
diciéndole que el número que queremos que se utilice

1049
01:34:52,439 --> 01:34:53,739
sea el 4

1050
01:34:53,739 --> 01:34:55,939
a ver

1051
01:34:55,939 --> 01:35:08,300
¿por qué no me compila esto?

1052
01:35:21,579 --> 01:35:22,939
vale, es que he puesto aquí

1053
01:35:22,939 --> 01:35:24,779
que recibe una persona

1054
01:35:24,779 --> 01:35:26,359
y no una raíz de personas, ¿veis?

1055
01:35:27,020 --> 01:35:28,340
le estoy pasando una raíz de personas

1056
01:35:28,340 --> 01:35:30,520
y aquí le he dicho

1057
01:35:30,520 --> 01:35:33,020
oye, mira, el primer parámetro es una persona

1058
01:35:33,020 --> 01:35:34,840
y lo que recibe es un array de personas.

1059
01:35:36,460 --> 01:35:37,239
Ahora ya me compila.

1060
01:35:39,729 --> 01:35:43,449
Pues nada, entonces aquí, independientemente de que esta llamada

1061
01:35:43,449 --> 01:35:45,810
se está haciendo con este array y un 4,

1062
01:35:46,090 --> 01:35:49,170
podría ser con cualquier array de personas y con cualquier otro número,

1063
01:35:49,630 --> 01:35:51,970
ahora trabajamos en el método para dar solución

1064
01:35:51,970 --> 01:35:55,930
a lo que tiene que gestionarse dentro de ese método

1065
01:35:55,930 --> 01:35:59,909
y estos datos para probar que efectivamente luego funciona el método.

1066
01:36:00,350 --> 01:36:01,369
Luego le damos variantes.

1067
01:36:01,369 --> 01:36:05,729
entonces lo que nos venía a decir el ejercicio es

1068
01:36:05,729 --> 01:36:08,609
vamos a acumular las edades de aquellas personas cuyo

1069
01:36:08,609 --> 01:36:11,409
DNI termine en 4, pues algo parecido a esto

1070
01:36:11,409 --> 01:36:14,670
a la hora de acumular, cogemos y decimos int

1071
01:36:14,670 --> 01:36:16,510
y result

1072
01:36:16,510 --> 01:36:20,449
igual a 0, vamos a acumular, bueno result vamos a poner

1073
01:36:20,449 --> 01:36:23,250
edad, o suma edad

1074
01:36:23,250 --> 01:36:26,489
para que tenga un dato, inicialmente todavía no

1075
01:36:26,489 --> 01:36:29,569
hemos comprobado ninguna persona, pues la edad acumulada

1076
01:36:29,569 --> 01:36:38,920
será de cero. Esto lo que recibe es una referencia de este array de personas.

1077
01:36:39,199 --> 01:36:43,300
Este array de personas, cuando hicimos su new, pues ya hubo una reserva de memoria

1078
01:36:43,300 --> 01:36:46,119
y luego para cada una de las personas tiene su reserva de memoria.

1079
01:36:46,260 --> 01:36:50,359
Entonces, esto estará apuntando a la misma posición de memoria al pasarlo por aquí

1080
01:36:50,359 --> 01:36:54,779
que esta otra. Entonces, el array de personas que está recibiendo aquí

1081
01:36:54,779 --> 01:36:58,859
ya tiene su espacio de memoria reservado con ciertos datos, porque es una posición

1082
01:36:58,859 --> 01:37:06,359
de memoria en particular porque se hizo esa reserva por aquí con lo cual aquí podemos trabajar con el

1083
01:37:06,359 --> 01:37:12,000
array de personas y en esta ejecución en particular teniendo en cuenta que los datos son estos y en

1084
01:37:12,000 --> 01:37:16,039
otra ejecución en particular definiríamos otro array de personas posiblemente dimensionado con

1085
01:37:16,039 --> 01:37:21,899
un tamaño diferente y con otros datos distintos con lo cual ese otro array de personas sería el

1086
01:37:21,899 --> 01:37:29,920
que al que apuntaría esta variable local al método per entonces para recorrer cada una de las personas

1087
01:37:29,920 --> 01:37:46,119
¿Cómo lo hacemos con el array? Pues con un bucle for int i igual a cero. Mientras i sea menor que el tamaño, porque queremos recorrer todas las personas, que es su longitud, hacemos un i más más.

1088
01:37:46,119 --> 01:37:55,439
para cada... Fijaros, esto es un array de personas, ¿verdad?

1089
01:37:59,960 --> 01:38:02,600
Esto es una persona, lo que estamos comentando.

1090
01:38:03,199 --> 01:38:07,000
¿Y qué queremos comprobar? Como esto está dentro de un bucle

1091
01:38:07,000 --> 01:38:11,260
recorriendo todo el array, en cada una de las ejecuciones esto iterará para una de las

1092
01:38:11,260 --> 01:38:15,060
personas en particular de ese array. Y lo que queremos

1093
01:38:15,060 --> 01:38:19,100
comprobar es si su DNI justo termina en este

1094
01:38:19,100 --> 01:38:21,720
número. Lo hemos hecho aquí. Fijaros.

1095
01:38:24,439 --> 01:38:53,100
Entonces podemos decir, if punto idni es igual, perdón, módulo 10, si esto es igual a el número que recibo aquí, ¿qué es lo que hago? Pues acumulo edades.

1096
01:38:53,100 --> 01:39:03,050
entonces el y suma edad será igual a lo que ya lleva acumulado hasta ese momento más la edad de

1097
01:39:03,050 --> 01:39:14,380
la persona está en particular como esto lo recuerdo para cada una de las personas aquellas que cumplan

1098
01:39:14,380 --> 01:39:21,800
esta condición es decir que su último dígito en el dni coincida con el parámetro este que está

1099
01:39:21,800 --> 01:39:28,939
recibiendo veis aquí la condición esa del if en ese caso acumulamos la edad y luego que nos queda

1100
01:39:28,939 --> 01:39:48,329
hacer después del for cuando hayamos recorrido todas las personas vamos a dar un poco el

1101
01:39:48,329 --> 01:40:20,460
resultado como siempre de las edades de las personas cuyo dni termina en es pues está aquí

1102
01:40:20,460 --> 01:40:27,119
lo tenemos entonces ejecutamos por aquí vamos a ver si de verdad funciona fijaros que la ejecución

1103
01:40:27,119 --> 01:40:29,840
la estamos haciendo, ahora modificamos en alguna otra ejecución

1104
01:40:29,840 --> 01:40:33,380
los datos, cargamos el array este de personas

1105
01:40:33,380 --> 01:40:35,699
y decimos que compruebe

1106
01:40:35,699 --> 01:40:38,479
como último dígito del DNI

1107
01:40:38,479 --> 01:40:41,619
que sea un 4, entonces ese criterio lo cumple

1108
01:40:41,619 --> 01:40:44,899
tanto esta como esta, pero esta no, que es 22

1109
01:40:44,899 --> 01:40:47,520
y las edades son 10 y 11

1110
01:40:47,520 --> 01:40:50,359
con lo cual es previsible que el resultado que nos dé

1111
01:40:50,359 --> 01:40:53,039
si el código lo hemos puesto bien, si no pues habrá que depurar

1112
01:40:53,039 --> 01:40:55,180
sea 10 más 11, 21

1113
01:40:55,180 --> 01:40:57,720
entonces le damos aquí a la ejecución y aquí nos lleva

1114
01:40:57,720 --> 01:40:58,760
que es 21, ¿veis?

1115
01:41:00,340 --> 01:41:01,859
si hacemos una ejecución

1116
01:41:01,859 --> 01:41:03,520
en lugar de decir 14 y 24

1117
01:41:03,520 --> 01:41:05,359
que el DNI acabe en 2

1118
01:41:05,359 --> 01:41:07,760
pues como es

1119
01:41:07,760 --> 01:41:08,579
solamente esta

1120
01:41:08,579 --> 01:41:11,779
la que lo cumple, pues es de esperar

1121
01:41:11,779 --> 01:41:13,739
que nos diga que la edad es

1122
01:41:13,739 --> 01:41:15,880
12, ahí lo tenéis

1123
01:41:15,880 --> 01:41:19,300
si decimos que sea en 3

1124
01:41:19,300 --> 01:41:20,920
pues nos tendría que decir que es 0

1125
01:41:20,920 --> 01:41:23,520
porque ahora mismo ningún DNI está acabando en 3

1126
01:41:23,520 --> 01:41:25,600
pues nos dice que es 0

1127
01:41:25,600 --> 01:41:28,000
y bueno pues

1128
01:41:28,000 --> 01:41:30,380
vamos a poner aquí 34

1129
01:41:30,380 --> 01:41:32,760
y vamos a decir que compruebe el 4

1130
01:41:32,760 --> 01:41:35,340
para que se cumplan todas ellas

1131
01:41:35,340 --> 01:41:39,199
con lo cual sería 10, 21

1132
01:41:39,199 --> 01:41:41,760
23, 33

1133
01:41:41,760 --> 01:41:47,380
entonces el código

1134
01:41:47,380 --> 01:41:50,260
pues sería este

1135
01:41:50,260 --> 01:41:53,079
el que pedíamos ahí

1136
01:41:53,079 --> 01:41:57,590
que bueno ya veis que

1137
01:41:57,590 --> 01:41:58,550
bueno pues si que es

1138
01:41:58,550 --> 01:42:00,529
que no digo yo que sea fácil

1139
01:42:00,529 --> 01:42:04,649
que estáis ahora aprendiendo, bueno, algunos lo habéis hecho bien, pues yo que sé, se ve que tenéis

1140
01:42:04,649 --> 01:42:08,569
destreza ya con Java, por lo que habéis aprendido, por el bagaje que tengáis anterior

1141
01:42:08,569 --> 01:42:12,350
y los que estáis ahora sobre todo arrancando más con Java, pues

1142
01:42:12,350 --> 01:42:16,630
pues cuesta a lo mejor llegar a la conclusión de plantearlo así

1143
01:42:16,630 --> 01:42:20,250
pero lo que quiero deciros es que no, en principio pues no pedimos

1144
01:42:20,250 --> 01:42:24,689
grandes cantidades de código ahí para que os tengáis que volver locos

1145
01:42:24,689 --> 01:42:28,670
ya veis que en realidad se resolvía con 10 líneas de código

1146
01:42:28,670 --> 01:42:31,210
con las dificultades que tiene

1147
01:42:31,210 --> 01:42:32,949
y bueno, pues eso, que estéis entrenando

1148
01:42:32,949 --> 01:42:34,810
para saber hacer

1149
01:42:34,810 --> 01:42:38,180
todo esto. ¿Lo veis?

1150
01:42:42,380 --> 01:42:43,539
Sí. Vale.

1151
01:42:44,000 --> 01:42:45,500
Vale. Sí.

1152
01:42:46,579 --> 01:42:47,579
Bueno, pues

1153
01:42:47,579 --> 01:42:49,899
pues nada, yo creo que ya no os voy a contar

1154
01:42:49,899 --> 01:42:51,659
nada más. Ya estamos en las siete y cuarto

1155
01:42:51,659 --> 01:42:53,600
a no ser que tengáis alguna duda por ahí.

1156
01:42:53,939 --> 01:42:56,060
Os he puesto, a los que os habéis presentado

1157
01:42:56,060 --> 01:42:58,180
os he puesto las notas ya ahí en el aula virtual

1158
01:42:58,180 --> 01:42:59,300
bueno, pues echarle un ojo

1159
01:42:59,300 --> 01:43:01,819
y he pensado que mejor que

1160
01:43:01,819 --> 01:43:04,039
cerrar un día que sé que andáis con trabajo

1161
01:43:04,039 --> 01:43:05,979
y os resulta mejor

1162
01:43:05,979 --> 01:43:08,140
complicado venir en un momento en particular

1163
01:43:08,140 --> 01:43:10,000
pues lo dejo abierto

1164
01:43:10,000 --> 01:43:11,920
a cualquier lunes, si alguien quiere ver

1165
01:43:11,920 --> 01:43:13,100
su examen cualquier lunes

1166
01:43:13,100 --> 01:43:15,859
luego claro, esto tiene el inconveniente de que sí

1167
01:43:15,859 --> 01:43:17,699
que es cierto que tenéis que cerrar conmigo

1168
01:43:17,699 --> 01:43:19,140
cuando vais a venir, porque yo

1169
01:43:19,140 --> 01:43:21,859
en principio mi jornada de trabajo es por la

1170
01:43:21,859 --> 01:43:23,399
mañana, solo vengo a daros la tutoría

1171
01:43:23,399 --> 01:43:25,420
y en cuanto acabo me marcho a casa

1172
01:43:25,420 --> 01:43:27,899
entonces a ver si alguien se va a pegar un viaje desde lejos

1173
01:43:27,899 --> 01:43:29,979
va a llegar aquí y ya no me va a pillar

1174
01:43:29,979 --> 01:43:31,739
entonces quien quiera ver su examen

1175
01:43:31,739 --> 01:43:34,960
me lo decís y justo al terminar la tutoría

1176
01:43:34,960 --> 01:43:35,760
quedamos

1177
01:43:35,760 --> 01:43:38,560
uno o dos, los que sean, este lunes

1178
01:43:38,560 --> 01:43:40,140
el siguiente, me da igual cuando sea

1179
01:43:40,140 --> 01:43:42,579
o si uno no puede, os digo, este no puedo, a ver al siguiente

1180
01:43:42,579 --> 01:43:44,720
que lo concretamos, es decir, lo tenemos que concretar

1181
01:43:44,720 --> 01:43:46,760
y nada, os paséis

1182
01:43:46,760 --> 01:43:47,680
a verlo cuando queráis

1183
01:43:47,680 --> 01:43:49,739
vuestro examen si queréis

1184
01:43:49,739 --> 01:43:59,300
nada, nada, sobre 10, sobre 10

1185
01:43:59,300 --> 01:44:00,760
sí, sí, sí, sí

1186
01:44:00,760 --> 01:44:01,560
sí, sí

1187
01:44:01,560 --> 01:44:04,840
que conste que me di cuenta

1188
01:44:04,840 --> 01:44:06,880
y digo, va, voy a poner la aclaración

1189
01:44:06,880 --> 01:44:09,399
Luego se me pasó, pero no, no, es sobre 10, sobre 10, sí, sí.

1190
01:44:11,579 --> 01:44:18,279
Sí, no tiene nada que ver una nota en particular si es sobre 10 o si es sobre 100, nada que ver, sí, sí, no, sobre 10.

1191
01:44:21,810 --> 01:44:30,970
Y nada, pues nada, si no tenéis nada que consultarme, pues aquí cerramos ya, por hoy, la semana que viene más.

1192
01:44:30,970 --> 01:44:37,579
La semana que viene repasamos cosas del tema 7, ¿sí?

1193
01:44:37,579 --> 01:44:39,800
pues nada, venga

1194
01:44:39,800 --> 01:44:43,159
como siempre os subo

1195
01:44:43,159 --> 01:44:45,159
la clase al aula por si la queréis

1196
01:44:45,159 --> 01:44:46,439
volver a echar un ojo en algún momento

1197
01:44:46,439 --> 01:44:48,340
venga, buena tarde, hasta luego