1
00:00:00,000 --> 00:00:05,800
Vale, voy a grabar, por lo tanto, si habláis, me estáis autorizando.

2
00:00:05,800 --> 00:00:10,300
Entonces, hemos hablado de clase, hemos dicho que la clase es un molde, ¿vale?

3
00:00:10,300 --> 00:00:12,500
Es un molde para crear objetos.

4
00:00:12,500 --> 00:00:18,400
Una sola clase, que es una abstracción, es una generalización de muchos objetos

5
00:00:18,400 --> 00:00:19,300
que puedo crear.

6
00:00:19,300 --> 00:00:23,300
A partir de una clase puedo crear muchas instancias distintas,

7
00:00:23,300 --> 00:00:28,100
todas tendrán la misma estructura, pero cada uno tendrá valores distintos,

8
00:00:28,400 --> 00:00:36,200
parecidos o mezclados, pues da igual, son entidades separadas que se llamarán objetos, ¿vale?

9
00:00:36,200 --> 00:00:41,800
Cada objeto es una instancia, cada objeto es un trozo de memoria separado, ¿vale?

10
00:00:41,800 --> 00:00:46,400
Los objetos no tienen que ver nada uno con otro, pertenecen todos a la misma clase,

11
00:00:46,400 --> 00:00:50,000
la clase es única, los objetos son instancias distintas.

12
00:00:50,000 --> 00:00:51,800
¿Se entiende esto?

13
00:00:51,800 --> 00:00:52,900
¿Sí?

14
00:00:52,900 --> 00:00:53,800
Vale.

15
00:00:53,800 --> 00:00:56,900
Entonces un objeto es un elemento concreto de la clase definida,

16
00:00:56,900 --> 00:00:59,600
una instancia de la clase, como se suele decir, ¿vale?

17
00:00:59,600 --> 00:01:04,400
Cuando se habla de instancia, es que yo tengo mi molde, he pillado la arena,

18
00:01:04,400 --> 00:01:08,300
la he puesto dentro del molde, la he puesto allí y me ha salido la figurita del elefante.

19
00:01:08,300 --> 00:01:09,300
Vale, fenomenal.

20
00:01:09,300 --> 00:01:10,800
Ahora ya tengo un elefante.

21
00:01:10,800 --> 00:01:16,100
Ahora hago otro elefante al lado, tengo dos elefantes, he usado el mismo molde,

22
00:01:16,100 --> 00:01:18,000
pero tengo dos elefantes distintos.

23
00:01:18,000 --> 00:01:23,700
Y si modifico uno de los dos elefantes, el otro elefante se queda como ha estado antes.

24
00:01:23,700 --> 00:01:25,000
¿Se entiende?

25
00:01:25,200 --> 00:01:29,200
¿Puedes tener dos elefantes iguales?

26
00:01:29,200 --> 00:01:32,700
Como yo puedo llamarme Estefano Quieres, puede haber otra persona que se llame Estefano Quieres.

27
00:01:32,700 --> 00:01:37,700
Ahora, lo natural y lo obvio, estas son dos personas distintas,

28
00:01:37,700 --> 00:01:39,700
si viene otra persona que se llama Estefano Quieres aquí,

29
00:01:39,700 --> 00:01:42,700
posiblemente notáis que somos dos personas distintas,

30
00:01:42,700 --> 00:01:44,700
no hay que decir, de repente son iguales.

31
00:01:44,700 --> 00:01:50,700
Probablemente tú como programador quieres poderlos diferenciar

32
00:01:50,700 --> 00:01:52,700
y es por eso que tenemos los identificadores.

33
00:01:53,400 --> 00:01:58,400
Tú le dices, además de nombre y apellido, le pongo también el DNI

34
00:01:58,400 --> 00:02:03,400
y entonces sé que Estefano Quieres con DNI1 no es el mismo objeto persona

35
00:02:03,400 --> 00:02:05,400
de Estefano Quieres con DNI2.

36
00:02:07,400 --> 00:02:09,400
Pero ahí también no es tan fácil,

37
00:02:09,400 --> 00:02:17,400
porque tú deberías tener un método, una forma concreta y compleja

38
00:02:17,400 --> 00:02:22,400
de verificar que si alguien intenta crear otro Estefano Quieres con DNI1,

39
00:02:23,100 --> 00:02:24,100
debería decir, no, no puedes.

40
00:02:24,100 --> 00:02:26,100
Y esto lo tienes que programar tú,

41
00:02:26,100 --> 00:02:28,100
porque el fichero por sí mismo te permite crear.

42
00:02:28,100 --> 00:02:31,100
O sea, el identificador por sí mismo no es único,

43
00:02:31,100 --> 00:02:34,100
tienes que garantizar tú que sea único.

44
00:02:34,100 --> 00:02:36,100
¿Cómo? Construyendo una base de datos

45
00:02:36,100 --> 00:02:40,100
y todas las personas que crean la guardas en esa base de datos

46
00:02:40,100 --> 00:02:42,100
y cada vez que creas una nueva te vas a esa base de datos

47
00:02:42,100 --> 00:02:44,100
y le dices, ¿existe ya? No, pues entonces lo creo.

48
00:02:44,100 --> 00:02:46,100
¿Existe ya? Sí, pues entonces no lo creo.

49
00:02:46,800 --> 00:02:48,800
¿Sí? O un fichero o un...

50
00:02:51,800 --> 00:02:55,800
En el momento de la ejecución se crean los objetos de la clase

51
00:02:55,800 --> 00:02:57,800
para los cuales hemos escrito código.

52
00:02:57,800 --> 00:03:02,800
Cada objeto tendrá un nombre para poder utilizarlos en nuestro programa.

53
00:03:02,800 --> 00:03:04,800
No un nombre entendido como atributo nombre,

54
00:03:04,800 --> 00:03:06,800
sino un identificador, ¿vale?

55
00:03:06,800 --> 00:03:10,800
En particular, un objeto va a tener una identidad,

56
00:03:10,800 --> 00:03:15,800
es decir, tengo que tener algo para distinguir los dos elefantes que he hecho,

57
00:03:16,500 --> 00:03:19,500
esto lo llamo elefante 1, esto lo llamo elefante 2,

58
00:03:19,500 --> 00:03:22,500
y ahora ya puedo distinguirlos a nivel de programación,

59
00:03:22,500 --> 00:03:25,500
o esta es la variable A y esta es la variable B

60
00:03:25,500 --> 00:03:26,500
y son dos personas distintas,

61
00:03:26,500 --> 00:03:29,500
o esta es una raíz de personas y en cada celda de las personas

62
00:03:29,500 --> 00:03:33,500
pongo una persona distinta,

63
00:03:33,500 --> 00:03:35,500
algo para identificarlos,

64
00:03:35,500 --> 00:03:41,500
los atributos que constituyen el estado de un objeto, ¿vale?

65
00:03:41,500 --> 00:03:45,500
Un objeto tendrá sus 3, 4, 7, 29 variables que lo definen.

66
00:03:46,200 --> 00:03:48,200
Nombre, apellido, edad, ¿vale?

67
00:03:48,200 --> 00:03:54,200
En cada momento yo puedo hacer una foto a este objeto

68
00:03:54,200 --> 00:03:56,200
y definir su estado.

69
00:03:56,200 --> 00:04:01,200
Su estado es los valores en este momento de todos sus atributos.

70
00:04:05,200 --> 00:04:11,200
En este momento hago una foto a la persona Stephano Chiesa,

71
00:04:11,200 --> 00:04:14,200
pues su estado es Stephano Chiesa 18.

72
00:04:16,200 --> 00:04:19,200
Mañana cumple los años, cumple 19,

73
00:04:19,200 --> 00:04:23,200
pues entonces su estado se ha modificado en Stephano Chiesa 19.

74
00:04:26,200 --> 00:04:30,200
Cada objeto tendrá su estado.

75
00:04:30,200 --> 00:04:34,200
Si yo cumplo los años, es que las otras personas cumplen años también.

76
00:04:35,200 --> 00:04:39,200
Solo aquellos objetos que ejecutan él,

77
00:04:39,200 --> 00:04:44,200
hoy es mi cumpleaños, pues lo que harán es pillar edad y sumarle 1.

78
00:04:46,200 --> 00:04:47,200
¿Vale?

79
00:04:47,200 --> 00:04:51,200
Y también tienes unos métodos, que son los métodos definidos por la clase,

80
00:04:51,200 --> 00:04:54,200
que definen el comportamiento de este objeto,

81
00:04:54,200 --> 00:04:56,200
lo que puede hacer este objeto.

82
00:04:56,200 --> 00:05:00,200
Si no tengo un método que me hace cumplir los años,

83
00:05:00,200 --> 00:05:03,200
pues mi objeto no puede cumplir años.

84
00:05:05,200 --> 00:05:07,200
¿Se entiende, no?

85
00:05:07,900 --> 00:05:08,900
¿Ya?

86
00:05:13,900 --> 00:05:14,900
La identidad, ¿vale?

87
00:05:14,900 --> 00:05:16,900
Profundizando cada una de estas cosas.

88
00:05:16,900 --> 00:05:18,900
Pues los objetos se crean en la memoria RAM.

89
00:05:18,900 --> 00:05:20,900
Yo tengo un espacio en la memoria RAM

90
00:05:20,900 --> 00:05:24,900
cuando lanzo el proceso de la Java Virtual Machine,

91
00:05:24,900 --> 00:05:26,900
que es el intérprete de Java,

92
00:05:26,900 --> 00:05:30,900
pues ese se crea un espacio dentro de este espacio de la RAM,

93
00:05:30,900 --> 00:05:32,900
que lo solicita al sistema operativo.

94
00:05:32,900 --> 00:05:34,900
El sistema operativo dice, yo necesito ejecutarme,

95
00:05:35,600 --> 00:05:38,600
tómate estos megas, ¿vale?

96
00:05:38,600 --> 00:05:40,600
Ok, estos son mis megas donde puedo trabajar.

97
00:05:40,600 --> 00:05:44,600
Una parte de este espacio de aquí, que la llamará el heap,

98
00:05:44,600 --> 00:05:45,600
¿vale?

99
00:05:45,600 --> 00:05:47,600
Es la zona donde voy a crear los objetos.

100
00:05:47,600 --> 00:05:49,600
Si mi programa me dice crear objetos,

101
00:05:49,600 --> 00:05:51,600
los voy a meter allí dentro.

102
00:05:51,600 --> 00:05:53,600
Tengo este espacio y voy a crear objetos.

103
00:05:53,600 --> 00:05:55,600
¿Es infinito? No, porque la RAM no es infinita.

104
00:05:55,600 --> 00:05:56,600
¿Vale?

105
00:05:56,600 --> 00:06:00,600
Toda memoria, pues si me pongo aquí con un while true a crear objetos,

106
00:06:00,600 --> 00:06:02,600
antes o después explota.

107
00:06:03,300 --> 00:06:07,300
Su identidad se definirá con un valor de referencia único del objeto.

108
00:06:07,300 --> 00:06:12,300
¿Os acordáis cuando yo os decía, hablando de los arrays,

109
00:06:12,300 --> 00:06:17,300
que cuando yo creaba el array X dentro de la variable X

110
00:06:17,300 --> 00:06:20,300
no había el array por sí mismo,

111
00:06:20,300 --> 00:06:24,300
sino una referencia donde está el array?

112
00:06:24,300 --> 00:06:26,300
Pues es esta referencia.

113
00:06:27,000 --> 00:06:29,000
Cuando yo creo el objeto,

114
00:06:36,000 --> 00:06:40,000
la Java Machine arranca y pilla un trozo de RAM.

115
00:06:40,000 --> 00:06:41,000
¿Vale?

116
00:06:41,000 --> 00:06:43,000
Este es el trozo donde puedo hacer las cosas.

117
00:06:43,000 --> 00:06:46,000
Un trozo de esta RAM será el heap.

118
00:06:54,000 --> 00:06:56,000
Y aquí es donde se crean los objetos.

119
00:06:56,700 --> 00:06:58,700
Me dicen, oye mira, créate un nuevo objeto.

120
00:06:58,700 --> 00:07:00,700
Vale, entonces aquí yo crearé un objeto.

121
00:07:00,700 --> 00:07:04,700
Este es mi objeto persona que tiene dentro su nombre,

122
00:07:04,700 --> 00:07:06,700
su apellido y su edad.

123
00:07:06,700 --> 00:07:07,700
¿Vale?

124
00:07:07,700 --> 00:07:11,700
Si creo un nuevo objeto, tendré un nuevo objeto con nombre,

125
00:07:11,700 --> 00:07:13,700
apellido y edad.

126
00:07:13,700 --> 00:07:14,700
¿Vale?

127
00:07:14,700 --> 00:07:18,700
Y cada uno de estos de aquí será referenciado con una posición

128
00:07:20,700 --> 00:07:21,700
en esta memoria.

129
00:07:21,700 --> 00:07:23,700
Digamos así, no es exactamente así en Java,

130
00:07:23,700 --> 00:07:25,700
pero para entendernos.

131
00:07:26,400 --> 00:07:30,400
Y aquí por algún lado donde tendré mi variable persona1

132
00:07:30,400 --> 00:07:32,400
y mi variable persona2,

133
00:07:32,400 --> 00:07:37,400
pues aquí dentro lo que tengo es un puntero a este punto de aquí

134
00:07:37,400 --> 00:07:41,400
y aquí un puntero, una referencia a este punto de aquí.

135
00:07:45,400 --> 00:07:46,400
¿Vale?

136
00:07:46,400 --> 00:07:48,400
Parecido a lo que era con los arrays.

137
00:07:48,400 --> 00:07:50,400
Porque el array no es objeto.

138
00:07:50,400 --> 00:07:52,400
String también es un objeto.

139
00:07:52,400 --> 00:07:54,400
String funciona así, más o menos.

140
00:07:55,100 --> 00:07:57,100
String es especial.

141
00:07:57,100 --> 00:07:58,100
¿Sí?

142
00:07:58,100 --> 00:07:59,100
Vale.

143
00:08:01,100 --> 00:08:04,100
En Java no se trabaja directamente con direcciones de memoria,

144
00:08:04,100 --> 00:08:06,100
sino con un concepto un poquito más abstrato,

145
00:08:06,100 --> 00:08:08,100
que son los nombres simbólicos.

146
00:08:08,100 --> 00:08:10,100
O sea, cuando tú programas en Java,

147
00:08:10,100 --> 00:08:13,100
no vas a referirte al objeto diciendo,

148
00:08:13,100 --> 00:08:17,100
oye, este es el objeto arroba579342.

149
00:08:17,100 --> 00:08:19,100
Vale, vete a esa posición de memoria.

150
00:08:19,100 --> 00:08:22,100
Pues tú le darás un nombre, le das el nombre persona1,

151
00:08:22,100 --> 00:08:24,100
y trabajas con persona1.

152
00:08:24,800 --> 00:08:26,800
Porque queremos un nivel de abstracción más abstrato.

153
00:08:26,800 --> 00:08:29,800
No queremos ir a mirar la memoria dentro.

154
00:08:29,800 --> 00:08:32,800
Quiero que la Java Virtual Machine me esconda todas estas cosas

155
00:08:32,800 --> 00:08:35,800
para que yo sea más libre de pensar a mi problema

156
00:08:35,800 --> 00:08:38,800
y no a los problemas técnicos de dónde está la memoria.

157
00:08:38,800 --> 00:08:42,800
En otros lenguajes de programación, que son más a bajo nivel,

158
00:08:42,800 --> 00:08:46,800
pues a lo mejor puedes ir a trabajar con los espacios de memoria directamente,

159
00:08:46,800 --> 00:08:48,800
con las posiciones de memoria.

160
00:08:48,800 --> 00:08:51,800
Tienes más control sobre lo que pasa,

161
00:08:52,500 --> 00:08:56,500
porque puedes decidir qué hacer con la memoria literalmente,

162
00:08:56,500 --> 00:09:00,500
pero claramente es mucho más complejo hacer cosas grandes.

163
00:09:00,500 --> 00:09:02,500
Porque tienes que...

164
00:09:02,500 --> 00:09:04,500
Es como...

165
00:09:04,500 --> 00:09:06,500
¿Habéis jugado alguna vez algún juego?

166
00:09:06,500 --> 00:09:08,500
Esto de micromanagement,

167
00:09:08,500 --> 00:09:12,500
en el que todas las cosas que tienes que hacer tienen su opción

168
00:09:12,500 --> 00:09:14,500
y tú tienes que controlar absolutamente todo

169
00:09:14,500 --> 00:09:16,500
y llega un momento que mata

170
00:09:16,500 --> 00:09:19,500
porque te ganan,

171
00:09:20,200 --> 00:09:22,200
porque se te ha olvidado activar el no sé qué...

172
00:09:22,200 --> 00:09:24,200
Pues es eso.

173
00:09:24,200 --> 00:09:25,200
La diferencia entre decir

174
00:09:25,200 --> 00:09:27,200
ataca y todo mi ejército va atacando

175
00:09:27,200 --> 00:09:29,200
y te atropelamos aquí, te atropelamos aquí...

176
00:09:29,200 --> 00:09:31,200
Pues es lo mismo.

177
00:09:35,200 --> 00:09:39,200
Un objeto es un valor que se puede asignar a una variable

178
00:09:39,200 --> 00:09:41,200
cuyo tipo es la clase.

179
00:09:41,200 --> 00:09:43,200
La clase define el tipo,

180
00:09:43,200 --> 00:09:46,200
el objeto es un valor específico de este tipo.

181
00:09:46,200 --> 00:09:48,200
Es decir,

182
00:09:48,900 --> 00:09:52,900
un objeto con pinzas

183
00:09:52,900 --> 00:09:54,900
es un literal.

184
00:09:55,900 --> 00:09:56,900
¿Sí?

185
00:09:56,900 --> 00:09:58,900
¿Acordáis los int?

186
00:09:58,900 --> 00:10:00,900
Yo tenía tres,

187
00:10:00,900 --> 00:10:02,900
es un literal de tipo int.

188
00:10:02,900 --> 00:10:03,900
¿Sí?

189
00:10:03,900 --> 00:10:06,900
True es un literal de tipo boolean.

190
00:10:06,900 --> 00:10:08,900
Un objeto...

191
00:10:08,900 --> 00:10:10,900
Estefano pieza con la edad que tiene...

192
00:10:10,900 --> 00:10:17,900
Pues es un literal de tipo persona.

193
00:10:18,600 --> 00:10:22,600
La clase define un nuevo tipo.

194
00:10:25,600 --> 00:10:29,600
Los objetos son valores de ese tipo.

195
00:10:32,600 --> 00:10:35,600
No exactamente, sería el conjunto de actividad.

196
00:10:35,600 --> 00:10:37,600
Porque el objeto es todo,

197
00:10:37,600 --> 00:10:39,600
es un bloque.

198
00:10:39,600 --> 00:10:40,600
¿Sí?

199
00:10:40,600 --> 00:10:42,600
Tú estás definiendo un nuevo tipo

200
00:10:42,600 --> 00:10:44,600
que no es un tipo primitivo, no es un int.

201
00:10:44,600 --> 00:10:46,600
Porque una persona no es un int,

202
00:10:47,300 --> 00:10:50,300
una persona es string string int.

203
00:10:50,300 --> 00:10:53,300
Y este tipo nuevo que estoy creando,

204
00:10:53,300 --> 00:10:56,300
que representa una persona, lo llamo tipo persona.

205
00:10:57,300 --> 00:11:00,300
Las clases definen tipos.

206
00:11:00,300 --> 00:11:02,300
De hecho, lo sabéis,

207
00:11:02,300 --> 00:11:06,300
porque vosotros sabéis que string x es igual a gato.

208
00:11:06,300 --> 00:11:08,300
Y cuando ponéis string x,

209
00:11:08,300 --> 00:11:11,300
¿qué variable es?

210
00:11:11,300 --> 00:11:14,300
La variable x de tipo string.

211
00:11:14,300 --> 00:11:16,300
Y string no es una clase.

212
00:11:17,000 --> 00:11:20,000
Pues sí, es una clase, porque es ese mayúsculo.

213
00:11:20,000 --> 00:11:22,000
Entonces, lo habéis hecho.

214
00:11:22,000 --> 00:11:24,000
Ahora nosotros hacemos persona.

215
00:11:24,000 --> 00:11:28,000
Persona1 es igual a un objeto persona.

216
00:11:28,000 --> 00:11:30,000
¿Sí? Y lo vemos en un minuto.

217
00:11:32,000 --> 00:11:34,000
Si queremos crear un objeto tipo persona,

218
00:11:34,000 --> 00:11:36,000
le daremos un identificador

219
00:11:36,000 --> 00:11:38,000
para poder trabajar con él.

220
00:11:38,000 --> 00:11:40,000
Bueno, aquí, ¿vale?

221
00:11:40,000 --> 00:11:42,000
A esto.

222
00:11:43,000 --> 00:11:45,000
Estoy creando una nueva variable.

223
00:11:45,700 --> 00:11:47,700
¿Cuál es el tipo de alumno?

224
00:11:47,700 --> 00:11:48,700
Persona.

225
00:11:48,700 --> 00:11:49,700
¿Qué quiere decir?

226
00:11:49,700 --> 00:11:51,700
Que un alumno es de tipo persona

227
00:11:51,700 --> 00:11:55,700
que seguirá la estructura definida en la clase persona.

228
00:11:55,700 --> 00:11:58,700
Es un objeto de la clase persona.

229
00:11:58,700 --> 00:12:00,700
Cuidado, aquí todavía no hay objetos.

230
00:12:00,700 --> 00:12:03,700
Esto es como cuando hacía int x.

231
00:12:03,700 --> 00:12:05,700
¿Qué valor tiene x?

232
00:12:05,700 --> 00:12:07,700
No está todavía el valor de x.

233
00:12:07,700 --> 00:12:09,700
Pero he definido que existirá.

234
00:12:09,700 --> 00:12:11,700
Esta es una variable

235
00:12:12,400 --> 00:12:15,400
que contendrá un valor de tipo persona.

236
00:12:15,400 --> 00:12:17,400
O sea que aquí dentro tiene que ir un objeto.

237
00:12:17,400 --> 00:12:20,400
No puede hacer persona alumno es igual a 3.

238
00:12:20,400 --> 00:12:22,400
Porque 3 no es tipo persona.

239
00:12:22,400 --> 00:12:24,400
Es tipo int.

240
00:12:32,400 --> 00:12:33,400
Atributos.

241
00:12:33,400 --> 00:12:36,400
Son las características que definen un objeto.

242
00:12:36,400 --> 00:12:39,400
Cada atributo tiene una visibilidad,

243
00:12:39,400 --> 00:12:41,400
un tipo y un identificador del atributo.

244
00:12:42,100 --> 00:12:44,100
¿Qué son estos?

245
00:12:44,100 --> 00:12:46,100
La visibilidad es esto de public, private,

246
00:12:46,100 --> 00:12:48,100
protected y lo que sea.

247
00:12:48,100 --> 00:12:50,100
Lo veremos.

248
00:12:50,100 --> 00:12:52,100
Por ahora son public.

249
00:12:52,100 --> 00:12:54,100
Tiene un tipo,

250
00:12:54,100 --> 00:12:56,100
que puede ser un tipo primitivo,

251
00:12:56,100 --> 00:12:58,100
como antes que he hecho que mi atributo

252
00:12:58,100 --> 00:13:00,100
era int edad.

253
00:13:00,100 --> 00:13:03,100
O una clase, como cuando hacía string.

254
00:13:03,100 --> 00:13:05,100
Hemos dicho que a una persona

255
00:13:05,100 --> 00:13:07,100
yo le puedo dar una casa o un coche.

256
00:13:07,100 --> 00:13:09,100
Yo puedo ponerle como atributo

257
00:13:09,800 --> 00:13:11,800
Aquí.

258
00:13:13,800 --> 00:13:15,800
Como atributo a una persona

259
00:13:15,800 --> 00:13:17,800
le puedo poner public

260
00:13:17,800 --> 00:13:19,800
coche con la C mayúscula

261
00:13:19,800 --> 00:13:21,800
mi coche.

262
00:13:21,800 --> 00:13:23,800
Y ahora lo que pasa es que una persona

263
00:13:23,800 --> 00:13:25,800
tiene como atributo

264
00:13:25,800 --> 00:13:27,800
un objeto de tipo coche.

265
00:13:29,800 --> 00:13:31,800
Ahora lo hacemos.

266
00:13:31,800 --> 00:13:33,800
O sea con ejemplos.

267
00:13:34,500 --> 00:13:36,500
Y el nombre de este atributo.

268
00:13:36,500 --> 00:13:38,500
Dentro de mi clase este atributo

269
00:13:38,500 --> 00:13:40,500
se llamará edad.

270
00:13:40,500 --> 00:13:42,500
Se llamará mi coche.

271
00:13:42,500 --> 00:13:44,500
Se llamará segundo coche.

272
00:13:44,500 --> 00:13:46,500
¿Qué sé yo?

273
00:13:46,500 --> 00:13:48,500
Por ejemplo una persona

274
00:13:48,500 --> 00:13:50,500
tiene nombre edad como atributo.

275
00:13:50,500 --> 00:13:52,500
Por lo tanto el nombre

276
00:13:52,500 --> 00:13:54,500
de tipo string es una clase

277
00:13:54,500 --> 00:13:56,500
y el edad es un tipo int

278
00:13:56,500 --> 00:13:58,500
es un tipo primitivo.

279
00:14:00,500 --> 00:14:02,500
El estado de un objeto

280
00:14:03,200 --> 00:14:05,200
está definido por los valores

281
00:14:05,200 --> 00:14:07,200
de sus atributos en un momento concreto.

282
00:14:07,200 --> 00:14:09,200
Hago una foto ahora

283
00:14:09,200 --> 00:14:11,200
y veo cuál es

284
00:14:11,200 --> 00:14:13,200
el nombre en este momento

285
00:14:13,200 --> 00:14:15,200
y cuál es la edad en este momento

286
00:14:15,200 --> 00:14:17,200
este es el estado de este objeto en este momento.

287
00:14:17,200 --> 00:14:19,200
¿Puede variar? Sí, si yo quiero.

288
00:14:19,200 --> 00:14:21,200
Si yo hago métodos

289
00:14:21,200 --> 00:14:23,200
que puedan variar su edad como cumplir los años

290
00:14:23,200 --> 00:14:25,200
pues su estado puede cambiar.

291
00:14:25,200 --> 00:14:27,200
Ahora tiene 18 años

292
00:14:27,200 --> 00:14:29,200
cumple edad, pues ahora tiene 19.

293
00:14:29,200 --> 00:14:31,200
Ha cambiado su estado.

294
00:14:31,900 --> 00:14:33,900
El estado puede variar a cambiar los valores

295
00:14:33,900 --> 00:14:35,900
de los atributos.

296
00:14:35,900 --> 00:14:37,900
Dudas hasta aquí.

297
00:14:39,900 --> 00:14:41,900
Y luego están los métodos.

298
00:14:41,900 --> 00:14:43,900
Identificación, atributos y métodos.

299
00:14:43,900 --> 00:14:45,900
Los métodos son

300
00:14:45,900 --> 00:14:47,900
es el contrato que

301
00:14:47,900 --> 00:14:49,900
los objetos proporcionan

302
00:14:49,900 --> 00:14:51,900
servicios a otros objetos.

303
00:14:51,900 --> 00:14:53,900
Yo soy el objeto persona

304
00:14:53,900 --> 00:14:55,900
y tengo mis métodos. ¿Qué son mis métodos?

305
00:14:55,900 --> 00:14:57,900
Son los métodos saludar

306
00:14:57,900 --> 00:14:59,900
y los métodos cumplir años.

307
00:15:00,600 --> 00:15:02,600
Estos son servicios que otros pueden pedir

308
00:15:02,600 --> 00:15:04,600
a mi como objeto

309
00:15:04,600 --> 00:15:06,600
para que yo lo haga.

310
00:15:06,600 --> 00:15:08,600
Si alguien pide a mi

311
00:15:08,600 --> 00:15:10,600
como objeto, oye, saluda

312
00:15:10,600 --> 00:15:12,600
pues yo escribiré

313
00:15:12,600 --> 00:15:14,600
Hola, me llamo Estefano

314
00:15:14,600 --> 00:15:16,600
y si alguien pide a mi como objeto

315
00:15:16,600 --> 00:15:18,600
el cumpleaños

316
00:15:18,600 --> 00:15:20,600
pues yo actualizaré mi estado

317
00:15:20,600 --> 00:15:22,600
añadiendo uno a la edad.

318
00:15:22,600 --> 00:15:24,600
Estos son servicios

319
00:15:24,600 --> 00:15:26,600
a disposición de quien quiera

320
00:15:26,600 --> 00:15:28,600
y quien quiera utilizarlos puede acceder a mis servicios

321
00:15:29,300 --> 00:15:31,300
es decir, haz esto, y yo lo hago.

322
00:15:33,300 --> 00:15:35,300
¿Cómo?

323
00:15:37,300 --> 00:15:39,300
Un método suele tener

324
00:15:39,300 --> 00:15:41,300
un nombre

325
00:15:41,300 --> 00:15:43,300
como antes creábamos las funciones

326
00:15:43,300 --> 00:15:45,300
le dábamos cálcula media

327
00:15:45,300 --> 00:15:47,300
unos parámetros

328
00:15:47,300 --> 00:15:49,300
los parámetros que poníamos entre paréntesis

329
00:15:49,300 --> 00:15:51,300
que pero pueden no estar

330
00:15:51,300 --> 00:15:53,300
saluda, por ejemplo

331
00:15:53,300 --> 00:15:55,300
puede no tener parámetros

332
00:15:56,000 --> 00:15:58,000
y lo que devuelve

333
00:15:58,000 --> 00:16:00,000
o sea, yo hago todo el trabajo

334
00:16:00,000 --> 00:16:02,000
y al final del trabajo, ¿qué hago?

335
00:16:02,000 --> 00:16:04,000
te devuelvo algo

336
00:16:04,000 --> 00:16:06,000
o no

337
00:16:06,000 --> 00:16:08,000
lo que ya antes se llamaba función o procedimiento

338
00:16:08,000 --> 00:16:10,000
pues ahora se llama método

339
00:16:10,000 --> 00:16:12,000
y puede devolver algo o no

340
00:16:12,000 --> 00:16:14,000
es igual a antes

341
00:16:14,000 --> 00:16:16,000
porque nosotros hemos hecho eso

342
00:16:16,000 --> 00:16:18,000
hemos impropiamente utilizado los métodos

343
00:16:18,000 --> 00:16:20,000
como función y procedimiento

344
00:16:20,000 --> 00:16:22,000
pero eran métodos antes también

345
00:16:22,000 --> 00:16:24,000
Es importante saber

346
00:16:24,700 --> 00:16:26,700
qué método implementa una clase

347
00:16:26,700 --> 00:16:28,700
qué parámetros tienen los métodos

348
00:16:28,700 --> 00:16:30,700
y qué devuelven

349
00:16:30,700 --> 00:16:32,700
para que otros programas puedan utilizar esos métodos

350
00:16:32,700 --> 00:16:34,700
es decir, que yo cuando

351
00:16:34,700 --> 00:16:36,700
pillo la clase Persona

352
00:16:36,700 --> 00:16:38,700
me la voy a leer y digo

353
00:16:38,700 --> 00:16:40,700
¿qué puede hacer Persona?

354
00:16:40,700 --> 00:16:42,700
pues tiene sus atributos, puede hacer esto, esto, esto

355
00:16:42,700 --> 00:16:44,700
vale, ahora sé utilizarla

356
00:16:44,700 --> 00:16:46,700
si no sé qué métodos están implementados

357
00:16:46,700 --> 00:16:48,700
pues no puedo utilizar propiamente una clase

358
00:16:48,700 --> 00:16:50,700
Cuidado, no es importante

359
00:16:50,700 --> 00:16:52,700
cómo se hacen las cosas

360
00:16:53,400 --> 00:16:55,400
sino lo que se puede hacer

361
00:16:55,400 --> 00:16:57,400
a mí, como programador

362
00:16:57,400 --> 00:16:59,400
me interesa de la clase Persona saber

363
00:16:59,400 --> 00:17:01,400
que puede saludar

364
00:17:01,400 --> 00:17:03,400
y que puede cumplir años

365
00:17:03,400 --> 00:17:05,400
con estos dos, me vale

366
00:17:05,400 --> 00:17:07,400
quien ha hecho esa clase

367
00:17:07,400 --> 00:17:09,400
probablemente sabrá

368
00:17:09,400 --> 00:17:11,400
cómo se hacen esas cosas

369
00:17:11,400 --> 00:17:13,400
la habrá implementado él

370
00:17:13,400 --> 00:17:15,400
pero a mí no me interesa saber cómo

371
00:17:15,400 --> 00:17:17,400
me interesa utilizar su clase

372
00:17:17,400 --> 00:17:19,400
y utilizarla

373
00:17:19,400 --> 00:17:21,400
cuando vosotros utilizáis Println

374
00:17:22,100 --> 00:17:24,100
System.8.Println

375
00:17:24,100 --> 00:17:26,100
Println es un método

376
00:17:26,100 --> 00:17:28,100
vosotros, ¿sabéis cómo se hace?

377
00:17:28,100 --> 00:17:30,100
¿sabéis cómo se escribe en pantalla?

378
00:17:30,100 --> 00:17:32,100
¿qué hace por detrás

379
00:17:32,100 --> 00:17:34,100
para que aparezcan

380
00:17:34,100 --> 00:17:36,100
vuestras letras en la pantalla

381
00:17:36,100 --> 00:17:38,100
en la consola?

382
00:17:38,100 --> 00:17:40,100
no, pero a vosotros os interesa saber

383
00:17:40,100 --> 00:17:42,100
que existe Println para poder escribir en consola

384
00:17:42,100 --> 00:17:44,100
¿sí?

385
00:17:44,100 --> 00:17:46,100
la idea es siempre extraer

386
00:17:46,100 --> 00:17:48,100
yo me hago Persona

387
00:17:48,100 --> 00:17:50,100
cumplir los años es un código infernal

388
00:17:50,800 --> 00:17:52,800
que pilla una base de datos

389
00:17:52,800 --> 00:17:54,800
va a otro lado, cosa así

390
00:17:54,800 --> 00:17:56,800
un millón de líneas de código

391
00:17:56,800 --> 00:17:58,800
no me interesa, eso es que Persona tiene cumplir años

392
00:17:58,800 --> 00:18:00,800
llamo cumplir años y cumple años

393
00:18:00,800 --> 00:18:02,800
¿sí?

394
00:18:06,800 --> 00:18:08,800
¿dónde creamos una clase?

395
00:18:08,800 --> 00:18:10,800
oh

396
00:18:10,800 --> 00:18:12,800
los atributos de una clase

397
00:18:12,800 --> 00:18:14,800
son ser responsabilidad de la clase misma

398
00:18:14,800 --> 00:18:16,800
por eso si quiero permitir

399
00:18:16,800 --> 00:18:18,800
que se lean o se modifiquen

400
00:18:19,500 --> 00:18:21,500
para implementar métodos adecuados para ellos

401
00:18:21,500 --> 00:18:23,500
los getter y los setter

402
00:18:23,500 --> 00:18:25,500
mira

403
00:18:25,500 --> 00:18:27,500
esta es mi clase Persona

404
00:18:27,500 --> 00:18:29,500
¿vale?

405
00:18:29,500 --> 00:18:31,500
mi clase Persona tiene string apellido

406
00:18:31,500 --> 00:18:33,500
y string nombre

407
00:18:33,500 --> 00:18:35,500
¿y luego qué tiene?

408
00:18:35,500 --> 00:18:37,500
tiene métodos

409
00:18:37,500 --> 00:18:39,500
tiene el método que devuelve

410
00:18:39,500 --> 00:18:41,500
un string que es get apellido

411
00:18:41,500 --> 00:18:43,500
¿sí?

412
00:18:43,500 --> 00:18:45,500
si yo llamo sobre un método de tipo Persona

413
00:18:45,500 --> 00:18:47,500
sobre un objeto de tipo Persona

414
00:18:48,200 --> 00:18:50,200
llamo el método get apellido

415
00:18:50,200 --> 00:18:52,200
lo que hará él es pillar

416
00:18:52,200 --> 00:18:54,200
el contenido de esta variable

417
00:18:54,200 --> 00:18:56,200
y devolverlo

418
00:18:56,200 --> 00:18:58,200
¿sí?

419
00:18:58,200 --> 00:19:00,200
y luego está set apellido

420
00:19:00,200 --> 00:19:02,200
set apellido es

421
00:19:02,200 --> 00:19:04,200
dame un valor

422
00:19:04,200 --> 00:19:06,200
yo este valor

423
00:19:06,200 --> 00:19:08,200
lo voy a poner

424
00:19:08,200 --> 00:19:10,200
dentro de esta variable de aquí

425
00:19:14,200 --> 00:19:16,200
¿sí?

426
00:19:16,900 --> 00:19:18,900
get nombre y set nombre

427
00:19:18,900 --> 00:19:20,900
¿vale? estos son getter y setter

428
00:19:20,900 --> 00:19:22,900
veremos más adelante

429
00:19:22,900 --> 00:19:24,900
hablaremos otra vez de ellos

430
00:19:24,900 --> 00:19:26,900
normalmente

431
00:19:26,900 --> 00:19:28,900
lo que yo quiero es que estos

432
00:19:28,900 --> 00:19:30,900
atributos de aquí

433
00:19:30,900 --> 00:19:32,900
los atributos de una clase

434
00:19:32,900 --> 00:19:34,900
no sean públicos

435
00:19:34,900 --> 00:19:36,900
yo no quiero que desde otra clase

436
00:19:36,900 --> 00:19:38,900
un coche pueda cambiar mi nombre

437
00:19:38,900 --> 00:19:40,900
a Luigi

438
00:19:42,900 --> 00:19:44,900
no puede

439
00:19:45,600 --> 00:19:47,600
hacer otra persona desde fuera

440
00:19:47,600 --> 00:19:49,600
es acceder a mi método

441
00:19:49,600 --> 00:19:51,600
set nombre

442
00:19:51,600 --> 00:19:53,600
donde me dice

443
00:19:53,600 --> 00:19:55,600
Luigi

444
00:19:55,600 --> 00:19:57,600
y que aquí dentro, en vez de ser tan sencillo

445
00:19:57,600 --> 00:19:59,600
haga una prueba

446
00:19:59,600 --> 00:20:01,600
en plan, oye, pero tú eres una persona que puede cambiar nombre

447
00:20:01,600 --> 00:20:03,600
eres el ayuntamiento

448
00:20:03,600 --> 00:20:05,600
si eres el ayuntamiento, tienes esta credencial

449
00:20:05,600 --> 00:20:07,600
bla bla bla bla bla

450
00:20:07,600 --> 00:20:09,600
código código código código

451
00:20:09,600 --> 00:20:11,600
entonces hazlo, y si no, no

452
00:20:11,600 --> 00:20:13,600
no sé si me explico lo que quiere decir

453
00:20:14,300 --> 00:20:16,300
si yo no hago esto

454
00:20:16,300 --> 00:20:18,300
y aquí permito directamente acceder a mi nombre

455
00:20:18,300 --> 00:20:20,300
cualquiera puede acceder a mi nombre y cambiarlo

456
00:20:20,300 --> 00:20:22,300
si yo me creo un método

457
00:20:22,300 --> 00:20:24,300
esto lo hago

458
00:20:24,300 --> 00:20:26,300
o así o privado, veremos la diferencia

459
00:20:26,300 --> 00:20:28,300
¿vale? de esta forma aquí

460
00:20:28,300 --> 00:20:30,300
no se puede hacer desde fuera

461
00:20:30,300 --> 00:20:32,300
se puede hacer solo de dentro de aquí

462
00:20:32,300 --> 00:20:34,300
y yo me creo un método

463
00:20:34,300 --> 00:20:36,300
que comprueba, antes de poner aquí

464
00:20:36,300 --> 00:20:38,300
nombre, si es válido o no

465
00:20:38,300 --> 00:20:40,300
pues me garantizo

466
00:20:40,300 --> 00:20:42,300
que mi nombre no se pueda cambiar

467
00:20:43,000 --> 00:20:45,000
fijaos que el método es público

468
00:20:45,000 --> 00:20:47,000
se puede acceder desde fuera

469
00:20:47,000 --> 00:20:49,000
pero el acceso a la variable no

470
00:20:49,000 --> 00:20:51,000
no sé si se nota esta cosa

471
00:20:51,000 --> 00:20:53,000
es más bien una pincelada de emisión

472
00:20:53,000 --> 00:20:55,000
es lo que decía antes del DNI

473
00:20:55,000 --> 00:20:57,000
imaginaos aquí una variable DNI

474
00:20:57,000 --> 00:20:59,000
si yo tengo

475
00:20:59,000 --> 00:21:01,000
la variable DNI directamente

476
00:21:01,000 --> 00:21:03,000
alguien puede acceder y decir

477
00:21:03,000 --> 00:21:05,000
DNI ahora pon ahí dentro cocodrilo

478
00:21:05,000 --> 00:21:07,000
y él dice vale

479
00:21:07,000 --> 00:21:09,000
sin embargo, si yo me hago un set DNI

480
00:21:09,000 --> 00:21:11,000
que aquí dentro

481
00:21:11,700 --> 00:21:13,700
dice for int igual a cero

482
00:21:13,700 --> 00:21:15,700
y menor de la longitud

483
00:21:15,700 --> 00:21:17,700
de la string que me has pasado y más más

484
00:21:17,700 --> 00:21:19,700
y lo que va a mirar

485
00:21:19,700 --> 00:21:21,700
charat cero es un número, charat uno es un número

486
00:21:21,700 --> 00:21:23,700
charat dos es un número, hasta charat sete

487
00:21:23,700 --> 00:21:25,700
son números

488
00:21:25,700 --> 00:21:27,700
y luego viene una letra

489
00:21:27,700 --> 00:21:29,700
pues ya estoy comprobando

490
00:21:29,700 --> 00:21:31,700
algo más

491
00:21:31,700 --> 00:21:33,700
¿entendéis?

492
00:21:33,700 --> 00:21:35,700
lo veremos, por ahora me interesa más bien

493
00:21:35,700 --> 00:21:37,700
esta cosa aquí

494
00:21:37,700 --> 00:21:39,700
fijaos que

495
00:21:40,400 --> 00:21:42,400
las variables estas

496
00:21:42,400 --> 00:21:44,400
las estoy usando en todos los métodos

497
00:21:44,400 --> 00:21:46,400
de la clase

498
00:21:46,400 --> 00:21:48,400
¿por qué? porque son atributos

499
00:21:48,400 --> 00:21:50,400
¿dónde es el scope?

500
00:21:50,400 --> 00:21:52,400
de estos dos

501
00:21:52,400 --> 00:21:54,400
desde aquí hasta aquí

502
00:21:54,400 --> 00:21:56,400
por lo tanto lo puedo utilizar en cualquier lado

503
00:21:56,400 --> 00:21:58,400
otra cosa

504
00:21:58,400 --> 00:22:00,400
que podríais haber notado

505
00:22:00,400 --> 00:22:02,400
es que yo aquí tengo

506
00:22:02,400 --> 00:22:04,400
string apellido

507
00:22:04,400 --> 00:22:06,400
y aquí tengo string apellido

508
00:22:06,400 --> 00:22:08,400
entonces ¿cómo no?

509
00:22:09,100 --> 00:22:11,100
¿qué me confundo entre

510
00:22:11,100 --> 00:22:13,100
esta variable

511
00:22:13,100 --> 00:22:15,100
y esta variable?

512
00:22:15,100 --> 00:22:17,100
podría confundirme

513
00:22:17,100 --> 00:22:19,100
porque aquí dentro existirá

514
00:22:19,100 --> 00:22:21,100
apellido esta variable de aquí

515
00:22:21,100 --> 00:22:23,100
pero yo quiero utilizar esta variable de aquí

516
00:22:23,100 --> 00:22:25,100
¿cómo las diferencio?

517
00:22:25,100 --> 00:22:27,100
esta de esta

518
00:22:31,100 --> 00:22:33,100
y del colorido

519
00:22:35,100 --> 00:22:37,100
este objeto

520
00:22:37,800 --> 00:22:39,800
esto es la variable que me han dado aquí

521
00:22:39,800 --> 00:22:41,800
una variable local a este método

522
00:22:41,800 --> 00:22:43,800
¿veis que el color es el mismo?

523
00:22:43,800 --> 00:22:45,800
pero lo que me has dado tú

524
00:22:45,800 --> 00:22:47,800
que es el nuevo apellido que quieres cambiar

525
00:22:47,800 --> 00:22:49,800
en mi objeto, yo quiero cambiar

526
00:22:49,800 --> 00:22:51,800
esta variable, para poder acceder

527
00:22:51,800 --> 00:22:53,800
a esta variable, utilizo

528
00:22:53,800 --> 00:22:55,800
this, ¿qué es this?

529
00:22:55,800 --> 00:22:57,800
esto, ¿esto qué?

530
00:22:57,800 --> 00:22:59,800
este objeto

531
00:22:59,800 --> 00:23:01,800
si yo soy la persona uno y me están llamando

532
00:23:01,800 --> 00:23:03,800
este apellido

533
00:23:03,800 --> 00:23:05,800
será el apellido de la persona uno

534
00:23:06,500 --> 00:23:08,500
si yo soy la persona dos

535
00:23:08,500 --> 00:23:10,500
y le están cambiando el apellido

536
00:23:10,500 --> 00:23:12,500
será el apellido de la persona dos

537
00:23:12,500 --> 00:23:14,500
del objeto

538
00:23:14,500 --> 00:23:16,500
que está ejecutando esto

539
00:23:16,500 --> 00:23:18,500
si tú llamas esto sobre el objeto uno

540
00:23:18,500 --> 00:23:20,500
pues lo pondrá

541
00:23:20,500 --> 00:23:22,500
en el campo apellido

542
00:23:22,500 --> 00:23:24,500
del objeto uno, si tú estás llamando esto

543
00:23:24,500 --> 00:23:26,500
sobre el objeto treinta siete

544
00:23:26,500 --> 00:23:28,500
pues lo utilizará la variable del objeto

545
00:23:28,500 --> 00:23:30,500
treinta siete

546
00:23:30,500 --> 00:23:32,500
el concepto de this

547
00:23:32,500 --> 00:23:34,500
this sirve porque si yo hiciera esto

548
00:23:36,500 --> 00:23:38,500
sin el this

549
00:23:38,500 --> 00:23:40,500
este apellido sería este apellido

550
00:23:42,500 --> 00:23:44,500
no habría diferencia, ¿cómo puedo saber

551
00:23:44,500 --> 00:23:46,500
si estoy copiando esto dentro de esto

552
00:23:46,500 --> 00:23:48,500
o esto dentro de esto

553
00:23:48,500 --> 00:23:50,500
o esto dentro de esto

554
00:23:50,500 --> 00:23:52,500
si son todos iguales, se llaman apellidos

555
00:23:52,500 --> 00:23:54,500
solución

556
00:23:54,500 --> 00:23:56,500
aquí lo llamo a

557
00:23:56,500 --> 00:23:58,500
entonces no hay

558
00:23:58,500 --> 00:24:00,500
ambigüedad y hago apellidos igual a

559
00:24:00,500 --> 00:24:02,500
apellido es sólo esto

560
00:24:03,200 --> 00:24:05,200
pero hay situaciones en que

561
00:24:05,200 --> 00:24:07,200
this sirve

562
00:24:07,200 --> 00:24:09,200
es para introducir cosas

563
00:24:09,200 --> 00:24:11,200
es mucha teoría

564
00:24:11,200 --> 00:24:13,200
pero porque quiero llegar

565
00:24:13,200 --> 00:24:15,200
a esto y luego hacemos ejemplos

566
00:24:15,200 --> 00:24:17,200
¿qué son los constructores?

567
00:24:17,200 --> 00:24:19,200
¿qué son los constructores?

568
00:24:19,200 --> 00:24:21,200
crear objetos

569
00:24:21,200 --> 00:24:23,200
¿hemos dicho que queremos crear objetos?

570
00:24:23,200 --> 00:24:25,200
pues para crear objetos necesitamos constructores

571
00:24:25,200 --> 00:24:27,200
los constructores son

572
00:24:27,200 --> 00:24:29,200
métodos especiales

573
00:24:29,200 --> 00:24:31,200
que lo que hacen es crearme

574
00:24:31,900 --> 00:24:33,900
un objeto

575
00:24:33,900 --> 00:24:35,900
¿cómo se crea un objeto?

576
00:24:35,900 --> 00:24:37,900
¿qué hará falta

577
00:24:37,900 --> 00:24:39,900
para crear una persona?

578
00:24:41,900 --> 00:24:43,900
¿qué es una persona?

579
00:24:45,900 --> 00:24:47,900
yo tengo mis atributos

580
00:24:47,900 --> 00:24:49,900
nombre, apellido y edad

581
00:24:49,900 --> 00:24:51,900
entonces ¿qué me sirve para crear un objeto?

582
00:24:51,900 --> 00:24:53,900
un objeto-persona

583
00:24:57,900 --> 00:24:59,900
que tú me des valores para estos tres atributos

584
00:25:00,600 --> 00:25:02,600
creame una nueva persona

585
00:25:02,600 --> 00:25:04,600
que se llame Estefano

586
00:25:04,600 --> 00:25:06,600
su apellido sea Kiesa

587
00:25:06,600 --> 00:25:08,600
y su edad sea 42

588
00:25:10,600 --> 00:25:12,600
además

589
00:25:12,600 --> 00:25:14,600
una clase produce un método especial

590
00:25:14,600 --> 00:25:16,600
que se llama constructores

591
00:25:16,600 --> 00:25:18,600
un constructor se tiene que llamar

592
00:25:18,600 --> 00:25:20,600
como una clase

593
00:25:20,600 --> 00:25:22,600
los constructores

594
00:25:22,600 --> 00:25:24,600
no devuelven nada

595
00:25:24,600 --> 00:25:26,600
no tienen ni void ni nada

596
00:25:26,600 --> 00:25:28,600
porque en realidad lo que están devolviendo

597
00:25:29,300 --> 00:25:31,300
tú llamas a ese constructor

598
00:25:31,300 --> 00:25:33,300
y te crea un objeto

599
00:25:33,300 --> 00:25:35,300
se ejecutan en el momento de la creación del objeto

600
00:25:35,300 --> 00:25:37,300
y se ejecutan utilizando el new

601
00:25:37,300 --> 00:25:39,300
nosotros ya lo hemos utilizado

602
00:25:41,300 --> 00:25:43,300
voy más rápido

603
00:25:43,300 --> 00:25:45,300
porque quiero ver esto

604
00:25:47,300 --> 00:25:49,300
aquí estamos

605
00:25:53,300 --> 00:25:55,300
clase-persona

606
00:25:55,300 --> 00:25:57,300
tiene nombre y edad

607
00:25:58,000 --> 00:26:00,000
este señor de aquí es un constructor

608
00:26:02,000 --> 00:26:04,000
si os fijáis es parecido

609
00:26:04,000 --> 00:26:06,000
a un método

610
00:26:06,000 --> 00:26:08,000
pero aquí no tiene ni void ni int ni nada

611
00:26:08,000 --> 00:26:10,000
es public-persona

612
00:26:10,000 --> 00:26:12,000
se llama como la clase

613
00:26:12,000 --> 00:26:14,000
y que pilla

614
00:26:14,000 --> 00:26:16,000
pilla un string-nom

615
00:26:16,000 --> 00:26:18,000
y un int-e

616
00:26:20,000 --> 00:26:22,000
entonces cuando yo llamaré este constructor

617
00:26:22,000 --> 00:26:24,000
con la new

618
00:26:24,000 --> 00:26:26,000
ahora lo vemos al lado

619
00:26:26,700 --> 00:26:28,700
voy a crear una nueva persona

620
00:26:28,700 --> 00:26:30,700
que se llama stefano,42

621
00:26:32,700 --> 00:26:34,700
lo que hace es que pillará este stefano

622
00:26:34,700 --> 00:26:36,700
y lo pondrá en el nombre

623
00:26:36,700 --> 00:26:38,700
de este objeto

624
00:26:38,700 --> 00:26:40,700
y pillará 42

625
00:26:40,700 --> 00:26:42,700
y lo guardará dentro de la edad de este objeto

626
00:26:44,700 --> 00:26:46,700
y me ha creado el objeto

627
00:26:48,700 --> 00:26:50,700
esto sería col-dis

628
00:26:50,700 --> 00:26:52,700
pero como esto y esto se llaman distintos

629
00:26:52,700 --> 00:26:54,700
pues no me hace falta

630
00:26:55,400 --> 00:26:57,400
si esto se llamara nombre y esto se llamara edad

631
00:26:57,400 --> 00:26:59,400
pues aquí debería hacer

632
00:26:59,400 --> 00:27:01,400
dis.nombre es igual a nombre

633
00:27:01,400 --> 00:27:03,400
dis.edad es igual a edad

634
00:27:07,400 --> 00:27:09,400
yo creo un objeto

635
00:27:09,400 --> 00:27:11,400
una vez que lo he creado

636
00:27:11,400 --> 00:27:13,400
si quiero poder modificar o leer

637
00:27:13,400 --> 00:27:15,400
mis datos

638
00:27:15,400 --> 00:27:17,400
pues tengo varias opciones

639
00:27:17,400 --> 00:27:19,400
leerlo directamente aquí

640
00:27:19,400 --> 00:27:21,400
si son públicos

641
00:27:21,400 --> 00:27:23,400
pero si en este caso son privados

642
00:27:24,100 --> 00:27:26,100
pues entonces necesito un getter and setter

643
00:27:26,100 --> 00:27:28,100
¿por qué necesito un getter and setter?

644
00:27:28,100 --> 00:27:30,100
porque no leo

645
00:27:30,100 --> 00:27:32,100
o escribo directamente

646
00:27:32,100 --> 00:27:34,100
sino que tengo más control

647
00:27:34,100 --> 00:27:36,100
porque alguien cuando quiere leer o quiere modificar

648
00:27:36,100 --> 00:27:38,100
tiene que pasar por mi método

649
00:27:38,100 --> 00:27:40,100
y yo en mi método puedo poner un if

650
00:27:40,100 --> 00:27:42,100
puedo poner un while,puedo poner un control

651
00:27:42,100 --> 00:27:44,100
para ver si tu puedes o no acceder a esos datos

652
00:27:48,100 --> 00:27:50,100
luego hablaremos de todas estas cosas

653
00:27:50,100 --> 00:27:52,100
¿qué es esto?

654
00:27:54,100 --> 00:27:56,100
¿qué es esto?

655
00:28:00,100 --> 00:28:02,100
es otro constructor

656
00:28:02,100 --> 00:28:04,100
pero este es un constructor que se llama

657
00:28:04,100 --> 00:28:06,100
cuando tu tienes

658
00:28:06,100 --> 00:28:08,100
una persona que sabe su nombre

659
00:28:08,100 --> 00:28:10,100
pero no sabe su edad

660
00:28:10,100 --> 00:28:12,100
entonces

661
00:28:12,100 --> 00:28:14,100
lo llamas así

662
00:28:14,100 --> 00:28:16,100
esto y esto crean objetos

663
00:28:16,100 --> 00:28:18,100
solo que esto crea un objeto

664
00:28:18,100 --> 00:28:20,100
con nombre y edad asignado

665
00:28:20,100 --> 00:28:22,100
mientras esto aquí crea un nombre

666
00:28:22,800 --> 00:28:24,800
un valor por defecto

667
00:28:24,800 --> 00:28:26,800
podría hasta poner que aquí

668
00:28:26,800 --> 00:28:28,800
edad es igual a menos uno

669
00:28:28,800 --> 00:28:30,800
como indicar una edad desconocida

670
00:28:30,800 --> 00:28:32,800
¿cómo se llaman estos señores?

671
00:28:32,800 --> 00:28:34,800
así

672
00:28:38,800 --> 00:28:40,800
sintaxis

673
00:28:40,800 --> 00:28:42,800
nombre de la clase

674
00:28:42,800 --> 00:28:44,800
nombre de la variable

675
00:28:44,800 --> 00:28:46,800
es igual a new nombre de la clase

676
00:28:46,800 --> 00:28:48,800
los parámetros

677
00:28:48,800 --> 00:28:50,800
esto es el constructor

678
00:28:51,500 --> 00:28:53,500
por ejemplo

679
00:28:53,500 --> 00:28:55,500
persona, persona1

680
00:28:55,500 --> 00:28:57,500
esta es una variable

681
00:28:57,500 --> 00:28:59,500
de tipo persona

682
00:28:59,500 --> 00:29:01,500
es igual, crea un nuevo objeto

683
00:29:01,500 --> 00:29:03,500
de tipo persona

684
00:29:03,500 --> 00:29:05,500
que se llama Lola y tiene 30 años

685
00:29:07,500 --> 00:29:09,500
persona, persona2

686
00:29:09,500 --> 00:29:11,500
es una nueva persona

687
00:29:11,500 --> 00:29:13,500
que se llama Pepe y tiene 25 años

688
00:29:13,500 --> 00:29:15,500
estos son dos objetos distintos

689
00:29:15,500 --> 00:29:17,500
tienen nada que ver uno con otro

690
00:29:17,500 --> 00:29:19,500
los dos son de tipo persona

691
00:29:20,200 --> 00:29:22,200
misma estructura pero dos entidades distintas

692
00:29:24,200 --> 00:29:26,200
y puedo utilizar persona, persona3

693
00:29:26,200 --> 00:29:28,200
es igual a personaPaco

694
00:29:28,200 --> 00:29:30,200
esto me crea un objeto

695
00:29:30,200 --> 00:29:32,200
su edad será cero

696
00:29:32,200 --> 00:29:34,200
porque por defecto un int es cero

697
00:29:38,200 --> 00:29:40,200
y ahora puedo utilizar persona1

698
00:29:40,200 --> 00:29:42,200
y decir persona1.cumpleaños

699
00:29:46,200 --> 00:29:48,200
¿qué pasa con persona1.cumpleaños?

700
00:29:48,900 --> 00:29:50,900
que este de aquí se sumará a 1

701
00:29:50,900 --> 00:29:52,900
y se vuelve 31

702
00:29:52,900 --> 00:29:54,900
sin afectar ni esto ni esto

703
00:29:54,900 --> 00:29:56,900
porque son objetos distintos

704
00:29:56,900 --> 00:29:58,900
misma clase pero objetos distintos

705
00:29:58,900 --> 00:30:00,900
instancias distintas

706
00:30:04,900 --> 00:30:06,900
¿alguna persona cumpleaños?

707
00:30:06,900 --> 00:30:08,900
¿qué es el sentido?

708
00:30:09,600 --> 00:30:11,600
si se llama Laura no puede cumpleaños

709
00:30:15,600 --> 00:30:17,600
si dentro de cumpleaños

710
00:30:17,600 --> 00:30:19,600
tu dices

711
00:30:19,600 --> 00:30:21,600
if nombre.e

712
00:30:21,600 --> 00:30:23,600
cual es Laura

713
00:30:23,600 --> 00:30:25,600
entre comillas

714
00:30:25,600 --> 00:30:27,600
nada

715
00:30:27,600 --> 00:30:29,600
elce edad++

716
00:30:31,600 --> 00:30:33,600
cuando se llama cumpleaños

717
00:30:33,600 --> 00:30:35,600
si te llaman Laura no cumples

718
00:30:36,300 --> 00:30:38,300
yo lo pondría

719
00:30:38,300 --> 00:30:40,300
depende de lo que quieras hacer

720
00:30:40,300 --> 00:30:42,300
puedes hacerlo de dos formas

721
00:30:42,300 --> 00:30:44,300
o dentro de persona

722
00:30:44,300 --> 00:30:46,300
dentro del método cumpleaños

723
00:30:46,300 --> 00:30:48,300
pones eso

724
00:30:48,300 --> 00:30:50,300
que nunca una persona

725
00:30:50,300 --> 00:30:52,300
que se llame Laura

726
00:30:52,300 --> 00:30:54,300
comprará los años, nunca

727
00:30:54,300 --> 00:30:56,300
porque todas las veces que alguien que se llama Laura entra allí

728
00:30:56,300 --> 00:30:58,300
pues no le suman los años

729
00:30:58,300 --> 00:31:00,300
o lo puedes hacer desde fuera

730
00:31:00,300 --> 00:31:02,300
aquí dices

731
00:31:02,300 --> 00:31:04,300
if persona3.getName

732
00:31:05,000 --> 00:31:07,000
.equals Laura

733
00:31:07,000 --> 00:31:09,000
entonces no haga nada

734
00:31:09,000 --> 00:31:11,000
y si no cumpleaños

735
00:31:11,000 --> 00:31:13,000
pues entonces la persona Laura

736
00:31:13,000 --> 00:31:15,000
puede cumplir

737
00:31:15,000 --> 00:31:17,000
pero en este caso concreto

738
00:31:17,000 --> 00:31:19,000
en tu programa no

739
00:31:25,000 --> 00:31:27,000
¿escáner es un objeto?

740
00:31:35,000 --> 00:31:37,000
si persona1 es igual

741
00:31:37,000 --> 00:31:39,000
le llamas un método

742
00:31:45,000 --> 00:31:47,000
si el método que tu llamas

743
00:31:47,000 --> 00:31:49,000
te devuelve algo lo puedes hacer

744
00:31:53,000 --> 00:31:55,000
si el método que tu llamas

745
00:31:55,000 --> 00:31:57,000
te crea un objeto coche

746
00:31:57,000 --> 00:31:59,000
porque el método de personas

747
00:31:59,000 --> 00:32:01,000
es comprar coche

748
00:32:01,000 --> 00:32:03,000
entonces crea un coche y te lo devuelve

749
00:32:03,700 --> 00:32:05,700
coche, mi nuevo coche

750
00:32:05,700 --> 00:32:07,700
es igual a persona1.compracoche

751
00:32:11,700 --> 00:32:13,700
compracoche se llama sobre persona1

752
00:32:13,700 --> 00:32:15,700
persona1 compra el coche

753
00:32:15,700 --> 00:32:17,700
y gasta dinero suyo

754
00:32:17,700 --> 00:32:19,700
crea un coche y este coche se guarda

755
00:32:19,700 --> 00:32:21,700
en la variable

756
00:32:21,700 --> 00:32:23,700
haremos ejemplos

757
00:32:23,700 --> 00:32:25,700
por ahora nos paramos aquí

758
00:32:25,700 --> 00:32:27,700
después de recreo vamos a hacer ejemplos

759
00:32:27,700 --> 00:32:29,700
para todas estas cosas