1
00:00:04,530 --> 00:00:22,640
comparto pantalla ahí está y bueno si no tenéis ninguna cosa en particular pues para cerrar un

2
00:00:22,640 --> 00:00:29,780
poco el tema el tema 2 pues se me había ocurrido el tema 2 el tema 4 se me había ocurrido que

3
00:00:29,780 --> 00:00:35,179
podíamos hacer la tarea si no tenéis ninguna cosita así en particular que queráis que veamos

4
00:00:36,740 --> 00:00:40,859
aunque tenéis una solución propuesta por lo hacemos poco a poco y así vamos comentando

5
00:00:40,859 --> 00:00:42,799
toda la jugada

6
00:00:42,799 --> 00:00:52,679
bueno, mirad, aquí tenemos el enunciado

7
00:00:52,679 --> 00:00:54,020
hacemos una lectura

8
00:00:54,020 --> 00:00:56,039
rápida de él

9
00:00:56,039 --> 00:00:58,780
nos pone en contexto

10
00:00:58,780 --> 00:01:00,439
que una cadena de restaurante

11
00:01:00,439 --> 00:01:02,200
necesita un programa para registrar

12
00:01:02,200 --> 00:01:04,500
los alimentos domésticos que tienen sus cocinas

13
00:01:04,500 --> 00:01:06,519
dice que

14
00:01:06,519 --> 00:01:08,239
una cocina puede tener un frigorífico

15
00:01:08,239 --> 00:01:09,379
y una placa de inducción

16
00:01:09,379 --> 00:01:12,680
ambas cosas

17
00:01:12,680 --> 00:01:14,659
una de las dos o ninguna de ellas

18
00:01:14,659 --> 00:01:17,280
bueno, pues un poco

19
00:01:17,280 --> 00:01:23,040
para identificar lo que sería un diseño previo a hacer el ejercicio pues bueno pues proponemos

20
00:01:23,040 --> 00:01:30,640
que existan al menos tres clases bueno pues en realidad muchos de vosotros habéis resuelto la

21
00:01:30,640 --> 00:01:35,280
tarea con una cuarta que es perfectamente correcto que sería la que inicia el programa para luego ir

22
00:01:35,280 --> 00:01:43,420
instanciando objetos de cada una de estas tres clases identificados los tres actores digamos

23
00:01:43,420 --> 00:01:55,760
El término actor está un poco relacionado con la programación orientada a objetos en la parte de diseño y probablemente os aparecerá este término si veis la asignatura de entornos de desarrollo.

24
00:01:56,439 --> 00:02:05,959
Para los que participan en un programa se les puede llegar a denominar actores, como si formaran parte de una película que fuese nuestro programa o de una obra de teatro.

25
00:02:05,959 --> 00:02:13,139
entonces lo que correspondería a la hora de hacer el diseño sería para cada una de las clases

26
00:02:13,139 --> 00:02:17,860
identificar qué es aquello significativo para esa clase dentro del programa

27
00:02:17,860 --> 00:02:24,919
entonces el enunciado dice que tendrá las siguientes características que son aquellos parámetros

28
00:02:24,919 --> 00:02:30,180
que más o menos podemos identificar como importantes a la hora de definir la clase cocina

29
00:02:30,180 --> 00:02:34,560
que sería un nombre, pues el nombre lo guardaremos en una variable tipo string

30
00:02:34,560 --> 00:03:04,300
un frigorífico, que lo que haremos será construir un atributo, parámetro de la clase cocina de tipo clase frigorífico, una placa, la misma forma que el frigorífico, pues crearemos un atributo para la placa, luego existirá o no existirá, primero podemos definir como parámetro de clase la referencia y luego hacer, reservar los recursos a través del new y el constructor del frigorífico y la placa,

31
00:03:04,560 --> 00:03:08,539
caso de que se nos pida, ¿no? Y luego, bueno, pues para aquí

32
00:03:08,539 --> 00:03:12,460
os proponía en el enunciado que hubiese un par

33
00:03:12,460 --> 00:03:18,319
de booleans, por ejemplo, aquí no aparece, aquí, sería

34
00:03:18,319 --> 00:03:22,460
lo que sería el indicador, los booleans que nos indiquen si hay o no hay frigorífico.

35
00:03:22,759 --> 00:03:28,159
Y esto sería las referencias a frigorífico y a la placa. Y luego, bueno, para que

36
00:03:28,159 --> 00:03:32,180
os resultase un poco más fácil el ejercicio, como todavía no nos hemos

37
00:03:32,180 --> 00:03:36,000
metido muy, muy de lleno todavía a programar, pues en lo que es

38
00:03:36,000 --> 00:03:42,900
el enunciado pues os proponía aparte de los parámetros pues al menos los métodos que se me

39
00:03:42,900 --> 00:03:48,960
ocurría que pudieran tener no para enfocarlo y que el ejercicio esté de acuerdo a lo que más o menos

40
00:03:48,960 --> 00:03:55,780
hemos visto como contenidos en este tema entonces que tuviese un método aquí que lo que haga es

41
00:03:55,780 --> 00:04:03,780
informar de exactamente qué componentes tiene esa cocina en particular junto con su nombre con este

42
00:04:03,780 --> 00:04:07,080
tipo de mensaje. Y en lugar de hacer aquí

43
00:04:07,080 --> 00:04:09,180
el system.out.println, pues os

44
00:04:09,180 --> 00:04:10,939
pedía que, pues para

45
00:04:10,939 --> 00:04:13,099
gestionar un poco lo que es el return y todo

46
00:04:13,099 --> 00:04:14,819
esto, que no fuese un método

47
00:04:14,819 --> 00:04:17,000
que devolviese un void, sino un string para

48
00:04:17,000 --> 00:04:19,079
construir el string que devuelve y el

49
00:04:19,079 --> 00:04:21,160
mensaje en sí se pusiera en el main, me parece

50
00:04:21,160 --> 00:04:25,060
recordar que decía por aquí. Luego, bueno,

51
00:04:25,079 --> 00:04:27,079
la clase frigorífico es

52
00:04:27,079 --> 00:04:28,980
un getter y un setter, que también

53
00:04:28,980 --> 00:04:30,040
hemos hablado de ellos,

54
00:04:31,019 --> 00:04:33,060
relaciona al único parámetro que

55
00:04:33,060 --> 00:04:35,240
tiene, que es el de marca, que será un string.

56
00:04:36,420 --> 00:04:37,060
Como tenemos los

57
00:04:37,060 --> 00:04:43,439
getter y los setter, lo que vamos a hacer luego va a ser poner este parámetro que sea de acceso

58
00:04:43,439 --> 00:04:50,279
privado para que a la hora de informar a este parámetro de su valor o a la hora de recoger su

59
00:04:50,279 --> 00:04:57,079
información, obligarnos a utilizar los getter y los setter. Y bueno, pues nada, en la placa, pues otro

60
00:04:57,079 --> 00:05:03,160
de los elementos de los que hemos hablado durante el ejercicio, pues el constructor, un método

61
00:05:03,160 --> 00:05:08,560
constructor y un getter y un setter para el color y en este caso el color en lugar de pedirse por

62
00:05:08,560 --> 00:05:15,759
teclado lo que hacíamos era solicitar el color a través de de forma aleatoria entre tres posibles

63
00:05:15,759 --> 00:05:23,199
colores para que fuese azul marrón o verde en un mismo porcentaje de posibilidades y luego aquí

64
00:05:23,199 --> 00:05:28,860
una secuencia de cómo podría el programa pues nada se solicita el nombre de la cocina para informar

65
00:05:28,860 --> 00:05:35,160
a este parámetro de la clase cocina se dice si hay frigorífico en el frigorífico y en caso de

66
00:05:35,160 --> 00:05:41,480
que haya frigorífico pues aplica hacemos unión a la referencia que tenemos como parámetro de clase

67
00:05:41,480 --> 00:05:50,689
del frigorífico si resulta que el frigorífico tenemos que recuperar su marca la cogemos por

68
00:05:50,689 --> 00:05:59,170
teclado y esa marca será la que asignaremos a través del setter aquí en el frigorífico con

69
00:05:59,170 --> 00:06:02,529
el set marca, y luego la placa

70
00:06:02,529 --> 00:06:03,529
un poco la misma idea

71
00:06:03,529 --> 00:06:06,810
lo único que el color en sí no se lo pedimos

72
00:06:06,810 --> 00:06:08,730
por teclado, sino que se carga

73
00:06:08,730 --> 00:06:10,730
de forma aleatoria en el constructor

74
00:06:10,730 --> 00:06:12,589
de la cocina, lo decimos por aquí

75
00:06:12,589 --> 00:06:14,870
fijaros, el constructor

76
00:06:14,870 --> 00:06:15,750
llama setColor

77
00:06:15,750 --> 00:06:18,649
y luego para concluir, pues lo que hacemos es

78
00:06:18,649 --> 00:06:20,850
llamar al método informo para que nos diga

79
00:06:20,850 --> 00:06:22,290
cómo ha ido la cocina

80
00:06:22,290 --> 00:06:26,600
hoy el tiempo es un poco más escaso, como solo

81
00:06:26,600 --> 00:06:28,819
tenemos una hora, pues a ver si nos da tiempo a completar

82
00:06:28,819 --> 00:06:30,500
el ejercicio, y si nos da tiempo

83
00:06:30,500 --> 00:06:32,000
pues jugamos un poco con

84
00:06:32,000 --> 00:06:35,399
la etiqueta static de nuevo

85
00:06:35,399 --> 00:06:37,120
que ya le hemos comentado en varias ocasiones

86
00:06:37,120 --> 00:06:39,620
y bueno, tenemos abierta

87
00:06:39,620 --> 00:06:41,060
alguna pregunta ahí en el foro

88
00:06:41,060 --> 00:06:43,459
en relación a esto, pues si nos da tiempo lo vemos

89
00:06:43,459 --> 00:06:44,699
y si no ya retomaremos

90
00:06:44,699 --> 00:06:46,860
en algún otro momento esta etiqueta

91
00:06:46,860 --> 00:06:49,420
durante el siguiente tema con seguridad

92
00:06:49,420 --> 00:06:51,699
Pues vale, vamos a

93
00:06:51,699 --> 00:06:55,060
ponernos en marcha

94
00:06:55,060 --> 00:06:56,000
con el ejercicio

95
00:06:56,000 --> 00:07:04,720
os voy contando un poquito

96
00:07:04,720 --> 00:07:08,139
rápido, a ver si nos da tiempo a acabar el ejercicio

97
00:07:08,139 --> 00:07:10,319
repasando

98
00:07:10,319 --> 00:07:15,819
parando un poquito en cada en diferentes conceptos de los que hemos ido viendo en el tema pero si

99
00:07:15,819 --> 00:07:21,360
tenéis cualquier duda pues pararme al final estas tutorías más que para ver de mario avanzado es

100
00:07:21,360 --> 00:07:31,120
para resolver posibles tutorías que tengáis unos cortes en avisarme si alguna cosilla no se entiende

101
00:07:31,120 --> 00:07:41,569
bien ahora por aquí del ejercicio con el que estuvimos trabajando el último día creamos un

102
00:07:41,569 --> 00:07:59,720
un proyecto, un proyecto Java, que podemos llamar, vamos a llamarlo restaurante, voy a eliminar el módulo este,

103
00:08:00,399 --> 00:08:08,019
como hago siempre, y vamos a crear, vamos a construir el ejercicio en base a cuatro clases, entonces,

104
00:08:08,220 --> 00:08:17,420
vamos a crear una primera clase restaurante, básicamente para que tenga el main, fijaros, en lugar de andar

105
00:08:17,420 --> 00:08:21,319
escribiéndolo luego, voy a poner aquí que me integre el código main, que me da

106
00:08:21,319 --> 00:08:30,759
la opción Eclipse y aquí tenemos restaurante. Luego tenemos tres clases

107
00:08:30,759 --> 00:09:00,299
más, la clase cocina, la clase frigorífico y la clase placa. En la clase

108
00:09:00,299 --> 00:09:08,240
restaurante podríamos, el ejercicio está planteado para que haya, entendemos

109
00:09:08,240 --> 00:09:13,299
un solo restaurante que tiene una única cocina y la cocina tiene la

110
00:09:13,299 --> 00:09:18,740
posibilidad de tener o no tener placa o no tener frigorífico o en caso de tener alguna de las dos

111
00:09:18,740 --> 00:09:24,340
o ambas solamente una de cada de cada clase no permiten tener varias cocinas o no lo propone

112
00:09:24,340 --> 00:09:31,419
así el ejercicio entonces podríamos decir que bueno pues el restaurante que caracteriza a la

113
00:09:31,419 --> 00:09:38,000
hora de definir los parámetros que tiene una clase pues aquí java nos permite definir cualquier cosa

114
00:09:38,000 --> 00:09:42,220
imaginaros que pusiéramos aquí un int y esto en realidad es una variable que luego utilizamos

115
00:09:42,220 --> 00:09:48,580
aquí para ir trabajando sobre un bucle pues esto lo permitiría como y lo ponemos a esta altura sería

116
00:09:48,580 --> 00:09:54,460
del ámbito de la clase en su conjunto pues y estaría disponible aquí compilaría el programa

117
00:09:54,460 --> 00:10:01,120
si funcionaría así pero sería muy correcto poner una variable y que en realidad podríamos querer

118
00:10:01,120 --> 00:10:07,299
para un bucle dentro del main pues no mucho porque aparte de que de buscar que los programas

119
00:10:07,299 --> 00:10:12,539
nos funcionen en sí, tenemos que, estamos intentando dar respuesta

120
00:10:12,539 --> 00:10:16,519
a una funcionalidad y los parámetros de clase en la programación

121
00:10:16,519 --> 00:10:20,080
orientada a objetos, tenemos que pensarlos como aquellas cosas

122
00:10:20,080 --> 00:10:25,419
que son características del restaurante, no definirlas de forma

123
00:10:25,419 --> 00:10:27,759
que nos permita que el programa nos compile en sí.

124
00:10:28,519 --> 00:10:31,460
Lógicamente el programa finalmente tendrá que compilar, pero esta variable

125
00:10:31,460 --> 00:10:35,139
y desistir, que no va a ser el caso, si fuese una variable para

126
00:10:35,139 --> 00:10:39,820
trabajo intermedio dentro del método main, pues habría que definirla aquí y no aquí como parámetro

127
00:10:39,820 --> 00:10:45,759
de clase, ya que no es algo que caracteriza a los restaurantes. En este ejercicio, ¿podríamos

128
00:10:45,759 --> 00:10:52,240
entender que la cocina podría ser una característica del restaurante? Bueno, pues podríamos

129
00:10:52,240 --> 00:10:57,500
entenderlo. Podría tener el restaurante, si el enunciado lo pidiese, unas dimensiones para

130
00:10:57,500 --> 00:11:06,860
expresar los metros cuadrados, una cocina, una sala donde están las mesas, estas cosas sí pueden

131
00:11:06,860 --> 00:11:12,980
caracterizar al restaurante, una variable por ejemplo de este tipo. La cocina, pues sí podría

132
00:11:12,980 --> 00:11:24,240
ser, ponemos cocina, mi cocina. Aquí tenemos una referencia a una cocina, será una referencia que

133
00:11:24,240 --> 00:11:31,440
todavía no es un objeto activado, a un tipo de datos, que no es un tipo de datos primitivo, es un tipo de datos referenciado

134
00:11:31,440 --> 00:11:38,980
y corresponde a una de las clases que luego vamos a desarrollar aquí nosotros en nuestro programa, que es la clase cocina.

135
00:11:42,740 --> 00:11:51,120
Bueno, pues aquí entonces, en realidad esto todavía es una referencia, podríamos coger y decir aquí, vamos a instanciar la cocina,

136
00:11:51,120 --> 00:12:01,610
con toda seguridad va a haber una cocina en el ejercicio pero aquí igual año cocina y con esta

137
00:12:01,610 --> 00:12:29,049
jugada a ver si claro es cierto al estar fuera del min debería ser estático vale vamos a vamos

138
00:12:29,049 --> 00:12:42,879
a repasar esto mirad imaginaos que tenemos un método public public mostrar nombre de él

139
00:12:42,879 --> 00:12:51,620
por ejemplo el nombre del restaurante si yo cojo y pongo aquí esto fijaros que aquí se me compila

140
00:12:51,620 --> 00:12:58,379
pero aquí no que es justo lo que lo que se refiere es alguien alguien me estaba diciendo para la

141
00:12:58,379 --> 00:13:06,000
grabación que si no debería ser estático a la hora de definirlo aquí qué es lo que sucede main es un

142
00:13:06,000 --> 00:13:12,940
método que es estático entonces cuando se está ejecutando main para cualquier método estático

143
00:13:12,940 --> 00:13:22,009
main es un poco más especial al referirse a al referirse al método que por el que entramos en

144
00:13:22,009 --> 00:13:28,730
el programa pero cuando nosotros cogemos y utilizamos un método como estático bien sea

145
00:13:28,730 --> 00:13:34,710
main o no sea main este método es común a todos los posibles objetos que pertenecen a la clase

146
00:13:34,710 --> 00:13:42,669
restaurante. Como mi cocina es un parámetro que no lo hemos definido estático, cada uno de los

147
00:13:42,669 --> 00:13:47,090
restaurantes que pudiéramos definir en nuestro programa en línea general tendrían un mi cocina

148
00:13:47,090 --> 00:13:55,169
y como este método main sí que es estático, es el mismo método, el mismo código el que se

149
00:13:55,169 --> 00:14:00,389
ejecutará para absolutamente todos los restaurantes. Si tuviéramos en nuestro programa instanciados

150
00:14:00,389 --> 00:14:06,929
cuatro restaurantes en otras clases que sucedería que todos ellos utilizarían el mismo main y

151
00:14:06,929 --> 00:14:13,269
cualquiera de ellos podría ejecutar el método main de los cuatro restaurantes cada uno tendría

152
00:14:13,269 --> 00:14:19,210
su propia cocina entonces si cada uno tiene su propia cocina no sabríamos a qué cocina nos

153
00:14:19,210 --> 00:14:25,590
estamos refiriendo a cuál de las cuatro entonces desde un método que es estático no podemos hacer

154
00:14:25,590 --> 00:14:36,990
referencia a parámetros que no sean estáticos por este motivo porque no está claro a que mi cocina

155
00:14:36,990 --> 00:14:42,730
a cual de todos los posibles restaurantes que utilicen el main estarán refiriéndose a la hora

156
00:14:42,730 --> 00:14:49,710
de utilizar la variable mi cocina entonces se solucionaría poniendo este como static para que

157
00:14:49,710 --> 00:15:00,090
compile, pero ahora habría que ver si en el contexto del ejercicio me interesaría que todo restaurante

158
00:15:00,090 --> 00:15:05,870
tuviese la misma cocina, porque esto tiene sus connotaciones, claro. El hecho de definir mi cocina

159
00:15:05,870 --> 00:15:12,929
como estático implica que si en el ejercicio hubiese cinco restaurantes, los cinco restaurantes

160
00:15:12,929 --> 00:15:19,090
estarían compartiendo la misma cocina porque lo hemos definido como estático. Si así fuese, estaría

161
00:15:19,090 --> 00:15:25,909
correctamente bien definido de esta forma y nos permitiría permitiría utilizarlo aquí nos

162
00:15:25,909 --> 00:15:33,909
compilaría si el enunciado del ejercicio dice que la diferente restaurantes cada uno tiene su cocina

163
00:15:33,909 --> 00:15:39,409
entonces esto no lo podríamos definir ya estático por porque el requisito del ejercicio no nos lo

164
00:15:39,409 --> 00:15:47,370
permite y ya no nos compilaría aquí ya que el main es un método común en este caso si quisiéramos

165
00:15:47,370 --> 00:15:54,149
dentro trabajar con un objeto propio de la cocina tendríamos que definir la variable no como una

166
00:15:54,149 --> 00:16:00,889
variable de clase que fuese que tuviese cada uno de los restaurantes una cocina sino como una

167
00:16:00,889 --> 00:16:08,250
variable local al mail aquí podríamos poner cocina y entonces pues ya si me compilaría aquí ya habría

168
00:16:08,250 --> 00:16:14,509
ambigüedades no sea el restaurante que sea cuando llame al main aunque sea común la cocina a la que

169
00:16:14,509 --> 00:16:21,129
se refiere es esta que está definida aquí como local y no está y no a este parámetro de clase

170
00:16:21,129 --> 00:16:29,879
que sería una diferente para cada uno de los restaurantes vamos a dejarlo así es cierto lo

171
00:16:29,879 --> 00:16:34,340
que comentaba veis para que me compilase en el main tendría que haber sido así cosa diferente

172
00:16:34,340 --> 00:16:39,360
es si tenemos un método que no es estático dentro del restaurante si yo pongo aquí un método que no

173
00:16:39,360 --> 00:16:45,259
es estático, public void, mi nombre vamos a poner, por poner un nombre

174
00:16:45,259 --> 00:16:57,419
el que sea, si yo ahora pongo aquí una cocina que es un parámetro

175
00:16:57,419 --> 00:17:00,559
de clase de cualquiera de los restaurantes, si hay cinco restaurantes

176
00:17:00,559 --> 00:17:06,019
cada restaurante tendrá su parámetro mi cocina, si yo en un método

177
00:17:06,019 --> 00:17:11,460
como mi nombre que no es estático, al contrario de main, ahora yo pongo

178
00:17:11,460 --> 00:17:21,599
aquí mi cocina, punto, lo que sea, mi cocina igual a new cocina. Este sí me compila. ¿Y por qué me compila?

179
00:17:22,140 --> 00:17:28,480
Porque este método, al no ser estático, cada restaurante ejecutará, digamos, una copia de este

180
00:17:28,480 --> 00:17:33,980
método. Y cuando esté un restaurante, el restaurante 1, ejecutando el método mi nombre, método

181
00:17:33,980 --> 00:17:39,640
perteneciente a la clase restaurante para el restaurante 1, ejecutando mi nombre, como es el

182
00:17:39,640 --> 00:17:45,900
restaurante1, el que está ejecutando mi nombre, sin lugar a dudas, mi cocina que utiliza es mi

183
00:17:45,900 --> 00:17:55,099
cocina del restaurante1. Entonces, en este caso, me compila, pero desde un método que es estático,

184
00:17:55,960 --> 00:18:03,140
no puedo utilizar una variable sin identificarla perfectamente, que no sea estática, porque ante

185
00:18:03,140 --> 00:18:09,599
la posibilidad de que existan diferentes restaurantes, no sabría cuál de ellos, que mi

186
00:18:09,599 --> 00:18:13,660
cocina utilizar, la cocina de qué restaurante, si del restaurante 1, del 2, del 3, del 4

187
00:18:13,660 --> 00:18:17,700
o del 5. Dicho esto, cuando

188
00:18:17,700 --> 00:18:21,720
hagamos el programa no hay que poner esto estático para que me compile

189
00:18:21,720 --> 00:18:25,319
si es que lo quiero utilizar aquí en el main o dejarlo sin que sea estático

190
00:18:25,319 --> 00:18:29,720
porque me compila en algún otro sitio. La definición del parámetro tiene que ser

191
00:18:29,720 --> 00:18:33,839
acorde a diferentes restaurantes compartirán la misma

192
00:18:33,839 --> 00:18:37,559
cocina, si es que sí, estático. Diferentes

193
00:18:37,559 --> 00:18:50,910
¿Qué restaurantes compartirán la misma cocina? No, pues entonces no es estática para que cada uno de los restaurantes que instanciemos tenga su propia cocina.

194
00:18:50,910 --> 00:19:09,460
¿No se respondía a tu pregunta? ¿Alguien que preguntaba por ahí que si tenía que ser estático? Sí. Vale. Bueno, pues continuamos entonces.

195
00:19:09,460 --> 00:19:28,220
Entonces, fijaos, instanciamos un objeto de la cocina con un constructor. Vamos un momentito a la cocina, luego vamos retomando el mail. La cocina, ¿qué es lo que tiene que tener? Pues hemos dicho que tiene un nombre, cosas que caracterizan a la cocina, que son variables que de verdad son propias de una cocina en este ejercicio.

196
00:19:28,220 --> 00:19:56,339
Pues tendrá un nombre, tendrá un indicador de si tiene frigorífico o no, un indicador de si tiene placa, tendrá un frigorífico, tendrá una placa.

197
00:20:03,730 --> 00:20:11,549
Todos estos atributos, si los dejamos así, sin ninguna etiqueta extra de public, private y todo esto, tienen alcance de paquete.

198
00:20:11,549 --> 00:20:14,069
lo suyo en verdad es

199
00:20:14,069 --> 00:20:17,769
trabajar con ellos de forma privada

200
00:20:17,769 --> 00:20:22,619
en líneas generales

201
00:20:22,619 --> 00:20:26,660
y que los accesos los hagamos

202
00:20:26,660 --> 00:20:28,339
a través de getters y setters

203
00:20:28,339 --> 00:20:39,089
igual nos puede resultar un poco

204
00:20:39,089 --> 00:20:41,789
incómodo el tener esto privado

205
00:20:41,789 --> 00:20:45,769
luego lo hacemos desde el principio

206
00:20:45,769 --> 00:20:50,259
con privados, ahora podríamos construir los getters

207
00:20:50,259 --> 00:20:52,799
y los setters, vamos a apoyarnos en

208
00:20:52,940 --> 00:21:28,250
en los ides, Eclipse, también NetBeans nos proporciona esa opción, otros ides casi con toda seguridad, de generar getters y setters, que él nos cree en los bloques de código, entonces vamos a decirle que nos cree getters y setters para todos y los mantenemos de forma privada, vemos aquí que los genere y por aquí nos aparecen todos, voy a ponerlos aquí abajo, me gusta más tener los parámetros aquí en esta parte de arriba, vale, pues ya tenemos la cocina,

209
00:21:28,609 --> 00:21:37,970
la cocina además tiene la placa en el frigorífico hemos dicho que tiene la posibilidad de tener una

210
00:21:37,970 --> 00:21:48,569
marca que es un string entonces aquí un string ese color igual que antes tendría alcance de

211
00:21:48,569 --> 00:21:56,450
paquetes si no decimos nada público si ponemos public protect y también son etiquetas que hemos

212
00:21:56,450 --> 00:22:03,690
visto en este tema vamos a ponerlo privado privado recordad que solamente permite el acceso desde la

213
00:22:03,690 --> 00:22:10,970
propia clase a la variable al parámetro el hecho de que sea privado si hacemos un getter y un setter

214
00:22:10,970 --> 00:22:17,329
como está en la misma clase pues tendrán acceso al parámetro vamos a crear también un getter y

215
00:22:17,329 --> 00:22:26,140
un setter por aquí en este caso de la clase el frigorífico no es color el frigorífico es marca

216
00:22:26,140 --> 00:22:31,720
el color creo que es en la placa

217
00:22:31,720 --> 00:22:35,799
todos los efectos da igual pero vamos a ponerlo bien

218
00:22:35,799 --> 00:22:52,160
a ver, no sé que me está pasando aquí

219
00:22:52,160 --> 00:23:04,029
vale, pues ya está, no lo había salvado

220
00:23:04,029 --> 00:23:07,019
yo creo, y bueno

221
00:23:07,019 --> 00:23:07,700
y la placa

222
00:23:07,700 --> 00:23:10,440
pues tiene

223
00:23:10,440 --> 00:23:22,380
el color y vamos a hacer la misma

224
00:23:22,380 --> 00:23:24,539
jugada, lo generamos

225
00:23:24,539 --> 00:23:25,640
y lo vamos a poner privado

226
00:23:25,640 --> 00:23:35,079
la placa también tiene un

227
00:23:35,079 --> 00:23:37,279
constructor, acordaros, los constructores

228
00:23:37,279 --> 00:23:38,819
no devuelven nada

229
00:23:38,819 --> 00:23:40,619
al contrario por ejemplo que

230
00:23:40,619 --> 00:23:45,240
el get, el getter que sí que devuelve un string, los constructores no devuelven nada

231
00:23:45,240 --> 00:23:50,759
pero nos indica convoy. Los métodos por convenio suelen

232
00:23:50,759 --> 00:23:54,599
empezar por letra minúscula si tienen varias palabras

233
00:23:54,599 --> 00:23:59,180
las siguientes palabras, primera de las letras en mayúscula

234
00:23:59,180 --> 00:24:03,259
con excepción de los constructores

235
00:24:03,259 --> 00:24:07,039
que la primera letra directamente es mayúscula porque como

236
00:24:07,039 --> 00:24:11,480
están obligados a llamarse como la clase y el convenio para las clases es que empiecen con mayúscula

237
00:24:11,480 --> 00:24:15,700
pues no nos queda más remedio que bien romper la norma de que las clases

238
00:24:15,700 --> 00:24:19,799
se empiecen por mayúscula o la de que los métodos empiecen por minúscula

239
00:24:19,799 --> 00:24:26,619
al tener que ser iguales, bueno pues aquí tenemos el constructor, ¿por qué nos

240
00:24:26,619 --> 00:24:30,460
interesa tener un constructor? bueno pues porque tenemos que llamar

241
00:24:30,460 --> 00:24:34,140
a setColor para que nos aplique un color que sea aleatorio

242
00:24:34,140 --> 00:24:38,680
a el setColor de la placa, entonces aquí lo que

243
00:24:38,680 --> 00:24:42,740
vamos a hacer va a ser llamar al método setColor

244
00:24:42,740 --> 00:25:00,240
En realidad vamos a hacer una sobrecarga de este método porque justo el setColor tradicional lo que suele hacer es copiar el que recibe como parámetro, se lo copia a la variable de clase, el setColor.

245
00:25:00,240 --> 00:25:20,559
Pero justo este set color no recibe la información desde fuera, sino que la completa a partir de un número aleatorio, porque podrá ser o bien los colores azul, marrón o verde, yo creo que era, azul, marrón o verde en igual proporción.

246
00:25:20,559 --> 00:25:42,210
¿Cómo podemos hacer que sea en igual proporción y que sea aleatorio? Disponemos de dos clases en la librería de Java para calcular números aleatorios. Una que está en la clase math con el método random que devuelve un double entre 0 y 1.

247
00:25:42,210 --> 00:25:46,170
y otro que está en la clase

248
00:25:46,170 --> 00:25:53,170
random, bueno, por ahí tenemos

249
00:25:53,170 --> 00:25:56,210
en java.util.random, habría que integrarlo, es otra de las

250
00:25:56,210 --> 00:25:58,930
opciones y también nos devuelve números aleatorios

251
00:25:58,930 --> 00:26:02,210
la clase random, su propio nombre lo indica

252
00:26:02,210 --> 00:26:05,190
y como método también integrado entre la clase

253
00:26:05,190 --> 00:26:08,029
mat, si esto nos devuelve un valor entre 0 y 1

254
00:26:08,029 --> 00:26:14,460
una posibilidad que tenemos, bueno, pues sería

255
00:26:14,460 --> 00:26:16,759
como nos devuelve un double

256
00:26:16,759 --> 00:26:21,250
mi color, vamos a poner aquí

257
00:26:21,250 --> 00:26:27,730
de color, cogemos

258
00:26:27,730 --> 00:26:29,609
un valor entre 0 y 1 con decimales

259
00:26:29,609 --> 00:26:33,509
y en igual proporción más o menos

260
00:26:33,509 --> 00:26:35,430
seríamos a un 0,3

261
00:26:35,430 --> 00:26:36,690
periodo del 3, ¿verdad?

262
00:26:37,089 --> 00:26:39,009
Para ir entre 0 y 0,3

263
00:26:39,009 --> 00:26:42,009
el 33% de las posibilidades

264
00:26:42,009 --> 00:26:43,589
que nos devolvería el

265
00:26:43,589 --> 00:26:45,470
más random, entre 0,33

266
00:26:45,470 --> 00:26:47,430
y 0,66 con el 6

267
00:26:47,430 --> 00:26:49,529
de nuevo periodo hasta donde

268
00:26:49,529 --> 00:26:51,450
queramos llegar y luego para completar

269
00:26:51,450 --> 00:26:53,430
desde el 0,66 una tercera parte

270
00:26:53,430 --> 00:26:55,509
hasta la unidad, que es lo que nos devuelve random.

271
00:26:57,680 --> 00:27:01,180
Entonces aquí podríamos coger y definir, para ahora hacer las comparaciones aquí,

272
00:27:03,910 --> 00:27:12,130
podríamos definir unas constantes, recordar que se definen parecido a las variables,

273
00:27:12,569 --> 00:27:17,430
en este caso nos interesa, ya que vamos a hacer una comparación con un double

274
00:27:17,430 --> 00:27:20,809
que nos está devolviendo el random, que sean variables de ese tipo,

275
00:27:20,809 --> 00:27:45,190
Vamos a definir la private también aquí. Double. Y vamos a definirla un tercio. Vamos a decir que sea igual a cero. Bueno, aquí podríamos poner tres en los que quisiéramos, ¿verdad? Vamos a poner esos. En realidad es tres periodo. Y luego podríamos decir dos tercios aquí. Dos tercios.

276
00:27:45,190 --> 00:27:53,460
directamente con esta variable ya nos valdría para que nos funcionase pero resulta que esto no son

277
00:27:53,460 --> 00:27:58,079
variables son constantes no vamos a querer que durante el programa esto vaya cambiando entonces

278
00:27:58,079 --> 00:28:03,359
para convertir una variable en una constante que la implicación que tiene es que luego su valor no

279
00:28:03,359 --> 00:28:10,500
pueda cambiarse a lo largo del código podemos poner la etiqueta final y esto convierte ya esta variable

280
00:28:10,500 --> 00:28:11,799
en una constante.

281
00:28:12,640 --> 00:28:14,039
Entonces ponemos final a las dos,

282
00:28:14,539 --> 00:28:16,579
ya tenemos ahí dos constantes, una al valor

283
00:28:16,579 --> 00:28:18,519
fijo de un tercio y otra

284
00:28:18,519 --> 00:28:19,619
al valor fijo de

285
00:28:19,619 --> 00:28:21,319
dos tercios.

286
00:28:22,460 --> 00:28:23,759
Y las constantes

287
00:28:23,759 --> 00:28:28,140
tenemos por convenio, igual que hablábamos

288
00:28:28,140 --> 00:28:29,539
de los métodos y las

289
00:28:29,539 --> 00:28:32,359
clases, que las clases su primera

290
00:28:32,359 --> 00:28:34,220
letra era mayúscula, los métodos empezaban

291
00:28:34,220 --> 00:28:36,220
con una letra minúscula,

292
00:28:36,220 --> 00:28:37,859
para que luego al identificar por ahí

293
00:28:37,859 --> 00:28:39,920
una constante en el código

294
00:28:39,920 --> 00:28:41,960
tengamos directamente la idea

295
00:28:41,960 --> 00:28:47,119
de que efectivamente es una constante las definimos con letras mayúsculas así un tercio

296
00:28:47,119 --> 00:29:05,279
aquí ponemos bien pues nada aquí cada vez que llamemos a set color más rando nos devolverá un

297
00:29:05,279 --> 00:29:10,700
valor entre 0 y 1 principio al ser aleatorio entendemos que la librería estará bien programada

298
00:29:10,700 --> 00:29:15,779
y no lo devolverán en las mismas proporciones no según el número de llamadas con la misma

299
00:29:15,779 --> 00:29:22,119
probabilidad es una posibilidad que tenemos aquí es decir y hay alternativas para gestionar cómo

300
00:29:22,119 --> 00:29:27,839
hacerlo esto si nos da tiempo vemos por ejemplo cómo lo podemos gestionar con un array y decir

301
00:29:27,839 --> 00:29:35,920
si el color es menor el color no el número que nos devuelve el random para determinar el color

302
00:29:35,920 --> 00:29:55,259
es menor a un tercio, entendemos que la diosa fortuna ha querido que el color de esa placa sea azul.

303
00:29:55,819 --> 00:30:07,599
Aquí hicimos el shift, si es menor que dos tercios, recordad que los shifts son autoexcluyentes,

304
00:30:07,740 --> 00:30:13,880
si entra por un tercio, lógicamente también es menor que dos tercios, pero como if el shift es autoexcluyente,

305
00:30:13,880 --> 00:30:18,079
en el momento en que fuese menor de 0,33, este ya no se valoraría.

306
00:30:21,349 --> 00:30:23,269
Con dos tercios podemos hablar de que sea marrón

307
00:30:23,269 --> 00:30:33,960
y en caso de no ser ni uno ni otro, pues decimos que sea verde.

308
00:30:39,069 --> 00:30:42,630
¿En qué caso asignamos un color? Pues vamos a asignar un color en el caso

309
00:30:42,630 --> 00:30:48,160
en el que llamemos que exista una placa. Si existe una placa

310
00:30:48,160 --> 00:30:51,799
como haremos el new y llamaremos al constructor, desde el propio

311
00:30:51,799 --> 00:30:56,160
constructor que se encarga de inicializar los objetos, pues nos

312
00:30:56,160 --> 00:31:01,740
interesa que esa placa tenga un color pues ese color llamamos al método set color y el set color

313
00:31:01,740 --> 00:31:06,839
ya está asignando a la variable de clase el color con el que va a trabajar mientras ese objeto viva

314
00:31:06,839 --> 00:31:17,109
mientras esté activo en el programa el ojo la clase placa prácticamente la tenemos ahí la clase

315
00:31:17,109 --> 00:31:26,130
frigorífico yo creo que prácticamente lo tenemos aquí y ahora pues la clase restaurante bueno pues

316
00:31:26,130 --> 00:31:41,380
Aquí tenemos el inicio y la clase cocina nos queda por implementar el método que informe de sus características.

317
00:31:41,619 --> 00:31:45,880
Después lo hacemos. Vamos a ir avanzando aquí. Cuando lo necesitemos ya lo atacamos.

318
00:31:48,259 --> 00:31:54,180
El ejercicio nos decía que lo primero que hace el programa es solicitar por teclado la cocina.

319
00:31:54,180 --> 00:32:13,690
Ahora, para acceder a información recibida desde el teclado, recordad, tenemos que acceder al flujo de datos SystemIn. El flujo de datos SystemIn tiene la posibilidad de leer desde aquí, fijaros, read, o sea, directamente desde SystemIn seríamos capaces de leer información desde el teclado.

320
00:32:13,690 --> 00:32:23,700
recordad que el teclado está directamente en todo programa asociado al flujo de datos system in pero

321
00:32:23,700 --> 00:32:29,900
bueno la forma de trabajar digamos con desde el código los métodos que tiene system in es un poco

322
00:32:29,900 --> 00:32:36,380
más incómoda que si nos apoyamos en otra librería que tenemos en la en java que ya conocemos que la

323
00:32:36,380 --> 00:32:46,579
clase escáner la clase escáner lo que hace es nos facilita trabajar con flujos de datos con

324
00:32:46,579 --> 00:32:54,299
¿Con qué flujo de datos? Con el que indiquemos aquí. Este flujo de datos podrá ser un fichero, si identificamos aquí un fichero,

325
00:32:54,680 --> 00:33:01,900
podrá ser una conexión con un socket. Un día hablábamos un poquito de los sockets, aunque trabajaréis con ellos más el año que viene

326
00:33:01,900 --> 00:33:12,240
en otra de las asignaturas. Y otro de los flujos de datos, que es el que en el 99% utilizamos para inyectar información en el objeto

327
00:33:12,240 --> 00:33:19,200
de la clase Scanner es precisamente el Sistening, que decimos que está asociado al teclado.

328
00:33:19,200 --> 00:33:28,539
Mi programa permite compilar directamente sin importar nada, sin hacer importaciones de otras clases,

329
00:33:29,720 --> 00:33:39,319
con cosas que están en mi propio paquete, con aquellas clases que tenemos disponibles desde la librería

330
00:33:39,319 --> 00:33:53,099
java lang por ejemplo si éste existe en out verdad si ponemos aquí un sistema out print ln directamente

331
00:33:53,099 --> 00:33:59,960
esto me compila porque esto está en las librerías java lang toda la librería java lang está integrada

332
00:33:59,960 --> 00:34:05,299
directamente en todo programa pero lo que no está en java lang ni pertenezca directamente a mi

333
00:34:05,299 --> 00:34:11,320
estructura de clases en mi paquete pues para que sepa dónde localizarlas tenemos que importar las

334
00:34:11,320 --> 00:34:18,460
dónde está la clase en qué librería está de las dejaba está la clase escáner en la java útil le

335
00:34:18,460 --> 00:34:23,800
decimos aquí metemos el import correspondiente en la cabecera y ya lo tenemos ahí disponible

336
00:34:23,800 --> 00:34:32,590
nuestro programa aquí en el main cuando termine el main se termina nuestro programa y se liberan

337
00:34:32,590 --> 00:34:38,469
los recursos pero podría ser que utilizásemos un escáner en un método que no fuese el main de ese

338
00:34:38,469 --> 00:34:44,690
programa siguiese funcionando entonces para dejar bien cerradito los flujos de datos es conveniente

339
00:34:44,690 --> 00:34:50,469
que todo flujo de datos que abramos aquí estamos abriendo un flujo de datos en system in lo cerremos

340
00:34:50,469 --> 00:34:57,010
una vez terminemos de trabajar con él entonces vamos a poner aquí abajo un close es especialmente

341
00:34:57,010 --> 00:35:01,070
preocupante esto no porque como se acaba el programa al finalizar el main se cerraría en

342
00:35:01,070 --> 00:35:08,150
cualquier caso pero bueno siempre queda mejor ahí no nos pide el nombre en primer lugar toda cocina

343
00:35:08,150 --> 00:35:10,150
va a tener un nombre, no hay lugar a dudas, pues ya

344
00:35:10,150 --> 00:35:12,050
está, aquí vamos a poner un system out

345
00:35:12,050 --> 00:35:14,250
para coger

346
00:35:14,250 --> 00:35:16,250
por teclado el nombre, en primer lugar

347
00:35:16,250 --> 00:35:17,369
nos lo vamos a pedir

348
00:35:17,369 --> 00:35:19,650
por consola, entonces

349
00:35:19,650 --> 00:35:21,710
indica el nombre

350
00:35:21,710 --> 00:35:23,949
de la cocina

351
00:35:23,949 --> 00:35:27,849
y ahora lo que hacemos es

352
00:35:27,849 --> 00:35:30,389
cargar ese nombre, ¿dónde vamos a cargar el nombre?

353
00:35:30,650 --> 00:35:31,949
pues tenemos una variable

354
00:35:31,949 --> 00:35:34,269
para

355
00:35:34,269 --> 00:35:35,690
guardar el nombre de la cocina

356
00:35:35,690 --> 00:35:37,869
aquí en cocina, ese nombre

357
00:35:37,869 --> 00:35:46,139
este atributo recordad que es privado es un string privado en la cocina entonces tenemos aquí una

358
00:35:46,139 --> 00:35:51,440
cocina que hemos instanciado y queremos guardar en esta cocina en su nombre el nombre de la cocina

359
00:35:51,440 --> 00:36:03,500
con la que vamos a trabajar entonces decimos mi cocina lo primero lo primero que nos apetecería

360
00:36:03,500 --> 00:36:13,010
poner es poner aquí después de mi cocina pues el parámetro del nombre ese nombre pero no me

361
00:36:13,010 --> 00:36:18,570
ofrece como parámetro porque no me lo ofrece el ide porque es privado no está al alcance solamente

362
00:36:18,570 --> 00:36:26,429
está al alcance de la propia clase cocina el perdonaje me quedé callado es que están son está

363
00:36:26,429 --> 00:36:32,550
sonando por megafonía y no sé si hay un aviso de desalojo o algo de eso supongo que no bueno

364
00:36:32,550 --> 00:36:42,719
entonces para acceder a la cocina vamos a utilizar el setter de este parámetro se nombre verdad set

365
00:36:42,719 --> 00:36:50,380
nombre y el nombre en sí se lo asignamos como parámetro aquí recordad este parámetro lo que

366
00:36:50,380 --> 00:36:56,840
hace es como variable local al métodos en nombre en este ámbito fijaros como al marcarlos identifican

367
00:36:56,840 --> 00:37:02,960
los dos se ponen los dos en negrita se lo aplica al a la variable que tiene justo el mismo nombre

368
00:37:02,960 --> 00:37:07,900
pero anteponiendo el 10 lo cual quiere decir que se refiere a la variable de clase fijaros

369
00:37:07,900 --> 00:37:24,840
en este otro caso pues ahora vamos a ponerle el nombre que cogemos desde escáner te vamos a poner

370
00:37:24,840 --> 00:37:32,659
aquí vamos a poner que un string ese aus una variable auxiliar string podemos poner aquí esto

371
00:37:32,659 --> 00:37:41,719
que sea igual a mi scan punto netline cogemos el nombre de la cocina se aplica ese aus y ahora ese

372
00:37:41,719 --> 00:37:50,800
aus lo ponemos aquí fijaros estas dos instrucciones bueno pues ahora está bien que las pongáis juntas

373
00:37:50,800 --> 00:37:55,739
luego ya con el tiempo pues intentaréis compactar código porque resultará probablemente más cómodo

374
00:37:55,739 --> 00:38:02,420
más cómodo y que podríamos hacer pues fijaros podríamos hacer sustituir estas dos líneas ahora

375
00:38:02,420 --> 00:38:07,639
el momento que pongáis las dos líneas yo creo que hasta os resulta útil para para que se entienda

376
00:38:07,639 --> 00:38:13,739
mejor aquí lo que hacemos es que lo que cogemos desde tecla desde este teclado lo cargamos en una

377
00:38:13,739 --> 00:38:21,000
variable y luego a esta variable con el setter le aplicamos lo que tiene la variable que anteriormente

378
00:38:21,000 --> 00:38:32,030
hemos cogido por teclado podríamos integrar esas dos líneas y ponerlo así aplicamos al nombre de

379
00:38:32,030 --> 00:38:38,130
la cocina con el setter lo que cogemos por teclado estas dos líneas en dos pasos serían equivalentes

380
00:38:38,130 --> 00:38:49,599
a esta a continuación por aquí nos dice nada nos va a dar tiempo a terminar son las 8 y 10 ya pero

381
00:38:49,599 --> 00:38:53,260
Bueno, solicita por el teclado si hay frigorífico en la cocina.

382
00:38:53,619 --> 00:38:56,380
Y conocido este dato, se hace el new del frigorífico.

383
00:38:58,489 --> 00:39:00,929
Pues nada, vamos a ver si hay frigorífico.

384
00:39:00,929 --> 00:39:08,139
Decimos system out, println, hay frigorífico.

385
00:39:16,320 --> 00:39:17,980
Vamos a decirle que nos diga sí o no.

386
00:39:18,400 --> 00:39:20,880
No recuerdo si exactamente es como lo dice el enunciado.

387
00:39:21,599 --> 00:39:24,039
Pues nada, ante la pregunta de si hay frigorífico,

388
00:39:24,840 --> 00:39:26,380
lo cogemos desde el teclado.

389
00:39:30,130 --> 00:39:31,929
Aquí recuperaremos un sí o un no.

390
00:39:31,929 --> 00:39:37,510
aquí podríamos meter alguno lo habéis hecho ya para proteger que éste sea así o no podríamos

391
00:39:37,510 --> 00:39:43,389
meter un bucle mientras sea diferente así o no sigue pidiendo vamos a entender que el dato se

392
00:39:43,389 --> 00:39:50,150
mete correctamente o si no es sí y metes cualquier otra cosa es no vale sí otro día retomamos el

393
00:39:50,150 --> 00:39:59,429
ejercicio lo afinamos un poquito más entonces qué haríamos comprobaríamos sí lo que acabo de recibir

394
00:39:59,429 --> 00:40:07,670
recordad que ese aus es una variable de tipo string está entre medias de ser un tipo de

395
00:40:07,670 --> 00:40:15,510
referenciado y un tipo primitivo para unas cosas no es necesario hacer el new con lo cual se parece

396
00:40:15,510 --> 00:40:19,710
un poco a los primitivos pero más bien es referenciado y una de las características

397
00:40:19,710 --> 00:40:24,190
que tiene por ser referenciado es que no podemos compararlo con igual igual no nos vale esta

398
00:40:24,190 --> 00:40:30,550
comparación entonces que como lo tenemos que utilizar cómo podemos compararlo con un compare

399
00:40:30,550 --> 00:40:38,849
tú si queremos que nos valga cualquier combinación de sí sin minúsculas y mayúsculas si entre

400
00:40:38,849 --> 00:40:44,849
minúscula y mayúscula como está el caso aquí de esta opción puede hacer un utilizar el compare

401
00:40:44,849 --> 00:40:51,710
tú ignore case este caso le vale mayúsculas minúsculas y de todo tipo y si quiero mantener

402
00:40:51,710 --> 00:40:55,889
esa característica, pero sin utilizar el compare to in every case, puedo utilizar

403
00:40:55,889 --> 00:40:59,989
el compare to que obliga que diferencia entre mayúsculas y minúsculas

404
00:40:59,989 --> 00:41:03,670
pero en ese caso lo que podríamos hacer es utilizar aquí otro

405
00:41:03,670 --> 00:41:14,309
método que es el to, comparar aquí con sí

406
00:41:14,309 --> 00:41:18,949
en mayúsculas y ese aus aquí podría coger y decir

407
00:41:18,949 --> 00:41:22,550
que ese aus se igual a ese aus punto to

408
00:41:22,550 --> 00:41:26,989
uppercase, entonces este como este, ese aus

409
00:41:26,989 --> 00:41:32,929
aquí con mayúsculas minúsculas en este paso lo convierto con toda seguridad a mayúsculas y aquí

410
00:41:32,929 --> 00:41:39,469
puedo comparar con el compare tú directamente poniendo las mayúsculas ya que el aus ese aus

411
00:41:39,469 --> 00:41:46,969
con toda seguridad pondrá sino o lo que sea pero estar en mayúsculas dado que hemos ejecutado aquí

412
00:41:46,969 --> 00:41:55,469
antes el método tu perquis en las estructuras de control necesariamente tenemos que poner aquí

413
00:41:55,469 --> 00:42:02,650
algo que se evalúe como verdadero o falso el compare tú devuelve compare tú en particular

414
00:42:02,650 --> 00:42:08,989
devuelve un valor numérico no es el mejor lo podemos hacer con el compare tú devuelve cero

415
00:42:08,989 --> 00:42:18,190
si es igual un valor menor que cero si es menor una s aus que el sí y un valor mayor que cero si

416
00:42:18,190 --> 00:42:27,030
es mayor esto nos permite al devolvernos mayor menor o igual nos permite ordenar los algoritmos

417
00:42:27,030 --> 00:42:32,710
ordenación utilizar el compare tú entonces esto lo podríamos utilizar con si lo que me devuelve

418
00:42:32,710 --> 00:42:39,090
es un cero quiere decir que ese aus es igual a si te diría cero es igual a cero en caso de ser

419
00:42:39,090 --> 00:42:45,869
iguales me devolvería un truco y luego podemos utilizar el método más directo que en lugar del

420
00:42:45,869 --> 00:42:55,719
compare tú sea el ecuador el cual ya sí que devuelve un booleán diciendo si son iguales

421
00:42:55,719 --> 00:43:01,900
o no lo son mejor es cuál es más directo en este caso que no necesitamos ordenar y sólo queremos

422
00:43:01,900 --> 00:43:08,099
saber si son mayores o no lo son en este caso resulta que tenemos frigorífico entonces pues

423
00:43:08,099 --> 00:43:21,019
nada nos pondríamos a nos pondríamos a trabajar sobre estas dos variables la boolean y él

424
00:43:22,579 --> 00:43:29,099
y sobre el frigorífico para darle alta fijaros el frigorífico el setter del frigorífico recibe

425
00:43:29,099 --> 00:43:39,139
un objeto de la clase frigorífico es decir es un un setter copia lo que hace es asignar la

426
00:43:39,139 --> 00:43:45,119
referencia de un frigorífico que está recibiendo por aquí al frigorífico que tiene la clase y el

427
00:43:45,119 --> 00:43:51,719
setter de si tiene frigorífico el boolean recibe un boolean que será yes en caso de tenerlo y no

428
00:43:51,719 --> 00:43:58,619
en caso de no tenerlo entonces en el caso de tener frigorífico lo que haríamos sería llamar

429
00:43:58,619 --> 00:44:13,539
a mi cocina punto set de frigorífico en este caso diríamos true sí que tiene frigorífico y en el

430
00:44:13,539 --> 00:44:21,030
setter del frigorífico le tenemos que pasar un objeto de la clase frigorífico veis entonces lo

431
00:44:21,030 --> 00:44:27,849
que podríamos hacer aquí es llamar a un frigorífico crear un nuevo frigorífico es decir frigorífico

432
00:44:27,849 --> 00:44:29,630
miFrig

433
00:44:29,630 --> 00:44:32,250
igual a

434
00:44:32,250 --> 00:44:34,789
newFrigorífico

435
00:44:34,789 --> 00:44:37,639
Aquí acabo de construir

436
00:44:37,639 --> 00:44:38,519
un frigorífico

437
00:44:38,519 --> 00:44:41,340
y el setter este

438
00:44:41,340 --> 00:44:43,639
lo que recibe es una referencia a un frigorífico.

439
00:44:44,599 --> 00:44:45,559
Entonces, para llamar a este método

440
00:44:45,559 --> 00:44:47,619
lo tenemos que pasar una referencia a un frigorífico

441
00:44:47,619 --> 00:44:49,699
y esa referencia la tenemos aquí.

442
00:44:50,260 --> 00:44:50,920
Como podéis ver.

443
00:44:51,139 --> 00:44:52,780
El frigorífico que acabo de construir.

444
00:44:59,440 --> 00:44:59,760
Este

445
00:44:59,760 --> 00:45:03,440
y le pasamos la referencia al frigorífico.

446
00:45:03,440 --> 00:45:16,440
Me estoy obligando a hacer esto porque lo he definido aquí como privado. Si el frigorífico aquí no fuese privado, directamente haríamos el new sobre este frigorífico y nos dejaríamos de ese setter.

447
00:45:16,760 --> 00:45:48,369
Bueno, como existe frigorífico, antes de asignarlo, aquí lo que podríamos hacer es pedir la marca del frigorífico, aquí la cargo y esta marca del frigorífico en realidad se la tengo que asignar al frigorífico.

448
00:45:48,369 --> 00:45:54,610
fijaros acordaros que el frigorífico tiene el setter de la marca por el frigorífico

449
00:45:55,690 --> 00:46:00,989
entonces esa marca que la he capturado aquí la tengo en ese aus guardadita en el momento en el

450
00:46:00,989 --> 00:46:09,050
que construye el frigorífico puede decir mi frig punto set marca ese aus es aquí pongo la marca

451
00:46:09,050 --> 00:46:17,340
al frigorífico que acabo de construir le pongo la marca que le había cargado aquí mejor por cercanía

452
00:46:17,340 --> 00:46:30,880
es como más directo aquí separamos así esto construimos el frigorífico asignamos marca

453
00:46:30,880 --> 00:46:37,059
al frigorífico y asociamos al frigorífico con el setter la referencia del frigorífico que he

454
00:46:37,059 --> 00:46:48,179
creado en el mail aquí tendríamos el frigorífico y en caso de que no existe ese frigorífico pues

455
00:46:48,179 --> 00:46:56,059
podríamos que la cocina decir false y ya no existe frigorífico pues no tenemos que hacer

456
00:46:56,059 --> 00:47:05,800
el new del frigorífico ni nada al no existir el frigorífico. Vamos a hacer

457
00:47:05,800 --> 00:47:10,460
copy-paste de esto para la placa y la adaptamos.

458
00:47:12,570 --> 00:47:18,820
Hay placa, si no, si resulta que hay

459
00:47:18,820 --> 00:47:22,480
placa, decimos en lugar del set frigorífico

460
00:47:22,480 --> 00:47:26,599
set placa verdadero y aquí

461
00:47:26,599 --> 00:47:30,480
en este caso diríamos set placa falso. No existe placa.

462
00:47:31,280 --> 00:47:34,599
Si existe placa, pues ¿qué vamos a hacer? Vamos a definir

463
00:47:34,599 --> 00:47:47,929
una placa auxiliar aquí mi placa fijaros en este momento esta placa hace la reserva para una placa

464
00:47:47,929 --> 00:47:55,789
una placa que es una variable local al método main del restaurante pero luego se la vamos a pasar

465
00:47:55,789 --> 00:48:02,050
aquí para cuando completemos y lo pongamos esto bien para que se quede esa referencia esta placa

466
00:48:02,050 --> 00:48:10,099
que estamos construyendo aquí como placa de la cocina en el caso de la placa no hay que pedir

467
00:48:10,099 --> 00:48:17,300
la marca de la placa y en realidad lo que con lo que jugábamos con la placa era con el color y el

468
00:48:17,300 --> 00:48:22,639
color fijaos recordad que se llamaba aquí estamos llamando al constructor de esta placa que estamos

469
00:48:22,639 --> 00:48:29,239
generando y el constructor era el que llamaba set color con lo cual aquí hace ya toda la jugada nos

470
00:48:29,239 --> 00:48:43,960
aplica el color que tenga esa placa venimos aquí el restaurante en caso de existir la placa decimos

471
00:48:43,960 --> 00:49:08,960
mi codicina, punto, set placa y recibe, perdón, no set placa, no, punto, set mi placa, este, que recibe como parámetro una referencia a una placa, mi placa.

472
00:49:08,960 --> 00:49:20,360
Aquí le ponemos el punto y coma y ya nos compila.

473
00:49:24,079 --> 00:49:26,420
¿Y qué nos queda del ejercicio?

474
00:49:26,920 --> 00:49:30,880
Pues nos queda que el método informov.

475
00:49:31,159 --> 00:49:35,079
El método informov muestra por pantalla el resumen del inmobiliario disponible,

476
00:49:35,820 --> 00:49:38,460
pero decimos que devuelva esa información, informov.

477
00:49:41,059 --> 00:49:45,739
Entonces aquí creamos un método que sea public,

478
00:49:47,000 --> 00:49:50,420
devuelve string, se llama informov,

479
00:49:50,420 --> 00:49:54,110
formar el mobiliario

480
00:49:54,110 --> 00:49:58,170
y ahora aquí tiene que construir

481
00:49:58,170 --> 00:50:00,130
en base a toda esta información

482
00:50:00,130 --> 00:50:01,969
si tiene placa, no tiene placa

483
00:50:01,969 --> 00:50:03,090
como es la jugada

484
00:50:03,090 --> 00:50:06,289
como devuelve un string

485
00:50:06,289 --> 00:50:08,389
pues tendría que haber un return

486
00:50:08,389 --> 00:50:10,050
aquí, vamos a poner

487
00:50:10,050 --> 00:50:12,369
ese información

488
00:50:12,369 --> 00:50:17,599
y la variable

489
00:50:17,599 --> 00:50:19,920
esa información la podemos definir aquí como local

490
00:50:19,920 --> 00:50:23,179
y la podemos ir construyendo

491
00:50:23,179 --> 00:50:24,159
poco a poco, es decir

492
00:50:24,159 --> 00:50:26,940
la cocina

493
00:50:26,940 --> 00:50:30,159
una determinada cocina

494
00:50:30,159 --> 00:50:31,219
que tiene un nombre

495
00:50:31,219 --> 00:50:33,280
ese nombre, variable local

496
00:50:33,280 --> 00:50:36,059
aquí no hace falta el getNombre porque es una variable

497
00:50:36,059 --> 00:50:38,159
local, este método

498
00:50:38,159 --> 00:50:39,920
pertenece aquí, por mucho que sea privado

499
00:50:39,920 --> 00:50:42,119
tiene el alcance, le llega

500
00:50:42,119 --> 00:50:50,489
y ahora podemos ir haciendo

501
00:50:50,489 --> 00:50:52,369
a ver, que es lo que me pasa aquí

502
00:50:52,369 --> 00:50:54,050
esto lo defino como string

503
00:50:54,050 --> 00:50:57,630
y ahora puedo ir completando, digo

504
00:50:57,630 --> 00:50:58,630
sí, if

505
00:50:58,630 --> 00:51:03,190
si no tiene

506
00:51:03,190 --> 00:51:07,880
frigorífico

507
00:51:07,880 --> 00:51:46,449
y no tiene placa, ni frigorífico, ni placa, entonces, bueno, pues podría completar ese info, esa información, que es lo que estoy volviendo luego aquí, lo completo con lo que ya tiene hasta ahora, más, no tiene ni frigorífico, ni el shift.

508
00:51:46,449 --> 00:52:34,269
A ver, si no tiene frigorífico y tiene placa, placa y no frigorífico, voy a decir no tiene placa y su frigorífico es de marca y tenemos que la marca la tenemos aquí con el frigorífico, punto frigorífico, get marca.

509
00:52:34,269 --> 00:52:41,949
la hacemos, perdonad si voy un poco rápido

510
00:52:41,949 --> 00:52:44,889
intentando a ver si nos da tiempo

511
00:52:44,889 --> 00:52:48,050
encima no tiene frigorífico

512
00:52:48,050 --> 00:52:54,030
y su placa es de color

513
00:52:54,030 --> 00:53:01,570
dead color

514
00:53:01,570 --> 00:53:05,369
y ya el else es la otra combinación que nos queda

515
00:53:05,369 --> 00:53:10,400
en principio tiene frigorífico y placa

516
00:53:10,400 --> 00:53:13,320
decimos

517
00:53:13,320 --> 00:53:18,110
tiene un frigorífico

518
00:53:18,110 --> 00:53:20,210
frigorífico

519
00:53:20,210 --> 00:53:21,710
de marca

520
00:53:21,710 --> 00:53:28,300
mi frigg.get

521
00:53:28,300 --> 00:53:31,500
marca y su

522
00:53:31,500 --> 00:53:32,500
placa es de color

523
00:53:32,500 --> 00:53:34,860
vamos a hacer una prueba

524
00:53:34,860 --> 00:53:37,519
fijaros, mi import devuelve un string

525
00:53:37,519 --> 00:53:41,559
con lo cual aquí lo que haremos será llamar

526
00:53:41,559 --> 00:53:42,780
a

527
00:53:42,780 --> 00:53:46,719
mi cocina

528
00:53:46,719 --> 00:53:49,400
punto

529
00:53:49,400 --> 00:53:51,639
mi inform

530
00:53:51,639 --> 00:53:57,440
inform of

531
00:53:57,440 --> 00:54:00,320
y esto lo que queremos es soltarlo

532
00:54:00,320 --> 00:54:01,940
por pantalla

533
00:54:01,940 --> 00:54:03,659
println

534
00:54:03,659 --> 00:54:14,019
mi cocina

535
00:54:14,019 --> 00:54:18,309
.get

536
00:54:18,309 --> 00:54:21,880
.informov

537
00:54:21,880 --> 00:54:23,480
aquí lo tenemos

538
00:54:23,480 --> 00:54:26,039
falta aquí

539
00:54:26,039 --> 00:54:27,019
un paréntesis

540
00:54:27,019 --> 00:54:31,119
y nada, vamos a hacer un par de ejecuciones

541
00:54:31,119 --> 00:54:33,980
y a ver si nos va, si no la terminamos de revisar

542
00:54:33,980 --> 00:54:36,039
el próximo día, lanzamos por aquí

543
00:54:36,039 --> 00:54:37,639
nombre cocina A

544
00:54:37,639 --> 00:54:39,099
¿tiene frigorífico? no

545
00:54:39,099 --> 00:54:41,860
¿tiene placa? no, la cocina A

546
00:54:41,860 --> 00:54:43,559
no tiene ni frigorífico ni placa

547
00:54:44,219 --> 00:54:44,820
Siguiente prueba.

548
00:54:46,719 --> 00:54:49,519
A, vamos a decir que sí tiene frigorífico y que no tiene placa.

549
00:54:50,000 --> 00:54:54,000
A, el nombre frigorífico, Fagor, y no tiene placa.

550
00:54:55,420 --> 00:54:57,800
Uy, él no tiene placa, no le ha gustado por ahí.

551
00:54:59,400 --> 00:55:01,260
Displaca nul, claro.

552
00:55:01,260 --> 00:55:11,630
Aquí, lo que pasa es que aquí, si no tiene placa, se nos va aquí.

553
00:55:14,329 --> 00:55:15,750
Bueno, habría que revisarlo un poco.

554
00:55:19,900 --> 00:55:23,260
Vamos a decir que sí tiene frigorífico, sí tiene placa.

555
00:55:23,320 --> 00:55:45,599
Bueno, dice que tiene... Ah, tiene... Tampoco me dice el nombre del frigorífico. Bueno, queda pendiente darle una vueltecilla. Pero vamos a tener que parar aquí porque están ya preparando para, como os comentaba antes, hacer lo de los proyectos en la aula y están empezando a venir los compañeros para presentar su proyecto.

556
00:55:45,599 --> 00:55:58,590
Si tenéis la solución del ejercicio completa en aula virtual, con las prisas, bueno, no os ha dado tiempo a depurarlo, pero a grandes rasgos, así es como había que montar el ejercicio.

557
00:55:59,550 --> 00:56:02,190
¿Alguna consulta que queréis hacerme antes de cerrar?

558
00:56:06,539 --> 00:56:15,119
Si estáis muy interesados en completar este ejercicio, el próximo día ya después de Navidad lo damos una vueltecilla y lo terminamos de completar en un ratito.

559
00:56:15,340 --> 00:56:17,599
Y si no, pues bueno, pasamos directamente a cosas nuevas.

560
00:56:17,599 --> 00:56:22,639
bueno, sin nada

561
00:56:22,639 --> 00:56:25,880
si no tenéis nada

562
00:56:25,880 --> 00:56:28,400
nos vemos ya justo a la vuelta de navidades

563
00:56:28,400 --> 00:56:30,260
el día 11 me parece que es

564
00:56:30,260 --> 00:56:31,800
la primera semana de

565
00:56:31,800 --> 00:56:34,460
la primera no, la segunda semana de enero

566
00:56:34,460 --> 00:56:36,119
que paséis una buena fiesta

567
00:56:36,119 --> 00:56:38,900
y nada, descansad y comen mucho turrón

568
00:56:38,900 --> 00:56:40,460
venga

569
00:56:40,460 --> 00:56:42,900
pues nada, felices fiestas

570
00:56:42,900 --> 00:56:44,760
hasta luego, aquí corto

571
00:56:44,760 --> 00:56:46,000
hasta luego