1
00:00:00,000 --> 00:00:05,000
Bueno, pues venga, estábamos programando esta clase, ¿vale?

2
00:00:05,000 --> 00:00:11,000
Por ahora habíamos dicho que una vez decidida la clase, esto empezaba

3
00:00:11,000 --> 00:00:16,000
con la palabra CLAS, todo en minúscula, y el nombre que nosotros decidíamos

4
00:00:16,000 --> 00:00:21,000
como pauta que deberíamos seguir de estilo, empezando en letra mayúscula

5
00:00:21,000 --> 00:00:23,000
y lo más explicativa posible.

6
00:00:23,000 --> 00:00:25,000
Vale, bueno, pues ¿ahora qué hacemos dentro?

7
00:00:25,000 --> 00:00:27,000
¿Ahora qué hacemos dentro?

8
00:00:27,000 --> 00:00:29,000
Pues dentro esencialmente hay dos partes.

9
00:00:29,000 --> 00:00:34,000
A ver, yo todo lo que os voy contando es...

10
00:00:36,000 --> 00:00:38,000
Iba a decir es pseudo-mentira, no es que sea mentira.

11
00:00:38,000 --> 00:00:43,000
Lo que pasa es que, claro, hay que incorporar, robo, tantísimas cosas

12
00:00:43,000 --> 00:00:45,000
que hay muchas cosas que no os voy a decir.

13
00:00:45,000 --> 00:00:47,000
Entonces vos veis a lo mejor una clase, veis el programa y decís

14
00:00:47,000 --> 00:00:49,000
¡Uy, pero esta parte me falta!

15
00:00:49,000 --> 00:00:53,000
Vale, es que no podemos meternos todo de golpe ni hablarlo todo, ¿vale?

16
00:00:53,000 --> 00:00:55,000
Vamos progresivamente.

17
00:00:55,000 --> 00:01:00,000
Bueno, pues esencialmente una clase tiene dentro dos partes.

18
00:01:03,000 --> 00:01:05,000
Dos partes.

19
00:01:06,000 --> 00:01:10,000
Una parte es la de las propiedades

20
00:01:14,000 --> 00:01:18,000
y otra parte es la de los métodos.

21
00:01:20,000 --> 00:01:24,000
Esas dos partes son las que tiene, la de las propiedades y la de los métodos.

22
00:01:26,000 --> 00:01:30,000
Bueno, pues en la parte de las propiedades, ¿qué codificamos?

23
00:01:30,000 --> 00:01:36,000
Ahí codificamos las propiedades que hemos decidido nosotros

24
00:01:36,000 --> 00:01:39,000
que necesitamos para caracterizar el pedido.

25
00:01:39,000 --> 00:01:43,000
Ahí ponemos lo que nos interesa que caracterice a los pedidos.

26
00:01:43,000 --> 00:01:46,000
Las cosas que nos interesan, no.

27
00:01:46,000 --> 00:01:49,000
Entonces si hemos decidido, después de hacer un buen diseño,

28
00:01:49,000 --> 00:01:56,000
que el pedido sólo necesita para caracterizarse su código y su descripción,

29
00:01:56,000 --> 00:01:59,000
pues esas son sus dos propiedades, código y descripción.

30
00:01:59,000 --> 00:02:02,000
Y ahora toca declararlas aquí.

31
00:02:02,000 --> 00:02:05,000
¿Cómo se declaran las propiedades de una clase?

32
00:02:05,000 --> 00:02:07,000
¿Cómo se declaran las variables?

33
00:02:07,000 --> 00:02:09,000
Exactamente igual, no hay ninguna diferencia.

34
00:02:09,000 --> 00:02:13,000
Bueno, pues si yo he decidido que una propiedad del pedido es el código,

35
00:02:13,000 --> 00:02:17,000
pues tengo que pensar, vale, ¿y el código qué tipo de dato es?

36
00:02:17,000 --> 00:02:20,000
Pues tiene que ser uno de los tipos de datos de Java que conocemos.

37
00:02:20,000 --> 00:02:23,000
Venga, el código va a ser un número entero, vale,

38
00:02:23,000 --> 00:02:27,000
pues declaro esa propiedad como declaro cualquier variable entera.

39
00:02:27,000 --> 00:02:31,000
Int, tipo de dato y el nombre de la propiedad.

40
00:02:35,000 --> 00:02:38,000
Entonces esto es como declarar una variable, exactamente igual.

41
00:02:38,000 --> 00:02:40,000
Exactamente igual.

42
00:02:40,000 --> 00:02:43,000
La puedo inicializar también, aunque eso por ahora vamos a dejarlo,

43
00:02:43,000 --> 00:02:48,000
porque ya veremos eso qué implica.

44
00:02:48,000 --> 00:02:54,000
Sigue el mismo criterio de estilo que las propiedades que empiecen con minúscula,

45
00:02:54,000 --> 00:02:57,000
porque en realidad eso es una declaración de variable,

46
00:02:57,000 --> 00:03:01,000
pero es una declaración de variable hecha dentro de una clase.

47
00:03:01,000 --> 00:03:02,000
¿Eso qué significa?

48
00:03:02,000 --> 00:03:07,000
Que esta variable es una propiedad del pedido.

49
00:03:07,000 --> 00:03:10,000
Eso significa, vale.

50
00:03:10,000 --> 00:03:13,000
Bueno, pues ya tengo mi primera propiedad declarada.

51
00:03:13,000 --> 00:03:16,000
Pues los pedidos se caracterizan por su código.

52
00:03:16,000 --> 00:03:19,000
Pues ya está, pongo aquí su propiedad, vale,

53
00:03:19,000 --> 00:03:21,000
y la declaro como cualquier otra variable.

54
00:03:21,000 --> 00:03:25,000
A ver qué más propiedades hemos decidido que interesan para caracterizar un pedido.

55
00:03:25,000 --> 00:03:27,000
Hemos dicho que la descripción.

56
00:03:27,000 --> 00:03:29,000
Bueno, pues ahora pensamos, vale, la descripción,

57
00:03:29,000 --> 00:03:31,000
¿qué tipo de dato le interesa?

58
00:03:31,000 --> 00:03:33,000
Pues si es una cadena pedido de bolis.

59
00:03:33,000 --> 00:03:36,000
Pues string, es el tipo de dato que le interesa.

60
00:03:36,000 --> 00:03:39,000
Pues entonces lo declaramos como cualquier otra variable.

61
00:03:39,000 --> 00:03:43,000
String, string y el nombre de la variable.

62
00:03:48,000 --> 00:03:53,000
Vale, entonces nombres lo más explicativos posibles.

63
00:03:53,000 --> 00:03:56,000
Cuando hay una clase con propiedades X e Y,

64
00:03:56,000 --> 00:03:57,000
eso es horroroso.

65
00:03:57,000 --> 00:03:59,000
¿X y qué propiedad es X?

66
00:03:59,000 --> 00:04:00,000
¿Y qué propiedad es Y?

67
00:04:00,000 --> 00:04:03,000
Sin embargo aquí uno ve código de descripción

68
00:04:03,000 --> 00:04:07,000
y rápidamente ya entiende que va a contener esto.

69
00:04:07,000 --> 00:04:09,000
Pues esto va a contener un código, el del pedido.

70
00:04:09,000 --> 00:04:11,000
Esto va a contener una descripción, el del pedido.

71
00:04:11,000 --> 00:04:14,000
Si yo la llamo X e Y, ¿qué va a contener X e Y?

72
00:04:14,000 --> 00:04:16,000
Lo sabrá él que las ha declarado y las va a usar,

73
00:04:16,000 --> 00:04:19,000
pero nadie más sabe qué va a contener X e Y.

74
00:04:19,000 --> 00:04:22,000
Entonces vamos a elegir nombres explicativos

75
00:04:22,000 --> 00:04:24,000
que empiecen con minúscula, no obligatorio,

76
00:04:24,000 --> 00:04:30,000
pero es un criterio de estilo que deberíamos seguir, recomendable,

77
00:04:30,000 --> 00:04:33,000
y tipo de dato de los que conocemos, de Java.

78
00:04:33,000 --> 00:04:34,000
Bueno, pues nuestro pedido.

79
00:04:34,000 --> 00:04:36,000
Si ya no tiene más propiedades,

80
00:04:36,000 --> 00:04:38,000
porque no le hacen falta más,

81
00:04:38,000 --> 00:04:39,000
ya hemos acabado con la parte de propiedades,

82
00:04:39,000 --> 00:04:40,000
ya la hemos terminado.

83
00:04:40,000 --> 00:04:43,000
Ya está, ya no hay más que poner nada más.

84
00:04:43,000 --> 00:04:44,000
Cuidado.

85
00:04:44,000 --> 00:04:48,000
Entonces ahora habría que hacer la parte de métodos.

86
00:04:48,000 --> 00:04:50,000
Pero antes de meternos con la parte de métodos,

87
00:04:50,000 --> 00:04:53,000
vamos a entender ahora cómo funciona una aplicación

88
00:04:53,000 --> 00:04:54,000
que tiene pedidos.

89
00:04:54,000 --> 00:04:55,000
Porque esta clase pedido, ¿ahora qué?

90
00:04:55,000 --> 00:04:57,000
¿Y los pedidos dónde están?

91
00:04:57,000 --> 00:04:59,000
¿Y el pedido qué código tiene?

92
00:04:59,000 --> 00:05:00,000
¿Y cuántos pedidos tengo?

93
00:05:00,000 --> 00:05:03,000
¿Y si mi aplicación tiene 20 pedidos?

94
00:05:03,000 --> 00:05:04,000
¿Qué tengo, 20 clases?

95
00:05:04,000 --> 00:05:06,000
O sea, ese tipo de cosas se han quedado como...

96
00:05:06,000 --> 00:05:08,000
¿Y qué significa una clase pedido?

97
00:05:08,000 --> 00:05:09,000
¿Y ahora esto cómo se usa?

98
00:05:09,000 --> 00:05:11,000
¿Cómo se usa esto?

99
00:05:11,000 --> 00:05:14,000
Bueno.

100
00:05:14,000 --> 00:05:16,000
A ver, todo esto que estamos viendo ahora

101
00:05:16,000 --> 00:05:18,000
es lo más importante de entender.

102
00:05:18,000 --> 00:05:21,000
Porque una vez entendido el funcionamiento,

103
00:05:21,000 --> 00:05:24,000
luego ya los detalles de cómo se codifica esto,

104
00:05:24,000 --> 00:05:25,000
cómo se codifican los métodos,

105
00:05:25,000 --> 00:05:27,000
son detalles de sintaxis.

106
00:05:27,000 --> 00:05:28,000
Eso no es el problema.

107
00:05:28,000 --> 00:05:30,000
El problema es entender la filosofía

108
00:05:30,000 --> 00:05:32,000
de la relación entre dos objetos.

109
00:05:32,000 --> 00:05:34,000
Bueno, pues hasta aquí estamos simplemente

110
00:05:34,000 --> 00:05:37,000
en que hemos decidido que haya una clase pedido

111
00:05:37,000 --> 00:05:40,000
porque mi aplicación va a trabajar con pedidos.

112
00:05:40,000 --> 00:05:41,000
Va a trabajar con ellos.

113
00:05:41,000 --> 00:05:43,000
Entonces tiene sentido que haya una clase pedido.

114
00:05:43,000 --> 00:05:45,000
Tiene sentido.

115
00:05:45,000 --> 00:05:47,000
Y una vez que lo he decidido,

116
00:05:47,000 --> 00:05:51,000
codifico, declaro las propiedades que lo caracterizan.

117
00:05:51,000 --> 00:05:53,000
Ahora ya vendría la pregunta natural de

118
00:05:53,000 --> 00:05:55,000
¿y mi aplicación funcionando dónde está?

119
00:05:55,000 --> 00:05:57,000
¿Dónde está mi aplicación que yo arranco,

120
00:05:57,000 --> 00:05:59,000
le doy al play de la aplicación

121
00:05:59,000 --> 00:06:01,000
y dónde está esa aplicación?

122
00:06:01,000 --> 00:06:02,000
¿Y pedidos?

123
00:06:02,000 --> 00:06:03,000
¿Cuántos puedo tener?

124
00:06:03,000 --> 00:06:04,000
¿20, 30?

125
00:06:04,000 --> 00:06:06,000
Porque ahí solo tengo una clase.

126
00:06:06,000 --> 00:06:07,000
¿Puedo tener 20 pedidos?

127
00:06:07,000 --> 00:06:09,000
Pues sí, eso es una aplicación que trabaja con pedidos

128
00:06:09,000 --> 00:06:11,000
y debería poder tener 30, 40, 50.

129
00:06:11,000 --> 00:06:12,000
Entonces, ¿qué?

130
00:06:12,000 --> 00:06:14,000
¿Eso cómo encaja con que haya una sola clase?

131
00:06:14,000 --> 00:06:15,000
¿Cómo lo ha...?

132
00:06:15,000 --> 00:06:16,000
¿Cómo encaja?

133
00:06:16,000 --> 00:06:18,000
Bueno, pues entonces,

134
00:06:18,000 --> 00:06:22,000
vamos a seguir construyendo esta mini aplicación.

135
00:06:22,000 --> 00:06:24,000
Vale, pues efectivamente

136
00:06:24,000 --> 00:06:27,000
tiene que haber una aplicación que arranque en algún lado.

137
00:06:27,000 --> 00:06:28,000
Tiene que haber una aplicación que arranque.

138
00:06:28,000 --> 00:06:30,000
Que yo le dé al play y la aplicación arranque.

139
00:06:30,000 --> 00:06:33,000
Para que empiece yo a poder trabajar con pedidos y con cosas.

140
00:06:33,000 --> 00:06:35,000
Tiene que haber una aplicación que arranque.

141
00:06:35,000 --> 00:06:36,000
Efectivamente.

142
00:06:36,000 --> 00:06:38,000
Bueno, pues en mi aplicación,

143
00:06:38,000 --> 00:06:40,000
aparte de mis clases entidad,

144
00:06:40,000 --> 00:06:42,000
mi clase pedido, mi clase cliente.

145
00:06:42,000 --> 00:06:44,000
Tiene que haber una clase.

146
00:06:44,000 --> 00:06:46,000
Tiene que haber otra más.

147
00:06:46,000 --> 00:06:48,000
Tiene que haber otra.

148
00:06:48,000 --> 00:06:51,000
Que tenga el famoso método ese

149
00:06:51,000 --> 00:06:53,000
que ya nos hemos tudo de memoria.

150
00:06:53,000 --> 00:06:56,000
Public, static, void, main, bla, bla, bla.

151
00:07:03,000 --> 00:07:06,000
Este método que hemos escrito tantísimas veces.

152
00:07:17,000 --> 00:07:19,000
Bueno.

153
00:07:24,000 --> 00:07:26,000
Vale.

154
00:07:26,000 --> 00:07:29,000
Vale, pues otra clase más de mi aplicación.

155
00:07:29,000 --> 00:07:30,000
Otra más.

156
00:07:30,000 --> 00:07:33,000
Tiene que ser una clase que no es ni entidad ni es nada.

157
00:07:33,000 --> 00:07:35,000
No es ni pedido, ni es cliente, ni es nada.

158
00:07:35,000 --> 00:07:36,000
No es entidad ni es nada.

159
00:07:36,000 --> 00:07:38,000
Es una clase

160
00:07:38,000 --> 00:07:40,000
que tiene

161
00:07:40,000 --> 00:07:42,000
este método, esta función,

162
00:07:42,000 --> 00:07:43,000
como la queremos llamar.

163
00:07:43,000 --> 00:07:45,000
La veremos aquí dentro, que la hemos usado siempre.

164
00:07:45,000 --> 00:07:48,000
Que es el punto de arranque de la aplicación.

165
00:07:48,000 --> 00:07:50,000
Aquí es donde la aplicación arranca.

166
00:07:51,000 --> 00:07:54,000
Ahí arranca.

167
00:07:56,000 --> 00:07:58,000
Entonces, esto es una clase sin más.

168
00:07:58,000 --> 00:08:00,000
De hecho, empieza con class.

169
00:08:00,000 --> 00:08:01,000
La hemos hecho hasta ahora.

170
00:08:01,000 --> 00:08:03,000
Empieza con class y le hemos dado un nombre.

171
00:08:03,000 --> 00:08:04,000
El nombre que nos dé la gana.

172
00:08:04,000 --> 00:08:06,000
Bueno, como esta clase,

173
00:08:06,000 --> 00:08:07,000
que es una clase más,

174
00:08:07,000 --> 00:08:09,000
es la clase que es el punto de arranque

175
00:08:09,000 --> 00:08:11,000
de la aplicación, de la aplicación arranca,

176
00:08:11,000 --> 00:08:13,000
pues normalmente

177
00:08:13,000 --> 00:08:14,000
uno la suele ver identificada

178
00:08:14,000 --> 00:08:16,000
pues con el nombre de main en mayúscula

179
00:08:16,000 --> 00:08:18,000
o principal,

180
00:08:18,000 --> 00:08:20,000
o como uno la quiera llamar.

181
00:08:20,000 --> 00:08:22,000
Es la clase, es el punto de arranque.

182
00:08:22,000 --> 00:08:24,000
Porque la aplicación,

183
00:08:24,000 --> 00:08:26,000
cuando se está ejecutando,

184
00:08:26,000 --> 00:08:28,000
es una sentencia tras otra, eso sí o sí.

185
00:08:28,000 --> 00:08:30,000
Que las sentencias estén en clases diferentes.

186
00:08:30,000 --> 00:08:32,000
Da igual, pero es esta

187
00:08:32,000 --> 00:08:34,000
y de aquí saltará aquí, de aquí saltará aquí.

188
00:08:34,000 --> 00:08:36,000
Bueno, pues el punto de arranque,

189
00:08:36,000 --> 00:08:37,000
donde la aplicación arranca, ¿cuál va a ser?

190
00:08:37,000 --> 00:08:39,000
Aquí.

191
00:08:39,000 --> 00:08:41,000
Tendré yo mi clase principal

192
00:08:41,000 --> 00:08:43,000
con esto dentro

193
00:08:43,000 --> 00:08:45,000
y aquí arranca mi aplicación.

194
00:08:45,000 --> 00:08:46,000
Entonces, cuando mi aplicación

195
00:08:46,000 --> 00:08:48,000
con todas las clases, las que sean

196
00:08:48,000 --> 00:08:50,000
uno o mil, en este caso dos,

197
00:08:50,000 --> 00:08:52,000
esta y esta, en este caso dos,

198
00:08:52,000 --> 00:08:54,000
cuando mi aplicación arranque,

199
00:08:54,000 --> 00:08:56,000
donde va a arrancar es aquí.

200
00:08:56,000 --> 00:08:58,000
En la primera sentencia del main.

201
00:08:58,000 --> 00:09:00,000
Ahí es donde va a arrancar.

202
00:09:00,000 --> 00:09:02,000
Y ahí empiezan a pasar cosas.

203
00:09:02,000 --> 00:09:04,000
Bueno, y ahí que empieza a pasar

204
00:09:04,000 --> 00:09:06,000
lo que a mí me dé la gana.

205
00:09:06,000 --> 00:09:08,000
Empieza a pasar lo que a mí me dé la gana.

206
00:09:08,000 --> 00:09:10,000
Vale, pues ¿qué es lo primero que vamos a hacer?

207
00:09:10,000 --> 00:09:12,000
En esta aplicación.

208
00:09:12,000 --> 00:09:14,000
Pues crear un pedido.

209
00:09:14,000 --> 00:09:16,000
No es una aplicación que trabaja con pedidos,

210
00:09:16,000 --> 00:09:18,000
vamos a crear uno.

211
00:09:18,000 --> 00:09:20,000
Voy a escribir esto aquí un poquito mejor

212
00:09:20,000 --> 00:09:22,000
para traer espacio.

213
00:09:26,000 --> 00:09:28,000
¿Qué?

214
00:09:28,000 --> 00:09:30,000
¿En qué método?

215
00:09:30,000 --> 00:09:32,000
No, no, no.

216
00:09:32,000 --> 00:09:34,000
Hemos dicho que esto por ahora

217
00:09:34,000 --> 00:09:36,000
lo dejamos vacío, ¿vale?

218
00:09:36,000 --> 00:09:38,000
Puede estar vacío, no es obligatorio que tenga algo.

219
00:09:38,000 --> 00:09:40,000
Esta clase tal y como está, si la escribís,

220
00:09:40,000 --> 00:09:42,000
es una clase perfectamente válida.

221
00:09:42,000 --> 00:09:44,000
Lo que importa es que las dos partes estén rellenas.

222
00:09:44,000 --> 00:09:46,000
Vamos a hacer la principal,

223
00:09:46,000 --> 00:09:48,000
esta de aquí.

224
00:10:02,000 --> 00:10:04,000
Vale, y esta clase principal es la que tiene

225
00:10:04,000 --> 00:10:06,000
ese main ahí.

226
00:10:08,000 --> 00:10:10,000
Como es muy largo, bueno,

227
00:10:12,000 --> 00:10:14,000
lo pongo así.

228
00:10:16,000 --> 00:10:18,000
Vale.

229
00:10:22,000 --> 00:10:24,000
Vale, entonces tengo dos clases,

230
00:10:24,000 --> 00:10:26,000
esta y esta.

231
00:10:26,000 --> 00:10:28,000
Arranco la aplicación,

232
00:10:28,000 --> 00:10:30,000
la máquina virtual automáticamente

233
00:10:30,000 --> 00:10:32,000
se va a buscar este main,

234
00:10:32,000 --> 00:10:34,000
se va a buscar esto,

235
00:10:34,000 --> 00:10:36,000
navega por todas las clases,

236
00:10:36,000 --> 00:10:38,000
ya veremos también cómo, tenemos millones de cosas que ver.

237
00:10:38,000 --> 00:10:40,000
La máquina virtual, cuando yo le digo

238
00:10:40,000 --> 00:10:42,000
arranca la aplicación que tiene todas las clases,

239
00:10:42,000 --> 00:10:44,000
todas, arráncala, el navega, blablabla,

240
00:10:44,000 --> 00:10:46,000
hasta que encuentre esto.

241
00:10:46,000 --> 00:10:48,000
Como no encuentre esto, te dice,

242
00:10:48,000 --> 00:10:50,000
no puedo arrancar la aplicación.

243
00:10:50,000 --> 00:10:52,000
Y como haya dos clases

244
00:10:52,000 --> 00:10:54,000
que las dos tengan eso,

245
00:10:54,000 --> 00:10:56,000
tampoco puede porque se hace un lío.

246
00:10:56,000 --> 00:10:58,000
Con lo cual tiene que haber una única clase

247
00:10:58,000 --> 00:11:00,000
que tenga esto.

248
00:11:00,000 --> 00:11:02,000
Pues entonces, arrancamos esta aplicación

249
00:11:02,000 --> 00:11:04,000
con dos clases.

250
00:11:04,000 --> 00:11:06,000
La máquina virtual, blablabla, se va buscando,

251
00:11:06,000 --> 00:11:08,000
ah, vale, ya lo encontré,

252
00:11:08,000 --> 00:11:10,000
ya tengo donde arrancar, aquí arranco.

253
00:11:10,000 --> 00:11:12,000
Bueno, ¿qué es lo primero que vamos a decirle que haga?

254
00:11:12,000 --> 00:11:14,000
Pues que cree un objeto pedido.

255
00:11:14,000 --> 00:11:16,000
Y aquí ya he mencionado

256
00:11:16,000 --> 00:11:18,000
la palabra clave, objeto.

257
00:11:18,000 --> 00:11:20,000
Yo hasta ahora no la he mencionado.

258
00:11:20,000 --> 00:11:22,000
Es, programación de entradas de objetos,

259
00:11:22,000 --> 00:11:24,000
es como se llama, y por ahora no he mencionado

260
00:11:24,000 --> 00:11:26,000
la palabra objeto. He mencionado la palabra clase,

261
00:11:26,000 --> 00:11:28,000
que es esto.

262
00:11:28,000 --> 00:11:30,000
Entonces, clase, ¿qué es?

263
00:11:30,000 --> 00:11:32,000
Clase tiene que verlo como una plantilla vacía.

264
00:11:32,000 --> 00:11:34,000
Una clase indica

265
00:11:34,000 --> 00:11:36,000
cuando haya pedidos,

266
00:11:36,000 --> 00:11:38,000
cuando haya, que todavía no los hay en ningún lado,

267
00:11:38,000 --> 00:11:40,000
cuando haya,

268
00:11:40,000 --> 00:11:42,000
esos pedidos se caracterizarán

269
00:11:42,000 --> 00:11:44,000
por un código y una descripción.

270
00:11:44,000 --> 00:11:46,000
Eso es lo que significa clase.

271
00:11:46,000 --> 00:11:48,000
Una plantilla

272
00:11:48,000 --> 00:11:50,000
de lo que puede haber

273
00:11:50,000 --> 00:11:52,000
en el futuro, y si lo hay,

274
00:11:52,000 --> 00:11:54,000
qué propiedades va a tener.

275
00:11:54,000 --> 00:11:56,000
Pero todavía no hay ningún objeto pedido

276
00:11:56,000 --> 00:11:58,000
concreto. ¿Vale?

277
00:11:58,000 --> 00:12:00,000
Es como

278
00:12:00,000 --> 00:12:02,000
persona sería

279
00:12:02,000 --> 00:12:04,000
la clase.

280
00:12:04,000 --> 00:12:06,000
Y ahora ya, de esa clase,

281
00:12:06,000 --> 00:12:08,000
hay casos concretos, ¿no?

282
00:12:08,000 --> 00:12:10,000
Pues ya es, Adrián, que es un caso

283
00:12:10,000 --> 00:12:12,000
concreto de persona,

284
00:12:12,000 --> 00:12:14,000
Miguel, que es otro caso concreto de persona,

285
00:12:14,000 --> 00:12:16,000
Alejandro es otro caso concreto de persona.

286
00:12:16,000 --> 00:12:18,000
Pues aquí igual.

287
00:12:18,000 --> 00:12:20,000
Del concepto pedido,

288
00:12:20,000 --> 00:12:22,000
que está aquí declarado en plan plantilla,

289
00:12:22,000 --> 00:12:24,000
es decir, bueno, cuando haya

290
00:12:24,000 --> 00:12:26,000
pedidos, tendrán código y

291
00:12:26,000 --> 00:12:28,000
descripción. Pues de la clase pedido,

292
00:12:28,000 --> 00:12:30,000
que es la descripción del concepto,

293
00:12:30,000 --> 00:12:32,000
ahora ya habrá pedidos concretos.

294
00:12:32,000 --> 00:12:34,000
Pedido de bolis, pedido

295
00:12:34,000 --> 00:12:36,000
de gomas, pedido de sacapuntas,

296
00:12:36,000 --> 00:12:38,000
puede haber uno o mil

297
00:12:38,000 --> 00:12:40,000
pedidos de estos.

298
00:12:40,000 --> 00:12:42,000
Pues cada uno de los casos concretos

299
00:12:42,000 --> 00:12:44,000
de una clase es el objeto.

300
00:12:44,000 --> 00:12:46,000
¿Vale?

301
00:12:46,000 --> 00:12:48,000
Bueno, pues la clase entonces es

302
00:12:48,000 --> 00:12:50,000
la plantilla que se

303
00:12:50,000 --> 00:12:52,000
escribe y se declara una única

304
00:12:52,000 --> 00:12:54,000
vez, y que te dice

305
00:12:54,000 --> 00:12:56,000
cuando haya de esto

306
00:12:56,000 --> 00:12:58,000
tendrá estas propiedades, pero

307
00:12:58,000 --> 00:13:00,000
todavía no hay nada, esta es la plantilla,

308
00:13:00,000 --> 00:13:02,000
y el objeto es cada uno

309
00:13:02,000 --> 00:13:04,000
de los casos ya concretos que

310
00:13:04,000 --> 00:13:06,000
existen de pedido.

311
00:13:06,000 --> 00:13:08,000
¿Vale?

312
00:13:08,000 --> 00:13:10,000
En el otro ejemplo,

313
00:13:10,000 --> 00:13:12,000
la persona como tal no existe,

314
00:13:12,000 --> 00:13:14,000
la persona es un concepto,

315
00:13:14,000 --> 00:13:16,000
es un concepto platónico, la persona,

316
00:13:16,000 --> 00:13:18,000
quien existe es Adrián, Miguel,

317
00:13:18,000 --> 00:13:20,000
Alejandro, la persona no, la persona

318
00:13:20,000 --> 00:13:22,000
es una definición, pero no

319
00:13:22,000 --> 00:13:24,000
existe, es una definición.

320
00:13:24,000 --> 00:13:26,000
Luego ya existen casos concretos, objetos

321
00:13:26,000 --> 00:13:28,000
concretos. Pues esto igual,

322
00:13:28,000 --> 00:13:30,000
esto es una definición,

323
00:13:30,000 --> 00:13:32,000
es un concepto, y ahora

324
00:13:32,000 --> 00:13:34,000
ya existen

325
00:13:34,000 --> 00:13:36,000
todos los casos

326
00:13:36,000 --> 00:13:38,000
concretos de pedido que la aplicación quiera,

327
00:13:38,000 --> 00:13:40,000
si quiere 20, 20, si quiere 36, 37,

328
00:13:40,000 --> 00:13:42,000
todos los que quiera, y cada uno

329
00:13:42,000 --> 00:13:44,000
de esos casos concretos es un

330
00:13:44,000 --> 00:13:46,000
objeto. ¿Vale?

331
00:13:46,000 --> 00:13:48,000
Luego tenéis que tener muy clara

332
00:13:48,000 --> 00:13:50,000
la diferencia entre

333
00:13:50,000 --> 00:13:52,000
clase y objeto.

334
00:13:52,000 --> 00:13:54,000
¿Vale?

335
00:13:54,000 --> 00:13:56,000
Primera cosa con la que tenéis que ir muy clara hoy en la

336
00:13:56,000 --> 00:13:58,000
cabeza, clase y objeto.

337
00:13:58,000 --> 00:14:00,000
La clase es la plantilla. ¿Vale?

338
00:14:00,000 --> 00:14:02,000
Pues ahora ya cuando la aplicación arranca,

339
00:14:02,000 --> 00:14:04,000
ahora ya la aplicación

340
00:14:04,000 --> 00:14:06,000
lo que ya hace es crear objetos concretos.

341
00:14:06,000 --> 00:14:08,000
Ahora ya sí,

342
00:14:08,000 --> 00:14:10,000
cuando la aplicación entra en ejecución,

343
00:14:10,000 --> 00:14:12,000
ahora ya aparecen

344
00:14:12,000 --> 00:14:14,000
los pedidos concretos, aparecen

345
00:14:14,000 --> 00:14:16,000
los objetos, en el momento en que eso arranca.

346
00:14:16,000 --> 00:14:18,000
Cuando todavía no ha arrancado,

347
00:14:18,000 --> 00:14:20,000
esto está escrito en los ficheritos guardados,

348
00:14:20,000 --> 00:14:22,000
aquí no hay ningún objeto ni nada.

349
00:14:22,000 --> 00:14:24,000
El objeto aparece

350
00:14:24,000 --> 00:14:26,000
cuando la aplicación ya arranca, cada pedido

351
00:14:26,000 --> 00:14:28,000
concreto. Bueno, pues vamos

352
00:14:28,000 --> 00:14:30,000
a hacer, vamos a crear un objeto.

353
00:14:30,000 --> 00:14:32,000
Aquí.

354
00:14:34,000 --> 00:14:36,000
Uno concreto.

355
00:14:40,000 --> 00:14:42,000
¿Vale?

356
00:14:42,000 --> 00:14:44,000
Pues el objeto

357
00:14:44,000 --> 00:14:46,000
ya es un caso concreto

358
00:14:46,000 --> 00:14:48,000
de esta plantilla, es un caso

359
00:14:48,000 --> 00:14:50,000
concreto, de los mil que puede

360
00:14:50,000 --> 00:14:52,000
haber, uno concreto.

361
00:14:52,000 --> 00:14:54,000
Bueno, pues lo primero que tengo que decidir es darle un nombre.

362
00:14:54,000 --> 00:14:56,000
Darle un nombre.

363
00:14:56,000 --> 00:14:58,000
¿Vale? Igual que él se llama Adrián, y él se llama

364
00:14:58,000 --> 00:15:00,000
Miguel, siendo personas,

365
00:15:00,000 --> 00:15:02,000
pues el pedido tiene que tener su propio nombre

366
00:15:02,000 --> 00:15:04,000
para distinguirlo del resto de los objetos

367
00:15:04,000 --> 00:15:06,000
pedido. Pedido

368
00:15:06,000 --> 00:15:08,000
bolis. Pues venga, pedido bolis,

369
00:15:08,000 --> 00:15:10,000
que es muy bonito el nombre. Pues ya está,

370
00:15:10,000 --> 00:15:12,000
le doy su nombre.

371
00:15:12,000 --> 00:15:14,000
Pedido bolis.

372
00:15:14,000 --> 00:15:16,000
Ahora,

373
00:15:16,000 --> 00:15:18,000
tengo que indicar que este objeto

374
00:15:18,000 --> 00:15:20,000
pertenece a esta clase,

375
00:15:20,000 --> 00:15:22,000
que es un objeto pedido

376
00:15:22,000 --> 00:15:24,000
y no un objeto cliente, un objeto mesa.

377
00:15:24,000 --> 00:15:26,000
Pues lo pongo

378
00:15:26,000 --> 00:15:28,000
poniéndolo delante como si ese fuera su tipo

379
00:15:28,000 --> 00:15:30,000
de dato. Y es que lo es.

380
00:15:30,000 --> 00:15:32,000
¿Veis? Pedido

381
00:15:32,000 --> 00:15:34,000
y el nombre que a mí me dé la gana.

382
00:15:34,000 --> 00:15:36,000
Entonces, es

383
00:15:36,000 --> 00:15:38,000
exactamente igual que cuando declaro una variable.

384
00:15:38,000 --> 00:15:40,000
Cuando declaramos una variable entera

385
00:15:40,000 --> 00:15:42,000
poníamos int

386
00:15:42,000 --> 00:15:44,000
y el numerito.

387
00:15:44,000 --> 00:15:46,000
Perdón, y el nombre.

388
00:15:46,000 --> 00:15:48,000
Este es el nombre que yo decidía,

389
00:15:48,000 --> 00:15:50,000
N, el que yo decidía,

390
00:15:50,000 --> 00:15:52,000
N, y aquí ponía el

391
00:15:52,000 --> 00:15:54,000
tipo de dato que iba a contener.

392
00:15:54,000 --> 00:15:56,000
Pues, con el objeto

393
00:15:56,000 --> 00:15:58,000
igual, yo decido el nombre

394
00:15:58,000 --> 00:16:00,000
de mi objeto, el que

395
00:16:00,000 --> 00:16:02,000
me dé la gana el nombre, un nombre

396
00:16:02,000 --> 00:16:04,000
concreto, Miguel, Adrián,

397
00:16:04,000 --> 00:16:06,000
un nombre concreto, y digo

398
00:16:06,000 --> 00:16:08,000
de qué tipo es ese objeto.

399
00:16:08,000 --> 00:16:10,000
Pues este objeto es de tipo pedido.

400
00:16:10,000 --> 00:16:12,000
Igual que aquí el numerito

401
00:16:12,000 --> 00:16:14,000
N es de tipo entero.

402
00:16:14,000 --> 00:16:16,000
Pues este objeto es de tipo pedido.

403
00:16:16,000 --> 00:16:18,000
¿Vale?

404
00:16:18,000 --> 00:16:20,000
Bueno, he hecho parte

405
00:16:20,000 --> 00:16:22,000
para crear un objeto, pero no he hecho todo.

406
00:16:22,000 --> 00:16:24,000
¿Qué he hecho con eso?

407
00:16:24,000 --> 00:16:26,000
He hecho

408
00:16:26,000 --> 00:16:28,000
simplemente esto.

409
00:16:28,000 --> 00:16:30,000
Pues

410
00:16:30,000 --> 00:16:32,000
cuando la máquina virtual se encuentre esta

411
00:16:32,000 --> 00:16:34,000
ya automáticamente me crea

412
00:16:34,000 --> 00:16:36,000
ahí una variable

413
00:16:36,000 --> 00:16:38,000
a la que le da ese nombre

414
00:16:38,000 --> 00:16:40,000
igual que cuando se encuentra esto me crea una variable

415
00:16:40,000 --> 00:16:42,000
¿verdad? a la que llama N.

416
00:16:42,000 --> 00:16:44,000
Igual que cuando se encuentra esto se crea N,

417
00:16:44,000 --> 00:16:46,000
un espacio para el numerito entero.

418
00:16:46,000 --> 00:16:48,000
Pues aquí igual, se crea en memoria principal

419
00:16:48,000 --> 00:16:50,000
una variable que se llama

420
00:16:50,000 --> 00:16:52,000
pedidoBolis

421
00:16:52,000 --> 00:16:54,000
¿y qué va a contener esa variable?

422
00:16:54,000 --> 00:16:56,000
Pues esta variable al ser de tipo

423
00:16:56,000 --> 00:16:58,000
objeto, al ser de tipo

424
00:16:58,000 --> 00:17:00,000
objeto, porque su tipo de dato es una

425
00:17:00,000 --> 00:17:02,000
clase, no un primitivo

426
00:17:02,000 --> 00:17:04,000
es una clase, al ser de tipo objeto

427
00:17:04,000 --> 00:17:06,000
lo que contiene esa variable

428
00:17:06,000 --> 00:17:08,000
es una dirección de memoria

429
00:17:08,000 --> 00:17:10,000
igual que los Arrays.

430
00:17:10,000 --> 00:17:12,000
Cuando declaramos un Array, en realidad

431
00:17:12,000 --> 00:17:14,000
el Array contiene la dirección de memoria.

432
00:17:14,000 --> 00:17:16,000
Pues cuando uno declara una variable

433
00:17:16,000 --> 00:17:18,000
que es de tipo objeto

434
00:17:18,000 --> 00:17:20,000
porque su tipo es el de una clase

435
00:17:20,000 --> 00:17:22,000
lo que en realidad está

436
00:17:22,000 --> 00:17:24,000
haciendo aparecer en memoria

437
00:17:24,000 --> 00:17:26,000
es un espacio con ese nombre

438
00:17:26,000 --> 00:17:28,000
que contiene

439
00:17:28,000 --> 00:17:30,000
una dirección de memoria

440
00:17:30,000 --> 00:17:32,000
y en esa dirección

441
00:17:32,000 --> 00:17:34,000
esa dirección ya apunta

442
00:17:34,000 --> 00:17:36,000
al espacio para contener los datos

443
00:17:36,000 --> 00:17:38,000
del objeto concreto.

444
00:17:38,000 --> 00:17:40,000
Este objeto

445
00:17:40,000 --> 00:17:42,000
tiene que tener dentro

446
00:17:42,000 --> 00:17:44,000
su código y descripción

447
00:17:44,000 --> 00:17:46,000
porque los objetos tienen su código y descripción

448
00:17:46,000 --> 00:17:48,000
entonces esta dirección de memoria

449
00:17:48,000 --> 00:17:50,000
tiene que apuntar a un sitio

450
00:17:50,000 --> 00:17:52,000
para que quepan

451
00:17:52,000 --> 00:17:54,000
dentro el código y la descripción

452
00:17:54,000 --> 00:17:56,000
igual que cuando uno declara un Array

453
00:17:56,000 --> 00:17:58,000
sabe que automáticamente

454
00:17:58,000 --> 00:18:00,000
aparece una variable en memoria

455
00:18:00,000 --> 00:18:02,000
con la dirección

456
00:18:02,000 --> 00:18:04,000
y esa dirección me lleva al espacio

457
00:18:04,000 --> 00:18:06,000
para contener todas las posiciones

458
00:18:06,000 --> 00:18:08,000
pues aquí hemos hecho esto

459
00:18:08,000 --> 00:18:10,000
pero con esa línea sin más

460
00:18:10,000 --> 00:18:12,000
esta dirección de memoria

461
00:18:12,000 --> 00:18:14,000
está a medias

462
00:18:14,000 --> 00:18:16,000
se queda apuntando

463
00:18:16,000 --> 00:18:18,000
a lo que llamamos null

464
00:18:18,000 --> 00:18:20,000
en Java

465
00:18:20,000 --> 00:18:22,000
que null es espacio inhábil

466
00:18:22,000 --> 00:18:24,000
la nada de memoria RAM

467
00:18:24,000 --> 00:18:26,000
espacio inhabilitado

468
00:18:26,000 --> 00:18:28,000
solo con esta línea

469
00:18:28,000 --> 00:18:30,000
yo tengo la dirección de memoria

470
00:18:30,000 --> 00:18:32,000
se me ha pedido Boris

471
00:18:32,000 --> 00:18:34,000
pero ahora mismo apunta a un espacio inhabilitado

472
00:18:34,000 --> 00:18:36,000
vale

473
00:18:36,000 --> 00:18:38,000
pues siguiente paso

474
00:18:38,000 --> 00:18:40,000
tendremos que crear

475
00:18:40,000 --> 00:18:42,000
vamos a crear el espacio

476
00:18:42,000 --> 00:18:44,000
para ya los datos de este objeto

477
00:18:44,000 --> 00:18:46,000
en este caso serían dos

478
00:18:46,000 --> 00:18:48,000
para código

479
00:18:48,000 --> 00:18:50,000
y descripción

480
00:18:50,000 --> 00:18:52,000
vale

481
00:18:52,000 --> 00:18:54,000
para código y descripción

482
00:18:54,000 --> 00:18:56,000
vamos a crear esto

483
00:18:56,000 --> 00:18:58,000
bueno pues como creamos el espacio

484
00:18:58,000 --> 00:19:00,000
pues muy parecido a lo que hacíamos con Arrays

485
00:19:00,000 --> 00:19:02,000
ya en la misma línea en la que lo declaramos

486
00:19:02,000 --> 00:19:04,000
vamos a

487
00:19:04,000 --> 00:19:06,000
new

488
00:19:06,000 --> 00:19:08,000
nombre de la clase

489
00:19:08,000 --> 00:19:10,000
y por ahora

490
00:19:10,000 --> 00:19:12,000
porque no hemos visto nada más

491
00:19:12,000 --> 00:19:14,000
por ahora

492
00:19:14,000 --> 00:19:16,000
paréntesis vacíos

493
00:19:16,000 --> 00:19:18,000
paréntesis vacíos

494
00:19:18,000 --> 00:19:20,000
ahora ya sí

495
00:19:20,000 --> 00:19:22,000
ahora

496
00:19:22,000 --> 00:19:24,000
hemos declarado la variable que se llama

497
00:19:24,000 --> 00:19:26,000
pedido Boris

498
00:19:26,000 --> 00:19:28,000
y hemos hecho aparecer

499
00:19:28,000 --> 00:19:30,000
con el new

500
00:19:30,000 --> 00:19:32,000
un espacio en memoria

501
00:19:32,000 --> 00:19:34,000
capaz

502
00:19:34,000 --> 00:19:36,000
de contener

503
00:19:36,000 --> 00:19:38,000
todas las propiedades de pedido

504
00:19:38,000 --> 00:19:40,000
código

505
00:19:40,000 --> 00:19:42,000
y descripción

506
00:19:42,000 --> 00:19:44,000
ahora

507
00:19:44,000 --> 00:19:46,000
ya sí tenemos todo esto

508
00:19:46,000 --> 00:19:48,000
y esto ya sí es un objeto

509
00:19:48,000 --> 00:19:50,000
o sea un objeto es ya

510
00:19:50,000 --> 00:19:52,000
un espacio en memoria principal

511
00:19:52,000 --> 00:19:54,000
para contener unos datos concretos

512
00:19:54,000 --> 00:19:56,000
los datos de un pedido concreto

513
00:19:56,000 --> 00:19:58,000
esto ya es un objeto

514
00:19:58,000 --> 00:20:00,000
un objeto concreto

515
00:20:00,000 --> 00:20:02,000
ahora mismo

516
00:20:02,000 --> 00:20:04,000
este objeto que características

517
00:20:04,000 --> 00:20:06,000
tiene en código y descripción

518
00:20:06,000 --> 00:20:08,000
no tiene nada

519
00:20:08,000 --> 00:20:10,000
bueno

520
00:20:10,000 --> 00:20:12,000
vamos a darle valores a este pedido en concreto

521
00:20:12,000 --> 00:20:14,000
bueno pues como

522
00:20:14,000 --> 00:20:16,000
accedemos

523
00:20:16,000 --> 00:20:18,000
a las partes del objeto

524
00:20:18,000 --> 00:20:20,000
como accedemos a este espacio código

525
00:20:20,000 --> 00:20:22,000
pues accedemos con este

526
00:20:22,000 --> 00:20:24,000
operador

527
00:20:24,000 --> 00:20:26,000
voy a acceder al código para darle

528
00:20:26,000 --> 00:20:28,000
7 por ejemplo

529
00:20:28,000 --> 00:20:30,000
pues pongo

530
00:20:32,000 --> 00:20:34,000
pedido Boris

531
00:20:34,000 --> 00:20:36,000
punto

532
00:20:36,000 --> 00:20:38,000
y nombre de la propiedad

533
00:20:38,000 --> 00:20:40,000
tal y como aparece en la clase

534
00:20:40,000 --> 00:20:42,000
en la plantilla

535
00:20:42,000 --> 00:20:44,000
pedido Boris

536
00:20:44,000 --> 00:20:46,000
punto código

537
00:20:48,000 --> 00:20:50,000
igual a 7

538
00:20:50,000 --> 00:20:52,000
bueno pues

539
00:20:52,000 --> 00:20:54,000
automáticamente la máquina virtual

540
00:20:54,000 --> 00:20:56,000
va al pedido Boris

541
00:20:56,000 --> 00:20:58,000
aquí a donde me llevas de pedido Boris

542
00:20:58,000 --> 00:21:00,000
te llevo a código

543
00:21:00,000 --> 00:21:02,000
porque es punto código

544
00:21:02,000 --> 00:21:04,000
te llevo a código

545
00:21:04,000 --> 00:21:06,000
vale ya estoy aquí

546
00:21:06,000 --> 00:21:08,000
que haces asignarle el 7

547
00:21:08,000 --> 00:21:10,000
pues ala ahí se crea el 7

548
00:21:10,000 --> 00:21:12,000
esto es como una asignación cualquiera

549
00:21:12,000 --> 00:21:14,000
una variable

550
00:21:14,000 --> 00:21:16,000
lo que pasa es que a la variable

551
00:21:16,000 --> 00:21:18,000
a la que estamos accediendo

552
00:21:18,000 --> 00:21:20,000
es la propiedad código

553
00:21:20,000 --> 00:21:22,000
del objeto pedido Boris

554
00:21:22,000 --> 00:21:24,000
¿cuál es la posición a este objeto?

555
00:21:26,000 --> 00:21:28,000
pues pedido Boris

556
00:21:28,000 --> 00:21:30,000
que es el nombre del objeto

557
00:21:30,000 --> 00:21:32,000
así lo tengo que llamar, pedido Boris

558
00:21:32,000 --> 00:21:34,000
punto propiedad a la que quiero acceder

559
00:21:38,000 --> 00:21:40,000
esta es un string

560
00:21:40,000 --> 00:21:42,000
le tengo que asignar un tipo

561
00:21:42,000 --> 00:21:44,000
compatible, claro

562
00:21:44,000 --> 00:21:46,000
o yo que se, ala, Boris

563
00:21:48,000 --> 00:21:50,000
vale

564
00:21:50,000 --> 00:21:52,000
bueno pues automáticamente

565
00:21:52,000 --> 00:21:54,000
aparecerá aquí

566
00:21:56,000 --> 00:21:58,000
ala pues ya tengo un objeto

567
00:21:58,000 --> 00:22:00,000
un objeto creado en memoria

568
00:22:00,000 --> 00:22:02,000
este es el objeto, lo que existe en memoria

569
00:22:02,000 --> 00:22:04,000
que tiene un nombre

570
00:22:04,000 --> 00:22:06,000
el que a mi me ha dado la gana

571
00:22:06,000 --> 00:22:08,000
y tiene un contenido

572
00:22:08,000 --> 00:22:10,000
un contenido concreto

573
00:22:10,000 --> 00:22:12,000
tiene un contenido concreto

574
00:22:12,000 --> 00:22:14,000
y este objeto

575
00:22:14,000 --> 00:22:16,000
sigue esa plantilla

576
00:22:16,000 --> 00:22:18,000
que yo he tenido que programar aparte una clase

577
00:22:18,000 --> 00:22:20,000
vale

578
00:22:20,000 --> 00:22:22,000
que quiero hacer más objetos

579
00:22:22,000 --> 00:22:24,000
hago todos los que me den la gana

580
00:22:24,000 --> 00:22:26,000
que quiero ahora un pedido

581
00:22:26,000 --> 00:22:28,000
de gomas

582
00:22:28,000 --> 00:22:30,000
pues igual

583
00:22:30,000 --> 00:22:32,000
pedido gomas

584
00:22:34,000 --> 00:22:36,000
igual a new

585
00:22:36,000 --> 00:22:38,000
pedido

586
00:22:40,000 --> 00:22:42,000
ala ya tengo otro objeto

587
00:22:42,000 --> 00:22:44,000
en memoria principal me aparecerá otro

588
00:22:48,000 --> 00:22:50,000
vale

589
00:22:58,000 --> 00:23:00,000
que apunta un espacio

590
00:23:04,000 --> 00:23:06,000
código descripción

591
00:23:10,000 --> 00:23:12,000
vale

592
00:23:12,000 --> 00:23:14,000
ya tengo los objetos

593
00:23:14,000 --> 00:23:16,000
son dos objetos diferentes

594
00:23:16,000 --> 00:23:18,000
ambos de tipo pedido

595
00:23:18,000 --> 00:23:20,000
y mi aplicación puede tener

596
00:23:20,000 --> 00:23:22,000
mil, dos mil

597
00:23:22,000 --> 00:23:24,000
los que necesite, todos los pedidos que quiera

598
00:23:24,000 --> 00:23:26,000
y todos ellos

599
00:23:26,000 --> 00:23:28,000
siguen esa plantilla en cuanto a que tienen

600
00:23:28,000 --> 00:23:30,000
todos ellos dos propiedades

601
00:23:30,000 --> 00:23:32,000
y yo con esas propiedades las relleno

602
00:23:32,000 --> 00:23:34,000
hago lo que haga falta como si fueran variables

603
00:23:34,000 --> 00:23:36,000
la única diferencia es que la forma

604
00:23:36,000 --> 00:23:38,000
de acceder a ellas es de esta manera

605
00:23:38,000 --> 00:23:40,000
nombre del objeto

606
00:23:40,000 --> 00:23:42,000
punto nombre de la descripción

607
00:23:42,000 --> 00:23:44,000
que quiero acceder aquí

608
00:23:44,000 --> 00:23:46,000
pedido gomas punto código

609
00:23:46,000 --> 00:23:48,000
igual a lo que sea

610
00:23:48,000 --> 00:23:50,000
que quiero acceder aquí

611
00:23:50,000 --> 00:23:52,000
pedido gomas punto descripción

612
00:23:56,000 --> 00:23:58,000
bueno las grabaciones de hoy no van a empanar

613
00:23:58,000 --> 00:24:00,000
porque aquí tampoco había puesto la cámara

614
00:24:00,000 --> 00:24:02,000
en fin

615
00:24:04,000 --> 00:24:06,000
se ha grabado pero

616
00:24:08,000 --> 00:24:10,000
vale pues

617
00:24:10,000 --> 00:24:12,000
este es un funcionamiento

618
00:24:12,000 --> 00:24:14,000
muy muy muy resumido y sin detalles

619
00:24:14,000 --> 00:24:16,000
de una aplicación de todos los objetos

620
00:24:16,000 --> 00:24:18,000
lo que hace es esto

621
00:24:18,000 --> 00:24:20,000
uno decide las clases que necesita

622
00:24:20,000 --> 00:24:22,000
porque son las que representan

623
00:24:22,000 --> 00:24:24,000
los conceptos

624
00:24:24,000 --> 00:24:26,000
clase persona, clase jefe, clase empleado

625
00:24:26,000 --> 00:24:28,000
clase, representan los conceptos

626
00:24:28,000 --> 00:24:30,000
esas son plantillas

627
00:24:30,000 --> 00:24:32,000
en las que pone las propiedades que lo va a caracterizar

628
00:24:32,000 --> 00:24:34,000
y en esa plantilla

629
00:24:34,000 --> 00:24:36,000
el jefe le va a caracterizar

630
00:24:36,000 --> 00:24:38,000
pues el sueldo, el nombre, el DNI

631
00:24:38,000 --> 00:24:40,000
el empleado

632
00:24:40,000 --> 00:24:42,000
lo va a caracterizar

633
00:24:42,000 --> 00:24:44,000
pues el código, la fecha de incorporación

634
00:24:44,000 --> 00:24:46,000
de cada clase

635
00:24:46,000 --> 00:24:48,000
uno decide lo que lo va a caracterizar

636
00:24:48,000 --> 00:24:50,000
y luego ya habrá una aplicación

637
00:24:50,000 --> 00:24:52,000
perdón, habrá una clase

638
00:24:52,000 --> 00:24:54,000
con este main

639
00:24:54,000 --> 00:24:56,000
que es el punto de arranque

640
00:24:56,000 --> 00:24:58,000
y a partir de ahí ya la aplicación ya creando objetos

641
00:24:58,000 --> 00:25:00,000
lo que haga falta

642
00:25:00,000 --> 00:25:02,000
lo que se pida, lo que haga falta

643
00:25:02,000 --> 00:25:04,000
entonces los objetos

644
00:25:04,000 --> 00:25:06,000
ya aparecen en tiempo

645
00:25:06,000 --> 00:25:08,000
de ejecución

646
00:25:08,000 --> 00:25:10,000
cuando la aplicación está ejecutando

647
00:25:10,000 --> 00:25:12,000
ya van apareciendo

648
00:25:12,000 --> 00:25:14,000
que son espacios de memoria

649
00:25:14,000 --> 00:25:16,000
cada uno de ellos con un nombre distinto

650
00:25:16,000 --> 00:25:18,000
y puede haber tantos objetos

651
00:25:18,000 --> 00:25:20,000
de la misma clase como hagan falta

652
00:25:20,000 --> 00:25:22,000
tantos objetos como hagan falta

653
00:25:26,000 --> 00:25:28,000
entonces claro, una aplicación de pedidos

654
00:25:28,000 --> 00:25:30,000
pues tendría sentido hacerlo así

655
00:25:30,000 --> 00:25:32,000
si yo no trabajo con clases

656
00:25:32,000 --> 00:25:34,000
que me hago variables sueltas

657
00:25:34,000 --> 00:25:36,000
que sean código del pedido 1

658
00:25:36,000 --> 00:25:38,000
una variable entera suelta

659
00:25:38,000 --> 00:25:40,000
otra variable insuelta, código del pedido 2

660
00:25:40,000 --> 00:25:42,000
pues hombre, lo puedo hacer así

661
00:25:42,000 --> 00:25:44,000
descripción del pedido 1, una variable string suelta

662
00:25:44,000 --> 00:25:46,000
descripción del pedido 2, otra variable string suelta

663
00:25:46,000 --> 00:25:48,000
pues lo puedo hacer con variables sueltas

664
00:25:48,000 --> 00:25:50,000
pero hombre, que horrorosa

665
00:25:50,000 --> 00:25:52,000
y que fea y que complicada

666
00:25:52,000 --> 00:25:54,000
es mucho más fácil si yo tengo

667
00:25:54,000 --> 00:25:56,000
una variable pedido bolis

668
00:25:56,000 --> 00:25:58,000
dentro de la cual si quiero

669
00:25:58,000 --> 00:26:00,000
me voy a las propiedades

670
00:26:00,000 --> 00:26:02,000
otra variable pedido gomas, de la clase pedido

671
00:26:02,000 --> 00:26:04,000
dentro de la cual ya si quiero

672
00:26:04,000 --> 00:26:06,000
me voy a las propiedades

673
00:26:06,000 --> 00:26:08,000
mucho más organizada así

674
00:26:08,000 --> 00:26:10,000
mucho más bonita

675
00:26:10,000 --> 00:26:12,000
que no con variables sueltas

676
00:26:12,000 --> 00:26:14,000
código pedido 1, código pedido 2

677
00:26:14,000 --> 00:26:16,000
mucho mejor así, con una clase pedido

678
00:26:16,000 --> 00:26:18,000
con mis pedidos en variables separadas

679
00:26:18,000 --> 00:26:20,000
cada una de ellas teniendo sus propiedades

680
00:26:20,000 --> 00:26:22,000
va a quedar mucho más claro y mejor

681
00:26:22,000 --> 00:26:24,000
que ahora me hago otra aplicación

682
00:26:24,000 --> 00:26:26,000
que también trabaja con pedidos

683
00:26:26,000 --> 00:26:28,000
anda, pues esta misma clase pedido

684
00:26:28,000 --> 00:26:30,000
que ya tengo hecha

685
00:26:30,000 --> 00:26:32,000
en mi caso es que hay dos líneas

686
00:26:32,000 --> 00:26:34,000
pero esta clase que ya tengo hecha

687
00:26:34,000 --> 00:26:36,000
voy a llevármela a mi otra aplicación

688
00:26:36,000 --> 00:26:38,000
no tengo que volver a hacerla

689
00:26:38,000 --> 00:26:40,000
no tengo que volver a hacerla

690
00:26:40,000 --> 00:26:42,000
gracias a que ya tengo una clase pedido hecha

691
00:26:42,000 --> 00:26:44,000
a cualquier otra aplicación que os he pedido

692
00:26:44,000 --> 00:26:46,000
sale, ahí me la llevo

693
00:26:46,000 --> 00:26:48,000
y ya tengo ese trabajo

694
00:26:48,000 --> 00:26:50,000
puedo reutilizar el código de las clases

695
00:26:52,000 --> 00:26:54,000
¿vale?

696
00:26:54,000 --> 00:26:56,000
venga, pues para

697
00:26:56,000 --> 00:26:58,000
asegurarnos de que esto está claro

698
00:26:58,000 --> 00:27:00,000
vais a programar vosotros ahora

699
00:27:02,000 --> 00:27:04,000
esta misma clase

700
00:27:10,000 --> 00:27:12,000
esta misma clase

701
00:27:12,000 --> 00:27:14,000
vais a programar una aplicación

702
00:27:14,000 --> 00:27:16,000
con estas dos clases

703
00:27:16,000 --> 00:27:18,000
¿vale?

704
00:27:18,000 --> 00:27:20,000
la clase pedido

705
00:27:20,000 --> 00:27:22,000
con las propiedades que hemos dicho

706
00:27:22,000 --> 00:27:24,000
con el código

707
00:27:26,000 --> 00:27:28,000
y la descripción

708
00:27:28,000 --> 00:27:30,000
y la descripción

709
00:27:30,000 --> 00:27:32,000
y ahora vais a hacer una aplicación

710
00:27:32,000 --> 00:27:34,000
un método main

711
00:27:34,000 --> 00:27:36,000
que haga lo siguiente, tiene que hacer

712
00:27:36,000 --> 00:27:38,000
crear dos objetos pedido

713
00:27:38,000 --> 00:27:40,000
y rellenar

714
00:27:40,000 --> 00:27:42,000
sus propiedades

715
00:27:42,000 --> 00:27:44,000
no con valores que yo le he asignado a capón

716
00:27:44,000 --> 00:27:46,000
como aquí, sino con valores que habéis

717
00:27:46,000 --> 00:27:48,000
editado por teclado

718
00:27:48,000 --> 00:27:50,000
¿vale?

719
00:27:50,000 --> 00:27:52,000
eso es lo primero que vamos a hacer, rellenar

720
00:27:52,000 --> 00:27:54,000
en mi main

721
00:27:54,000 --> 00:27:56,000
dos objetos

722
00:27:58,000 --> 00:28:00,000
pedido

723
00:28:00,000 --> 00:28:02,000
con valores

724
00:28:02,000 --> 00:28:04,000
solicitados

725
00:28:04,000 --> 00:28:06,000
por teclado

726
00:28:06,000 --> 00:28:08,000
los dos códigos

727
00:28:08,000 --> 00:28:10,000
y solicitados

728
00:28:14,000 --> 00:28:16,000
por teclado

729
00:28:16,000 --> 00:28:18,000
vale, y una vez

730
00:28:18,000 --> 00:28:20,000
hecho eso

731
00:28:20,000 --> 00:28:22,000
lo que vais a hacer va a ser

732
00:28:22,000 --> 00:28:24,000
vais a

733
00:28:24,000 --> 00:28:26,000
mostrar

734
00:28:26,000 --> 00:28:28,000
una utilidad un poco

735
00:28:28,000 --> 00:28:30,000
extraña, pero bueno

736
00:28:30,000 --> 00:28:32,000
vais a mostrar

737
00:28:32,000 --> 00:28:34,000
la descripción

738
00:28:34,000 --> 00:28:36,000
del pedido cuyo código

739
00:28:36,000 --> 00:28:38,000
sea mayor, ya está

740
00:28:42,000 --> 00:28:44,000
ahora mismo

741
00:28:44,000 --> 00:28:46,000
me da igual, pero como todavía no hemos visto

742
00:28:46,000 --> 00:28:48,000
paquetes ni entendemos lo que es

743
00:28:48,000 --> 00:28:50,000
si lo queréis hacer en un paquete, me da lo mismo

744
00:28:50,000 --> 00:28:52,000
pero yo no doy todavía los paquetes

745
00:28:52,000 --> 00:28:54,000
por tabla, porque no los hemos visto

746
00:28:56,000 --> 00:28:58,000
en default está bien por ahora

747
00:29:00,000 --> 00:29:02,000
mostrar la

748
00:29:02,000 --> 00:29:04,000
descripción

749
00:29:04,000 --> 00:29:06,000
la utilidad de los paquetes

750
00:29:06,000 --> 00:29:08,000
aparece efectivamente cuando viene la aplicación

751
00:29:08,000 --> 00:29:10,000
tiene muchas clases, si tiene muchas

752
00:29:10,000 --> 00:29:12,000
conviene organizar diferentes paquetes

753
00:29:12,000 --> 00:29:14,000
pero esto tiene un funcionamiento específico

754
00:29:14,000 --> 00:29:16,000
que todavía nos falta volver también

755
00:29:16,000 --> 00:29:18,000
mostrar la descripción

756
00:29:18,000 --> 00:29:20,000
del pedido

757
00:29:20,000 --> 00:29:22,000
con código

758
00:29:22,000 --> 00:29:24,000
mayor

759
00:29:26,000 --> 00:29:28,000
venga pues esto