1
00:00:01,389 --> 00:00:02,529
Ya estamos grabando.

2
00:00:04,269 --> 00:00:07,910
No sé si tenéis alguna duda o alguna cosita que me queréis comentar

3
00:00:07,910 --> 00:00:12,189
antes de arrancar a contaros yo cosas por ahí del tema 4.

4
00:00:18,480 --> 00:00:19,559
¿Alguien decía algo por ahí?

5
00:00:23,120 --> 00:00:27,219
Ah, sí, que no hay ninguna cosa que plantear de momento.

6
00:00:27,780 --> 00:00:31,920
Vale, pues nada, pues arranco a contaros cosas entonces.

7
00:00:35,640 --> 00:00:38,740
Bueno, el tema 4 ya lo tenemos abierto desde la semana pasada.

8
00:00:38,740 --> 00:01:03,880
No sé si habéis tenido oportunidad de ir echándole un ojillo. Vamos a hacer un repaso así general. Este tema 4 habla, aquí estamos, es una introducción a la programación orientada a objetos y en verdad es muy complicado arrancar la asignatura si no se empieza a hablar desde el día 1, si vas a hacer cosas con Java ya relacionada con los objetos.

9
00:01:03,880 --> 00:01:06,439
hablar de las estructuras de control

10
00:01:06,439 --> 00:01:07,859
que es verdad que son

11
00:01:07,859 --> 00:01:10,379
los bucles o las condiciones

12
00:01:10,379 --> 00:01:11,579
los if, los switch

13
00:01:11,579 --> 00:01:13,560
porque si

14
00:01:13,560 --> 00:01:16,459
si lo estás utilizando

15
00:01:16,459 --> 00:01:18,099
dentro de una programación orientada a objetos

16
00:01:18,099 --> 00:01:19,780
e intentar evitar

17
00:01:19,780 --> 00:01:21,719
lo que son objetos y lo que son clases

18
00:01:21,719 --> 00:01:23,260
pues en verdad es muy complicado

19
00:01:23,260 --> 00:01:25,420
así que además

20
00:01:25,420 --> 00:01:28,000
considero que es mejor ir introduciendo

21
00:01:28,000 --> 00:01:29,719
todos estos conceptos desde el principio

22
00:01:29,719 --> 00:01:32,060
así que mucho de lo que se habla aquí

23
00:01:32,060 --> 00:01:36,219
pues ya hemos ido trabajando, en cualquier caso le damos otro repaso

24
00:01:36,219 --> 00:01:39,480
más formal y vamos con ello

25
00:01:39,480 --> 00:01:48,260
vamos a crear un proyecto, por ejemplo llamemos tema 4

26
00:01:48,260 --> 00:01:52,859
y así nos vamos apoyando en el IDE para ir haciendo

27
00:01:52,859 --> 00:01:57,159
ir comentando los diferentes contenidos

28
00:01:57,159 --> 00:02:07,189
bueno lo primero de lo que empieza a hablar el tema 4 es la diferencia

29
00:02:07,189 --> 00:02:11,409
entre clase y objeto, como os digo ya lo hemos

30
00:02:11,409 --> 00:02:20,229
tratado estos conceptos, una clase vendría a ser un esquema en el cual definimos cómo

31
00:02:20,229 --> 00:02:25,009
se van a comportar diferentes objetos dentro de nuestro programa. Cuando nosotros arrancamos

32
00:02:25,009 --> 00:02:31,949
un programa, en realidad las clases no se activan, sino que se activan objetos que responden

33
00:02:31,949 --> 00:02:36,669
a las características que hemos definido por una clase en particular. Eso sí, esos

34
00:02:36,669 --> 00:02:42,030
objetos tienen un comportamiento de acuerdo a lo que esté definido en la clase. Y cuando definimos

35
00:02:42,030 --> 00:02:50,289
la clase, recordad, decimos que se compone, digamos, por dos tipos de información. Por un lado,

36
00:02:52,360 --> 00:03:00,490
vamos a llamar clase tarea 4 o clase persona. Por un lado tenemos características o atributos

37
00:03:00,490 --> 00:03:08,289
de la clase y por otro lado tenemos lo que son los métodos o las acciones. Los atributos

38
00:03:08,289 --> 00:03:13,509
son variables pertenecientes a la clase que están disponibles en el ámbito

39
00:03:13,509 --> 00:03:17,729
de toda la clase, es decir, todo atributo que definamos para una clase estará disponible

40
00:03:17,729 --> 00:03:21,789
para trabajar con ellos en métodos que aparezcan

41
00:03:21,789 --> 00:03:25,150
dentro de su ámbito, es decir, de las llaves que encierran a la llave.

42
00:03:25,469 --> 00:03:28,150
Por ejemplo, por una persona diríamos que tenemos public

43
00:03:28,150 --> 00:03:32,189
public string para el nombre.

44
00:03:33,129 --> 00:03:37,909
Es un clásico utilizar la clase persona cuando te pones a explicar cosas de estas.

45
00:03:38,289 --> 00:03:53,669
Ya en este tema, pues vamos a hablar un poquito de lo que son las etiquetas public, tanto para una clase como para un método o para un atributo, como es el caso, pero ahora en un ratín, lo decimos.

46
00:03:53,669 --> 00:03:57,169
las variables típicamente

47
00:03:57,169 --> 00:04:01,250
si son de clase, están definidas en el ámbito de la clase

48
00:04:01,250 --> 00:04:05,909
y si son variables que necesitamos utilizar dentro de un determinado método

49
00:04:05,909 --> 00:04:09,969
vuelve a aparecer aquí la etiqueta public, ya os digo que ahora

50
00:04:09,969 --> 00:04:14,110
comentamos en qué consisten las diferentes posibilidades que tenemos para utilizar public

51
00:04:14,110 --> 00:04:18,410
o alternativas a public, voy a saludar

52
00:04:18,410 --> 00:04:22,430
vamos a poner aquí, esto sería un método, es decir, estos son los dos

53
00:04:22,430 --> 00:04:29,790
bloques que tenemos dentro de una clase. Fijaros que una clase no es, en este caso una clase y en

54
00:04:29,790 --> 00:04:33,949
particular la clase persona que estamos definiendo, no es ninguna persona en particular que vaya a

55
00:04:33,949 --> 00:04:40,290
formar, que vaya a interactuar con otros objetos de mi programa, sino que es el esquema de lo que

56
00:04:40,290 --> 00:04:45,110
van a tener cualquiera de las personas que demos de alta dentro de mi programa, que podrán tener

57
00:04:45,110 --> 00:04:53,180
un nombre, una edad y la posibilidad de saludar. Fijaros que, bueno, pues podríamos definir

58
00:04:53,180 --> 00:04:56,399
variables en diferentes ámbitos. En el ámbito de la clase

59
00:04:56,399 --> 00:04:59,740
en sí, con lo cual está disponible entre las llaves de la clase

60
00:04:59,740 --> 00:05:01,899
y aquí podríamos definir otras variables

61
00:05:01,899 --> 00:05:05,240
int y valor. Si fuera en un momento dado

62
00:05:05,240 --> 00:05:08,120
dentro del saludo necesitáramos un determinado valor.

63
00:05:11,040 --> 00:05:13,379
Esta variable está disponible para el ámbito

64
00:05:13,379 --> 00:05:16,399
del método saludar, mientras estas otras

65
00:05:16,399 --> 00:05:19,560
en el ámbito de la clase. Podríamos decir, bueno, pues

66
00:05:19,560 --> 00:05:22,639
si quiero utilizarla aquí en el método saludar, me resulta

67
00:05:22,639 --> 00:05:24,279
muy cómodo coger y definirla aquí

68
00:05:24,279 --> 00:05:26,600
y ya está, defino aquí todas y también

69
00:05:26,600 --> 00:05:27,899
puedo utilizar y valor aquí

70
00:05:27,899 --> 00:05:30,680
esto tendría dos implicaciones

71
00:05:30,680 --> 00:05:33,040
por un lado, la implicación

72
00:05:33,040 --> 00:05:34,639
de que esta variable

73
00:05:34,639 --> 00:05:36,920
estaría no solo disponible en el método saludar

74
00:05:36,920 --> 00:05:38,740
si consideramos que es una variable

75
00:05:38,740 --> 00:05:40,939
propia de este método y no de toda la clase

76
00:05:40,939 --> 00:05:42,639
sino que otro método

77
00:05:42,639 --> 00:05:44,120
que tuviéramos por aquí, despedirse

78
00:05:44,120 --> 00:05:46,519
también tendría disponible

79
00:05:46,519 --> 00:05:48,560
esa variable, que puede ser

80
00:05:48,560 --> 00:05:49,459
que nos interese

81
00:05:49,459 --> 00:05:53,660
ponerlo con minúscula

82
00:05:55,019 --> 00:06:17,100
Podría ser que no nos interese y luego, por otro lado, a nivel organizativo, las variables que definamos de clase típicamente serán variables que identifiquen a las personas y no variables que momentáneamente podamos necesitar para hacer una determinada tarea, en este caso dentro del método de saludar, como podría ser la variable y valor.

83
00:06:17,100 --> 00:06:31,339
Y valor, en el contexto de saludar, según el algoritmo que estemos desarrollando aquí para saludar, podría ser necesaria, pero y valor no sería algo que identifique a objetos de la clase persona que vayamos definiendo.

84
00:06:31,339 --> 00:06:47,300
Entonces, bajo ese criterio tendríamos que definir los métodos de clase que sí que tengan que ver con características de las personas y si necesitamos otras variables en momentos puntuales dentro de unos métodos para desarrollar su algoritmo, pues los definimos como variables locales.

85
00:06:47,300 --> 00:07:13,399
Dentro de lo que son la sintaxis típica que está un poco acordada a la hora de programar en Java, las clases las ponemos empezando con una letra mayúscula y los métodos con una letra minúscula, con una excepción que son los métodos constructores.

86
00:07:13,399 --> 00:07:17,399
Los métodos constructores se tienen que llamar exactamente igual que la clase.

87
00:07:18,620 --> 00:07:25,279
Entonces aquí podríamos definir un método, public void persona.

88
00:07:28,410 --> 00:07:35,689
Entonces este método, lógicamente si se tiene que llamar, es un método constructor porque tiene el mismo nombre y método que la clase.

89
00:07:36,709 --> 00:07:43,610
Si se tiene que llamar igual y nos obligamos a que las clases empiecen con mayúscula, lógicamente el método constructor tendrá que empezar con mayúscula.

90
00:07:43,610 --> 00:07:51,930
mayúscula y se escapa de el acuerdo digamos que hay para nombrar los métodos en líneas generales

91
00:07:51,930 --> 00:07:56,410
que deberían empezar todos con minúscula. Si ponemos una S mayúscula fijaros que no es un

92
00:07:56,410 --> 00:08:02,170
problema en realidad para el compilador sino que más bien es un convenio a la hora de nombrar

93
00:08:02,170 --> 00:08:08,990
las diferentes funciones en Java y que si lo vemos en minúscula pues rápidamente sepamos

94
00:08:08,990 --> 00:08:18,240
que eso podría llegar a ser un método los métodos constructores recordad mira vamos a poner aquí

95
00:08:18,240 --> 00:08:31,579
otra clase dentro del proyecto que sea la clase inicio vamos a llamarla por ejemplo y en esta

96
00:08:31,579 --> 00:08:37,659
clase inicio vamos a suponer que es el punto de arranque de nuestro proyecto entonces en esta

97
00:08:37,659 --> 00:08:47,679
clase está el método public public static o static public me parece que tiene que ir el static antes

98
00:08:47,679 --> 00:09:05,649
después repasamos un poco toda esta cabecera

99
00:09:05,649 --> 00:09:08,769
del método main, entonces

100
00:09:08,769 --> 00:09:12,230
venimos diciendo que todo proyecto necesita un punto de entrada

101
00:09:12,230 --> 00:09:15,330
que es el método main

102
00:09:15,330 --> 00:09:17,450
aquí es donde vamos a arrancar nuestro programa

103
00:09:17,450 --> 00:09:22,419
en este proyecto hemos definido una clase que es la clase persona

104
00:09:22,419 --> 00:09:24,779
que tiene unas determinadas características

105
00:09:24,779 --> 00:09:28,720
y realiza unas determinadas acciones en forma de métodos

106
00:09:28,720 --> 00:09:30,899
que en realidad todavía no hemos programado nada

107
00:09:30,899 --> 00:09:33,659
uno de los métodos es el método constructor

108
00:09:33,659 --> 00:09:36,639
¿por qué? porque se llama igual que la clase

109
00:09:36,639 --> 00:09:38,899
y luego, bueno, pues tiene otros dos métodos aquí

110
00:09:38,899 --> 00:09:41,700
después vamos poniendo algo de código en ellos

111
00:09:41,700 --> 00:09:44,200
que son el de saludar y despedirse

112
00:09:44,200 --> 00:09:47,799
en nuestro programa ahora mismo, si no venimos al main

113
00:09:47,799 --> 00:09:51,200
tenemos alguna persona que haya cobrado vida

114
00:09:51,200 --> 00:09:54,440
digamos, y empieza a hacer cosas dentro del programa

115
00:09:54,440 --> 00:09:57,000
para dar solución al algoritmo que estamos buscando

116
00:09:57,000 --> 00:09:59,700
pues no, todavía no, pero si en cambio tenemos

117
00:09:59,700 --> 00:10:04,179
un esqueleto aquí de cómo se comportan las personas, es decir,

118
00:10:04,299 --> 00:10:07,259
el comportamiento de toda persona que definamos en nuestro programa

119
00:10:07,259 --> 00:10:14,519
está agrupado en esta clase que es la que hemos llamado de esta forma.

120
00:10:15,659 --> 00:10:19,500
Entonces, ¿en qué momento damos vida a una persona?

121
00:10:19,500 --> 00:10:25,299
Pues definimos un tipo de variable que en este caso va a ser del tipo persona

122
00:10:25,299 --> 00:10:29,500
que justo hemos definido aquí sus parámetros y sus comportamientos

123
00:10:29,500 --> 00:10:34,320
un poquito de forma similar a como definiríamos una variable

124
00:10:34,320 --> 00:10:38,279
de un tipo primitivo, igual que definimos aquí

125
00:10:38,279 --> 00:10:42,460
y es una variable del tipo int, resulta que persona

126
00:10:42,460 --> 00:10:46,519
es una variable del tipo miper, es una variable del tipo

127
00:10:46,519 --> 00:10:50,320
persona, entonces las características que tiene miper serán las que hayamos

128
00:10:50,320 --> 00:10:54,379
definido nosotros aquí en esta clase. Para los tipos

129
00:10:54,379 --> 00:10:57,519
primitivos hemos hablado otros días, no es necesario hacer el new

130
00:10:57,519 --> 00:11:00,659
para los tipos referenciados si que lo es

131
00:11:00,659 --> 00:11:03,980
entonces la clase persona es un tipo referenciado

132
00:11:03,980 --> 00:11:05,980
para el objeto miper

133
00:11:05,980 --> 00:11:09,159
lo primero que tenemos que hacer es hacer un new

134
00:11:09,159 --> 00:11:12,820
que nos hará las reservas que toquen

135
00:11:12,820 --> 00:11:15,659
en memoria RAM para que miper sea capaz

136
00:11:15,659 --> 00:11:17,000
de funcionar dentro del programa

137
00:11:17,000 --> 00:11:21,019
que principalmente se entiende sobre todo

138
00:11:21,019 --> 00:11:24,379
si nos fijamos en sus parámetros pues hará reserva para guardar

139
00:11:24,379 --> 00:11:28,679
estos datos y luego después del new

140
00:11:28,679 --> 00:11:33,379
Java lo que nos demanda es que

141
00:11:33,379 --> 00:11:37,200
le ponga, llamemos a un método que haga una inicialización

142
00:11:37,200 --> 00:11:41,500
si es que corresponde hacer alguna inicialización del objeto que estamos dando

143
00:11:41,500 --> 00:11:44,919
de alta y esa inicialización se hace a través de los constructores

144
00:11:44,919 --> 00:11:49,600
recordad que hemos dicho que el constructor

145
00:11:49,600 --> 00:11:53,519
es un método que se llama igual que la clase, entonces por eso

146
00:11:53,519 --> 00:11:57,200
justo aquí después del new solemos poner persona

147
00:11:57,200 --> 00:12:02,120
en este conjunto lo que estamos haciendo es definir

148
00:12:02,120 --> 00:12:05,500
en el conjunto de esta instrucción, estamos definiendo

149
00:12:05,500 --> 00:12:08,519
un objeto llamado miper en particular

150
00:12:08,519 --> 00:12:12,059
de la clase persona, hacemos las reservas

151
00:12:12,059 --> 00:12:14,779
que correspondan en memoria y llamamos a un método

152
00:12:14,779 --> 00:12:17,559
para la inicialización de este objeto

153
00:12:17,559 --> 00:12:20,799
de la clase persona, que es el método constructor

154
00:12:20,799 --> 00:12:23,620
¿y qué inicialización se producirá? Pues la que

155
00:12:23,620 --> 00:12:29,720
programemos aquí. En relación a los constructores

156
00:12:29,720 --> 00:12:36,799
fijaros que si yo comento esto

157
00:12:36,799 --> 00:12:43,139
este persona me sigue funcionando, me sigue compilando.

158
00:12:43,360 --> 00:12:43,840
¿Qué sucede?

159
00:12:44,019 --> 00:12:50,940
Si, como siempre después de hacer un new en un objeto que es de un tipo referenciado,

160
00:12:51,059 --> 00:12:52,899
como siempre vamos a llamar al constructor,

161
00:12:54,200 --> 00:12:56,000
por defecto, aunque no lo hayamos definido,

162
00:12:56,460 --> 00:12:59,019
en la clase, en este caso la clase persona,

163
00:13:00,360 --> 00:13:03,620
Java entiende que hay un constructor por defecto

164
00:13:03,620 --> 00:13:08,120
que en esa inicialización no viene a hacer nada, digamos.

165
00:13:08,120 --> 00:13:14,720
pero para dar sentido a la sintaxis que tiene java pues existe por defecto un constructor de

166
00:13:14,720 --> 00:13:22,940
este tipo es decir el nombre de la clase y sin ningún parámetro metido aquí en dentro de las

167
00:13:22,940 --> 00:13:31,059
llaves si yo cojo eso es para cuando no existe el de por defecto cuando no existe definido ningún

168
00:13:31,059 --> 00:13:36,899
constructor dentro de la clase persona si yo para inicializar la clase persona me defino un

169
00:13:36,899 --> 00:13:39,840
constructor, pues ese que había por defecto por ahí

170
00:13:39,840 --> 00:13:42,360
queda ya sobrescrito y el que se utiliza

171
00:13:42,360 --> 00:13:46,000
es el que yo define aquí con el código

172
00:13:46,000 --> 00:13:57,990
que yo ponga. Entonces, en el momento que yo ya he definido

173
00:13:57,990 --> 00:14:01,110
un constructor dentro de la clase persona, ese constructor por defecto

174
00:14:01,110 --> 00:14:03,950
al que estaba llamando yo antes cuando no existía ninguno, que era

175
00:14:03,950 --> 00:14:07,009
uno por defecto y no hacía nada, deja

176
00:14:07,009 --> 00:14:10,129
de existir para pasar a existir el que yo ponga

177
00:14:10,129 --> 00:14:12,750
dentro de mi clase. Pero es más,

178
00:14:13,309 --> 00:14:16,070
si yo defino un constructor

179
00:14:16,090 --> 00:14:32,590
que dentro de mi clase que admita y ahora repasamos también estos métodos que admita información entre

180
00:14:32,590 --> 00:14:38,590
los paréntesis ahora hablamos de qué consiste esto esto también desactiva el constructor por

181
00:14:38,590 --> 00:14:44,629
defecto es decir definir cualquier constructor con o sin información entre los paréntesis desactiva

182
00:14:44,629 --> 00:14:49,149
el constructor que por defecto tiene java para cuando no existe ninguno entonces en este caso

183
00:14:49,149 --> 00:15:02,759
me sigue compilando esto, yo esperaba que no me compilase

184
00:15:02,759 --> 00:15:31,100
pues nada de lo dicho, pues sigue compilando

185
00:15:31,100 --> 00:15:35,480
nada, retiro lo dicho, estaba comentando que en el momento que definías

186
00:15:35,480 --> 00:15:42,470
cualquier constructor, que en el momento que definías cualquier constructor con o sin

187
00:15:42,470 --> 00:15:45,629
parámetros, yo pensaba

188
00:15:45,629 --> 00:15:50,250
cosa que por lo que veo según se está comportando el código, era erróneo

189
00:15:50,250 --> 00:15:54,350
que el constructor por defecto quedaba desactivado, en este caso

190
00:15:54,350 --> 00:15:57,549
si hubiera sido como yo decía, esto me debería haber dado error

191
00:15:57,549 --> 00:16:00,570
porque estoy invocando a un constructor por defecto

192
00:16:00,570 --> 00:16:03,070
que no recibe ningún parámetro y en cambio solo

193
00:16:03,070 --> 00:16:06,070
por código tengo definido uno que sí que recibe un parámetro

194
00:16:06,070 --> 00:16:09,429
pero por lo que veo el constructor por defecto solamente

195
00:16:09,429 --> 00:16:11,970
deja de tener sentido el que

196
00:16:11,970 --> 00:16:14,549
nos ofrece Java que no hace nada

197
00:16:14,549 --> 00:16:17,669
si lo sobrescribo dentro de

198
00:16:17,669 --> 00:16:20,289
la clase persona, no si

199
00:16:20,289 --> 00:16:24,049
lo sobrecargo, ahora os comento el tema de la sobrecarga

200
00:16:24,049 --> 00:16:27,870
que es otro constructor con parámetros aquí, pues nada

201
00:16:27,870 --> 00:16:32,009
este seguiría funcionando por lo que se ve aquí, ahora tendríamos

202
00:16:32,009 --> 00:16:36,090
en sí dos constructores a los que podríamos llamar después del

203
00:16:36,090 --> 00:16:39,809
new, fijaros que ambos dos son constructores porque los dos

204
00:16:39,809 --> 00:16:44,090
se llaman como la clase persona, como la clase y este

205
00:16:44,090 --> 00:16:47,850
objeto en el momento de inicializarlo, pues podríamos utilizar

206
00:16:47,850 --> 00:16:51,830
el constructor que no recibe ningún parámetro, que sería este

207
00:16:51,830 --> 00:17:14,069
y para este segundo objeto podríamos utilizar el constructor que si lo recibe vale bien ya entiendo

208
00:17:14,069 --> 00:17:24,559
lo que me está pasando está mi error mirad los los constructores se definen sin tipo aquí ahora

209
00:17:24,559 --> 00:17:36,819
también os comento lo que es el tipo este es public persona no public void a ver si ahora

210
00:17:36,819 --> 00:17:44,690
así que tiene el comportamiento que yo esperaba miras efectivamente en el momento que defino

211
00:17:44,690 --> 00:17:49,029
cualquier constructor ahora repaso lo que me estaba lo que estaba sucediendo para que lo

212
00:17:49,029 --> 00:17:53,269
tengáis claro en el momento que yo defino cualquier constructor con o sin parámetros

213
00:17:53,269 --> 00:17:58,910
recibiéndose por aquí entre los paréntesis el constructor por defecto deja de estar activo

214
00:17:58,910 --> 00:18:04,529
veis ya no me compila por aquí cuando está activo cuando está disponible el constructor por defecto

215
00:18:04,529 --> 00:18:10,650
cuando no existe ningún constructor en la clase en este caso fijaros como ahora tengo comentados

216
00:18:10,650 --> 00:18:15,589
tanto el que no recibe parámetros como el que sí que lo recibe uno y ya me vuelvo a compilar esto

217
00:18:15,589 --> 00:18:21,150
que era la lógica que yo esperaba antes pero mi error es que había puesto aquí un public void

218
00:18:21,150 --> 00:18:27,569
y al momento al poner este voice aquí ya no lo consideraba como el constructor en sí porque los

219
00:18:27,569 --> 00:18:32,490
constructores no tienen ninguna etiqueta de este tipo ahora os comento lo que es el voice este

220
00:18:32,490 --> 00:19:07,599
Aquí lo tenemos. Bueno, pues fijaros cómo hemos dado de alta aquí a dos personas y estos objetos ya sí que son los que van interactuando durante el programa con, bueno, pues para ir haciendo cosas, pues mi per podrá saludar, mi per 2 podrá despedirse y a través de los objetos que hemos dado de alta y hemos inicializado con el constructor, poniendo aquí un punto, pues podemos hacer a sus parámetros o a las funciones que él puede hacer.

221
00:19:08,440 --> 00:19:29,200
¿Qué funciones puede, qué métodos podemos llamar o qué funciones puede hacer un objeto? Pues los que tengamos definido dentro de la clase, más otros que están disponibles en todas las clases de que podamos, que vayamos utilizando dentro de nuestro programa, porque los tienen disponibles como consecuencia de una especie de herencia desde la clase Object.

222
00:19:29,200 --> 00:19:48,259
Como pues el notify, notify all, toString, wait, bueno, todos estos métodos están disponibles para cualquier objeto de cualquier clase, no porque los definamos en sí dentro de la clase, sino porque nos vienen definidos, digamos, desde unas instancias superiores en una jerarquía de clases por herencia.

223
00:19:48,259 --> 00:20:17,380
La herencia, hablaremos de ella más en detalle en siguientes temas, pero viene a consistir en que una clase que definamos, aparte de tener sus características, tiene algunas características porque son clases hijas dentro de una jerarquía de clases que va de arriba a abajo, de clases superiores.

224
00:20:17,380 --> 00:20:29,480
Entonces la clase object es una clase definida en las librerías de Java que implementa unas ciertas cosas que interesa que las tengan disponibles todos los objetos de todos los programas.

225
00:20:29,480 --> 00:20:50,519
Y esa es la razón por la que si ponemos aquí mi per punto, no solamente sale despedir aquí o saludar, que son métodos que he definido ahí o los atributos que tenemos por aquí, sino que nos salen otros métodos como equals, getClass, hasCode y notify que vienen heredados desde esas clases superiores.

226
00:20:50,519 --> 00:21:20,150
Mira, más cosas. Una de las características que tenemos en la programación orientada a objeto es la sobrecarga de métodos. Persona, en este caso que es el método constructor, es un método más de la clase, entonces es posible sobrecargarlo, igual que sería otros métodos que tengamos por aquí.

227
00:21:20,150 --> 00:21:25,849
Vamos a sobrecargar el método saludar, después os cuento para qué sirve el void este que decíamos.

228
00:21:27,190 --> 00:21:47,460
Mira, si yo pongo este código, system.out.println, hola, en este saludo, y aquí pongo un hola2, resulta que el programa no me compila.

229
00:21:47,460 --> 00:22:06,220
¿Y por qué no me compila? Porque si yo ahora cojo aquí y digo miper.saludar, hago una llamada para que el objeto miper salude, para saludar se tiene que ir al esquema de la clase persona a ver cómo tiene que actuar a la hora de saludar.

230
00:22:06,220 --> 00:22:13,539
Y cuando llega aquí dice, tengo un saludar aquí y todo otro saludar aquí, que en principio van a hacer cosas diferentes.

231
00:22:13,980 --> 00:22:21,519
Entonces hay una dualidad de posibilidades que dice, entonces, ¿qué hago? ¿Digo hola por pantalla o digo hola dos?

232
00:22:21,640 --> 00:22:30,019
Esto no lo va a permitir el programa, el compilador nunca, porque como no sabe por dónde tirar, pues lo que nos dice es no compilo.

233
00:22:30,019 --> 00:22:36,079
entonces que tendría que hacer definir un método diferente saludar dos para que me dejara hacer

234
00:22:36,079 --> 00:22:41,259
los lados y saludar para que me dejas hacer el hola sería una alternativa pero ya no sería el

235
00:22:41,259 --> 00:22:46,039
método saludar que es realmente lo que yo quiero hacer tenerlo identificado como saludar en ambos

236
00:22:46,039 --> 00:22:52,579
casos con dos posibilidades distintas como podríamos manejarlo pues sobrecargando el

237
00:22:52,579 --> 00:23:00,839
método saludar sobrecargar el método a saludar implica que de alguna forma cuando vayamos a

238
00:23:00,839 --> 00:23:07,119
hacer una llamada a saludar no haya dudas de si quiere utilizar un código u otro y que técnica

239
00:23:07,119 --> 00:23:13,200
en la que nos permite sobrecargar métodos que tienen el mismo nombre pues que reciban una

240
00:23:13,200 --> 00:23:24,009
serie de parámetros entre los paréntesis entonces por ejemplo yo pongo aquí string ese saludo ahora

241
00:23:24,009 --> 00:23:25,509
ya me compila, como podéis ver.

242
00:23:27,109 --> 00:23:28,150
El hecho de que compila aquí

243
00:23:28,150 --> 00:23:29,990
me permite que ahora

244
00:23:29,990 --> 00:23:31,970
yo si yo llamo a mi

245
00:23:31,970 --> 00:23:34,049
per.saludar y aquí

246
00:23:34,049 --> 00:23:36,109
no paso ningún

247
00:23:36,109 --> 00:23:37,470
parámetro, ninguna información,

248
00:23:38,210 --> 00:23:40,109
ningún dato, cuando se venga

249
00:23:40,109 --> 00:23:41,589
a la clase persona a buscar

250
00:23:41,589 --> 00:23:44,289
que saludar ejecutar, ya no va a haber

251
00:23:44,289 --> 00:23:45,430
lugar a dudas. Este

252
00:23:45,430 --> 00:23:47,769
no espera recibir ninguna información,

253
00:23:47,990 --> 00:23:49,829
con lo cual ejecutaría en este caso este

254
00:23:49,829 --> 00:23:51,490
System.out.println

255
00:23:51,490 --> 00:23:56,210
y este solo se ejecutará en el caso de que entre los paréntesis

256
00:23:56,210 --> 00:24:00,529
a la hora de llamar al método saludar, pasemos un string.

257
00:24:01,750 --> 00:24:14,019
Entonces, si yo cojo y pongo aquí, miper.saludar, buenos días,

258
00:24:18,660 --> 00:24:22,319
ahora estoy llamando al método saludar, pasándole entre paréntesis

259
00:24:22,319 --> 00:24:24,720
una cadena de caracteres, es decir, un string.

260
00:24:24,720 --> 00:24:29,380
Si nos venimos por aquí, este no tiene definido ningún string aquí,

261
00:24:29,380 --> 00:24:31,839
con lo cual no va a ser el código que se va a ejecutar

262
00:24:31,839 --> 00:24:35,400
y este en cambio tiene definido un string que corresponde justo

263
00:24:35,400 --> 00:24:38,579
con la sintaxis de esta llamada

264
00:24:38,579 --> 00:24:41,019
que le estábamos pasando una cadena de caracteres

265
00:24:41,019 --> 00:24:43,980
entonces para este saludar buenos días

266
00:24:43,980 --> 00:24:47,700
ahora vuelvo a no haber dudas que el método

267
00:24:47,700 --> 00:24:50,500
saludar que quiero ejecutar de la clase persona

268
00:24:50,500 --> 00:24:53,680
es este, en este segundo caso nos dirá

269
00:24:53,680 --> 00:24:55,339
uno o la dos

270
00:24:55,339 --> 00:24:58,099
fijaros como si ejecutamos

271
00:24:58,099 --> 00:25:05,480
he ejecutado el programa del otro día

272
00:25:05,480 --> 00:25:20,200
bueno, me ha sacado aquí toda esta información

273
00:25:20,200 --> 00:25:22,420
y fijaros en qué consiste toda esta información

274
00:25:22,420 --> 00:25:23,920
hemos llamado a

275
00:25:23,920 --> 00:25:26,380
dos constructores, este constructor

276
00:25:26,380 --> 00:25:29,809
persona, fijaros como

277
00:25:29,809 --> 00:25:31,650
tiene un hola, con lo cual el primer constructor

278
00:25:31,650 --> 00:25:33,710
me ha mostrado este hola, al crear el

279
00:25:33,710 --> 00:25:34,170
segundo

280
00:25:34,170 --> 00:25:37,809
de los objetos, también he llamado al constructor

281
00:25:37,809 --> 00:25:39,789
que no recibe ningún parámetro, aunque tengo

282
00:25:39,789 --> 00:25:41,630
dos por aquí, me ha vuelto a escribir un segundo

283
00:25:41,630 --> 00:25:45,960
hola, este saludar

284
00:25:45,960 --> 00:25:47,819
al invocar este método

285
00:25:47,819 --> 00:25:52,259
sin parámetros me ha ejecutado este saludar, me ha dicho el tercero de los olas

286
00:25:52,259 --> 00:25:57,559
y este otro que recibía un stream buenos días

287
00:25:57,559 --> 00:26:01,539
me ha ejecutado este otro método y ya me ha puesto el ola2

288
00:26:01,539 --> 00:26:09,400
vale pues, que diferencia

289
00:26:09,400 --> 00:26:13,519
en realidad, que diferencia tenemos entre llamar a uno u otro

290
00:26:13,519 --> 00:26:17,460
pues aquí estamos, bueno antes de contaros eso, fijaros que yo

291
00:26:17,460 --> 00:26:21,500
si yo pongo aquí saludar y le pongo aquí un número

292
00:26:21,500 --> 00:26:25,339
en una cadena de caracteres un 2, pues tampoco me compila. ¿Por qué? Porque

293
00:26:25,339 --> 00:26:29,759
un método saludar que recibe un valor numérico

294
00:26:29,759 --> 00:26:33,900
aquí entero, no está considerado, no está sobrecargado

295
00:26:33,900 --> 00:26:37,640
entre los diferentes métodos saludar que tiene la clase persona, que tiene una sobrecarga

296
00:26:37,640 --> 00:26:41,500
entre un saludar sin parámetros y un saludar que recibe

297
00:26:41,500 --> 00:26:45,539
un string. Pero no hay ningún saludar que reciba un valor

298
00:26:45,539 --> 00:26:49,619
entero. Como no hay ninguno que reciba un valor entero, pues coge y este

299
00:26:49,619 --> 00:26:53,759
no me compila. Si fuese necesario saludar pasándole

300
00:26:53,759 --> 00:26:59,539
aquí un dato, fijaros que, ¿qué tendríamos que hacer? Pues sobrecargar

301
00:26:59,539 --> 00:27:05,180
nuevamente saludar, fijaros que ahora vuelve a no compilarme

302
00:27:05,180 --> 00:27:09,299
porque vuelve a haber una ambigüedad entre dos saludar

303
00:27:09,299 --> 00:27:13,220
que los dos reciben un string, pues podría poner aquí uno que reciba un

304
00:27:13,220 --> 00:27:21,960
entero y volvería a compilarme, ¿por qué? Porque tengo una triple

305
00:27:21,960 --> 00:27:25,819
sobrecarga, uno sin parámetros, uno con un string y otro con un valor entero

306
00:27:25,819 --> 00:27:49,569
Y ahora ya, aquí también, este ya no le importa, también le gusta. Bien, pues ahí tenemos la sobrecarga. ¿Qué sucede con estos? ¿Qué interés tiene, según acabo de hacer ahora, crear valores sobrecargados que reciban aquí cierta información?

307
00:27:49,569 --> 00:28:19,549
Pues el interés puede ser el siguiente, fijaros, si yo, estas variables que definimos aquí dentro de los paréntesis se utilizan dentro del método como variables locales, si yo pongo aquí int y 1, pues 1 sería una variable tipo primitiva de tipo int y estaría disponible para ir utilizando esta variable metiendo valores, datos, utilizándolo para operaciones numéricas,

308
00:28:19,569 --> 00:28:24,890
o lo que correspondiese dentro del ámbito del método saludar, que es donde está definido.

309
00:28:25,650 --> 00:28:33,869
Pues estas variables que aparecen aquí entre los paréntesis son variables de ámbito local al método también.

310
00:28:33,869 --> 00:28:43,049
Es decir, el string eseSaludo pertenece al ámbito del método saludar, de este en particular, de esta sobrecarga del método saludar.

311
00:28:43,910 --> 00:28:48,150
De igual forma, esta variable int y valor pertenecen a este ámbito.

312
00:28:48,150 --> 00:29:14,950
¿Y qué valor tienen? Pues por aquí podríamos ir modificándolo, podríamos poner ese saludo igual que con cualquier otra variable, pues irle dando valores aquí, información, lo que fuese, pero de partida la información que tiene con la información que se cargan en el inicio de la ejecución del método corresponde al dato que pasemos nosotros aquí cuando estemos haciendo la llamada.

313
00:29:14,950 --> 00:29:26,230
Entonces, estos buenos días, en este saludar que está recibiendo una cadena de caracteres, este buenos días se carga directamente en la variable ese saludo.

314
00:29:26,230 --> 00:30:14,869
entonces si yo pongo aquí un system.out.println de ese saludo, para que no me muestre más mensajes, de momento voy a quitar los constructores estos, al quitar esos dos constructores se me queda el constructor por defecto que no hace nada en código, uno disponible siempre, que no recibe ningún parámetro, ¿veis como me sigue compilando?

315
00:30:14,869 --> 00:30:25,319
entonces si yo ahora me llamo al método que recibe

316
00:30:25,319 --> 00:30:28,779
una cadena de caracteres en dos ocasiones

317
00:30:28,779 --> 00:30:33,660
y en uno le paso buenos días y en otro buenas noches, durante la ejecución

318
00:30:33,660 --> 00:30:37,500
de este saludar que recibe un string, este buenos días se cargará

319
00:30:37,500 --> 00:30:41,240
en la variable ese saludo y en la segunda de las ejecuciones

320
00:30:41,240 --> 00:30:45,240
lo que cargará será este buenas noches en la variable ese saludo

321
00:30:45,240 --> 00:30:49,700
de tal forma que nos permite mostrar diferentes saludos

322
00:30:49,700 --> 00:30:52,259
un mismo código

323
00:30:52,259 --> 00:30:53,500
haciendo la misma llamada

324
00:30:53,500 --> 00:30:55,220
en función a

325
00:30:55,220 --> 00:30:58,160
la información que tengamos desde el punto

326
00:30:58,160 --> 00:30:58,900
de la llamada

327
00:30:58,900 --> 00:31:02,180
fijaros como si ejecutamos aquí

328
00:31:02,180 --> 00:31:03,980
pues ahora nos dice una vez buenos días

329
00:31:03,980 --> 00:31:05,160
y otra vez buenas noches

330
00:31:05,160 --> 00:31:10,279
si tenemos aquí el saludar

331
00:31:10,279 --> 00:31:12,980
este que recibe un valor

332
00:31:12,980 --> 00:31:16,390
numérico, pues de igual

333
00:31:16,390 --> 00:31:17,849
forma aquí podríamos coger y decir

334
00:31:17,849 --> 00:31:18,849
vamos a mostrar

335
00:31:18,849 --> 00:31:22,130
el valor, la misma jugada que antes

336
00:31:22,130 --> 00:31:49,869
entonces ahora esto no escribiría siempre un valor, si ponemos aquí que escriba un 2, pues escribiría un 2, pero si ponemos sí valor, lo que nos mostrará es la información de esta variable, esta variable se carga cada vez con el dato que hemos pasado en la llamada, entonces si ahora ponemos aquí un 2 y hacemos otra llamada con un 3, veamos como la ejecución de los métodos nos muestran el dato con la información de las variables

337
00:31:49,869 --> 00:32:17,789
En cuanto a la sobrecarga, también deciros que hemos hecho sobrecarga aquí del método saludar sin parámetros, con un parámetro, con otro parámetro, pues podemos seguir sobrecargándolo en base a que se diferencie el método saludar unas implementaciones de OTT con otras en el número o en el tipo de datos que tengamos.

338
00:32:17,789 --> 00:32:21,609
aquí teníamos un mismo número de datos pero de diferente tipo

339
00:32:21,609 --> 00:32:25,730
con lo cual ya no había ambigüedad aquí a la hora de llamarlo, luego tenemos también la

340
00:32:25,730 --> 00:32:29,049
posibilidad de decir, mira pues quiero uno que

341
00:32:29,049 --> 00:32:35,069
reciba dos parámetros, ese info, entonces

342
00:32:35,069 --> 00:32:39,109
para llamar a este, desde el sitio donde

343
00:32:39,109 --> 00:32:42,470
invocamos el método, pues pondríamos miper.

344
00:32:44,009 --> 00:32:46,990
saludar, fijaros que aquí Eclipse

345
00:32:46,990 --> 00:32:53,369
me está ofreciendo todos los métodos sobrecargados informándome de los tipos de datos que puede

346
00:32:53,369 --> 00:32:58,750
recibir. En particular queremos utilizar este ahora, pues uno que recibe un entero y otro que

347
00:32:58,750 --> 00:33:08,069
recibe un string. Entonces podríamos decir el valor 4 y el string buenas. ¿Y qué sucede con

348
00:33:08,069 --> 00:33:13,150
estos dos valores? Pues supongo que ya lo iréis adivinando por lo que hemos comentado antes. Estos

349
00:33:13,150 --> 00:33:17,170
valores, lo que hacen es directamente cargarse en estas dos

350
00:33:17,170 --> 00:33:21,150
variables. Y valor de inicio valdrá en esta llamada

351
00:33:21,150 --> 00:33:25,109
4 y buenas, este string se cargará en ese

352
00:33:25,109 --> 00:33:29,170
info. Y estas dos serán dos variables locales disponibles

353
00:33:29,170 --> 00:33:32,890
dentro del ámbito del método saludar

354
00:33:32,890 --> 00:33:36,910
de esta versión sobrecargada del método saludar, es decir

355
00:33:36,910 --> 00:33:40,910
en todo el ámbito de sus llaves. Aquí lo podríamos utilizar

356
00:33:40,910 --> 00:33:51,900
para lo que lo que tocase típicamente los constructores que hablábamos antes de ellos

357
00:33:51,900 --> 00:34:08,650
decimos que tienen el nombre de la clase y típicamente existe bueno pues el constructor

358
00:34:08,650 --> 00:34:36,519
por defecto que es un constructor que no recibe ningún dato luego existe el constructor copia y

359
00:34:36,519 --> 00:34:45,260
bueno podríamos llamar el constructor completo que recibe tantos parámetros el completo este sería

360
00:34:45,260 --> 00:35:03,940
constructor copia este el constructor por por defecto y luego el que podríamos llamar

361
00:35:03,940 --> 00:35:17,860
constructor completo que éste recibe tantos parámetros como atributos tenga definida la

362
00:35:17,860 --> 00:35:23,219
clase este tiene dos atributos un string y una edad podría tener más si hubiera más

363
00:35:23,219 --> 00:35:28,840
características particulares de objetos de la clase persona podría tener más en este caso

364
00:35:28,840 --> 00:35:42,940
tiene dos, pues entonces recibiría string snom, vamos a poner, y int y et. Fijaros, tiene dos

365
00:35:42,940 --> 00:35:51,059
atributos, voy a llamar completo, y normalmente este constructor lo que hace es, estos datos los

366
00:35:51,059 --> 00:35:58,480
copia en las variables del objeto que estamos creando. Entonces aquí pondríamos ese nombre,

367
00:35:58,480 --> 00:36:01,800
igual a ese nom

368
00:36:01,800 --> 00:36:10,079
y edad igual a i ed

369
00:36:10,079 --> 00:36:20,280
vamos a pensar un momentito en este, ahora después pasamos al constructor

370
00:36:20,280 --> 00:36:24,119
copia, fijaros, si yo cojo y defino

371
00:36:24,119 --> 00:36:30,760
imaginaos que doy de alta, interrumpidme si tenéis

372
00:36:30,760 --> 00:36:34,860
alguna duda, alguna pregunta que hacerme sobre lo que os voy

373
00:36:34,860 --> 00:36:45,110
contando, damos de alta en nuestro programa una persona

374
00:36:45,110 --> 00:36:51,630
que llamamos MiPer. Justo a esta persona le empezamos a dar características.

375
00:36:51,630 --> 00:37:06,059
Si decimos que tiene un nombre que es Noah y MiPer tiene una edad que es 10 años, por ejemplo.

376
00:37:08,219 --> 00:37:12,320
Hemos dado de alta un objeto para que participe en nuestro programa

377
00:37:12,320 --> 00:37:18,289
llamando a este constructor, ese constructor

378
00:37:18,289 --> 00:37:22,889
es este constructor por defecto, que fijaros, no está haciendo nada, bueno, no es el de por defecto

379
00:37:22,889 --> 00:37:26,369
lo tengo aquí escrito, pero no está haciendo nada, no he puesto código en él

380
00:37:26,369 --> 00:37:30,550
y luego cojo y digo, esta persona, fijaros que

381
00:37:30,550 --> 00:37:34,489
a la hora de hacer este new, me habrá hecho el sistema operativo

382
00:37:34,489 --> 00:37:38,730
una reserva en zona de memoria, con al menos espacio donde guardar

383
00:37:38,730 --> 00:37:42,610
estos datos, entonces, el hecho

384
00:37:42,610 --> 00:37:46,889
de hacer el new, vamos a ponerlo aquí en esta línea, pues igual ha cogido el sistema operativo

385
00:37:46,889 --> 00:37:50,730
y ha dicho en la posición 30.000, la que sea, ¿vale? Pongo aquí 30.000, pero sería la que

386
00:37:50,730 --> 00:37:54,630
en la que encuentre un espacio en memoria RAM el sistema

387
00:37:54,630 --> 00:37:57,809
operativo donde guardar esos datos. Reservo espacio

388
00:37:57,809 --> 00:38:06,860
bueno, sí, reservo espacio

389
00:38:06,860 --> 00:38:11,659
para una persona. El tamaño

390
00:38:11,659 --> 00:38:15,780
de espacio que necesita reservar, pues ya se lo estará archivando el compilador

391
00:38:15,780 --> 00:38:22,079
dejaba que serán menos para estos dos datos. Cuando cojo y escribo el nombre

392
00:38:22,079 --> 00:38:26,340
de NOA, pues de alguna forma se habrá organizado y a partir de la 30.000

393
00:38:26,340 --> 00:38:29,480
seguro que pondrá en algún sitio, guardará el valor de NOA

394
00:38:29,480 --> 00:38:34,099
y cuando le pongo la edad de 10, a partir del 30.000

395
00:38:34,099 --> 00:38:38,179
dentro del rango de memoria que haya reservado

396
00:38:38,179 --> 00:38:42,119
pues seguro que guarda NOA y en algún sitio guardará el 10.

397
00:38:42,699 --> 00:38:46,079
Todo este trocito está a partir del 30.000 dentro del

398
00:38:46,079 --> 00:38:48,440
espacio de memoria que nos habrá hecho de reserva para el new.

399
00:38:49,760 --> 00:38:53,579
Si yo cojo ahora aquí y digo miper2

400
00:38:53,579 --> 00:38:57,239
igual a new persona

401
00:38:57,239 --> 00:39:13,510
y ahora le paso aquí estos datos,

402
00:39:14,590 --> 00:39:18,650
lo que estoy haciendo es con el new una reserva de memoria igual que

403
00:39:18,650 --> 00:39:22,429
pasaba aquí para una persona, en particular va a ser para miper2,

404
00:39:22,429 --> 00:39:26,329
es decir, esta referencia de una persona apuntará a la posición

405
00:39:26,329 --> 00:39:30,050
que toque, y a lo mejor el sistema operativo en este caso ha dicho que es el 40.000

406
00:39:30,050 --> 00:39:35,929
y luego llamo a un constructor que recibe

407
00:39:35,929 --> 00:39:39,949
una cadena de caracteres y un valor numérico, este constructor

408
00:39:39,949 --> 00:39:44,050
resulta que es uno de los disponibles aquí, porque lo tenemos sobrecargado

409
00:39:44,050 --> 00:39:47,750
es este, fijaros como este recibe un string y un valor numérico

410
00:39:47,750 --> 00:39:51,489
¿veis? entonces Valeria donde se cargará?

411
00:39:51,489 --> 00:39:57,340
se cargará en SNOM y el 13 se cargará

412
00:39:57,340 --> 00:40:03,449
en ied, ¿veis? Ahora continuamos con esa ejecución.

413
00:40:07,739 --> 00:40:10,920
Los valores que tiene miper cuando he definido esta primera

414
00:40:10,920 --> 00:40:15,079
persona, como hicimos el new, hemos cargado

415
00:40:15,079 --> 00:40:19,159
en su nombre y en su edad, fijaros que son las variables de clase

416
00:40:19,159 --> 00:40:23,000
de miper, noa y 10, es decir, los hemos cargado en

417
00:40:23,000 --> 00:40:26,940
estas dos variables, ¿veis? Con lo cual, todo el tiempo

418
00:40:26,940 --> 00:40:30,019
que esté disponible el objeto miper,

419
00:40:30,019 --> 00:40:35,260
como estas variables están en este ámbito de ejecución

420
00:40:35,260 --> 00:40:39,400
de toda la clase, los tendremos disponibles. Es decir, ese nombre

421
00:40:39,400 --> 00:40:43,340
si no sobreescribimos su información, valdrá durante

422
00:40:43,340 --> 00:40:47,500
toda la ejecución del objeto, si llamamos

423
00:40:47,500 --> 00:40:51,179
a métodos, valdrá no A y la edad valdrá 10.

424
00:40:53,280 --> 00:40:56,340
¿Qué sucede en este otro? Valeria y 13

425
00:40:56,340 --> 00:41:00,920
que podemos pensar, y de hecho es lo que vamos a hacer, que son el nombre y la edad

426
00:41:00,920 --> 00:41:05,360
que va a tener mi per 2, Valeria y 13 lo estamos metiendo a través del constructor.

427
00:41:06,500 --> 00:41:13,460
Y el constructor guardará en esta variable la información de Valeria y en esta variable el 13.

428
00:41:14,500 --> 00:41:20,219
¿Qué ámbito de ejecución hemos dicho que tienen estas dos variables que están aquí entre los paréntesis?

429
00:41:20,340 --> 00:41:23,139
Hemos dicho que son variables locales a este método.

430
00:41:23,840 --> 00:41:27,920
Con lo cual, una vez que se ejecute este método, estas dos variables desaparecen.

431
00:41:27,920 --> 00:41:32,019
desaparecen. Es decir, que si este ha cogido valeria y este ha cogido 13, cuando llegue el código

432
00:41:32,019 --> 00:41:35,300
aquí, se terminó estas dos variables.

433
00:41:36,039 --> 00:41:40,199
Con lo cual, el nombre no está disponible si lo queremos utilizar por aquí en saludar,

434
00:41:40,199 --> 00:41:44,219
en este otro saludar o en despedir. Para conseguir

435
00:41:44,219 --> 00:41:47,239
que este valeria y este 13 se queden guardados

436
00:41:47,239 --> 00:41:50,280
para el objeto miper2

437
00:41:50,280 --> 00:41:56,500
y tenerlos disponibles en cualquier otro método de la clase,

438
00:41:56,500 --> 00:41:59,440
que lo que hacemos es que esta información

439
00:41:59,440 --> 00:42:02,900
y esta la guardamos en estas otras dos variables

440
00:42:02,900 --> 00:42:07,130
que son las variables de clase. En definitiva hemos hecho

441
00:42:07,130 --> 00:42:10,250
algo parecido en ambos casos. Hemos creado

442
00:42:10,250 --> 00:42:13,150
un objeto miper y miper2. En este hemos

443
00:42:13,150 --> 00:42:15,489
utilizado el constructor por defecto

444
00:42:15,489 --> 00:42:19,230
que no hacía nada y luego

445
00:42:19,230 --> 00:42:20,829
mediante estas dos instrucciones

446
00:42:20,829 --> 00:42:25,349
hemos dado valor a los parámetros

447
00:42:25,349 --> 00:42:29,710
de clase que el objeto miper de la clase persona

448
00:42:29,710 --> 00:42:33,489
tiene. Hemos puesto noa en esta variable, en esta

449
00:42:33,489 --> 00:42:37,269
de clase, y la edad de 10 en esta variable.

450
00:42:38,250 --> 00:42:41,530
Como están definidas en este ámbito, no solamente están

451
00:42:41,530 --> 00:42:45,269
disponibles en el constructor, sino que están disponibles en cualquier otro método de la clase

452
00:42:45,269 --> 00:42:49,010
persona cuando ejecutemos ese código para el objeto

453
00:42:49,010 --> 00:42:52,309
miper. Y en este segundo caso,

454
00:42:52,309 --> 00:42:56,590
a todos los efectos esta línea ha hecho lo mismo que estas tres

455
00:42:56,590 --> 00:43:00,489
para la clase miper2, luego que lo hemos hecho a través de

456
00:43:00,489 --> 00:43:05,289
un constructor, hemos pasado estos datos por aquí, que vendrían a ser el equivalente

457
00:43:05,289 --> 00:43:09,130
de estos dos, y la clase en este constructor

458
00:43:09,130 --> 00:43:13,469
que como decimos, una vez termina su ejecución

459
00:43:13,469 --> 00:43:17,190
ya que se copian en estas variables, si estas variables son de ámbito

460
00:43:17,190 --> 00:43:21,090
local al constructor, desaparecerían, pero al guardarlas

461
00:43:21,090 --> 00:43:24,829
en las variables de clase, pues ya las tenemos disponibles para utilizar

462
00:43:24,829 --> 00:43:28,869
esos datos, Valeria como nombre y 13 como edad

463
00:43:28,869 --> 00:43:32,969
en cualquiera de todos los métodos cuando estemos trabajando

464
00:43:32,969 --> 00:43:38,780
con el objeto miper2 de la clase persona. Cuando termina

465
00:43:38,780 --> 00:43:42,619
esta ejecución, con este new habremos hecho

466
00:43:42,619 --> 00:43:46,739
esta reserva y aquí terminará valiendo en la memoria RAM

467
00:43:46,739 --> 00:43:50,199
Valeria y 13, pero este Valeria y 13

468
00:43:50,199 --> 00:43:53,400
se estarán cargando justo durante la ejecución

469
00:43:53,400 --> 00:43:59,449
del constructor aquí. Entonces este es el que podríamos llamar

470
00:43:59,449 --> 00:44:01,849
no me acuerdo si exactamente es completo como lo llama

471
00:44:01,849 --> 00:44:04,710
la teoría, creo que sí

472
00:44:04,710 --> 00:44:08,710
lo podríamos llamar completo en tanto en cuanto se utiliza

473
00:44:08,710 --> 00:44:11,349
para copiar en el momento que estamos haciendo

474
00:44:11,349 --> 00:44:12,969
una inicialización del objeto

475
00:44:12,969 --> 00:44:17,269
información de tantos parámetros como

476
00:44:17,269 --> 00:44:19,909
de tantos datos como parámetros

477
00:44:19,909 --> 00:44:22,130
tiene la clase persona.

478
00:44:27,340 --> 00:44:29,219
Podría haber otros intermedios, otros constructores

479
00:44:29,219 --> 00:44:31,079
intermedios, pero ya no tienen un nombre

480
00:44:31,079 --> 00:44:32,679
en sí. Es decir, podríamos tener uno

481
00:44:32,679 --> 00:44:35,079
que dijese, mira, vamos a hacer

482
00:44:35,079 --> 00:44:37,280
un constructor persona que reciba un nombre

483
00:44:37,280 --> 00:44:41,349
y no reciba una edad.

484
00:44:41,730 --> 00:44:43,530
Si no recibe una edad, ya no lo consideramos

485
00:44:43,530 --> 00:44:44,730
como el constructor completo.

486
00:44:45,469 --> 00:44:47,369
Nos serviría para, desde el momento en el que estamos

487
00:44:47,369 --> 00:44:49,210
haciendo la inicialización, darle un nombre,

488
00:44:49,809 --> 00:44:51,230
pero esta variable no tendría un dato.

489
00:44:51,849 --> 00:44:53,230
Imaginaros que nuestro programa dice

490
00:44:53,230 --> 00:44:55,329
hay un momento en el que queremos

491
00:44:55,329 --> 00:45:01,650
que todas las personas que se dan de alta con este constructor tengan la edad de 15, pues aquí

492
00:45:01,650 --> 00:45:09,250
podríamos poner y edad igual a 15, con lo cual estaríamos inicializando los dos parámetros, este

493
00:45:09,250 --> 00:45:15,130
como consecuencia del parámetro que se recibe a la hora de llamar al constructor y este siempre con

494
00:45:15,130 --> 00:45:22,139
un valor de 15, en esa situación se podría por ejemplo encontrar una tercera persona que sería

495
00:45:22,139 --> 00:45:27,920
persona miper3, este nombre de los objetos

496
00:45:27,920 --> 00:45:31,159
me estoy inventando unos, hacemos el new como siempre

497
00:45:31,159 --> 00:45:35,679
y ahora llamamos al objeto persona y esta persona

498
00:45:35,679 --> 00:45:40,199
se llama Rubén y no le pasamos un segundo parámetro

499
00:45:40,199 --> 00:45:44,289
pues miper3

500
00:45:44,289 --> 00:45:49,170
el string de Rubén se guardaría en la variable

501
00:45:49,170 --> 00:45:53,449
senom, esta variable senom es local

502
00:45:53,449 --> 00:46:00,489
a este método sobrecargado de la constructor de la clase persona,

503
00:46:00,610 --> 00:46:05,590
con lo cual ese nom desaparece aquí, pero para dejarlo permanente

504
00:46:05,590 --> 00:46:10,309
mientras exista el objeto miper3, lo paso a una variable de clase

505
00:46:10,309 --> 00:46:12,469
que es del ámbito de la clase en su conjunto.

506
00:46:12,469 --> 00:46:15,369
Es decir, copio en ese nombre ese nom.

507
00:46:16,489 --> 00:46:20,730
Y como justo este constructor es el que hemos decidido utilizar

508
00:46:20,730 --> 00:46:23,789
cuando creamos nuevas personas a las que les queremos añadir

509
00:46:23,789 --> 00:46:26,789
un nombre, pero sin darles una edad

510
00:46:26,789 --> 00:46:29,809
por defecto le consideramos una edad 15, imaginaos que eso es lo que

511
00:46:29,809 --> 00:46:32,670
dijese nuestro enunciado del ejercicio, pues aprovechamos

512
00:46:32,670 --> 00:46:35,750
y en el constructor que es momento de inicialización

513
00:46:35,750 --> 00:46:38,949
del objeto, decimos que su edad y edad sea 15

514
00:46:38,949 --> 00:46:41,190
ahora este

515
00:46:41,190 --> 00:46:44,789
ya no sería ninguno de los que

516
00:46:44,789 --> 00:46:47,869
tenemos digamos más estándar, el de por defecto que no recibe nada

517
00:46:47,869 --> 00:46:50,869
el de copia que ahora os cuento y el completo

518
00:46:50,869 --> 00:46:53,909
que tendría tantos parámetros de entrada

519
00:46:53,909 --> 00:46:55,809
como atributos tiene la clase

520
00:46:55,809 --> 00:46:59,829
si tuviéramos 10 atributos aquí, pues fijaros si habría

521
00:46:59,829 --> 00:47:02,590
combinaciones de posibles constructores, un constructor

522
00:47:02,590 --> 00:47:05,690
que le pasas 9 y uno se queda por defecto, otro que le pasas

523
00:47:05,690 --> 00:47:08,730
7, otro que le pasas 7 pero diferentes a los 7

524
00:47:08,730 --> 00:47:11,389
anteriores, habría muchas posibles

525
00:47:11,389 --> 00:47:16,309
combinaciones de posibles parámetros sobrecargados

526
00:47:16,309 --> 00:47:20,309
estos 3, el de por defecto

527
00:47:20,309 --> 00:47:32,139
el completo y el copia. Fijaros, el copia lo que recibe como parámetro es otra persona, ¿veis? Aquí.

528
00:47:37,619 --> 00:47:43,440
Si tenemos aquí, vamos a repasar, este me ha dejado de compilar, sí, porque lo he borrado.

529
00:47:49,050 --> 00:47:58,920
Mirad, vamos a ver el constructor copia. Creamos una primera persona según este modelo, según el constructor por defecto,

530
00:47:58,920 --> 00:48:00,280
el que no recibe ningún parámetro.

531
00:48:02,079 --> 00:48:03,360
Y ahora vamos a crear una segunda persona,

532
00:48:07,070 --> 00:48:08,929
igual a new, persona,

533
00:48:09,130 --> 00:48:11,010
y queremos utilizar el constructor copia.

534
00:48:11,190 --> 00:48:13,369
¿Qué recibe el constructor copia?

535
00:48:13,570 --> 00:48:16,769
Fijaros, recibe una referencia a una persona.

536
00:48:19,460 --> 00:48:21,760
Entonces aquí podríamos poner una referencia a una persona.

537
00:48:21,880 --> 00:48:24,380
¿Quién es una persona anterior que ya existe en mi programa?

538
00:48:24,880 --> 00:48:25,500
Mi per, ¿veis?

539
00:48:26,980 --> 00:48:29,699
Entonces aquí podemos poner mi per.

540
00:48:31,920 --> 00:48:32,880
El programa me compila.

541
00:48:33,480 --> 00:48:34,860
¿Y esto qué sentido tiene?

542
00:48:34,860 --> 00:48:51,039
Pues fijaros, miper es una referencia, es un dedito, es un puntero que está señalando el lugar en la memoria RAM donde se nos ha producido la reserva. ¿Para qué? Para guardar para miper su nombre y su edad.

543
00:48:51,039 --> 00:49:10,360
Es decir, mi per, según este desarrollo de ejemplo que estamos poniendo, sería 30.000. Sería posición de memoria 30.000. A partir de ahí es donde están los datos del objeto mi per. Es decir, a partir de ahí es donde, por ser una persona, mi per tendrá guardado su nombre y su edad.

544
00:49:10,360 --> 00:49:17,059
aquí justo a este constructor de la clase personal le estoy pasando

545
00:49:17,059 --> 00:49:21,159
un valor de una referencia a una persona, es decir, en este caso

546
00:49:21,159 --> 00:49:25,239
porque es el que hemos elegido, hemos hecho el supuesto que nos ha dado

547
00:49:25,239 --> 00:49:28,940
el sistema operativo, es mi per que apunta en la RAM al 30.000

548
00:49:28,940 --> 00:49:33,239
entonces igual que en estos casos, esto era un string que se copiaba en la variable

549
00:49:33,239 --> 00:49:36,780
local que tenemos en el método, pues

550
00:49:36,780 --> 00:49:40,880
esta referencia se copia en la variable local que tenemos en el método constructor

551
00:49:40,880 --> 00:50:01,840
Es decir, aquí P tendrá la posición, tendrá la referencia a donde apunta quien ha llamado y quien ha llamado justo en esta ocasión, porque fijaros que este constructor lo vamos a llamar ahora después más veces, pues en esta ocasión ha llamado mi per.

552
00:50:01,840 --> 00:50:21,449
Entonces, para este caso en particular, p apuntará al mismo sitio donde mi per. Entonces, ¿dónde estará apuntando p? Pues en esta ejecución en particular, para esta, que estoy haciendo aquí, estará llamando p, apuntando p a 30.000.

553
00:50:21,449 --> 00:50:25,050
entonces si yo ahora cojo y digo ese nombre

554
00:50:25,050 --> 00:50:27,570
fijaros, este ese nombre

555
00:50:27,570 --> 00:50:30,989
a quien corresponde, a este atributo

556
00:50:30,989 --> 00:50:33,050
de la clase persona y este

557
00:50:33,050 --> 00:50:36,849
constructor lo estamos llamando para quien, lo estamos llamando

558
00:50:36,849 --> 00:50:39,409
para miper2, con lo cual

559
00:50:39,409 --> 00:50:43,050
si miper2 en el new ha sido 40.000

560
00:50:43,050 --> 00:50:45,329
me dio 40.000 la reserva

561
00:50:45,329 --> 00:50:49,010
ya os digo que 30.000 y 40.000 son datos

562
00:50:49,010 --> 00:50:51,150
inventados, el sistema operativo nos dará el que

563
00:50:51,150 --> 00:50:53,469
el que le parezca según los espacios

564
00:50:53,469 --> 00:50:55,690
que encuentren memoria RAM disponibles en cada momento

565
00:50:55,690 --> 00:50:57,550
no tienen

566
00:50:57,550 --> 00:50:59,469
por qué ser estos números redonditos

567
00:50:59,469 --> 00:51:00,630
que os voy poniendo en el ejemplo

568
00:51:00,630 --> 00:51:05,420
entonces, ese nombre

569
00:51:05,420 --> 00:51:08,039
e iedad

570
00:51:08,039 --> 00:51:09,780
estarán

571
00:51:09,780 --> 00:51:11,440
a partir del

572
00:51:11,440 --> 00:51:13,800
40.000 en una zona de memoria

573
00:51:13,800 --> 00:51:15,739
con un espacio suficiente para guardarle

574
00:51:15,739 --> 00:51:17,099
ese nombre y la iedad

575
00:51:17,099 --> 00:51:19,460
¿de quién? de miperdos

576
00:51:19,460 --> 00:51:21,280
entonces si yo pongo aquí

577
00:51:21,280 --> 00:51:23,579
ese nombre, este ese nombre

578
00:51:23,579 --> 00:51:25,599
corresponderá a ese

579
00:51:25,599 --> 00:51:27,639
posible, ese nombre que tenemos aquí

580
00:51:27,639 --> 00:51:28,860
colgando del 40.000

581
00:51:28,860 --> 00:51:31,480
y aquí diremos que sea igual a

582
00:51:31,480 --> 00:51:33,940
p.eseNombre

583
00:51:33,940 --> 00:51:36,940
p donde nos apuntaba

584
00:51:36,940 --> 00:51:38,539
a 30.000

585
00:51:38,539 --> 00:51:43,110
y a partir de ese 30.000

586
00:51:43,110 --> 00:51:45,550
tiene un nombre, pues el nombre que hay

587
00:51:45,550 --> 00:51:46,630
colgando de 30.000

588
00:51:46,630 --> 00:51:48,369
que es

589
00:51:48,369 --> 00:51:50,309
noa, como veis aquí

590
00:51:50,309 --> 00:51:52,889
esa información del string lo copia

591
00:51:52,889 --> 00:51:57,530
en el nombre perteneciente al objeto que está haciendo la llamada

592
00:51:57,530 --> 00:51:59,210
al constructor, que es miper2.

593
00:51:59,349 --> 00:52:01,329
Con lo cual, lo que estamos haciendo es poner aquí noa.

594
00:52:06,880 --> 00:52:14,019
Y luego cogemos y hacemos aquí uniedad igual a p.iedad.

595
00:52:15,679 --> 00:52:17,659
Nuevamente, p donde apunta a 30.000.

596
00:52:17,800 --> 00:52:21,539
Colgando de 30.000, según la estructura que nos haya dado

597
00:52:21,539 --> 00:52:24,219
el sistema operativo para hacer la reserva para las variables

598
00:52:24,219 --> 00:52:26,159
de clase, hay una edad.

599
00:52:26,159 --> 00:52:30,239
aquí que hemos puesto este 10, que cuelga de 30.000, fijaros

600
00:52:30,239 --> 00:52:33,000
entonces coge este 10 y lo copia ¿dónde?

601
00:52:33,780 --> 00:52:35,440
en iedad, iedad ¿quién es?

602
00:52:35,920 --> 00:52:39,079
esta iedad, ¿de qué objeto está llamando al constructor

603
00:52:39,079 --> 00:52:42,380
en este momento? miper2, que está en el 40.000

604
00:52:42,380 --> 00:52:43,739
entonces 40.000

605
00:52:43,739 --> 00:52:47,659
con el desplazamiento necesario para guardar la edad

606
00:52:47,659 --> 00:52:51,260
nos guardará el dato de 30.000 con el desplazamiento

607
00:52:51,260 --> 00:52:53,179
de la edad, es decir, nos copiará aquí el 10

608
00:52:53,179 --> 00:53:14,320
Entonces, para todos los atributos que tengamos en una clase, el constructor copia lo que hace es guardarnos la información de este objeto que le pasamos como parámetro en los atributos que tiene el nuevo objeto que estamos creando.

609
00:53:14,320 --> 00:53:25,420
Por eso se llama constructor copia. Copiamos la información de este objeto en el nuevo objeto y en todos sus parámetros. Este es el copia.

610
00:53:25,420 --> 00:53:52,369
Si aquí cogiésemos, si hiciésemos persona miper3 igual a new persona y le pasamos p, por ejemplo, de nuevo, miper, perdón, miper2, por ejemplo.

611
00:53:54,349 --> 00:53:59,130
Ahora, para esta ejecución, miper2, que hemos dicho que vale 40.000.

612
00:53:59,130 --> 00:54:02,369
para miper3, gracias a este new

613
00:54:02,369 --> 00:54:06,010
nos hará una reserva, sistema operativo de espacio de memoria

614
00:54:06,010 --> 00:54:08,630
vamos a suponer que sería el 50.000

615
00:54:08,630 --> 00:54:09,909
vamos a dividir de 10.000 en 10.000

616
00:54:09,909 --> 00:54:13,190
con un trozo de memoria por aquí reservado

617
00:54:13,190 --> 00:54:17,289
para guardar información para sus atributos

618
00:54:17,289 --> 00:54:19,710
es decir, para su nombre y para su edad

619
00:54:19,710 --> 00:54:22,210
nombre y edad de quien? de miper3

620
00:54:22,210 --> 00:54:25,710
al constructor le pasamos como referencia

621
00:54:25,710 --> 00:54:28,650
un objeto de una clase persona, miper2 donde apunta

622
00:54:28,650 --> 00:54:40,889
al 40.000. Entonces, en esta segunda ejecución P, en la primera ejecución apuntaba a quien la

623
00:54:40,889 --> 00:54:45,769
había llamado, en ese caso era mi per, pues en este caso, en esta segunda llamada es a mi per 2,

624
00:54:45,769 --> 00:54:53,150
que es en el 40.000. Entonces P sería 40.000 ese nombre, que bueno, como es copia desde el primero,

625
00:54:53,269 --> 00:54:57,090
los datos van a ser los mismos de nuevo, pero en este caso no los va a estar copiando de aquí,

626
00:54:57,090 --> 00:54:58,630
sino que lo va a estar copiando de aquí.

627
00:54:59,269 --> 00:55:00,789
Lo pondría aquí en el 50.000 NOA

628
00:55:00,789 --> 00:55:07,059
y luego la edad sería el 40.000

629
00:55:07,059 --> 00:55:09,800
y la IEDAD a copiarlo en la edad del nuevo.

630
00:55:10,519 --> 00:55:11,820
Con lo cual tendríamos aquí un 10.

631
00:55:14,059 --> 00:55:15,000
Constructor copia.

632
00:55:17,429 --> 00:55:17,889
¿Se entiende?

633
00:55:18,929 --> 00:55:19,429
Más o menos.

634
00:55:21,409 --> 00:55:23,349
Miren el chat, a ver si me decís alguien algo por ahí.

635
00:55:33,400 --> 00:55:36,980
Bueno, pues, a ver, al final yo os voy contando,

636
00:55:37,260 --> 00:55:39,260
bueno, me preguntan para la grabación

637
00:55:39,260 --> 00:55:46,940
que qué sentido tiene poder hacer la copia al final os voy enseñando aquí un poco herramientas

638
00:55:46,940 --> 00:55:54,159
que luego bueno pues pueden pueden ser útiles en algún momento no sé al final hay que hay que

639
00:55:54,159 --> 00:55:59,059
buscar enunciados donde pueda esto tener sentido decir ah pues me viene bien utilizar un constructor

640
00:55:59,059 --> 00:56:11,039
copia. Imaginaros que estamos aquí en clase y tenemos lo que es personas son los alumnos y

641
00:56:11,039 --> 00:56:18,000
resulta que todos los alumnos tienen en lugar de dos parámetros como aquí pues tienen 15 parámetros

642
00:56:18,000 --> 00:56:27,199
y de esos 15, 13 son comunes podrían ser. Pues bueno podríamos utilizar dar de alta 1 aquí y

643
00:56:27,199 --> 00:56:31,139
luego utilizar el constructor copia y hacer las pequeñas modificaciones sobre el nuevo que

644
00:56:31,139 --> 00:56:45,500
correspondiese o yo que sé imaginaros que no sé a ver qué deciros imaginaos que es una clínica

645
00:56:45,500 --> 00:56:55,099
veterinaria y estamos dando de alta cachorros de que tiene pues no sé una mamá perrito no y tiene

646
00:56:55,099 --> 00:56:59,940
10 cachorros y en el mundo de en el momento de partida pues todos los consideras con los mismos

647
00:56:59,940 --> 00:57:04,019
datos. Pues bueno, pues podrías dar de alta uno de los cachorros y luego

648
00:57:04,019 --> 00:57:07,980
dar de alta 10 objetos nuevos, utilizando el

649
00:57:07,980 --> 00:57:11,900
constructor copia, para que los 10 cachorros en ese momento inicial al menos

650
00:57:11,900 --> 00:57:16,260
tuvieran todos el mismo valor. Y luego ya, bueno, pues según vaya evolucionando

651
00:57:16,260 --> 00:57:20,039
el programa, pues a lo mejor alguno irá cambiando sus datos, como podría ser

652
00:57:20,039 --> 00:57:24,440
aquí miper2.el, la edad, pues si cambia de 1, pues cambiarlo

653
00:57:24,440 --> 00:57:27,539
a 15. En este caso ya sobreescribiríamos

654
00:57:27,539 --> 00:57:33,539
la edad que tenía en el constructor copia los constructores son una inicialización de

655
00:57:33,539 --> 00:57:40,800
el objeto según lo estás creando y bueno pues puede ser que en un momento dado fijaros que

656
00:57:40,800 --> 00:57:46,659
sobrecargados tenemos mil alternativas de poner constructores uno que no tenga ningún dato bueno

657
00:57:46,659 --> 00:57:51,039
pues ya se irán rellenando sus parámetros según vaya evolucionando el programa podemos tener

658
00:57:51,039 --> 00:57:53,659
algunos, según nuestro enunciado, que

659
00:57:53,659 --> 00:57:57,139
tenga todos los datos, que

660
00:57:57,139 --> 00:58:00,019
vendría a ser como un constructor copia, pero en lugar de pasar la referencia

661
00:58:00,019 --> 00:58:03,260
pasar todos los datos. Podríamos tener algún constructor

662
00:58:03,260 --> 00:58:05,960
que tuviera un conjunto

663
00:58:05,960 --> 00:58:09,099
de parámetros que no fuesen todos ellos, pero

664
00:58:09,099 --> 00:58:11,940
unos cuantos. Y el definir uno,

665
00:58:12,119 --> 00:58:15,099
dos, diez o los que sean, pues irá

666
00:58:15,099 --> 00:58:17,480
en función a lo que nos demande el enunciado.

667
00:58:18,519 --> 00:58:20,820
Y en un momento dado, pues a lo mejor podría ser que

668
00:58:20,820 --> 00:58:27,360
de unos como base queramos sacar copias para no tener que estar rellenando todos sus parámetros

669
00:58:27,360 --> 00:58:33,059
de golpe pues bueno de partida en el momento inicial aquí es una copia exacta todos sus

670
00:58:33,059 --> 00:58:38,260
parámetros pero a partir de aquí el programa pues podría ir evolucionando cambiando ciertos

671
00:58:38,260 --> 00:58:45,099
parámetros según lo vayamos necesitando y entre todos ellos pues bueno hay tres que se definen

672
00:58:45,099 --> 00:58:49,519
digamos que se les ponen nombres y apellidos porque sí que son siempre iguales el de por

673
00:58:49,519 --> 00:58:53,519
defecto, que es el que no recibe parámetros, el constructor

674
00:58:53,519 --> 00:58:57,320
copia, que es el que recibe una referencia para hacer una copia exacta

675
00:58:57,320 --> 00:59:01,380
de todos sus atributos en el nuevo objeto con el que recibimos por aquí, y el

676
00:59:01,380 --> 00:59:05,519
completo, que en principio se utiliza un poco para lo mismo, pero en lugar de pasar

677
00:59:05,519 --> 00:59:09,480
una referencia a un objeto, pues se le

678
00:59:09,480 --> 00:59:10,739
pasan todos los atributos.

679
00:59:24,719 --> 00:59:27,900
Mirad, más cosillas que os

680
00:59:27,900 --> 00:59:33,739
voy contando. Cuando nosotros estamos definiendo en una clase

681
00:59:33,739 --> 00:59:40,360
su asignatura o su cabecera, típicamente aquí los constructores

682
00:59:40,360 --> 00:59:43,659
no, ahora después llegamos a los constructores. Aquí, bueno,

683
00:59:43,780 --> 00:59:48,019
pues ponemos, ponemos public y ponemos aquí algo. Hasta ahora

684
00:59:48,019 --> 00:59:51,079
casi siempre suele ser el void. Fijaros que main también tiene

685
00:59:51,079 --> 00:59:57,340
void aquí. Los métodos, a la hora de salirnos de un método,

686
00:59:57,340 --> 01:00:00,280
¿Cuándo termina un método?

687
01:00:00,539 --> 01:00:02,300
En el que ponemos aquí la etiqueta void

688
01:00:02,300 --> 01:00:04,400
Pues cuando se realiza toda su ejecución

689
01:00:04,400 --> 01:00:06,300
Y existe la posibilidad de

690
01:00:06,300 --> 01:00:09,099
Utilizar la etiqueta return

691
01:00:09,099 --> 01:00:10,980
La etiqueta return lo que hace es

692
01:00:10,980 --> 01:00:12,059
Me salgo del método

693
01:00:12,059 --> 01:00:13,159
Donde la encuentre

694
01:00:13,159 --> 01:00:14,880
De hecho, si yo pongo aquí

695
01:00:14,880 --> 01:00:17,500
System.out.println

696
01:00:17,500 --> 01:00:23,300
Fijaros que Eclipse me dice

697
01:00:23,300 --> 01:00:24,820
Oye, mira, esto no tiene ningún sentido

698
01:00:24,820 --> 01:00:25,659
Esto que estás haciendo

699
01:00:25,659 --> 01:00:27,159
Porque has puesto aquí una instrucción

700
01:00:27,159 --> 01:00:28,960
Y este código es código muerto

701
01:00:28,960 --> 01:00:30,320
Aquí el programa nunca va a llegar

702
01:00:30,320 --> 01:00:35,079
porque se encuentra antes un retorno esto si quiero que me compile pues bueno pues podría

703
01:00:35,079 --> 01:00:57,150
poner aquí y y igual a 2 poner aquí y y es igual a 2 fijaros cada día si me compila y en cualquier

704
01:00:57,150 --> 01:01:01,630
caso este código según está puesto ahora mismo esto nunca se ejecutaría porque se cumple este

705
01:01:01,630 --> 01:01:09,110
if y siempre se va a salir por el return pero ya el compilador de java o eclipse no se fija en este

706
01:01:09,110 --> 01:01:14,769
caso no se preocupa de evaluar esto sino que ya ve que sí que hay alguna alternativa porque hay

707
01:01:14,769 --> 01:01:20,590
un if y este return está dentro de una estructura de selección con lo cual podría no ejecutarse

708
01:01:20,590 --> 01:01:25,389
siempre imaginaos que esto en lugar de cogerlo por aquí lo estuviéramos cogiendo con un escáner

709
01:01:25,389 --> 01:01:30,230
el valor de i, pues una vez podríamos meter un 2 y otra vez podríamos meter un 5

710
01:01:30,230 --> 01:01:33,730
entonces como ya no siempre sale por el return

711
01:01:33,730 --> 01:01:38,210
esta instrucción podría haber, aunque en este código sí que pasa

712
01:01:38,210 --> 01:01:41,610
tal cual está porque siempre iba a valer 2 si no lo modificamos

713
01:01:41,610 --> 01:01:44,909
pero imaginaos, ya os digo que no, imaginaos que

714
01:01:44,909 --> 01:01:59,619
este código lo tenemos aquí y en lugar de si ponemos iValor

715
01:01:59,619 --> 01:02:05,690
pues aquí ya se da un caso en el que no siempre iValor puede valer 2

716
01:02:05,690 --> 01:02:09,650
porque dependerá del dato que hayamos puesto nosotros cuando hayamos

717
01:02:09,650 --> 01:02:13,530
hecho la llamada, una vez será 2 y otra vez será 10, entonces no siempre

718
01:02:13,530 --> 01:02:17,469
saldría por aquí, ya habría opción de que esto se ejecutase, con lo cual ya me compila

719
01:02:17,469 --> 01:02:21,969
pero resulta que si este valor es cierto, esto no va a suceder

720
01:02:21,969 --> 01:02:25,769
esto se va a salir con el return y no va a pasar por aquí, vamos a hacer

721
01:02:25,769 --> 01:02:30,510
esa ejecución, vamos a poner mi per

722
01:02:30,510 --> 01:02:36,730
punto saludar, ponemos aquí un 2

723
01:02:36,730 --> 01:02:39,010
y lo vamos a poner aquí, un 3.

724
01:02:39,449 --> 01:02:43,010
Vamos a hacer dos llamadas, una que vale 2 y otra que vale 3.

725
01:02:43,829 --> 01:02:50,550
Entonces, la que vale 2, vamos a mostrar aquí el valor.

726
01:02:53,880 --> 01:02:57,000
Una vez valdrá iValor2 y otra vez valdrá iValor3.

727
01:02:58,079 --> 01:03:01,480
Cuando valga 2, se va a salir, y cuando valga 3, no se va a salir,

728
01:03:01,579 --> 01:03:03,139
nos va a mostrar también este mensaje.

729
01:03:06,239 --> 01:03:08,280
Entonces, hacemos esa ejecución, ahí lo tenéis.

730
01:03:08,900 --> 01:03:14,570
Cuando vale 2, nos ha mostrado este iValor2,

731
01:03:14,730 --> 01:03:17,429
pero como era 2, se ha salido con el return y nos ha mostrado este mensaje.

732
01:03:17,429 --> 01:03:22,409
Cuando valía 3, me ha mostrado el 3 y luego me ha mostrado el mensaje.

733
01:03:23,150 --> 01:03:27,789
Es decir, return nos saca de la instrucción, nos saca del método.

734
01:03:28,750 --> 01:03:33,110
No es muy aconsejable poner returns por ahí entre medias del código.

735
01:03:33,110 --> 01:03:38,130
Una vez dicho su función de return, poner returns por aquí por la mitad del código,

736
01:03:38,750 --> 01:03:43,570
porque si este código es muy largo y hace muchas cosas, una cosa así tan sencilla,

737
01:03:43,570 --> 01:03:48,849
podemos perder la referencia de los puntos de salida de los métodos entonces se suele aconsejar

738
01:03:48,849 --> 01:03:57,610
evitar el uso de return así tal cual y que y provocar que el método termine siempre al

739
01:03:57,610 --> 01:04:06,280
finalizar aquí en este en este espacio eso es la recomendación general cuando éste cuando el

740
01:04:06,280 --> 01:04:13,179
método indica que devuelve void quiere decir que este método no devuelve nada es decir cuando lo

741
01:04:13,179 --> 01:04:17,199
llamamos, no se espera ningún retorno

742
01:04:17,199 --> 01:04:20,920
de él. Claro, si ponemos aquí un tipo int,

743
01:04:21,119 --> 01:04:25,219
podríamos poner cualquier tipo, tipos primitivos o tipos referenciados, lo que

744
01:04:25,219 --> 01:04:29,400
pretende decirnos es que saludar va a devolver

745
01:04:29,400 --> 01:04:33,139
aparte de hacer lo que tenga que hacer por aquí, recibiendo información

746
01:04:33,139 --> 01:04:37,099
como variables locales aquí entre paréntesis, va a ser capaz de

747
01:04:37,099 --> 01:04:40,780
devolver un dato, un dato que será de tipo entero

748
01:04:40,780 --> 01:04:57,849
Y para que devuelva algo, utilizamos el método return, pero en este caso no nos vale un return sin ningún dato, porque se espera que retorne, que devuelva un valor entero y se lo tenemos que indicar aquí.

749
01:04:57,849 --> 01:05:09,909
Entonces vamos a poner aquí un 1, ¿veis? Ahora ya me compila. Devuelve un 1. ¿Qué hará esta instrucción? Aparte de sacarnos del código, devuelve un 1. Ahora vemos dónde capturamos este 1.

750
01:05:09,909 --> 01:05:16,869
típicamente igual que antes con el consejo que os daba el return es que los return aparezcan al

751
01:05:16,869 --> 01:05:22,329
final del método no en cualquier sitio por el intermedio para que no se nos salga de un método

752
01:05:22,329 --> 01:05:27,090
en sitios que sea más difícil de localizar el por qué se ha ido cuando estemos haciendo un

753
01:05:27,090 --> 01:05:35,570
mantenimiento o un testeo del programa este return que es un entero aquí se captura justo en el sitio

754
01:05:35,570 --> 01:05:38,690
de llamada y lo devuelve la llamada hacia la izquierda.

755
01:05:40,230 --> 01:05:41,530
Es decir, nosotros aquí estamos llamando

756
01:05:41,530 --> 01:05:44,309
al método. Fijaros, estamos llamando al método

757
01:05:44,309 --> 01:05:45,969
que recibe como parámetro un entero

758
01:05:45,969 --> 01:05:50,369
que corresponde a este, con lo cual el que nos está ejecutando es este.

759
01:05:51,449 --> 01:05:53,409
Antes teníamos aquí void que no devolvía nada

760
01:05:53,409 --> 01:05:55,230
pero ahora hemos dicho que devuelve un entero.

761
01:05:56,429 --> 01:05:59,369
Y si ya le decimos que devuelve un entero, es obligatorio meter una instrucción

762
01:05:59,369 --> 01:06:01,449
return para que nos compile.

763
01:06:02,449 --> 01:06:05,329
Y es necesaria una instrucción return

764
01:06:05,329 --> 01:06:10,449
junto con un valor del tipo que hayamos indicado aquí en la cabecera

765
01:06:10,449 --> 01:06:15,460
que devuelve. Si ponemos ahí un return1, ya le va gustando. ¿Por qué?

766
01:06:15,519 --> 01:06:17,679
Porque un 1 es un valor de tipo entero.

767
01:06:19,440 --> 01:06:23,559
Esto que devolvemos, ¿dónde lo tenemos? Pues lo obtenemos

768
01:06:23,559 --> 01:06:27,860
en la llamada y es como si lo ejecutase y lo devolviese hacia la izquierda.

769
01:06:28,739 --> 01:06:31,300
Entonces, si yo pongo aquí un int y

770
01:06:31,300 --> 01:06:37,059
valor devuelto, una vez que se ejecute este,

771
01:06:37,059 --> 01:06:42,039
hace la llamada para el método saludar del objeto

772
01:06:42,039 --> 01:06:45,440
miper, hará todo el código que sea

773
01:06:45,440 --> 01:06:49,920
en el momento en el que hace un return, con lo cual termina el método y devuelve un 1

774
01:06:49,920 --> 01:06:56,409
tipo entero, valor que lo devuelve

775
01:06:56,409 --> 01:07:00,670
en la llamada hacia la izquierda, con lo cual lo estoy cargando en esta variable

776
01:07:00,670 --> 01:07:04,750
yo podría poner aquí un system.out.println

777
01:07:04,750 --> 01:07:24,739
valor devuelto, entonces si yo ejecuto

778
01:07:24,739 --> 01:07:32,590
ahora, ¿veis? Valor devuelto, 1, 1. Este valor devuelto

779
01:07:32,590 --> 01:07:36,510
es como consecuencia de este, ¿y por qué me ha puesto aquí

780
01:07:36,510 --> 01:07:39,909
1, 1? Porque lo que ha cargado y valor, que es lo que me ha devuelto, saludar 2.

781
01:07:43,510 --> 01:07:47,309
Imaginaos que este saludar, en lugar

782
01:07:47,309 --> 01:07:50,010
de ser un método saludar, pues fuese algo que

783
01:07:50,010 --> 01:07:54,809
bueno, algo que tiene alternativas, ¿no? Imaginaos que

784
01:07:54,809 --> 01:07:59,250
estamos intentando pedir nombres, imaginaos que

785
01:07:59,250 --> 01:08:05,429
estamos pidiendo nombres por teclado y pues con el escáner hacemos la solicitud y hay un

786
01:08:05,429 --> 01:08:13,469
momento en el que decimos y si el nombre este en este nombre que no voy a ponerme no voy a

787
01:08:13,469 --> 01:08:17,729
poner por teclado por no andar enredando porque ya lo conocemos imaginaos que lo estamos cogiendo por

788
01:08:17,729 --> 01:08:24,810
ejemplo por teclado vale una varía y lo cargamos en una variable ponemos aquí que se puede recibir

789
01:08:24,810 --> 01:08:31,989
a Ana en un caso y en otro caso se pueda recibir Mila, por ejemplo.

790
01:08:32,710 --> 01:08:36,869
Entonces podríamos decir, sí, ya os digo que aquí lo he puesto

791
01:08:36,869 --> 01:08:39,630
de esta forma, pero aquí podríamos poner un escáner para que esto

792
01:08:39,630 --> 01:08:42,250
fuera variable entre los nombres que se fueran metiendo.

793
01:08:43,289 --> 01:08:49,659
Entonces pusiéramos aquí, si ese nombre, punto, equals a Ana,

794
01:08:53,930 --> 01:08:56,409
aquí podríamos hacer lo que tocase con Ana, guardarlo en una base

795
01:08:56,409 --> 01:08:59,050
de datos, en un fichero, hacer el procesamiento que fuese,

796
01:08:59,050 --> 01:09:03,310
pero podríamos querer que aparte de hacer lo que fuese

797
01:09:03,310 --> 01:09:07,029
por aquí, que desde el sitio donde se llama

798
01:09:07,029 --> 01:09:11,109
fuésemos capaces de saber si se ha devuelto Ana o se ha escrito

799
01:09:11,109 --> 01:09:15,369
Ana o se ha escrito Mila, pues entonces podríamos coger e identificarlo

800
01:09:15,369 --> 01:09:20,649
de esta forma, es decir, en ese caso return un 1

801
01:09:20,649 --> 01:09:24,649
un 1 es un código que estamos asociando a Ana

802
01:09:24,649 --> 01:09:28,430
else, si no

803
01:09:28,430 --> 01:09:31,590
un return de un 2

804
01:09:31,590 --> 01:09:33,609
y un 2 podría ser un código que

805
01:09:33,609 --> 01:09:35,609
estuviésemos asociando a Mila

806
01:09:35,609 --> 01:09:39,500
fijaros que ahora como hay

807
01:09:39,500 --> 01:09:40,359
dos return aquí

808
01:09:40,359 --> 01:09:43,760
en una instrucción

809
01:09:43,760 --> 01:09:45,119
de selección

810
01:09:45,119 --> 01:09:47,579
y no hay más alternativas que estar 2

811
01:09:47,579 --> 01:09:49,340
esto vuelve a no compilarme, ¿por qué?

812
01:09:49,399 --> 01:09:51,779
porque dice aquí este código es muerto, aquí nunca va a llegar

813
01:09:51,779 --> 01:09:53,479
el código, vamos a quitarlo de momento

814
01:09:53,479 --> 01:09:58,119
entonces aparte de hacer aquí lo que quisiésemos

815
01:09:58,119 --> 01:10:00,100
porque es Ana y porque es Mila

816
01:10:00,100 --> 01:10:01,460
pues a lo mejor guardar

817
01:10:01,460 --> 01:10:07,220
en un fichero hola, porque Ana

818
01:10:07,220 --> 01:10:11,000
siempre dice hola. Y en este caso podríamos guardar en un fichero adiós, porque

819
01:10:11,000 --> 01:10:15,239
Mila siempre se despide. Aparte de eso, puede ser que

820
01:10:15,239 --> 01:10:19,199
esas son las acciones que queremos que pasen aquí en el método saludar, pero puede ser que

821
01:10:19,199 --> 01:10:22,979
aquí, según haya sido uno u otro, haya sido Ana o Mila,

822
01:10:23,439 --> 01:10:27,079
podemos coger y decir, mira, queremos que pasen también cosas. Entonces aquí podríamos hacer

823
01:10:27,079 --> 01:10:30,619
una valoración de if y valor de if

824
01:10:30,619 --> 01:10:35,579
es igual a 1, entonces sé que ha sido Ana

825
01:10:35,579 --> 01:11:00,949
y si no, si no es 1 es porque será 2

826
01:11:00,949 --> 01:11:04,710
en este caso no hay más alternativas porque saludar solo devuelve eso

827
01:11:04,710 --> 01:11:14,760
entonces vamos a hacer una ejecución con Ana, dato que podríamos por ejemplo

828
01:11:14,760 --> 01:11:19,079
estar cogiendo el de teclado, aquí lo tenemos puesto a fuego digamos en la variable

829
01:11:19,079 --> 01:11:22,960
entonces hacemos una ejecución con Ana, pues fijaros como

830
01:11:22,960 --> 01:11:26,600
nos dice aquí ha sido Ana, y si en cambio

831
01:11:26,600 --> 01:11:36,850
ponemos aquí que sea mila, pues nos dice así dos mila

832
01:11:36,850 --> 01:11:41,149
es decir, gracias al valor devuelto por un método

833
01:11:41,149 --> 01:11:45,189
que lo devuelve con el método, con la instrucción

834
01:11:45,189 --> 01:11:49,329
return y en el sitio de la llamada lo devuelve

835
01:11:49,329 --> 01:11:53,609
hacia la izquierda una vez que termina, aquí ponemos una variable del mismo tipo que devuelve

836
01:11:53,609 --> 01:11:57,050
pues lo podemos capturar y aquí seguir haciendo un procesamiento

837
01:11:57,050 --> 01:12:01,250
en función de lo que haya pasado aquí, algo muy típico pues imaginaros que

838
01:12:01,250 --> 01:12:05,470
más que aquí el ejemplo este de Mila y Ana, pues imaginaros

839
01:12:05,470 --> 01:12:08,409
que esto es insertar en base de datos

840
01:12:08,409 --> 01:12:11,390
un dato, una información. Pues durante la

841
01:12:11,390 --> 01:12:13,729
inserción en la base de datos, para ver si se queda registrado,

842
01:12:14,649 --> 01:12:17,369
puede ser que de repente no haya acceso a la base de datos

843
01:12:17,369 --> 01:12:20,670
y no se puede hacer. Pues a lo mejor nos devuelve en ese caso el método

844
01:12:20,670 --> 01:12:23,510
en este int que he puesto un 1 para Mila

845
01:12:23,510 --> 01:12:26,829
y un 2 para Ana, pues nos puede devolver el código 65

846
01:12:26,829 --> 01:12:29,510
que es imposibilidad de acceder a la base

847
01:12:29,510 --> 01:12:32,350
de datos y el código 66 que es

848
01:12:32,350 --> 01:12:35,189
vamos, que podría ser según

849
01:12:35,189 --> 01:12:36,850
tuviéramos definido en

850
01:12:36,850 --> 01:12:41,390
una serie de posibles errores

851
01:12:41,390 --> 01:12:44,430
al acceder a la base de datos, el 66 que pudiera ser

852
01:12:44,430 --> 01:12:47,390
no tienes privilegios para insertar registros

853
01:12:47,390 --> 01:12:50,750
en la base de datos y a lo mejor el código 0 cuando ha ido bien

854
01:12:50,750 --> 01:12:53,930
pues entonces, si de la llamada

855
01:12:53,930 --> 01:12:56,569
al método, en este caso saludar, que sería

856
01:12:56,569 --> 01:12:59,689
insertar en base de datos, aquí nos devuelve

857
01:12:59,689 --> 01:13:02,430
un cero, pues podemos decir el proceso ha ido correcto

858
01:13:02,430 --> 01:13:05,550
y si nos devuelve un valor distinto, pues a lo mejor podemos

859
01:13:05,550 --> 01:13:08,310
no seguir haciendo ciertas operaciones que vendrían

860
01:13:08,310 --> 01:13:11,409
a continuación de haber hecho esa inserción en la base

861
01:13:11,409 --> 01:13:16,659
de datos. Aquí, fijaros que antes os he dicho

862
01:13:16,659 --> 01:13:19,460
no es muy aconsejable ir poniendo returns

863
01:13:19,460 --> 01:13:22,880
por ahí por el código. ¿Cómo sería la forma correcta

864
01:13:22,880 --> 01:13:24,859
para intentar evitar que esto pasase?

865
01:13:26,039 --> 01:13:28,500
Poner un solo return al final que es

866
01:13:28,500 --> 01:13:33,020
lo que está más aconsejado, pues mirad lo que podríamos hacer es lo siguiente

867
01:13:33,020 --> 01:13:36,260
para poner un solo return y tener la garantía de que se nos va a ir

868
01:13:36,260 --> 01:13:40,779
justo antes de finalizar el método, lo que podríamos hacer aquí

869
01:13:40,779 --> 01:13:46,880
es definir una variable aquí int i result del mismo

870
01:13:46,880 --> 01:13:51,020
tipo que el que tenemos aquí y aquí en lugar de ir haciéndolo return

871
01:13:51,020 --> 01:13:55,020
pues hacer aquí un i result igual a 1

872
01:13:55,020 --> 01:13:58,939
que es el que identifica en este ejemplo que ha sido

873
01:13:58,939 --> 01:14:01,500
ana y poner aquí un irresult

874
01:14:01,500 --> 01:14:07,000
igual a 2, ahora no nos compila, fijaros que no nos compila ahora mismo

875
01:14:07,000 --> 01:14:10,100
el método, ¿por qué? porque esperamos que devuelva un entero

876
01:14:10,100 --> 01:14:14,720
y como no estamos con un return devolviendo un entero, pues no se queja, pero

877
01:14:14,720 --> 01:14:20,579
lo que vamos a poner aquí es un return de irresult y así

878
01:14:20,579 --> 01:14:24,439
conseguimos que solamente hay un return en todo el método, vamos guardando el valor

879
01:14:24,439 --> 01:14:28,239
que luego vamos a devolver en una variable que podemos definir aquí en la cabecera

880
01:14:28,239 --> 01:14:33,020
del método, en la parte de arriba, y luego hacer un return de esa variable.

881
01:14:37,750 --> 01:14:42,149
Igual que aquí estamos devolviendo un int, cuando no nos interesa que un método devuelva nada,

882
01:14:42,310 --> 01:14:46,930
simplemente queremos su gestión, lo que tenga que hacer por aquí según su algoritmo,

883
01:14:47,449 --> 01:14:52,369
pero que no devuelva nada, porque no hay nada pendiente que hacer según le haya ido al método,

884
01:14:52,529 --> 01:14:55,369
pues en ese caso es cuando utilizamos la etiqueta void.

885
01:14:57,090 --> 01:15:01,750
Y si en lugar de devolver un entero queremos que devuelva otro tipo de datos,

886
01:15:01,750 --> 01:15:07,069
pues puede ser otro tipo de datos puede haber un método saludar que devuelve un string pues entonces pondremos aquí

887
01:15:07,750 --> 01:15:09,250
public

888
01:15:09,250 --> 01:15:10,970
string

889
01:15:10,970 --> 01:15:18,340
saludar vamos a poner esta string

890
01:15:18,899 --> 01:15:26,180
en este caso lo que devolvería sería un string y ahora ha dejado de compilarme porque lo que estoy devolviendo aquí es un tipo de

891
01:15:26,180 --> 01:15:29,020
datos numérico cuando lo que le he dicho aquí en la

892
01:15:29,600 --> 01:15:33,579
cabecera en la firma del método es que se espera que devuelva un string

893
01:15:33,579 --> 01:15:46,920
bueno en este caso si es lo que nos interesa se podríamos poner aquí un string ese result un

894
01:15:46,920 --> 01:15:53,020
poco llevando la misma funcionalidad de antes no entonces esto tendría que devolver tendría

895
01:15:53,020 --> 01:16:06,420
que ser una variable de este tipo string y luego devolveríamos aquí ese resulto y un método puede

896
01:16:06,420 --> 01:16:13,439
devolver tipos primitivos o puede ahora este no le gusta aquí porque ya esto como devuelve un

897
01:16:13,439 --> 01:16:24,390
string y estoy cargando un entero pues ya dice que no vamos a poner esto para que compile si

898
01:16:24,390 --> 01:16:29,550
no pongo nada aquí a la izquierda de la llamada que supone pues que el método en verdad devolverá

899
01:16:29,550 --> 01:16:35,430
el string en este caso el entero antes pero como no lo capturó por aquí en ningún sitio pues como

900
01:16:35,430 --> 01:16:45,739
que se pierde y luego también podríamos tener la posibilidad de devolver tipos referenciados

901
01:16:45,739 --> 01:17:04,399
Esto en realidad podría devolver una referencia a una persona. Imaginaos que estamos en un contexto en el que es un club de patinaje y es un método donde damos de alta a nuevos socios.

902
01:17:04,399 --> 01:17:08,439
entonces este método podría ser el método de dar de alta, por aquí podríamos ir

903
01:17:08,439 --> 01:17:12,939
recuperando todos los datos que iríamos cargando en un objeto de la clase

904
01:17:12,939 --> 01:17:17,079
persona y luego el return nos podría devolver

905
01:17:17,079 --> 01:17:20,880
ese objeto, entonces estaríamos devolviendo en lugar de un entero o un string

906
01:17:20,880 --> 01:17:24,340
como antes, estaríamos devolviendo una referencia a una persona

907
01:17:24,340 --> 01:17:30,439
para asignársela a una persona que hayamos dado por aquí de alta, sería una

908
01:17:30,439 --> 01:17:34,699
referencia parecida a la que estábamos pasando aquí como parámetro de entrada

909
01:17:34,699 --> 01:17:39,359
la posición de memoria de una persona que se ha creado en ese caso

910
01:17:39,359 --> 01:17:43,539
dentro del método, la estoy devolviendo para que esté disponible

911
01:17:43,539 --> 01:17:47,640
desde el sitio donde se llamó, es decir, digamos la operación inversa

912
01:17:47,640 --> 01:17:50,699
lo que hemos hecho cuando lo hemos pasado como parámetro. Aquí

913
01:17:50,699 --> 01:17:55,159
una persona de alta en el ámbito este del main

914
01:17:55,159 --> 01:17:59,300
se lo estábamos pasando para que estuviera disponible su posición de memoria

915
01:17:59,300 --> 01:18:03,619
y poder trabajar con ella dentro del método. Y lo otro

916
01:18:03,619 --> 01:18:18,199
si devolvemos con el return una referencia a una persona, lo que estamos haciendo es dar de alta a la persona en el método y con el return devuelvo la posición de memoria para que pueda estar disponible desde donde se llama.

917
01:18:18,199 --> 01:18:39,359
en este caso sería desde el main, si se entiende, por ahí bien, mira si nos venimos aquí al método

918
01:18:39,359 --> 01:18:51,250
main tenemos aquí un touch un poco grande de información y de etiquetas aunque de bastante

919
01:18:51,250 --> 01:18:56,229
ya hemos ido hablando, fijaros main que lo hemos escrito muchas veces hasta ahora pero no habíamos

920
01:18:56,229 --> 01:19:03,430
no nos habíamos parado a repasarlo es un método que devuelve void, como devuelve void fijaros que

921
01:19:03,430 --> 01:19:08,430
cuando ponemos por aquí el main nunca tiene un retorno es necesario podríamos poner un

922
01:19:08,430 --> 01:19:15,529
retorno cuando cuando no devuelve nada puedes poner el retorno y le vale o no ponerlo y ya

923
01:19:15,529 --> 01:19:20,210
está y cuando llega aquí termina si devuelve algo no nos vale no poner retorno obligatoriamente

924
01:19:20,210 --> 01:19:26,869
tenemos que poner un retorno con el tipo de datos entonces main es un boite fijaros como el método

925
01:19:26,869 --> 01:19:29,949
main para su ejecución recibe aquí una información

926
01:19:29,949 --> 01:19:34,640
que será, en este caso es

927
01:19:34,640 --> 01:19:37,739
args es un array

928
01:19:37,739 --> 01:19:40,659
de cadenas de caracteres. Entonces

929
01:19:40,659 --> 01:19:43,800
args será una variable de este tipo, como

930
01:19:43,800 --> 01:19:46,800
decimos, array de cadenas de caracteres que estará disponible como

931
01:19:46,800 --> 01:19:49,460
variable local dentro del ámbito del main,

932
01:19:49,720 --> 01:19:52,239
es decir, entre esta apertura de llave y este cierre.

933
01:19:53,680 --> 01:19:55,000
Lo mismo que decíamos aquí.

934
01:19:57,239 --> 01:20:00,100
Ese saludo, en este caso era un string disponible

935
01:20:00,100 --> 01:20:03,939
como variable local en el ámbito de este método saludar, entre su apertura

936
01:20:03,939 --> 01:20:10,930
y cierre de llaves. En estos métodos, saludar

937
01:20:10,930 --> 01:20:14,909
cuando cargábamos este dato, lo cargábamos en el momento en el que hacíamos la llamada

938
01:20:14,909 --> 01:20:18,970
a saludar, que era tal que por aquí, en estos ejemplos

939
01:20:18,970 --> 01:20:23,310
que teníamos por aquí. Aquí llamamos al método saludar y en la llamada le pasábamos

940
01:20:23,310 --> 01:20:26,609
el dato que se va a cargar como

941
01:20:26,609 --> 01:20:30,989
la información que se va a cargar en esta variable, que es una variable local a la ejecución del

942
01:20:30,989 --> 01:20:38,930
método. En main, exactamente lo mismo. Aquí tenemos una variable que se carga en el momento en el que

943
01:20:38,930 --> 01:20:44,710
main es llamado. Lo que pasa es que el main, justo como es el punto de entrada del programa, no es código

944
01:20:44,710 --> 01:20:49,010
que pongamos nosotros para llamar, sino que directamente se llama en el momento en el que se invoca el

945
01:20:49,010 --> 01:20:56,750
programa. Con lo cual, ¿en qué momento ARS-S cogerá información para su ejecución? Pues la coge en el

946
01:20:56,750 --> 01:21:03,130
momento en el que estamos lanzando su ejecución y en alguna práctica anterior creo que habíamos

947
01:21:03,130 --> 01:21:16,340
hablado que si nosotros venimos aquí a invocar la llamada a nuestro programa vamos al word

948
01:21:16,340 --> 01:21:20,680
escape base de eclipse como hemos dicho otras veces vamos al ejercicio con el que estamos entre

949
01:21:20,680 --> 01:21:29,920
manos tema 4 ls dentro del proyecto tema 4 tenemos en src los códigos fuente los puntos java y en el

950
01:21:29,920 --> 01:21:35,140
los ejecutables. Fijaros que tenemos la clase inicio

951
01:21:35,140 --> 01:21:38,779
y la clase persona, con su extensión .class

952
01:21:38,779 --> 01:21:42,840
que si intentamos visualizarlo, more es un comando

953
01:21:42,840 --> 01:21:46,159
de Linux que nos muestra sin editar los ficheros

954
01:21:46,159 --> 01:21:49,640
si ponemos more persona.class, pues fijaros como

955
01:21:49,640 --> 01:21:54,720
es bytecode, una vez el código ya compilado no se ve exactamente

956
01:21:54,720 --> 01:22:01,369
el mismo código que tenemos aquí escrito. Entonces si nos venimos aquí

957
01:22:01,369 --> 01:22:16,300
voy a comentar todo el código del main, ahí está

958
01:22:16,300 --> 01:22:20,399
todo el código comentado, para que solo tener esto que ponemos, entonces si ponemos

959
01:22:20,399 --> 01:22:26,859
aquí un system.out.println de rs

960
01:22:26,859 --> 01:22:35,720
0, se llama inicio

961
01:22:35,720 --> 01:22:40,180
fijaros, entonces el bytecode de la clase inicio.java

962
01:22:40,180 --> 01:22:43,720
pues será inicio.class, llamamos a java, inicio

963
01:22:43,720 --> 01:22:49,560
y me da un error, ahora os cuento el error, si yo pongo

964
01:22:49,560 --> 01:22:53,600
inicio hola, fijaros como me muestra por pantalla hola

965
01:22:53,600 --> 01:22:57,180
que he mostrado, la posición 0

966
01:22:57,180 --> 01:23:01,859
del array RS, que se ha cargado en la posición 0 del array RS

967
01:23:01,859 --> 01:23:05,659
se ha cargado este parámetro

968
01:23:05,659 --> 01:23:09,819
que le he pasado cuando he llamado al programa, si yo pongo

969
01:23:09,819 --> 01:23:15,310
java inicio hola adiós

970
01:23:15,310 --> 01:23:22,479
y también muestro la posición 1 del array RS

971
01:23:22,479 --> 01:23:26,420
que es, recordad, ars es un array de strings

972
01:23:26,420 --> 01:23:32,210
salvo por aquí el programa para que me actualice el

973
01:23:32,210 --> 01:23:36,130
bytecode, entonces fijaros como ya me muestra hola y adiós, este hola corresponde

974
01:23:36,130 --> 01:23:39,350
a la posición 0 del array, esta

975
01:23:39,350 --> 01:23:45,649
y este adiós corresponde a la posición 1, si yo ahora aquí, si yo hago

976
01:23:45,649 --> 01:23:49,829
una ejecución en la que pongo esto, quitando el adiós

977
01:23:49,829 --> 01:23:53,649
me muestra el hola, la posición 0 y me da

978
01:23:53,649 --> 01:23:57,350
un error, que es cuando intenta acceder a la posición 1 del array

979
01:23:57,350 --> 01:24:01,470
¿por qué no existe la posición 1? pues porque no le he pasado un segundo parámetro, esto ha cargado

980
01:24:01,470 --> 01:24:04,909
en el arc S0 y en el arc S1 no ha cargado a nadie

981
01:24:04,909 --> 01:24:09,609
que es lo que me había pasado aquí cuando hice un Java

982
01:24:09,609 --> 01:24:12,930
inicio, porque hice este Java inicio

983
01:24:12,930 --> 01:24:18,779
y me di un error intentando acceder a la posición 0 del programa

984
01:24:18,779 --> 01:24:25,859
es decir, ¿en qué momento se llama el método

985
01:24:25,859 --> 01:24:31,739
main, se llama el método main cuando intentamos arrancar el programa, que es el momento

986
01:24:31,739 --> 01:24:34,960
cuando se ejecuta cualquier método, es el momento en el que

987
01:24:34,960 --> 01:24:39,279
estas variables que tiene por aquí entre paréntesis se cargan con información

988
01:24:39,279 --> 01:24:43,460
por aquí hemos cargado constructores con

989
01:24:43,460 --> 01:24:47,000
información cuando hemos hecho la llamada al constructor, por aquí hemos

990
01:24:47,000 --> 01:24:51,359
cargado con un string una variable del método saludar

991
01:24:51,359 --> 01:24:55,520
el que está sobrecargado con un string cuando hemos hecho la llamada, en el momento que llamábamos

992
01:24:55,520 --> 01:25:02,159
a ejecutar a saludar le pasamos por aquí el dato esto cuando se cargará pues se cargará en el

993
01:25:02,159 --> 01:25:05,979
momento que llamemos al main pero es que el main no lo llamamos nosotros desde código sino que se

994
01:25:05,979 --> 01:25:12,880
llama en el momento en el que lanzamos el programa como estamos haciendo por aquí si no queréis venir

995
01:25:12,880 --> 01:25:21,180
para probar esto al terminar y lanzar el programa también ya lo vimos un día a ver si me acuerdo

996
01:25:21,180 --> 01:25:31,800
estaba en como verás configuration saber era aquí si miras aquí para hacer esto mismo que

997
01:25:31,800 --> 01:25:37,420
he hecho de pasarle parámetros a la ejecución del main a la ejecución del programa es decir

998
01:25:37,420 --> 01:25:43,680
en la llamada al main parámetros que se cargan en ars 0 y en ars 1 para hacer esta simulación

999
01:25:43,680 --> 01:25:45,659
desde Eclipse, pues nos podemos venir

1000
01:25:45,659 --> 01:25:47,819
aquí a la opción

1001
01:25:47,819 --> 01:25:48,640
de menú run

1002
01:25:48,640 --> 01:25:51,640
cobreis configurations

1003
01:25:51,640 --> 01:25:53,439
y aquí

1004
01:25:53,439 --> 01:25:55,439
aparece la opción arguments

1005
01:25:55,439 --> 01:25:57,560
entonces aquí en arguments

1006
01:25:57,560 --> 01:26:01,829
podemos poner los argumentos

1007
01:26:01,829 --> 01:26:03,350
este hola y adiós

1008
01:26:03,350 --> 01:26:05,170
corresponden justo

1009
01:26:05,170 --> 01:26:06,609
a este

1010
01:26:06,609 --> 01:26:09,329
hola y adiós que os he puesto

1011
01:26:09,329 --> 01:26:11,630
aquí, más allá de la llamada

1012
01:26:11,630 --> 01:26:13,869
entonces si yo digo aplicar

1013
01:26:15,250 --> 01:26:19,189
close si yo ahora hago una ejecución aquí de

1014
01:26:19,189 --> 01:26:23,250
eclipse fijaros como demuestra ese o la que es el que puesto ahí porque solamente

1015
01:26:23,250 --> 01:26:29,829
puesto ahora aquí el ars s les comento también este otro y me

1016
01:26:29,829 --> 01:26:39,189
saldría el ola y adiós este ola y adiós son estos dos argumentos que he puesto

1017
01:26:39,189 --> 01:26:54,750
aquí cambió por dos y ya me hice ola y dos bien entonces tenemos en el main

1018
01:26:54,750 --> 01:26:58,670
tenemos, en este caso es void, podría, main

1019
01:26:58,670 --> 01:27:02,989
tiene esta cabecera, es decir, es inamovible, tiene que ser

1020
01:27:02,989 --> 01:27:06,729
así, pero para cualquier otro método equivalente al void

1021
01:27:06,729 --> 01:27:10,109
podríamos tener un int, un string, un tipo referenciado

1022
01:27:10,109 --> 01:27:13,909
otro día lo volvemos a dar a lo mejor otra vuelta

1023
01:27:13,909 --> 01:27:18,770
luego está la etiqueta estática de aquí en el main, de esta os he hablado

1024
01:27:18,770 --> 01:27:22,810
también en diferentes tutorías, cuando cosas

1025
01:27:22,810 --> 01:27:26,789
se definen de forma estática, primero

1026
01:27:26,789 --> 01:27:30,149
os cuento sin el static. Cuando una clase

1027
01:27:30,149 --> 01:27:33,789
no es estática, pues tenemos

1028
01:27:33,789 --> 01:27:38,710
podemos definir diferentes objetos de esa clase

1029
01:27:38,710 --> 01:27:42,750
y el acceso, bueno, las cosas estáticas en líneas generales

1030
01:27:42,750 --> 01:27:46,109
es que con lo que mejor se entiende el término estático es con los parámetros.

1031
01:27:46,930 --> 01:27:51,109
Las cosas estáticas en líneas generales es que están compartidas

1032
01:27:51,109 --> 01:27:53,550
por todos los objetos de una clase

1033
01:27:53,550 --> 01:27:55,970
entonces si yo

1034
01:27:55,970 --> 01:27:57,850
el main

1035
01:27:57,850 --> 01:27:59,569
no era una clase, era un método

1036
01:27:59,569 --> 01:28:01,710
pero se entiende mejor para los

1037
01:28:01,710 --> 01:28:03,430
parámetros, si yo pongo aquí

1038
01:28:03,430 --> 01:28:04,909
un public, fijaros

1039
01:28:04,909 --> 01:28:06,270
static

1040
01:28:06,270 --> 01:28:11,310
y valor, vamos a poner

1041
01:28:11,310 --> 01:28:13,229
int

1042
01:28:13,229 --> 01:28:18,260
de tipo entero, fijaros

1043
01:28:18,260 --> 01:28:20,239
este static para este

1044
01:28:20,239 --> 01:28:24,510
valor lo que supone, voy a borrar por aquí

1045
01:28:24,510 --> 01:28:26,970
vamos a crear

1046
01:28:26,970 --> 01:28:47,189
una primera persona. Fijaros que aquí en la clase

1047
01:28:47,189 --> 01:28:51,029
de persona he mantenido la edad como un parámetro

1048
01:28:51,029 --> 01:28:55,350
de tipo entero que no es estático y valor lo he mantenido

1049
01:28:55,350 --> 01:29:00,689
como un tipo entero pero estático. Entonces yo pongo aquí miper

1050
01:29:00,689 --> 01:29:05,350
punto y valor igual a 15.

1051
01:29:10,739 --> 01:29:14,399
De fin, una segunda persona y para esta segunda persona

1052
01:29:14,399 --> 01:29:20,239
digo que tengo una edad 20 y el valor le voy a decir que sea 25.

1053
01:29:20,239 --> 01:29:23,180
y ahora pongo aquí un system out

1054
01:29:23,180 --> 01:29:25,539
.println

1055
01:29:25,539 --> 01:29:29,079
y vamos a poner estos dos datos

1056
01:29:29,079 --> 01:29:30,300
de mi per

1057
01:29:30,300 --> 01:29:36,850
voy a poner aquí unos espacios

1058
01:29:36,850 --> 01:29:39,369
y el segundo

1059
01:29:39,369 --> 01:29:40,130
de los datos

1060
01:29:40,130 --> 01:29:42,810
mi per y valor

1061
01:29:42,810 --> 01:29:51,840
y vamos a hacer lo mismo para la segunda

1062
01:29:51,840 --> 01:29:52,560
de las personas

1063
01:29:52,560 --> 01:29:57,159
entonces si yo ejecuto aquí

1064
01:29:57,159 --> 01:29:59,239
mira lo que pasa

1065
01:29:59,239 --> 01:30:05,210
en principio si nosotros vemos

1066
01:30:05,210 --> 01:30:09,569
que estamos mostrando aquí mi per, la edad y mi per, valor

1067
01:30:09,569 --> 01:30:13,649
lo que nos hace pensar es que la edad, si la hemos asignado a 10

1068
01:30:13,649 --> 01:30:16,750
nos va a mostrar un 10 y el valor nos va a mostrar un 15

1069
01:30:16,750 --> 01:30:19,970
pero esta primera línea nos dice que es 10 y 25

1070
01:30:19,970 --> 01:30:25,930
y en este segundo caso, mi per y edad y mi per y valor

1071
01:30:25,930 --> 01:30:28,949
pensamos que nos va a devolver 20 y 25

1072
01:30:28,949 --> 01:30:33,270
que efectivamente es correcto lo que hace, pero lo que nos chirría

1073
01:30:33,270 --> 01:30:38,659
un poco es aquí, porque aquí no nos muestra un 15, pues bueno, volvemos

1074
01:30:38,659 --> 01:30:41,680
a hablar un poco de lo que es las zonas de memoria, cuando

1075
01:30:41,680 --> 01:30:46,600
nosotros hacemos un new aquí para mi pair, si este tiene la posición

1076
01:30:46,600 --> 01:30:50,199
30.000, el reserva con el new espacios de memoria

1077
01:30:50,199 --> 01:30:55,000
para sus atributos, pero no se preocupa de aquellos atributos

1078
01:30:55,000 --> 01:30:58,680
que son estáticos, en este caso reservaría un espacio

1079
01:30:58,680 --> 01:31:01,640
de memoria a partir de la 30.000 para el ese nombre y la iedad

1080
01:31:01,640 --> 01:31:12,369
ese nombre e iedad. En este caso, para miper2

1081
01:31:12,369 --> 01:31:18,539
en la 40.000, reservaría para esa segunda persona

1082
01:31:18,539 --> 01:31:22,279
espacio para ese nombre y para la iedad, igualmente

1083
01:31:22,279 --> 01:31:26,560
y en forma global para todas las personas, no para esta

1084
01:31:26,560 --> 01:31:30,039
ni para esta otra, se fijaría en aquellos que son estáticos

1085
01:31:30,039 --> 01:31:34,579
y para la clase persona, pero no para un objeto en particular, sino en línea

1086
01:31:34,579 --> 01:31:38,460
en general, y de forma compartida, reservaría

1087
01:31:38,460 --> 01:31:42,140
espacio de memoria, vete a saber en qué posición

1088
01:31:42,140 --> 01:31:45,300
el sistema operativo, vamos a poner aquí la 80.000

1089
01:31:45,300 --> 01:31:50,420
para aquellos atributos que sean estáticos, que en este

1090
01:31:50,420 --> 01:31:55,840
caso es iValor. Y estos atributos, al ser

1091
01:31:55,840 --> 01:31:59,920
static, que podríamos decir que es igual

1092
01:31:59,920 --> 01:32:05,359
a compartidos, estos atributos tienen una única posición de memoria

1093
01:32:05,359 --> 01:32:08,039
para todos los objetos. Entonces cuando

1094
01:32:08,039 --> 01:32:12,140
yo asigno aquí a iedad el valor de 10

1095
01:32:12,140 --> 01:32:16,399
como iedad no es estático, se irá a su posición de memoria

1096
01:32:16,399 --> 01:32:21,979
aquí y cogerá y me pondrá un 10 aquí.

1097
01:32:23,220 --> 01:32:25,720
Cuando yo voy a mi per, que es una persona

1098
01:32:25,720 --> 01:32:29,880
y valor y le asigno un 15, fijaros como por ser

1099
01:32:29,880 --> 01:32:33,760
estático no hemos hecho reserva de memoria aquí, sino que se ha hecho para la persona en su conjunto.

1100
01:32:33,760 --> 01:32:37,579
Entonces cogerá y se vendrá aquí al ser estático y pondrá

1101
01:32:37,579 --> 01:32:44,090
un 15. Si yo ahora cojo y asigno

1102
01:32:44,090 --> 01:32:46,930
un 20 aquí, como iedad no es estático

1103
01:32:46,930 --> 01:32:49,949
y cada uno de los objetos tiene su zona de memoria

1104
01:32:49,949 --> 01:32:52,970
lo que nos hará es aquí en esta iedad

1105
01:32:52,970 --> 01:32:57,819
cogerá y pondrá un 20. Pero si yo

1106
01:32:57,819 --> 01:32:59,779
me voy aquí y asigno a iValor

1107
01:32:59,779 --> 01:33:03,659
que es un parámetro estático de la clase persona

1108
01:33:03,659 --> 01:33:06,460
el valor 25, como no tenemos

1109
01:33:06,460 --> 01:33:09,239
para cada uno de los objetos ese iValor, donde se irá

1110
01:33:09,239 --> 01:33:12,560
a la zona global de la clase

1111
01:33:12,560 --> 01:33:14,680
persona, entonces, que es esta

1112
01:33:14,680 --> 01:33:16,300
y que está compartida. Entonces, este

1113
01:33:16,300 --> 01:33:18,899
15 lo estará sobrescribiendo a 25.

1114
01:33:20,199 --> 01:33:20,859
Y perdemos

1115
01:33:20,859 --> 01:33:22,359
el 15 que habíamos puesto aquí.

1116
01:33:23,220 --> 01:33:24,779
Bueno, decimos, lo perdemos.

1117
01:33:24,939 --> 01:33:26,699
Bueno, es que a lo mejor es lo que nos interesa

1118
01:33:26,699 --> 01:33:28,300
según el enunciado del ejercicio.

1119
01:33:28,880 --> 01:33:30,060
Si todos tienen,

1120
01:33:31,159 --> 01:33:32,199
imaginaos que tienes,

1121
01:33:32,840 --> 01:33:34,539
vamos a hacer una exageración de dato,

1122
01:33:34,720 --> 01:33:36,239
pero un millón de personas que

1123
01:33:36,239 --> 01:33:38,420
todos pertenecen a

1124
01:33:38,420 --> 01:33:40,340
a Dan, vamos a decir,

1125
01:33:40,340 --> 01:33:42,340
a nuestra clase

1126
01:33:42,340 --> 01:33:44,560
de DAM. Todos ellos.

1127
01:33:45,319 --> 01:33:46,520
Y además un poco exagerado

1128
01:33:46,520 --> 01:33:47,979
con lo del millón de personas, pero bueno,

1129
01:33:48,100 --> 01:33:50,039
para que sea más ilustrativo.

1130
01:33:50,779 --> 01:33:51,859
Si tuviéramos que cambiar

1131
01:33:51,859 --> 01:33:54,239
el nombre de ese millón de personas, como

1132
01:33:54,239 --> 01:33:56,380
cada uno tiene su nombre, no nos quedaría más remedio

1133
01:33:56,380 --> 01:33:58,020
que ir uno a uno y cambiar su nombre.

1134
01:33:58,279 --> 01:34:00,220
Porque sería una variable de este tipo, de cada uno

1135
01:34:00,220 --> 01:34:02,239
de los objetos, de cada una de las instancias.

1136
01:34:03,279 --> 01:34:04,359
Pero si lo que queremos es

1137
01:34:04,359 --> 01:34:06,399
cambiar el que pertenece

1138
01:34:06,399 --> 01:34:07,779
en a DAM, porque ahora

1139
01:34:07,779 --> 01:34:11,479
desde la consejería de educación nos dicen que en lugar de

1140
01:34:11,479 --> 01:34:15,060
DAM sea DAN, pues sin necesidad

1141
01:34:15,060 --> 01:34:17,359
al ser un dato común a todos ellos de ir

1142
01:34:17,359 --> 01:34:20,359
a ese millón de objetos y hacer el cambio de DAM a DAN

1143
01:34:20,359 --> 01:34:23,619
como es común, pues iríamos a la variable estática

1144
01:34:23,619 --> 01:34:26,220
y con un único cambio quedarían automáticamente

1145
01:34:26,220 --> 01:34:29,239
todos actualizados, que es lo que nos ha sucedido aquí con

1146
01:34:29,239 --> 01:34:32,279
IVALOR. Como consecuencia de que

1147
01:34:32,279 --> 01:34:35,319
IVALOR, aquí pusimos 15 para mi PER

1148
01:34:35,319 --> 01:34:37,479
pero luego hemos puesto aquí 25

1149
01:34:37,479 --> 01:34:41,739
es actualizado, cuando aquí estoy mostrando y valor para mi per

1150
01:34:41,739 --> 01:34:46,020
como la zona es común, el dato que tiene es 25 y como consecuencia

1151
01:34:46,020 --> 01:34:51,260
nos muestra aquí este 25, entonces esta es la información de los datos

1152
01:34:51,260 --> 01:34:55,359
como funcionan los atributos que definimos

1153
01:34:55,359 --> 01:34:59,220
como estáticos, de igual forma los métodos también

1154
01:34:59,220 --> 01:35:03,199
pueden ser estáticos, en realidad cuando definimos

1155
01:35:03,199 --> 01:35:06,560
un objeto y ponemos un método como el de saludar

1156
01:35:06,560 --> 01:35:09,840
que no sea estático, lo que hace es

1157
01:35:09,840 --> 01:35:14,300
que cada uno de los objetos tendrá su propio método saludar

1158
01:35:14,300 --> 01:35:17,779
y si aquí ponemos static, como le sucede al main

1159
01:35:17,779 --> 01:35:22,260
pues será un método común para todos los objetos y llamará justo

1160
01:35:22,260 --> 01:35:25,960
la misma zona de código compartida entre todos

1161
01:35:25,960 --> 01:35:30,100
la misma idea que para los parámetros, lo que pasa es que con los parámetros el ejemplo

1162
01:35:30,100 --> 01:35:32,500
se ve muy claro haciendo una cosa así de este estilo

1163
01:35:32,500 --> 01:35:53,149
Pero si nosotros cogemos y ponemos aquí y edad igual a 45, ¿qué nos pasa? Que esto no nos compila. Y no nos compila, volvemos un poco a lo mismo que con la sobrecarga hablábamos de las ambigüedades.

1164
01:35:53,149 --> 01:35:57,149
si yo pongo aquí y edad, pensando en una persona

1165
01:35:57,149 --> 01:36:01,010
me dirá, muy bien, pero ¿qué persona, la edad

1166
01:36:01,010 --> 01:36:04,689
de qué persona quieres cambiar? Tú date cuenta que si es la edad del miper1

1167
01:36:04,689 --> 01:36:08,869
me tengo que ir a la posición que cuelga del 30.000 para cambiarlo. Y si es

1168
01:36:08,869 --> 01:36:12,909
de miper2, cuelga del 40.000. Entonces

1169
01:36:12,909 --> 01:36:16,850
como no seas más preciso, yo no te dejo compilar porque no es un

1170
01:36:16,850 --> 01:36:20,890
parámetro estático y no sé a quién tengo que cambiar. Entonces, si

1171
01:36:20,890 --> 01:36:28,210
yo cojo y pongo aquí mi per 2 punto y edad ya me compila porque ya no hay ambigüedades mi per 2

1172
01:36:28,210 --> 01:36:32,609
empieza en la posición 40.000 y la edad está aquí pues lo que estoy haciendo es cambiar este dato

1173
01:36:32,609 --> 01:36:41,479
a 45 cambio los datos estáticos me permiten hacerlos de esta forma poner en lugar de un

1174
01:36:41,479 --> 01:36:50,840
objeto persona punto fijaros cómo me ofrece el y valor para cambiarlo un dato que es estático

1175
01:36:50,840 --> 01:36:54,739
lo puedo cambiar a través de cualquiera de sus

1176
01:36:54,739 --> 01:36:58,720
objetos, aunque siempre van a actuar sobre la misma posición de memoria, el cambio va a ser

1177
01:36:58,720 --> 01:37:02,800
común a todos, o a través de la clase total, si solo tengo una posición

1178
01:37:02,800 --> 01:37:06,500
de memoria, no hay ambigüedades, de nuevo, pues te lo permito. Entonces, en este caso,

1179
01:37:06,619 --> 01:37:09,739
lo que me haría sería el 55. Pero fijaros cómo

1180
01:37:09,739 --> 01:37:17,000
a través de la clase persona, punto, no me da la opción

1181
01:37:17,000 --> 01:37:20,720
de cambiar una edad, porque me diría, no, eso no es un dato estático, no es común

1182
01:37:20,720 --> 01:37:23,859
a todas las personas, no tengo ni idea de qué persona

1183
01:37:23,859 --> 01:37:26,699
quieres cambiar la edad. En este ejercicio es miper y miper2

1184
01:37:26,699 --> 01:37:34,270
pero podrían ser muchos otros. Para acceder a

1185
01:37:34,270 --> 01:37:37,170
datos con independencia de los estáticos

1186
01:37:37,170 --> 01:37:40,989
de cualquier clase, necesitamos

1187
01:37:40,989 --> 01:37:43,670
definir un objeto. Para cambiar

1188
01:37:43,670 --> 01:37:46,350
la edad de una persona, obligatoriamente necesito

1189
01:37:46,350 --> 01:37:49,689
definir el objeto de la clase persona miper

1190
01:37:49,689 --> 01:37:51,810
y así de esta forma puedo acceder a él.

1191
01:37:53,689 --> 01:37:55,170
Siempre, por

1192
01:37:55,489 --> 01:38:02,670
Regla general, que queremos acceder a un parámetro o a un método de un objeto de una clase, tendremos que instanciar su clase.

1193
01:38:02,670 --> 01:38:08,729
¿Con qué excepción? Con la excepción de parámetros y métodos que sean estáticos.

1194
01:38:09,029 --> 01:38:17,909
Si son estáticos, puedo decir, lo defino para la clase y cuando vaya habiendo instancias de objetos de esa clase, ya tienen esos datos.

1195
01:38:19,010 --> 01:38:23,390
¿Dónde utilizamos nosotros continuamente métodos estáticos?

1196
01:38:23,390 --> 01:38:28,250
Pues mirad, un sitio donde utilizamos métodos estáticos es cuando ponemos el system.out.println.

1197
01:38:31,619 --> 01:38:36,579
Esto, fijaros que tiene toda la pinta de la sintaxis de los métodos de los que estamos hablando.

1198
01:38:36,859 --> 01:38:48,960
Tiene un nombre y recibe por aquí, tiene entre paréntesis, en particular el println recibe aquí una cadena de caracteres o cadenas de caracteres puede recibir.

1199
01:38:49,340 --> 01:38:51,220
O está sobrecargado con diferentes opciones.

1200
01:38:51,220 --> 01:38:57,779
esto pertenece, es un método que pertenecerá en la librería de Java

1201
01:38:57,779 --> 01:39:01,420
a una clase que es la clase System.out que es un flujo de salida hacia pantalla

1202
01:39:01,420 --> 01:39:05,899
hemos instanciado un objeto de System.out antes de llamar

1203
01:39:05,899 --> 01:39:09,659
al método println como necesitábamos para

1204
01:39:09,659 --> 01:39:13,699
escribir por ejemplo sobre el parámetro y edad, no, entonces

1205
01:39:13,699 --> 01:39:17,140
println como estará definido en la librería de Java

1206
01:39:17,140 --> 01:39:24,640
pues como un método, más punto, mirad el valor

1207
01:39:24,640 --> 01:39:30,640
absoluto de un número? Pues hay una clase que es la clase math

1208
01:39:30,640 --> 01:39:35,060
y hemos llamado al método valor absoluto

1209
01:39:35,060 --> 01:39:38,319
de un número que recibe aquí como parámetro. Si metemos un

1210
01:39:38,319 --> 01:39:42,859
valor que sea menos 5, pues nos devolverá un 5. Si metemos el 5, pues el 5,

1211
01:39:42,920 --> 01:39:47,020
el valor absoluto de matemáticas. ¿Hemos instanciado un objeto

1212
01:39:47,020 --> 01:39:50,579
de la clase math? No. ¿Hemos sido capaces de llamar a un método?

1213
01:39:50,579 --> 01:39:54,100
Sí. ¿Esto qué implica? Pues que implica que apps

1214
01:39:54,100 --> 01:39:58,039
en las librerías de Java, estaría definido como

1215
01:39:58,039 --> 01:40:08,800
un método estático. ¿Alguna duda? Yo creo que vamos a ir

1216
01:40:08,800 --> 01:40:11,479
cerrando ya aquí, porque son las 7 y cuarto.

1217
01:40:15,560 --> 01:40:20,199
Sí, más o menos bien. Mirad, del main, bueno, todavía la próxima clase

1218
01:40:20,199 --> 01:40:27,199
os sigo contando más. Me entra un eco, no sé si alguien habéis dejado abierto

1219
01:40:27,199 --> 01:40:33,659
el micro. Bueno, pues nada,

1220
01:40:33,720 --> 01:40:36,739
la próxima clase os cuento, os sigo contando cositas de esto.

1221
01:40:36,739 --> 01:40:39,439
termino con el main, que nos ha faltado

1222
01:40:39,439 --> 01:40:43,140
bueno, el main que es algo común a todos los métodos

1223
01:40:43,140 --> 01:40:45,220
pero aparece también aquí en el main, el public

1224
01:40:45,220 --> 01:40:47,779
y bueno, pues vamos haciendo por ahí

1225
01:40:47,779 --> 01:40:51,779
algunas cositas más, mientras tanto os voy viendo

1226
01:40:51,779 --> 01:40:54,079
por ahí por los foros, si tenéis alguna

1227
01:40:54,079 --> 01:40:57,699
duda y bueno, y poco más

1228
01:40:57,699 --> 01:41:03,180
que contaros, si

1229
01:41:03,180 --> 01:41:05,859
alguien tiene una pregunta por ahí, dime