1
00:00:00,000 --> 00:00:05,639
Voy a grabar esta clase, si habláis me dais consentimiento para que grabe esta voz.

2
00:00:06,160 --> 00:00:13,580
Entonces, nosotros hemos hecho los primeros pasos en el mundo de la programación orientada a objetos.

3
00:00:14,119 --> 00:00:19,640
Hemos empezado a ver la diferencia entre objetos y clases, hemos empezado a ver que es un constructor,

4
00:00:19,899 --> 00:00:25,420
hemos visto el concepto de sobrecargar un constructor o sobrecargar un método.

5
00:00:25,420 --> 00:00:29,679
Hemos visto... ¿qué más hemos visto? Poco más.

6
00:00:30,000 --> 00:00:34,420
Hemos visto las bases para poder crear objetos, hemos hecho ejemplos, etc.

7
00:00:35,880 --> 00:00:48,859
Antes de entrar en las capacidades avanzadas de la programación orientada a objetos, como son herencia, como son polimorfismo, como son cosas por el estilo,

8
00:00:49,420 --> 00:00:56,439
pues tenemos que acabar de dar unas pinceladas siempre sobre el concepto de clases y sobre lo que se puede hacer en una clase.

9
00:00:56,439 --> 00:01:01,759
Algunas cosas son cosas que hemos visto siempre allí y no sabemos exactamente qué es

10
00:01:01,759 --> 00:01:03,140
Pues ahora vamos a ver qué es

11
00:01:03,140 --> 00:01:09,120
Y algunas cosas ya las hemos dicho en ejemplos anteriores, pues hoy las formalizamos

12
00:01:09,120 --> 00:01:13,879
Entonces, primer punto, el método main

13
00:01:13,879 --> 00:01:20,780
Nosotros desde el primer día, desde aquel día de septiembre en el que empezamos el primer Hello World

14
00:01:20,780 --> 00:01:27,239
En el que, además de public class no sé qué, escribimos un public static void main, ¿vale?

15
00:01:27,579 --> 00:01:40,700
Y, si os dais cuenta, cada día que pasa, vamos añadiendo algo más que nos hace entender qué es este public static main void, ¿vale?

16
00:01:40,980 --> 00:01:43,659
Por ejemplo, al principio no sabíamos nada de todo esto.

17
00:01:44,040 --> 00:01:48,680
Hoy sabemos que main es el nombre, que void, ¿qué quiere decir void?

18
00:01:48,680 --> 00:01:52,560
Que el main no me espero que devuelva algo

19
00:01:52,560 --> 00:01:53,400
¿Vale?

20
00:01:54,299 --> 00:01:57,579
Static, todavía no lo entendemos muy bien

21
00:01:57,579 --> 00:02:02,280
Pero entendemos que cuando es static no depende de un objeto

22
00:02:02,280 --> 00:02:05,299
Y cuando no es static depende de un objeto

23
00:02:05,299 --> 00:02:09,939
O sea que el main no necesita haber creado un objeto sobre el que llamar el main

24
00:02:09,939 --> 00:02:10,759
¿Vale?

25
00:02:10,840 --> 00:02:13,400
Y es normal porque cuando empiezo no tengo objetos

26
00:02:13,400 --> 00:02:14,259
¿Sí?

27
00:02:15,360 --> 00:02:18,080
Public, que es accesible desde fuera

28
00:02:18,080 --> 00:02:21,240
de esta clase, hoy veremos mejor

29
00:02:21,240 --> 00:02:23,580
el concepto de visibilidad

30
00:02:23,580 --> 00:02:26,139
y que pilla como parámetro

31
00:02:26,139 --> 00:02:29,360
una cosa que se llama args

32
00:02:29,360 --> 00:02:33,180
que es una variable, que es un array de string

33
00:02:33,180 --> 00:02:35,479
esto es todo lo que sabemos

34
00:02:35,479 --> 00:02:39,240
esto lo sabemos más o menos leer, lo entendemos más o menos

35
00:02:39,240 --> 00:02:42,240
sabemos que es un método especial, es el punto de acceso

36
00:02:42,240 --> 00:02:43,580
a mi programa, a mi sistema

37
00:02:43,580 --> 00:02:48,939
Siempre tendrá que haber un punto de acceso más importante

38
00:02:48,939 --> 00:02:52,580
Esto no quita que pueda hacer varias clases con un main

39
00:02:52,580 --> 00:02:56,039
Pero mi sistema tendrá que empezar con un main concreto

40
00:02:56,039 --> 00:03:00,620
Habrá una clase, clase principal, la clase inicio, la clase de llamarla como os da la gana

41
00:03:00,620 --> 00:03:06,620
Que será la clase que tendrá el main, que es el que crea todos los objetos que tiene que crear

42
00:03:06,620 --> 00:03:09,860
Y a partir de allí sale y empieza mi sistema

43
00:03:09,860 --> 00:03:18,740
¿Vale? Como es static, se puede invocar su ejecución si necesita de que exista un objeto de la clase a la que pertenece

44
00:03:18,740 --> 00:03:24,139
¿Vale? Entonces se puede lanzar ya directamente, si esta es la clase, mi clase, ¿vale?

45
00:03:24,219 --> 00:03:28,960
Puede tener o no un main, nosotros hemos hecho clases con main y clases sin main

46
00:03:28,960 --> 00:03:30,740
¿Recordáis? ¿Sí? Vale

47
00:03:30,740 --> 00:03:34,439
¿Qué es esto de string args? ¿Sí?

48
00:03:34,439 --> 00:03:43,180
En realidad, StringArgs representa un array de parámetros con el que yo ejecuto el programa.

49
00:03:43,360 --> 00:03:52,620
Si vosotros habéis usado algún programita en línea de comando, muchos de estos programas, después del programa, admiten parámetros.

50
00:03:53,219 --> 00:03:55,819
¿Habéis usado un ping alguna vez en vuestra vida?

51
00:03:56,379 --> 00:04:01,080
Ping es el comando, pero luego, después del ping, admite parámetros.

52
00:04:01,080 --> 00:04:03,580
En particular, ¿a quién haces ping?

53
00:04:04,439 --> 00:04:06,879
o ping menos t

54
00:04:06,879 --> 00:04:09,240
y a quien hacéis ping

55
00:04:09,240 --> 00:04:10,860
el menos t es un parámetro

56
00:04:10,860 --> 00:04:12,780
que permite hacer ping para siempre

57
00:04:12,780 --> 00:04:13,919
hasta que tú lo bloquees

58
00:04:13,919 --> 00:04:16,819
entonces, todos los programas

59
00:04:16,819 --> 00:04:18,019
que nosotros podemos crear

60
00:04:18,019 --> 00:04:20,540
admiten parámetros

61
00:04:20,540 --> 00:04:22,819
yo puedo crear en mi

62
00:04:22,819 --> 00:04:24,180
programa Java

63
00:04:24,180 --> 00:04:27,279
un programa que al lanzarlo

64
00:04:27,279 --> 00:04:28,680
le añado parámetros

65
00:04:28,680 --> 00:04:30,779
en el momento del lanzamiento

66
00:04:30,779 --> 00:04:40,060
en línea de comando

67
00:04:40,060 --> 00:04:43,100
Y primero utilizamos el programa Java C

68
00:04:43,100 --> 00:04:43,779
Java C

69
00:04:43,779 --> 00:04:46,579
Que es sustancialmente

70
00:04:46,579 --> 00:04:47,519
El compilador de Java

71
00:04:47,519 --> 00:04:50,779
Que transforma el punto Java en un punto class

72
00:04:50,779 --> 00:04:53,199
Transforma Java como lo conocéis vosotros

73
00:04:53,199 --> 00:04:54,819
En otro lenguaje intermedio

74
00:04:54,819 --> 00:04:55,839
Que se llama el bytecode

75
00:04:55,839 --> 00:04:58,259
Y luego hacíamos Java

76
00:04:58,259 --> 00:05:00,000
Y el nombre de la clase

77
00:05:00,000 --> 00:05:02,339
Y esto crea la Java Virtual Machine

78
00:05:02,339 --> 00:05:04,420
Le pasa como parámetro el nombre de la clase

79
00:05:04,420 --> 00:05:05,259
Y ya está

80
00:05:05,259 --> 00:05:07,060
Entonces

81
00:05:07,060 --> 00:05:15,540
Yo tenía Java C

82
00:05:15,540 --> 00:05:18,139
mi clase

83
00:05:18,139 --> 00:05:20,959
punto java

84
00:05:20,959 --> 00:05:23,139
esto me crea

85
00:05:23,139 --> 00:05:25,000
mi clase punto class

86
00:05:25,000 --> 00:05:27,500
y luego hacía java mi clase

87
00:05:27,500 --> 00:05:30,699
esto es

88
00:05:30,699 --> 00:05:31,399
lo básico

89
00:05:31,399 --> 00:05:34,720
ahora yo puedo a esta

90
00:05:34,720 --> 00:05:36,740
cosa de aquí darle

91
00:05:36,740 --> 00:05:38,699
unos parámetros, es decir que cuando lo llamo

92
00:05:38,699 --> 00:05:40,699
así, vale, podría

93
00:05:40,699 --> 00:05:42,459
por ejemplo pasarle aquí

94
00:05:42,459 --> 00:05:44,060
1, 10

95
00:05:44,060 --> 00:05:46,579
esto le estaría pasando dos

96
00:05:46,579 --> 00:05:48,600
parámetros, el parámetro 1 y el parámetro 10

97
00:05:48,600 --> 00:05:50,620
¿sí? que por ejemplo

98
00:05:50,620 --> 00:05:52,199
luego podría utilizar como

99
00:05:52,199 --> 00:05:54,540
no sé, imaginamos que mi clase sea

100
00:05:54,540 --> 00:05:55,699
una

101
00:05:55,699 --> 00:05:58,500
una clase que lo que hace es generar

102
00:05:58,500 --> 00:05:59,879
números aleatorios

103
00:05:59,879 --> 00:06:02,360
pues yo quiero crear que cuando la lanzo así

104
00:06:02,360 --> 00:06:04,019
sea un número aleatorio entre 1 y 10

105
00:06:04,019 --> 00:06:05,480
si lo lanzo así

106
00:06:05,480 --> 00:06:08,439
genera un número aleatorio

107
00:06:08,439 --> 00:06:09,420
entre 10 o 100

108
00:06:09,420 --> 00:06:12,139
¿sí? o sea que si lo estoy pasando

109
00:06:12,139 --> 00:06:14,360
no pidiendo al usuario

110
00:06:14,360 --> 00:06:16,079
oye usuario, dame un número

111
00:06:16,079 --> 00:06:18,660
dentro del código

112
00:06:18,660 --> 00:06:21,240
sino que al momento de lanzarlo

113
00:06:21,240 --> 00:06:23,259
yo le puedo dar unos parámetros

114
00:06:23,259 --> 00:06:25,019
determinados, por ejemplo

115
00:06:25,019 --> 00:06:27,240
esto se usará en un futuro para pasarle

116
00:06:27,240 --> 00:06:29,519
un fichero, por ejemplo, yo lanzo mi clase

117
00:06:29,519 --> 00:06:31,579
y aquí le digo el nombre

118
00:06:31,579 --> 00:06:33,819
del fichero, log.txt

119
00:06:33,819 --> 00:06:35,759
y esto será el fichero

120
00:06:35,759 --> 00:06:37,480
que él utilizará durante

121
00:06:37,480 --> 00:06:39,959
esta ejecución, si cambio en log2

122
00:06:39,959 --> 00:06:41,660
pues usará un fichero distinto

123
00:06:41,660 --> 00:06:43,540
esto podría ser un

124
00:06:43,540 --> 00:06:45,519
fichero de configuración

125
00:06:45,519 --> 00:07:07,420
configuración, config.cfg, qué sé yo, entonces cuando él arranca dentro de este fichero encontrará una serie de parámetros que utilizará para arrancar de una determinada forma, quién es el servidor, quién es el local, cuántos jugadores puede admitir, no lo sé, lo que me haga falta, ¿vale?

126
00:07:07,420 --> 00:07:25,389
Ahora, cuando yo lanzo algo así, Java, mi clase, y pongo cosas aquí, ¿dónde acaban estos datos? Es decir, ¿cómo puedo pillar estos datos desde dentro del programa?

127
00:07:25,389 --> 00:07:42,529
Y estos datos se van insertando en un array de string donde en la posición cero está el primer argumento, en la segunda está el segundo argumento, en la tercera posición está gato.

128
00:07:43,209 --> 00:07:48,819
Y este array es este array. ¿Se entiende?

129
00:07:48,819 --> 00:07:53,990
entonces, una vez que yo lanzo el main

130
00:07:53,990 --> 00:07:56,149
tengo estos argumentos que pueden estar vacíos

131
00:07:56,149 --> 00:07:58,189
nosotros hemos usado hasta ahora vacío

132
00:07:58,189 --> 00:08:00,089
no hemos nunca rellenado algo allí

133
00:08:00,089 --> 00:08:02,129
pero puede ser que yo lance

134
00:08:02,129 --> 00:08:04,089
mi programa pasándole lo que se llaman

135
00:08:04,089 --> 00:08:06,170
argumentos, y como los encuentro

136
00:08:06,170 --> 00:08:07,629
los encuentro como string

137
00:08:07,629 --> 00:08:09,629
dentro de args

138
00:08:09,629 --> 00:08:11,750
args de 0

139
00:08:11,750 --> 00:08:13,870
será el primer argumento, args de 1

140
00:08:13,870 --> 00:08:15,769
será el primer argumento, me puedo preguntar

141
00:08:15,769 --> 00:08:17,250
¿cuánto es grande args?

142
00:08:17,870 --> 00:08:20,250
y si args.length es 0

143
00:08:20,250 --> 00:08:22,170
Quiere decir que no me has pasado argumentos

144
00:08:22,170 --> 00:08:24,850
Si args.length es mayor que 0

145
00:08:24,850 --> 00:08:27,029
Quiere decir que me has pasado algún argumento

146
00:08:27,029 --> 00:08:27,930
Y ahora hacemos pruebas

147
00:08:27,930 --> 00:08:28,189
¿Vale?

148
00:08:29,430 --> 00:08:31,670
Una clase, mi clase, cotoriego, comando, Java, mi clase

149
00:08:31,670 --> 00:08:33,590
Java, mi clase, algo, 3, otra cosa

150
00:08:33,590 --> 00:08:36,789
Generaría que en args de 0 estaría algo

151
00:08:36,789 --> 00:08:39,090
En args de 1 estaría 3

152
00:08:39,090 --> 00:08:40,470
Cuidado, como string

153
00:08:40,470 --> 00:08:42,370
No como número

154
00:08:42,370 --> 00:08:43,950
Si lo quiero como número

155
00:08:43,950 --> 00:08:46,470
Tengo que hacer algo para transformarla en número

156
00:08:46,470 --> 00:08:48,029
Pero esto es un array de string

157
00:08:48,029 --> 00:08:49,029
¿Sí?

158
00:08:49,029 --> 00:09:04,909
Y en el args de dos estaría otra cosa, ¿vale? Separado por espacios, allí pongo los valores, los string. En Eclipse se puede hacer lo mismo sin tener que llegar allí diciéndole, oye, mira, estos son los parámetros cuando ejecutas la clase, ¿vale?

159
00:09:04,909 --> 00:09:13,269
Decíamos antes que existe un punto de acceso a mi sistema, una clase main

160
00:09:13,269 --> 00:09:18,169
Clase main quiere decir principal, cuidado, no el método main, la clase main

161
00:09:18,169 --> 00:09:23,309
No se tiene que llamar así, se puede llamar inicio, se puede llamar con el nombre de vuestro programa

162
00:09:23,309 --> 00:09:27,690
Se puede llamar como os da la gana, pero esa es la clase que yo tengo que ejecutar

163
00:09:27,690 --> 00:09:32,549
Eso no quiere decir que tenga que tener un solo main, cada clase puede tener su main

164
00:09:32,549 --> 00:09:36,789
De hecho, muchas veces las clases tienen un main para probar esa clase.

165
00:09:36,950 --> 00:09:43,309
Yo hago la clase persona, que simula a una persona, y dentro tiene un main para crear dos o tres personas y hacerles algo.

166
00:09:44,090 --> 00:09:50,309
Luego creo la clase coche, y dentro de la clase coche tengo un main que prueba esa clase.

167
00:09:50,490 --> 00:09:56,850
Y luego tengo clase garage o taller, que asocia personas a clases, y eso es mi sistema de verdad.

168
00:09:56,850 --> 00:09:59,029
Las tres tienen un main

169
00:09:59,029 --> 00:10:02,169
Pero dos de los main no hacen prácticamente nada

170
00:10:02,169 --> 00:10:03,710
Prueban solo la clase interna

171
00:10:03,710 --> 00:10:05,009
O hacen cosillas pequeñas

172
00:10:05,009 --> 00:10:06,870
Y es el main principal

173
00:10:06,870 --> 00:10:09,929
Es la clase taller que permite lanzar el sistema

174
00:10:09,929 --> 00:10:10,629
¿Se entiende?

175
00:10:11,929 --> 00:10:12,129
Vale

176
00:10:12,129 --> 00:10:15,110
Estas clases pueden tener o no un main

177
00:10:15,110 --> 00:10:17,649
Si lo tienen normalmente se utiliza para probarlo unitariamente

178
00:10:17,649 --> 00:10:20,429
Aunque con utilidades como JUnit

179
00:10:20,429 --> 00:10:21,909
¿Habéis visto yo JUnit ya?

180
00:10:22,169 --> 00:10:22,929
No, lo veréis

181
00:10:22,929 --> 00:10:26,029
No es lo habitual

182
00:10:26,029 --> 00:10:29,750
no tiene por qué llamarse main, se puede llamar como se le da la gana

183
00:10:29,750 --> 00:10:31,730
y es el detonante de mi sistema

184
00:10:31,730 --> 00:10:59,940
paramos aquí, hacemos un ejemplito

185
00:10:59,940 --> 00:11:07,980
esto es un proyecto, voy a hacer un package

186
00:11:07,980 --> 00:11:10,399
de ejemplos

187
00:11:10,399 --> 00:11:13,659
args

188
00:11:13,659 --> 00:11:17,620
ejemplos args

189
00:11:17,620 --> 00:11:20,159
y creo un ejemplo arg

190
00:11:20,159 --> 00:11:23,879
con un main

191
00:11:23,879 --> 00:11:29,169
yo tengo este aquí para hacer un ejemplo

192
00:11:29,169 --> 00:12:03,960
pues lo que puede hacer es decir si args.length es cero, si so, este programa no se usa así, tienes que darme parámetros o argumentos, args, ¿sí?

193
00:12:03,960 --> 00:12:22,129
Esto es típico. Cuando vosotros lanzáis un programa sin lanzarlo con los parámetros correctos, lo que suele salir es una descripción de cómo se usa.

194
00:12:23,730 --> 00:12:29,710
Pinga secas no hace nada porque te dice, mira, pinga después necesita algunos de estos parámetros.

195
00:12:29,710 --> 00:12:35,049
Si están entre corchetes, normalmente es que son opcionales.

196
00:12:35,169 --> 00:12:42,350
Puede ser "-t", "-a", "-ncount", "-liz", y luego tiene que poner un nombre destino, que es donde haces el ping.

197
00:12:42,850 --> 00:12:43,750
Entonces, estos son todos parámetros.

198
00:12:44,149 --> 00:12:45,690
Y luego te explica todos los parámetros.

199
00:12:45,889 --> 00:12:49,529
"-t", hace esto, "-a", hace esto, "-liz", hace esto.

200
00:12:50,669 --> 00:12:59,250
Entonces, la idea es que si tu programa necesita parámetros y tú no le das parámetros,

201
00:12:59,710 --> 00:13:05,710
Pues lo que haga él es decirte, oye, mira, no se usa así, se usa de esta forma.

202
00:13:06,190 --> 00:13:07,809
Te explica cómo se usa, ¿vale?

203
00:13:08,230 --> 00:13:12,850
Nosotros lo hacemos más sencillo, que dice que si sustancialmente no me has pasado ningún parámetro,

204
00:13:13,269 --> 00:13:17,389
pues entonces dime que este parámetro, este programa no se usa así, tienes que darme parámetros.

205
00:13:17,509 --> 00:13:21,009
Si ahora lo lanzo, me está diciendo esto.

206
00:13:21,009 --> 00:13:33,500
Y de esto deduzco una cosa que es, que args no es null.

207
00:13:33,500 --> 00:13:56,200
O sea, que esta cosa alguien la ha creado. Justo. Porque si no, esto me habría explotado. Con un null pointer exception. El hecho de que esto no haya explotado quiere decir que alguien, mágicamente, por debajo, me ha creado este objeto. Este objeto no es null. Este objeto existe.

208
00:13:56,200 --> 00:13:58,700
Alguien ha creado este objeto

209
00:13:58,700 --> 00:14:01,139
Antes de que yo empezara

210
00:14:01,139 --> 00:14:02,740
A ejecutar esto

211
00:14:02,740 --> 00:14:05,179
¿Quién?

212
00:14:05,899 --> 00:14:06,679
La Java Virtual Machine

213
00:14:06,679 --> 00:14:10,299
Al asumir que a llamar esto

214
00:14:10,299 --> 00:14:11,799
La Java Virtual Machine habrá creado

215
00:14:11,799 --> 00:14:14,340
Un array a partir de los argumentos que le he dado

216
00:14:14,340 --> 00:14:16,100
Y se lo habrá pasado aquí

217
00:14:16,100 --> 00:14:17,480
¿Vale? Entonces

218
00:14:17,480 --> 00:14:19,019
Este de aquí

219
00:14:19,019 --> 00:14:21,779
Es un objeto, es un objeto real

220
00:14:21,779 --> 00:14:22,460
Que existe

221
00:14:22,460 --> 00:14:26,200
Ahora, ¿cómo le doy esta cosa?

222
00:14:26,200 --> 00:14:35,740
En realidad yo debería hacer, por ejemplo, java ejemplo args algo, ¿vale?

223
00:14:35,820 --> 00:14:39,100
Entonces este algo se metería aquí dentro, ¿sí?

224
00:14:39,879 --> 00:14:47,379
En Eclipse no lo puede hacer así, ahora vemos cómo se hace, pero antes hagámoslo de hacer algo.

225
00:14:47,379 --> 00:14:49,600
else, asumiendo que

226
00:14:49,600 --> 00:14:51,639
si no es cero

227
00:14:51,639 --> 00:14:53,700
entonces quiere decir que hay algo

228
00:14:53,700 --> 00:14:55,019
¿vale? entonces

229
00:14:55,019 --> 00:14:57,320
vamos a hacer que liste por ejemplo

230
00:14:57,320 --> 00:14:58,559
lo que tenga

231
00:14:58,559 --> 00:15:01,240
entonces lo que hago es for

232
00:15:01,240 --> 00:15:03,039
string s

233
00:15:03,039 --> 00:15:05,320
dos puntos args

234
00:15:05,320 --> 00:15:12,929
siso s

235
00:15:12,929 --> 00:15:16,309
¿vale? esto lo que me

236
00:15:16,309 --> 00:15:18,210
hace es que me escribe los parámetros que te he dado

237
00:15:18,210 --> 00:15:20,389
¿sí? entonces si yo lo lanzo

238
00:15:20,389 --> 00:15:22,370
ahora, me dice no, este programa

239
00:15:22,370 --> 00:15:24,289
no es aquí, tiene que darme unos argumentos

240
00:15:24,289 --> 00:15:26,210
¿Cómo le doy argumentos?

241
00:15:27,070 --> 00:15:32,669
Aquí cuando lanzáis, tenéis al lado una flechita negra

242
00:15:32,669 --> 00:15:37,029
Si le dais aquí, le podéis dar Run Configurations

243
00:15:37,029 --> 00:15:42,190
Run Configurations, abre un menú que dice cuando lanzo este señor

244
00:15:42,190 --> 00:15:47,210
Fijaos que aquí os aparecen todos los main que podéis lanzar

245
00:15:47,830 --> 00:15:51,710
Entonces a veces que le dais a lanzar y en vez de lanzar vuestro programa

246
00:15:51,710 --> 00:15:55,610
está lanzando otro programa, podéis venir aquí y seleccionar

247
00:15:55,610 --> 00:15:59,370
cuál es el main que queréis lanzar, si no aparece aquí, es que os habéis

248
00:15:59,370 --> 00:16:03,610
equivocado en escribir el main y el main no está correcto, entonces él no lo reconoce como

249
00:16:03,610 --> 00:16:07,549
main, entonces no lo puede lanzar, entonces nosotros estamos

250
00:16:07,549 --> 00:16:11,669
lanzando ejemplo args y si

251
00:16:11,669 --> 00:16:14,669
os fijáis aquí arriba, está arguments

252
00:16:14,669 --> 00:16:19,250
si pincháis en arguments, esto es lo que

253
00:16:19,250 --> 00:16:24,730
escribiríais después de Java mi clase o Java ejemplo args en este caso.

254
00:16:25,389 --> 00:16:34,429
Entonces, si yo escribo aquí gato turrón 22 y algo más,

255
00:16:36,049 --> 00:16:39,210
pues yo estoy mandando cuatro parámetros.

256
00:16:39,649 --> 00:16:41,970
Uno, dos, tres y cuatro parámetros.

257
00:16:41,970 --> 00:16:45,409
en el momento en que lo lanzo

258
00:16:45,409 --> 00:16:47,440
run

259
00:16:47,440 --> 00:16:49,480
veis que ahora ya

260
00:16:49,480 --> 00:16:52,460
ha encontrado algo dentro de args

261
00:16:52,460 --> 00:16:54,019
en args de 0

262
00:16:54,019 --> 00:16:56,039
me ha escrito gato

263
00:16:56,039 --> 00:16:57,700
turrón 22

264
00:16:57,700 --> 00:16:58,659
algo más

265
00:16:58,659 --> 00:17:01,159
¿se entiende?

266
00:17:02,899 --> 00:17:03,100
si

267
00:17:03,100 --> 00:17:05,700
entonces

268
00:17:05,700 --> 00:17:10,839
¿qué podéis hacer aquí?

269
00:17:11,460 --> 00:17:12,140
si hizo

270
00:17:12,140 --> 00:17:14,619
args.length

271
00:17:14,619 --> 00:17:20,849
para que me diga

272
00:17:20,849 --> 00:17:23,069
que tiene cuatro parámetros

273
00:17:23,069 --> 00:17:24,950
y luego me dice cuáles son los parámetros

274
00:17:24,950 --> 00:17:27,589
este es un array, normal y corriente

275
00:17:27,589 --> 00:17:28,150
¿vale?

276
00:17:28,509 --> 00:17:31,450
esta es una forma de pasarle datos

277
00:17:31,450 --> 00:17:32,950
en vez de

278
00:17:32,950 --> 00:17:34,950
dentro desde el usuario

279
00:17:34,950 --> 00:17:36,430
en el momento en que se lanza

280
00:17:36,430 --> 00:17:39,410
¿vale? y muchos programas

281
00:17:39,410 --> 00:17:40,950
cuando se lanzan ya tienen varios

282
00:17:40,950 --> 00:17:43,630
argumentos, usa esos argumentos

283
00:17:43,630 --> 00:17:44,750
y trabaja

284
00:17:44,750 --> 00:17:46,250
repito que por ahora

285
00:17:46,250 --> 00:17:49,730
sepa que existe, esto es para completar

286
00:17:49,730 --> 00:17:52,490
que es esto, porque hasta ahora no lo sabíamos

287
00:17:52,490 --> 00:17:55,470
y ahora tenemos todos los elementos para entender que es esto, por lo tanto

288
00:17:55,470 --> 00:17:57,910
lo vemos, probablemente

289
00:17:57,910 --> 00:18:01,410
lo usaremos relativamente poco, porque normalmente

290
00:18:01,410 --> 00:18:03,690
damos datos de otra forma, pero

291
00:18:03,690 --> 00:18:07,569
es una forma, por ejemplo, lo que decía

292
00:18:07,569 --> 00:18:10,109
de poder pasar por parámetros

293
00:18:10,109 --> 00:18:13,430
a vuestros programas, ficheros

294
00:18:13,430 --> 00:18:17,329
de configuración alternativos o cosas por el estilo que si aquí no hay nada

295
00:18:17,329 --> 00:18:23,210
pilla el fichero de configuración por defecto si aquí se lo explícito pues

296
00:18:23,210 --> 00:18:32,009
pillará los datos que yo le doy dudas sobre esto

297
00:18:32,009 --> 00:18:40,279
paz si acabo de hacerte un ejemplo imagínate que tú tienes un fichero con

298
00:18:40,279 --> 00:18:49,970
con información algo que podéis utilizar vosotros si vosotros conocéis ping si por ejemplo trabajar

299
00:18:49,970 --> 00:18:57,789
es el próximo curso con apache o cosas por el estilo que son servidores web pues servidores

300
00:18:57,789 --> 00:19:04,710
web tienen un conjunto de ficheros de configuración vale y tú a lo mejor cuando lanzas el apache puede

301
00:19:04,710 --> 00:19:09,950
decir apache a secas y lo que estás lanzando es con los ficheros de configuración suyos o le

302
00:19:09,950 --> 00:19:11,970
puedes explicitar, oye mira, no uses

303
00:19:11,970 --> 00:19:14,369
los ficheros normales

304
00:19:14,369 --> 00:19:15,990
pero usa este fichero de aquí, ¿qué te

305
00:19:15,990 --> 00:19:17,970
paso yo? ¿vale? o por ejemplo

306
00:19:17,970 --> 00:19:20,069
en el ping, el ping normalmente lo que

307
00:19:20,069 --> 00:19:22,190
hace es lanzar cuatro veces un mensaje

308
00:19:22,190 --> 00:19:24,049
a otro, ¿vale? pero si

309
00:19:24,049 --> 00:19:26,049
tú no quieres lanzarlo cuatro veces, tú lo quieres

310
00:19:26,049 --> 00:19:28,190
lanzar infinitas veces para comprobar

311
00:19:28,190 --> 00:19:29,809
el momento en que se

312
00:19:29,809 --> 00:19:31,769
cierra la comunicación

313
00:19:31,769 --> 00:19:34,049
pues entonces le puedes dar el parámetro menos t

314
00:19:34,049 --> 00:19:35,990
¿vale? entonces si tú haces tu

315
00:19:35,990 --> 00:19:37,849
java que normalmente

316
00:19:37,849 --> 00:19:39,930
hace una cosa, pero si le pones el parámetro

317
00:19:39,930 --> 00:19:41,809
menos t, hace una cosa distinta

318
00:19:41,809 --> 00:19:43,390
o el parámetro t hace otra cosa

319
00:19:43,390 --> 00:19:45,130
pues lo puedes hacer con este de aquí

320
00:19:45,130 --> 00:19:47,789
tú tienes tu programa que funciona sin parámetros

321
00:19:47,789 --> 00:19:49,430
o no funciona sin parámetros

322
00:19:49,430 --> 00:19:51,490
por ejemplo, el ejercicio que hemos hecho ahora

323
00:19:51,490 --> 00:19:52,789
no funciona sin parámetros

324
00:19:52,789 --> 00:19:55,910
si tú no le das parámetros, te dice, oye, me tienes que dar parámetros

325
00:19:55,910 --> 00:19:56,769
¿sí?

326
00:19:57,029 --> 00:19:59,609
y en el momento en que en vez tiene parámetros, pues lo que hace

327
00:19:59,609 --> 00:20:00,869
te lo escribe por pantalla

328
00:20:00,869 --> 00:20:03,509
no lo sé, ¿vale? a lo mejor algunos

329
00:20:03,509 --> 00:20:04,890
ejemplos, tú piensa

330
00:20:04,890 --> 00:20:07,329
a los ejercicios que has hecho, que empieza

331
00:20:07,329 --> 00:20:10,650
con dame tu nombre, dame tu edad

332
00:20:10,650 --> 00:20:13,450
pues esta cosa aquí en vez de pedírsela

333
00:20:13,450 --> 00:20:16,210
habrías podido ponerla directamente como argumento

334
00:20:16,210 --> 00:20:18,910
en el momento en que lo lanzas, no es lo normal

335
00:20:18,910 --> 00:20:20,509
porque depende de

336
00:20:20,509 --> 00:20:25,089
mientras lo que pides por consola es

337
00:20:25,089 --> 00:20:26,970
comunicación con el usuario

338
00:20:26,970 --> 00:20:31,230
pues esto es otra cosa, no es el usuario

339
00:20:31,230 --> 00:20:33,970
normalmente que hace esto, sino son parámetros tuyos

340
00:20:33,970 --> 00:20:36,450
que al momento de lanzarlos te sirven de alguna forma

341
00:20:36,450 --> 00:20:46,210
Por ejemplo, podrías decidir dónde, podrías hacer un numerito, 1, 2, 3, que es el nivel de verbose de tu programa.

342
00:20:46,670 --> 00:20:52,150
Que si es 1, no escribe nada. Si es 2, escribe solo las cosas más importantes.

343
00:20:52,390 --> 00:20:56,569
Y si es 3, escribe cualquier cosa que está haciendo. Existe esto, se llama verbose.

344
00:20:57,289 --> 00:21:02,230
Entonces tú, cuando escribes algo en pantalla, en vez de escribirlo directamente, preguntas,

345
00:21:02,230 --> 00:21:04,710
sí, args de cero

346
00:21:04,710 --> 00:21:06,789
vale, no sé qué, pues entonces lo escribes

347
00:21:06,789 --> 00:21:07,250
y si no, no

348
00:21:07,250 --> 00:21:11,029
por ejemplo, si args

349
00:21:11,029 --> 00:21:12,769
de cero

350
00:21:12,769 --> 00:21:16,339
punto equals

351
00:21:16,339 --> 00:21:17,700
verbose

352
00:21:17,700 --> 00:21:27,339
entonces

353
00:21:27,339 --> 00:21:31,079
de cero

354
00:21:31,079 --> 00:21:34,019
entonces escribe también esta frase

355
00:21:34,019 --> 00:21:36,400
si no, no, entonces si yo lo lanzo

356
00:21:36,400 --> 00:21:38,599
ahora, pues no me lo va a escribir

357
00:21:38,599 --> 00:21:40,119
porque el primer

358
00:21:40,119 --> 00:21:41,160
elemento es gato

359
00:21:41,160 --> 00:21:44,200
Si yo cuando lanzo este de aquí

360
00:21:44,200 --> 00:21:48,119
Le digo, no, entra en modalidad verbose

361
00:21:48,119 --> 00:21:52,660
Entonces la primera opción es verbose

362
00:21:52,660 --> 00:21:57,579
Pues ahora al lanzarlo me escribe también los parámetros que tengo

363
00:21:57,579 --> 00:22:05,299
Vale

364
00:22:05,299 --> 00:22:08,960
No, esto

365
00:22:08,960 --> 00:22:14,779
Vale, entonces clase main más o menos, método main más o menos

366
00:22:14,779 --> 00:22:18,400
Entonces, concepto de static

367
00:22:18,400 --> 00:22:21,720
Lo hemos visto, lo hemos probado

368
00:22:21,720 --> 00:22:23,859
Hemos hecho algunos ejemplos y algunas cosillas

369
00:22:23,859 --> 00:22:28,500
Vamos a intentar darle una espincelada más

370
00:22:28,500 --> 00:22:31,759
Para entender la diferencia de cuando hago algo static

371
00:22:31,759 --> 00:22:33,500
Y cuando hago algo no static

372
00:22:33,500 --> 00:22:36,720
Ten en cuenta que esto es algo que luego se os olvida con el tiempo

373
00:22:36,720 --> 00:22:41,380
Pero es una de las cosas muy importantes de la programación orientada a objetos

374
00:22:41,380 --> 00:22:44,359
Por lo tanto, por favor, atención

375
00:22:44,359 --> 00:22:47,220
Y si no lo entendéis, levantad la mano, no hay ningún problema

376
00:22:47,220 --> 00:22:50,700
Entonces, cuando no pongo static

377
00:22:50,700 --> 00:22:56,099
Cuando Java no utiliza la palabra reservada static

378
00:22:56,099 --> 00:22:59,279
Me estoy refiriendo a algo que depende de un objeto concreto

379
00:22:59,279 --> 00:23:04,339
Eso quiere decir que este método, esta variable, este lo que sea

380
00:23:04,339 --> 00:23:07,880
Tiene que estar asociado a un objeto

381
00:23:07,880 --> 00:23:17,640
y que objetos distintos tendrán resultados distintos haciendo lo que estoy llamando, ¿vale?

382
00:23:17,900 --> 00:23:22,259
Static puede ser una variable o un método, por ahora, nosotros, ¿vale? Como lo usamos.

383
00:23:22,640 --> 00:23:27,559
Si es una variable, no static quiere decir que es una variable propia del objeto.

384
00:23:28,279 --> 00:23:34,460
Objetos distintos tendrán copias distintas de esa variable, con el mismo nombre, pero copias distintas,

385
00:23:34,460 --> 00:23:53,500
Y que si yo llamo el nombre de la persona 1 o el nombre de la persona 2, pues tendré cosas distintas ahí dentro. Cada uno tiene lo suyo. Y cuando en vez de no estático un método, no es lo mismo. El resultado será distinto si yo lo llamo sobre el objeto persona 1 o sobre el objeto persona 2.

386
00:23:53,500 --> 00:24:16,160
Por ejemplo, el método saludar no es estático, que no pilla parámetros, y lo que hace es decir hola, me llamo, y su propio nombre, pues si lo llamo sobre persona 1, dirá hola, me llamo, como se llama la persona 1, Paco, y si lo llamo sobre la persona 2, dirá hola, me llamo, Sara, porque la persona 2 tiene como nombre Sara.

387
00:24:16,160 --> 00:24:17,519
¿Se entiende?

388
00:24:19,420 --> 00:24:21,119
Entonces, un atributo de una clase

389
00:24:21,119 --> 00:24:23,559
Aparecerá en todas las instancias de esa clase

390
00:24:23,559 --> 00:24:25,279
Los objetos, pero cada instancia

391
00:24:25,279 --> 00:24:27,500
Podrá tener un valor distinto de ese atributo

392
00:24:27,500 --> 00:24:28,579
¿Sí?

393
00:24:29,180 --> 00:24:30,920
Y un método que no es estático

394
00:24:30,920 --> 00:24:33,299
Quiere decir que hay que llamarlo

395
00:24:33,299 --> 00:24:34,440
Sobre un objeto concreto

396
00:24:34,440 --> 00:24:37,119
Y usará datos de ese objeto concreto

397
00:24:37,119 --> 00:24:38,119
En su ejecución

398
00:24:38,119 --> 00:24:40,640
Normalmente un método no estático

399
00:24:40,640 --> 00:24:43,599
Debería usar algo propio del objeto

400
00:24:43,599 --> 00:24:45,859
Algún variable del objeto

401
00:24:45,859 --> 00:24:48,180
Si no usa nada del objeto

402
00:24:48,180 --> 00:24:50,319
No depende de ese objeto

403
00:24:50,319 --> 00:24:51,619
Y por lo tanto

404
00:24:51,619 --> 00:24:54,519
Podría ser que no lo quiera

405
00:24:54,519 --> 00:24:56,440
No es estático, sino que lo quiera estático

406
00:24:56,440 --> 00:24:57,980
¿Sí?

407
00:24:58,420 --> 00:24:59,240
Ahora hacemos el ejemplo

408
00:24:59,240 --> 00:25:00,940
El ejemplo de no estático

409
00:25:00,940 --> 00:25:03,380
La clase rectángulo

410
00:25:03,380 --> 00:25:06,779
Tiene un largo y un ancho

411
00:25:06,779 --> 00:25:08,319
Tiene una

412
00:25:08,319 --> 00:25:10,220
Funcionalidad que es setData

413
00:25:10,220 --> 00:25:11,160
Que me da el largo

414
00:25:11,160 --> 00:25:12,779
L y B

415
00:25:12,779 --> 00:25:17,619
Y me pone que largo es igual a L y ancho es igual a B

416
00:25:17,619 --> 00:25:20,440
O 10.largo y 10.ancho, me da igual

417
00:25:20,440 --> 00:25:24,819
Y luego tiene área que no pilla parámetros

418
00:25:24,819 --> 00:25:25,920
¿Por qué no pilla parámetros?

419
00:25:26,099 --> 00:25:29,500
¿Dónde encuentro los parámetros para calcular el área?

420
00:25:29,700 --> 00:25:32,240
Desde sus propios atributos

421
00:25:32,240 --> 00:25:37,680
Rectángulo área será igual a largo por ancho

422
00:25:37,680 --> 00:25:41,220
Que son estos, 10.largo por 10.ancho

423
00:25:41,220 --> 00:25:43,839
Y devuelve el área de rectángulo

424
00:25:43,839 --> 00:25:45,599
¿Cómo se usa este señor?

425
00:25:46,059 --> 00:25:48,200
Pues este señor para poder utilizarlos

426
00:25:48,200 --> 00:25:53,740
Necesito crear un rectángulo

427
00:25:53,740 --> 00:25:55,980
Si no creo objetos rectángulos

428
00:25:55,980 --> 00:25:57,519
No puedo hacer nada

429
00:25:57,519 --> 00:26:01,200
Entonces creo REC1 y REC2

430
00:26:01,200 --> 00:26:02,619
Que son dos rectángulos

431
00:26:02,619 --> 00:26:05,839
Al primero le excepto los datos a 5 y 6

432
00:26:05,839 --> 00:26:08,200
Entonces es un rectángulo 5 por 6

433
00:26:08,200 --> 00:26:11,119
Al segundo le excepto los datos 1 y 3

434
00:26:11,119 --> 00:26:12,819
Entonces es un rectángulo 1 por 3

435
00:26:12,819 --> 00:26:17,660
Cuando hago int result es igual a rec.area

436
00:26:17,660 --> 00:26:19,920
Lo que estoy haciendo, rec1.area

437
00:26:19,920 --> 00:26:21,599
Estoy diciendo, oye, cálculame el área

438
00:26:21,599 --> 00:26:22,859
Llámame este método

439
00:26:22,859 --> 00:26:26,420
Pero sobre aquel objeto que es rec1

440
00:26:26,420 --> 00:26:30,259
Que tiene lado 5 y alto 6

441
00:26:30,259 --> 00:26:30,859
O lo que sea

442
00:26:30,859 --> 00:26:34,700
Entonces este método de aquí

443
00:26:34,700 --> 00:26:37,200
Me usará los datos de rectángulo 1

444
00:26:37,200 --> 00:26:38,660
Entonces será 5 por 6

445
00:26:38,660 --> 00:26:42,259
Y este 5 por 6 lo pondrá en resultado

446
00:26:42,259 --> 00:26:44,380
Y luego cuando lo escribe, lo escribe en resultado

447
00:26:44,380 --> 00:26:48,160
Cuando hago esto y vuelvo a usar result

448
00:26:48,160 --> 00:26:51,119
Pero lo llamo sobre rectángulo 2

449
00:26:51,119 --> 00:26:53,160
Pues este es el mismo método

450
00:26:53,160 --> 00:26:57,440
Pero ahora no lo está usando con los datos de rect1

451
00:26:57,440 --> 00:27:00,619
O sea 5 y 6, más lo está usando con los datos de rect2

452
00:27:00,619 --> 00:27:01,720
O sea 1 y 3

453
00:27:01,720 --> 00:27:05,259
Entonces el resultado de área

454
00:27:05,259 --> 00:27:08,440
Depende sobre el objeto que yo lo estoy llamando

455
00:27:08,440 --> 00:27:12,180
Por lo tanto, no es estático

456
00:27:12,180 --> 00:27:17,119
Por lo tanto, área no es estática

457
00:27:17,119 --> 00:27:19,789
¿Dudas?

458
00:27:21,349 --> 00:27:22,029
¿Preguntas?

459
00:27:25,609 --> 00:27:27,670
¿Cuándo en vez de algo es estático?

460
00:27:29,049 --> 00:27:31,289
Cuando estamos en un entorno estático

461
00:27:31,289 --> 00:27:35,630
Me refiero a algo que no pertenece a un objeto concreto

462
00:27:35,630 --> 00:27:37,930
Sino a la clase en general

463
00:27:37,930 --> 00:27:44,670
Entonces yo estoy definiendo la clase rectángulos, la clase persona, la clase lo que sea

464
00:27:44,670 --> 00:27:51,569
Y hay algunos conceptos, algunas variables, algunos atributos o algunos métodos

465
00:27:51,569 --> 00:27:55,009
Que no dependen de personas distintas

466
00:27:55,009 --> 00:28:01,609
Sino que cada persona siempre dará el mismo resultado, siempre tendrá el mismo valor

467
00:28:01,609 --> 00:28:06,150
Es como si fuera una variable compartida entre todas las personas

468
00:28:06,150 --> 00:28:17,529
o un método que cualquier persona que lo llame, en realidad, no use nada de esa persona para poder hacer algo, ¿vale?

469
00:28:17,529 --> 00:28:23,990
Entonces no tiene sentido llamarlo sobre un objeto persona, no tiene ni siquiera sentido tener un objeto persona.

470
00:28:24,569 --> 00:28:35,869
Por ejemplo, imaginamos una variable que dice homo sapiens, entonces todas las personas tienen como variable asociada que su especie es homo sapiens, ¿vale?

471
00:28:35,869 --> 00:28:38,289
Eso no depende de una persona o de otra.

472
00:28:38,390 --> 00:28:42,529
No puedo pillar a otra persona y decir, no, pero tú no eres homo sapiens, eres otra cosa.

473
00:28:43,470 --> 00:28:46,710
Entonces, eso es para todas las personas.

474
00:28:47,250 --> 00:28:52,069
Entonces, esa de allí no sería una variable de objeto, una variable no estática,

475
00:28:52,170 --> 00:28:56,210
sino sería una variable estática porque todas las personas compartirían su especie.

476
00:28:58,230 --> 00:29:02,470
Entonces, cualquier persona que llama, tú no llamarías, si se llama la variable especie,

477
00:29:02,789 --> 00:29:05,450
persona1.especie o persona2.especie.

478
00:29:05,450 --> 00:29:11,390
Si no, llamarías persona.especies, donde persona es la clase.

479
00:29:11,630 --> 00:29:12,509
Ahora hacemos ejemplo.

480
00:29:13,470 --> 00:29:17,630
Una variable estática tendría el mismo valor para cualquier objeto que la use,

481
00:29:17,829 --> 00:29:19,670
no depende del objeto sino de la clase.

482
00:29:20,609 --> 00:29:24,549
Y un método estático no se llama sobre un objeto sino se llama sobre la clase.

483
00:29:24,950 --> 00:29:29,690
Cuando ayer hicimos utils y poníamos dentro leer número,

484
00:29:30,289 --> 00:29:32,009
yo no creaba un objeto de utils.

485
00:29:32,009 --> 00:29:37,150
Utils x es igual a new utils, y luego hacía x.learnumero, ¿vale?

486
00:29:37,329 --> 00:29:40,490
Sino que hacía directamente utils.learnumero.

487
00:29:41,069 --> 00:29:44,269
Estaba llamando el método sobre la clase, no sobre un objeto.

488
00:29:46,430 --> 00:29:49,150
No usa los datos de un objeto concreto para ejecutarse.

489
00:29:49,410 --> 00:29:52,950
Puede usar los datos estáticos de esa clase, ¿vale?

490
00:29:52,950 --> 00:29:57,990
En contextos estáticos se puede utilizar las cosas estáticas.

491
00:29:58,569 --> 00:30:03,089
En contextos estáticos no puede usar cosas estáticas.

492
00:30:03,390 --> 00:30:15,470
¿Qué quiere decir? Si estoy en un método static que depende de la clase, que no está llamado sobre un objeto, no puedo usar variables de un objeto porque no sabría de qué objeto es.

493
00:30:15,470 --> 00:30:34,650
Un método no estático usa los valores del objeto sobre el que lo llamo. Cuando en área tengo que utilizar largo y ancho, sé que son los largos y anchos de este objeto.

494
00:30:34,829 --> 00:30:38,470
pero si yo este método de aquí lo hago estático

495
00:30:38,470 --> 00:30:40,849
entonces no lo llamo sobre un rectángulo

496
00:30:40,849 --> 00:30:44,829
y lo llamo sobre rectángulo como área

497
00:30:44,829 --> 00:30:47,230
como clase, punto área

498
00:30:47,230 --> 00:30:50,470
pues cuando llega aquí y dice úsame largo, ¿largo de quién?

499
00:30:50,750 --> 00:30:53,470
no lo estás usando sobre un objeto, lo estás usando sobre la clase

500
00:30:53,470 --> 00:30:56,809
entonces no tengo ese valor, ese valor es propio de un objeto

501
00:30:56,809 --> 00:30:59,390
tengo que crear un objeto para saber cuánto hay dentro de largo

502
00:30:59,390 --> 00:31:02,309
entonces no lo puedo usar, ahora hacemos ejemplos

503
00:31:02,309 --> 00:31:05,430
en Eclipse y veréis que se enfada.

504
00:31:10,789 --> 00:31:16,910
Después. ¿Vale? Entonces, lo mismo

505
00:31:16,910 --> 00:31:20,910
no es lo mismo. Sí, es lo mismo. Lo mismo

506
00:31:20,910 --> 00:31:24,990
en modalidad estática.

507
00:31:25,329 --> 00:31:28,910
¿Vale? Tengo una clase estática. Aquí tengo un static int

508
00:31:28,910 --> 00:31:32,529
operaciones hechas, que es cero. ¿Vale? Y aquí, mirad,

509
00:31:32,890 --> 00:31:36,029
calcular el rectángulo hace lo mismo que el otro.

510
00:31:36,029 --> 00:31:41,089
Pero como esto es estático, no depende de un objeto

511
00:31:41,089 --> 00:31:45,009
Por lo tanto, esos valores, el ancho y el largo, no los tengo

512
00:31:45,009 --> 00:31:47,450
Se los tengo que pasar como parámetro

513
00:31:47,450 --> 00:31:55,170
Entonces, en el ejemplo anterior, este método se llamaba sobre un objeto

514
00:31:55,170 --> 00:31:59,849
Y era este objeto que empaquetaba los datos necesarios para poder hacer lo que tenga que hacer

515
00:31:59,849 --> 00:32:04,930
Aquí, como no tengo un objeto, los datos necesarios se los estoy pasando por parámetro

516
00:32:04,930 --> 00:32:08,569
y una vez que se lo he pasado por parámetro

517
00:32:08,569 --> 00:32:09,789
hace lo mismo

518
00:32:09,789 --> 00:32:12,769
y fijaos que dentro de un contexto estático

519
00:32:12,769 --> 00:32:14,750
puede usar una variable estática

520
00:32:14,750 --> 00:32:16,130
una variable de esta clase

521
00:32:16,130 --> 00:32:17,269
que es operaciones hechas

522
00:32:17,269 --> 00:32:19,009
cada vez que haga una operación

523
00:32:19,009 --> 00:32:20,349
me suma uno aquí

524
00:32:20,349 --> 00:32:22,190
entonces yo puedo saber

525
00:32:22,190 --> 00:32:26,470
cuantas veces han sido hechas estas operaciones

526
00:32:26,470 --> 00:32:28,829
tanto calcular área como calcular perímetro

527
00:32:28,829 --> 00:32:31,289
porque fijaos que aquí también hace operaciones hechas

528
00:32:31,289 --> 00:32:34,230
y me está contando que cada vez que alguien hace esto

529
00:32:34,230 --> 00:32:35,509
Pues me suma 1 allí

530
00:32:35,509 --> 00:32:37,250
Entonces en cualquier momento puedo decir

531
00:32:37,250 --> 00:32:38,809
¿Cuántas operaciones se han hecho hasta ahora?

532
00:32:39,450 --> 00:32:41,950
Y me dirá cuántas veces se ha calculado un área

533
00:32:41,950 --> 00:32:44,269
O cuántas veces se ha calculado un perímetro

534
00:32:44,269 --> 00:32:45,769
¿Por qué me sirve esto? No lo sé

535
00:32:45,769 --> 00:32:49,009
Eso ya veremos usos

536
00:32:49,009 --> 00:32:54,809
El main, si os fijáis, dice

537
00:32:54,809 --> 00:32:56,849
El área de rectángulo 1 tiene

538
00:32:56,849 --> 00:33:00,069
Fijaos que ahora el método estático

539
00:33:00,069 --> 00:33:02,650
Lo llamo sobre una clase

540
00:33:02,650 --> 00:33:03,970
No sobre un objeto

541
00:33:03,970 --> 00:33:05,930
En ningún momento he hecho una new

542
00:33:05,930 --> 00:33:08,089
¿Vale? Pero ahora

543
00:33:08,089 --> 00:33:10,170
Este solo no me sirve

544
00:33:10,170 --> 00:33:11,529
Para calcular el área del triángulo

545
00:33:11,529 --> 00:33:13,750
Le tendré que decir cuáles son

546
00:33:13,750 --> 00:33:15,890
El ancho y el lado del triángulo

547
00:33:15,890 --> 00:33:17,710
Entonces lo pongo aquí

548
00:33:17,710 --> 00:33:19,289
El ancho y el largo

549
00:33:19,289 --> 00:33:21,109
¿Sí?

550
00:33:22,690 --> 00:33:23,890
Aquí estoy haciendo

551
00:33:23,890 --> 00:33:25,250
El cálculo de otro rectángulo

552
00:33:25,250 --> 00:33:27,190
Está aquí, ¿vale?

553
00:33:27,930 --> 00:33:29,549
Y perímetro, lo que sea

554
00:33:29,549 --> 00:33:31,609
Al final puede escribir

555
00:33:31,609 --> 00:33:33,230
Cuántas operaciones se ha hecho

556
00:33:33,230 --> 00:33:34,809
Cuántas operaciones dará

557
00:33:34,809 --> 00:33:38,599
¿Cuánto dará esto?

558
00:33:45,140 --> 00:33:47,019
Hola, buenos días

559
00:33:47,019 --> 00:33:49,779
Tres

560
00:33:49,779 --> 00:33:52,319
Porque cuando llama este método

561
00:33:52,319 --> 00:33:54,079
Se habrá sumado uno

562
00:33:54,079 --> 00:33:56,180
Cuando llama este método

563
00:33:56,180 --> 00:33:57,779
Se habrá sumado otro

564
00:33:57,779 --> 00:33:59,519
Cuando llama este método

565
00:33:59,519 --> 00:34:01,740
Se habrá sumado un tercero

566
00:34:01,740 --> 00:34:03,779
Entonces, ¿cómo accedo a ese variable?

567
00:34:04,259 --> 00:34:06,140
Pues utilizando su clase

568
00:34:06,140 --> 00:34:07,160
Punto

569
00:34:07,160 --> 00:34:08,679
El nombre de la variable

570
00:34:08,679 --> 00:34:12,309
¿Dudas?

571
00:34:18,579 --> 00:34:23,739
Hagamos un ejemplo

572
00:34:24,460 --> 00:34:26,480
static

573
00:34:26,480 --> 00:34:31,170
y un ejemplo

574
00:34:31,170 --> 00:34:35,820
no static

575
00:34:35,820 --> 00:34:38,059
y

576
00:34:38,059 --> 00:34:42,949
un ejemplo

577
00:34:42,949 --> 00:34:43,849
main

578
00:34:43,849 --> 00:34:48,420
entonces

579
00:34:48,420 --> 00:34:53,320
tengo un ejemplo static y un ejemplo no static

580
00:34:53,320 --> 00:34:55,179
¿vale? pongamos que en el ejemplo

581
00:34:55,179 --> 00:34:56,699
no static este es un objeto

582
00:34:56,699 --> 00:34:59,260
¿vale? tenga algún parámetro

583
00:34:59,260 --> 00:35:01,239
dentro, por ejemplo tiene

584
00:35:01,239 --> 00:35:03,079
un int edad

585
00:35:03,079 --> 00:35:04,320
¿sí?

586
00:35:04,320 --> 00:35:05,559
entonces

587
00:35:05,559 --> 00:35:08,300
ahora yo puedo hacer un programa

588
00:35:08,300 --> 00:35:09,420
un método

589
00:35:09,420 --> 00:35:10,860
que sea el método

590
00:35:10,860 --> 00:35:15,280
public

591
00:35:15,280 --> 00:35:17,780
boolean

592
00:35:17,780 --> 00:35:20,840
puedes entrar

593
00:35:20,840 --> 00:35:22,420
a la

594
00:35:22,420 --> 00:35:23,800
disco

595
00:35:23,800 --> 00:35:28,329
que me dice que si

596
00:35:28,329 --> 00:35:31,090
edad es mayor

597
00:35:31,090 --> 00:35:32,809
igual que 18

598
00:35:32,809 --> 00:35:36,449
return true

599
00:35:36,449 --> 00:35:39,750
return false

600
00:35:39,750 --> 00:35:46,730
Si la edad que tiene

601
00:35:46,730 --> 00:35:48,769
Este valor

602
00:35:48,769 --> 00:35:50,449
Es mayor o igual a 18

603
00:35:50,449 --> 00:35:51,849
Puedes entrar a la discoteca

604
00:35:51,849 --> 00:35:52,449
Si no, no

605
00:35:52,449 --> 00:35:55,530
Ten en cuenta que esto sería así

606
00:35:55,530 --> 00:35:58,969
Funciona igual

607
00:35:58,969 --> 00:36:02,349
Necesitaría un constructor

608
00:36:02,349 --> 00:36:04,489
Entonces tengo un public

609
00:36:04,489 --> 00:36:06,110
Ejemplo

610
00:36:06,110 --> 00:36:07,469
No static

611
00:36:07,469 --> 00:36:09,829
Que recibe un int

612
00:36:09,829 --> 00:36:10,670
E

613
00:36:10,670 --> 00:36:13,969
Y lo que hago es this.edad

614
00:36:13,969 --> 00:36:14,929
es igual a e

615
00:36:14,929 --> 00:36:18,570
¿si? vale, perfecto

616
00:36:18,570 --> 00:36:20,250
entonces, esto quiere decir

617
00:36:20,250 --> 00:36:21,710
que en mi ejemplo main

618
00:36:21,710 --> 00:36:23,730
lo que puedo hacer yo es crear un

619
00:36:23,730 --> 00:36:25,710
ejemplo no

620
00:36:25,710 --> 00:36:26,889
static

621
00:36:26,889 --> 00:36:29,489
1

622
00:36:29,489 --> 00:36:31,110
es igual a new

623
00:36:31,110 --> 00:36:34,010
ejemplo no

624
00:36:34,010 --> 00:36:36,130
static

625
00:36:36,130 --> 00:36:37,610
de

626
00:36:37,610 --> 00:36:39,070
19

627
00:36:39,070 --> 00:36:46,500
no static

628
00:36:46,500 --> 00:36:50,679
se me ha castellanizado

629
00:36:50,679 --> 00:36:51,440
¿Sí?

630
00:36:51,880 --> 00:36:55,739
Puedo crear también otro objeto

631
00:36:55,739 --> 00:37:01,369
Que

632
00:37:01,369 --> 00:37:03,230
Tiene xc

633
00:37:03,230 --> 00:37:06,090
¿Vale? Y ahora me puedo preguntar

634
00:37:06,090 --> 00:37:10,719
Si eso, uno

635
00:37:10,719 --> 00:37:13,059
Si entra uno

636
00:37:13,059 --> 00:37:14,480
A la discoteca, más

637
00:37:14,480 --> 00:37:15,840
Uno punto

638
00:37:15,840 --> 00:37:17,980
Puede entrar a disco

639
00:37:17,980 --> 00:37:25,420
Y dos

640
00:37:25,420 --> 00:37:29,500
Dos, ¿qué me lo llaman?

641
00:37:32,280 --> 00:37:33,940
Entonces, uno

642
00:37:33,940 --> 00:37:35,940
Usará sus datos

643
00:37:35,940 --> 00:37:37,679
Y me dará true

644
00:37:37,679 --> 00:37:40,480
2 usará sus datos

645
00:37:40,480 --> 00:37:41,460
y me dará false

646
00:37:41,460 --> 00:37:43,619
hasta aquí

647
00:37:43,619 --> 00:37:46,179
hagamos lo mismo

648
00:37:46,179 --> 00:37:48,219
en versión estático

649
00:37:48,219 --> 00:37:51,440
en versión estático

650
00:37:51,440 --> 00:37:53,820
lo que hago yo es

651
00:37:53,820 --> 00:37:58,199
utilizar un método

652
00:37:58,199 --> 00:38:00,519
que pero no depende de los atributos

653
00:38:00,519 --> 00:38:01,239
de esta clase

654
00:38:01,239 --> 00:38:04,320
entonces hago un public

655
00:38:04,320 --> 00:38:06,239
static

656
00:38:06,239 --> 00:38:09,940
Voyder, no, Boolean

657
00:38:09,940 --> 00:38:13,199
Entra

658
00:38:13,199 --> 00:38:14,659
Se lo llamo igual

659
00:38:14,659 --> 00:38:18,329
Puedes entrar a disco

660
00:38:18,329 --> 00:38:27,130
Esto será prácticamente igual dentro

661
00:38:27,130 --> 00:38:31,750
Pero el problema es que ahora

662
00:38:31,750 --> 00:38:32,670
La edad yo no lo tengo

663
00:38:32,670 --> 00:38:35,409
Porque no es de un objeto

664
00:38:35,409 --> 00:38:37,269
Antes yo tenía el objeto y decía

665
00:38:37,269 --> 00:38:39,190
Puedes entrar, voy a mirar tu edad

666
00:38:39,190 --> 00:38:40,789
Y en base a eso te digo si sí o no

667
00:38:40,789 --> 00:38:42,449
Pero ahora no

668
00:38:42,449 --> 00:38:46,429
Entonces, ¿de dónde saco este dato?

669
00:38:46,570 --> 00:38:51,469
le pondré un parámetro aquí

670
00:38:51,469 --> 00:38:54,530
¿vale? entonces aquí habrá un int edad

671
00:38:54,530 --> 00:38:57,369
es decir que este método lo que hace es

672
00:38:57,369 --> 00:39:00,429
puedes entrar a disco pero le tienes que pasar la edad

673
00:39:00,429 --> 00:39:02,829
y en base a la edad que le has pasado

674
00:39:02,829 --> 00:39:05,150
lo hará uno

675
00:39:05,150 --> 00:39:09,070
¿cómo se usa esto? pues desde ejemplo main

676
00:39:09,070 --> 00:39:11,510
si yo quiero usarlo haré

677
00:39:11,510 --> 00:39:13,789
ejercicio

678
00:39:13,789 --> 00:39:19,670
3 que no es un objeto

679
00:39:19,670 --> 00:39:22,389
Y daré

680
00:39:22,389 --> 00:39:27,090
Ejemplo static

681
00:39:27,090 --> 00:39:28,909
Lo estoy llamando sobre la clase

682
00:39:28,909 --> 00:39:30,110
Punto

683
00:39:30,110 --> 00:39:32,030
Veis que ahora me aparece aquí

684
00:39:32,030 --> 00:39:33,710
El método static

685
00:39:33,710 --> 00:39:35,349
Puedes entrar a Discord

686
00:39:35,349 --> 00:39:38,369
Que pero necesitará ponerle aquí

687
00:39:38,369 --> 00:39:40,269
Un valor

688
00:39:40,269 --> 00:39:43,619
Con 20

689
00:39:43,619 --> 00:39:44,639
Esto me dará true

690
00:39:44,639 --> 00:39:57,949
Y esto me tendrá que dar

691
00:39:57,949 --> 00:40:01,360
False

692
00:40:01,360 --> 00:40:09,059
¿Veis la diferencia?

693
00:40:09,860 --> 00:40:23,219
Este de aquí no se puede utilizar a menos que no tenga un objeto, porque este método depende del objeto y usa datos de este objeto.

694
00:40:23,559 --> 00:40:28,239
Llamándolo sobre dos objetos distintos, tendré resultados distintos.

695
00:40:29,280 --> 00:40:37,800
Este no depende de ningún objeto porque no usa parámetros de los objetos, usa estos parámetros de aquí, los parámetros que yo le paso.

696
00:40:37,800 --> 00:40:41,940
Pero su resultado no depende de ningún objeto

697
00:40:41,940 --> 00:40:45,340
Distintos objetos harían lo mismo

698
00:40:45,340 --> 00:40:46,400
Me explico

699
00:40:46,400 --> 00:40:48,840
Imaginémonos que yo aquí

700
00:40:48,840 --> 00:40:54,579
Cree otra versión

701
00:40:54,579 --> 00:40:56,119
¿Vale?

702
00:40:56,760 --> 00:40:58,199
Pero no estática

703
00:40:58,199 --> 00:41:01,019
Que haga esto

704
00:41:01,019 --> 00:41:05,420
¿Sí?

705
00:41:06,199 --> 00:41:06,960
Ahora

706
00:41:06,960 --> 00:41:09,219
Esto yo lo puedo llamar desde aquí

707
00:41:09,219 --> 00:41:10,420
Sí

708
00:41:10,420 --> 00:41:11,639
¿Cómo?

709
00:41:11,639 --> 00:41:18,559
Así, déjame copiar esto

710
00:41:18,559 --> 00:41:22,690
Uno bis

711
00:41:22,690 --> 00:41:24,889
Dos bis

712
00:41:24,889 --> 00:41:25,630
¿Vale?

713
00:41:26,190 --> 00:41:28,650
Yo puedo llamar el otro método, sí

714
00:41:28,650 --> 00:41:30,329
Pero le tengo que poner

715
00:41:30,329 --> 00:41:32,630
Algo así

716
00:41:32,630 --> 00:41:34,489
Fijaos

717
00:41:34,489 --> 00:41:36,690
Este señor de aquí tiene dentro

718
00:41:36,690 --> 00:41:38,469
Que tiene, no sé cuántos años tiene

719
00:41:38,469 --> 00:41:40,889
Y este aquí 15

720
00:41:40,889 --> 00:41:42,070
Decía 8 y 15

721
00:41:42,070 --> 00:41:44,829
¿Vale? O sea que esto me debería dar true

722
00:41:44,829 --> 00:41:46,630
Y esto me debería dar false

723
00:41:46,630 --> 00:41:48,630
¿Sí? Sin embargo

724
00:41:48,630 --> 00:41:51,679
True y true

725
00:41:51,679 --> 00:41:52,940
¿Por qué?

726
00:41:53,699 --> 00:41:56,340
Porque ahora ya no dependo de este objeto.

727
00:41:56,840 --> 00:42:01,800
Llamándolo sobre objetos distintos, lo que cuenta es esta variable de aquí.

728
00:42:03,079 --> 00:42:08,619
Porque si os fijáis en su definición, esta es la definición del objeto, ¿vale?

729
00:42:08,619 --> 00:42:14,039
Del no estático, pues se está usando esta edad de aquí.

730
00:42:15,340 --> 00:42:20,460
Entonces, este método, que yo lo he metido como no estático,

731
00:42:20,699 --> 00:42:22,880
o sea, le estoy diciendo, lo tienes que llamar sobre un objeto.

732
00:42:22,940 --> 00:42:27,260
Pero en realidad no depende del objeto, depende solo de esta cosa de aquí

733
00:42:27,260 --> 00:42:33,159
Entonces que yo lo llame sobre un objeto 1 o yo lo llame sobre un objeto 2

734
00:42:33,159 --> 00:42:37,000
Con el mismo parámetro no tiene ninguna diferencia

735
00:42:37,000 --> 00:42:41,079
Entonces esto debería ser estático

736
00:42:41,079 --> 00:42:48,480
Cuando el resultado de este método no depende del objeto sobre el que lo llamo

737
00:42:48,480 --> 00:42:52,440
Debería ser estático, ¿se entiende?

738
00:42:52,440 --> 00:43:08,860
Si yo quito uno, me da error porque en esta clase, él lo busca en esta clase aquí, en la clase ejemplo main, y no hay este método.

739
00:43:10,440 --> 00:43:31,690
Si yo lo llamo sobre ejemplo no static, me da error porque no hay un método estático que se llame así dentro de la clase ejemplo no static.

740
00:43:31,690 --> 00:43:35,130
¿Por qué? Si ahora pusiera aquí static

741
00:43:35,130 --> 00:43:37,190
Pues entonces

742
00:43:37,190 --> 00:43:38,809
Este de aquí

743
00:43:38,809 --> 00:43:40,150
Ahora me dice muy bien

744
00:43:40,150 --> 00:43:42,489
Este de aquí también

745
00:43:42,489 --> 00:43:44,989
¿Vale? Pero es feo

746
00:43:44,989 --> 00:43:47,110
Porque estoy llamando un método estático

747
00:43:47,110 --> 00:43:48,750
Sobre un objeto, esto no tiene sentido

748
00:43:48,750 --> 00:43:50,429
No se suele utilizar

749
00:43:50,429 --> 00:43:52,329
¿Sí?

750
00:43:52,690 --> 00:43:55,409
Él asume que, como lo estás llamando sobre este método

751
00:43:55,409 --> 00:43:57,190
Él asume que lo estás llamando

752
00:43:57,190 --> 00:43:58,550
Sobre esta clase

753
00:43:58,550 --> 00:44:00,750
Porque este objeto es

754
00:44:00,750 --> 00:44:03,210
de esta clase, pero

755
00:44:03,210 --> 00:44:05,389
veis que te lo marca

756
00:44:05,389 --> 00:44:05,949
te dice

757
00:44:05,949 --> 00:44:08,869
el método estático

758
00:44:08,869 --> 00:44:11,610
método estático

759
00:44:11,610 --> 00:44:13,489
este de aquí, de la clase

760
00:44:13,489 --> 00:44:15,630
ejemplo no estático, debería

761
00:44:15,630 --> 00:44:17,590
ser accedido

762
00:44:17,590 --> 00:44:18,670
en un

763
00:44:18,670 --> 00:44:20,969
modo estático, o sea

764
00:44:20,969 --> 00:44:23,630
no sobre un objeto, sino sobre la clase

765
00:44:23,630 --> 00:44:25,670
aún así

766
00:44:25,670 --> 00:44:27,489
te dice, bueno, entiendo lo que querías hacer

767
00:44:27,489 --> 00:44:29,469
pero te lo marco

768
00:44:29,469 --> 00:44:35,199
Repito que si aquí quito lo static

769
00:44:35,199 --> 00:44:37,619
Pues esto se enfada

770
00:44:37,619 --> 00:44:41,599
Y repito también que este método de aquí

771
00:44:41,599 --> 00:44:43,380
Debería ser static

772
00:44:43,380 --> 00:44:47,000
Porque no hace referencia aquí dentro

773
00:44:47,000 --> 00:44:48,400
A nada de este objeto

774
00:44:48,400 --> 00:44:51,840
¿Dudas?

775
00:44:53,980 --> 00:44:54,800
Más cosillas

776
00:44:54,800 --> 00:44:56,280
Y fijaos que este es un error

777
00:44:56,280 --> 00:44:57,179
¿Vale?

778
00:44:57,619 --> 00:44:58,199
Porque yo

779
00:44:58,199 --> 00:45:00,119
Me has dicho que no es estático

780
00:45:00,119 --> 00:45:01,239
Que depende de un objeto

781
00:45:01,239 --> 00:45:04,840
Entonces cuando yo lo llamo sobre una clase

782
00:45:04,840 --> 00:45:06,860
no sabría, no lo puede hacer

783
00:45:06,860 --> 00:45:08,900
porque necesito el objeto para poder llamar

784
00:45:08,900 --> 00:45:13,099
el último ejemplo

785
00:45:13,099 --> 00:45:14,860
es con

786
00:45:14,860 --> 00:45:16,920
variables estáticas, porque el

787
00:45:16,920 --> 00:45:19,079
acceso a esta variable aquí

788
00:45:19,079 --> 00:45:20,840
más o menos lo tenemos claro

789
00:45:20,840 --> 00:45:22,880
lo hemos ya hecho, vale, yo desde aquí

790
00:45:22,880 --> 00:45:23,760
puedo poner

791
00:45:23,760 --> 00:45:29,639
siso1.edad

792
00:45:30,639 --> 00:45:33,079
y esto me escribe

793
00:45:33,079 --> 00:45:34,460
la edad de 1

794
00:45:34,460 --> 00:45:36,900
aquí, 19

795
00:45:36,900 --> 00:45:41,420
La cosa que todavía no hemos utilizado

796
00:45:41,420 --> 00:45:42,159
No hemos visto

797
00:45:42,159 --> 00:45:44,860
Es que en el ejemplo estático

798
00:45:44,860 --> 00:45:47,079
Yo puedo crear una variable estática

799
00:45:47,079 --> 00:45:48,679
Static

800
00:45:48,679 --> 00:45:50,340
Public

801
00:45:50,340 --> 00:45:52,519
Static

802
00:45:52,519 --> 00:45:57,780
Personas

803
00:45:57,780 --> 00:45:59,039
En la disco

804
00:45:59,039 --> 00:46:08,880
Que me está diciendo

805
00:46:08,880 --> 00:46:10,780
Cuántas personas han entrado en la disco

806
00:46:10,780 --> 00:46:12,760
Entonces

807
00:46:12,760 --> 00:46:14,440
Cuando puedes entrar en la cosa

808
00:46:14,440 --> 00:46:17,239
Si yo entro aquí dentro y tienes mayor que 18

809
00:46:17,239 --> 00:46:18,820
Entonces has entrado en la disco

810
00:46:18,820 --> 00:46:22,820
Puedo hacer personas en la disco

811
00:46:22,820 --> 00:46:25,570
Más, más

812
00:46:25,570 --> 00:46:27,730
Sí

813
00:46:27,730 --> 00:46:35,150
Que si tú pones int así

814
00:46:35,150 --> 00:46:37,250
Ahora para que esto funcione

815
00:46:37,250 --> 00:46:39,829
Necesitas un ejemplo, un objeto ejemplo static

816
00:46:39,829 --> 00:46:43,050
Sin embargo, si lo pones así

817
00:46:43,050 --> 00:46:44,690
No necesitas un ejemplo static

818
00:46:44,690 --> 00:46:46,929
Y que si lo pones así

819
00:46:46,929 --> 00:46:49,369
Cada objeto ejemplo static

820
00:46:49,369 --> 00:46:52,469
tiene una copia distinta de personas en la disco

821
00:46:52,469 --> 00:46:54,789
entonces si este objeto suma uno

822
00:46:54,789 --> 00:46:56,869
este objeto no lo suma

823
00:46:56,869 --> 00:47:01,489
no está compartido entre objetos de esta cosa

824
00:47:01,489 --> 00:47:06,329
mientras que así es una cosa de la lista

825
00:47:06,329 --> 00:47:10,110
entonces cada vez que yo ejecutaré

826
00:47:10,110 --> 00:47:13,130
este tipo de estos

827
00:47:13,130 --> 00:47:15,849
estaré sumando uno a esta variable

828
00:47:15,849 --> 00:47:18,909
si entra, si no entra no

829
00:47:18,909 --> 00:47:41,179
Y entonces aquí me puedo preguntar si eso, gente en la disco, estática, y puedo hacer ejemplo static, punto, y acceder a esta variable de aquí.

830
00:47:45,500 --> 00:47:50,760
Fijaos que esto no es de un objeto, es de una clase.

831
00:47:52,380 --> 00:47:56,420
Entonces si yo lo lanzo ahora, en la clase estática hay uno.

832
00:47:56,500 --> 00:47:58,800
¿Vale? Porque he llamado solo una vez

833
00:47:58,800 --> 00:48:02,300
¿Dudas hasta aquí?

834
00:48:06,260 --> 00:48:06,460
Vale

835
00:48:06,460 --> 00:48:10,039
Si yo pongo esto

836
00:48:10,039 --> 00:48:11,059
Como estático

837
00:48:11,059 --> 00:48:13,280
Esto depende de esta clase

838
00:48:13,280 --> 00:48:16,159
¿Vale? Entonces todas las clases

839
00:48:16,159 --> 00:48:17,199
Todas las

840
00:48:17,199 --> 00:48:20,079
Esta clase tiene una única variable

841
00:48:20,079 --> 00:48:22,300
¿Vale? Una única variable personal a disco

842
00:48:22,300 --> 00:48:24,400
Cuando se está sumando

843
00:48:24,400 --> 00:48:25,760
O restando sobre esta variable

844
00:48:25,760 --> 00:48:26,820
Todos

845
00:48:26,820 --> 00:48:30,239
Hay solo esa variable

846
00:48:30,239 --> 00:48:34,239
Entonces todos que acceden a esta variable ven que ha cambiado

847
00:48:34,239 --> 00:48:37,179
Si yo esto lo quito como static

848
00:48:37,179 --> 00:48:43,039
Ahora esta de aquí es una cosa que depende de un objeto

849
00:48:43,039 --> 00:48:48,579
Entonces primero no puedo acceder a ella como ejemplo static.personal.disco

850
00:48:48,579 --> 00:48:53,559
Porque depende de un objeto, necesito un objeto ejemplo static

851
00:48:53,559 --> 00:48:56,239
Tendré que hacer new ejemplo static por algún lado

852
00:48:56,239 --> 00:49:00,159
Y que si ahora en un new ejemplo static sumo 1

853
00:49:00,159 --> 00:49:02,019
En otro objeto

854
00:49:02,019 --> 00:49:04,460
No tendré la misma variable

855
00:49:04,460 --> 00:49:06,800
Tendré variables distintas

856
00:49:06,800 --> 00:49:09,699
A ver si lo consigo hacer

857
00:49:09,699 --> 00:49:12,320
Fijaos que esto no lo puedo hacer ahora

858
00:49:12,320 --> 00:49:12,920
¿Por qué no?

859
00:49:20,590 --> 00:49:22,289
Porque este es un objeto

860
00:49:22,289 --> 00:49:24,730
Y yo estoy en un entorno estático

861
00:49:24,730 --> 00:49:26,190
Esto es

862
00:49:26,190 --> 00:49:27,989
Estoy hablando de la clase

863
00:49:27,989 --> 00:49:31,030
No estoy en ningún objeto concreto

864
00:49:31,030 --> 00:49:32,349
Y de repente te digo

865
00:49:32,349 --> 00:49:34,530
Oye, añádele uno a persona en la disco

866
00:49:34,530 --> 00:49:36,670
Pero es algo que depende de un objeto

867
00:49:36,670 --> 00:49:38,550
Y no te he dicho de qué objeto

868
00:49:38,550 --> 00:49:40,449
Por lo tanto no lo puede hacer

869
00:49:40,449 --> 00:49:42,449
Y se enfada y te lo dice

870
00:49:42,449 --> 00:49:46,110
No puedes hacer una referencia estática

871
00:49:46,110 --> 00:49:48,190
A un campo no estático

872
00:49:48,190 --> 00:49:50,389
Que es este campo aquí

873
00:49:50,389 --> 00:49:54,289
Desde un entorno estático

874
00:49:54,289 --> 00:49:57,469
En el que no saben qué objeto estás trabajando

875
00:49:57,469 --> 00:49:59,369
Porque estás trabajando sobre la clase

876
00:49:59,369 --> 00:50:03,250
No puedes modificar un campo no estático

877
00:50:03,250 --> 00:50:04,590
Que depende de un objeto

878
00:50:04,590 --> 00:50:12,480
Puedes trabajar con cosas estáticas también

879
00:50:12,480 --> 00:50:14,500
Pero no con cosas no estáticas

880
00:50:14,500 --> 00:50:21,269
Vamos a meter algo parecido aquí

881
00:50:21,269 --> 00:50:23,849
A esto en el otro

882
00:50:23,849 --> 00:50:28,440
En el ejemplo no estático

883
00:50:28,440 --> 00:50:32,519
Public si queréis, ahora luego vemos que es este de public

884
00:50:32,519 --> 00:50:38,829
Y hagamos que si puede entrar a la clase

885
00:50:38,829 --> 00:50:42,210
A la cosa pues hago

886
00:50:42,210 --> 00:50:45,230
Personas en la disco

887
00:50:45,230 --> 00:50:45,449
Más

888
00:50:45,449 --> 00:50:49,210
Tiene que ir antes

889
00:50:49,210 --> 00:50:54,550
Parece lo mismo

890
00:50:54,550 --> 00:50:57,190
¿Sí? Ahora, ¿cómo uso

891
00:50:57,190 --> 00:51:02,320
Esto? En un determinado

892
00:51:02,320 --> 00:51:04,239
Momento, yo aquí he entrado

893
00:51:04,239 --> 00:51:06,280
Personas, ha entrado personas

894
00:51:06,280 --> 00:51:08,159
¿Vale? Hagamos

895
00:51:08,159 --> 00:51:09,719
Que los dos puedan entrar

896
00:51:09,719 --> 00:51:15,670
Pueden entrar, ¿vale?

897
00:51:16,289 --> 00:51:18,289
Entran, entonces ahora

898
00:51:18,289 --> 00:51:20,010
Me pregunto, si hizo

899
00:51:20,010 --> 00:51:21,989
Uno punto

900
00:51:21,989 --> 00:51:23,750
personas en la disco

901
00:51:23,750 --> 00:51:25,789
exciso

902
00:51:25,789 --> 00:51:30,980
dos puntos personas en la disco

903
00:51:30,980 --> 00:51:39,920
¿cuánto me debería dar?

904
00:51:42,969 --> 00:51:44,389
si esto está pensado

905
00:51:44,389 --> 00:51:46,170
como quiero saber cuántas personas

906
00:51:46,170 --> 00:51:47,550
hay en la disco en este momento

907
00:51:47,550 --> 00:51:50,389
esto está mal hecho, porque cada uno

908
00:51:50,389 --> 00:51:51,650
contará a sí mismo

909
00:51:51,650 --> 00:51:58,289
¿veis? sin embargo

910
00:51:58,289 --> 00:51:59,550
la que es estática

911
00:51:59,550 --> 00:52:02,210
si yo pongo dos personas

912
00:52:02,210 --> 00:52:03,510
que sí pueden entrar

913
00:52:03,510 --> 00:52:06,170
a ver

914
00:52:06,170 --> 00:52:06,809
Donde están

915
00:52:06,809 --> 00:52:11,480
Aquí, aquí, aquí

916
00:52:11,480 --> 00:52:13,559
Si pongo dos personas que

917
00:52:13,559 --> 00:52:15,099
Pueden entrar

918
00:52:15,099 --> 00:52:18,219
Ahora me dirá que hay dos personas

919
00:52:18,219 --> 00:52:21,070
En la disco

920
00:52:21,070 --> 00:52:22,849
¿Se entiende la diferencia?

921
00:52:25,190 --> 00:52:27,369
O sea, que unes todo depende del objeto

922
00:52:27,369 --> 00:52:29,590
Cada objeto tiene sus copias de cosas

923
00:52:29,590 --> 00:52:30,469
¿Vale?

924
00:52:30,909 --> 00:52:31,429
Paint

925
00:52:31,429 --> 00:52:36,090
Cuando yo hago una cosa no estática

926
00:52:36,090 --> 00:52:39,110
Yo tengo aquí mi edad

927
00:52:39,110 --> 00:52:43,059
Y también mi personas en la disco

928
00:52:43,059 --> 00:52:46,389
¿Sí?

929
00:52:47,050 --> 00:53:08,150
Cuando creo otro, este es uno, cuando creo otro objeto, dos, tengo mi edad y tengo mi persona, se la disco, es una copia distinta, cuando modifico esto, no se modifica esto, porque son dos objetos distintos, ¿sí?

930
00:53:08,150 --> 00:53:16,190
Entonces, cuando yo llamo el método no estático, irá a mirar este valor de aquí, que es 20, y por lo tanto sumará 1 aquí.

931
00:53:17,070 --> 00:53:22,269
Cuando voy aquí y veo que este aquí es 25, me dirá, muy bien, puedes entrar y sumará 1 aquí.

932
00:53:23,250 --> 00:53:27,980
Esto no me va a 2. Cada uno conta por separado.

933
00:53:28,739 --> 00:53:32,420
Sin embargo, todos estos son instancias de una clase.

934
00:53:32,420 --> 00:53:42,059
Si yo hago un persona en la disco estático, esto no depende de ningún objeto.

935
00:53:44,000 --> 00:53:50,920
Y cuando aquí se suma, no depende de este objeto o de este objeto,

936
00:53:51,059 --> 00:53:52,619
sino depende de la clase en general.

937
00:53:54,480 --> 00:53:57,539
Entonces, para completar.

938
00:53:57,539 --> 00:54:17,500
Y si yo quisiera, en este ejemplo de aquí, que cada uno tuviera su edad, o sea, quiero crear personas así, pero luego quiero saber cuántas personas en la disco hay, lo podría hacer.

939
00:54:17,500 --> 00:54:50,619
Sí. ¿Cómo? Pues esta variable de aquí la hago estática, porque de un contexto estático no puedo acceder a un contexto no estático, pero desde un contexto no estático sí puedo acceder a un contexto estático.

940
00:54:50,619 --> 00:54:58,539
entonces ahora en este ejemplo aquí edad es propia del objeto pero personas en

941
00:54:58,539 --> 00:55:04,000
la disco no es propia del objeto es propia de la clase y que cada vez que

942
00:55:04,000 --> 00:55:11,300
yo admito una persona en la disco estoy sumando uno a esta variable estática de

943
00:55:11,300 --> 00:55:21,190
esta clase ahora esto se enfada porque ahora esta persona la disco aquí no la

944
00:55:21,190 --> 00:55:32,809
debería llamar sobre el objeto sino la debería llamar sobre la clase y

945
00:55:32,809 --> 00:55:39,349
entonces ahora también las dos personas que han entrado