1
00:00:03,180 --> 00:00:29,480
Bien, mirad, seguimos con el tema 2 hoy, mañana ya abrimos el siguiente tema, el tema 3, a lo largo del día os lo pongo ya disponible, en principio para la tarea del tema 2 lo tenéis abierto hasta esta noche, a las 12 de la noche, animaros a intentarla, ya he visto que alguno habéis hecho la entrega, y bueno, pues le echo un ojillo y ya os voy haciendo por ahí comentarios.

2
00:00:29,480 --> 00:00:35,020
Retomando un poco de lo que estuvimos hablando el otro día

3
00:00:35,020 --> 00:00:38,460
Bueno, pues estábamos con algo

4
00:00:38,460 --> 00:00:39,979
Bueno, con este proyecto

5
00:00:39,979 --> 00:00:44,719
Estuvimos comentando un poco como la información

6
00:00:44,719 --> 00:00:47,619
Bueno, antes de ponerme a contaros

7
00:00:47,619 --> 00:00:49,600
Que doy por hecho que no tenéis ninguna pregunta

8
00:00:49,600 --> 00:00:52,799
No sé si queréis hacerme alguna consulta o algo

9
00:00:52,799 --> 00:00:54,579
Antes de arrancar a contaros cosas

10
00:00:54,579 --> 00:00:56,759
¿Alguna duda por ahí?

11
00:00:56,759 --> 00:01:08,340
sí, sí, sí, el código

12
00:01:08,340 --> 00:01:09,599
de hecho yo para verlo

13
00:01:09,599 --> 00:01:12,400
lo subiré a, lo pasaré a Eclipse

14
00:01:12,400 --> 00:01:14,480
y pues aparte de echar un vistazo al código

15
00:01:14,480 --> 00:01:16,319
pues le haré un par de ejecuciones

16
00:01:16,319 --> 00:01:18,140
por ahí, pues con alguna variante

17
00:01:18,140 --> 00:01:19,540
alguna cosilla que quiera comprobar

18
00:01:19,540 --> 00:01:22,540
entonces sí, el código, no es necesario que me envíéis los .class

19
00:01:22,540 --> 00:01:23,260
ni nada de eso

20
00:01:23,260 --> 00:01:25,180
el código ya está, sí

21
00:01:25,180 --> 00:01:28,420
de hecho, o sea, el código seguro

22
00:01:28,420 --> 00:01:29,939
enviármelo, porque es lo que utilizaré yo

23
00:01:29,939 --> 00:01:32,019
aparte de verlo para ejecutarlo, no me envíéis

24
00:01:32,019 --> 00:01:33,659
solo el .class, si me envíéis todo

25
00:01:33,659 --> 00:01:35,200
terminaré cogiendo solo el código

26
00:01:35,200 --> 00:01:36,980
pero solo lo otro no

27
00:01:36,980 --> 00:01:40,750
solo los ejecutables no

28
00:01:40,750 --> 00:02:01,870
hombre, por existir

29
00:02:01,870 --> 00:02:03,870
pues un poco los que

30
00:02:03,870 --> 00:02:06,109
hablábamos en el tema 1

31
00:02:06,109 --> 00:02:08,469
son un poco los que puedes

32
00:02:08,469 --> 00:02:10,590
hacer, de todas formas los diagramas

33
00:02:10,590 --> 00:02:12,849
de flujo en un proyecto como os comentaba

34
00:02:12,849 --> 00:02:14,629
estas semanas

35
00:02:14,629 --> 00:02:16,810
atrás, en un proyecto en general

36
00:02:16,810 --> 00:02:18,650
se suelen definir

37
00:02:18,650 --> 00:02:20,449
antes de hacer el programa, que es un poco

38
00:02:20,449 --> 00:02:21,490
entiendo por donde vas

39
00:02:21,490 --> 00:02:24,229
en la parte de diseño, entonces

40
00:02:24,229 --> 00:02:27,889
yo creo que para nuestros programitas estos que son cortitos

41
00:02:27,889 --> 00:02:30,990
no hace falta, pero bueno, si te animas

42
00:02:30,990 --> 00:02:33,930
en la asignatura de entorno de desarrollo

43
00:02:33,930 --> 00:02:36,629
pues, bueno, aquí habíamos hablado un poquillo

44
00:02:36,629 --> 00:02:39,710
habláis, creo que habláis un poquito también de alguna herramienta

45
00:02:39,710 --> 00:02:42,530
de estas para hacer diagramas de flujo y luego

46
00:02:42,530 --> 00:02:45,650
tiene también una parte de pruebas donde

47
00:02:45,650 --> 00:02:48,270
bueno, se hacen diagramas, digamos, para

48
00:02:48,270 --> 00:02:51,550
ver cómo vas a probar el programa. En esta asignatura

49
00:02:51,550 --> 00:02:53,270
en particular no vamos a trabajar con eso.

50
00:02:54,229 --> 00:02:55,990
No es imprescindible, desde luego.

51
00:03:01,889 --> 00:03:04,229
Vale, pues nada, si no tenéis ninguna cosita más,

52
00:03:05,250 --> 00:03:06,389
continúo contándoos.

53
00:03:07,009 --> 00:03:10,270
Mirad, cuando creamos un programa en Java,

54
00:03:10,669 --> 00:03:12,669
bueno, un programa en cualquier lenguaje,

55
00:03:12,889 --> 00:03:14,849
al final la información tiene que estar,

56
00:03:15,770 --> 00:03:16,689
cuando está en ejecución,

57
00:03:16,870 --> 00:03:18,050
utiliza una serie de variables

58
00:03:18,050 --> 00:03:21,449
y estas variables tienen que utilizar memoria RAM

59
00:03:21,449 --> 00:03:23,110
para ir guardándose durante el tiempo

60
00:03:23,110 --> 00:03:24,310
en el que están en ejecución.

61
00:03:25,110 --> 00:03:26,629
Cosas de las que hablábamos el otro día.

62
00:03:26,629 --> 00:03:28,969
Pues hablábamos de...

63
00:03:29,509 --> 00:03:31,509
el ámbito en el que están definidas las variables.

64
00:03:31,509 --> 00:03:35,509
Las variables, ahora en el programa lo vemos, en Java,

65
00:03:36,669 --> 00:03:41,090
las variables, el código en sí en Java, se encierra entre unas llaves.

66
00:03:44,360 --> 00:03:46,800
Entonces cada bloque de estas llaves es un ámbito

67
00:03:46,800 --> 00:03:50,080
y las variables que defines dentro de un determinado ámbito,

68
00:03:50,419 --> 00:03:56,560
en unas llaves, están disponibles para ese conjunto de instrucciones.

69
00:03:56,979 --> 00:03:58,259
Entonces si yo defino aquí una variable,

70
00:03:58,259 --> 00:04:02,000
imaginamos que tenemos una clase, public class

71
00:04:02,000 --> 00:04:06,419
hola, vamos a llamar a la clase, y luego tenemos un método aquí

72
00:04:06,419 --> 00:04:10,439
y la clase, las clases también están encerradas con unas llaves

73
00:04:10,439 --> 00:04:16,420
la clase, todo lo que definamos como variables

74
00:04:16,420 --> 00:04:20,139
de clase, que cuando hablábamos de la programación orientada a objetos decíamos

75
00:04:20,139 --> 00:04:23,839
que eran métodos que estaban relacionados en sí con

76
00:04:23,839 --> 00:04:28,300
la clase en sí, vamos a poner persona, la clase persona, pues por ejemplo podría ser

77
00:04:28,300 --> 00:04:34,759
el nombre, esta variable estaría disponible en todo

78
00:04:34,759 --> 00:04:38,579
el ámbito de la clase, que sería desde la llave de apertura hasta la llave de cierre.

79
00:04:39,199 --> 00:04:42,500
Si aquí definimos nosotros un método que sea el public void

80
00:04:42,500 --> 00:04:48,889
saludar, el método saludar, y definimos una variable

81
00:04:48,889 --> 00:04:53,170
decimos string también ese saludo

82
00:04:53,170 --> 00:04:57,310
que sea igual a hola

83
00:04:57,310 --> 00:05:02,300
por ejemplo. Y si tenemos aquí otro método que sea despedirse

84
00:05:02,300 --> 00:05:11,660
despedir, pues resulta que la variable saludo

85
00:05:11,660 --> 00:05:15,800
es una variable que está en este ámbito y no está disponible

86
00:05:15,800 --> 00:05:19,879
en este otro, porque en el momento que termina el ámbito donde está definida, que sería en esta otra

87
00:05:19,879 --> 00:05:23,819
llave, ya ha desaparecido. Es decir, cuando nos pongamos a

88
00:05:23,819 --> 00:05:27,759
ejecutar este método, el programa pedirá al sistema operativo un trocito

89
00:05:27,759 --> 00:05:31,680
de memoria RAM donde guardar información que está relacionada con

90
00:05:31,680 --> 00:05:35,660
una cadena de caracteres a la cual va a llamar ese saludo y va

91
00:05:35,660 --> 00:05:39,899
asignarle el valor hola. Y cuando termine el método saludar

92
00:05:39,899 --> 00:05:43,620
queda fuera del ámbito, con lo cual ya se supone que no es una

93
00:05:43,620 --> 00:05:47,720
variable necesaria dentro del programa y el recolector de basura

94
00:05:47,720 --> 00:05:51,680
que hablábamos de él también la semana pasada, liberará esa zona

95
00:05:51,680 --> 00:05:54,759
de memoria RAM. Con lo cual, si yo pongo aquí ese saludo

96
00:05:54,759 --> 00:05:59,800
igual intento actuar sobre esa variable, diciendo que en lugar de decir

97
00:05:59,800 --> 00:06:03,879
hola al despedirse, digas adiós, me dará un error de compilación

98
00:06:03,879 --> 00:06:10,579
porque esta variable no existe en un ámbito en el cual, no está definida en un ámbito en el cual la estoy intentando utilizar,

99
00:06:10,779 --> 00:06:21,439
sino que está definida en este otro. En cambio, si utilizo ese nombre, ese nombre, pongo aquí el nombre de Ana,

100
00:06:22,420 --> 00:06:28,439
esto sí me compilaría, porque me compilaría y me permitiría utilizar esta variable, porque estoy utilizando esa variable

101
00:06:28,439 --> 00:06:37,889
en el ámbito donde el nombre está definido, que es en toda la clase. En relación a esto, si tenemos la clase persona,

102
00:06:37,889 --> 00:06:42,529
podemos definir una serie de variables que tienen que ver de forma muy directa con las personas

103
00:06:42,529 --> 00:06:48,490
y que son relevantes en nuestro programa cuando demos de alta una nueva persona.

104
00:06:49,310 --> 00:06:53,069
Definimos un objeto de la clase persona, que sea la persona José,

105
00:06:53,569 --> 00:06:58,170
y tendrá una variable donde podremos poner un nombre, que será José Manuel, por ejemplo, en mi caso.

106
00:07:00,279 --> 00:07:04,699
Estas variables son las que llamamos variables miembro de clase o variables de clase,

107
00:07:04,699 --> 00:07:06,439
variables de clase o variables miembro.

108
00:07:06,439 --> 00:07:28,879
Y estas otras son variables que están definidas en un ámbito de un método. Realmente la variable saludo nos viene fenomenal dentro del método saludar, pero saludo no es algo que identifique a las personas, sino que tiene su uso realmente en el marco del método saludar.

109
00:07:28,879 --> 00:07:42,060
Por lo tanto, no tenemos que definirla como una variable de clase miembro, sino una variable particular de este método, entonces sería una variable local.

110
00:07:42,060 --> 00:08:05,379
Otra cosa de las que hablábamos a la hora de clasificar el otro día las variables en relación a la memoria RAM era si eran variables primitivas o referenciadas.

111
00:08:06,560 --> 00:08:09,459
Y después voy a incluir otro tipo de variables.

112
00:08:09,660 --> 00:08:15,939
Mirad, otra en relación al uso, digamos, a la reserva de memoria.

113
00:08:16,800 --> 00:08:21,839
Lógicamente, toda variable va a necesitar reservar una zona de memoria,

114
00:08:22,000 --> 00:08:29,740
porque este hola, en algún sitio se tiene que estar guardando por si luego lo quiero utilizar yo posteriormente aquí en el método saludar.

115
00:08:30,139 --> 00:08:34,720
Igual que para esta variable tendrá que haber una zona de memoria que me reservará el sistema operativo

116
00:08:34,720 --> 00:08:40,659
a petición del intérprete de java para poder luego acceder a la información que tenga esa variable

117
00:08:40,659 --> 00:08:47,919
todas ellas necesitarán de un espacio de memoria donde guardar la información ahora bien hay una

118
00:08:47,919 --> 00:08:53,320
serie de variables de tipos de datos que nos permiten generar variables que son las variables

119
00:08:53,320 --> 00:08:59,860
primitivas en java que son aquellas propias del lenguaje java como puede ser string o como puede

120
00:08:59,860 --> 00:09:05,840
ser int, las variables estas como puede ser la variable boolean que hablábamos de ellas el otro

121
00:09:05,840 --> 00:09:14,740
día, la long también de tipo entero, la float ya para meter decimales, todas estas variables se

122
00:09:14,740 --> 00:09:21,299
consideran o se definen como primitivas. El hecho de definir esta variable int a por ejemplo de tipo

123
00:09:21,299 --> 00:09:29,580
a ya directamente permite que hace que el sistema operativo nos reserve el espacio donde guardar la

124
00:09:29,580 --> 00:09:32,379
información del entero, es decir, cuando

125
00:09:32,379 --> 00:09:35,659
el programa se encuentre esto, llegará el intérprete

126
00:09:35,659 --> 00:09:37,879
de Java y le dirá al sistema operativo, búscame espacio

127
00:09:37,879 --> 00:09:41,559
para guardar un valor que necesita

128
00:09:41,559 --> 00:09:44,820
creo que son 32 bits, entonces el sistema operativo

129
00:09:44,820 --> 00:09:47,740
dentro de la RAM, según se esté usando por este programa y por

130
00:09:47,740 --> 00:09:49,700
otros, localizará ese espacio

131
00:09:49,700 --> 00:09:53,039
y a lo mejor en la posición de memoria

132
00:09:53,039 --> 00:09:56,240
30.000, digo 30.000 como podría ser cualquier otra

133
00:09:56,240 --> 00:09:59,159
reservará esos 32 bits donde

134
00:09:59,159 --> 00:10:06,399
a partir de este momento cuando guardemos un número 33 este 33 estará asociada a la etiqueta

135
00:10:06,399 --> 00:10:13,940
a variable local del método saludar lo mismo sucede si defino para un long pues reservará

136
00:10:13,940 --> 00:10:20,399
más espacio de memoria pero si defino el long b pues en otro espacio de memoria reservará esos

137
00:10:20,399 --> 00:10:28,580
bytes donde guardar el dato entonces si metemos aquí 660 cualquier número pues este número

138
00:10:28,580 --> 00:10:32,700
directamente ya se guardará en memoria RAM. Estas son las variables

139
00:10:32,700 --> 00:10:36,879
primitivas. Directamente identificar una variable primitiva

140
00:10:36,879 --> 00:10:40,759
implica reservar en la memoria RAM el espacio donde se

141
00:10:40,759 --> 00:10:44,659
guarda su valor. Luego tenemos, imaginaos que tenemos

142
00:10:44,659 --> 00:10:46,820
aquí otra clase, public class

143
00:10:46,820 --> 00:10:52,019
clase, vamos a llamarla aula.

144
00:10:53,840 --> 00:10:58,059
Imaginaos que en esta clase definimos como variable

145
00:10:58,059 --> 00:11:02,100
miembro, o como cualquier variable

146
00:11:02,100 --> 00:11:05,779
en el main, vamos a poner aquí el método main, y ya no es una variable

147
00:11:05,779 --> 00:11:09,980
miembro, public static void main, recordad el método

148
00:11:09,980 --> 00:11:13,399
main, es el punto de entrada en el programa

149
00:11:13,399 --> 00:11:20,940
paradme si tenéis dudas de cualquiera de las cosas que comento, entonces

150
00:11:20,940 --> 00:11:24,840
aquí en el main, como otro método más, igual que estábamos haciendo aquí en la clase persona

151
00:11:24,840 --> 00:11:28,980
tenemos este método, podríamos definir una variable, en este

152
00:11:28,980 --> 00:11:32,820
caso no una variable miembro, sino una variable local al método main, que fuese

153
00:11:32,820 --> 00:11:37,080
un int, int y valor, entonces esta variable

154
00:11:37,080 --> 00:11:40,639
fijaros, es de tipo int, es una variable de tipo primitiva

155
00:11:40,639 --> 00:11:45,159
pues como igual que antes decíamos, pedirá al sistema operativo

156
00:11:45,159 --> 00:11:49,039
un espacio de memoria para guardar un valor posible

157
00:11:49,039 --> 00:11:52,919
de tipo entero y valor del método main, y ya

158
00:11:52,919 --> 00:11:56,980
directamente se reserva la memoria

159
00:11:56,980 --> 00:12:01,799
para donde va a ir guardándose valores enteros para este valor.

160
00:12:02,519 --> 00:12:06,720
En cambio, si cogemos y decimos que queremos definir una variable,

161
00:12:07,720 --> 00:12:12,100
pero en una variable primitiva, sin una variable, en este caso, referenciada,

162
00:12:13,100 --> 00:12:18,580
lo que estamos diciendo es que vamos a crear una variable de una clase que tenemos nosotros.

163
00:12:18,580 --> 00:12:24,580
En este caso, la variable, si antes definíamos un entero que permitía guardar números,

164
00:12:24,580 --> 00:12:32,019
ahora lo que vamos a definir va a ser una variable del tipo persona y el tipo persona es una clase

165
00:12:32,019 --> 00:12:41,659
que hemos definido nosotros en nuestro programa entonces podemos llamarlo persona 1 y fijaros esta

166
00:12:41,659 --> 00:12:52,809
persona tiene aquí pues tiene diferentes variables miembro estas variables locales al método saludar

167
00:12:52,809 --> 00:12:59,649
variables miembro las variables miembro suelen identificar características muy directas de los

168
00:12:59,649 --> 00:13:06,210
objetos de la clase en la que están asociadas por eso el nombre y la edad si parecen variables que

169
00:13:06,210 --> 00:13:11,690
por diseño tienen que ver con una persona una variable saludar parece que es una variable que

170
00:13:11,690 --> 00:13:16,289
vamos a utilizar en medio de este método para hacer ciertas ciertas actividades con ella pero

171
00:13:16,289 --> 00:13:21,009
saludo no es algo que identifiquen si a las personas por eso está el local y estas son

172
00:13:21,009 --> 00:13:29,370
variables miembro. Cuando estamos definiendo un objeto de la clase que se llama per una de la

173
00:13:29,370 --> 00:13:37,149
clase persona, este per una por pertenecer a esta clase seguirá este esquema y tendrá como

174
00:13:37,149 --> 00:13:43,809
características la de los parámetros que hayamos definido y acciones o métodos que puede realizar

175
00:13:43,809 --> 00:13:50,809
las que tengamos también definidas en la clase. Con lo cual para per una vamos a necesitar espacio

176
00:13:50,809 --> 00:13:59,950
de memoria que tenga que ver con una variable de tipo string que sea su nombre y una variable de tipo entero que sea su edad, según tenemos definido

177
00:13:59,950 --> 00:14:10,570
aquí en nuestro código. Estas variables referenciadas, por defecto, no cogen un espacio de memoria todavía, igual que hacían las primitivas que decíamos

178
00:14:10,570 --> 00:14:20,450
y ya directamente el definir persona per una no implica que ya tengamos un trocito de memoria run que nos haya asignado el sistema operativo

179
00:14:20,450 --> 00:14:23,889
para guardar su nombre o para guardar su edad,

180
00:14:24,929 --> 00:14:29,029
sino que lo que tenemos es una zona de memoria

181
00:14:29,029 --> 00:14:32,950
a partir, digamos, en la que vamos a poder empezar a identificar a PER1.

182
00:14:33,210 --> 00:14:35,389
Imaginaros que el sistema operativo en este caso nos dice

183
00:14:35,389 --> 00:14:40,009
que cuando tú en el programa pongas PER1,

184
00:14:40,970 --> 00:14:46,269
está asociado a la zona de memoria RAM 50.000.

185
00:14:46,269 --> 00:15:16,110
Pero este 50.000 no es ni el nombre que le vayamos a asignar a per una ni su edad. Es una referencia a este objeto. Para de verdad, mira, si ahora cogemos y ponemos aquí per una para esa persona quiero darle una edad, fijaros, la edad del objeto per una igual a 10, por ejemplo, 10 años, esto nos va a dar un error en ejecución.

186
00:15:16,269 --> 00:15:32,769
¿Por qué? Porque el sistema operativo no ha hecho una reserva para donde guardar información para este entero. Por eso las variables que definimos a partir de una clase se llaman referenciadas.

187
00:15:32,769 --> 00:15:44,350
No tenemos esa zona de memoria RAM reservada con la simple definición del objeto al contrario de lo que nos pasaba con este tipo de variable que es primitiva de las iniciales de Java.

188
00:15:45,350 --> 00:15:58,649
Pero oye, nosotros en verdad lo que queremos es poder asignar a esta persona su edad y su nombre y trabajar con ella y permitir que pueda despedirse y permitir que pueda saludar y para eso necesito ese espacio de memoria.

189
00:15:58,649 --> 00:16:16,669
Para obtener ese espacio de memoria, lo que hacemos es decir que per una y aquí utilizamos el operador new y este new es el que coge y nos pide espacio de memoria RAM para donde poder albergar esta información.

190
00:16:17,330 --> 00:16:20,129
Por ser referenciada, necesitamos hacer este segundo paso.

191
00:16:21,909 --> 00:16:27,929
Y luego, disculpad, luego lo que se hace es llamar a un método,

192
00:16:29,450 --> 00:16:35,309
aquí tenemos el método saludar, pues a un método que se llama igual que la clase, persona.

193
00:16:37,049 --> 00:16:41,990
Fijaros que esto, al tener aquí los paréntesis, es que estamos llamando a la ejecución de un método.

194
00:16:42,950 --> 00:16:46,629
Este método es el método constructor, del cual hablaremos más adelante.

195
00:16:47,350 --> 00:16:50,470
Ahora, quería poner el foco aquí en este new.

196
00:16:50,649 --> 00:16:55,509
Este new lo que hace, como os digo, es hacer la reserva de la memoria RAM.

197
00:16:55,509 --> 00:16:58,769
Esto le pide al sistema operativo espacio en la memoria RAM,

198
00:16:58,850 --> 00:17:05,369
donde poder guardar información de aquellos atributos que tiene definida la clase persona.

199
00:17:05,650 --> 00:17:10,089
En particular, para una persona que estoy dando de alta, un objeto que es per1.

200
00:17:11,569 --> 00:17:15,869
Después de hacer esto, si ahora yo cojo y digo per1.iedad igual a 10,

201
00:17:15,869 --> 00:17:17,630
ya sí que me lo permite. ¿Por qué?

202
00:17:18,069 --> 00:17:19,509
Porque gracias a este new

203
00:17:19,509 --> 00:17:21,829
ahora ya tengo un espacio de memoria donde

204
00:17:21,829 --> 00:17:23,750
poder guardar la edad

205
00:17:23,750 --> 00:17:26,069
para la per1, persona1

206
00:17:26,069 --> 00:17:27,970
que es un objeto de la

207
00:17:27,970 --> 00:17:28,670
clase persona.

208
00:17:30,069 --> 00:17:31,630
¿Cómo es como ha funcionado esto?

209
00:17:31,789 --> 00:17:33,950
Pues mirad, este new lo que hace

210
00:17:33,950 --> 00:17:35,750
es, el sistema operativo

211
00:17:35,750 --> 00:17:38,009
dice, voy a buscar

212
00:17:38,009 --> 00:17:39,910
un espacio de memoria donde

213
00:17:39,910 --> 00:17:41,309
guardar esta información

214
00:17:41,309 --> 00:17:44,289
y a lo mejor un nombre y una edad.

215
00:17:44,289 --> 00:17:47,170
es lo que está

216
00:17:47,170 --> 00:17:48,410
realizando esteño

217
00:17:48,410 --> 00:17:50,589
y a lo mejor el sistema operativo dice

218
00:17:50,589 --> 00:17:52,569
pues mira, tengo un espacio, he encontrado

219
00:17:52,569 --> 00:17:54,069
un huequecito en la memoria RAM

220
00:17:54,069 --> 00:17:56,730
en la posición 85.000

221
00:17:56,730 --> 00:17:58,109
estos números

222
00:17:58,109 --> 00:18:00,630
son los que sean, pongo cualquiera

223
00:18:00,630 --> 00:18:01,470
donde

224
00:18:01,470 --> 00:18:02,829
entra

225
00:18:02,829 --> 00:18:06,190
información para

226
00:18:06,190 --> 00:18:08,569
una variable de tipo string, que es el nombre

227
00:18:08,569 --> 00:18:12,329
y una variable

228
00:18:12,329 --> 00:18:17,190
de tipo entero, int, que es la edad.

229
00:18:20,869 --> 00:18:24,349
Reserva desde el 85.000, vamos a suponer hasta, por decir un número,

230
00:18:24,529 --> 00:18:29,990
que no sé exactamente hasta qué cantidad lo hará, hasta el 85.100,

231
00:18:30,150 --> 00:18:34,750
vamos a suponer, hasta el 85.100, que en estos 100 es donde entran

232
00:18:34,750 --> 00:18:39,990
estos dos datos. Y este 85.000, que es donde está el nombre y la edad,

233
00:18:39,990 --> 00:18:52,589
esto, este es el dato que asigna a este 50.000, a PER1. Entonces, en la posición de memoria 50.000, lo que aguarda es el 85.000,

234
00:18:52,710 --> 00:19:01,869
que es a partir de donde tengo los parámetros del objeto PER1 de la clase persona. En definitiva, esta instrucción,

235
00:19:01,869 --> 00:19:03,990
qué es lo que hará si pensamos en memoria.

236
00:19:04,170 --> 00:19:07,809
Por decir, a Peruna, esta la tengo claro, que está en el 50.000.

237
00:19:08,609 --> 00:19:13,809
El 50.000 apunta al 85.000 y edad estará por el 85.000

238
00:19:13,809 --> 00:19:16,430
en algún sitio donde tiene guardada la edad.

239
00:19:20,980 --> 00:19:26,160
¿Se entiende? ¿Más o menos?

240
00:19:28,660 --> 00:19:29,599
¿Sí? Vale.

241
00:19:30,140 --> 00:19:33,839
Pues ahí radica un poco la diferencia de las variables primitivas

242
00:19:33,839 --> 00:19:34,859
y las referenciadas.

243
00:19:35,480 --> 00:19:38,480
Nosotros en un programa donde utilicemos este tipo de variables

244
00:19:38,480 --> 00:19:44,480
no tenemos nunca que preocuparnos de hacer la reserva de memoria, simplemente con la definición de la variable

245
00:19:44,480 --> 00:19:50,579
ya me está asignando ese espacio de RAM para ir trabajando con ese dato.

246
00:19:51,400 --> 00:19:56,839
En cambio, cuando lo que estamos trabajando es con una variable, que en realidad es una instancia,

247
00:19:56,940 --> 00:20:04,109
un objeto de una clase que tenemos definida en nuestro programa, esto lo único que nos hace es

248
00:20:04,109 --> 00:20:09,049
reservar directamente espacio memoria para guardar ese dedito

249
00:20:09,049 --> 00:20:13,269
que apunta al sitio donde luego se va a reservar la memoria

250
00:20:13,269 --> 00:20:16,410
de verdad cuando hagamos el new.

251
00:20:19,349 --> 00:20:24,710
Vale, pues aquí tenemos las primitivas y las referenciadas.

252
00:20:26,170 --> 00:20:29,730
En Java se dice que todo o prácticamente todo,

253
00:20:29,730 --> 00:20:33,789
estas primitivas, luego tienen unas otras clases que son

254
00:20:33,789 --> 00:20:36,049
las wrappers, que en algún momento

255
00:20:36,049 --> 00:20:38,170
haremos alguna cosita con ellas

256
00:20:38,170 --> 00:20:40,069
bueno, durante el curso

257
00:20:40,069 --> 00:20:41,950
pero en algún momento os contaré más explícitamente

258
00:20:41,950 --> 00:20:43,930
que tiene métodos para trabajar con estos tipos

259
00:20:43,930 --> 00:20:46,089
de datos, pero en Java

260
00:20:46,089 --> 00:20:47,049
todo, todo, todo

261
00:20:47,049 --> 00:20:49,869
es un, son

262
00:20:49,869 --> 00:20:52,009
clases, entonces, si venimos

263
00:20:52,009 --> 00:20:53,470
por ejemplo aquí a este ejercicio

264
00:20:53,470 --> 00:20:56,170
que teníamos, fijaros

265
00:20:56,170 --> 00:20:57,609
como un programa

266
00:20:57,609 --> 00:21:00,089
que simplemente tenga un main

267
00:21:00,089 --> 00:21:03,599
donde, aunque solamente

268
00:21:03,599 --> 00:21:07,420
cojamos y hagamos un system.out.println

269
00:21:07,420 --> 00:21:11,799
pongamos un hola, un holamundo

270
00:21:11,799 --> 00:21:14,619
de los que hacíamos ahí al principio, si lo ejecutamos

271
00:21:14,619 --> 00:21:29,460
a ver, que quito por aquí, que tenía más cosas en el proyecto

272
00:21:29,460 --> 00:21:32,500
y no me compila, si no, ya compila

273
00:21:32,500 --> 00:21:35,339
bueno, pues si lo doy aquí a ejecutar

274
00:21:35,339 --> 00:21:38,180
pues nada, me muestra el hola, fijaros como simplemente

275
00:21:38,180 --> 00:21:41,019
este código ya está metido dentro de una clase, es decir

276
00:21:41,019 --> 00:21:44,019
todo va dentro de clases y siempre hay una clase

277
00:21:44,019 --> 00:21:47,019
que al menos tiene que tener un main que es el punto de entrada al programa

278
00:21:49,599 --> 00:22:01,480
Mirad, esto, si veis esto, esto no cuadra del todo al 100% con lo que os estoy contando yo aquí de clases o variables de este tipo o referenciadas.

279
00:22:01,480 --> 00:22:09,839
Porque las primitivas, las variables primitivas son estas, los enteros, los boolean, los longs, estos que guardan datos de los más básicos, los string.

280
00:22:09,839 --> 00:22:14,980
y las referenciadas son variables de objetos

281
00:22:14,980 --> 00:22:19,319
de los cuales definimos nosotros un objeto,

282
00:22:19,500 --> 00:22:21,539
como por ejemplo la clase Persona hacíamos aquí.

283
00:22:22,539 --> 00:22:25,259
Y aquí, en cambio, estamos utilizando un método,

284
00:22:25,259 --> 00:22:28,019
fijaros que los métodos son los que hacen cosas,

285
00:22:28,119 --> 00:22:34,099
recordad, println y tenemos aquí entre paréntesis,

286
00:22:34,400 --> 00:22:37,799
que recibe aquí un valor, pero está metido entre paréntesis.

287
00:22:37,799 --> 00:22:44,740
Entonces, println, ¿qué será? Pues será un método. Hemos dicho que las clases se organizan en parámetros y métodos.

288
00:22:44,819 --> 00:22:47,880
Los métodos son los que hacen cosas, pues este método saca por pantalla.

289
00:22:49,359 --> 00:22:56,039
Entonces me diréis, si tú estás utilizando aquí un método, ¿dónde has definido el objeto que tendrá que ver con esta clase?

290
00:22:56,039 --> 00:22:59,359
System.out, ¿verdad? System será un paquete, out será una clase.

291
00:22:59,920 --> 00:23:01,880
¿Dónde has definido un objeto?

292
00:23:02,000 --> 00:23:04,480
¿Dónde has dicho, voy a definir un objeto

293
00:23:04,480 --> 00:23:08,039
System.out

294
00:23:08,680 --> 00:23:11,119
a, a, a, igual

295
00:23:11,119 --> 00:23:13,920
a new, un poco en el esquema que os decía

296
00:23:13,920 --> 00:23:17,240
del objeto de la clase

297
00:23:17,240 --> 00:23:20,519
persona del que hablábamos antes. Pues resulta

298
00:23:20,519 --> 00:23:23,279
que para trabajar

299
00:23:23,279 --> 00:23:25,279
con objetos

300
00:23:25,279 --> 00:23:29,680
ahora retomo el System.out, para trabajar con objetos

301
00:23:29,680 --> 00:23:34,180
lo que hacemos es definir un objeto de la clase Persona

302
00:23:34,180 --> 00:23:44,299
y podemos definir un segundo objeto de la clase Persona, 2

303
00:23:44,299 --> 00:23:47,960
y ahora hacemos un new de nuevo

304
00:23:47,960 --> 00:23:51,079
y decimos que la persona 2 tiene una edad diferente

305
00:23:51,079 --> 00:23:55,799
ahora vuelvo al System.out, a lo que os iba a contar

306
00:23:55,799 --> 00:24:00,059
pero voy a introducir primero un segundo objeto de la clase Persona

307
00:24:00,059 --> 00:24:02,480
cuando hemos hecho todo esto

308
00:24:02,480 --> 00:24:04,779
se han producido estos pasos

309
00:24:04,779 --> 00:24:06,480
en este primero

310
00:24:06,480 --> 00:24:08,660
per 1 a per

311
00:24:08,660 --> 00:24:10,740
nos había dado este 50.000

312
00:24:10,740 --> 00:24:11,619
que habíamos dicho

313
00:24:11,619 --> 00:24:13,660
por aquí

314
00:24:13,660 --> 00:24:16,319
y cuando hicimos el new

315
00:24:16,319 --> 00:24:18,319
hizo la reserva en el 85.000

316
00:24:18,319 --> 00:24:20,160
y este dato del 85.000

317
00:24:20,160 --> 00:24:22,579
que es donde se guarda el nombre

318
00:24:22,579 --> 00:24:23,200
y la edad

319
00:24:23,200 --> 00:24:26,160
se lo asignó a per 1

320
00:24:26,160 --> 00:24:27,940
con lo cual a través de per 1

321
00:24:27,940 --> 00:24:32,259
50.000 y de este dato somos capaces de llegar

322
00:24:32,259 --> 00:24:36,019
a su nombre y a su edad. Cuando definimos una segunda persona

323
00:24:36,019 --> 00:24:39,960
esta segunda persona queremos que tenga un nombre

324
00:24:39,960 --> 00:24:43,480
y una edad diferente. O podría tenerlo, ¿no?

325
00:24:43,920 --> 00:24:48,180
Entonces, cuando hacemos esta asignación, ¿qué hará el sistema

326
00:24:48,180 --> 00:24:52,059
operativo? Pues igual que hizo aquí y nos dio el

327
00:24:52,059 --> 00:24:56,259
50.000 para la persona 2, cogerá en el sistema operativo

328
00:24:56,259 --> 00:25:01,099
y buscará una zona de memoria, que por ejemplo sea la 100.000.

329
00:25:02,500 --> 00:25:06,900
Y todavía no tendrá asignado un espacio en esta instrucción

330
00:25:06,900 --> 00:25:09,980
donde guardar el nombre y la edad de la persona 2.

331
00:25:09,980 --> 00:25:12,299
¿Por qué? Porque es una variable de tipo referenciado.

332
00:25:13,259 --> 00:25:17,660
En cambio, si hacemos un new a la persona 2,

333
00:25:18,440 --> 00:25:20,039
se producirá el mismo proceso de antes,

334
00:25:20,259 --> 00:25:24,819
buscará un espacio de memoria para la edad y el nombre de esta persona 2

335
00:25:24,819 --> 00:25:28,359
y el sistema operativo vamos a suponer que lo encuentre en la 110.000.

336
00:25:29,220 --> 00:25:37,259
Aquí ha encontrado un huequecito donde guardar información para un nombre, un string y una edad, un entero.

337
00:25:38,119 --> 00:25:47,299
Y este 100.000, 110.000 se lo va a asignar como consecuencia de este new a PER2 porque es al que se lo estamos aplicando aquí.

338
00:25:47,299 --> 00:26:00,299
Entonces este apuntará a 110.000 y en este 110.000 se reservará un trocito para guardar el string para el nombre y el entero para la edad de esta segunda persona.

339
00:26:00,299 --> 00:26:20,099
Con lo cual, cuando nosotros pongamos per1 y edad igual a 10, en algún espacio de este trocito se guardará ese 10 para el entero y cuando digamos per2 igual a 20, en algún trocito de este otro espacio, del 110.000, se guardará el 20.

340
00:26:20,519 --> 00:26:27,200
Fijaros que tenemos para una variable una zona de memoria y para otra, otra zona de memoria.

341
00:26:27,779 --> 00:26:34,819
La verdad, ambas dos son la edad, pero cada una corresponde a una persona distinta que es per1 y per2 dentro de nuestro programa.

342
00:26:34,819 --> 00:26:41,579
Cada uno de los objetos tiene su espacio de memoria.

343
00:26:43,519 --> 00:26:44,519
Mira, retomamos esto.

344
00:26:45,380 --> 00:26:56,519
Aquí no hemos definido un objeto, no hemos definido un objeto de la clase System.out y hemos cogido y hemos dicho luego a.ejecuto el método.

345
00:26:56,519 --> 00:27:09,259
No, directamente lo hemos utilizado. ¿Esto qué supone? Pues resulta que hay una serie de clases que tienen información que es común para todos los objetos de la clase.

346
00:27:12,329 --> 00:27:17,430
Mirad, aquí el nombre en la persona no puede ser común a todos los objetos de la clase.

347
00:27:17,569 --> 00:27:23,049
Si tuviera una única zona de memoria, es decir, el nombre fuese común para todos los objetos de la clase,

348
00:27:23,049 --> 00:27:38,869
si nosotros pusiésemos per1.nombre, ese nombre, igual a Rubén, pues guardaría en una zona de memoria Rubén.

349
00:27:39,009 --> 00:27:40,410
En verdad lo está haciendo por aquí.

350
00:27:40,410 --> 00:28:06,140
Y si ponemos per2 ese nombre noa, en realidad lo estará guardando por aquí, ¿verdad? En la zona donde habíamos reservado.

351
00:28:06,619 --> 00:28:19,380
Si el nombre fuese común para todas las personas, lo que tendríamos no sería un trocito para el nombre reservado para per1 y otro trocito para el nombre reservado para per2,

352
00:28:19,380 --> 00:28:27,119
sino que tendríamos, si todos tuvieran el mismo nombre, resulta que esto es un club de aquellas personas que se llaman NOA.

353
00:28:27,819 --> 00:28:35,359
Pues entonces, la clase, no cada uno de los objetos per1 y per2, sino la clase persona, para la clase persona,

354
00:28:36,900 --> 00:28:47,210
se reservaría un trocito de memoria donde guardar el nombre.

355
00:28:47,210 --> 00:28:51,329
entonces si cogiésemos y dijésemos per1 igual a Rubén

356
00:28:51,329 --> 00:28:54,650
en ese trocito de memoria ya que es común a todos ellos

357
00:28:54,650 --> 00:28:59,200
se pondría Rubén y si luego pongo

358
00:28:59,200 --> 00:29:02,019
per2 igual a noa como la zona de memoria

359
00:29:02,019 --> 00:29:04,279
bajo ese supuesto sería común

360
00:29:04,279 --> 00:29:08,559
y sería común a todos los objetos de esa clase

361
00:29:08,559 --> 00:29:11,579
persona en el mismo espacio de memoria se pondría noa

362
00:29:11,579 --> 00:29:13,279
y sobre escribiría Rubén

363
00:29:13,279 --> 00:29:17,059
entonces en este código fijaros si pusiéramos

364
00:29:17,059 --> 00:29:21,259
suponiendo que el nombre es común para todos los objetos

365
00:29:21,259 --> 00:29:27,799
de la persona, si nosotros ponemos aquí un system.out.println

366
00:29:27,799 --> 00:29:39,349
per1.eseNombre, viendo el código pensaríamos que nos va a poner

367
00:29:39,349 --> 00:29:42,170
Rubén porque hemos asignado el valor Rubén aquí, luego hemos

368
00:29:42,170 --> 00:29:45,549
asignado el valor Rubén no aquí, pero a per2 y muestro

369
00:29:45,549 --> 00:29:50,549
per1.eseNombre. El código nos invita a pensar que lo que va a

370
00:29:50,549 --> 00:29:54,410
escribir esto por pantalla va a ser Rubén. Pero en cambio lo que escribiría

371
00:29:54,410 --> 00:29:58,109
en este caso sería Noah. ¿Por qué? Porque como la zona de común,

372
00:29:58,609 --> 00:30:02,569
la zona de memoria sería común, el Rubén que se había escrito aquí

373
00:30:02,569 --> 00:30:05,130
lo habría sobrescrito este otro.

374
00:30:06,490 --> 00:30:10,410
Y es común hasta tal punto de que para escribir cuando

375
00:30:10,410 --> 00:30:14,210
una de estas variables o métodos, esto sirve para los métodos,

376
00:30:14,369 --> 00:30:18,410
recordad los métodos que son las acciones que hacen los objetos de la clase

377
00:30:18,410 --> 00:30:23,009
o los atributos, cuando se trata de métodos

378
00:30:23,009 --> 00:30:27,130
que son comunes, ahora os hablo de cómo lo definimos, podemos escribirlo

379
00:30:27,130 --> 00:30:35,630
incluso de esta forma, poner persona.eseNombre, imaginaos que

380
00:30:35,630 --> 00:30:42,420
hacemos un system.out de persona.eseNombre, esto nos

381
00:30:42,420 --> 00:30:46,460
valdría siempre y cuando ese nombre, esta

382
00:30:46,460 --> 00:30:50,380
variable, una variable miembro o de clase, se haya

383
00:30:50,380 --> 00:30:54,559
definido, ahora os digo cómo se hace, de forma común a todos los objetos

384
00:30:54,559 --> 00:30:58,319
de la clase, porque no hay lugar

385
00:30:58,319 --> 00:31:02,440
a incertidumbre de a qué nombre se está refiriendo. Si es común

386
00:31:02,440 --> 00:31:06,599
está claro que se está refiriendo a este. En cambio, si no lo hemos

387
00:31:06,599 --> 00:31:10,019
definido como común, vamos a poner aquí y edad

388
00:31:10,019 --> 00:31:14,539
que no hemos hablado en ningún momento que todas

389
00:31:14,539 --> 00:31:18,420
las personas tengan la misma edad, sino que cada una tiene su edad, tal y como habíamos

390
00:31:18,420 --> 00:31:22,299
distribuido por aquí antes para la PER 1 estará guardada la edad por aquí

391
00:31:22,299 --> 00:31:33,650
y para la per 2 estará guardada la edad por aquí esto no me no sé no me entendéis pero no me

392
00:31:33,650 --> 00:31:50,549
entendéis o no me oís pero pero por el micrófono o por la explicación voy a cuelgo y me conecto de

393
00:31:50,549 --> 00:31:56,309
nuevo vale no paro no paro la grabación al menos en la grabación si os va quedando pero voy a

394
00:31:56,309 --> 00:32:26,589
colgar y me vuelvo a conectar aunque veáis que me salgo esperarme un segundo ahí bueno estoy de

395
00:32:26,589 --> 00:32:35,190
vuelta no sé si hemos resuelto algo o no ahora sí vale pues voy a compartir pantalla de nuevo

396
00:32:35,190 --> 00:32:51,680
vale pues nada continuó lo que estaba comentando era en relación a las variables que son comunes

397
00:32:51,680 --> 00:32:58,220
a todos los objetos de una clase o no lo son estábamos haciendo el supuesto de que todo en

398
00:32:58,220 --> 00:33:04,240
esta clase persona ahora os digo cómo se asigna eso por código todos los nombres tuviesen el mismo

399
00:33:05,359 --> 00:33:08,700
todos los objetos tuviesen el mismo nombre, con lo cual esta variable sería común

400
00:33:08,700 --> 00:33:13,440
y como consecuencia de ello, en la memoria RAM solamente reservaríamos

401
00:33:13,440 --> 00:33:17,859
un trocito de memoria RAM para un solo stream y estaría relacionado

402
00:33:17,859 --> 00:33:21,680
con toda la clase. Todos los objetos de la clase, cuando quieran acceder al nombre,

403
00:33:22,180 --> 00:33:25,839
accederían a esta zona de memoria. En cambio, estábamos haciendo

404
00:33:25,839 --> 00:33:30,119
el supuesto de que la edad, no, la edad queremos que sea diferente

405
00:33:30,119 --> 00:33:33,359
¿Me veis la pantalla, verdad?

406
00:33:33,359 --> 00:33:38,039
que la edad sea diferente para cada una de las personas.

407
00:33:38,960 --> 00:33:43,480
Como consecuencia de esto, no me valdría tener una sola zona de memoria

408
00:33:43,480 --> 00:33:48,500
porque per 1 tendría una edad de 10 y per 2 tendría una edad de 20.

409
00:33:48,660 --> 00:33:51,140
Si tenemos un único espacio común de memoria,

410
00:33:51,559 --> 00:33:53,559
cada vez que escribiésemos la edad de una persona,

411
00:33:54,980 --> 00:33:56,559
machacaríamos la edad de la otra.

412
00:33:57,500 --> 00:34:01,119
Cuando estas variables son variables de cada uno de los objetos,

413
00:34:01,119 --> 00:34:04,519
esta instrucción no la puedo utilizar, no puedo decir

414
00:34:04,519 --> 00:34:07,559
dime la edad de persona

415
00:34:07,559 --> 00:34:10,599
¿por qué? porque me van a decir, oye, muy bien, ¿de qué persona?

416
00:34:10,900 --> 00:34:13,739
¿de PER1 o de PER2? es de quien quieren mostrar

417
00:34:13,739 --> 00:34:16,659
la edad, entonces en este caso

418
00:34:16,659 --> 00:34:19,960
me vería obligado a decir, oye, la que quiero mostrar es la edad de PER1

419
00:34:19,960 --> 00:34:22,699
y dicen, vale, esto me gusta porque aquí no hay

420
00:34:22,699 --> 00:34:25,739
discrepancias, si me dices de PER1, sé que tengo que buscarlo

421
00:34:25,739 --> 00:34:28,599
en esta zona de código, y si digo de PER2

422
00:34:31,320 --> 00:34:33,079
pues lo tengo que buscar en esta otra zona de código.

423
00:34:34,239 --> 00:34:37,360
Cada uno tiene un espacio, no hay discrepancias, no hay problema.

424
00:34:37,360 --> 00:34:44,849
Si pongo aquí persona para la edad, me dice, muy bien, tengo dos personas,

425
00:34:45,250 --> 00:34:51,110
no has definido la variable miembro y edad como común a todos los objetos de la clase,

426
00:34:51,909 --> 00:34:53,829
¿cuál quieres que muestre? ¿Esta o esta?

427
00:34:54,050 --> 00:34:57,809
Y el programa no le gusta esta discrepancia y no nos compilaría.

428
00:34:57,809 --> 00:35:17,809
Es decir, existen a la hora de definir variables miembro, variables miembro de la clase o métodos, podemos definirlos para que cada uno de los objetos que definamos tenga su propia zona de memoria donde guardar esa información o sea común a todas ellas.

429
00:35:17,809 --> 00:35:24,329
el nombre en línea general es el nombre y la edad se entiende

430
00:35:24,329 --> 00:35:28,590
siempre un programa nos va a invitar a que sean variables

431
00:35:28,590 --> 00:35:32,869
en el que cada objeto tenga su propia zona de memoria

432
00:35:32,869 --> 00:35:37,170
ya os digo, a no ser que sea el ejemplo que os estaba poniendo en el cual todos los objetos

433
00:35:37,170 --> 00:35:40,730
tuviesen, fuera un club de personas que se llaman NOA

434
00:35:40,730 --> 00:35:43,769
pero bueno, por ejemplo, imaginaros que

435
00:35:43,769 --> 00:35:48,809
yo que sé, imaginaros que es de personas de una determinada

436
00:35:48,809 --> 00:35:50,909
quinta, que justo nacieron

437
00:35:50,909 --> 00:35:52,929
en un año. Entonces puede ser

438
00:35:52,929 --> 00:35:54,409
int y

439
00:35:54,409 --> 00:35:56,570
año

440
00:35:56,570 --> 00:35:57,929
y ponemos que sea

441
00:35:57,929 --> 00:36:00,250
el año 2000.

442
00:36:01,309 --> 00:36:02,530
Pues este año

443
00:36:02,530 --> 00:36:05,030
si justo este programa va a tratar

444
00:36:05,030 --> 00:36:06,849
de todas aquellas personas que

445
00:36:06,849 --> 00:36:08,710
tendrán nombres y edades diferentes pero

446
00:36:08,710 --> 00:36:10,949
todos son de este año, si lo definimos

447
00:36:10,949 --> 00:36:12,969
así tal cual, ahora os digo

448
00:36:12,969 --> 00:36:15,010
la diferencia para convertirlo en una variable

449
00:36:15,010 --> 00:36:17,090
de clase que no sea de cada uno de los objetos

450
00:36:17,090 --> 00:36:18,429
¿qué sucedería?

451
00:36:18,429 --> 00:36:28,849
que cada uno de los objetos que definiéramos, per1 y per2, tendría una reserva de espacio de memoria para un entero, porque lo hemos definido así como entero, ¿veis?

452
00:36:29,789 --> 00:36:35,829
¿Dónde pondría 2000? Este tendría otro espacio de memoria reservado donde pondría también 2000.

453
00:36:36,789 --> 00:36:47,730
Y si definimos, vamos a ser un poco brutos, 10.000 personas, 10.000 veces tendríamos un espacio de memoria reservada para cada uno de ellos

454
00:36:47,730 --> 00:36:53,710
y en todos ellos pondría 2000, con lo cual haríamos un derroche de memoria RAM innecesario,

455
00:36:53,969 --> 00:36:55,250
porque todos tienen el mismo dato.

456
00:36:55,849 --> 00:37:00,610
Para convertir esta variable en una variable común a todos los objetos de la clase,

457
00:37:01,050 --> 00:37:06,230
la definimos como estática, que es meterle aquí la etiqueta static.

458
00:37:07,150 --> 00:37:10,630
Y esto lo que hace es que cuando vayamos definiendo diferentes personas,

459
00:37:11,570 --> 00:37:15,869
a la hora de hacer una reserva de memoria RAM donde guardar la información de sus atributos,

460
00:37:15,869 --> 00:37:20,369
para cada uno de los objetos solamente hablará para aquellos

461
00:37:20,369 --> 00:37:23,429
en los que sí que puedan tener información diferente

462
00:37:23,429 --> 00:37:28,289
y para la variable static que es común a todos ellos

463
00:37:28,289 --> 00:37:31,409
solamente se reserva un espacio de memoria RAM entero

464
00:37:31,409 --> 00:37:34,730
para toda la clase persona y cualquiera de sus objetos

465
00:37:34,730 --> 00:37:38,190
con lo cual aquí ahora tendríamos el 2000

466
00:37:38,190 --> 00:37:40,750
y no lo tendríamos en cada uno de ellos.

467
00:37:43,539 --> 00:37:45,679
Repitiendo lo que os decía antes, en este caso

468
00:37:45,679 --> 00:37:49,059
que ahora ya hemos definido el año como estático y no el nombre y la edad

469
00:37:49,059 --> 00:37:51,340
para poder acceder al nombre y la edad

470
00:37:51,340 --> 00:37:55,000
primero tendríamos que identificar de qué persona estamos hablando

471
00:37:55,000 --> 00:37:58,199
per una y edad

472
00:37:58,199 --> 00:38:00,119
y esto le gustaría, o per dos

473
00:38:00,119 --> 00:38:03,920
y edad y también le gustaría, en un caso se vendría esta edad

474
00:38:03,920 --> 00:38:05,820
y en otro caso se vendría esta

475
00:38:05,820 --> 00:38:19,969
bueno, no sé, el matiz de constante y variable

476
00:38:19,969 --> 00:38:22,769
no, esto, tú imagínate que

477
00:38:22,769 --> 00:38:25,550
estamos haciendo la ejecución del programa

478
00:38:25,550 --> 00:38:30,150
y durante la ejecución del programa dices, pues ahora voy a trabajar con todas las personas

479
00:38:30,150 --> 00:38:35,570
que sean del año 2000. Y le pones aquí 2000. Y luego dices, pues ahora quiero trabajar

480
00:38:35,570 --> 00:38:40,429
con todas las personas que sean del año 2001. Entonces tú podrías actualizar esta variable

481
00:38:40,429 --> 00:38:46,030
en el código y cambiar este valor a 2001, con lo cual es una variable porque puede cambiar

482
00:38:46,030 --> 00:38:49,809
su valor, no es constante en todo el programa. ¿Cómo podríamos hacer este cambio?

483
00:38:49,809 --> 00:39:10,070
Pues aquí podrías poner en el código, por ejemplo, en saludar, esto te lo permitiría el compilador, poner 2001. ¿Es variable? Sí. Lo que pasa es que esta asignación te cambia el año para absolutamente todas las personas que están de alta, no para una persona en particular.

484
00:39:10,070 --> 00:39:14,389
Es estática porque es para todas, pero sigue siendo variable porque puede cambiar su valor.

485
00:39:15,469 --> 00:39:21,369
La etiqueta que convertiría en una constante esto sería la etiqueta final.

486
00:39:21,789 --> 00:39:28,409
Si tú pones una etiqueta final a un atributo, la etiqueta final, dependiendo a quién se la pongas, tiene diferentes significados.

487
00:39:28,829 --> 00:39:30,550
Hablaremos de ello también en algún momento.

488
00:39:31,809 --> 00:39:38,150
Si está relacionada para un parámetro o un atributo de clase en particular, lo que hace es convertirla en una constante.

489
00:39:38,150 --> 00:39:45,789
Entonces, si tú pones esta etiqueta aquí final, esto daría un error de compilación, porque no podrías cambiarlo.

490
00:39:47,130 --> 00:39:51,190
Esta sí que sería una constante, no me va a cambiar en ningún momento en ninguna zona de código.

491
00:39:52,389 --> 00:40:05,360
Cambio esto, esto sí lo permitiría, cambiaría el valor, pero ese cambio de valor afectaría a todos los objetos de esa clase.

492
00:40:05,360 --> 00:40:12,840
Mira, imagínate que lo que queremos es que el nombre sea estático.

493
00:40:12,980 --> 00:40:17,619
Si pones tu static, resulta que la memoria RAM, cuando se reserva para esto,

494
00:40:17,820 --> 00:40:20,360
no se hace una reserva particular para cada uno de los objetos,

495
00:40:21,000 --> 00:40:25,179
sino que se hace una única para la clase de este estilo, para la clase persona.

496
00:40:26,619 --> 00:40:34,219
Entonces, si tú tienes aquí este código, puedes asignar al nombre que es estático el valor de Rubén.

497
00:40:34,219 --> 00:40:48,269
¿Eso qué implicaría? Pues que en esta única zona de memoria, lea Rubén, si luego pones para el nombre que es común su zona de memoria para todos los objetos de esa clase, noa, pues te pondré aquí noa.

498
00:40:49,409 --> 00:40:54,989
¿Estamos cambiando el valor del nombre? Sí, entonces es una variable, no es una constante.

499
00:40:54,989 --> 00:41:22,210
Si yo ahora intento escribir aquí per1, como os decía antes, por pantalla per1, ese nombre, a pesar de que aquí le asigné Rubén, cuando vaya a hacer el acceso al nombre de per1 al tratarse de una variable de tipo estático, tendrá una zona única de memoria para la clase persona y cogerá la información que hay aquí, que es noa, que es la que se asignó aquí.

500
00:41:22,210 --> 00:41:26,550
Con lo cual, este per 1, por mucho que aquí pusimos robin, nos mostrará no a.

501
00:41:27,170 --> 00:41:31,070
Pero, siendo estático, ¿es una variable? Sí, nos permite cambiar su valor.

502
00:41:31,590 --> 00:41:38,199
Si es final, ¿va a ser sí o sí una constante? Sí.

503
00:41:38,380 --> 00:41:44,500
Entonces, si yo intento modificar el valor de iedad, directamente no me va a compilar el programa.

504
00:41:52,309 --> 00:42:02,679
Bien, pues, estábamos diciendo entonces, para aquellas variables estáticas que son comunes,

505
00:42:02,679 --> 00:42:07,239
Pasa igual, los métodos también se pueden definir estáticos, static.

506
00:42:10,000 --> 00:42:13,239
Entonces este método, su ejecución sería común a todos los,

507
00:42:13,519 --> 00:42:18,780
el código sería común a todos los objetos que lo pudieran utilizar.

508
00:42:19,280 --> 00:42:23,880
Mirad, la información estática, podemos acceder a ella, como os decía,

509
00:42:24,079 --> 00:42:28,460
a través de un objeto, per 1, ese nombre, que ahora lo tenemos definido como static,

510
00:42:28,460 --> 00:42:54,239
Per 2, ese nombre no hay lugar a dudas, se refiere a esta zona de memoria y como la zona de memoria es única para toda la persona, podemos acceder a ella a través de persona. Persona, ese nombre no tiene problemas, no hay conflictos, solamente hay una zona de memoria ya que el nombre es estático que será esta, con lo cual cojo noa y cojo y lo pongo por pantalla en este momento.

511
00:42:54,239 --> 00:43:19,780
Si en nuestro programa nosotros no hemos definido ningún objeto y somos capaces de acceder a cosas de la persona, en este caso un atributo, aunque no hayamos definido ningún objeto, tenemos total certeza de que esta variable en la clase persona está definida como estática.

512
00:43:19,780 --> 00:43:37,039
Porque si no está definida como estática, nos daría un error de compilación. Necesitaríamos saber a cuál de los nombres nos estamos refiriendo si no es estática. Pero si es estática, para la clase hace esa reserva y directamente con el nombre de la clase y el atributo accedemos al nombre.

513
00:43:37,039 --> 00:43:46,099
esto que hablamos para un atributo pues sucede para los métodos aquí en el sistema println este

514
00:43:46,099 --> 00:43:53,300
esto es un método y resulta que si miramos hacia la izquierda deberíamos tener un objeto que ejecuta

515
00:43:53,300 --> 00:43:59,239
este método pero no hemos definido ningún objeto por aquí veis en definitiva println es estará

516
00:43:59,239 --> 00:44:07,849
definido en la clase out del paquete existen como un método estático por eso podemos utilizar cierto

517
00:44:07,849 --> 00:44:16,539
código sin haber definido antes objetos pero hay un buen toncio para llegar a este punto pero

518
00:44:16,539 --> 00:44:40,670
entendéis la jugada más o menos bueno sí pero pero bueno ahí hay dos conceptos no quería llegar justo

519
00:44:40,670 --> 00:44:48,889
a ese concepto pero bueno también lo que incorporó tu concepto y vuelve a pegar un repasillo nuestro

520
00:44:48,889 --> 00:44:55,969
programa estará formado por clases que definamos en el propio programa. En este tenemos una clase

521
00:44:55,969 --> 00:45:03,849
alumno y una clase hola2 y por clases que estarán en la biblioteca de Java. Es decir, el juntar

522
00:45:03,849 --> 00:45:09,190
diferentes clases de la librería de Java y las que tengamos definidas nosotros con nuestro código

523
00:45:09,190 --> 00:45:14,949
será lo que le dé la entidad completa a nuestro proyecto. De la librería de Java utilizaremos

524
00:45:14,949 --> 00:45:18,150
clases que tendrán comportamientos

525
00:45:18,150 --> 00:45:20,829
generales. Lógicamente, cuando alguien definió las

526
00:45:20,829 --> 00:45:24,090
librerías de Java, no estaba pensando en, hoy que os estoy

527
00:45:24,090 --> 00:45:26,650
contando yo aquí, una serie de cosas del tema 2

528
00:45:26,650 --> 00:45:29,710
de distancia. Estaba pensando en funcionalidades generales

529
00:45:29,710 --> 00:45:32,969
de Java. Entonces, una funcionalidad general de Java

530
00:45:32,969 --> 00:45:35,849
será casi seguro, tanto en nuestro programa

531
00:45:35,849 --> 00:45:38,809
como en tantos otros, será escribir por pantalla. Entonces,

532
00:45:38,849 --> 00:45:41,869
dijeron, vamos a crear unas clases. La clase out

533
00:45:41,869 --> 00:45:44,789
que está en el paquete system, que tenga

534
00:45:44,789 --> 00:45:47,929
un método que nos permita escribir por pantalla.

535
00:45:48,250 --> 00:45:50,789
Estamos pudiendo utilizar esto sin haber definido

536
00:45:50,789 --> 00:45:53,230
nosotros el código de la clase out

537
00:45:53,230 --> 00:45:56,730
en uno de nuestros ficheros porque está en las

538
00:45:56,730 --> 00:45:59,530
librerías de Java. Perfecto, eso por un lado. Tenemos

539
00:45:59,530 --> 00:46:03,130
información que está en las librerías

540
00:46:03,130 --> 00:46:06,030
de Java, información de nuestros proyectos, que va un poco

541
00:46:06,030 --> 00:46:08,250
al hilo de lo que me comentabas.

542
00:46:09,550 --> 00:46:11,969
Y luego, por otro lado, tanto en las librerías

543
00:46:11,969 --> 00:46:17,050
de Java como en las nuestras, podremos tener definidos parámetros

544
00:46:17,050 --> 00:46:22,670
y métodos que sean estáticos. Cuando en la librería de Java,

545
00:46:23,010 --> 00:46:25,829
pues por ejemplo, ahora dentro de un momento os voy a comentar

546
00:46:25,829 --> 00:46:29,750
algo de la clase Scanner. La clase Scanner es una clase que está

547
00:46:29,750 --> 00:46:33,389
definida en las librerías de Java. Para utilizar Scanner tenemos

548
00:46:33,389 --> 00:46:38,110
que definir, igual que os decía aquí, que definíamos un objeto

549
00:46:38,110 --> 00:46:41,510
per uno de la clase Persona y Persona es una clase que he

550
00:46:41,510 --> 00:46:45,730
desarrollado yo el código, para poder utilizar Scanner es necesario

551
00:46:45,730 --> 00:46:49,670
definir un objeto. Igual que Per 1 antes, pues aquí definimos

552
00:46:49,670 --> 00:46:53,570
un objeto. ¿De quién? De la clase Scanner. Esto quiere decir

553
00:46:53,570 --> 00:46:57,690
que si yo defino diferentes objetos

554
00:46:57,690 --> 00:47:01,610
de la clase Scanner, para cada uno de estos objetos, cuando le hago

555
00:47:01,610 --> 00:47:05,610
un new, tendré una zona de memoria diferente para aquellos métodos

556
00:47:05,610 --> 00:47:09,269
que tenga la clase Scanner y que estarán definidos donde

557
00:47:09,269 --> 00:47:13,449
su código Java? Pues lo habrán hecho para nosotros y estará ubicado

558
00:47:13,449 --> 00:47:17,230
en la librería de Java. Han hecho ese código para nosotros

559
00:47:17,230 --> 00:47:21,349
que nos viene estupendo, porque ya veréis ahora que fácil es poder

560
00:47:21,349 --> 00:47:25,090
hacer una lectura con la clase Scanner de información desde teclado

561
00:47:25,090 --> 00:47:29,349
que si lo tuviéramos que codificar nosotros, el ser capaces de llegar a través del sistema

562
00:47:29,349 --> 00:47:31,809
operativo al teclado sería una locura.

563
00:47:33,230 --> 00:47:36,929
Pero, igual que tenemos ahí la clase, cuando la han definido

564
00:47:36,929 --> 00:47:41,650
tendrán sus métodos y sus parámetros y para poder tener zona de memoria

565
00:47:41,650 --> 00:47:45,570
para esos métodos y esos parámetros, definimos un objeto y le hacemos un new

566
00:47:45,570 --> 00:47:49,530
scanner y aquí le ponemos

567
00:47:49,530 --> 00:47:53,489
bueno, pues ahora lo completamos. Es decir, estamos

568
00:47:53,489 --> 00:47:57,690
definiendo un objeto scanner de la clase scanner.

569
00:47:57,829 --> 00:48:01,469
La clase scanner está en la librería de Java. Aquí estábamos

570
00:48:01,469 --> 00:48:05,250
definiendo un objeto per1 y per2 de la clase

571
00:48:05,250 --> 00:48:07,449
persona. ¿La clase persona está en las librerías

572
00:48:07,449 --> 00:48:09,070
de Java? No, pertenece a nuestro

573
00:48:09,070 --> 00:48:10,969
proyecto que estamos desarrollando.

574
00:48:14,699 --> 00:48:19,800
Es decir, la clase

575
00:48:19,800 --> 00:48:22,019
persona aquí en nuestro desarrollo

576
00:48:22,019 --> 00:48:23,980
tiene algunos métodos

577
00:48:23,980 --> 00:48:25,579
que no los hemos definido estáticos

578
00:48:25,579 --> 00:48:27,980
y tiene algunos, perdón, algunos atributos

579
00:48:27,980 --> 00:48:29,980
que no los hemos definido estáticos y algún

580
00:48:29,980 --> 00:48:31,679
método que no lo hemos definido estático

581
00:48:31,679 --> 00:48:33,940
y tiene algún método que lo hemos

582
00:48:33,940 --> 00:48:36,000
definido estático y algún atributo que lo hemos

583
00:48:36,000 --> 00:48:37,940
definido estático. Esto lo hemos hecho en una

584
00:48:37,940 --> 00:48:39,179
clase que hemos hecho nosotros.

585
00:48:39,760 --> 00:48:41,699
Igual que aquí hemos tenido

586
00:48:41,699 --> 00:48:47,559
nosotros ese criterio para diferentes métodos y diferentes parámetros, los han podido tener ellos

587
00:48:47,559 --> 00:48:54,960
cuando hayan hecho clases que están en las librerías de Java. Sabiendo que esto puede pasar tanto en un

588
00:48:54,960 --> 00:49:02,119
sitio como en otro, pues cuando utilizamos nuestro programa, si queremos acceder a una variable

589
00:49:02,119 --> 00:49:09,019
que sea estática, que sea común a todos los objetos de la clase, podemos acceder a ella poniendo el

590
00:49:09,019 --> 00:49:16,079
nombre de la clase y el atributo o podríamos ejecutar el método saludar poniendo el método

591
00:49:16,079 --> 00:49:26,300
el nombre de la clase y el método y esto ejecutaría saludar en cambio si nosotros ponemos el nombre

592
00:49:26,300 --> 00:49:31,440
de la clase y despedir esto nos daría un error de compilación porque porque despedir no es estática

593
00:49:31,440 --> 00:49:36,719
y tenemos que ejecutarlo para cada uno de los objetos cuando es estática es común a todos los

594
00:49:36,719 --> 00:49:41,039
objetos y podemos utilizar el nombre de la clase, cuando no es estática

595
00:49:41,039 --> 00:49:44,599
es particular para cada uno de los objetos y si yo digo aquí

596
00:49:44,599 --> 00:49:47,820
que me ejecute persona.despedir, me diría

597
00:49:47,820 --> 00:49:52,559
como esto no lo has definido general para la clase, ¿tú quieres que se despida

598
00:49:52,559 --> 00:49:56,699
per1 o per2? Pues entonces no te dejo que utilices

599
00:49:56,699 --> 00:50:02,670
la clase persona para despedirte. ¿Veis la diferencia? ¿Cuándo es

600
00:50:02,670 --> 00:50:12,110
estático y cuándo no? Si yo

601
00:50:12,110 --> 00:50:18,309
quito todo este código

602
00:50:18,309 --> 00:50:23,030
y no tengo definido ningún objeto de la clase

603
00:50:23,030 --> 00:50:24,469
persona, esto

604
00:50:24,469 --> 00:50:26,849
despedir no me funcionará

605
00:50:26,849 --> 00:50:28,469
pero saludar

606
00:50:28,469 --> 00:50:33,179
sí. ¿Por qué me funcionará saludar?

607
00:50:33,539 --> 00:50:35,380
Pues porque no tiene lugar a dudas

608
00:50:35,380 --> 00:50:37,219
el método saludar

609
00:50:37,219 --> 00:50:39,119
igual que sucedía antes aquí

610
00:50:39,119 --> 00:50:41,219
con los parámetros, es que con los parámetros se ve un poquito

611
00:50:41,219 --> 00:50:43,099
mejor con la memoria RAM, es

612
00:50:43,099 --> 00:50:45,239
único para toda la clase persona. Entonces la clase

613
00:50:45,239 --> 00:50:47,119
persona por sí misma, aunque no haya ningún

614
00:50:47,119 --> 00:50:49,219
objeto, es capaz de saludar. Pero si yo pongo

615
00:50:49,219 --> 00:50:49,920
aquí despedir

616
00:50:49,920 --> 00:50:56,199
esto no le gusta, ¿por qué? pues porque tenemos un método de despedir para cada uno de ellos

617
00:50:56,199 --> 00:51:00,920
fijaros que saludar me lo ha permitido sin haber definido ningún objeto

618
00:51:00,920 --> 00:51:07,159
entonces si nos venimos aquí, quito el escáner

619
00:51:07,159 --> 00:51:14,699
fijaros como println tiene aquí unos paréntesis con lo cual esto es un método

620
00:51:14,699 --> 00:51:19,480
es un método que estamos ejecutando de la clase out del paquete system

621
00:51:19,480 --> 00:51:44,559
Y estamos ejecutando esto sin haber instanciado ningún objeto de la clase out. Es decir, trasladándolo a este ejemplo sin haber instanciado ningún objeto de la clase persona. Entonces, si sin instanciar ningún objeto de la clase persona nos deja utilizar el método println, será porque el método println es estático. En su definición, en la librería de Java, cuando lo han construido.

622
00:51:44,559 --> 00:51:54,170
¿Se entiende? Regular, ¿no?

623
00:52:00,699 --> 00:52:02,599
Respecto a la memoria RAM, entonces

624
00:52:02,599 --> 00:52:07,780
tenemos las posibles variables que definimos

625
00:52:07,780 --> 00:52:12,139
primitivas. Las variables primitivas, por ejemplo

626
00:52:12,139 --> 00:52:15,920
int a, directamente ya me reserva para

627
00:52:15,920 --> 00:52:19,940
una etiqueta de mi nombre a, un espacio de memoria donde podré guardar

628
00:52:19,940 --> 00:52:23,639
información para un entero. Tenemos las referenciadas

629
00:52:23,639 --> 00:52:28,840
persona miper. Esto no me

630
00:52:28,840 --> 00:52:32,800
reserva espacio de memoria directamente para los atributos de una persona. Para conseguir

631
00:52:32,800 --> 00:52:36,960
eso, ¿qué le tengo que hacer? Un new y luego, bueno, llamamos

632
00:52:36,960 --> 00:52:40,860
a un método que es constructor, siempre después del new. Del constructor ya os hablaré, pero

633
00:52:40,860 --> 00:52:44,199
con este new ya sí que reservo espacio para todos esos.

634
00:52:45,960 --> 00:52:48,820
¿Para quién me reservará memoria este new? Para aquellos

635
00:52:48,820 --> 00:53:00,130
parámetros que no sean estáticos. Si yo

636
00:53:00,130 --> 00:53:01,869
tengo uno que es estático, static

637
00:53:01,869 --> 00:53:03,570
y

638
00:53:03,570 --> 00:53:05,269
año decíamos

639
00:53:05,269 --> 00:53:09,840
este new no me

640
00:53:09,840 --> 00:53:11,840
reserva espacio memoria

641
00:53:11,840 --> 00:53:13,940
para esta persona, mi per

642
00:53:13,940 --> 00:53:16,039
con esta

643
00:53:16,039 --> 00:53:18,139
instrucción. ¿Por qué?

644
00:53:18,239 --> 00:53:19,860
Porque al ser estático

645
00:53:19,860 --> 00:53:22,099
ya tendré un espacio de memoria reservado

646
00:53:22,099 --> 00:53:23,579
para toda la clase.

647
00:53:24,400 --> 00:53:25,800
Es decir, tendré para la clase

648
00:53:25,800 --> 00:53:27,719
persona, habrá mirado y habrá dicho

649
00:53:27,719 --> 00:53:28,940
para los static

650
00:53:28,940 --> 00:53:31,699
voy a ir reservando ya memoria y veo que

651
00:53:31,699 --> 00:53:35,239
tengo un año, un entero, pues reservo espacio para un entero

652
00:53:35,239 --> 00:53:39,679
y le asocio el nombre de año. Entonces, este miper

653
00:53:39,679 --> 00:53:43,820
new nos reservará para este objeto miper

654
00:53:43,820 --> 00:53:47,820
espacio de memoria particular para el nombre y para la edad.

655
00:53:48,500 --> 00:53:51,639
¿Para el año lo necesita? No, porque ya hay uno que es común a toda

656
00:53:51,639 --> 00:53:53,860
la clase y se ha reservado para toda la clase.

657
00:53:55,579 --> 00:53:59,920
Si yo cojo y ahora pongo un system.out.println

658
00:53:59,920 --> 00:54:07,849
y pongo persona.eseNombre

659
00:54:07,849 --> 00:54:09,809
¿esto me funcionará?

660
00:54:10,289 --> 00:54:11,210
Pues no me funcionará.

661
00:54:11,309 --> 00:54:11,550
¿Por qué?

662
00:54:11,630 --> 00:54:12,730
Porque si tengo instanciada

663
00:54:12,730 --> 00:54:13,710
más de una persona

664
00:54:13,710 --> 00:54:16,929
no sabrá a qué zona de memoria

665
00:54:16,929 --> 00:54:17,909
tiene que acceder.

666
00:54:18,389 --> 00:54:19,369
Para cada una de las personas

667
00:54:19,369 --> 00:54:20,429
con el new habrá hecho

668
00:54:20,429 --> 00:54:21,449
una reserva diferente.

669
00:54:22,269 --> 00:54:22,750
Pero en cambio,

670
00:54:22,750 --> 00:54:27,070
si yo pongo persona.ianio

671
00:54:27,070 --> 00:54:30,630
en este caso no hay dudas

672
00:54:30,630 --> 00:54:32,150
y podrá ejecutarlo.

673
00:54:32,349 --> 00:54:32,429
¿Por qué?

674
00:54:32,429 --> 00:54:37,389
porque para cualquier objeto de la clase persona y año se ha definido como estática

675
00:54:37,389 --> 00:54:42,170
y hay una única posición de memoria por mucho que tenga uno, dos o cien objetos.

676
00:54:42,489 --> 00:54:46,530
La posición de memoria es única en cuanto a los atributos.

677
00:54:47,030 --> 00:54:49,070
Y la misma idea sucede con los métodos.

678
00:54:49,329 --> 00:54:54,929
Si yo un método lo tengo definido como static, puedo acceder a él con el indicador de la clase.

679
00:54:54,929 --> 00:55:00,030
y si no es static tendré que instanciar un objeto y acceder

680
00:55:00,030 --> 00:55:04,889
al método pero ya con el objeto. Aquí

681
00:55:04,889 --> 00:55:09,170
desde las librerías de Java han hecho la clase System.out

682
00:55:09,170 --> 00:55:12,929
que tendrá unos métodos y unos parámetros y

683
00:55:12,929 --> 00:55:17,289
esta clase sin haber instanciado por aquí ningún objeto

684
00:55:17,289 --> 00:55:20,590
de esa clase nos está permitiendo acceder a un método que es Println

685
00:55:20,590 --> 00:55:25,469
pues este acceso al método Println se produce a través de la clase

686
00:55:25,469 --> 00:55:44,800
gracias a que es estático. Bueno, no lo enredo más veces. Si alguien tiene alguna duda, o bien preguntarme, o luego en los foros, por no volver a darle vueltas otra vez al mismo bucle.

687
00:55:44,800 --> 00:56:00,530
bueno, en principio

688
00:56:00,530 --> 00:56:03,170
no es un poco la idea de ir alargándolas

689
00:56:03,170 --> 00:56:06,829
si tenéis una necesidad así general la puedo alargar

690
00:56:06,829 --> 00:56:08,570
un día más o una cosa así

691
00:56:08,570 --> 00:56:11,730
pero bueno, ya que es la primera, pero en principio

692
00:56:11,730 --> 00:56:15,309
intentaremos ajustarnos a los plazos

693
00:56:15,309 --> 00:56:18,170
de entrega con independencia y que luego

694
00:56:18,170 --> 00:56:21,130
si quieres terminar de completarla

695
00:56:21,130 --> 00:56:23,429
porque no te ha dado tiempo, me la envíes y te la echo un ojo

696
00:56:23,429 --> 00:57:08,909
O sea, no es por la cuestión de echarla del ojo o no, sino por seguir un poco los formalismos de los plazos. Pero bueno, está en principio, si queréis, os la alargo un día más. Vale. Vale. Mira, un poco. Sí, claro, claro, claro. Mira, sirve, lo traslado un poco la pregunta porque creo que en la grabación no queda.

697
00:57:08,909 --> 00:57:13,269
me preguntan si al final el objetivo de Static es optimizar memoria RAM.

698
00:57:14,750 --> 00:57:20,530
Digamos que optimizar memoria RAM es una de las consecuencias que tiene el utilizar Static

699
00:57:20,530 --> 00:57:24,210
y luego tiene una serie de ventajas adicionales a optimizar memoria RAM.

700
00:57:24,769 --> 00:57:30,210
Imagínate que tienes, volviendo al ejemplo del que hablábamos antes, tienes el Static y Anio,

701
00:57:31,670 --> 00:57:33,789
que es de tipo entero.

702
00:57:33,789 --> 00:57:40,869
si tienes 200, imagínate que el año

703
00:57:40,869 --> 00:57:44,510
lo hemos considerado estático porque es común a todos los objetos, que es

704
00:57:44,510 --> 00:57:48,010
la filosofía que persigue el hecho de que sea estático el método

705
00:57:48,010 --> 00:57:52,269
aquí no me compila porque tiene que ser una variable de clase

706
00:57:52,269 --> 00:57:57,090
entonces, fijaros, un detalle, continúo contándote

707
00:57:57,090 --> 00:58:01,050
lo había puesto aquí en el main, pero realmente si lo pongo

708
00:58:01,050 --> 00:58:04,710
aquí es una variable local al main, no sería una variable

709
00:58:04,710 --> 00:58:09,110
de la clase y estamos buscando con el static que sea una variable

710
00:58:09,110 --> 00:58:13,090
para todos los objetos de la clase. Por eso no me compila aquí en este ámbito del método

711
00:58:13,090 --> 00:58:17,190
main y si me compila, si lo convierto en una variable miembro

712
00:58:17,190 --> 00:58:21,170
de la clase. Por comentaros ya que ha pasado

713
00:58:21,170 --> 00:58:25,489
esto. Fijaros, tú imagínate que ahora durante el programa yo instancio

714
00:58:25,489 --> 00:58:28,769
mil objetos de la clase hola.

715
00:58:29,530 --> 00:58:32,949
El hecho de que sea estático implica que esos mil objetos

716
00:58:32,949 --> 00:58:34,570
va a tener el mismo valor para año.

717
00:58:35,130 --> 00:58:42,210
Y en el código, si no lo hubiera definido estático,

718
00:58:42,590 --> 00:58:43,889
que sí que queremos que lo sea,

719
00:58:44,570 --> 00:58:47,690
esos 1.000 objetos tendrían su trocito de memoria,

720
00:58:47,789 --> 00:58:49,969
con lo cual tendríamos peor rendimiento

721
00:58:49,969 --> 00:58:51,389
en cuanto al uso de memoria RAM.

722
00:58:51,829 --> 00:58:53,349
Pero también en el tiempo de ejecución,

723
00:58:53,829 --> 00:58:56,889
si resulta que yo tengo que es del año 2000

724
00:58:56,889 --> 00:58:58,510
y quiero pasar al año 2001,

725
00:58:59,050 --> 00:59:00,170
si tengo 1.000 objetos,

726
00:59:00,389 --> 00:59:02,469
tengo que ir a cada uno de esos 1.000 objetos

727
00:59:02,469 --> 00:59:05,090
si quiero que sea coherente y que todos tengan el mismo año

728
00:59:05,090 --> 00:59:08,829
para pasarlo a 2001 tendría que cambiar mil variables

729
00:59:08,829 --> 00:59:10,309
una de cada uno de los objetos

730
00:59:10,309 --> 00:59:13,510
y en cambio, si la tengo como static

731
00:59:13,510 --> 00:59:16,929
pues yo pongo static y ahora pongo aquí

732
00:59:16,929 --> 00:59:21,530
en este caso la clase se llama hola2.ianio

733
00:59:21,530 --> 00:59:22,829
y pongo 2001

734
00:59:22,829 --> 00:59:25,610
y de una tacada tengo cambiado los mil

735
00:59:25,610 --> 00:59:28,190
¿por qué? porque como es una única zona de memoria

736
00:59:28,190 --> 00:59:31,289
cambio esa zona de memoria y como aplica al ser estática

737
00:59:31,289 --> 00:59:33,389
los mil objetos, los mil objetos

738
00:59:33,389 --> 00:59:35,289
cada vez que quieran acceder al año ya tendrán el

739
00:59:35,289 --> 00:59:35,750
2001.

740
00:59:37,190 --> 00:59:39,329
Con lo cual, me ahorraría tener que

741
00:59:39,329 --> 00:59:41,230
hacer esta actualización para los mil

742
00:59:41,230 --> 00:59:43,070
objetos. Y quien dice mil,

743
00:59:43,190 --> 00:59:45,170
yo qué sé, ya podemos querer ser exagerados

744
00:59:45,170 --> 00:59:46,949
y decir un millón de objetos, ¿no?

745
00:59:47,369 --> 00:59:49,110
Pues fíjate, un millón de instrucciones

746
00:59:49,110 --> 00:59:51,230
o una instrucción sola que al final

747
00:59:51,230 --> 00:59:52,809
cumple con el objetivo que queremos.

748
00:59:53,630 --> 00:59:55,429
Y es más, si la filosofía

749
00:59:55,429 --> 00:59:57,090
de y año es que sea común

750
00:59:57,090 --> 00:59:59,090
para todos ellos y tengo

751
00:59:59,090 --> 01:00:01,269
esos mil objetos de los que hablábamos

752
01:00:01,269 --> 01:00:08,309
antes resulta que yo por código he podido cambiar 500 y los otros 500 no lo he hecho con lo cual

753
01:00:08,309 --> 01:00:13,750
estoy ya cometiendo un error de fondo según la filosofía de la variable y año que tendría que

754
01:00:13,750 --> 01:00:19,250
ser común es para común para todos porque he dejado 500 de mis objetos de la clase o lados

755
01:00:19,250 --> 01:00:25,130
con el valor 2000 y 500 con el valor 2001 con lo cual ya hay una incoherencia y entonces si es

756
01:00:25,130 --> 01:00:30,590
estático es que nos viene de perlas si el valor en sí puede ser estático nos viene de perlas

757
01:00:30,590 --> 01:00:33,309
definirlo como estático por todas estas ventajas

758
01:00:33,309 --> 01:00:34,010
ahora

759
01:00:34,010 --> 01:00:36,630
¿nos vale poner estático cualquier cosa?

760
01:00:36,750 --> 01:00:38,849
pues no, pues en la clase persona de antes

761
01:00:38,849 --> 01:00:40,670
si decimos, pues bueno, para tener

762
01:00:40,670 --> 01:00:42,690
las ventajas que me pueda proporcionar

763
01:00:42,690 --> 01:00:44,650
static, voy a definir

764
01:00:44,650 --> 01:00:46,449
el nombre como estático, pues entonces

765
01:00:46,449 --> 01:00:48,630
la puede chafar, porque cada persona puede tener

766
01:00:48,630 --> 01:00:50,909
un nombre diferente y volvemos

767
01:00:50,909 --> 01:00:52,550
a lo que os ponía antes, si

768
01:00:52,550 --> 01:00:54,650
el nombre Rubén, primero

769
01:00:54,650 --> 01:00:56,809
asignábamos el nombre Rubén y a la

770
01:00:56,809 --> 01:00:58,050
per 1 y a la per 2

771
01:00:58,050 --> 01:01:00,110
le asignábamos luego el nombre de Noah

772
01:01:00,110 --> 01:01:04,429
cuando queríamos ir al nombre de Rubén se llamaba NOA porque la posición de memoria era única

773
01:01:04,429 --> 01:01:07,489
es decir, hay variables que pueden ser static y variables que no

774
01:01:07,489 --> 01:01:10,389
y cuando pueden ser static, el definirlas tal cual

775
01:01:10,389 --> 01:01:15,809
aporta bastante ventajas y una de ellas es el ahorro de memoria RAM

776
01:01:15,809 --> 01:01:21,539
también, no sé si más o menos está claro

777
01:01:21,539 --> 01:01:25,639
bueno, pues

778
01:01:25,639 --> 01:01:30,480
dejo un poco el tema este del static y todo esto, seguiréis trabajando

779
01:01:30,480 --> 01:01:39,400
De todas formas, si luego volvéis a ver la práctica o tenéis dudas, en los foros os voy atendiendo e intentamos ir resolviéndolas.

780
01:01:40,760 --> 01:01:45,980
Mirad, nuestros programas, me voy a otro ámbito de cosas para contaros.

781
01:01:46,579 --> 01:01:51,260
Nuestros programas tienen que comunicarse con el mundo exterior.

782
01:01:51,579 --> 01:01:54,460
Tiene que llegar la información tanto de entrada como de salida.

783
01:01:54,460 --> 01:02:00,739
La información de entrada y de salida a los programas puede ser de diferentes fuentes

784
01:02:00,739 --> 01:02:05,880
El año que viene veréis en una asignatura cómo comunicar aplicaciones a través de sockets

785
01:02:05,880 --> 01:02:08,980
en la asignatura de programación de servicios y procesos

786
01:02:08,980 --> 01:02:12,139
o según vuestro ritmo cuando matriculeis de ella

787
01:02:12,139 --> 01:02:19,239
Esta técnica es a través de sockets, es por ejemplo cuando nosotros nos conectamos a un servidor web

788
01:02:19,239 --> 01:02:42,300
Pues hay una aplicación que se pone a la escucha en un determinado puerto y tiene una determinada dirección IPS equipo. Y desde otra aplicación, que será nuestro navegador, nosotros hacemos que nuestro navegador en nuestra máquina se comunique con el servidor web, que a lo mejor es el servidor web de marca, para ver la página de tenis.

789
01:02:42,300 --> 01:02:55,860
Entonces se establece un flujo de comunicación entre el navegador y el servidor que nos permitiría el traslado de la información de la página de tennis y ver, yo que sé, cómo va la Copa Davis o lo que sea.

790
01:02:56,699 --> 01:03:06,539
Entonces es un flujo de comunicación. Otro flujo de comunicación que tenemos para sacar información y meter en nuestro programa puede ser a través, por ejemplo, de bases de datos.

791
01:03:06,539 --> 01:03:22,179
El año que viene tenéis una asignatura de base de datos y el último tema de este curso, no sé si llegaremos con más o menos tiempo, pero también habla un poquito de cómo acceder a base de datos. Ahí podéis guardar vuestra información y recuperarla.

792
01:03:23,059 --> 01:03:30,739
Más métodos de comunicar nuestro programa con el exterior para inyectarle datos o para sacar resultados puede ser a través de ficheros.

793
01:03:31,380 --> 01:03:34,420
Tenemos un tema que hablaremos cómo trabajar con ficheros.

794
01:03:35,800 --> 01:03:41,000
Todas estas vías de comunicación utilizan el término de flujos de datos.

795
01:03:41,380 --> 01:03:48,510
Los flujos de datos son las tuberías que establecemos desde fuera de nuestro programa,

796
01:03:48,630 --> 01:03:53,469
bien para inyectar o sacar resultados desde Java en este caso.

797
01:03:53,489 --> 01:04:05,190
Y luego hay tres flujos de datos, aparte de todos estos que os comentaba y algún otro que pueda haber por ahí, hay tres flujos de datos que de forma estándar se activan en los programas.

798
01:04:05,190 --> 01:04:28,730
Que es el flujo de datos de entrada, entrada de datos por defecto, que es a través del teclado, de salida por defecto, que es el monitor, y de error por defecto, que también está enlazado con el monitor.

799
01:04:28,730 --> 01:04:36,269
cuando escribimos algo vamos a entenderlo como una tubería que en un lado de la tubería tiene

800
01:04:36,269 --> 01:04:42,730
enganchado pues en nuestro programa está enganchado y en el otro lado pues está enganchado en cualquier

801
01:04:42,730 --> 01:04:47,489
otro sitio en el ejemplo que decía antes del servidor web imaginaros que hemos hecho nuestro

802
01:04:47,489 --> 01:04:54,050
programa del navegador en java pues tendríamos enchufado en el socket este que os decía antes

803
01:04:54,050 --> 01:04:57,949
una parte de la tubería en nuestro propio programa y el otro extremo en el servidor web

804
01:04:58,730 --> 01:05:01,230
que nos proporcionaría la página esta de tenis.

805
01:05:02,429 --> 01:05:08,769
La entrada por defecto, pues tiene enchufado uno de los lados de la tubería en nuestro programa

806
01:05:08,769 --> 01:05:10,789
y la otra en el teclado.

807
01:05:10,989 --> 01:05:14,570
Entonces, cada tecla que escribimos se traslada hasta nuestro programa en Java.

808
01:05:15,550 --> 01:05:21,030
La salida por defecto, pues tiene un lado de la tubería en nuestro programa y la salida al monitor.

809
01:05:21,650 --> 01:05:24,010
Y la de error, cuando queremos escribir un mensaje de error,

810
01:05:25,030 --> 01:05:28,670
pues un lado de la tubería en nuestro programa y la otra también al monitor.

811
01:05:28,730 --> 01:05:35,219
esto es entendiendo como está organizado el tema

812
01:05:35,219 --> 01:05:37,840
en realidad ya hemos utilizado alguna de ellas

813
01:05:37,840 --> 01:05:40,340
porque si nosotros hacemos un system.out

814
01:05:40,340 --> 01:05:48,000
.println y aquí ponemos

815
01:05:48,000 --> 01:05:50,840
un texto, lo que sea, hola, lo que estamos haciendo es

816
01:05:50,840 --> 01:05:53,400
que la clase system.out

817
01:05:53,400 --> 01:05:56,519
en realidad lo que hace es conectarse

818
01:05:56,519 --> 01:05:59,760
system.out está desarrollado en las librerías de Java

819
01:05:59,760 --> 01:06:02,960
resulta que println es un método estático que lo podemos

820
01:06:02,960 --> 01:06:10,280
utilizar sin instanciar ningún objeto de esa clase por ir enlazando con lo que hablábamos antes y es

821
01:06:10,280 --> 01:06:18,380
una clase desarrollada en java que lo que hace es utilizar la salida por defecto entonces este hola

822
01:06:18,380 --> 01:06:29,050
donde nos sale pues nos sale a consola al monitor si ejecutamos este hola mundo y le vamos a ejecutar

823
01:06:29,050 --> 01:06:36,590
pues como consecuencia es sacarlo la mundo donde nos saca consola al monitor porque porque utiliza

824
01:06:36,590 --> 01:06:40,409
la salida por defecto. ¿Quién? Una clase, que en Java

825
01:06:40,409 --> 01:06:44,570
todos son clases, que está definida en las librerías, que se llama

826
01:06:44,570 --> 01:06:48,469
out del paquete system y utiliza un método estático que es el println

827
01:06:48,469 --> 01:06:52,510
que nos hace meter aquí el texto

828
01:06:52,510 --> 01:06:56,469
que queramos que se enchufe al otro lado de la tubería en el monitor gracias a que

829
01:06:56,469 --> 01:07:01,719
utiliza la salida por defecto. La entrada por defecto es

830
01:07:01,719 --> 01:07:08,090
system in. Entonces hay una clase en Java,

831
01:07:08,090 --> 01:07:11,929
también en las librerías que en la clase system, en la clase in del paquete

832
01:07:11,929 --> 01:07:15,929
system, que igual que la system out utiliza la salida por defecto para

833
01:07:15,929 --> 01:07:18,789
escribir en monitor, system in lo que hace es

834
01:07:18,789 --> 01:07:23,949
enganchar el lado de la tubería del flujo de datos que tenemos

835
01:07:23,949 --> 01:07:28,130
en nuestro programa, enganchar esa tubería que al otro lado

836
01:07:28,130 --> 01:07:31,269
está en el teclado para ir metiendo información en nuestro programa.

837
01:07:32,869 --> 01:07:35,250
Normalmente cuando utilizamos system in

838
01:07:35,250 --> 01:07:39,150
podemos directamente, igual que con System.out, escribir, con System.in

839
01:07:39,150 --> 01:07:43,170
podríamos leer directamente, pero en las librerías de Java

840
01:07:43,170 --> 01:07:47,489
hay otra clase que le pone un envoltorio

841
01:07:47,489 --> 01:07:50,730
a la clase System.in para facilitarnos la lectura

842
01:07:50,730 --> 01:07:55,590
desde teclado en nuestros programas. Del flujo de datos System.in

843
01:07:55,590 --> 01:07:59,309
que es la entrada por defecto, podemos utilizar otra clase

844
01:07:59,309 --> 01:08:02,969
que también está definida en las librerías, que encasula

845
01:08:02,969 --> 01:08:05,969
digamos que le da un abrazote ahí a System.in

846
01:08:05,969 --> 01:08:09,050
y hacia nosotros nos resulta más fácil

847
01:08:09,050 --> 01:08:11,289
con los métodos que tiene esta otra clase

848
01:08:11,289 --> 01:08:14,690
el poder leer cosas desde el teclado, que es la clase

849
01:08:14,690 --> 01:08:23,189
Scanner. Ir parándome, si tenéis dudas de cosas

850
01:08:23,189 --> 01:08:24,930
me vais diciendo, mirad

851
01:08:24,930 --> 01:08:36,819
Mirad, cuando he puesto aquí

852
01:08:36,819 --> 01:08:39,539
el método println de System.out

853
01:08:39,539 --> 01:08:42,699
no he tenido que hacer nada en especial, lo he podido utilizar directamente

854
01:08:42,699 --> 01:08:45,779
Esta clase hemos dicho que está en las librerías

855
01:08:45,779 --> 01:08:51,899
de java y la utilizó directamente en mi programa porque mi programa aparte de utilizar mis clases

856
01:08:51,899 --> 01:08:58,659
es capaz de utilizar clases directamente sin tener que hacer nada más que están en un paquete de java

857
01:08:58,659 --> 01:09:07,100
que se llama los paquetes java lang todo lo que son son clases están de uso tan común que

858
01:09:07,100 --> 01:09:11,680
directamente no tengo ni que importarlas a mi proyecto directamente todo proyecto en java ya

859
01:09:11,680 --> 01:09:15,680
es capaz de utilizarlas, todas las que están definidas en ese paquete, como es el caso

860
01:09:15,680 --> 01:09:20,220
de la clase System.out o la clase System.in, que ya veis que no se me queja.

861
01:09:20,960 --> 01:09:23,600
En cambio, luego en la librería de Java

862
01:09:23,600 --> 01:09:27,239
hay muchísimos otros paquetes diferentes

863
01:09:27,239 --> 01:09:31,479
y en unos programas querremos utilizar unos y en otros querremos utilizar otros.

864
01:09:31,479 --> 01:09:35,319
Entonces Java ha decidido que sin necesidad de hacer nada más

865
01:09:35,319 --> 01:09:39,100
podemos utilizar aquellas clases que están en este paquete, en Java.lang

866
01:09:39,100 --> 01:09:50,659
Pero las demás, si queremos utilizarlas, tenemos que avisárselo para no tener en consideración todas las clases de la librería de Java que hubiera, aunque no vayamos a utilizar el 99% de todas las que estén definidas.

867
01:09:51,359 --> 01:10:02,359
Ese es el caso de la clase Scanner. La clase Scanner está definida en los paquetes de Java, pero no está precisamente en esos paquetes que se importan de forma automática.

868
01:10:03,140 --> 01:10:04,960
Entonces, para que lo tenga en consideración mi programa,

869
01:10:05,079 --> 01:10:06,659
lo tengo que importar.

870
01:10:07,319 --> 01:10:09,960
Si me pongo aquí con Eclipse sobre escáner,

871
01:10:10,020 --> 01:10:11,560
que me está dando un error, me dice,

872
01:10:11,779 --> 01:10:15,260
importa escáner del paquete Java útil.

873
01:10:16,180 --> 01:10:18,140
Entonces, lo doy aquí y lo que me hace en el código

874
01:10:18,140 --> 01:10:21,399
es ponerme aquí que importa Java útil.

875
01:10:21,859 --> 01:10:23,279
Fijaros, este no lo he importado directamente

876
01:10:23,279 --> 01:10:24,439
porque no está en Java lang.

877
01:10:25,180 --> 01:10:27,939
Escáner y ya mi programa tiene en consideración

878
01:10:27,939 --> 01:10:31,800
que cuando defina objetos como mi scan de la clase escáner,

879
01:10:32,359 --> 01:10:39,300
En realidad tienen que responder a una clase que está desarrollada en el paquete Java útil y que la han llamado Scanner.

880
01:10:40,100 --> 01:10:47,039
Igual que la clase persona la habíamos definido nosotros antes, pues aquí hay una clase definida en los paquetes de Java,

881
01:10:47,220 --> 01:10:51,600
que es la clase Scanner y la han decidido meter dentro de un paquete de utilidades de Java.

882
01:10:52,460 --> 01:10:59,560
Y para utilizarlo en nuestro programa tenemos que indicárselo aquí al inicio del programa del fichero .java

883
01:10:59,560 --> 01:11:03,119
diciendo que la importamos para que esté disponible en este fichero a Java.

884
01:11:06,050 --> 01:11:07,470
Entonces, fijaros lo que hemos hecho aquí.

885
01:11:07,470 --> 01:11:19,170
¿Os acordáis de cuando antes ponía persona, miper, igual a new, persona, ponía algo así?

886
01:11:20,250 --> 01:11:29,060
Cuando hablábamos antes, persona era el nombre de una clase y miper o per1, había puesto per1,

887
01:11:29,380 --> 01:11:32,960
por ponerlo igual que lo habíamos dicho, per1 era un objeto de la clase persona,

888
01:11:32,960 --> 01:11:50,180
al cual luego antes ya le podíamos asignar un nombre y una edad y todo esto. Pues aquí, fijaros que es el mismo esquema, mi scan es un objeto de la clase scanner, la clase scanner en este caso está desarrollada en los paquetes de Java, la clase personal la estaba desarrollando yo.

889
01:11:50,180 --> 01:11:55,279
directamente esto decíamos, esto si es un tipo referenciado

890
01:11:55,279 --> 01:11:58,680
que no es un tipo primitivo de Java, ya nos permite

891
01:11:58,680 --> 01:12:03,560
acceder a sus parámetros y a sus métodos, decíamos no, si es referenciado

892
01:12:03,560 --> 01:12:07,140
necesitamos hacerle un new, que era el que le pedía

893
01:12:07,140 --> 01:12:11,180
al sistema operativo espacio de memoria para tener

894
01:12:11,180 --> 01:12:15,199
toda la información relacionada con el objeto per1, pues fijaros lo que hacemos aquí

895
01:12:15,199 --> 01:12:19,520
new, esto le está pidiendo al sistema operativo espacio de memoria

896
01:12:19,520 --> 01:12:23,800
para reservar toda la información de un objeto que se llama en mi programa

897
01:12:23,800 --> 01:12:28,119
miScan y que responde al esquema de una clase que tengo definida

898
01:12:28,119 --> 01:12:30,100
en las librerías de Java, que es Scanner.

899
01:12:33,529 --> 01:12:38,149
Y luego aquí os decía que aquí se llama, siempre después del new,

900
01:12:38,289 --> 01:12:41,130
a un método, y es un método porque tiene aquí los paréntesis,

901
01:12:42,630 --> 01:12:46,109
que se llama exactamente igual que la clase y es el método constructor,

902
01:12:46,310 --> 01:12:48,510
del cual hablaremos otro día.

903
01:12:48,510 --> 01:12:52,930
entonces fijaros como se sigue manteniendo el mismo esquema

904
01:12:52,930 --> 01:12:56,590
la clase se llama Scanner y después del new llamamos a un método

905
01:12:56,590 --> 01:12:59,329
y es un método porque hay aquí unos paréntesis como veis

906
01:12:59,329 --> 01:13:03,689
que se llama exactamente igual que la clase con lo cual es un constructor

907
01:13:03,689 --> 01:13:08,710
y en particular le estamos diciendo que este objeto Scanner

908
01:13:08,710 --> 01:13:12,529
se enganche para leer información

909
01:13:12,529 --> 01:13:16,430
a una tubería

910
01:13:16,430 --> 01:13:20,449
que quiero enganchar a mi programa, que es System.im.

911
01:13:20,569 --> 01:13:30,479
Y System.im hemos dicho que era la entrada por defecto.

912
01:13:30,479 --> 01:13:36,199
¿Por qué indico aquí este System.im en este método constructor de la clase Scanner?

913
01:13:36,560 --> 01:13:40,220
Pues porque con la clase Scanner puedo leer desde el teclado,

914
01:13:40,359 --> 01:13:44,880
si pongo aquí System.im, puedo leer desde un fichero que tenga guardado en disco,

915
01:13:45,100 --> 01:13:49,359
si pongo la ruta del fichero, iré haciendo diferentes lecturas

916
01:13:49,359 --> 01:13:52,979
del flujo de datos que indique aquí en el constructor.

917
01:13:53,579 --> 01:13:55,859
En particular ahora nos interesa leer desde el teclado,

918
01:13:56,000 --> 01:14:00,199
por eso pongo System.im, que hemos dicho que es el flujo de datos

919
01:14:00,199 --> 01:14:03,479
de la entrada por defecto en Java, que se establece.

920
01:14:06,859 --> 01:14:10,960
Mira, si yo cojo y pongo aquí string, ese valor,

921
01:14:14,260 --> 01:14:19,359
defino qué estoy haciendo en esta instrucción.

922
01:14:19,359 --> 01:14:21,960
Cada instrucción voy despacito y voy repasando todo.

923
01:14:23,060 --> 01:14:25,899
Defino una variable, que en este caso es de tipo string.

924
01:14:25,899 --> 01:14:30,039
¿Necesito hacer un new? No, porque string es un tipo de los primitivos

925
01:14:30,039 --> 01:14:34,039
de Java. String tiene alguna particularidad que la diferencia con el resto de datos

926
01:14:34,039 --> 01:14:37,899
de tipos primitivos, pero en tanto en cuanto tener que hacer el new

927
01:14:37,899 --> 01:14:43,869
no es necesario. ¿Por qué? Porque es tipo primitivo. Le indico

928
01:14:43,869 --> 01:14:47,829
el nombre y bueno, de partida, he puesto aquí que se inicialice a un

929
01:14:47,829 --> 01:14:52,109
valor. Podríamos poner que no estuviera inicializado. Vamos a decir que de partida

930
01:14:52,109 --> 01:14:54,409
tenga un texto que sea nada.

931
01:14:54,409 --> 01:14:57,409
entonces si ahora pongo yo aquí ese valor

932
01:14:57,409 --> 01:14:59,930
que esa variable sea igual

933
01:14:59,930 --> 01:15:04,109
utilizo el objeto

934
01:15:04,109 --> 01:15:05,630
de la clase scanner, mi scan

935
01:15:05,630 --> 01:15:08,090
y ahora si yo le pongo aquí un punto

936
01:15:08,090 --> 01:15:09,670
tengo acceso

937
01:15:09,670 --> 01:15:12,229
¿os acordáis antes cuando para la persona

938
01:15:12,229 --> 01:15:14,069
per1 le quería asignar

939
01:15:14,069 --> 01:15:15,670
una edad y ponía iedad?

940
01:15:18,289 --> 01:15:19,850
aquí no me compila lógicamente

941
01:15:19,850 --> 01:15:21,970
porque en el proyecto este de Eclipse no tengo

942
01:15:21,970 --> 01:15:24,149
definido la clase

943
01:15:24,149 --> 01:15:26,289
ni la clase persona

944
01:15:26,289 --> 01:15:28,050
ni este objeto, porque está aquí comentado

945
01:15:28,050 --> 01:15:32,289
pero la forma de acceder a la edad de una persona

946
01:15:32,289 --> 01:15:34,989
era con un punto y su valor

947
01:15:34,989 --> 01:15:36,989
y si queríamos que esa persona saludara

948
01:15:36,989 --> 01:15:38,949
os acordáis que habíamos definido el método saludar

949
01:15:38,949 --> 01:15:42,109
poníamos per1.saludar

950
01:15:42,109 --> 01:15:44,510
y entonces hacía todas las acciones

951
01:15:44,510 --> 01:15:48,149
que utilizan las personas para saludar

952
01:15:48,149 --> 01:15:49,930
¿qué persona saludaba? per1

953
01:15:49,930 --> 01:15:54,270
pues entonces, siguiendo esa misma idea

954
01:15:54,270 --> 01:15:57,970
igual que teníamos per1 como un objeto de la clase persona

955
01:15:57,970 --> 01:16:20,470
tenemos mi scan como un objeto de la clase scanner, entonces si ponemos aquí mi scan, ponemos aquí un punto, aquí me podré acceder a aquellos parámetros y aquellos métodos que tenga disponible en la librería de Java, porque así se definió en su momento, la clase scanner.

956
01:16:20,470 --> 01:16:54,159
Entonces, pues mirad, fijaros todos los métodos que tiene disponible por aquí, muchos, uno de ellos es el método Nestline, lo que hace Scanner cuando llamas al método Nestline es leer una línea hasta que hay un Enter.

957
01:16:54,159 --> 01:17:00,369
¿De dónde leerá Scanner? Pues como aquí, cuando lo hemos

958
01:17:00,369 --> 01:17:04,069
definido en el constructor, le hemos dicho que sea de System.in, pues leerá

959
01:17:04,069 --> 01:17:08,430
una línea completa desde teclado. Si aquí hubiéramos puesto un fichero, ¿de dónde leería

960
01:17:08,430 --> 01:17:11,850
una línea completa el objeto

961
01:17:11,850 --> 01:17:16,229
MiScanner, que es de la clase Scanner? Si hubiéramos puesto aquí un fichero, pues leería

962
01:17:16,229 --> 01:17:22,079
una línea entera de ese fichero. Voy a hacer una ejecución ahora

963
01:17:22,079 --> 01:17:26,539
un momento. Después de leer esta línea

964
01:17:26,539 --> 01:17:30,779
voy a poner aquí un system.out.println

965
01:17:30,779 --> 01:17:42,560
y a poner aquí terminando, este programa

966
01:17:42,560 --> 01:17:46,819
arrancará en el main, bueno, sacará un, voy a comentar

967
01:17:46,819 --> 01:17:50,800
el hola mundo este, el system.out, definirá esto, vale, pues

968
01:17:50,800 --> 01:17:54,779
hará esa acción que no tendrá ninguna repercusión en la consola para

969
01:17:54,779 --> 01:17:58,859
nosotros, una variable, lee una línea, pero esta lectura de la

970
01:17:58,859 --> 01:18:02,880
línea la mete en esta variable, con lo cual seguimos sin ninguna repercusión

971
01:18:02,880 --> 01:18:09,640
en nuestra consola para ver nada y luego después de leer esa línea, sacará un terminado aquí.

972
01:18:10,880 --> 01:18:16,699
Si yo lo doy aquí y ejecuto, resulta que ahí se me queda. Fijaros, ¿veis que no me ha mostrado nada?

973
01:18:17,500 --> 01:18:21,840
Pero el programa está arrancado. ¿Veis aquí el pilotito este rojo? ¿Qué es lo que ha sucedido?

974
01:18:22,260 --> 01:18:27,500
Pues que se me ha quedado en esta línea esperando a que yo escriba algo. Ha definido estas variables

975
01:18:27,500 --> 01:18:40,189
y está aquí en esta línea. Si yo pongo aquí hola por teclado y le doy enter, en el momento que le dé enter leerá hasta el next line y continuará.

976
01:18:40,970 --> 01:18:47,210
Entonces le doy enter aquí y veis, como ya ha leído, habrá metido en ese valor este hola y me muestra el terminado.

977
01:18:48,369 --> 01:18:56,390
En definitiva, antes de encontrarnos un next line, para que no nos parezca que el programa se nos ha quedado colgado, como sucedería en este caso,

978
01:18:59,189 --> 01:19:32,689
he deshecho los cambios aquí, a ver, lo voy a parar, para que no suceda, como en este caso me parece que se nos ha quedado colgado, lo que haríamos sería meter un mensajito donde nos pida alguna información por teclado, entonces si nosotros ponemos aquí, como sé que aquí se me va a quedar parado, pues voy a poner por pantalla, system.out.ntln, mete alguna info, vamos a poner el mensaje que quisiéramos que nos saliese,

979
01:19:32,689 --> 01:19:43,989
Entonces, en este caso ya nos dice esto y ya sabemos que es que estamos esperando algo de información. Ponemos hola aquí, damos enter, salta esto y nos muestra aquí terminado.

980
01:19:43,989 --> 01:19:48,649
este valor que hemos cargado aquí, pues podríamos utilizarlo para trabajar con él

981
01:19:48,649 --> 01:19:50,710
entonces podríamos poner aquí

982
01:19:50,710 --> 01:19:59,779
me ha dicho y enlazo

983
01:19:59,779 --> 01:20:04,979
esta cadena de texto fija con la información que tenga esta variable

984
01:20:04,979 --> 01:20:11,029
que es la que acabamos de cargar por aquí por teclado, entonces dice

985
01:20:11,029 --> 01:20:15,409
mete algo de información y decimos hola y ahora dice me ha dicho y fijaros como pone

986
01:20:15,409 --> 01:20:19,470
este hola, gracias a que ese valor tiene el hola que acabamos de meter

987
01:20:19,470 --> 01:20:22,069
a través de la lectura desde teclado.

988
01:20:26,739 --> 01:20:27,140
¿Lo veis?

989
01:20:40,600 --> 01:20:42,420
Bueno, me preguntan

990
01:20:42,420 --> 01:20:43,479
por qué pongo ese valor.

991
01:20:44,899 --> 01:20:46,020
Os comentaba otro día

992
01:20:46,020 --> 01:20:48,479
en otra de las reuniones

993
01:20:48,479 --> 01:20:50,220
las variables

994
01:20:50,220 --> 01:20:52,600
tienen un determinado

995
01:20:52,600 --> 01:20:54,939
hay una determinada

996
01:20:54,939 --> 01:20:56,720
sintaxis para nombrar

997
01:20:56,720 --> 01:20:57,399
las variables.

998
01:20:58,800 --> 01:21:00,600
Típicamente las variables suelen empezar con

999
01:21:00,600 --> 01:21:02,460
minúsculas y ¿por qué pongo yo aquí una S?

1000
01:21:02,460 --> 01:21:03,659
Pues es

1001
01:21:03,659 --> 01:21:05,899
una manía que tengo yo

1002
01:21:05,899 --> 01:21:09,539
de donde trabajé con anterioridad a ser profe.

1003
01:21:09,979 --> 01:21:12,140
Que allí, bueno, pues entre las normas que nos poníamos

1004
01:21:12,140 --> 01:21:15,439
era que para ser capaz de identificar un poco

1005
01:21:15,439 --> 01:21:17,720
el tipo de datos que nos encontrásemos

1006
01:21:17,720 --> 01:21:19,420
por ahí en cualquier zona de código,

1007
01:21:20,119 --> 01:21:22,699
pues le anteponíamos una letrita

1008
01:21:22,699 --> 01:21:24,920
que tenía que ver con el tipo de datos.

1009
01:21:25,939 --> 01:21:29,140
Pero esto es igual que, mira, para los métodos

1010
01:21:29,140 --> 01:21:31,920
hay un acuerdo más o menos

1011
01:21:31,920 --> 01:21:33,939
que los métodos tienen que empezar con minúsculas.

1012
01:21:33,939 --> 01:21:52,039
Que luego Java se traga con mayúsculas, pues se los traga, pero digamos que es un convenio generalizado. Las clases suelen empezar siempre con mayúsculas. Si tienes un nombre de una variable, pues por ejemplo, necesitas el valor en curso.

1013
01:21:52,039 --> 01:21:55,600
Pues lo normal es que la variable empiece con minúscula

1014
01:21:55,600 --> 01:21:56,939
Y si tiene varias palabras

1015
01:21:56,939 --> 01:21:59,560
Que cada una de las palabras

1016
01:21:59,560 --> 01:22:01,720
Su primera letra sea mayúscula

1017
01:22:01,720 --> 01:22:02,739
La S

1018
01:22:02,739 --> 01:22:04,840
Pues la costumbre que tengo yo

1019
01:22:04,840 --> 01:22:07,140
Heredada de aquellos tiempos en los que trabajaba

1020
01:22:07,140 --> 01:22:08,359
En este caso la S

1021
01:22:08,359 --> 01:22:10,340
Le he puesto una S porque es un string

1022
01:22:10,340 --> 01:22:12,119
Ese es el criterio que tengo yo

1023
01:22:12,119 --> 01:22:13,399
Pero no es un estándar

1024
01:22:13,399 --> 01:22:16,579
Tan oficial

1025
01:22:16,579 --> 01:22:18,960
Como el de los métodos minúsculas

1026
01:22:18,960 --> 01:22:20,260
Las clases mayúsculas

1027
01:22:20,260 --> 01:22:24,239
si tienes una constante todas ellas en mayúscula, esos son estándares

1028
01:22:24,239 --> 01:22:26,939
como muy generalizados de Java, este no tanto

1029
01:22:26,939 --> 01:22:31,460
pero en mis ejemplos verás que siempre lo suelo poner así

1030
01:22:31,460 --> 01:22:40,619
porque tengo esa rutina, ¿sabes? de hacerlo. ¿Se ve bien?

1031
01:22:42,989 --> 01:22:46,250
Vale, mirad, cuando tú

1032
01:22:46,250 --> 01:22:52,270
lees con Scanner, con Nest lee cualquier cosa

1033
01:22:52,270 --> 01:22:56,449
puedes poner un Nest Synth y te lee un entero

1034
01:22:56,449 --> 01:23:02,510
Puedes poner Ness Double y te lee una variable de tipo Double

1035
01:23:02,510 --> 01:23:07,670
Es decir, tiene un montón de métodos definidos en las librerías de Java

1036
01:23:07,670 --> 01:23:10,930
La clase Scanner que te permite la lectura de diferentes tipos

1037
01:23:10,930 --> 01:23:19,409
Hay algunas situaciones en las que el leer con Nessing bien gestionado no tiene por qué dar problemas

1038
01:23:19,409 --> 01:23:25,689
Luego algunos de vosotros me hacéis ejercicios y lo controláis y no os da problemas

1039
01:23:25,689 --> 01:23:36,189
Pero la lectura de datos con estos otros métodos, como Nessin, Nessdouble, a veces puede generar problemas del siguiente tipo.

1040
01:23:36,550 --> 01:23:44,130
Mirad, imaginaros que tú tienes en un programa que lees un entero y luego lees una línea.

1041
01:23:44,850 --> 01:23:50,670
Tienes estas dos líneas, en tu flujo de datos se puede dar esa situación, en la cual te vas a leer primero,

1042
01:23:50,670 --> 01:23:53,170
imaginaos que en el programa te pide

1043
01:23:53,170 --> 01:23:55,250
que metas un número, tienes la necesidad

1044
01:23:55,250 --> 01:23:56,529
de meter un número, metes un 8

1045
01:23:56,529 --> 01:23:57,989
y luego metes

1046
01:23:57,989 --> 01:24:00,630
un texto, que sea hola, ¿vale?

1047
01:24:02,739 --> 01:24:04,720
Si tú lees con nesint

1048
01:24:04,720 --> 01:24:06,640
un entero

1049
01:24:06,640 --> 01:24:08,739
cuando lee el 8

1050
01:24:08,739 --> 01:24:10,279
no se espera

1051
01:24:10,279 --> 01:24:12,119
a un enter porque

1052
01:24:12,119 --> 01:24:14,880
el enter lo coge cuando tú lees

1053
01:24:14,880 --> 01:24:15,720
con un nesline.

1054
01:24:16,819 --> 01:24:18,260
Entonces tú puedes coger y poner aquí

1055
01:24:18,260 --> 01:24:19,779
int y valor

1056
01:24:19,779 --> 01:24:25,340
igual y con nesynth te cogería y te leería un entero

1057
01:24:25,340 --> 01:24:29,279
pero te lee un entero cuando ya has metido un entero, no necesariamente espera

1058
01:24:29,279 --> 01:24:33,579
o a lo mejor metes aquí un espacio y ya como los separas con un espacio

1059
01:24:33,579 --> 01:24:37,500
no con un enter, has cogido y te ha considerado

1060
01:24:37,500 --> 01:24:41,100
ya un entero y te carga el 8 aquí, si tú en tu programa

1061
01:24:41,100 --> 01:24:45,539
después de leer un entero resulta que vas a leer una línea y haces esto

1062
01:24:45,539 --> 01:24:49,300
al meterlo pones 8 enter

1063
01:24:49,300 --> 01:24:52,159
se puede dar el caso, bajo ciertas casuísticas

1064
01:24:52,159 --> 01:24:54,220
y suele ser complicado encontrar el motivo

1065
01:24:54,220 --> 01:24:56,199
se puede dar

1066
01:24:56,199 --> 01:24:57,979
el caso que aquí te meta

1067
01:24:57,979 --> 01:24:59,960
el 8 y en esto que

1068
01:24:59,960 --> 01:25:01,779
tienes un Slime que esperabas

1069
01:25:01,779 --> 01:25:04,020
un texto con un Enter, te cargue

1070
01:25:04,020 --> 01:25:04,939
el Enter solo

1071
01:25:04,939 --> 01:25:10,550
y si te termina pasando esto, es complicado

1072
01:25:10,550 --> 01:25:11,890
si tienes un programa un poco largo

1073
01:25:11,890 --> 01:25:14,310
terminar de darte cuenta que esto sucede

1074
01:25:14,310 --> 01:25:16,409
esto, hay una

1075
01:25:16,409 --> 01:25:18,409
forma de evitarlo, si por

1076
01:25:18,409 --> 01:25:20,270
defecto, seguir siempre

1077
01:25:20,270 --> 01:25:24,409
este mecanismo, pero no es obligatorio porque también con cuidado

1078
01:25:24,409 --> 01:25:28,289
se puede evitar que se lleguen a dar estas situaciones. Pero una forma muy directa

1079
01:25:28,289 --> 01:25:31,789
que yo es la que utilizo siempre, es leer siempre con Nestline

1080
01:25:31,789 --> 01:25:36,329
aunque sean valores numéricos. Nestline lo que nos devuelve es un string.

1081
01:25:37,590 --> 01:25:39,810
Entonces si yo lo que quiero leer es un entero,

1082
01:25:40,390 --> 01:25:44,529
yo ahora defino aquí el valor entero y puedo pasar

1083
01:25:44,529 --> 01:25:48,229
un string, un valor string a un entero con un método

1084
01:25:48,229 --> 01:25:50,949
de la clase integer, no, de la clase

1085
01:25:50,949 --> 01:25:52,850
integer, si, bueno, hay varias formas

1086
01:25:52,850 --> 01:25:57,170
fijaros, el método integer parseInt

1087
01:25:57,170 --> 01:25:59,770
la clase integer

1088
01:25:59,770 --> 01:26:03,189
es una clase que tiene que ver

1089
01:26:03,189 --> 01:26:05,890
con funciones relacionadas con los enteros

1090
01:26:05,890 --> 01:26:08,850
entonces, si utilizas el método parseInt

1091
01:26:08,850 --> 01:26:12,710
de la clase integer y le pones aquí

1092
01:26:12,710 --> 01:26:15,710
un string, el valor

1093
01:26:15,710 --> 01:26:22,750
que tenga ese string, imaginaos que tiene como una cadena de caracteres un 8, lo traslada

1094
01:26:22,750 --> 01:26:29,989
para cargarlo en una variable de tipo entero a 8. Esto es un string cuyo único carácter

1095
01:26:29,989 --> 01:26:35,229
es el carácter 8 y esto es una variable entera con valor 8. Esto es un número, esto no es

1096
01:26:35,229 --> 01:26:41,949
un número, es un string, pero su carácter es un 8. Entonces con esta secuencia de hacer

1097
01:26:41,949 --> 01:26:49,590
leerlo como una línea y trasladarlo al valor entero, que en realidad en este momento lo que queríamos era leer un entero

1098
01:26:49,590 --> 01:27:03,289
mediante un integer parseInt, consigues el efecto equivalente al nestInt de escáner y en todo momento evitas situaciones

1099
01:27:03,289 --> 01:27:09,090
que se pudieran dar de esas raras como las que os intentaba comentar antes si lo que quiere ser

1100
01:27:09,090 --> 01:27:19,729
leer un valor con un flow at que tenga un double que tenga parte decimal pues puedes y hacer

1101
01:27:20,789 --> 01:27:32,369
lo lees como un string y luego pones double de valor y tienes la clase rapper double

1102
01:27:33,289 --> 01:27:42,140
punto y auxilias el par se da gol y aquí ha leído un double desde teclado

1103
01:27:44,000 --> 01:27:49,779
evitando el posible problema ese que os pudiera llegar a dar yo siempre hago esto en dos pasos

1104
01:27:50,779 --> 01:28:18,220
también mira podemos tenemos diferentes alternativas mira podríamos si tenemos tres

1105
01:28:18,220 --> 01:28:32,810
valores y valor 1 si es verdad es verdad si lanzó la pregunta me preguntan por por cómo podemos hacer

1106
01:28:32,810 --> 01:28:40,289
para tres valores seguidos a través de con escáner para de cara un poco a la idea de la práctica

1107
01:28:40,289 --> 01:28:45,890
bueno pues mira tenemos varias alternativas una podría ser si tenemos los tres valores que son

1108
01:28:45,890 --> 01:29:07,770
de tipo entero, int y valor 1, vamos a poner aquí tres valores, 2 y 3, ponemos aquí, dime el valor 1, por ejemplo.

1109
01:29:15,859 --> 01:29:22,060
Mirad, aprovecho y os cuento otra cosita, el System of Println, pues tiene no solamente el método print,

1110
01:29:22,279 --> 01:29:30,720
Println, o sea, Println, el método Println lo que hace es mostrar esto por pantalla y si es este

1111
01:29:30,720 --> 01:29:36,720
te muestra el cursor se queda aquí en la siguiente línea al principio y luego tienes por ejemplo el

1112
01:29:36,720 --> 01:29:44,979
método print que le quitas el ln y ya no te hace el salto de línea con lo cual si tú pones un print

1113
01:29:44,979 --> 01:29:50,100
en lugar de un print ln el cursor se te queda aquí que parece como mejor si has pedido algo aquí que

1114
01:29:50,100 --> 01:29:54,119
se te quede el cursor aquí para que puedas escribir lo que estás pidiendo entonces mira voy a poner un

1115
01:29:54,119 --> 01:30:01,579
print entonces que podríamos hacer pues podríamos hacer ese valor lo leo como valor igual a mi scan

1116
01:30:01,579 --> 01:30:21,300
veis y hago un es mi scan a ver qué es lo que he hecho por aquí que no le gusta a bueno next line

1117
01:30:21,300 --> 01:30:32,529
leo una línea y ahora puedo coger y digo el valor 1 es que sea igual a como es un entero integer

1118
01:30:32,529 --> 01:30:43,159
.parseInt

1119
01:30:43,159 --> 01:30:45,640
¿De quién? De ese valor.

1120
01:30:46,779 --> 01:30:49,939
Con lo cual, leo un primer valor, se me viene aquí,

1121
01:30:50,300 --> 01:30:54,359
lo tengo aquí en modo string y lo cargo aquí en modo entero.

1122
01:30:55,000 --> 01:30:57,479
Y luego, una posibilidad, si quieres leer tres,

1123
01:30:58,020 --> 01:31:00,840
que no me acuerdo si lo bloquea el enunciado ahora mismo,

1124
01:31:01,659 --> 01:31:03,899
pero bueno, os cuento esta posibilidad y ahora os cuento una segunda.

1125
01:31:03,899 --> 01:31:10,659
Dime el valor 2, vuelvo a leer, lo cargo aquí, no me importa perderlo del que cogí aquí porque ya me lo he guardado en valor 1.

1126
01:31:11,420 --> 01:31:14,720
Pongo aquí valor 2 y podría cargar un tercer valor aquí.

1127
01:31:18,670 --> 01:31:21,430
Dime el valor 3 y lo cargo en la variable 3.

1128
01:31:22,970 --> 01:31:25,170
Con lo cual ahí he leído tres números desde el teclado.

1129
01:31:25,949 --> 01:31:56,479
Mira, vamos a poner aquí valor 1, vamos a sacarlo por pantalla, valor 2, valor 3.

1130
01:31:56,479 --> 01:32:02,640
dice valor 1, vamos a poner un 5, un 7 y un 3

1131
01:32:02,640 --> 01:32:06,819
y aquí ves, ahora me muestra el resultado de los 3 valores y cada uno lo tengo en una de las variables

1132
01:32:06,819 --> 01:32:12,880
para poder hacer el cálculo que toque, no me acuerdo si

1133
01:32:12,880 --> 01:32:16,739
el enunciado lo exija así, pero también podría el enunciado

1134
01:32:16,739 --> 01:32:20,800
o como alternativa, podríais pensar, pues mira, quiero cargar los 3 valores pero solamente

1135
01:32:20,800 --> 01:32:24,880
quiero escribir una línea, entonces podría coger y en lugar de hacerlo

1136
01:32:24,880 --> 01:32:33,979
así, 3 veces, en una línea, vamos a ver como lo hacemos en una línea

1137
01:32:33,979 --> 01:32:55,890
pues mira hacer una línea podríamos cargarlo aquí vamos a hacer un sistema vendría a ser

1138
01:32:56,909 --> 01:33:09,939
pues mira la idea bueno en lugar de darme el valor 1 sería darme los tres valores separados

1139
01:33:09,939 --> 01:33:18,720
por un espacio hacemos así y me se me queja aquí en ese valor bueno se me queja

1140
01:33:18,720 --> 01:33:22,260
se me queja por este parseInt

1141
01:33:22,260 --> 01:33:23,800
lógicamente

1142
01:33:23,800 --> 01:33:25,859
¿qué ha sucedido? ¿por qué me ha dado

1143
01:33:25,859 --> 01:33:27,760
un error? el texto que he metido ha sido

1144
01:33:27,760 --> 01:33:29,420
esto, que no es un número

1145
01:33:29,420 --> 01:33:31,840
porque tiene espacios, he intentado

1146
01:33:31,840 --> 01:33:33,739
hacer un parseInt para convertir esto

1147
01:33:33,739 --> 01:33:35,399
en un entero y como

1148
01:33:35,399 --> 01:33:37,600
no ha sido capaz me ha dado este error

1149
01:33:37,600 --> 01:33:39,479
de hecho dice, me ha dado un error de

1150
01:33:39,479 --> 01:33:41,279
number format exception, ha dicho

1151
01:33:41,279 --> 01:33:43,319
no me gusta esto porque esto yo no sé

1152
01:33:43,319 --> 01:33:47,340
identificarlo como un número, voy a hacer

1153
01:33:47,340 --> 01:33:49,100
una ejecución después de comentar eso

1154
01:33:49,100 --> 01:33:52,300
fijaros como he cogido

1155
01:33:52,300 --> 01:33:55,020
el valor 3, 5, 6, lo tiene el string

1156
01:33:55,020 --> 01:33:57,880
no solo ha asignado ahora un valor

1157
01:33:57,880 --> 01:34:01,000
lo muestro, me muestra el 3, 5, 6, o sea que ese dato lo ha cogido

1158
01:34:01,000 --> 01:34:04,020
y luego he mostrado el valor 1, 2 y 3 que estaban

1159
01:34:04,020 --> 01:34:06,960
inicializados a ceros y es lo que me ha mostrado. Lo que quiero

1160
01:34:06,960 --> 01:34:09,579
es distribuir esto en

1161
01:34:09,579 --> 01:34:12,840
estas tres variables. Pues mirad, una posible

1162
01:34:12,840 --> 01:34:16,039
forma de hacerlo es con un método de la clase

1163
01:34:16,039 --> 01:34:20,670
string y

1164
01:34:21,310 --> 01:34:28,869
y con ese método la clase stream podemos utilizar un array de caracteres que no va a dar tiempo a

1165
01:34:28,869 --> 01:34:37,890
contarlo y yo creo los una los arrays mirad un array os cuento muy rápido si tú tienes si tú

1166
01:34:37,890 --> 01:34:47,210
coges y define es una variable imaginaos un entero y pues esto se va a la memoria ram es

1167
01:34:47,210 --> 01:34:54,310
una variable primitiva no necesitamos hacer el new y tú coges y en memoria ram coger y

1168
01:34:54,310 --> 01:35:02,829
dirá para la variable para la variable y reservo espacio en la posición 10.000 tú coges y dices

1169
01:35:02,829 --> 01:35:10,529
en jota y dice para la variable jota el sistema operativo respeto de reserva espacio en la

1170
01:35:10,529 --> 01:35:21,109
variable 10.100 y defines una tercera variable int p y lo mismo no para la variable p en el 10.200

1171
01:35:22,649 --> 01:35:27,489
para cada variable define su espacio de memoria cuando acceda a ellas pues guardará información

1172
01:35:27,489 --> 01:35:35,270
en esta zona de memoria y al leer leerá de ellas existe el existen los una de las estructuras de

1173
01:35:35,270 --> 01:35:41,630
datos que tenemos en java hablaremos en este tema me parece que había algo de teoría introductoria

1174
01:35:41,630 --> 01:35:47,449
los arrays ya o en el tema siguiente bueno son los arrays los arrays en qué consisten pues mira

1175
01:35:47,449 --> 01:35:57,739
tú puedes definir un tipo de datos con los corchetes tú identificas una variable el nombre

1176
01:35:57,739 --> 01:36:08,100
de una variable y ahora esta variable no es en sí un entero sino que es un array de enteros y

1177
01:36:08,100 --> 01:36:18,840
Y poniéndole un new para solicitar reserva de memoria para muchos en los arrays, podemos coger y poner int y entre corchetes otra vez, por ejemplo, un 3.

1178
01:36:19,539 --> 01:36:27,840
Esta sintaxis. Decimos L es un array de enteros y quiero que tenga un total de hasta tres enteros.

1179
01:36:28,600 --> 01:36:34,779
Y estos tres enteros, el tamaño en sí se lo identifico aquí y lo hago con este formato.

1180
01:36:34,779 --> 01:37:05,090
Le pongo igual a new, int, porque la array es de enteros, y entre corchetes el tamaño. Esto lo que implica es que en L, o sea, para la variable R, para L, el programa le pide al sistema operativo espacio de memoria, pero si un entero tiene 32 bits, que son los que reservaría para I, para J y para P, a partir de la posición 10.000, 10.100 y 10.200,

1181
01:37:05,090 --> 01:37:19,350
En este caso, por ser 3, lo que haría sería reservar 96 bits, es decir, son 36 por 12, 12, bueno, los que sean, no 3, 3 por el tamaño que tenga un entero.

1182
01:37:20,109 --> 01:37:27,989
Y a lo mejor coge y lo reserva a partir de la posición 90.000, con lo cual si accedo a la posición 90.000 estaré accediendo al primero de los enteros,

1183
01:37:27,989 --> 01:38:01,560
Si accedo a la posición 90.000 más el tamaño de un entero, estaré accediendo al segundo, más tamaño entero, estaré accediendo al segundo, pone lo que quiere y sin tilde ni nada, y si accedo al 90.000 más dos veces un entero, más dos veces el tamaño de un entero, estaré accediendo al tercero.

1184
01:38:01,560 --> 01:38:17,380
Esto en cuanto a la memoria RAM. ¿En el código cómo lo hacemos? Pues mirad, para acceder al primero, a este que se va a guardar en la posición 90.000, yo cojo y pongo L y entre corchetes un 0. Y este es el acceso al primero de los enteros.

1185
01:38:17,380 --> 01:38:21,880
fijaros, L0 es un entero

1186
01:38:21,880 --> 01:38:26,079
mirad, L y unos corchetes es un entero

1187
01:38:26,079 --> 01:38:29,199
con lo cual aquí lo puedo coger y guardar el valor, un valor entero

1188
01:38:29,199 --> 01:38:34,000
igual que se lo guardaba I, tanto I como L0

1189
01:38:34,000 --> 01:38:36,939
es un entero, para acceder al segundo

1190
01:38:36,939 --> 01:38:40,479
de los enteros que tengo definidos en este array

1191
01:38:40,479 --> 01:38:45,340
pondría L1, L1 es el segundo de los enteros

1192
01:38:45,340 --> 01:38:52,420
a los cuales accedo a partir de la etiqueta L, que será L posición 90.000 más el tamaño de un entero,

1193
01:38:52,640 --> 01:38:54,840
será la zona de memoria RAM donde estaría accediendo.

1194
01:38:56,020 --> 01:38:59,819
Entonces tendría una segunda variable que sería así, al cual le puedo acceder una 9.

1195
01:39:00,159 --> 01:39:03,539
Y la tercera de las variables sería con un 2.

1196
01:39:04,180 --> 01:39:07,140
¿Por qué llega hasta 2? Llega hasta 2 porque el tamaño es 3.

1197
01:39:07,500 --> 01:39:11,079
Son la posición 0, la posición 1 y la posición 2. Así son los arrays.

1198
01:39:12,479 --> 01:39:13,640
Hablaremos más de ellos.

1199
01:39:13,640 --> 01:39:44,159
Entonces, fijaros, si nosotros aquí cogemos y definimos un array de strings, ponemos string, ese info y utilizamos de la clase string, fijaros, string, el método split, pues tiene un montón de métodos, aquí le podemos indicar qué carácter es el que lo diferencia.

1200
01:39:44,159 --> 01:40:09,199
Os explico esta instrucción, enlazando con lo que os contaba antes. Ese valor, de acuerdo a esta ejecución, si la repetimos, tiene 3 espacio 5 espacio 6. Fijaros que este espacio es el carácter que he puesto aquí en el split.

1201
01:40:09,199 --> 01:40:13,680
split, seguro que sabéis mucho más inglés que yo, significa dividir

1202
01:40:13,680 --> 01:40:16,479
en inglés, ¿no? Entonces, estamos diciéndole

1203
01:40:16,479 --> 01:40:21,319
que lo que tiene este valor, esta variable, nos la

1204
01:40:21,319 --> 01:40:23,479
separe en trocitos, considerando que

1205
01:40:23,479 --> 01:40:29,520
la expresión separadora es un espacio, con lo cual si metemos

1206
01:40:29,520 --> 01:40:33,380
información separada por espacios, nos lo va a separar en tres

1207
01:40:33,380 --> 01:40:37,359
bloques, uno que tendrá un 3, otro que tendrá un 5 y otro que tendrá

1208
01:40:37,359 --> 01:40:45,699
un 6 y que lo guarde en un array de strings fijaros en ese info que es un array de strings

1209
01:40:45,699 --> 01:40:53,500
si metemos un 3 un 5 y un 6 resultará que vamos a tener tres posiciones que se parece mucho a lo

1210
01:40:53,500 --> 01:41:00,659
que habíamos definido antes aquí os acordáis de las tres posiciones entonces fijaros si yo ahora

1211
01:41:00,659 --> 01:41:11,060
cojo y aquí en una primera línea muestro ese valor en una segunda línea muestro ese valor

1212
01:41:11,060 --> 01:41:21,579
en la posición 0, ese valor no, ese info

1213
01:41:21,579 --> 01:41:26,680
que es el que es el array en la posición 0, ese info

1214
01:41:26,680 --> 01:41:34,180
ahí está, ese info en la posición

1215
01:41:34,180 --> 01:41:40,229
1 y ese info en la posición 2

1216
01:41:40,229 --> 01:41:47,960
mira, si hacemos esta ejecución, dime el valor, metemos el 3

1217
01:41:47,960 --> 01:41:51,039
el 6 y el 9, y mirad

1218
01:41:51,039 --> 01:41:55,720
dime el valor, este texto, como he puesto

1219
01:41:55,720 --> 01:41:59,920
print se me ha quedado el cursor aquí, ¿veis? He metido el 4, 6 y 9

1220
01:41:59,920 --> 01:42:03,859
en lo que he metido yo por teclado. Esa información la he cargado en ese

1221
01:42:03,859 --> 01:42:06,640
valor. La variable de ese valor aquí la he mostrado

1222
01:42:06,640 --> 01:42:11,920
y me ha sacado el 4, 6 y 9. Antes de hacer eso

1223
01:42:11,920 --> 01:42:15,899
utilizando la información que tiene ese valor que es 4, 6 y 9

1224
01:42:15,899 --> 01:42:19,859
como vemos aquí, he llamado al método split diciéndole que

1225
01:42:19,859 --> 01:42:23,500
la expresión por la cual quiero hacer la división de esa

1226
01:42:23,500 --> 01:42:26,439
cadena de caracteres es un espacio

1227
01:42:26,439 --> 01:42:29,939
y como voy a necesitar guardarlo en diferentes variables

1228
01:42:29,939 --> 01:42:33,439
cojo y defino un array de strings

1229
01:42:33,439 --> 01:42:38,109
esta separación me ha generado

1230
01:42:38,109 --> 01:42:40,890
tres strings diferentes, el 4, el 6 y el 9

1231
01:42:40,890 --> 01:42:43,890
que son los tres strings que están separados por este espacio

1232
01:42:43,890 --> 01:42:45,949
y me lo ha cargado en este array, ese info

1233
01:42:45,949 --> 01:42:50,229
como tiene tres valores, resulta que

1234
01:42:50,229 --> 01:42:53,090
si muestro ese info posición 0

1235
01:42:53,090 --> 01:42:56,409
me enseña uno de los valores, el primero de ellos, el 4.

1236
01:42:57,229 --> 01:43:00,810
Ese info 1 me muestra el segundo de los valores,

1237
01:43:01,170 --> 01:43:05,390
que en este caso es un 6. Y ese info 2 me muestra el tercero

1238
01:43:05,390 --> 01:43:08,250
de los valores, que en este caso es un 9. ¿Lo veis?

1239
01:43:08,850 --> 01:43:12,189
Ese info 0, ¿qué es? ¿Qué tipo de datos es?

1240
01:43:13,449 --> 01:43:17,329
Ese info 0, fijaros, es un string. ¿Lo tengo

1241
01:43:17,329 --> 01:43:20,590
en el dato que a mí me interesa? Todavía no, porque me interesa tenerlo

1242
01:43:20,590 --> 01:43:22,609
en valores numéricos, ¿verdad?

1243
01:43:22,970 --> 01:43:25,550
Como hemos pasado antes en el ejercicio,

1244
01:43:25,649 --> 01:43:26,869
antes de utilizar el split,

1245
01:43:27,689 --> 01:43:33,130
los valores que tenían cadenas de caracteres strings

1246
01:43:33,130 --> 01:43:36,409
a números, pues con el integer parseInt,

1247
01:43:36,449 --> 01:43:36,949
¿os acordáis?

1248
01:43:37,130 --> 01:43:38,090
Entonces podemos decir aquí,

1249
01:43:38,090 --> 01:43:45,970
y valor1 es igual a integer.parseInt.

1250
01:43:46,529 --> 01:43:47,609
Y aquí, ¿qué tengo que poner?

1251
01:43:47,689 --> 01:43:48,670
Tengo que poner un string.

1252
01:43:48,890 --> 01:43:49,810
¿Me interesa ese valor?

1253
01:43:50,329 --> 01:43:52,050
Si pongo ese valor, me va a dar este dato.

1254
01:43:52,710 --> 01:43:55,210
¿Quién tiene el primero de los valores, un 4?

1255
01:43:57,760 --> 01:43:58,500
¿Ese info cero?

1256
01:44:02,119 --> 01:44:02,300
Sí.

1257
01:44:13,289 --> 01:44:14,510
Es una buena pregunta.

1258
01:44:14,510 --> 01:44:17,510
Me preguntan, lo digo para la grabación,

1259
01:44:17,890 --> 01:44:20,170
que si no es necesario definir el tamaño previo aquí.

1260
01:44:20,710 --> 01:44:23,069
Pues normalmente, cuando tú definas un array,

1261
01:44:23,350 --> 01:44:24,789
tienes que definir el tamaño previo.

1262
01:44:25,050 --> 01:44:26,949
Es obligatorio, porque si no, no sabe.

1263
01:44:27,829 --> 01:44:31,270
Cuando hace una reserva de memoria, no sabe cómo hacerla.

1264
01:44:31,369 --> 01:44:32,350
No sabe cuánto hacer.

1265
01:44:32,350 --> 01:44:48,069
¿Qué formas tenemos para definir el tamaño previo de Arrays? Pues mirad aquí, hay diferentes alternativas, una es utilizando esto, el new, con el new estar definiendo aquí el tamaño, otra posibilidad es inicializándolo,

1266
01:44:48,069 --> 01:45:07,310
Tú puedes poner igual, pones aquí, creo recordar que es entre llaves, pones aquí valores, en este caso valores numéricos porque el array es de enteros y como se encuentra aquí una serie de valores de inicialización, da un tamaño ya de 3 y a la posición 0 le da un 2, a la posición 1 le da un 4, a la posición 2 le da un 2.

1267
01:45:07,310 --> 01:45:31,590
En este caso, el tamaño lo está entendiendo gracias a la inicialización. En este caso, porque se lo decimos aquí explícitamente. En este caso, pues porque el método split se encarga de fijarse a ver cuánto tamaño hay y dentro de este método en la librería de Java, que desconozco cómo lo han programado, con toda seguridad estará haciendo el new necesario para que esto tenga, en este caso, tres posiciones.

1268
01:45:34,029 --> 01:45:37,270
Es decir, ¿es necesario definir en un array el tamaño? Siempre.

1269
01:45:38,130 --> 01:45:45,649
¿Alternativas que tenemos? Indicándoselo de forma explícita a través de inicialización o que durante el código se haga de alguna forma.

1270
01:45:45,649 --> 01:45:56,010
En este caso, en nuestro programa, nosotros no se lo tenemos que poner, pero este array habrá tenido un tamaño inicial antes de asignar los valores, seguro.

1271
01:45:56,149 --> 01:46:00,710
¿Dónde se habrá asignado? En el método de split. ¿El método de split lo estamos programando nosotros? No.

1272
01:46:00,710 --> 01:46:12,720
lo habrán hecho cuando hicieron ese programa en las librerías de java se entiende claro por qué

1273
01:46:12,720 --> 01:46:20,500
porque en este en el momento el split estoy voy a hacer suposiciones porque no veo el código pero

1274
01:46:20,500 --> 01:46:27,579
que entiendo yo que hará split pues explica ojera y mirará a ver cuántos strings en este caso hay

1275
01:46:27,579 --> 01:46:33,979
separados por un espacio si pusiéramos aquí una en lugar de un espacio el carácter separador aquí

1276
01:46:33,979 --> 01:46:41,159
tenemos que poner 4 a 6 a 9 pues que ahora mirará a ver cuántos hay antes de empezar a asignar

1277
01:46:41,159 --> 01:46:47,539
cogerá y dirá voy a hacer una reserva para lo que tenga que guardar ese info que en este caso

1278
01:46:47,539 --> 01:46:55,579
será tres estrés mira si yo cojo vamos a hacer vamos a hacer uno mira vamos vamos a hacer una

1279
01:46:55,579 --> 01:46:59,819
cosa vamos a pasarle dos valores para que veáis lo que pasa en lugar de tres vamos a poner que

1280
01:46:59,819 --> 01:47:06,319
imaginaos que la cadena que ponemos es 3 y 6 y coge y me da un fallo mira lo que ha pasado ha

1281
01:47:06,319 --> 01:47:15,500
cogido y ha cargado 3 y 6 ha hecho el split y aquí ese info 0 que tiene 3 se lo ha cargado

1282
01:47:18,159 --> 01:47:25,829
bueno ha mostrado ese info 0 y ese info 1 ha mostrado ese info 0 con el 3 ha mostrado ese

1283
01:47:25,829 --> 01:47:30,850
info 1 con el 1 y este me ha dado un error, el 2. ¿Por qué? Porque no ha hecho una reserva

1284
01:47:30,850 --> 01:47:37,449
suficientemente grande como para que haya tres posiciones en el array. Cuando intenta acceder a

1285
01:47:37,449 --> 01:47:42,130
la tercera posición del array, este split no reservó para una tercera posición. ¿Por qué?

1286
01:47:42,590 --> 01:47:46,449
Porque split se dio cuenta que solamente había dos datos y al intentar acceder a una tercera

1287
01:47:46,449 --> 01:47:52,550
posición del array, ese info 2, me ha dado un error aquí, que es, fijaros, el tipo de error,

1288
01:47:52,550 --> 01:47:57,270
excepción, hablaremos de las excepciones también, es índice del array

1289
01:47:57,270 --> 01:48:01,069
fuera del alcance, digamos. Y aquí nos

1290
01:48:01,069 --> 01:48:04,989
lleva un poquito más el detalle. Dice, el index2 está fuera del alcance para

1291
01:48:04,989 --> 01:48:11,659
la longitud de este array. Es decir, sí que está preocupándose de ver

1292
01:48:11,659 --> 01:48:15,079
qué tamaño tiene el método split para reservar suficiente

1293
01:48:15,079 --> 01:48:37,369
zona de memoria aquí en ese info. No, no, mira,

1294
01:48:37,829 --> 01:48:41,430
sí, vale, sí, sí, vamos a hacer una ejecución. Me preguntan que

1295
01:48:41,430 --> 01:48:46,149
bueno, con tres valores, está esto preparado para tres valores, hemos visto que si metemos

1296
01:48:46,149 --> 01:48:49,989
dos valores nos da un error, ¿qué pasaría si metemos cuatro? Pues

1297
01:48:49,989 --> 01:48:54,170
vamos a hacer una suposición y ahora lo ejecutamos. Yo creo que si metemos

1298
01:48:54,170 --> 01:48:58,130
cuatro, este split va a reservar en ese info un tamaño de cuatro.

1299
01:48:59,270 --> 01:49:02,149
Entonces va a meter el primer valor en ese info cero, el segundo en ese

1300
01:49:02,149 --> 01:49:06,170
info uno, el tercero en ese info dos, el cuarto valor lo va a meter en

1301
01:49:06,170 --> 01:49:10,170
ese info tres y como aquí no lo tenemos en código, ese info

1302
01:49:10,170 --> 01:49:15,149
3 tendrá ese cuarto valor pero no lo estaremos mostrando por pantalla entonces si ponemos aquí

1303
01:49:15,149 --> 01:49:22,710
por ejemplo 3 5 7 y 8 este caso no nos da error es info 3 lo ha cargado pero no lo hemos utilizado

1304
01:49:22,710 --> 01:49:29,069
y vamos a asegurarnos de que esto es así vamos a poner un sistema print el n de ese info 3 y

1305
01:49:29,069 --> 01:49:34,890
ahora hacemos coincidir el número de parámetros con el número de datos que vamos a meter les

1306
01:49:34,890 --> 01:49:42,510
ponemos 3 y efectivamente para él es info 3 ahora en el segundo de los tres nos muestra el 7 que es

1307
01:49:42,510 --> 01:49:54,640
este dato que hemos puesto bueno pues nada tenemos y 21 aquí de las cosas que os iba a contar os he

1308
01:49:54,640 --> 01:50:00,520
contado muchas de las que quería y bueno alguna todavía no pero bueno por el próximo día os sigo

1309
01:50:00,520 --> 01:50:06,859
contando esto más o menos venía a hacer un poco falta para la práctica así que estupendo el

1310
01:50:06,859 --> 01:50:12,760
siguiente día cuento dos o tres detalles de por aquí y ya hablamos del tema 3 que a partir de

1311
01:50:12,760 --> 01:50:20,020
mañana lo pongo abierto ya tenéis alguna alguna cosilla que me queréis comentar antes de cerrar

1312
01:50:20,020 --> 01:50:47,229
se dime pues mira bueno tiene la posibilidad a través de file a ver cómo era esto bueno mira

1313
01:50:47,229 --> 01:50:52,350
te voy a decir la forma más directa de irte al código fuente y con como es un solo fichero me

1314
01:50:52,350 --> 01:50:56,909
lo puedes pasar por ahí y luego otro día lo intentamos terminar de colación bueno por aquí

1315
01:50:56,909 --> 01:51:03,750
con sport pases que si exportas el proyecto entero te va a exportar todo a todos los ficheritos me lo

1316
01:51:03,750 --> 01:51:09,029
podrías enviar también el fichero que te da esta exportación como un zip y yo luego lo descomprimo

1317
01:51:09,029 --> 01:51:17,189
y me cojo el código fuente para enviar el código fuente directamente mira aquí os comentaba que

1318
01:51:17,189 --> 01:51:24,569
clip se trabaja con un espacio de trabajo estos días atrás en el cual se van colocando todos los

1319
01:51:24,569 --> 01:51:31,710
proyectos entonces si estás utilizando la máquina virtual que os pase yo abriendo un terminal o

1320
01:51:31,710 --> 01:51:38,819
abriendo por aquí en la carpeta personal que la debían pues aparece este este directorio

1321
01:51:38,819 --> 01:51:47,979
el eclipse workspace ese workspace si te vas a ese ese fichero a ese directorio pones aquí

1322
01:51:47,979 --> 01:51:54,579
un ls ves que están justo tres directorios que corresponden en principio a los tres proyectos

1323
01:51:54,579 --> 01:52:01,239
que tenemos a hola y hola 2 como lo haya llamado tu proyecto pues habrá un directorio en particular

1324
01:52:01,239 --> 01:52:06,140
vamos por aquí también y lo vemos en paralelo en la misma secuencia a través del terminal y

1325
01:52:06,140 --> 01:52:12,399
del proyecto entonces entrando en el proyecto en particular sobre el que quieras pasarme la

1326
01:52:12,399 --> 01:52:19,079
información, tiene dos carpetas, una que es bin y otra que es src. Entramos en los dos, lo vamos

1327
01:52:19,079 --> 01:52:27,079
haciendo en paralelo. En el bin, ahora voy para atrás, están los .class, están los bytecode que

1328
01:52:27,079 --> 01:52:31,439
va generando Eclipse. Esto no me lo envíes porque esto no es elegible para mí, podría ejecutarlo,

1329
01:52:31,600 --> 01:52:36,140
pero prefiero ver vuestro código por si me parece que hay alguna cosa que os vaya a comentar. Donde

1330
01:52:36,140 --> 01:52:45,470
está el código fuente, el que se puede ver es en source, en src. Y aquí tienen los ficheros .java,

1331
01:52:45,569 --> 01:52:46,470
donde está tu código.

1332
01:52:47,229 --> 01:52:48,909
Entonces, como en este primer ejercicio

1333
01:52:48,909 --> 01:52:51,170
solamente habrás trabajado en un fichero .java,

1334
01:52:51,310 --> 01:52:53,050
pues me pasas este ficherito y es suficiente.

1335
01:52:56,350 --> 01:52:59,010
En este caso tengo dos ficheritos .java,

1336
01:53:00,130 --> 01:53:01,970
pues porque el proyecto la este2

1337
01:53:01,970 --> 01:53:03,310
de cuando hemos ido haciendo pruebas,

1338
01:53:03,449 --> 01:53:05,430
pues tiene dos ficheros creados.

1339
01:53:06,069 --> 01:53:08,409
Hoy hemos estado trabajando todo el rato en hola2,

1340
01:53:08,409 --> 01:53:09,390
este no lo hemos usado,

1341
01:53:09,590 --> 01:53:12,050
pero por eso tiene allí dos ficheros java,

1342
01:53:12,170 --> 01:53:16,460
porque el proyecto en sí tiene dos ficheros.

1343
01:53:17,239 --> 01:53:19,020
Entonces me pasas el fichero java y ya está.

1344
01:53:19,020 --> 01:53:21,699
a partir de ese yo lo suba eclipse

1345
01:53:22,140 --> 01:53:29,420
lo veo el código y lanzó un par de ejecuciones y ya pues te comento si me parece alguna cosilla que comentarte y ya está

1346
01:53:32,850 --> 01:53:35,829
bueno pues nada aquí lo dejamos voy a parar la grabación