1
00:00:00,000 --> 00:00:08,000
Bueno, a ver. No, no voy a hablar de nada que no queráis que hablemos.

2
00:00:08,000 --> 00:00:11,000
Vamos, que yo no tengo ninguna idea para ese día.

3
00:00:11,000 --> 00:00:14,000
Me dijeron ayer, necesito el tutorial de 9 a 10. Vale, pues ya está.

4
00:00:16,000 --> 00:00:17,000
Ya, ya, ya, ya lo sé.

5
00:00:19,000 --> 00:00:24,000
Venga, a ver. A ver, tenemos esta primera hora intensa.

6
00:00:24,000 --> 00:00:25,000
El domingo si se ponen faltas.

7
00:00:25,000 --> 00:00:29,000
El domingo si se ponen faltas. Si no estás aquí el domingo te pongo una falta gorda, gorda.

8
00:00:29,000 --> 00:00:35,000
No se ponen faltas. Bueno, yo por lo menos no pongo faltas.

9
00:00:35,000 --> 00:00:40,000
Vale, a ver. Tenemos una hora de aquí hasta las 12.40 intensa,

10
00:00:40,000 --> 00:00:42,000
en la que voy a tener que hablar mucho y soltar mucho rollo,

11
00:00:42,000 --> 00:00:47,000
porque luego las otras dos siguientes horas tengo lecturas de proyecto, etcétera,

12
00:00:47,000 --> 00:00:51,000
con lo cual me iré y os podéis quedar haciendo ejercicios.

13
00:00:52,000 --> 00:00:58,000
Y bueno, si alguien sí quiere ir, pues no le vea a que se quede,

14
00:00:58,000 --> 00:01:01,000
porque yo no voy a poder estar aquí. Vale.

15
00:01:01,000 --> 00:01:07,000
Bueno, pues venga, vamos a revisar y añadir unas cuantas cosas

16
00:01:07,000 --> 00:01:12,000
en cuanto a operación y orientación de objetos para que ya en navidades

17
00:01:12,000 --> 00:01:16,000
podáis trabajarlo más a partir de ejercicios que dejemos,

18
00:01:16,000 --> 00:01:20,000
podáis trabajar ya con conocimientos suficientes para hacer un poquito más.

19
00:01:20,000 --> 00:01:24,000
¿Vale? Silencio. Bueno, pues a ver.

20
00:01:34,000 --> 00:01:38,000
Silencio. Bueno, pues a la hora...

21
00:01:40,000 --> 00:01:43,000
A ver, ¿os queréis callar y estar en absoluto silencio,

22
00:01:43,000 --> 00:01:46,000
aunque no me escuchéis que eso me la refanfifla completamente?

23
00:01:46,000 --> 00:01:51,000
Lo que quiero es silencio absoluto. Así. Este perfecto.

24
00:01:51,000 --> 00:01:56,000
Ismael y Ricardo. También aplica. Vale.

25
00:01:56,000 --> 00:02:00,000
Tienes que ser capaces de aguantar callados, de verdad que no es tan complicado.

26
00:02:00,000 --> 00:02:05,000
Así mejor. Vale. Pues todos sabéis lo que es una clase

27
00:02:05,000 --> 00:02:10,000
y luego ya lo que significa crear un objeto de esa clase.

28
00:02:10,000 --> 00:02:13,000
Uno, dos, tres o mil. Vale.

29
00:02:13,000 --> 00:02:17,000
Una clase tiene dos partes. La parte de propiedades,

30
00:02:17,000 --> 00:02:21,000
que también sabemos todos lo que significa.

31
00:02:21,000 --> 00:02:25,000
No repito todo una y otra vez. Y la parte de métodos,

32
00:02:25,000 --> 00:02:30,000
que también sabemos todos lo que significa. ¿Vale?

33
00:02:30,000 --> 00:02:35,000
Lo que va a caracterizar al objeto que exista en el futuro de esa clase

34
00:02:35,000 --> 00:02:39,000
está aquí en propiedades y lo que ese objeto va a poder llamar

35
00:02:40,000 --> 00:02:43,000
para que se ejecute está aquí en métodos.

36
00:02:43,000 --> 00:02:47,000
Bueno, entonces en nuestra clase pedido con nuestras propiedades y nuestros métodos

37
00:02:47,000 --> 00:02:52,000
luego vimos que en una aplicación, ahora ya con un main que se puede ejecutar

38
00:02:52,000 --> 00:02:56,000
en una aplicación, uno crea ya todos los pedidos que dé la gana.

39
00:02:56,000 --> 00:02:59,000
Metidos en un array, sueltos, como sea.

40
00:02:59,000 --> 00:03:03,000
Y cuando lo cree siempre lo va a hacer con algo de este estilo.

41
00:03:03,000 --> 00:03:11,000
Pedido p igual a new pedido. Vale.

42
00:03:11,000 --> 00:03:16,000
Bueno, pues nosotros hemos puesto aquí el new pedido y hemos dicho

43
00:03:16,000 --> 00:03:22,000
con este término new, nombre de la clase y paréntesis,

44
00:03:22,000 --> 00:03:28,000
hemos dicho que lo que ocurre es que de repente aparece un objeto en memoria.

45
00:03:28,000 --> 00:03:31,000
Eso es lo que hemos dicho que ocurría cuando hacíamos esta llamada.

46
00:03:31,000 --> 00:03:35,000
Que de repente aparece un objeto en memoria y este objeto en memoria

47
00:03:35,000 --> 00:03:42,000
se quede apuntado por una dirección que está guardada en esa variable p.

48
00:03:42,000 --> 00:03:46,000
Esto es el resultado de hacer esta llamada new pedido.

49
00:03:46,000 --> 00:03:48,000
Que aparezca esto en memoria.

50
00:03:48,000 --> 00:03:52,000
Y como ya ha aparecido ese espacio en memoria, a partir de entonces

51
00:03:52,000 --> 00:03:56,000
ya podemos mediante p punto no sé cuántos, p punto no sé qué,

52
00:03:56,000 --> 00:04:02,000
acceder al espacio de este objeto para guardar las propiedades.

53
00:04:02,000 --> 00:04:05,000
Pues cliente, identificador, las propiedades que sea.

54
00:04:05,000 --> 00:04:09,000
Bueno, vale, pues tenemos que meternos ahora ya que entendemos

55
00:04:09,000 --> 00:04:12,000
lo que es un método un poquito más con esta llamada.

56
00:04:12,000 --> 00:04:15,000
Que hasta ahora lo único que sabemos es que lo que significa es

57
00:04:15,000 --> 00:04:18,000
que aparece ese espacio en memoria y se queda apuntado a por p.

58
00:04:18,000 --> 00:04:23,000
Vale. Pero es que además esta llamada también hace algo.

59
00:04:23,000 --> 00:04:28,000
Y es llamar a un método, y ya sabemos lo que es un método.

60
00:04:28,000 --> 00:04:34,000
Un método es un trozo de código que hay dentro de la clase, bajo un nombre.

61
00:04:34,000 --> 00:04:40,000
Pues mostrar descripción, lo que sea, un trozo de código bajo un nombre

62
00:04:40,000 --> 00:04:43,000
que se puede ejecutar cuando lo llama el objeto en su método.

63
00:04:43,000 --> 00:04:48,000
Bueno, pues hay unos métodos especiales que no hemos escrito hasta ahora

64
00:04:48,000 --> 00:04:51,000
ni hemos visto porque no es obligatorio que estén,

65
00:04:51,000 --> 00:04:56,000
que son los métodos constructores.

66
00:04:56,000 --> 00:05:02,000
Entonces, y son los únicos especiales.

67
00:05:02,000 --> 00:05:04,000
Vamos a ponerlo aquí.

68
00:05:04,000 --> 00:05:13,000
Dentro de los métodos existen unos especiales,

69
00:05:13,000 --> 00:05:17,000
especiales porque se saltan algunas de las reglas de construcción

70
00:05:17,000 --> 00:05:23,000
de métodos que vimos el otro día.

71
00:05:23,000 --> 00:05:32,000
Bueno, pues dentro de los métodos existe un método especial

72
00:05:32,000 --> 00:05:36,000
que es el método constructor.

73
00:05:36,000 --> 00:05:45,000
Y se llama así, método constructor.

74
00:05:46,000 --> 00:05:49,000
Pues entonces dentro de los métodos que ya hemos visto,

75
00:05:49,000 --> 00:05:51,000
los métodos como se codifican.

76
00:05:51,000 --> 00:05:55,000
Un nombre, parámetros que recibe si es que recibe alguno,

77
00:05:55,000 --> 00:05:58,000
tipo de dato de retorno, el código que tiene dentro.

78
00:05:58,000 --> 00:06:01,000
Ese es el concepto de método que ya sabemos lo que es.

79
00:06:01,000 --> 00:06:05,000
Bueno, pues dentro de todos los métodos que puede tener una clase,

80
00:06:05,000 --> 00:06:09,000
que puede tener uno o mil, uno o mil los que yo quiera programar,

81
00:06:09,000 --> 00:06:12,000
dentro de todos los métodos puede haber uno especial

82
00:06:12,000 --> 00:06:17,000
que todavía no lo hemos incorporado, que se le llama método constructor.

83
00:06:17,000 --> 00:06:20,000
Y vamos a ver este método porque es especial y que hace.

84
00:06:20,000 --> 00:06:23,000
¿Vale? Ese método especial dentro de los métodos.

85
00:06:23,000 --> 00:06:26,000
Vale, pues vamos a verlo.

86
00:06:43,000 --> 00:06:47,000
Vale, pues el método constructor de una clase es un método

87
00:06:47,000 --> 00:06:51,000
que obligatoriamente, obligatoriamente se tiene que llamar,

88
00:06:51,000 --> 00:06:54,000
obligatoriamente se tiene que llamar.

89
00:06:54,000 --> 00:06:58,000
Voy a hacer aquí un método constructor, para esta clase no está pedido.

90
00:07:01,000 --> 00:07:04,000
Pues el método constructor de una clase cualquiera,

91
00:07:04,000 --> 00:07:07,000
pedido, cliente, persona, alumno, la que sea.

92
00:07:07,000 --> 00:07:09,000
El método constructor de una clase cualquiera,

93
00:07:09,000 --> 00:07:15,000
obligatoriamente se tiene que llamar igual que la clase a la que pertenece.

94
00:07:20,000 --> 00:07:23,000
Esa es, obligatoriamente se tiene que llamar, igual que la clase.

95
00:07:23,000 --> 00:07:27,000
¿Vale? Esa es la primera característica que lo hace especial.

96
00:07:27,000 --> 00:07:29,000
Que yo no puedo elegir su nombre.

97
00:07:29,000 --> 00:07:32,000
Se tiene que llamar como la clase a la que pertenece.

98
00:07:34,000 --> 00:07:38,000
Luego este método se salta, ese convenio de programación

99
00:07:38,000 --> 00:07:41,000
de que los métodos empiecen por minúscula.

100
00:07:41,000 --> 00:07:44,000
Porque si se tiene que llamar igual que la clase,

101
00:07:44,000 --> 00:07:48,000
y la clase seguimos el convenio de programación establecido entre todos,

102
00:07:48,000 --> 00:07:52,000
que empiecen con mayúscula, pues el constructor va a empezar con mayúscula.

103
00:07:52,000 --> 00:07:54,000
¿Vale? O sea, el constructor no hay elección.

104
00:07:54,000 --> 00:07:57,000
Se tiene que llamar exactamente igual que la clase.

105
00:07:59,000 --> 00:08:02,000
Si yo hago otro método que se llame así,

106
00:08:02,000 --> 00:08:03,000
pues este será otro.

107
00:08:03,000 --> 00:08:07,000
Este ya no es el constructor, será otro el método que yo quiera hacer.

108
00:08:07,000 --> 00:08:10,000
Ya no será el constructor, será otro método cualquiera.

109
00:08:10,000 --> 00:08:14,000
Con su nombre, sus parámetros, si es que tiene, su valor de retorno, será otro.

110
00:08:14,000 --> 00:08:18,000
Pero el constructor se tiene que llamar igual que la clase.

111
00:08:18,000 --> 00:08:21,000
Y como ya sabéis que esto es sensible a minúsculas y mayúsculas.

112
00:08:21,000 --> 00:08:24,000
Vale, pues esta es la primera cosa que le hace especial.

113
00:08:26,000 --> 00:08:28,000
¿Qué parámetros recibe el constructor?

114
00:08:28,000 --> 00:08:31,000
Los que a mí me dé la gana.

115
00:08:32,000 --> 00:08:35,000
¿Y qué código? Sobre esto nos metemos ahora.

116
00:08:35,000 --> 00:08:37,000
¿Y qué código tiene aquí el constructor?

117
00:08:37,000 --> 00:08:39,000
El que a mí me dé la gana.

118
00:08:40,000 --> 00:08:41,000
¿Vale?

119
00:08:41,000 --> 00:08:43,000
Todavía no me meto con esto.

120
00:08:44,000 --> 00:08:46,000
Entonces, ahora la pregunta sería, ¿vale?

121
00:08:46,000 --> 00:08:48,000
¿Y para qué sirve ese método?

122
00:08:48,000 --> 00:08:49,000
¿Cuándo llamo yo a ese método?

123
00:08:49,000 --> 00:08:52,000
¿Por qué tiene que haber un método que se llame así?

124
00:08:52,000 --> 00:08:55,000
Bueno, pues ahora ya sí que nos vamos aquí.

125
00:08:57,000 --> 00:09:00,000
Cuando se instancia, ya en una clase main,

126
00:09:00,000 --> 00:09:04,000
una clase que ya empieza, que tiene las sentencias que se van ejecutando.

127
00:09:04,000 --> 00:09:06,000
Cuando se instancia, o se crea,

128
00:09:06,000 --> 00:09:08,000
es sinónimo instanciar, crear un objeto.

129
00:09:08,000 --> 00:09:11,000
Cuando se instancia un objeto,

130
00:09:11,000 --> 00:09:14,000
que nosotros sabemos que eso se hace haciendo newPedido,

131
00:09:14,000 --> 00:09:17,000
pues sí, efectivamente no hemos mentido.

132
00:09:17,000 --> 00:09:20,000
Pasa en memoria principal todo lo que hemos dicho.

133
00:09:20,000 --> 00:09:25,000
Que aparecerá un espacio para guardar las propiedades de este objeto P.

134
00:09:25,000 --> 00:09:28,000
Aquí aparece el espacio para las propiedades.

135
00:09:28,000 --> 00:09:31,000
Ese espacio se queda apuntado por la variable P.

136
00:09:31,000 --> 00:09:34,000
Pasa todo eso cuando se hace newPedido.

137
00:09:34,000 --> 00:09:38,000
Pero además pasa que si existe un método constructor,

138
00:09:38,000 --> 00:09:41,000
es decir, un método que se llama igual que la clase,

139
00:09:41,000 --> 00:09:46,000
además la máquina virtual se va a ejecutar.

140
00:09:46,000 --> 00:09:48,000
Si existe, se va a ejecutarlo.

141
00:09:48,000 --> 00:09:51,000
Si no existe, pues no se va a ejecutarlo porque no existe.

142
00:09:51,000 --> 00:09:53,000
Pero si existe, se va a ejecutarlo.

143
00:09:53,000 --> 00:09:56,000
Entonces ese método, ponerlo, nos viene bien

144
00:09:56,000 --> 00:10:00,000
para hacer a lo mejor tareas de inicializar propiedades del objeto

145
00:10:00,000 --> 00:10:03,000
o hacer cosas.

146
00:10:03,000 --> 00:10:04,000
O cualquier cosa.

147
00:10:04,000 --> 00:10:06,000
Por ejemplo, pues avisar.

148
00:10:06,000 --> 00:10:07,000
Se ha creado objeto.

149
00:10:07,000 --> 00:10:14,000
Lo que a mí me dé la gana puedo poner aquí.

150
00:10:14,000 --> 00:10:15,000
¿Vale?

151
00:10:15,000 --> 00:10:16,000
Luego repito.

152
00:10:16,000 --> 00:10:18,000
Lo que tenemos que saber es que este método constructor,

153
00:10:18,000 --> 00:10:20,000
que obligatoriamente se llama igual que la clase,

154
00:10:20,000 --> 00:10:22,000
es un método que se invoca solo,

155
00:10:22,000 --> 00:10:26,000
cada vez que se instancia un objeto a Tableau.

156
00:10:26,000 --> 00:10:27,000
Se invoca solo.

157
00:10:27,000 --> 00:10:28,000
Además de crear el espacio.

158
00:10:28,000 --> 00:10:30,000
Todo eso se llama aquí.

159
00:10:30,000 --> 00:10:33,000
Es decir, no es un método que uno llame a propósito en cualquier momento.

160
00:10:33,000 --> 00:10:34,000
No.

161
00:10:34,000 --> 00:10:38,000
Es un método que está pensado para ser llamado y ejecutado

162
00:10:38,000 --> 00:10:42,000
como consecuencia de hacer la instanciación de un objeto con new pedido.

163
00:10:42,000 --> 00:10:45,000
Entonces se llama automáticamente.

164
00:10:45,000 --> 00:10:49,000
Luego el uso de ese método será hacer pues tareas de inicialización,

165
00:10:49,000 --> 00:10:51,000
de lo que sea, lo que a mí me apetezca vender.

166
00:10:51,000 --> 00:10:52,000
Ahí ya sí que Java no se mete.

167
00:10:52,000 --> 00:10:53,000
Mete ahí lo que quieras.

168
00:10:53,000 --> 00:10:57,000
Lo que quieras que pase en el momento de construir el objeto.

169
00:10:57,000 --> 00:11:00,000
Lo que quieras que pase.

170
00:11:00,000 --> 00:11:02,000
¿Vale?

171
00:11:02,000 --> 00:11:06,000
Bueno, pues entonces, como este método se llama aquí,

172
00:11:06,000 --> 00:11:09,000
no hay valor de retorno posible.

173
00:11:09,000 --> 00:11:12,000
No hay valor de retorno porque es que esto en realidad

174
00:11:12,000 --> 00:11:15,000
está igual que se asigna aquí.

175
00:11:15,000 --> 00:11:16,000
Ya me está condenando.

176
00:11:16,000 --> 00:11:19,000
O sea, el método no tiene donde devolver el valor de retorno.

177
00:11:19,000 --> 00:11:22,000
No es un método que yo llamo y luego puedo asignar a una variable

178
00:11:22,000 --> 00:11:24,000
la llamada al método.

179
00:11:24,000 --> 00:11:25,000
No funciona así.

180
00:11:25,000 --> 00:11:27,000
En este momento, que la sintaxis es esta,

181
00:11:27,000 --> 00:11:31,000
no tengo donde recoger el valor de retorno.

182
00:11:31,000 --> 00:11:35,000
Luego, los métodos constructores nunca pueden devolver nada.

183
00:11:35,000 --> 00:11:36,000
No hay un retún ahí.

184
00:11:36,000 --> 00:11:37,000
Nunca.

185
00:11:37,000 --> 00:11:38,000
No hay un retún.

186
00:11:38,000 --> 00:11:40,000
Jamás van a tener un retún.

187
00:11:40,000 --> 00:11:42,000
Porque no devuelven nada.

188
00:11:42,000 --> 00:11:44,000
Entonces, tanto es así que no devuelven nada,

189
00:11:44,000 --> 00:11:48,000
que son métodos que tienen la característica especial y solo ellos,

190
00:11:48,000 --> 00:11:50,000
que ni siquiera se pone el void.

191
00:11:50,000 --> 00:11:51,000
Prohibido.

192
00:11:51,000 --> 00:11:52,000
Ni se pone el void.

193
00:11:52,000 --> 00:11:53,000
Nada.

194
00:11:53,000 --> 00:11:54,000
No se pone nada.

195
00:11:54,000 --> 00:11:56,000
Así se escribe el constructor.

196
00:11:56,000 --> 00:11:58,000
O sea, son los únicos métodos,

197
00:11:58,000 --> 00:12:00,000
los únicos,

198
00:12:00,000 --> 00:12:02,000
que no tienen nada delante.

199
00:12:02,000 --> 00:12:04,000
Ni void,

200
00:12:04,000 --> 00:12:07,000
ni el tipo de dato de retorno del método que sea.

201
00:12:07,000 --> 00:12:08,000
No tienen nada.

202
00:12:08,000 --> 00:12:11,000
Porque los constructores, por pura definición,

203
00:12:11,000 --> 00:12:13,000
no pueden devolver nada.

204
00:12:13,000 --> 00:12:15,000
Porque son llamados aquí,

205
00:12:15,000 --> 00:12:18,000
y aquí no puedo poner yo aquí una variable para que recoja el valor.

206
00:12:18,000 --> 00:12:20,000
No puedo ponerla, porque ya tengo que poner esto obligatoriamente.

207
00:12:20,000 --> 00:12:21,000
Ya tengo que ponerlo.

208
00:12:21,000 --> 00:12:23,000
La sintaxis es esta.

209
00:12:23,000 --> 00:12:27,000
Entonces no puedo meter en ninguna variable ningún valor de retorno.

210
00:12:27,000 --> 00:12:31,000
Luego no se pone aquí nada para hacer el constructor.

211
00:12:33,000 --> 00:12:37,000
Bueno, pues en este caso ya tendríamos aquí un constructor ya hecho.

212
00:12:37,000 --> 00:12:40,000
Esta clase nuestra ya tiene un constructor.

213
00:12:40,000 --> 00:12:45,000
En este caso el constructor se va a invocar cada vez que yo creo un objeto.

214
00:12:45,000 --> 00:12:47,000
Y lo único que hace es mostrar un mensajito.

215
00:12:47,000 --> 00:12:50,000
Bueno, pues un constructor poco útil.

216
00:12:50,000 --> 00:12:54,000
Lo normal es darles a los constructores un poquito más de utilidad.

217
00:12:55,000 --> 00:12:57,000
¿Cómo? Pues a lo mejor pasándoles parámetros.

218
00:12:57,000 --> 00:13:00,000
Yo este constructor que he hecho no recibe ningún parámetro.

219
00:13:00,000 --> 00:13:02,000
Lo he declarado así porque me ha dado la gana.

220
00:13:04,000 --> 00:13:06,000
Entonces, como lo he declarado así,

221
00:13:06,000 --> 00:13:10,000
en el momento de hacer new pedido, también lo pongo así.

222
00:13:11,000 --> 00:13:14,000
Pero yo puedo hacer constructores que reciban cosas, parámetros,

223
00:13:14,000 --> 00:13:16,000
igual que cualquier otro método.

224
00:13:16,000 --> 00:13:17,000
Eso sí que lo puedo hacer.

225
00:13:17,000 --> 00:13:19,000
No puedo hacer que devuelvan nada, eso es imposible.

226
00:13:19,000 --> 00:13:23,000
Pero si me da la gana, yo puedo hacer un constructor que reciba parámetros.

227
00:13:24,000 --> 00:13:27,000
Y si los recibe, cuando yo haga el new pedido,

228
00:13:27,000 --> 00:13:29,000
se los tengo que pasar aquí obligatoriamente.

229
00:13:30,000 --> 00:13:32,000
Si yo lo he declarado para que reciba parámetros,

230
00:13:32,000 --> 00:13:34,000
se lo tengo que pasar ahí.

231
00:13:37,000 --> 00:13:40,000
Por ejemplo, el uso habitual de los constructores,

232
00:13:40,000 --> 00:13:43,000
que prácticamente siempre se usan para eso.

233
00:13:43,000 --> 00:13:45,000
Pues para ya que creo el objeto,

234
00:13:45,000 --> 00:13:48,000
vamos a aprovechar para inicializar sus propiedades.

235
00:13:48,000 --> 00:13:49,000
Por ejemplo, pedido.

236
00:13:49,000 --> 00:13:51,000
Imaginaos que tiene dos propiedades,

237
00:13:51,000 --> 00:13:55,000
que son el identificador y la descripción.

238
00:13:59,000 --> 00:14:00,000
¿Vale?

239
00:14:00,000 --> 00:14:02,000
Ahora, vamos a hacerle un constructor,

240
00:14:02,000 --> 00:14:03,000
un método constructor.

241
00:14:03,000 --> 00:14:05,000
El método constructor se tiene que llamar pedido.

242
00:14:06,000 --> 00:14:08,000
Aquí ni void ni nada,

243
00:14:09,000 --> 00:14:10,000
porque es el constructor.

244
00:14:11,000 --> 00:14:13,000
Y ahora, ¿qué parámetros decido pasarle?

245
00:14:14,000 --> 00:14:18,000
Venga, pues vamos a pasarle un id y una descripción

246
00:14:18,000 --> 00:14:20,000
desde fuera, cuando lo llamemos.

247
00:14:20,000 --> 00:14:22,000
Vamos a pasárselo por aquí.

248
00:14:22,000 --> 00:14:25,000
Y vamos a usarlo para que inicialice las propiedades.

249
00:14:25,000 --> 00:14:27,000
Así no tenemos luego que inicializarlas

250
00:14:27,000 --> 00:14:30,000
con p.id, p.descripción.

251
00:14:30,000 --> 00:14:31,000
¿Vale?

252
00:14:31,000 --> 00:14:32,000
Pues ¿qué tenemos que pasarle?

253
00:14:32,000 --> 00:14:34,000
Tenemos que pasarle un id.

254
00:14:34,000 --> 00:14:37,000
Pues venga, le voy a pasar un numerito entero para el id.

255
00:14:37,000 --> 00:14:39,000
¿Qué más le quiero pasar a este método?

256
00:14:39,000 --> 00:14:41,000
Una cadena para que inicialice esta.

257
00:14:41,000 --> 00:14:44,000
Pues venga, le voy a pasar como parámetro una cadena.

258
00:14:45,000 --> 00:14:47,000
string descripción.

259
00:14:49,000 --> 00:14:50,000
¿Vale?

260
00:14:50,000 --> 00:14:51,000
Y ahora,

261
00:14:51,000 --> 00:14:54,000
¿el constructor qué queremos que haga con estos parámetros

262
00:14:54,000 --> 00:14:56,000
que le hemos pasado desde fuera?

263
00:14:57,000 --> 00:15:00,000
Pues con estos parámetros queremos que los utilice

264
00:15:00,000 --> 00:15:03,000
para inicializar las propiedades del objeto.

265
00:15:03,000 --> 00:15:04,000
Pues venga,

266
00:15:04,000 --> 00:15:07,000
la propiedad del objeto dis.id,

267
00:15:08,000 --> 00:15:10,000
que se inicialice con esta,

268
00:15:12,000 --> 00:15:18,000
y la propiedad dis.descripción,

269
00:15:20,000 --> 00:15:23,000
que se inicialice con esta.

270
00:15:25,000 --> 00:15:28,000
Pues este es el aspecto típico de los constructores,

271
00:15:28,000 --> 00:15:30,000
porque suelen valer para esto.

272
00:15:30,000 --> 00:15:33,000
Uno puede poner dentro lo que le la gana, insisto.

273
00:15:33,000 --> 00:15:36,000
Si le interesa que pasen más cosas

274
00:15:36,000 --> 00:15:38,000
en el momento de construir el objeto,

275
00:15:38,000 --> 00:15:39,000
lo pone.

276
00:15:39,000 --> 00:15:41,000
Como si pone ahí 10.000 líneas.

277
00:15:41,000 --> 00:15:42,000
Pero bueno, ¿para qué?

278
00:15:42,000 --> 00:15:45,000
Normalmente cuando uno construye un objeto,

279
00:15:45,000 --> 00:15:47,000
lo más que quiere que ocurra con ese objeto

280
00:15:47,000 --> 00:15:49,000
es darle valor a las propiedades.

281
00:15:49,000 --> 00:15:51,000
Es lo más que quiere.

282
00:15:51,000 --> 00:15:54,000
Pues en ese caso pondré este código y ya está.

283
00:15:54,000 --> 00:15:57,000
Bueno, pues es el constructor típico.

284
00:15:57,000 --> 00:16:00,000
Ahora, ¿cómo usaremos este constructor?

285
00:16:00,000 --> 00:16:03,000
Pues vamos a imaginarnos que queremos crear un pedido.

286
00:16:04,000 --> 00:16:07,000
En nuestra aplicación necesita crear un objeto pedido.

287
00:16:07,000 --> 00:16:09,000
Pues eso no cambia.

288
00:16:09,000 --> 00:16:12,000
Por ejemplo, le llamo p a ese objeto pedido

289
00:16:12,000 --> 00:16:15,000
en mi clase main, que estoy ahora en mi clase main.

290
00:16:15,000 --> 00:16:17,000
Pues venga, ¿cómo creamos un pedido?

291
00:16:17,000 --> 00:16:19,000
new, eso no cambia.

292
00:16:19,000 --> 00:16:21,000
new pedido, eso no cambia.

293
00:16:21,000 --> 00:16:25,000
Pero ojo, ahora los paredes ya no se quedan vacíos,

294
00:16:25,000 --> 00:16:28,000
porque ahora tengo un constructor

295
00:16:28,000 --> 00:16:31,000
que necesita recibir dos cosas.

296
00:16:31,000 --> 00:16:34,000
Si yo lo dejar así vacío,

297
00:16:34,000 --> 00:16:36,000
el compilador, ahora lo repasaremos

298
00:16:36,000 --> 00:16:38,000
y lo comprobaremos todo.

299
00:16:38,000 --> 00:16:40,000
El compilador me diría,

300
00:16:40,000 --> 00:16:42,000
me lo pondría rojito y me diría,

301
00:16:42,000 --> 00:16:45,000
perdona, pero no puedo llamar al constructor

302
00:16:45,000 --> 00:16:48,000
sin parámetros, porque es que el constructor

303
00:16:48,000 --> 00:16:50,000
tú lo has hecho para que reciba

304
00:16:50,000 --> 00:16:52,000
un entero y una cadena.

305
00:16:52,000 --> 00:16:54,000
Perdona, lo has hecho para que reciba

306
00:16:54,000 --> 00:16:56,000
un entero y una cadena.

307
00:16:56,000 --> 00:16:59,000
Luego no lo llames así, porque así no va a funcionar.

308
00:16:59,000 --> 00:17:01,000
Bueno, pues entonces aquí tenemos que pasar

309
00:17:01,000 --> 00:17:03,000
obligatoriamente un entero y una cadena.

310
00:17:03,000 --> 00:17:05,000
El uso normal sería que yo hubiera dicho primero

311
00:17:05,000 --> 00:17:08,000
introduzca el código del pedido, patatín.

312
00:17:08,000 --> 00:17:10,000
Introduzca la descripción del pedido, patatín.

313
00:17:10,000 --> 00:17:13,000
Y ahora le paso aquí esas dos variables.

314
00:17:13,000 --> 00:17:15,000
Vamos a suponer que se las doy directamente

315
00:17:15,000 --> 00:17:18,000
a capón aquí, porque no las he pedido por teclado.

316
00:17:18,000 --> 00:17:20,000
Bueno, esta llamada ya sí que es válida.

317
00:17:20,000 --> 00:17:23,000
Entonces con esto, ¿qué estaríamos haciendo?

318
00:17:23,000 --> 00:17:25,000
Construir un objeto pedido,

319
00:17:25,000 --> 00:17:28,000
que se quede apuntado por P.

320
00:17:28,000 --> 00:17:31,000
Y ahora, además de crear el espacio,

321
00:17:31,000 --> 00:17:33,000
saltamos al constructor.

322
00:17:33,000 --> 00:17:34,000
¿Qué hace el constructor?

323
00:17:34,000 --> 00:17:38,000
Coge 5, se lo asigna la propiedad ID del objeto,

324
00:17:38,000 --> 00:17:41,000
que es esta, ahí se queda el 5.

325
00:17:41,000 --> 00:17:44,000
Y coge descripción, que es D,

326
00:17:44,000 --> 00:17:47,000
y se lo asigna la propiedad de descripción del objeto,

327
00:17:47,000 --> 00:17:48,000
que es esta.

328
00:17:48,000 --> 00:17:52,000
Pues ala, esto habríamos conseguido con esta llamada.

329
00:17:52,000 --> 00:17:55,000
No solo crear el objeto, el espacio en memoria para él,

330
00:17:55,000 --> 00:17:57,000
sino además ya de paso,

331
00:17:57,000 --> 00:18:00,000
dar unos valores iniciales a las propiedades.

332
00:18:01,000 --> 00:18:02,000
Dar unos valores iniciales.

333
00:18:02,000 --> 00:18:04,000
Que es el uso habitual del constructor,

334
00:18:04,000 --> 00:18:06,000
cuando existe, el uso habitual.

335
00:18:06,000 --> 00:18:11,000
A partir de aquí, si yo ahora ya tengo P.ID que vale 5,

336
00:18:11,000 --> 00:18:14,000
P.descripción que vale D,

337
00:18:14,000 --> 00:18:17,000
que las quiero volver a cambiar, pues las vuelvo a cambiar.

338
00:18:17,000 --> 00:18:19,000
Pero ya tengo unos valores iniciales.

339
00:18:21,000 --> 00:18:22,000
¿Vale?

340
00:18:26,000 --> 00:18:28,000
En los ejemplos anteriores,

341
00:18:28,000 --> 00:18:31,000
no habíamos puesto método constructor.

342
00:18:31,000 --> 00:18:33,000
Esto no estaba.

343
00:18:33,000 --> 00:18:35,000
Entonces llamábamos sin parámetros,

344
00:18:35,000 --> 00:18:37,000
lo llamábamos así.

345
00:18:38,000 --> 00:18:41,000
Entonces uno diría, uy, pero si no tengo método constructor,

346
00:18:41,000 --> 00:18:44,000
el compilador como verifica que...

347
00:18:44,000 --> 00:18:47,000
A ver, si yo no he hecho método constructor,

348
00:18:47,000 --> 00:18:49,000
Java se inventa uno y lo pone ahí.

349
00:18:49,000 --> 00:18:51,000
Aunque nosotros no lo veamos físicamente.

350
00:18:51,000 --> 00:18:52,000
Lo pone ahí.

351
00:18:52,000 --> 00:18:55,000
Entonces si mi clase no tuviera método constructor,

352
00:18:55,000 --> 00:18:58,000
porque esto no lo tiene, yo no lo he puesto,

353
00:18:58,000 --> 00:19:02,000
es como si existiera esto.

354
00:19:02,000 --> 00:19:04,000
Que la máquina virtual lo pone y se lo inventa.

355
00:19:04,000 --> 00:19:06,000
Es como si existiera esto.

356
00:19:06,000 --> 00:19:09,000
Pedido sin parámetros y vacío.

357
00:19:09,000 --> 00:19:10,000
Se lo inventa.

358
00:19:10,000 --> 00:19:12,000
Y dice, ¿no tienes método constructor?

359
00:19:12,000 --> 00:19:15,000
Vale, me hago uno sin parámetros, sin código.

360
00:19:15,000 --> 00:19:17,000
Y ahí está oculto, aunque no lo veamos.

361
00:19:17,000 --> 00:19:19,000
Ahí está oculto.

362
00:19:19,000 --> 00:19:22,000
Que este es el que se llama el constructor sin parámetros.

363
00:19:22,000 --> 00:19:25,000
Entonces luego por eso, cuando hemos creado los objetos

364
00:19:25,000 --> 00:19:27,000
en nuestros ejemplos anteriores, los hemos creado así,

365
00:19:27,000 --> 00:19:28,000
sin parámetros.

366
00:19:28,000 --> 00:19:30,000
Porque como no habíamos hecho ni un constructor,

367
00:19:30,000 --> 00:19:33,000
la máquina virtual se ha inventado este.

368
00:19:33,000 --> 00:19:34,000
Que es el que se inventa siempre.

369
00:19:34,000 --> 00:19:36,000
Y este no tiene parámetros.

370
00:19:36,000 --> 00:19:37,000
Luego la llamada encajaba.

371
00:19:37,000 --> 00:19:40,000
Porque sin parámetros, sin parámetros.

372
00:19:40,000 --> 00:19:42,000
Pero siempre se llama un constructor.

373
00:19:42,000 --> 00:19:44,000
O bien el que he hecho yo,

374
00:19:44,000 --> 00:19:46,000
o bien el que la máquina virtual se ha inventado

375
00:19:46,000 --> 00:19:48,000
porque no tiene nada.

376
00:19:53,000 --> 00:19:55,000
Vale.

377
00:19:55,000 --> 00:20:01,000
Vamos a verlo en el eclipse, que se va a ver todo más claro.

378
00:20:01,000 --> 00:20:24,000
Bueno, ya sí que están subidas todas las clases.

379
00:20:24,000 --> 00:20:26,000
Aunque alguna puede estar medio rara

380
00:20:26,000 --> 00:20:30,000
porque se me olvidó cortar a veces en eso.

381
00:20:30,000 --> 00:20:35,000
Pero bueno, ya con las últimas ya están mejor.

382
00:20:35,000 --> 00:20:37,000
Y subido al aula virtual ya el proyecto este

383
00:20:37,000 --> 00:20:40,000
con el que vamos a hacer los ejemplos.

384
00:20:40,000 --> 00:20:42,000
Y los ejercicios que subimos ayer,

385
00:20:42,000 --> 00:20:47,000
que eran sobre el primero y parte del segundo.

386
00:20:47,000 --> 00:20:50,000
Vale, pues sobre este mismo proyecto de ejemplo

387
00:20:50,000 --> 00:20:52,000
que estamos usando de pedidos

388
00:20:52,000 --> 00:20:55,000
y que iremos ampliando e incorporando cosas,

389
00:20:55,000 --> 00:20:57,000
vamos a ampliar ahora con los constructores.

390
00:20:57,000 --> 00:20:59,000
¿Vale?

391
00:20:59,000 --> 00:21:02,000
¿Se ve mejor sin la luz?

392
00:21:14,000 --> 00:21:22,000
Bueno, esto es lo de ayer, vamos a olvidarnos.

393
00:21:22,000 --> 00:21:26,000
Vale, a ver, nuestro ejemplo de clases y objetos.

394
00:21:26,000 --> 00:21:29,000
Vale, esta es nuestra clase pedido de partida.

395
00:21:29,000 --> 00:21:33,000
Tenía tres propiedades, un método comprobar cliente

396
00:21:33,000 --> 00:21:35,000
con lo que estuvimos trabajando,

397
00:21:35,000 --> 00:21:37,000
un método actualiza descripción

398
00:21:37,000 --> 00:21:39,000
y luego ya teníamos aquí uno quantum main

399
00:21:39,000 --> 00:21:41,000
para probar cosas.

400
00:21:41,000 --> 00:21:42,000
¿Vale?

401
00:21:42,000 --> 00:21:44,000
Bueno, pues vamos a ampliar ahora nuestra clase pedido

402
00:21:44,000 --> 00:21:47,000
y vamos a ponerle un método constructor.

403
00:21:47,000 --> 00:21:50,000
Le vamos a poner un método constructor.

404
00:21:50,000 --> 00:21:52,000
Vale, pues venga, el método constructor

405
00:21:52,000 --> 00:21:55,000
se suele poner al principio de todos los métodos,

406
00:21:55,000 --> 00:21:57,000
después de las propiedades.

407
00:21:57,000 --> 00:21:59,000
No es que sea obligatorio,

408
00:21:59,000 --> 00:22:04,000
pero insisto, acostumbraos a seguir estilos de programación

409
00:22:04,000 --> 00:22:06,000
que compartimos todos,

410
00:22:06,000 --> 00:22:09,000
porque vuestros programas si no, no van a valer igual.

411
00:22:09,000 --> 00:22:11,000
Da igual que funcionen,

412
00:22:11,000 --> 00:22:13,000
si no siguen esos estilos de programación compartidos

413
00:22:13,000 --> 00:22:16,000
no van a ser legibles fácilmente

414
00:22:16,000 --> 00:22:18,000
y eso les hace poco valiosos.

415
00:22:18,000 --> 00:22:21,000
Vale, pues el constructor,

416
00:22:21,000 --> 00:22:24,000
vamos a hacer un constructor que,

417
00:22:24,000 --> 00:22:26,000
el constructor estándar,

418
00:22:26,000 --> 00:22:28,000
podríamos hacer cualquier cosa,

419
00:22:28,000 --> 00:22:30,000
pero vamos a hacer un constructor que reciba

420
00:22:30,000 --> 00:22:34,000
tantos parámetros como propiedades tiene el objeto

421
00:22:34,000 --> 00:22:38,000
y los use para inicializar

422
00:22:38,000 --> 00:22:40,000
las propiedades del objeto.

423
00:22:40,000 --> 00:22:43,000
Pues entonces en este caso habrá que pasarle

424
00:22:43,000 --> 00:22:47,000
un código,

425
00:22:47,000 --> 00:22:50,000
una descripción,

426
00:22:50,000 --> 00:23:00,000
una array de clientes.

427
00:23:00,000 --> 00:23:03,000
Vale, ¿y para qué puede usar estos parámetros el constructor?

428
00:23:03,000 --> 00:23:06,000
Pues para la propiedad .código,

429
00:23:06,000 --> 00:23:08,000
obligatorio poner el dis,

430
00:23:08,000 --> 00:23:10,000
porque con el nombre que he elegido para el parámetro

431
00:23:10,000 --> 00:23:12,000
tengo que distinguir,

432
00:23:12,000 --> 00:23:14,000
código,

433
00:23:14,000 --> 00:23:16,000
descripción,

434
00:23:16,000 --> 00:23:24,000
para la propiedad del objeto .descripción,

435
00:23:24,000 --> 00:23:28,000
pues descripción,

436
00:23:28,000 --> 00:23:36,000
y para la propiedad .clientes,

437
00:23:36,000 --> 00:23:38,000
clientes.

438
00:23:38,000 --> 00:23:41,000
Vale, este suele ser el aspecto estándar del constructor.

439
00:23:41,000 --> 00:23:44,000
Como veis, yo aquí no he puesto valor de retorno

440
00:23:44,000 --> 00:23:47,000
y el compilador no se queja ni dice nada.

441
00:23:47,000 --> 00:23:49,000
Dice, vale, muy bien.

442
00:23:49,000 --> 00:23:51,000
Pero sin embargo, si en un método normal y corriente

443
00:23:51,000 --> 00:23:53,000
que no es constructor,

444
00:23:53,000 --> 00:23:55,000
le quitara yo el valor de retorno,

445
00:23:55,000 --> 00:23:57,000
le quitara esto,

446
00:23:57,000 --> 00:23:59,000
automáticamente me diría aquí,

447
00:23:59,000 --> 00:24:01,000
oye, lo siento,

448
00:24:01,000 --> 00:24:03,000
pero me está diciendo,

449
00:24:03,000 --> 00:24:06,000
el tipo de retorno te falta, ponlo.

450
00:24:06,000 --> 00:24:08,000
Es lo que me está diciendo esta cosa amarilla,

451
00:24:08,000 --> 00:24:10,000
oye, oye, que te falta, ponlo.

452
00:24:10,000 --> 00:24:12,000
Claro, porque este no es el método constructor,

453
00:24:12,000 --> 00:24:14,000
es un método normalucho y corrientucho,

454
00:24:14,000 --> 00:24:17,000
entonces todos los métodos normales y corrientes

455
00:24:17,000 --> 00:24:20,000
necesitan el tipo de dato.

456
00:24:20,000 --> 00:24:22,000
Pero aquí en este no me lo ha pedido,

457
00:24:22,000 --> 00:24:24,000
porque este sabe que es el constructor.

458
00:24:24,000 --> 00:24:26,000
¿Y por qué sabe que es el constructor?

459
00:24:26,000 --> 00:24:30,000
Porque se llama exactamente igual que la clase.

460
00:24:30,000 --> 00:24:34,000
Si yo le cambio el nombre y lo llamo así,

461
00:24:34,000 --> 00:24:36,000
ya está, dejó de ser el constructor,

462
00:24:36,000 --> 00:24:38,000
porque le he cambiado el nombre,

463
00:24:38,000 --> 00:24:39,000
dejó de ser el constructor.

464
00:24:39,000 --> 00:24:40,000
¿Pasa algo?

465
00:24:40,000 --> 00:24:41,000
No pasa nada, el código está bien,

466
00:24:41,000 --> 00:24:42,000
todo está bien,

467
00:24:42,000 --> 00:24:44,000
pero lo que pasa es que entonces me dice

468
00:24:44,000 --> 00:24:45,000
el compilador,

469
00:24:45,000 --> 00:24:46,000
oye, este no es el constructor,

470
00:24:46,000 --> 00:24:48,000
con lo cual es obligatorio que le ponga

471
00:24:48,000 --> 00:24:49,000
el valor de retorno.

472
00:24:49,000 --> 00:24:51,000
Bueno, pues yo le pongo el valor de retorno

473
00:24:51,000 --> 00:24:52,000
y ya está.

474
00:24:52,000 --> 00:24:54,000
Pero esto ya no es el método constructor,

475
00:24:54,000 --> 00:24:55,000
esto es otro,

476
00:24:55,000 --> 00:24:57,000
con lo cual este no se va a invocar nunca

477
00:24:57,000 --> 00:24:58,000
cuando se hace el mío, nunca,

478
00:24:58,000 --> 00:24:59,000
porque es otro.

479
00:24:59,000 --> 00:25:01,000
Para que sea el constructor,

480
00:25:01,000 --> 00:25:02,000
por tanto, repito,

481
00:25:02,000 --> 00:25:04,000
se tiene que llamar igual que la clase.

482
00:25:04,000 --> 00:25:05,000
¿Vale?

483
00:25:05,000 --> 00:25:06,000
Y en ese caso,

484
00:25:06,000 --> 00:25:08,000
esto ni se pone nada,

485
00:25:08,000 --> 00:25:09,000
se queda en blanco

486
00:25:09,000 --> 00:25:10,000
para que se vea bien claro

487
00:25:10,000 --> 00:25:11,000
que es el constructor.

488
00:25:11,000 --> 00:25:13,000
Y no me quite los avisos de

489
00:25:13,000 --> 00:25:14,000
oye, ese es constructor,

490
00:25:14,000 --> 00:25:15,000
¿para qué le pones void?

491
00:25:15,000 --> 00:25:16,000
Bla, bla, bla.

492
00:25:16,000 --> 00:25:18,000
¿No es un public?

493
00:25:18,000 --> 00:25:19,000
No pasa nada,

494
00:25:19,000 --> 00:25:20,000
pero eso tiene que ver,

495
00:25:20,000 --> 00:25:21,000
de nuevo,

496
00:25:21,000 --> 00:25:23,000
los public, private, protect, etc.,

497
00:25:23,000 --> 00:25:25,000
tienen que ver con los paquetes.

498
00:25:25,000 --> 00:25:26,000
Y es que los paquetes

499
00:25:26,000 --> 00:25:27,000
todavía no los hemos contado.

500
00:25:27,000 --> 00:25:29,000
Por eso yo no pongo public en nada,

501
00:25:29,000 --> 00:25:30,000
porque no quiero poner nada

502
00:25:30,000 --> 00:25:32,000
que no entendemos lo que significa.

503
00:25:32,000 --> 00:25:33,000
Tú tranquilo,

504
00:25:33,000 --> 00:25:34,000
que tenemos que ver

505
00:25:34,000 --> 00:25:35,000
cómo construir paquetes,

506
00:25:35,000 --> 00:25:36,000
cómo empaquetar con criterio

507
00:25:36,000 --> 00:25:38,000
y cómo hacer modificadores de acceso.

508
00:25:38,000 --> 00:25:39,000
Public, private,

509
00:25:39,000 --> 00:25:41,000
todos esos modificadores de acceso.

510
00:25:41,000 --> 00:25:42,000
Pero claro,

511
00:25:42,000 --> 00:25:43,000
esos modificadores de acceso

512
00:25:43,000 --> 00:25:44,000
existen de momento

513
00:25:44,000 --> 00:25:45,000
en que existen paquetes.

514
00:25:45,000 --> 00:25:46,000
Si no,

515
00:25:46,000 --> 00:25:47,000
no tiene sentido que existan.

516
00:25:47,000 --> 00:25:48,000
Entonces,

517
00:25:48,000 --> 00:25:49,000
como no estamos todavía

518
00:25:49,000 --> 00:25:50,000
trabajando con paquetes,

519
00:25:50,000 --> 00:25:51,000
obvio los public,

520
00:25:51,000 --> 00:25:52,000
los quito siempre.

521
00:25:52,000 --> 00:25:53,000
¿Vale?

522
00:25:53,000 --> 00:25:54,000
¿Qué los pones?

523
00:25:54,000 --> 00:25:55,000
No pasa nada,

524
00:25:55,000 --> 00:25:56,000
no tiene implicaciones.

525
00:25:56,000 --> 00:25:57,000
Ahora mismo,

526
00:25:57,000 --> 00:25:58,000
porque no tiene implicaciones,

527
00:25:58,000 --> 00:25:59,000
pero todavía no las estamos viendo.

528
00:25:59,000 --> 00:26:00,000
Lo puedes poner.

529
00:26:00,000 --> 00:26:01,000
Vale,

530
00:26:01,000 --> 00:26:02,000
pues este es el aspecto estándar

531
00:26:02,000 --> 00:26:03,000
de un constructor

532
00:26:03,000 --> 00:26:05,000
normal y corriente.

533
00:26:06,000 --> 00:26:07,000
Repito,

534
00:26:07,000 --> 00:26:08,000
uno le puede poner

535
00:26:08,000 --> 00:26:09,000
lo que le dé la gana.

536
00:26:09,000 --> 00:26:10,000
Lo que quiera.

537
00:26:10,000 --> 00:26:11,000
Podríamos poner aquí,

538
00:26:11,000 --> 00:26:12,000
ala,

539
00:26:12,000 --> 00:26:14,000
se ha construido el pedido.

540
00:26:15,000 --> 00:26:16,000
¿Vale?

541
00:26:16,000 --> 00:26:17,000
Y ya está,

542
00:26:17,000 --> 00:26:18,000
se ha construido el pedido.

543
00:26:18,000 --> 00:26:19,000
Vale.

544
00:26:20,000 --> 00:26:21,000
Bueno,

545
00:26:21,000 --> 00:26:22,000
pues entonces,

546
00:26:22,000 --> 00:26:23,000
ahora,

547
00:26:23,000 --> 00:26:24,000
podríamos crear

548
00:26:24,000 --> 00:26:25,000
un objeto pedido,

549
00:26:25,000 --> 00:26:27,000
pero ya tendríamos que pasarle

550
00:26:27,000 --> 00:26:29,000
esto obligatoriamente.

551
00:26:29,000 --> 00:26:30,000
Ups.

552
00:26:30,000 --> 00:26:31,000
Por eso,

553
00:26:31,000 --> 00:26:33,000
en mis main de arriba,

554
00:26:33,000 --> 00:26:34,000
ahora ya se me han puesto

555
00:26:34,000 --> 00:26:35,000
en rojo,

556
00:26:35,000 --> 00:26:36,000
porque ahora ya

557
00:26:36,000 --> 00:26:38,000
el compilador me dice,

558
00:26:38,000 --> 00:26:39,000
eh,

559
00:26:39,000 --> 00:26:40,000
ojo,

560
00:26:40,000 --> 00:26:41,000
ojo,

561
00:26:41,000 --> 00:26:43,000
que cuando construyas el objeto,

562
00:26:43,000 --> 00:26:45,000
el constructor que has hecho,

563
00:26:45,000 --> 00:26:47,000
necesita parámetros.

564
00:26:48,000 --> 00:26:50,000
No me llames sin parámetros.

565
00:26:50,000 --> 00:26:51,000
Es imposible,

566
00:26:51,000 --> 00:26:52,000
por eso se me ha puesto en rojo.

567
00:26:52,000 --> 00:26:53,000
¿Vale?

568
00:26:53,000 --> 00:26:54,000
Ahora le ponemos parámetros

569
00:26:54,000 --> 00:26:55,000
y vamos con ello.

570
00:26:55,000 --> 00:26:56,000
Vale,

571
00:26:56,000 --> 00:26:57,000
volvemos un momento

572
00:26:57,000 --> 00:26:58,000
con el aspecto del código.

573
00:26:58,000 --> 00:26:59,000
Vale,

574
00:26:59,000 --> 00:27:01,000
para no tener que escribir tanto,

575
00:27:01,000 --> 00:27:03,000
este estándar

576
00:27:03,000 --> 00:27:04,000
eh,

577
00:27:04,000 --> 00:27:05,000
de forma tan generalizada,

578
00:27:05,000 --> 00:27:06,000
el uso habitual

579
00:27:06,000 --> 00:27:07,000
de los constructores,

580
00:27:07,000 --> 00:27:08,000
suele ser este,

581
00:27:08,000 --> 00:27:09,000
el uso habitual,

582
00:27:09,000 --> 00:27:10,000
que todos los entornos

583
00:27:10,000 --> 00:27:11,000
de desarrollo,

584
00:27:11,000 --> 00:27:12,000
te facilitan

585
00:27:12,000 --> 00:27:13,000
una forma de,

586
00:27:13,000 --> 00:27:14,000
pam,

587
00:27:14,000 --> 00:27:15,000
que te lo escribe el solo.

588
00:27:15,000 --> 00:27:16,000
¿Vale?

589
00:27:16,000 --> 00:27:17,000
Entonces,

590
00:27:17,000 --> 00:27:19,000
si vosotros dais aquí

591
00:27:19,000 --> 00:27:20,000
al botón derecho del eclipse,

592
00:27:20,000 --> 00:27:21,000
esto es un truco para vagos.

593
00:27:21,000 --> 00:27:22,000
¿Vale?

594
00:27:22,000 --> 00:27:23,000
Si le dais al botón

595
00:27:23,000 --> 00:27:24,000
de derecho del eclipse,

596
00:27:24,000 --> 00:27:25,000
si os vais a source,

597
00:27:25,000 --> 00:27:26,000
fuente,

598
00:27:26,000 --> 00:27:27,000
veis que

599
00:27:27,000 --> 00:27:28,000
se os despliega a la derecha

600
00:27:28,000 --> 00:27:29,000
un generar constructor

601
00:27:29,000 --> 00:27:30,000
usando campos.

602
00:27:30,000 --> 00:27:32,000
Campos son propiedades.

603
00:27:32,000 --> 00:27:33,000
¿Recordáis que cuando dijimos

604
00:27:33,000 --> 00:27:34,000
propiedades lo dije?

605
00:27:34,000 --> 00:27:35,000
Dije,

606
00:27:35,000 --> 00:27:36,000
en inglés

607
00:27:36,000 --> 00:27:37,000
se suele usar el término fill.

608
00:27:37,000 --> 00:27:38,000
Fill significa

609
00:27:38,000 --> 00:27:39,000
propiedad,

610
00:27:39,000 --> 00:27:40,000
que es sinónimo

611
00:27:40,000 --> 00:27:41,000
de atributo,

612
00:27:41,000 --> 00:27:42,000
variable de clase,

613
00:27:42,000 --> 00:27:43,000
etc.

614
00:27:43,000 --> 00:27:44,000
Pues,

615
00:27:44,000 --> 00:27:45,000
generar constructor

616
00:27:45,000 --> 00:27:46,000
usando campos.

617
00:27:46,000 --> 00:27:47,000
Marcáis

618
00:27:47,000 --> 00:27:48,000
todas las propiedades

619
00:27:48,000 --> 00:27:49,000
que queráis

620
00:27:49,000 --> 00:27:50,000
que aparezca

621
00:27:50,000 --> 00:27:51,000
en el constructor

622
00:27:51,000 --> 00:27:52,000
y ala,

623
00:27:52,000 --> 00:27:53,000
te lo genera

624
00:27:53,000 --> 00:27:54,000
automáticamente.

625
00:27:54,000 --> 00:27:55,000
¿Vale?

626
00:27:55,000 --> 00:27:56,000
Y él también,

627
00:27:56,000 --> 00:27:57,000
fíjate que casualidad,

628
00:27:57,000 --> 00:27:58,000
ha escogido

629
00:27:58,000 --> 00:27:59,000
como nombres

630
00:27:59,000 --> 00:28:00,000
de los parámetros

631
00:28:00,000 --> 00:28:01,000
los mismos

632
00:28:02,000 --> 00:28:03,000
que los de la clase.

633
00:28:03,000 --> 00:28:04,000
Para que quede muy claro

634
00:28:04,000 --> 00:28:06,000
que son el mismo concepto.

635
00:28:06,000 --> 00:28:07,000
Pero claro,

636
00:28:07,000 --> 00:28:08,000
eso le obliga

637
00:28:08,000 --> 00:28:09,000
a poner el dis.

638
00:28:09,000 --> 00:28:11,000
Le obliga a poner el dis.

639
00:28:11,000 --> 00:28:12,000
¿Vale?

640
00:28:15,000 --> 00:28:16,000
No olvidéis del dis.

641
00:28:16,000 --> 00:28:17,000
El dis significa

642
00:28:17,000 --> 00:28:19,000
el objeto en el que estoy,

643
00:28:19,000 --> 00:28:20,000
punto,

644
00:28:20,000 --> 00:28:21,000
propiedad del objeto.

645
00:28:21,000 --> 00:28:23,000
Si no ponemos el dis,

646
00:28:23,000 --> 00:28:24,000
si uno dice,

647
00:28:24,000 --> 00:28:25,000
uy,

648
00:28:25,000 --> 00:28:26,000
este dis que me molesta,

649
00:28:26,000 --> 00:28:27,000
lo quito,

650
00:28:27,000 --> 00:28:29,000
ha estropeado el constructor,

651
00:28:29,000 --> 00:28:30,000
porque automáticamente

652
00:28:30,000 --> 00:28:31,000
ahora código

653
00:28:31,000 --> 00:28:32,000
se referirá

654
00:28:32,000 --> 00:28:34,000
a este parámetro.

655
00:28:34,000 --> 00:28:35,000
Y es absurdo.

656
00:28:35,000 --> 00:28:36,000
A este parámetro

657
00:28:36,000 --> 00:28:37,000
darle el valor

658
00:28:37,000 --> 00:28:38,000
de este parámetro.

659
00:28:38,000 --> 00:28:39,000
Que tontería,

660
00:28:39,000 --> 00:28:40,000
no estamos diciendo nada.

661
00:28:43,000 --> 00:28:44,000
Vale.

662
00:28:44,000 --> 00:28:45,000
Entonces,

663
00:28:45,000 --> 00:28:46,000
el super

664
00:28:46,000 --> 00:28:47,000
tiene que ver con la herencia,

665
00:28:47,000 --> 00:28:48,000
no molesta si está ahí.

666
00:28:48,000 --> 00:28:49,000
Porque no hace nada

667
00:28:49,000 --> 00:28:50,000
ahora mismo.

668
00:28:50,000 --> 00:28:52,000
Porque no tenemos superclases.

669
00:28:52,000 --> 00:28:53,000
Y el public

670
00:28:53,000 --> 00:28:54,000
tampoco molesta,

671
00:28:54,000 --> 00:28:55,000
pero tampoco entendemos

672
00:28:55,000 --> 00:28:57,000
exactamente qué significa.

673
00:28:57,000 --> 00:28:58,000
Así que lo podemos quitar

674
00:28:58,000 --> 00:28:59,000
o dejar.

675
00:28:59,000 --> 00:29:00,000
Todavía no entendemos

676
00:29:00,000 --> 00:29:01,000
qué significa

677
00:29:01,000 --> 00:29:02,000
ni una cosa ni la otra.

678
00:29:02,000 --> 00:29:03,000
Bueno,

679
00:29:03,000 --> 00:29:04,000
pues nos ha generado

680
00:29:04,000 --> 00:29:05,000
el mismo código

681
00:29:05,000 --> 00:29:06,000
que hemos hecho nosotros.

682
00:29:06,000 --> 00:29:07,000
O sea,

683
00:29:07,000 --> 00:29:08,000
nos permite generarlo fácil.

684
00:29:08,000 --> 00:29:09,000
Bueno,

685
00:29:09,000 --> 00:29:10,000
ahora ya podemos

686
00:29:10,000 --> 00:29:11,000
crear pedidos,

687
00:29:11,000 --> 00:29:12,000
podemos crear pedidos

688
00:29:12,000 --> 00:29:13,000
usando este constructor

689
00:29:13,000 --> 00:29:14,000
de forma más cómoda.

690
00:29:16,000 --> 00:29:17,000
Vale,

691
00:29:17,000 --> 00:29:18,000
vamos a hacer un main3.

692
00:29:25,000 --> 00:29:27,000
Usando este constructor.

693
00:29:29,000 --> 00:29:30,000
Ahora,

694
00:29:31,000 --> 00:29:32,000
pues para construir un pedido

695
00:29:32,000 --> 00:29:33,000
lo normal ahora sería

696
00:29:33,000 --> 00:29:34,000
que uno pidiera

697
00:29:34,000 --> 00:29:35,000
con antelación,

698
00:29:35,000 --> 00:29:36,000
antes de construirlo

699
00:29:36,000 --> 00:29:37,000
pidiera con antelación

700
00:29:37,000 --> 00:29:38,000
los datos.

701
00:29:38,000 --> 00:29:39,000
Introduzca

702
00:29:39,000 --> 00:29:40,000
descripción,

703
00:29:40,000 --> 00:29:41,000
introduzca no sé qué.

704
00:29:42,000 --> 00:29:43,000
Voy a

705
00:29:43,000 --> 00:29:44,000
copiar de aquí

706
00:29:48,000 --> 00:29:49,000
del otro main

707
00:29:49,000 --> 00:29:50,000
el escáner.

708
00:29:51,000 --> 00:29:52,000
Y ahora voy a copiar

709
00:29:52,000 --> 00:29:53,000
de aquí esto,

710
00:29:53,000 --> 00:29:54,000
introduzca código,

711
00:29:54,000 --> 00:29:55,000
descripción

712
00:29:55,000 --> 00:29:56,000
para que

713
00:30:00,000 --> 00:30:01,000
vale,

714
00:30:03,000 --> 00:30:04,000
introduzca código,

715
00:30:04,000 --> 00:30:05,000
suponer que lo guardamos

716
00:30:05,000 --> 00:30:06,000
en una variable cualquiera,

717
00:30:06,000 --> 00:30:07,000
incódigo,

718
00:30:10,000 --> 00:30:11,000
introduzca descripción,

719
00:30:13,000 --> 00:30:14,000
vamos a suponer

720
00:30:14,000 --> 00:30:15,000
que lo guardamos

721
00:30:15,000 --> 00:30:16,000
en una variable cualquiera.

722
00:30:19,000 --> 00:30:20,000
Vale,

723
00:30:20,000 --> 00:30:21,000
ya tenemos dos valores

724
00:30:21,000 --> 00:30:22,000
leídos,

725
00:30:22,000 --> 00:30:23,000
dos variables,

726
00:30:23,000 --> 00:30:24,000
un código

727
00:30:24,000 --> 00:30:25,000
y una descripción.

728
00:30:25,000 --> 00:30:26,000
¿Para qué las vamos a usar?

729
00:30:27,000 --> 00:30:28,000
Pues las vamos a usar

730
00:30:28,000 --> 00:30:29,000
para crear ahora ya

731
00:30:30,000 --> 00:30:31,000
un nuevo objeto pedido,

732
00:30:32,000 --> 00:30:33,000
pedido p

733
00:30:33,000 --> 00:30:34,000
igual a

734
00:30:34,000 --> 00:30:35,000
new pedido

735
00:30:37,000 --> 00:30:38,000
y ahora tengo que pasarle

736
00:30:39,000 --> 00:30:40,000
los valores

737
00:30:40,000 --> 00:30:41,000
que el constructor me exige.

738
00:30:42,000 --> 00:30:43,000
El constructor me exige

739
00:30:43,000 --> 00:30:44,000
una descripción

740
00:30:45,000 --> 00:30:46,000
y un array

741
00:30:46,000 --> 00:30:47,000
para inicializar las propiedades.

742
00:30:48,000 --> 00:30:49,000
Bueno,

743
00:30:49,000 --> 00:30:50,000
pues el código lo tengo

744
00:30:50,000 --> 00:30:51,000
que lo acabo de leer,

745
00:30:51,000 --> 00:30:52,000
pues se lo paso,

746
00:30:53,000 --> 00:30:54,000
la descripción la tengo

747
00:30:54,000 --> 00:30:55,000
que la acabo de leer

748
00:30:56,000 --> 00:30:57,000
y vamos a crear un pedido

749
00:30:57,000 --> 00:30:58,000
con un array

750
00:30:58,000 --> 00:30:59,000
por ahora nulo,

751
00:30:59,000 --> 00:31:00,000
un array nulo,

752
00:31:00,000 --> 00:31:01,000
ya pues de así

753
00:31:01,000 --> 00:31:02,000
luego lo queremos crear

754
00:31:02,000 --> 00:31:03,000
los clientes,

755
00:31:03,000 --> 00:31:04,000
lo creamos.

756
00:31:04,000 --> 00:31:05,000
Bueno,

757
00:31:05,000 --> 00:31:06,000
pues esta llamada

758
00:31:06,000 --> 00:31:07,000
ya es una llamada válida,

759
00:31:07,000 --> 00:31:08,000
ya hemos creado el objeto.

760
00:31:16,000 --> 00:31:17,000
El objeto

761
00:31:17,000 --> 00:31:18,000
tiene

762
00:31:20,000 --> 00:31:21,000
de id

763
00:31:22,000 --> 00:31:23,000
y vamos a ponerlo aquí,

764
00:31:23,000 --> 00:31:24,000
p.id

765
00:31:27,000 --> 00:31:28,000
no, p.código

766
00:31:29,000 --> 00:31:30,000
se llamaba, ¿no?

767
00:31:38,000 --> 00:31:40,000
El objeto pedido

768
00:31:41,000 --> 00:31:43,000
tiene de descripción

769
00:31:49,000 --> 00:31:51,000
p.descripción

770
00:31:57,000 --> 00:31:58,000
Vale, pues ya está.

771
00:31:59,000 --> 00:32:00,000
Si ejecutamos esto,

772
00:32:00,000 --> 00:32:01,000
efectivamente este main,

773
00:32:07,000 --> 00:32:08,000
pues le meto el código

774
00:32:08,000 --> 00:32:09,000
veintitrés

775
00:32:10,000 --> 00:32:11,000
descripción

776
00:32:14,000 --> 00:32:15,000
pues se ha creado

777
00:32:15,000 --> 00:32:16,000
el objeto pedido

778
00:32:16,000 --> 00:32:17,000
y efectivamente

779
00:32:17,000 --> 00:32:18,000
se han,

780
00:32:18,000 --> 00:32:19,000
sus propiedades

781
00:32:19,000 --> 00:32:20,000
se han inicializado

782
00:32:20,000 --> 00:32:21,000
con esto

783
00:32:21,000 --> 00:32:22,000
por primera vez

784
00:32:22,000 --> 00:32:23,000
a través del constructor.

785
00:32:24,000 --> 00:32:25,000
Vale,

786
00:32:25,000 --> 00:32:26,000
a través del constructor

787
00:32:26,000 --> 00:32:27,000
ya le he pasado

788
00:32:27,000 --> 00:32:28,000
estos valores,

789
00:32:28,000 --> 00:32:29,000
los ha usado

790
00:32:29,000 --> 00:32:30,000
el constructor

791
00:32:30,000 --> 00:32:31,000
para inicializar

792
00:32:31,000 --> 00:32:32,000
las propiedades

793
00:32:33,000 --> 00:32:34,000
y efectivamente

794
00:32:34,000 --> 00:32:35,000
a partir de este punto

795
00:32:35,000 --> 00:32:36,000
el objeto ya tiene

796
00:32:36,000 --> 00:32:37,000
esas propiedades.

797
00:32:37,000 --> 00:32:38,000
¿Qué daño

798
00:32:38,000 --> 00:32:39,000
se las quiero cambiar

799
00:32:39,000 --> 00:32:40,000
a otras?

800
00:32:40,000 --> 00:32:41,000
Pues hago yo,

801
00:32:41,000 --> 00:32:42,000
yo ahora hago

802
00:32:42,000 --> 00:32:43,000
lo que me dé la gana.

803
00:32:43,000 --> 00:32:44,000
¿Que quiero cambiar

804
00:32:44,000 --> 00:32:45,000
el código

805
00:32:45,000 --> 00:32:46,000
y ponerle ahora dieciséis?

806
00:32:46,000 --> 00:32:47,000
Pues lo que yo quiera.

807
00:32:47,000 --> 00:32:48,000
¿Que quiero modificar

808
00:32:48,000 --> 00:32:49,000
la descripción?

809
00:32:49,000 --> 00:32:50,000
Lo que yo quiera.

810
00:32:50,000 --> 00:32:51,000
¿Vale?

811
00:32:51,000 --> 00:32:52,000
Bueno,

812
00:32:52,000 --> 00:32:53,000
pues esto es

813
00:32:53,000 --> 00:32:54,000
el concepto

814
00:32:54,000 --> 00:32:55,000
de método constructor.

815
00:32:55,000 --> 00:32:56,000
Aparece siempre

816
00:32:56,000 --> 00:32:57,000
cuando uno declara

817
00:32:57,000 --> 00:32:58,000
una clase entidad

818
00:32:58,000 --> 00:32:59,000
las que yo estoy llamando

819
00:32:59,000 --> 00:33:00,000
clases entidad

820
00:33:00,000 --> 00:33:01,000
son las clases

821
00:33:01,000 --> 00:33:02,000
que su significado es

822
00:33:02,000 --> 00:33:03,000
representar

823
00:33:03,000 --> 00:33:04,000
un concepto

824
00:33:04,000 --> 00:33:05,000
de mi aplicación.

825
00:33:05,000 --> 00:33:06,000
Representar pedido,

826
00:33:06,000 --> 00:33:07,000
representar cliente,

827
00:33:07,000 --> 00:33:08,000
representar mueble.

828
00:33:08,000 --> 00:33:09,000
La clase main

829
00:33:09,000 --> 00:33:10,000
no la llamaría

830
00:33:10,000 --> 00:33:11,000
clase entidad

831
00:33:11,000 --> 00:33:12,000
porque esta clase

832
00:33:12,000 --> 00:33:13,000
no representa

833
00:33:13,000 --> 00:33:14,000
ningún objeto

834
00:33:14,000 --> 00:33:15,000
de mi aplicación.

835
00:33:15,000 --> 00:33:16,000
Esta clase

836
00:33:16,000 --> 00:33:17,000
es una clase

837
00:33:17,000 --> 00:33:18,000
que tiene

838
00:33:18,000 --> 00:33:19,000
ese método

839
00:33:19,000 --> 00:33:20,000
especial

840
00:33:20,000 --> 00:33:21,000
que es

841
00:33:21,000 --> 00:33:22,000
el método

842
00:33:22,000 --> 00:33:23,000
constructor

843
00:33:23,000 --> 00:33:24,000
es una clase

844
00:33:24,000 --> 00:33:25,000
que tiene

845
00:33:25,000 --> 00:33:26,000
ese método

846
00:33:26,000 --> 00:33:27,000
especial

847
00:33:27,000 --> 00:33:28,000
que es el punto

848
00:33:28,000 --> 00:33:29,000
de arranque.

849
00:33:29,000 --> 00:33:30,000
A esa no la llamaría

850
00:33:30,000 --> 00:33:31,000
clase entidad

851
00:33:31,000 --> 00:33:32,000
pero es una clase

852
00:33:32,000 --> 00:33:33,000
también.

853
00:33:33,000 --> 00:33:34,000
No tiene propiedades,

854
00:33:34,000 --> 00:33:35,000
no tiene nada

855
00:33:35,000 --> 00:33:36,000
pero es una clase.

856
00:33:36,000 --> 00:33:37,000
Bueno,

857
00:33:37,000 --> 00:33:38,000
vale,

858
00:33:38,000 --> 00:33:39,000
constructores

859
00:33:39,000 --> 00:33:40,000
puede haber

860
00:33:40,000 --> 00:33:41,000
más de uno.

861
00:33:41,000 --> 00:33:42,000
Puede haber

862
00:33:42,000 --> 00:33:43,000
más de uno.

863
00:33:43,000 --> 00:33:44,000
Es decir,

864
00:33:44,000 --> 00:33:45,000
yo puedo hacer

865
00:33:45,000 --> 00:33:46,000
otro constructor

866
00:33:46,000 --> 00:33:47,000
si me da la gana

867
00:33:47,000 --> 00:33:48,000
pero claro,

868
00:33:48,000 --> 00:33:49,000
como todos

869
00:33:49,000 --> 00:33:50,000
se tienen que llamar

870
00:33:50,000 --> 00:33:51,000
igual

871
00:33:51,000 --> 00:33:52,000
porque eso es obligatorio

872
00:33:53,000 --> 00:33:54,000
y todos tienen que devolver

873
00:33:54,000 --> 00:33:55,000
lo mismo

874
00:33:55,000 --> 00:33:56,000
que es

875
00:33:56,000 --> 00:33:57,000
nada,

876
00:33:57,000 --> 00:33:58,000
el vacío

877
00:33:58,000 --> 00:33:59,000
¿Qué me queda a mí

878
00:33:59,000 --> 00:34:00,000
para distinguir

879
00:34:00,000 --> 00:34:01,000
uno de otro?

880
00:34:01,000 --> 00:34:02,000
¿Qué me queda?

881
00:34:03,000 --> 00:34:04,000
La lista de parámetros.

882
00:34:05,000 --> 00:34:06,000
Lo único que me queda a mí

883
00:34:06,000 --> 00:34:07,000
para poder distinguir

884
00:34:07,000 --> 00:34:08,000
uno de otro

885
00:34:08,000 --> 00:34:09,000
es la lista de parámetros

886
00:34:09,000 --> 00:34:10,000
porque el nombre

887
00:34:10,000 --> 00:34:11,000
tiene que ser igual.

888
00:34:11,000 --> 00:34:12,000
Lo que hay delante

889
00:34:12,000 --> 00:34:13,000
tiene que ser igual.

890
00:34:13,000 --> 00:34:14,000
Entonces,

891
00:34:14,000 --> 00:34:15,000
para distinguir

892
00:34:15,000 --> 00:34:16,000
uno de otro

893
00:34:16,000 --> 00:34:17,000
lo único que me falta

894
00:34:17,000 --> 00:34:18,000
es

895
00:34:18,000 --> 00:34:19,000
esta lista de parámetros.

896
00:34:19,000 --> 00:34:20,000
¿Vale?

897
00:34:21,000 --> 00:34:22,000
Pues,

898
00:34:22,000 --> 00:34:23,000
por ejemplo,

899
00:34:23,000 --> 00:34:24,000
aquí tengo otro ya

900
00:34:24,000 --> 00:34:25,000
otro constructor

901
00:34:27,000 --> 00:34:28,000
que me da a mí la gana

902
00:34:28,000 --> 00:34:29,000
que tenga este código

903
00:34:29,000 --> 00:34:30,000
que es nada.

904
00:34:30,000 --> 00:34:31,000
Pues como veis

905
00:34:31,000 --> 00:34:32,000
admite los dos

906
00:34:33,000 --> 00:34:34,000
que son perfectamente

907
00:34:34,000 --> 00:34:35,000
distinguibles.

908
00:34:35,000 --> 00:34:36,000
Este se llamaría

909
00:34:36,000 --> 00:34:37,000
el constructor

910
00:34:37,000 --> 00:34:38,000
sin parámetros

911
00:34:38,000 --> 00:34:39,000
porque no tiene parámetros.

912
00:34:39,000 --> 00:34:40,000
Este es otro

913
00:34:40,000 --> 00:34:41,000
que es distinto

914
00:34:41,000 --> 00:34:42,000
porque tiene parámetros.

915
00:34:43,000 --> 00:34:44,000
¿Vale?

916
00:34:44,000 --> 00:34:45,000
Las cabeceras son distintas.

917
00:34:48,000 --> 00:34:49,000
Entonces,

918
00:34:49,000 --> 00:34:50,000
a la hora de crear el objeto

919
00:34:51,000 --> 00:34:52,000
¿cómo sabe la máquina virtual

920
00:34:52,000 --> 00:34:53,000
a cuál tiene que ir?

921
00:34:54,000 --> 00:34:55,000
¿A uno o a otro?

922
00:34:56,000 --> 00:34:57,000
Pues depende

923
00:34:57,000 --> 00:34:58,000
de cómo lo llame yo.

924
00:34:58,000 --> 00:34:59,000
Si le llamo

925
00:34:59,000 --> 00:35:00,000
sin parámetros

926
00:35:00,000 --> 00:35:01,000
tendrá que ejecutar

927
00:35:01,000 --> 00:35:02,000
el de arriba.

928
00:35:03,000 --> 00:35:04,000
Si le llamo con parámetros

929
00:35:04,000 --> 00:35:05,000
el de abajo.

930
00:35:07,000 --> 00:35:08,000
Por ejemplo,

931
00:35:08,000 --> 00:35:09,000
en el main este

932
00:35:09,000 --> 00:35:10,000
del primer día

933
00:35:10,000 --> 00:35:11,000
que los estuvimos

934
00:35:11,000 --> 00:35:12,000
creando así.

935
00:35:13,000 --> 00:35:14,000
Pues aquí la máquina virtual

936
00:35:14,000 --> 00:35:15,000
no tiene ningún problema.

937
00:35:15,000 --> 00:35:16,000
Sabe que aparte

938
00:35:16,000 --> 00:35:17,000
de crear el objeto

939
00:35:17,000 --> 00:35:18,000
tiene que llamar

940
00:35:18,000 --> 00:35:19,000
al constructor

941
00:35:19,000 --> 00:35:20,000
que no necesita parámetros

942
00:35:21,000 --> 00:35:22,000
porque no se los estoy pasando

943
00:35:22,000 --> 00:35:23,000
que no necesita.

944
00:35:23,000 --> 00:35:24,000
¿Vale?

945
00:35:24,000 --> 00:35:25,000
Pues lo llama

946
00:35:25,000 --> 00:35:26,000
a este

947
00:35:26,000 --> 00:35:27,000
que lo único que hará

948
00:35:27,000 --> 00:35:28,000
será es mostrar este mensaje.

949
00:35:29,000 --> 00:35:30,000
Sin embargo aquí

950
00:35:30,000 --> 00:35:31,000
aquí yo estoy llamando

951
00:35:31,000 --> 00:35:32,000
al new pedido

952
00:35:32,000 --> 00:35:33,000
de esta otra manera.

953
00:35:34,000 --> 00:35:35,000
Entonces,

954
00:35:35,000 --> 00:35:36,000
además de crear el espacio

955
00:35:36,000 --> 00:35:37,000
sabe que tiene que llamar

956
00:35:37,000 --> 00:35:38,000
al constructor

957
00:35:38,000 --> 00:35:39,000
con tres parámetros.

958
00:35:40,000 --> 00:35:41,000
Pues entonces

959
00:35:41,000 --> 00:35:42,000
tiene que llamar a este.

960
00:35:43,000 --> 00:35:44,000
Luego no hay confusión

961
00:35:44,000 --> 00:35:45,000
cuando hacemos

962
00:35:45,000 --> 00:35:46,000
un new pedido

963
00:35:46,000 --> 00:35:47,000
a cuál de los métodos

964
00:35:47,000 --> 00:35:48,000
tiene que ir.

965
00:35:48,000 --> 00:35:49,000
¿A cuál de los constructores?

966
00:35:49,000 --> 00:35:50,000
Tiene que ir

967
00:35:50,000 --> 00:35:51,000
a aquel

968
00:35:51,000 --> 00:35:52,000
al que le encajen

969
00:35:52,000 --> 00:35:53,000
sus parámetros

970
00:35:53,000 --> 00:35:54,000
con el que yo le echo

971
00:35:54,000 --> 00:35:55,000
en la llamada.

972
00:35:57,000 --> 00:35:58,000
Y así como si le pongo

973
00:35:58,000 --> 00:35:59,000
27 constructores

974
00:35:59,000 --> 00:36:00,000
pero eso sí

975
00:36:00,000 --> 00:36:01,000
se tienen que distinguir

976
00:36:01,000 --> 00:36:02,000
en la lista de parámetros.

977
00:36:04,000 --> 00:36:05,000
No puede ser igual.

978
00:36:05,000 --> 00:36:06,000
Yo no puedo hacer

979
00:36:06,000 --> 00:36:07,000
otro constructor

980
00:36:08,000 --> 00:36:09,000
que reciba un entero

981
00:36:09,000 --> 00:36:10,000
un string

982
00:36:10,000 --> 00:36:11,000
y un array.

983
00:36:11,000 --> 00:36:12,000
No puedo

984
00:36:12,000 --> 00:36:13,000
porque sería igual.

985
00:36:13,000 --> 00:36:14,000
Pero puedo hacer

986
00:36:14,000 --> 00:36:15,000
otro constructor

987
00:36:16,000 --> 00:36:17,000
que reciba a lo mejor

988
00:36:17,000 --> 00:36:18,000
solamente el código

989
00:36:18,000 --> 00:36:19,000
por ejemplo.

990
00:36:19,000 --> 00:36:20,000
Porque me da a mí

991
00:36:20,000 --> 00:36:21,000
la gana hacer

992
00:36:21,000 --> 00:36:22,000
abrir la posibilidad

993
00:36:23,000 --> 00:36:24,000
de crear objetos

994
00:36:24,000 --> 00:36:25,000
sólo con el código

995
00:36:25,000 --> 00:36:26,000
y la descripción

996
00:36:26,000 --> 00:36:27,000
ya la pondré luego.

997
00:36:28,000 --> 00:36:29,000
¿Vale?

998
00:36:29,000 --> 00:36:30,000
Este sería otro constructor

999
00:36:30,000 --> 00:36:31,000
porque resulta

1000
00:36:31,000 --> 00:36:32,000
que a mi aplicación

1001
00:36:32,000 --> 00:36:33,000
le interesa

1002
00:36:33,000 --> 00:36:34,000
poder crear pedidos

1003
00:36:34,000 --> 00:36:35,000
pero por ahora

1004
00:36:35,000 --> 00:36:36,000
sólo con el código.

1005
00:36:36,000 --> 00:36:37,000
La descripción ya vendrá.

1006
00:36:37,000 --> 00:36:38,000
Bueno,

1007
00:36:38,000 --> 00:36:39,000
pues me hago otro

1008
00:36:39,000 --> 00:36:40,000
y no hay ningún problema.

1009
00:36:40,000 --> 00:36:41,000
Es perfectamente

1010
00:36:41,000 --> 00:36:42,000
distinguirlo del de arriba

1011
00:36:42,000 --> 00:36:43,000
porque la lista de parámetros

1012
00:36:43,000 --> 00:36:44,000
es distinta.

1013
00:36:45,000 --> 00:36:46,000
Luego yo ya

1014
00:36:46,000 --> 00:36:47,000
que quiero llamar

1015
00:36:47,000 --> 00:36:49,000
a este constructor

1016
00:36:50,000 --> 00:36:51,000
bueno, pues lo llamaré

1017
00:36:51,000 --> 00:36:52,000
pasándole

1018
00:36:52,000 --> 00:36:53,000
que le pongo aquí un 3.

1019
00:36:55,000 --> 00:36:56,000
Entonces la máquina virtual dirá

1020
00:36:56,000 --> 00:36:57,000
uy, estás llamando

1021
00:36:57,000 --> 00:36:58,000
al constructor

1022
00:36:58,000 --> 00:36:59,000
que necesita un entero

1023
00:37:00,000 --> 00:37:01,000
porque me estás pasando un 3.

1024
00:37:01,000 --> 00:37:02,000
Se va aquí y dice

1025
00:37:02,000 --> 00:37:03,000
a ver,

1026
00:37:03,000 --> 00:37:04,000
¿tengo algún constructor

1027
00:37:04,000 --> 00:37:05,000
que necesite un entero?

1028
00:37:05,000 --> 00:37:06,000
Sí, tengo uno, este.

1029
00:37:06,000 --> 00:37:07,000
Pues llamo a este.

1030
00:37:08,000 --> 00:37:09,000
Que yo lo llamo así

1031
00:37:09,000 --> 00:37:10,000
sin nada.

1032
00:37:10,000 --> 00:37:11,000
Dice, a ver,

1033
00:37:11,000 --> 00:37:12,000
estás llamando

1034
00:37:12,000 --> 00:37:13,000
al constructor

1035
00:37:13,000 --> 00:37:14,000
que no recibe nada.

1036
00:37:14,000 --> 00:37:15,000
¿Tengo algún constructor

1037
00:37:15,000 --> 00:37:16,000
que no reciba nada?

1038
00:37:16,000 --> 00:37:17,000
Sí, este.

1039
00:37:17,000 --> 00:37:18,000
Vale, pues llamo a este.

1040
00:37:18,000 --> 00:37:19,000
Ahora hago esta llamada.

1041
00:37:19,000 --> 00:37:20,000
Uy, estás llamando

1042
00:37:20,000 --> 00:37:21,000
a un constructor

1043
00:37:21,000 --> 00:37:22,000
que recibe un entero,

1044
00:37:23,000 --> 00:37:24,000
un string

1045
00:37:24,000 --> 00:37:25,000
y un objeto

1046
00:37:25,000 --> 00:37:26,000
porque nulo es un objeto.

1047
00:37:26,000 --> 00:37:27,000
¿Tengo yo algún

1048
00:37:27,000 --> 00:37:28,000
constructor que reciba eso?

1049
00:37:29,000 --> 00:37:30,000
Uy, pues sí.

1050
00:37:30,000 --> 00:37:31,000
Tengo este que recibe

1051
00:37:31,000 --> 00:37:32,000
un entero,

1052
00:37:33,000 --> 00:37:34,000
una cadena

1053
00:37:34,000 --> 00:37:35,000
y un array

1054
00:37:35,000 --> 00:37:36,000
que es un objeto.

1055
00:37:36,000 --> 00:37:37,000
Pues me encaja.

1056
00:37:37,000 --> 00:37:38,000
Vale, pues me encaja.

1057
00:37:39,000 --> 00:37:40,000
Que yo trato

1058
00:37:40,000 --> 00:37:41,000
de crear un objeto

1059
00:37:41,000 --> 00:37:42,000
pasándole

1060
00:37:43,000 --> 00:37:44,000
por ejemplo

1061
00:37:44,000 --> 00:37:45,000
un entero

1062
00:37:47,000 --> 00:37:48,000
y una cadena.

1063
00:37:49,000 --> 00:37:50,000
Automáticamente

1064
00:37:50,000 --> 00:37:51,000
se pone rojo.

1065
00:37:51,000 --> 00:37:52,000
Me dice, a ver,

1066
00:37:52,000 --> 00:37:54,000
¿tengo yo algún constructor

1067
00:37:54,000 --> 00:37:55,000
que necesite

1068
00:37:56,000 --> 00:37:57,000
un entero

1069
00:37:57,000 --> 00:37:58,000
y un string?

1070
00:37:59,000 --> 00:38:00,000
Él se pone a mirar

1071
00:38:00,000 --> 00:38:01,000
en la lista y dice no

1072
00:38:01,000 --> 00:38:04,000
porque este no recibe nada.

1073
00:38:05,000 --> 00:38:06,000
Este un entero,

1074
00:38:06,000 --> 00:38:07,000
un string

1075
00:38:07,000 --> 00:38:08,000
y una cadena

1076
00:38:08,000 --> 00:38:09,000
y este solo un entero.

1077
00:38:09,000 --> 00:38:10,000
Luego no hay ninguno

1078
00:38:10,000 --> 00:38:11,000
que encaje con esto.

1079
00:38:11,000 --> 00:38:12,000
Luego dice, no,

1080
00:38:12,000 --> 00:38:13,000
esa llamada no la puedes hacer

1081
00:38:13,000 --> 00:38:14,000
porque no hay ningún

1082
00:38:14,000 --> 00:38:15,000
método constructor

1083
00:38:15,000 --> 00:38:16,000
que me encaje con esto.

1084
00:38:17,000 --> 00:38:18,000
Que me da mi la gana

1085
00:38:18,000 --> 00:38:19,000
hacerlo

1086
00:38:19,000 --> 00:38:20,000
porque yo quiero

1087
00:38:20,000 --> 00:38:21,000
un constructor

1088
00:38:21,000 --> 00:38:22,000
que reciba solamente

1089
00:38:22,000 --> 00:38:23,000
el código

1090
00:38:24,000 --> 00:38:25,000
y la descripción.

1091
00:38:36,000 --> 00:38:37,000
Que me da mi la gana

1092
00:38:37,000 --> 00:38:38,000
hacer un

1093
00:38:39,000 --> 00:38:40,000
así,

1094
00:38:40,000 --> 00:38:41,000
así,

1095
00:38:41,000 --> 00:38:42,000
este.

1096
00:38:43,000 --> 00:38:44,000
Ala,

1097
00:38:44,000 --> 00:38:45,000
ya tengo otro constructor

1098
00:38:45,000 --> 00:38:46,000
que se distingue

1099
00:38:46,000 --> 00:38:47,000
de los demás

1100
00:38:47,000 --> 00:38:48,000
porque recibe una lista

1101
00:38:48,000 --> 00:38:49,000
de parámetros distinta.

1102
00:38:49,000 --> 00:38:50,000
Ah, pues entonces

1103
00:38:50,000 --> 00:38:51,000
ahora ya sí que se me ha

1104
00:38:51,000 --> 00:38:52,000
quitado este error.

1105
00:38:52,000 --> 00:38:53,000
Este.

1106
00:38:53,000 --> 00:38:54,000
Porque ahora ya

1107
00:38:54,000 --> 00:38:55,000
la máquina virtual

1108
00:38:55,000 --> 00:38:56,000
ya ha encontrado

1109
00:38:56,000 --> 00:38:57,000
que hay un constructor

1110
00:38:57,000 --> 00:38:58,000
que espera

1111
00:38:58,000 --> 00:38:59,000
un entero y un string.

1112
00:38:59,000 --> 00:39:00,000
Ya lo ha encontrado.

1113
00:39:00,000 --> 00:39:01,000
Entonces ya me quita

1114
00:39:01,000 --> 00:39:02,000
este error.

1115
00:39:02,000 --> 00:39:03,000
¿Vale?

1116
00:39:04,000 --> 00:39:05,000
Bueno,

1117
00:39:06,000 --> 00:39:07,000
pues esto de poner

1118
00:39:07,000 --> 00:39:08,000
varios constructores

1119
00:39:08,000 --> 00:39:09,000
es lo que se llama

1120
00:39:09,000 --> 00:39:10,000
hacer sobrecarga

1121
00:39:10,000 --> 00:39:11,000
de constructores

1122
00:39:18,000 --> 00:39:19,000
que se puede hacer

1123
00:39:19,000 --> 00:39:20,000
en el resto de métodos.

1124
00:39:20,000 --> 00:39:21,000
Pero eso ya lo veremos.

1125
00:39:21,000 --> 00:39:24,000
Tenemos cuatro constructores

1126
00:39:26,000 --> 00:39:27,000
que se distinguen

1127
00:39:29,000 --> 00:39:30,000
por

1128
00:39:30,000 --> 00:39:31,000
la lista de parámetros.

1129
00:39:35,000 --> 00:39:36,000
Y esto es lo que se llama

1130
00:39:36,000 --> 00:39:37,000
hacer sobrecarga

1131
00:39:37,000 --> 00:39:38,000
de constructores.

1132
00:39:45,000 --> 00:39:46,000
¿Vale?

1133
00:39:46,000 --> 00:39:47,000
Bueno, pues los constructores

1134
00:39:47,000 --> 00:39:48,000
siempre aparecen

1135
00:39:48,000 --> 00:39:49,000
de una clase

1136
00:39:49,000 --> 00:39:50,000
porque cuando uno

1137
00:39:50,000 --> 00:39:51,000
crea un objeto

1138
00:39:51,000 --> 00:39:52,000
quiere ya darle valores.

1139
00:39:54,000 --> 00:39:55,000
Y es que hay veces

1140
00:39:55,000 --> 00:39:56,000
que es que incluso

1141
00:39:56,000 --> 00:39:57,000
se los tiene que dar así.

1142
00:39:57,000 --> 00:39:58,000
Porque esto que yo he hecho

1143
00:39:58,000 --> 00:39:59,000
tan alegremente

1144
00:39:59,000 --> 00:40:00,000
de acceder

1145
00:40:00,000 --> 00:40:01,000
con

1146
00:40:01,000 --> 00:40:02,000
pedido gomas

1147
00:40:02,000 --> 00:40:03,000
punto código

1148
00:40:03,000 --> 00:40:04,000
pedido gomas

1149
00:40:04,000 --> 00:40:05,000
pues no se suele hacer así.

1150
00:40:05,000 --> 00:40:06,000
¿Vale?

1151
00:40:06,000 --> 00:40:07,000
Porque las propiedades

1152
00:40:07,000 --> 00:40:08,000
suelen ser privadas

1153
00:40:08,000 --> 00:40:09,000
hay paquetes, etcétera

1154
00:40:09,000 --> 00:40:10,000
que ya veremos a la vuelta.

1155
00:40:11,000 --> 00:40:12,000
Entonces no se suele hacer así

1156
00:40:12,000 --> 00:40:13,000
porque me habrán puesto

1157
00:40:13,000 --> 00:40:14,000
un privado y no podré.

1158
00:40:14,000 --> 00:40:15,000
Pero eso ya lo

1159
00:40:15,000 --> 00:40:16,000
veremos después.

1160
00:40:16,000 --> 00:40:17,000
¿Vale?

1161
00:40:21,000 --> 00:40:22,000
Vale, pues nada.

1162
00:40:23,000 --> 00:40:24,000
¿Alguna duda

1163
00:40:24,000 --> 00:40:25,000
sobre constructores

1164
00:40:25,000 --> 00:40:26,000
para lo que valen?

1165
00:40:30,000 --> 00:40:31,000
Bueno,

1166
00:40:31,000 --> 00:40:32,000
pues no nos da tiempo

1167
00:40:32,000 --> 00:40:33,000
a nada de

1168
00:40:36,000 --> 00:40:37,000
de bueno

1169
00:40:37,000 --> 00:40:38,000
a ver

1170
00:40:39,000 --> 00:40:40,000
en dos minutos

1171
00:40:40,000 --> 00:40:41,000
algo rápido

1172
00:40:41,000 --> 00:40:42,000
para que dejarlo ahí

1173
00:40:42,000 --> 00:40:43,000
planteado

1174
00:40:43,000 --> 00:40:44,000
por si luego podéis

1175
00:40:44,000 --> 00:40:45,000
con los ejercicios

1176
00:40:45,000 --> 00:40:46,000
practicarlo

1177
00:40:46,000 --> 00:40:47,000
y todo eso.

1178
00:40:48,000 --> 00:40:49,000
A ver.

1179
00:40:52,000 --> 00:40:53,000
Vale, pues

1180
00:40:53,000 --> 00:40:54,000
sobre clases

1181
00:40:54,000 --> 00:40:55,000
un poquito más

1182
00:40:55,000 --> 00:40:56,000
que no digo nada nuevo

1183
00:40:56,000 --> 00:40:57,000
simplemente generalizo.

1184
00:40:59,000 --> 00:41:00,000
Vale, vamos a imaginar

1185
00:41:00,000 --> 00:41:01,000
de esta aplicación

1186
00:41:01,000 --> 00:41:02,000
la vamos a ampliar.

1187
00:41:03,000 --> 00:41:04,000
Esta aplicación

1188
00:41:04,000 --> 00:41:05,000
era para gestionar

1189
00:41:05,000 --> 00:41:06,000
pedidos y clientes.

1190
00:41:07,000 --> 00:41:08,000
Vamos a ampliarla un poco.

1191
00:41:09,000 --> 00:41:10,000
Entonces para ampliarla

1192
00:41:11,000 --> 00:41:12,000
lo primero que se nos ocurre es

1193
00:41:12,000 --> 00:41:13,000
oye, pues vamos a

1194
00:41:14,000 --> 00:41:15,000
trabajar también

1195
00:41:15,000 --> 00:41:16,000
con clientes, ¿no?

1196
00:41:16,000 --> 00:41:17,000
Pues hombre, le pegaría

1197
00:41:17,000 --> 00:41:18,000
tener también

1198
00:41:18,000 --> 00:41:19,000
una clase cliente

1199
00:41:19,000 --> 00:41:20,000
que tenga las propiedades

1200
00:41:20,000 --> 00:41:21,000
de los clientes.

1201
00:41:22,000 --> 00:41:23,000
Porque

1202
00:41:23,000 --> 00:41:24,000
uno diría

1203
00:41:24,000 --> 00:41:25,000
vamos a ver

1204
00:41:25,000 --> 00:41:26,000
de mi cliente

1205
00:41:26,000 --> 00:41:27,000
me basta con el nombre

1206
00:41:27,000 --> 00:41:28,000
porque si me basta

1207
00:41:28,000 --> 00:41:29,000
con el nombre

1208
00:41:29,000 --> 00:41:30,000
no me hace falta

1209
00:41:30,000 --> 00:41:31,000
una clase cliente

1210
00:41:31,000 --> 00:41:32,000
porque

1211
00:41:32,000 --> 00:41:33,000
string

1212
00:41:33,000 --> 00:41:34,000
sirve para guardar un nombre

1213
00:41:34,000 --> 00:41:35,000
y entonces

1214
00:41:35,000 --> 00:41:36,000
con una propiedad string

1215
00:41:36,000 --> 00:41:37,000
me valdría para el cliente, ¿no?

1216
00:41:37,000 --> 00:41:38,000
Una propiedad string

1217
00:41:38,000 --> 00:41:39,000
me valdría

1218
00:41:39,000 --> 00:41:40,000
porque tiene su nombre.

1219
00:41:40,000 --> 00:41:41,000
Pero normal

1220
00:41:41,000 --> 00:41:42,000
es que los objetos

1221
00:41:42,000 --> 00:41:43,000
de mi aplicación

1222
00:41:43,000 --> 00:41:44,000
necesiten más cosas

1223
00:41:44,000 --> 00:41:45,000
para caracterizarse.

1224
00:41:46,000 --> 00:41:47,000
Entonces uno después

1225
00:41:47,000 --> 00:41:48,000
de analizar su aplicación

1226
00:41:48,000 --> 00:41:49,000
decide

1227
00:41:49,000 --> 00:41:50,000
que nombre no

1228
00:41:50,000 --> 00:41:51,000
de los clientes

1229
00:41:51,000 --> 00:41:52,000
le interesa

1230
00:41:52,000 --> 00:41:53,000
su DNI

1231
00:41:53,000 --> 00:41:54,000
su dirección

1232
00:41:54,000 --> 00:41:55,000
su teléfono

1233
00:41:55,000 --> 00:41:56,000
hombre, le interesan

1234
00:41:56,000 --> 00:41:57,000
varias cosas.

1235
00:41:57,000 --> 00:41:58,000
Pues entonces

1236
00:41:58,000 --> 00:41:59,000
tiene que haber una clase.

1237
00:41:59,000 --> 00:42:00,000
¿Vale?

1238
00:42:00,000 --> 00:42:01,000
Tres minutos

1239
00:42:01,000 --> 00:42:02,000
y nos vamos

1240
00:42:02,000 --> 00:42:03,000
o nos quedamos

1241
00:42:03,000 --> 00:42:04,000
¿Vale?

1242
00:42:04,000 --> 00:42:05,000
Entonces

1243
00:42:05,000 --> 00:42:06,000
vamos a hacer

1244
00:42:06,000 --> 00:42:07,000
una clase cliente.

1245
00:42:09,000 --> 00:42:10,000
A ver

1246
00:42:10,000 --> 00:42:11,000
lo que he dicho

1247
00:42:11,000 --> 00:42:12,000
al principio de la clase

1248
00:42:12,000 --> 00:42:13,000
que no me habéis hecho

1249
00:42:13,000 --> 00:42:14,000
ni caso

1250
00:42:14,000 --> 00:42:15,000
es que yo tengo

1251
00:42:15,000 --> 00:42:16,000
lectura de proyectos

1252
00:42:16,000 --> 00:42:17,000
ahora hasta las dos y media.

1253
00:42:17,000 --> 00:42:18,000
Entonces

1254
00:42:18,000 --> 00:42:19,000
os podéis quedar

1255
00:42:19,000 --> 00:42:20,000
aquí

1256
00:42:20,000 --> 00:42:21,000
haciendo ejercicios

1257
00:42:21,000 --> 00:42:22,000
de esto

1258
00:42:23,000 --> 00:42:24,000
o

1259
00:42:24,000 --> 00:42:25,000
si os vais a casa

1260
00:42:25,000 --> 00:42:26,000
pues no pasa nada.

1261
00:42:26,000 --> 00:42:27,000
No vais a casa.

1262
00:42:27,000 --> 00:42:28,000
¿Vale?

1263
00:42:31,000 --> 00:42:32,000
Espera

1264
00:42:32,000 --> 00:42:33,000
déjame que termine esto

1265
00:42:33,000 --> 00:42:34,000
¿Vale?

1266
00:42:34,000 --> 00:42:35,000
Y seguidme haciendo caso

1267
00:42:35,000 --> 00:42:36,000
bueno, si es que me lo

1268
00:42:36,000 --> 00:42:37,000
estabais haciendo.

1269
00:42:38,000 --> 00:42:39,000
Venga

1270
00:42:40,000 --> 00:42:41,000
cinco minutos

1271
00:42:44,000 --> 00:42:45,000
A ver

1272
00:42:45,000 --> 00:42:46,000
¿De qué te ríes?

1273
00:42:46,000 --> 00:42:47,000
Compártelo con nosotros

1274
00:42:48,000 --> 00:42:49,000
¿Por qué no?

1275
00:42:49,000 --> 00:42:50,000
¿De qué tienes miedo?

1276
00:42:51,000 --> 00:42:52,000
Pero igual a mí

1277
00:42:52,000 --> 00:42:53,000
sí me interesa.

1278
00:42:57,000 --> 00:42:58,000
¿Eh?

1279
00:42:59,000 --> 00:43:00,000
Bueno, vale.

1280
00:43:02,000 --> 00:43:03,000
Silencio

1281
00:43:04,000 --> 00:43:05,000
Bueno, vamos a seguir

1282
00:43:05,000 --> 00:43:06,000
ampliando nuestra aplicación.

1283
00:43:06,000 --> 00:43:07,000
Si nuestra aplicación

1284
00:43:07,000 --> 00:43:08,000
va a trabajar con pedidos

1285
00:43:08,000 --> 00:43:09,000
y va a trabajar con clientes

1286
00:43:10,000 --> 00:43:11,000
y los clientes

1287
00:43:11,000 --> 00:43:12,000
se quieren caracterizar

1288
00:43:12,000 --> 00:43:13,000
por diferentes cosas

1289
00:43:13,000 --> 00:43:14,000
una clase cliente

1290
00:43:14,000 --> 00:43:15,000
va a ser imprescindible.

1291
00:43:16,000 --> 00:43:17,000
¿Verdad que sí?

1292
00:43:17,000 --> 00:43:18,000
¿Vosotros dos?

1293
00:43:18,000 --> 00:43:19,000
Vamos a hacer

1294
00:43:19,000 --> 00:43:20,000
una clase cliente más

1295
00:43:20,000 --> 00:43:21,000
y la seguimos ampliando.

1296
00:43:23,000 --> 00:43:24,000
Venga

1297
00:43:24,000 --> 00:43:25,000
clase cliente

1298
00:43:30,000 --> 00:43:31,000
Vale

1299
00:43:32,000 --> 00:43:33,000
Venga

1300
00:43:33,000 --> 00:43:34,000
pues la clase cliente

1301
00:43:35,000 --> 00:43:36,000
Ahora

1302
00:43:36,000 --> 00:43:37,000
habría que plantearse

1303
00:43:37,000 --> 00:43:38,000
¿Por qué queremos

1304
00:43:38,000 --> 00:43:39,000
que se caracterice el cliente?

1305
00:43:39,000 --> 00:43:40,000
Venga

1306
00:43:40,000 --> 00:43:41,000
pues vamos a decirle

1307
00:43:41,000 --> 00:43:42,000
que se caracterice

1308
00:43:43,000 --> 00:43:44,000
por su DNI

1309
00:43:44,000 --> 00:43:45,000
su nombre

1310
00:43:46,000 --> 00:43:47,000
y por ejemplo

1311
00:43:48,000 --> 00:43:49,000
cada cliente

1312
00:43:49,000 --> 00:43:50,000
puede haber hecho

1313
00:43:50,000 --> 00:43:51,000
un pedido

1314
00:43:51,000 --> 00:43:52,000
y solo uno.

1315
00:43:52,000 --> 00:43:53,000
Silencio

1316
00:43:53,000 --> 00:43:54,000
¿Vale?

1317
00:43:55,000 --> 00:43:56,000
Entonces

1318
00:43:57,000 --> 00:43:58,000
después de analizar

1319
00:43:58,000 --> 00:43:59,000
nuestra aplicación

1320
00:43:59,000 --> 00:44:00,000
porque todo esto

1321
00:44:00,000 --> 00:44:01,000
se hace mucho antes

1322
00:44:01,000 --> 00:44:02,000
de ponerse a teclear

1323
00:44:02,000 --> 00:44:03,000
hemos visto que

1324
00:44:03,000 --> 00:44:04,000
vale

1325
00:44:04,000 --> 00:44:05,000
cada cliente

1326
00:44:05,000 --> 00:44:06,000
puede tener un solo pedido

1327
00:44:06,000 --> 00:44:07,000
y cada cliente

1328
00:44:07,000 --> 00:44:08,000
se caracteriza

1329
00:44:08,000 --> 00:44:09,000
por el pedido

1330
00:44:09,000 --> 00:44:10,000
que le ha hecho

1331
00:44:10,000 --> 00:44:11,000
solo uno.

1332
00:44:11,000 --> 00:44:12,000
Igual que se caracteriza

1333
00:44:12,000 --> 00:44:13,000
por su NIF

1334
00:44:13,000 --> 00:44:14,000
por su nombre

1335
00:44:14,000 --> 00:44:15,000
también se caracteriza

1336
00:44:15,000 --> 00:44:16,000
por el pedido

1337
00:44:16,000 --> 00:44:17,000
que ha hecho.

1338
00:44:17,000 --> 00:44:18,000
Luego la pregunta sería

1339
00:44:18,000 --> 00:44:19,000
vale

1340
00:44:19,000 --> 00:44:20,000
pues el pedido

1341
00:44:20,000 --> 00:44:21,000
que ha hecho

1342
00:44:21,000 --> 00:44:22,000
es una propiedad suya

1343
00:44:22,000 --> 00:44:23,000
igual que lo es

1344
00:44:23,000 --> 00:44:24,000
su NIF

1345
00:44:24,000 --> 00:44:25,000
y su nombre

1346
00:44:25,000 --> 00:44:26,000
el pedido

1347
00:44:26,000 --> 00:44:27,000
que ha hecho

1348
00:44:27,000 --> 00:44:28,000
también es una propiedad suya.

1349
00:44:28,000 --> 00:44:29,000
Bueno pues nos falta

1350
00:44:29,000 --> 00:44:30,000
esa tercera propiedad

1351
00:44:31,000 --> 00:44:32,000
¿Eh?

1352
00:44:35,000 --> 00:44:36,000
No, es un solo pedido

1353
00:44:36,000 --> 00:44:37,000
el que va a tener el cliente.

1354
00:44:38,000 --> 00:44:39,000
El cliente se caracteriza

1355
00:44:39,000 --> 00:44:40,000
por su NIF

1356
00:44:40,000 --> 00:44:41,000
su nombre

1357
00:44:41,000 --> 00:44:42,000
y el pedido

1358
00:44:42,000 --> 00:44:43,000
que ha hecho.

1359
00:44:43,000 --> 00:44:44,000
Recordad que tenemos

1360
00:44:44,000 --> 00:44:45,000
una clase pedido

1361
00:44:45,000 --> 00:44:46,000
que a su vez

1362
00:44:46,000 --> 00:44:47,000
tiene dentro

1363
00:44:47,000 --> 00:44:48,000
las propiedades del pedido.

1364
00:44:48,000 --> 00:44:49,000
Vale, pues esas tres propiedades

1365
00:44:49,000 --> 00:44:50,000
NIF

1366
00:44:50,000 --> 00:44:51,000
que es string

1367
00:44:51,000 --> 00:44:52,000
nombre que es string

1368
00:44:52,000 --> 00:44:53,000
y pedido

1369
00:44:53,000 --> 00:44:54,000
llamémosle a pedido

1370
00:44:54,000 --> 00:44:55,000
esa otra propiedad

1371
00:44:56,000 --> 00:44:57,000
esa otra propiedad

1372
00:44:58,000 --> 00:44:59,000
de qué tipo

1373
00:45:00,000 --> 00:45:01,000
veis que tendría sentido

1374
00:45:01,000 --> 00:45:02,000
que fuera

1375
00:45:05,000 --> 00:45:06,000
de tipo

1376
00:45:07,000 --> 00:45:08,000
objeto

1377
00:45:08,000 --> 00:45:09,000
¿Qué tipo de objeto?

1378
00:45:10,000 --> 00:45:11,000
Efectivamente

1379
00:45:11,000 --> 00:45:12,000
vale

1380
00:45:12,000 --> 00:45:13,000
entonces esta propiedad

1381
00:45:14,000 --> 00:45:15,000
sería

1382
00:45:15,000 --> 00:45:16,000
de este tipo

1383
00:45:17,000 --> 00:45:18,000
porque

1384
00:45:18,000 --> 00:45:19,000
recordad

1385
00:45:19,000 --> 00:45:20,000
que ahora ya

1386
00:45:20,000 --> 00:45:21,000
nuestras variables

1387
00:45:21,000 --> 00:45:22,000
pueden ser

1388
00:45:22,000 --> 00:45:23,000
de tipo primitivo

1389
00:45:23,000 --> 00:45:24,000
o también de tipo objeto

1390
00:45:25,000 --> 00:45:26,000
en nuestro main

1391
00:45:26,000 --> 00:45:27,000
de antes

1392
00:45:27,000 --> 00:45:28,000
en nuestro main

1393
00:45:29,000 --> 00:45:30,000
hemos declarado ya

1394
00:45:30,000 --> 00:45:31,000
propiedades

1395
00:45:31,000 --> 00:45:32,000
que son de tipo objeto

1396
00:45:32,000 --> 00:45:33,000
y hemos trabajado

1397
00:45:33,000 --> 00:45:34,000
con ellas

1398
00:45:34,000 --> 00:45:35,000
¿verdad?

1399
00:45:36,000 --> 00:45:37,000
Pues perfectamente

1400
00:45:37,000 --> 00:45:38,000
dentro de cliente

1401
00:45:38,000 --> 00:45:39,000
puede haber una propiedad

1402
00:45:39,000 --> 00:45:40,000
que sea tipo objeto pedido

1403
00:45:42,000 --> 00:45:43,000
y dentro de esta propiedad

1404
00:45:43,000 --> 00:45:44,000
a su vez

1405
00:45:44,000 --> 00:45:45,000
estará el código

1406
00:45:45,000 --> 00:45:46,000
etcétera

1407
00:45:47,000 --> 00:45:48,000
¿vale?

1408
00:45:51,000 --> 00:45:52,000
Entonces por ejemplo

1409
00:45:52,000 --> 00:45:53,000
y ya nos vamos

1410
00:45:55,000 --> 00:45:56,000
imaginaos que vamos

1411
00:45:56,000 --> 00:45:57,000
a hacerle un método

1412
00:45:57,000 --> 00:45:58,000
que es

1413
00:45:58,000 --> 00:45:59,000
mostrar

1414
00:45:59,000 --> 00:46:00,000
descripción

1415
00:46:00,000 --> 00:46:01,000
del pedido

1416
00:46:01,000 --> 00:46:02,000
del cliente

1417
00:46:05,000 --> 00:46:06,000
bueno

1418
00:46:06,000 --> 00:46:07,000
devolver descripción

1419
00:46:07,000 --> 00:46:08,000
más que mostrar

1420
00:46:14,000 --> 00:46:15,000
devolver descripción

1421
00:46:15,000 --> 00:46:16,000
del pedido que ha hecho el cliente

1422
00:46:16,000 --> 00:46:17,000
primera pregunta

1423
00:46:17,000 --> 00:46:18,000
¿qué os hago?

1424
00:46:18,000 --> 00:46:19,000
¿Necesita algún parámetro

1425
00:46:19,000 --> 00:46:20,000
de entrada

1426
00:46:20,000 --> 00:46:21,000
a este método?

1427
00:46:23,000 --> 00:46:24,000
Alejandro

1428
00:46:28,000 --> 00:46:29,000
de descripción

1429
00:46:31,000 --> 00:46:32,000
o sea

1430
00:46:32,000 --> 00:46:33,000
devolver descripción

1431
00:46:33,000 --> 00:46:34,000
del pedido que ha hecho

1432
00:46:34,000 --> 00:46:35,000
y que es una propiedad suya

1433
00:46:35,000 --> 00:46:36,000
que está ahí

1434
00:46:36,000 --> 00:46:37,000
entonces

1435
00:46:37,000 --> 00:46:38,000
¿necesita que yo le pase

1436
00:46:38,000 --> 00:46:39,000
alguna información

1437
00:46:39,000 --> 00:46:40,000
desde fuera

1438
00:46:40,000 --> 00:46:41,000
para acceder

1439
00:46:41,000 --> 00:46:42,000
a la información

1440
00:46:42,000 --> 00:46:43,000
de su pedido?

1441
00:46:45,000 --> 00:46:46,000
bueno ahora mismo

1442
00:46:46,000 --> 00:46:47,000
voy a traer el constructor

1443
00:46:47,000 --> 00:46:48,000
este objeto tiene

1444
00:46:48,000 --> 00:46:49,000
su propiedad pedido

1445
00:46:49,000 --> 00:46:50,000
en if y nombre

1446
00:46:50,000 --> 00:46:51,000
dentro de

1447
00:46:51,000 --> 00:46:52,000
ahora

1448
00:46:52,000 --> 00:46:53,000
para

1449
00:46:53,000 --> 00:46:54,000
devolverme

1450
00:46:54,000 --> 00:46:55,000
hacer un return

1451
00:46:55,000 --> 00:46:56,000
mostrarlo

1452
00:46:57,000 --> 00:46:58,000
su propiedad

1453
00:46:58,000 --> 00:46:59,000
pedido

1454
00:46:59,000 --> 00:47:00,000
¿necesita que yo le pase

1455
00:47:00,000 --> 00:47:01,000
algo de fuera?

1456
00:47:07,000 --> 00:47:08,000
a ver hago la pregunta

1457
00:47:08,000 --> 00:47:09,000
otra vez

1458
00:47:09,000 --> 00:47:10,000
imagínate que este método

1459
00:47:10,000 --> 00:47:11,000
te digo

1460
00:47:11,000 --> 00:47:12,000
mostrar

1461
00:47:12,000 --> 00:47:13,000
el nif

1462
00:47:13,000 --> 00:47:14,000
del cliente

1463
00:47:14,000 --> 00:47:15,000
que llama este método

1464
00:47:15,000 --> 00:47:17,000
¿qué haría este método?

1465
00:47:19,000 --> 00:47:20,000
¿qué pondría yo ahí?

1466
00:47:21,000 --> 00:47:22,000
si tuviera que

1467
00:47:22,000 --> 00:47:23,000
mostrar la descripción

1468
00:47:23,000 --> 00:47:24,000
perdón mostrarle el nif

1469
00:47:26,000 --> 00:47:27,000
¿le habríamos pasado

1470
00:47:27,000 --> 00:47:28,000
algo desde fuera?

1471
00:47:28,000 --> 00:47:29,000
no porque no le hace falta

1472
00:47:29,000 --> 00:47:30,000
el nif ya es una propiedad

1473
00:47:30,000 --> 00:47:31,000
del objeto

1474
00:47:31,000 --> 00:47:32,000
recordad que los métodos

1475
00:47:32,000 --> 00:47:33,000
tienen

1476
00:47:33,000 --> 00:47:34,000
acceso directamente

1477
00:47:34,000 --> 00:47:35,000
a las propiedades

1478
00:47:35,000 --> 00:47:36,000
del objeto

1479
00:47:36,000 --> 00:47:37,000
es lo que explicamos

1480
00:47:37,000 --> 00:47:39,000
ayer a última hora

1481
00:47:39,000 --> 00:47:40,000
cuando corregimos

1482
00:47:40,000 --> 00:47:41,000
el ejercicio

1483
00:47:41,000 --> 00:47:42,000
y lo hicimos todo

1484
00:47:42,000 --> 00:47:43,000
bueno lo que volvimos

1485
00:47:43,000 --> 00:47:44,000
a explicar otra vez

1486
00:47:44,000 --> 00:47:45,000
que un método

1487
00:47:45,000 --> 00:47:46,000
accede directamente

1488
00:47:46,000 --> 00:47:47,000
a las propiedades

1489
00:47:47,000 --> 00:47:48,000
del objeto

1490
00:47:48,000 --> 00:47:49,000
que lo llama

1491
00:47:49,000 --> 00:47:50,000
y la información

1492
00:47:50,000 --> 00:47:51,000
externa

1493
00:47:51,000 --> 00:47:52,000
si le hace falta

1494
00:47:52,000 --> 00:47:53,000
entonces el objeto cliente

1495
00:47:53,000 --> 00:47:54,000
cuando llame a este método

1496
00:47:54,000 --> 00:47:55,000
ese objeto cliente

1497
00:47:56,000 --> 00:47:57,000
ya tiene su pedido dentro

1498
00:48:03,000 --> 00:48:04,000
pero es que está dentro

1499
00:48:04,000 --> 00:48:05,000
entonces

1500
00:48:05,000 --> 00:48:06,000
imagina

1501
00:48:06,000 --> 00:48:07,000
para devolver descripción

1502
00:48:07,000 --> 00:48:08,000
de pedido

1503
00:48:09,000 --> 00:48:10,000
retún

1504
00:48:11,000 --> 00:48:12,000
pedido

1505
00:48:12,000 --> 00:48:13,000
punto

1506
00:48:14,000 --> 00:48:15,000
descripción

1507
00:48:20,000 --> 00:48:21,000
y ya estaría

1508
00:48:21,000 --> 00:48:22,000
es decir

1509
00:48:22,000 --> 00:48:23,000
pedido es una propiedad

1510
00:48:23,000 --> 00:48:24,000
que como es objeto

1511
00:48:24,000 --> 00:48:25,000
dentro de ella

1512
00:48:25,000 --> 00:48:26,000
tiene código

1513
00:48:26,000 --> 00:48:27,000
de descripción

1514
00:48:27,000 --> 00:48:28,000
y array de clientes

1515
00:48:28,000 --> 00:48:29,000
dentro de ella

1516
00:48:29,000 --> 00:48:30,000
todas metidas dentro

1517
00:48:30,000 --> 00:48:31,000
dentro las tiene todas

1518
00:48:32,000 --> 00:48:33,000
entonces yo puedo

1519
00:48:33,000 --> 00:48:34,000
acceder a ella

1520
00:48:34,000 --> 00:48:35,000
como se acceden

1521
00:48:35,000 --> 00:48:36,000
a las propiedades

1522
00:48:36,000 --> 00:48:37,000
de los objetos

1523
00:48:37,000 --> 00:48:38,000
con el punto

1524
00:48:38,000 --> 00:48:39,000
vale

1525
00:48:39,000 --> 00:48:40,000
entonces

1526
00:48:40,000 --> 00:48:41,000
no estoy diciendo

1527
00:48:41,000 --> 00:48:42,000
nada nuevo

1528
00:48:42,000 --> 00:48:43,000
lo que digo

1529
00:48:43,000 --> 00:48:44,000
es que las propiedades

1530
00:48:44,000 --> 00:48:45,000
objeto

1531
00:48:45,000 --> 00:48:46,000
pueden estar dentro

1532
00:48:46,000 --> 00:48:47,000
de otros objetos

1533
00:48:47,000 --> 00:48:48,000
también

1534
00:48:48,000 --> 00:48:49,000
vale

1535
00:48:49,000 --> 00:48:50,000
o sea un objeto

1536
00:48:50,000 --> 00:48:51,000
puede tener una propiedad

1537
00:48:51,000 --> 00:48:52,000
que a su vez es un objeto

1538
00:48:52,000 --> 00:48:53,000
y no pasa nada

1539
00:48:53,000 --> 00:48:54,000
pues tengo otra propiedad

1540
00:48:54,000 --> 00:48:55,000
dentro que a su vez

1541
00:48:55,000 --> 00:48:56,000
es un objeto

1542
00:48:56,000 --> 00:48:57,000
y yo puedo acceder

1543
00:48:57,000 --> 00:48:58,000
a las propiedades

1544
00:48:58,000 --> 00:48:59,000
con el punto

1545
00:48:59,000 --> 00:49:00,000
sin ningún problema

1546
00:49:00,000 --> 00:49:01,000
entonces

1547
00:49:01,000 --> 00:49:02,000
este método

1548
00:49:02,000 --> 00:49:03,000
devolvería la descripción

1549
00:49:03,000 --> 00:49:04,000
del objeto pedido

1550
00:49:05,000 --> 00:49:06,000
como haría

1551
00:49:06,000 --> 00:49:07,000
un constructor

1552
00:49:07,000 --> 00:49:08,000
de este método

1553
00:49:08,000 --> 00:49:09,000
por ejemplo

1554
00:49:09,000 --> 00:49:10,000
pues vamos a crearlo

1555
00:49:10,000 --> 00:49:11,000
automáticamente

1556
00:49:15,000 --> 00:49:16,000
pues mira

1557
00:49:16,000 --> 00:49:17,000
me ha creado automáticamente

1558
00:49:17,000 --> 00:49:18,000
este superloquito

1559
00:49:18,000 --> 00:49:19,000
y este publicloquito

1560
00:49:19,000 --> 00:49:20,000
que no me interesan

1561
00:49:20,000 --> 00:49:21,000
pues mira

1562
00:49:21,000 --> 00:49:22,000
le di

1563
00:49:22,000 --> 00:49:23,000
le pasa directamente

1564
00:49:23,000 --> 00:49:24,000
un if

1565
00:49:24,000 --> 00:49:25,000
un nombre

1566
00:49:25,000 --> 00:49:26,000
y un objeto enterito

1567
00:49:26,000 --> 00:49:27,000
un objeto enterito

1568
00:49:27,000 --> 00:49:28,000
y ese objeto

1569
00:49:28,000 --> 00:49:29,000
lo usa para inicializar

1570
00:49:29,000 --> 00:49:30,000
el objeto pedido

1571
00:49:30,000 --> 00:49:31,000
me da igual

1572
00:49:31,000 --> 00:49:32,000
que la propiedad

1573
00:49:32,000 --> 00:49:33,000
sea objeto

1574
00:49:33,000 --> 00:49:34,000
sea primitiva

1575
00:49:36,000 --> 00:49:37,000
pueden ser

1576
00:49:37,000 --> 00:49:38,000
propiedades

1577
00:49:38,000 --> 00:49:39,000
de la clase

1578
00:49:39,000 --> 00:49:40,000
perfectamente

1579
00:49:40,000 --> 00:49:41,000
con la salvedad

1580
00:49:41,000 --> 00:49:42,000
de que yo aquí

1581
00:49:42,000 --> 00:49:43,000
de esta variable

1582
00:49:43,000 --> 00:49:44,000
accederé a los campos

1583
00:49:44,000 --> 00:49:45,000
claro

1584
00:49:45,000 --> 00:49:46,000
accederé a lo que

1585
00:49:46,000 --> 00:49:47,000
me interese a mí

1586
00:49:47,000 --> 00:49:48,000
accederé a lo que

1587
00:49:48,000 --> 00:49:49,000
me interese

1588
00:49:49,000 --> 00:49:50,000
vale

1589
00:49:50,000 --> 00:49:51,000
bueno y ahora sí

1590
00:49:51,000 --> 00:49:52,000
para matar