1
00:00:00,110 --> 00:00:12,630
Y nada, ya estamos grabando. Y nada, preguntaros si tenéis alguna duda antes de empezar a hablar de otras cosas. Este tema 1 es como muy introductorio sobre el que hemos estado trabajando.

2
00:00:12,630 --> 00:00:15,789
el tema 2, lo abro luego esta noche

3
00:00:15,789 --> 00:00:18,230
en principio la fecha de apertura es mañana

4
00:00:18,230 --> 00:00:21,210
pero bueno, lo abro luego esta noche o mañana por la mañana

5
00:00:21,210 --> 00:00:24,949
y bueno, todavía ya empezamos

6
00:00:24,949 --> 00:00:28,309
a hacer alguna cosilla más con el lenguaje Java

7
00:00:28,309 --> 00:00:30,829
pero todavía es como muy sencillo

8
00:00:30,829 --> 00:00:33,549
sencillo al menos para los que ya habéis programado con anterioridad

9
00:00:33,549 --> 00:00:37,070
igual los que llegáis desde cero sí que necesitáis

10
00:00:37,070 --> 00:00:39,710
toda esta introducción para empezar a ir aterrizando un poco

11
00:00:39,710 --> 00:00:56,350
¿Tenéis alguna cosilla, alguna pregunta que queráis que comentemos antes de arrancar? ¿A contaros yo cosas? No, vale, pues nada, genial.

12
00:01:03,450 --> 00:01:22,209
Sí, sí, ese es, no sé si con alguna pequeña variación que nos surja según vayamos haciendo las tutorías de este año, pero ese chuletario es el que hemos utilizado por lo menos los dos últimos años y bueno, pues hay un resumen razonable de lo que es la sintaxis.

13
00:01:22,209 --> 00:01:39,569
Como ya os comentaba que el examen en sí lo haremos en papel, pues bueno, que tengáis ese chuletario de referencia. Entonces, contad con él, sí. De hecho, normalmente junto con el examen os lo damos nosotros el chuletario el propio día que tengáis la prueba.

14
00:01:39,569 --> 00:02:00,579
No, no, no, ese chuletario lo tendréis a vuestra disposición para cuidar el hombre. Es aconsejable quizás que lo echéis un ojo para estar familiarizado con la información que tiene, porque igual el día del examen no es el mejor momento para familiarizarse, porque tendréis que estar más centrados en el examen.

15
00:02:00,579 --> 00:02:06,040
Pero esa hoja la tendréis a mano para que podáis vosotros tirar de ella como referencia.

16
00:02:07,359 --> 00:02:13,300
Y si en ese chuletario a la que vayamos hablando de los diferentes contenidos,

17
00:02:13,719 --> 00:02:18,780
bueno, pues os parece que vendría bien añadir alguna cosilla, pues no lo decís.

18
00:02:18,919 --> 00:02:24,180
Y en principio, el chuletario es común para los dos grupos, lo tendría que coordinar con el otro profesor.

19
00:02:24,879 --> 00:02:30,099
Pero bueno, si son cosas para sintaxis y todo esto, que os puedan ayudar en el día del examen,

20
00:02:30,099 --> 00:03:00,159
pues lo podemos añadir en principio sin problema bueno pues no sé exactamente a qué diferencias te

21
00:03:00,159 --> 00:03:05,780
refieres a problemas en tanto en cuanto a la instalación o en tanto en cuanto a que aparecen

22
00:03:05,780 --> 00:03:46,280
diferentes opciones ya pues probablemente entre todas las opciones java te da una cantidad de

23
00:03:46,280 --> 00:03:52,699
alternativas brutales y no solamente para lo que es la gestión de un proyecto java sino para la

24
00:03:52,699 --> 00:03:54,659
gestión de proyectos muy en general, o sea

25
00:03:54,659 --> 00:03:56,039
es un mundo, estos IDEs

26
00:03:56,039 --> 00:03:58,139
están estupendos porque

27
00:03:58,139 --> 00:04:00,560
todas esas opciones al final son

28
00:04:00,560 --> 00:04:02,719
nos facilitan la vida una vez que nosotros

29
00:04:02,719 --> 00:04:04,180
estamos haciendo trabajos

30
00:04:04,180 --> 00:04:06,780
pues que tengan que ver con esas alternativas

31
00:04:06,780 --> 00:04:08,800
pero aquí

32
00:04:08,800 --> 00:04:10,340
vamos a trabajar con

33
00:04:10,340 --> 00:04:11,719
programas Java

34
00:04:11,719 --> 00:04:14,620
razonablemente sencillos y no vamos

35
00:04:14,620 --> 00:04:16,439
a profundizar en todo eso, no sé si

36
00:04:16,439 --> 00:04:18,439
en la asignatura de entornos de desarrollo

37
00:04:18,439 --> 00:04:20,300
que claro va un poco más al hilo de

38
00:04:20,300 --> 00:04:22,459
este tipo de IDEs, que no toda la

39
00:04:22,459 --> 00:04:26,560
asignatura versa, digamos, sobre estar viendo en torno al desarrollo.

40
00:04:26,720 --> 00:04:30,420
Luego hacéis bastantes más cosas en ese módulo. Pero no sé si

41
00:04:30,420 --> 00:04:34,720
ahí sí que hará un poco más recorrido sobre todas las opciones de menú que van apareciendo.

42
00:04:35,480 --> 00:04:38,579
En principio, de nuestra asignatura se queda un poco fuera del

43
00:04:38,579 --> 00:04:42,459
ámbito de lo que vamos a trabajar. Esto no quiere decir que si

44
00:04:42,459 --> 00:04:46,439
alguna a ti tú crees, pues yo creo que esta por lo que

45
00:04:46,439 --> 00:04:50,620
sugiere me va a resultar interesante. No quiere decir que ponla

46
00:04:50,620 --> 00:04:56,120
en los foros y bueno pues entre todos y yo mismo si quieres la investigó un poquillo y llegamos a

47
00:04:56,120 --> 00:05:01,360
conclusiones pero lo que es en sí necesario para la asignatura el millón de opciones que nos

48
00:05:01,360 --> 00:05:40,290
proporciona eclipse o net bienes no va a ser necesario que las conozcáis ya sí sí sí mira

49
00:05:40,290 --> 00:05:44,790
bueno te cuento te cuento un poco para poner en contexto quizás la pregunta y a ver si termino

50
00:05:44,790 --> 00:05:51,329
respondiendo te en los programas que nosotros vamos a hacer en principio durante la asignatura

51
00:05:51,329 --> 00:05:56,610
aunque bueno en la base para luego hacer grandes proyectos no pues son sencillos van a tener poca

52
00:05:56,610 --> 00:06:03,410
cosa el de esta forma veremos lo que son paquetes en algún momento habla en alguno de los temas no

53
00:06:03,410 --> 00:06:09,410
recuerdo exactamente en cuál de lo que son los paquetes digamos en java cuando estamos creando

54
00:06:09,410 --> 00:06:14,970
un proyecto aquí con eclipse estas nuevas versiones ofrecen directamente al crear un

55
00:06:14,970 --> 00:06:22,069
proyecto, lo voy a ir haciendo por aquí, después borramos este proyecto, vamos a llamarlo a A, una cosa

56
00:06:22,069 --> 00:06:29,009
sencillota, la propia creación del proyecto genera aquí en la carpeta source este ficherito, este

57
00:06:29,009 --> 00:06:36,490
ficherito tiene como objetivo digamos estructurar diferentes clases que puedan estar distribuidas

58
00:06:36,490 --> 00:06:41,930
en diferentes paquetes, ahora te explico un poco la idea de los paquetes, digamos que es como un

59
00:06:41,930 --> 00:06:46,050
enlace ahí para que todo el código Java sea capaz de localizar

60
00:06:46,050 --> 00:06:51,269
unas clases a otras. Entonces aquí con cierta sintaxis se puede

61
00:06:51,269 --> 00:06:55,810
meter ese tipo de información. ¿Qué vengo yo haciendo en esta

62
00:06:55,810 --> 00:06:58,329
asignatura todo este tiempo? Pues en cuanto creo un proyecto

63
00:06:58,329 --> 00:07:02,689
elimino este. El hecho de tener esto, cuando tú quieres crear

64
00:07:02,689 --> 00:07:06,230
una nueva clase, te obliga a que organizes las cosas sí o sí

65
00:07:06,230 --> 00:07:08,930
por paquetes. Entonces por eso te estaba exigiendo que tuvieras

66
00:07:08,930 --> 00:07:12,050
que introdujese es un paquete y el hecho de crear un paquete

67
00:07:12,050 --> 00:07:14,050
luego ya te dejaba seguir con el proyecto adelante.

68
00:07:15,189 --> 00:07:17,550
Para evitar esto, nuestros pequeños proyectos de ahora,

69
00:07:18,149 --> 00:07:20,149
yo lo que hago directamente es eliminar este ficherito.

70
00:07:20,389 --> 00:07:23,589
Y eliminando este ficherito nos libramos de esta situación.

71
00:07:24,250 --> 00:07:26,829
Que para grandes proyectos puede ser interesante, cuidado,

72
00:07:26,829 --> 00:07:30,310
pero que ahora quizás nos van a complicar más la vida

73
00:07:30,310 --> 00:07:32,269
que nos la van a favorecer.

74
00:07:32,350 --> 00:07:33,949
¿Qué son los paquetes en Java?

75
00:07:34,189 --> 00:07:37,370
No sé si de hecho tenía apuntado a hablaros un poco de ello aquí

76
00:07:37,370 --> 00:07:40,310
Y si no, bueno, os lo cuento ya que va al hilo.

77
00:07:40,910 --> 00:07:43,250
Pues vamos a ponernos en la situación de un gran proyecto.

78
00:07:43,370 --> 00:07:50,490
Imagínate que la banca te coge y te dice, pues mira, quiero que me hagas un proyecto, pero integral de todo.

79
00:07:51,230 --> 00:07:58,110
No un proyecto que haga una función main y me saque por pantalla tres cosillas, sino algo que me resulte ya funcional.

80
00:07:59,129 --> 00:08:05,269
Y la banca, por ejemplo, igual si alguno soy de banca me tomo la pata,

81
00:08:05,269 --> 00:08:14,250
Pero bueno, vamos a suponer que tiene varias líneas de negocio, una de créditos, otra de cuentas corrientes y otra para trabajar en bolsa, ¿no?

82
00:08:14,689 --> 00:08:23,509
Y entonces, si tú coges y te pones a hacer código para la aplicación en su conjunto, pues resultará que para dar servicio a cada uno de estos campos,

83
00:08:23,509 --> 00:08:28,629
de estas líneas de trabajo, necesitas hacer 10 ficheritos con extensión .java.

84
00:08:28,629 --> 00:08:47,710
Y claro, como si necesitas 10 ficheros con extensión .java para las tres funcionalidades, pues terminar juntando 30 y esas 30 estarían agrupadas en un único directorio, en lo que sería un único paquete que por defecto un proyecto, si quitamos el módulo este, es el paquete por defecto.

85
00:08:47,710 --> 00:09:05,389
Entonces, ¿qué es lo que podemos hacer? Pues podemos decir, mira, vamos a organizar el código de Java por bloques. Entonces, para lo que decíamos de bolsa, pues hacemos un paquete que vendría a ser en la estructura del sistema de archivos, un directorio y ahí organizo todo el código que tiene que ver con bolsa.

86
00:09:05,389 --> 00:09:31,450
Entonces ahí creo los 10 ficheritos .java con el código correspondiente que tiene que ver con bolsa. Creo otro directorio, es decir, un mecanismo de organización del código. Creo otro paquete que finalmente en la estructura del sistema de archivos va a ser un directorio diferente, donde creo la parte de préstamos y otro paquete para la otra parte que habíamos comentado.

87
00:09:31,450 --> 00:09:34,850
con lo cual, bueno, pues visualmente lo tengo mejor organizado

88
00:09:34,850 --> 00:09:35,909
que luego tengo un problema

89
00:09:35,909 --> 00:09:40,450
en el código que tiene que ver con las acciones a bolsa

90
00:09:40,450 --> 00:09:43,169
porque me detectan un error, pues ya por lo menos sé

91
00:09:43,169 --> 00:09:46,309
que me tengo que ir al paquete de bolsa y no en toda la vorágine

92
00:09:46,309 --> 00:09:48,549
de 30 ficheros con todo mezclado

93
00:09:48,549 --> 00:09:52,149
que si en lugar de 3 funcionalidades hablamos de 50, pues al igual

94
00:09:52,149 --> 00:09:55,129
tenemos 150 ficheros, pues localizar

95
00:09:55,129 --> 00:09:58,289
en esos 150 es más difícil que localizar justo en el

96
00:09:58,289 --> 00:10:01,149
paquetito, precisamente vamos al término

97
00:10:01,149 --> 00:10:04,210
de paquete donde tenemos organizado todo el código que tiene

98
00:10:04,210 --> 00:10:07,190
que ver con bolsa. Es decir, una forma

99
00:10:07,190 --> 00:10:10,350
de ser ordenado, digamos, en el código. Entonces, esa es la idea

100
00:10:10,350 --> 00:10:13,409
de los paquetes. Y luego, además, una de las características

101
00:10:13,409 --> 00:10:16,250
que tiene la programación orientada a objetos es

102
00:10:16,250 --> 00:10:18,690
que es tener

103
00:10:18,690 --> 00:10:22,370
la intención de reutilizar el código. Si yo

104
00:10:22,370 --> 00:10:25,230
un primer banco me sugiere que

105
00:10:25,230 --> 00:10:28,370
le haga un desarrollo, pues igual tengo que hacer

106
00:10:28,370 --> 00:10:33,230
todo el código es de cero pero a lo mejor luego entrando en esa línea de negocio pues otros 10

107
00:10:33,230 --> 00:10:38,629
bancos me lo piden también y resulta que la forma de trabajar para en bolsa de todos ellos a lo

108
00:10:38,629 --> 00:10:43,809
mejor termina siendo muy parecida pues pero otras otras a lo mejor otras líneas de negocio no tanto

109
00:10:43,809 --> 00:10:49,289
no pues entonces a lo mejor puedo ir al primero de los proyectos y directamente coger el paquete

110
00:10:49,289 --> 00:10:56,450
de donde he desarrollado el código relacionado con bolsa y coger y utilizarlo directamente

111
00:10:56,450 --> 00:11:00,110
trasladando ese paquete de forma completa al otro proyecto

112
00:11:00,110 --> 00:11:02,210
y haciendo quizás algún pequeño retoque.

113
00:11:02,549 --> 00:11:03,289
¿Estas ventajas tiene?

114
00:11:03,990 --> 00:11:06,629
Al final, en los proyectos de ingeniería,

115
00:11:06,750 --> 00:11:08,929
de ingeniería y ingeniería software también,

116
00:11:09,590 --> 00:11:13,250
lo que sueles facturar son horas que facturas

117
00:11:13,250 --> 00:11:15,769
y horas que tienes que pagar a quien está haciendo el desarrollo.

118
00:11:15,769 --> 00:11:19,490
Si ya lo tienes hecho el código de otra ocasión,

119
00:11:20,210 --> 00:11:22,970
a lo mejor con un poco de suerte hasta puedes facturar como nuevo

120
00:11:22,970 --> 00:11:26,250
y tener los beneficios como reutilizado.

121
00:11:26,450 --> 00:11:46,990
Y no solamente es el desarrollo, sino porque nosotros ahora justo aquí con Eclipse y en las clases vamos a hacer programas y parece que aquello ya se terminó, pero el hecho de hacer el desarrollo del código quizás no sea la que más tiempo te dedica en ocasiones y seguro que no es la que más dolor de cabeza te da.

122
00:11:46,990 --> 00:12:00,570
Porque luego, bueno, pues hay que probar todo aquello, hay que tener certeza si vas a dar un producto ya incluyente que va a ser final que prácticamente nunca falla, ¿no? Por no quemar la imagen de tu empresa dando algo desarrollado y poco probado.

123
00:12:00,990 --> 00:12:20,059
Entonces, paquetes que ya tienes muy trabajados, pues están ya muy probados y si los reutilizas, aparte de no tener que hacer el código, ya muy bien probados, pues eso ganas. Entonces, es un poco el espíritu de distribuir los proyectos en paquetes. ¿Sí? Más o menos.

124
00:12:21,220 --> 00:12:29,779
Para nuestros proyectos, ahora en el momento, mira, cuando, si quitas el módulo, el ficherito ese, como lo he borrado yo aquí de este proyecto, te libras de ello.

125
00:12:30,220 --> 00:12:38,600
Y luego, si quieres de todas formas organizar el código en paquetes, pues por aquí puedes crear nuevos paquetes y luego el código ir distribuyéndolo por ahí.

126
00:12:38,600 --> 00:12:43,279
más o menos para hacer un enlace del estilo de lo que decía

127
00:12:43,279 --> 00:12:47,320
el módulo info este de todo el proyecto, luego en la cabecera

128
00:12:47,320 --> 00:12:51,259
se puede poner aquí código donde identifiques cada clase

129
00:12:51,259 --> 00:12:54,820
en qué paquete está, que es con la etiqueta package

130
00:12:54,820 --> 00:12:59,179
pero bueno, ya esto lo vamos viendo

131
00:12:59,179 --> 00:13:06,419
pero un poco el espíritu de los paquetes es este, y bueno pues

132
00:13:06,419 --> 00:13:10,320
ya ves, esto tiene un montón de opciones, yo seguro

133
00:13:10,320 --> 00:13:30,519
Seguro que, al menos en un tema que habla de refactorización en entornos de desarrollo, hablaría de esta, de refactor y source, que viene a ser que el propio IDE te reconstruya o te dé ciertas características al código sin que cambie la funcionalidad, cambiando nombres de variables, cosas de este estilo.

134
00:13:30,519 --> 00:13:32,980
trabajéis más en entornos

135
00:13:32,980 --> 00:13:34,799
con ello. Y luego, bueno, pues por aquí

136
00:13:34,799 --> 00:13:36,679
ya veis, tiene un millón de opciones

137
00:13:36,679 --> 00:13:38,700
que seguro que todas son

138
00:13:38,700 --> 00:13:40,899
súper útiles y te aportan cosas

139
00:13:40,899 --> 00:13:43,059
y que yo no he utilizado nunca porque son tantas.

140
00:13:50,179 --> 00:13:51,179
¿Alguna otra cosita por ahí?

141
00:14:21,000 --> 00:14:21,200
Sí.

142
00:14:28,529 --> 00:14:33,149
Sí. El bytecode.

143
00:14:41,610 --> 00:14:42,190
No, no,

144
00:14:42,230 --> 00:14:43,669
en realidad va contra el punto class.

145
00:14:46,490 --> 00:14:47,610
Yo creo que sí.

146
00:14:48,110 --> 00:14:49,950
El intérprete, a veces

147
00:14:49,950 --> 00:14:51,649
nos intentan ayudar tanto los

148
00:14:51,750 --> 00:14:54,669
cuando hacen los programas, que probablemente

149
00:14:54,669 --> 00:14:56,570
el intérprete hasta sea capaz

150
00:14:56,570 --> 00:14:58,809
de generar, el intérprete

151
00:14:58,809 --> 00:15:00,490
te hablo del programa Java, no del Java

152
00:15:00,490 --> 00:15:02,889
que es el compilador, probablemente

153
00:15:02,889 --> 00:15:04,669
hasta si lo enfrentas al

154
00:15:04,669 --> 00:15:06,610
punto Java, a lo mejor hasta te lo ejecuta

155
00:15:06,610 --> 00:15:08,590
porque se va al código, hace el proceso

156
00:15:08,590 --> 00:15:09,929
ese que haría el compilador

157
00:15:09,929 --> 00:15:10,750
y

158
00:15:10,750 --> 00:15:18,580
si

159
00:15:18,580 --> 00:15:26,399
en realidad

160
00:15:26,399 --> 00:15:26,820
si tú

161
00:15:26,820 --> 00:15:50,379
Mira, te cuento, si tú utilizas el intérprete, que el intérprete es Java, el compilador es Javad, el intérprete Java. Si tú utilizas el intérprete, a ver, si saco aquí un editor texto, si tú, para compilar, el compilador es Javad, y el intérprete es Java.

162
00:15:50,379 --> 00:15:56,980
si tú utilizas el intérprete imagínate que ya teníamos aquí una clase que era hola mundo punto

163
00:15:56,980 --> 00:16:06,990
java entonces sobre esta clase es ahora que tú pasas el compilador y ésta te da esta es la que

164
00:16:06,990 --> 00:16:15,610
te da el punto clase sobre el intérprete lo que le pasas es hola mundo en principio sin extensión

165
00:16:15,610 --> 00:16:21,190
es como como en principio funciona pero si lo pasas sin extensión en el que ejecutas el punto

166
00:16:21,190 --> 00:16:27,490
class y puede ser que si le pones me parece que alguna vez que he hecho yo alguna prueba si le

167
00:16:27,490 --> 00:16:34,269
pones el donde está el código fuente pues el intérprete intenta intentar trabajar tanto por

168
00:16:34,269 --> 00:16:40,210
nosotros que es como que hace las dos fases de una entonces es como que lo intenté compilar

169
00:16:40,210 --> 00:16:47,289
e interpretar vale igual no hasta nos funciona pero lo suyo suyo lo purista es compiló con jabba

170
00:16:47,289 --> 00:16:54,190
obtengo el punto clas y ejecutó con el intérprete el hola mundo sin el punto clas y en principio si

171
00:16:54,190 --> 00:17:09,049
al ponerlo así sobre el que tira es sobre este no sobre este y se lo traga puede ser si yo creo

172
00:17:09,049 --> 00:17:17,009
yo creo que no creo que pasa como tú dices pero cuando tú ejecutas así lo que te ejecuta realmente

173
00:17:17,009 --> 00:17:28,819
es este a ver miramos vamos a hacer una pequeña prueba mira tenemos aquí este ejecutable el hola

174
00:17:28,819 --> 00:17:38,349
2 este es el que cree cuando se dice la copia está el otro día entonces os dije que os comentaba la

175
00:17:38,349 --> 00:17:47,930
semana pasada que tiene un directorio de trabajo eclipse que es este entonces vamos a ir ahí no

176
00:17:47,930 --> 00:17:54,299
vamos a ir a ese proyecto a la hora 2 y mira no vamos a ir aquí al bien que tiene el punto

177
00:17:54,299 --> 00:18:00,460
classo lo veis que si yo pongo aquí java bueno vamos a poner la ruta completa wish java aquí

178
00:18:00,460 --> 00:18:14,420
me chiva la ruta observa que aquí no está el punto java si ponemos esto y ponemos hola hola 2 es cómo

179
00:18:14,420 --> 00:18:22,279
funciona es decir me ha funcionado porque porque ha tirado del fichero punto clas miramos a para

180
00:18:22,279 --> 00:18:30,039
ya salir de dudas total voy a cambiar el nombre a este fichero para que no exista el punto clas

181
00:18:30,039 --> 00:18:40,460
y lo voy a llamar por un momento lo cambió el nombre vale ahora ahora lo recuperó por si

182
00:18:40,460 --> 00:18:46,039
queremos hacer algo con él y entonces si ahora hago una ejecución es hago la ejecución del

183
00:18:46,039 --> 00:18:51,740
intérprete que está en esa ruta de o la 2 pero ya no existe o la 2 punto clas sino que si teclas

184
00:18:51,740 --> 00:18:59,119
punto 2 por dice que no puede encontrar el fichero ves como para que como ya no existe el punto clas

185
00:18:59,119 --> 00:19:04,140
el intérprete en realidad está intentando tirar del punto clas y de hecho el mensaje que nos da

186
00:19:04,140 --> 00:19:11,460
errores no puede encontrar el fichero punto clas del ejecutable o lados si volvemos a recuperarlo

187
00:19:11,460 --> 00:19:22,630
pues en principio volvería a ir es decir que la idea funciona el teclado hay un poco la idea es

188
00:19:22,630 --> 00:19:27,490
que contra quien tira el intérprete es contra el punto class y si lo ejecutamos contra el punto

189
00:19:27,490 --> 00:19:33,309
java y funciona pues bueno es porque pues porque nos quiere ayudar el intérprete más de lo normal

190
00:19:33,309 --> 00:19:40,700
pero no es en realidad para lo que está para lo que está diseñado mira ves ahora volvemos a

191
00:19:40,700 --> 00:19:49,099
ejecutar y ya nos vuelve a funcionar porque porque tenemos volvemos a tener el punto class no sé si

192
00:19:49,099 --> 00:19:55,180
has visto el bueno la tutoría del otro día y el vídeo hacíamos el proyecto este justo desde aquí

193
00:19:55,180 --> 00:19:59,339
desde el terminal con un editor nano, compilábamos y terminábamos

194
00:19:59,339 --> 00:20:03,420
lanzando el intérprete. Si quieres un poco aclarar

195
00:20:03,420 --> 00:20:07,299
cómo lo hicimos, en el vídeo este que os tengo colgado en el aula virtual, justo estuvimos hablando

196
00:20:07,299 --> 00:20:11,299
un poco de todo esto. Que es para centrar conceptos, porque ya no vamos

197
00:20:11,299 --> 00:20:15,140
a volver a hacer proyectos a través de esos medios, sino que

198
00:20:15,140 --> 00:20:24,000
utilizaremos el IDE. ¿Alguna cosilla más por ahí?

199
00:20:46,910 --> 00:21:02,619
Te salen pequeñas, ¿no? No sé si será porque...

200
00:21:04,000 --> 00:21:05,400
Te sale de partida pequeño, ¿no?

201
00:21:08,059 --> 00:21:09,160
Es que...

202
00:21:09,160 --> 00:21:10,660
A ver, a ver, ¿dónde es?

203
00:21:46,829 --> 00:21:47,349
Yo...

204
00:21:47,349 --> 00:21:48,009
Sí.

205
00:21:48,990 --> 00:21:51,309
Sí, bueno, y te iba a comentar yo justo eso también.

206
00:21:51,750 --> 00:21:53,009
Están Virtual Boss,

207
00:21:53,369 --> 00:21:56,470
que es una cosa independiente en sí de la máquina.

208
00:21:57,069 --> 00:21:59,109
Tiene una cosa que se llama las Guest Additions,

209
00:21:59,109 --> 00:22:02,849
que es, bueno, pues cosas adicionales a los invitados,

210
00:22:02,910 --> 00:22:04,049
se podría traducir, pero bueno,

211
00:22:04,630 --> 00:22:09,000
que lo que te hace es que...

212
00:22:09,000 --> 00:22:09,259
¿Sí?

213
00:22:09,259 --> 00:22:16,930
sí que lo pusiste

214
00:22:16,930 --> 00:22:17,430
entonces

215
00:22:17,430 --> 00:22:20,099
ya

216
00:22:20,099 --> 00:22:21,160
es que

217
00:22:21,160 --> 00:22:21,819
es que justo

218
00:22:21,819 --> 00:22:25,009
justo con

219
00:22:25,009 --> 00:22:25,410
las

220
00:22:25,410 --> 00:22:26,190
las GES Addition

221
00:22:26,190 --> 00:22:26,990
suelen tener que ver

222
00:22:26,990 --> 00:22:27,430
con eso

223
00:22:27,430 --> 00:22:28,410
entre otras cosas

224
00:22:28,410 --> 00:22:29,130
pero

225
00:22:29,130 --> 00:22:29,569
pero

226
00:22:29,569 --> 00:22:31,210
cuando no tienes instaladas

227
00:22:31,210 --> 00:22:31,990
las GES Addition

228
00:22:31,990 --> 00:22:33,710
implica que

229
00:22:33,710 --> 00:22:34,650
te salen pequeño

230
00:22:34,650 --> 00:22:35,789
y luego cuando metes

231
00:22:35,789 --> 00:22:36,410
las GES Addition

232
00:22:36,410 --> 00:22:37,210
entre otras cosas

233
00:22:37,210 --> 00:22:37,869
lo que hace es

234
00:22:37,869 --> 00:22:38,809
digamos adaptar

235
00:22:38,809 --> 00:22:39,490
al tamaño

236
00:22:39,490 --> 00:22:40,269
de tu pantalla

237
00:22:40,269 --> 00:22:41,369
y te lo vuelve en grande

238
00:22:41,369 --> 00:22:43,670
teóricamente

239
00:22:43,670 --> 00:22:44,009
eh

240
00:22:44,009 --> 00:22:44,990
sí

241
00:22:44,990 --> 00:22:45,509
las

242
00:22:45,509 --> 00:22:47,069
las

243
00:22:47,349 --> 00:22:51,619
Ya, claro

244
00:22:51,619 --> 00:22:56,079
Pues no sé decirte

245
00:22:56,079 --> 00:22:58,700
¿No habrás cambiado de versión

246
00:22:58,700 --> 00:23:00,400
De VirtualBox respecto al año pasado

247
00:23:00,400 --> 00:23:02,079
Y se te ha quedado desactualizada

248
00:23:02,079 --> 00:23:02,819
La gestión?

249
00:23:14,700 --> 00:23:16,779
Y ha sido a posteriori

250
00:23:16,779 --> 00:23:38,839
Sí

251
00:23:38,839 --> 00:23:40,599
Sí, nada

252
00:23:40,599 --> 00:23:42,920
No se me ocurre nada así de antemano

253
00:23:42,920 --> 00:23:44,279
No sé si quieres abrir

254
00:23:44,279 --> 00:23:46,099
Si te da muchos problemas

255
00:23:46,099 --> 00:23:48,279
Pon algún pantallazo ahí en el foro

256
00:23:48,279 --> 00:23:50,980
A ver si entre todos se nos ocurre echarte una mano.

257
00:23:51,440 --> 00:23:54,819
Así de primeras, se me ocurría lo de la Guest Addition, pero poco más.

258
00:23:55,940 --> 00:23:56,519
A bote pronto.

259
00:24:07,150 --> 00:24:09,470
Bueno, nos vas contando, Silvia.

260
00:24:31,259 --> 00:24:33,579
Pero ¿por qué has puesto Java.class?

261
00:24:33,839 --> 00:24:34,160
¿O cómo?

262
00:24:34,680 --> 00:24:42,500
Sí, si le pones la extensión .class, mira, no sé si me estás viendo a mí ahora.

263
00:24:43,019 --> 00:24:45,700
Si le pones la extensión .class, es verdad que no funciona.

264
00:24:45,700 --> 00:24:50,700
O sea, el intérprete utiliza el .class, pero sin ponerle el .class.

265
00:24:50,880 --> 00:25:43,160
Ya, igual te está pasando esto porque, como has organizado el proyecto con paquetes, entonces igual intenta buscar esas estructuras que te aportaría el ficherito módulo java.modulo, ese que aparecía ahí al principio, que bien configurado te da la estructura de cómo encontrar unos paquetes u otros.

266
00:25:43,160 --> 00:25:51,660
mira hace una cosa si te parece crea un nuevo proyecto elimina el fichero ese genera el hola

267
00:25:51,660 --> 00:26:11,569
mundo y si quieres intenta ejecutarlo desde el terminal yo creo que va a funcionar sí sí pues

268
00:26:11,569 --> 00:26:18,869
mira en él justo ese proceso es uno de los que hicimos te lo digo por bueno pues por darme otras

269
00:26:18,869 --> 00:26:25,869
cosas lo hicimos justo aquí en este vídeo en este que no sé si has podido ver el vídeo que os colgué

270
00:26:25,869 --> 00:26:31,710
de la semana pasada justo estuvimos haciendo eso desde el terminal creando un proyecto no

271
00:26:31,710 --> 00:26:38,009
lo creamos no lo metíamos en ningún paquete y ejecutamos el bueno con el intérprete del punto

272
00:26:38,009 --> 00:26:44,809
class entonces si te parece echar un ojillo y si tienes algún problema si quieres en la próxima

273
00:26:44,809 --> 00:26:51,049
tutoría si ves que aún así no te sale o a través del foro me lo comentas y lo intento echar un

274
00:26:51,049 --> 00:26:55,609
vistazo por hacer algo lo digo por hacer algo un poco diferente a lo que hicimos ya la semana

275
00:26:55,609 --> 00:27:05,259
pasada sabes si te parece vale de tal forma no te quedes con la duda ya te digo si vuelves a

276
00:27:05,259 --> 00:27:11,660
intentarlo viendo el vídeo y no te funciona o bien por foros o la semana que viene lo echamos un ojo

277
00:27:11,660 --> 00:27:22,380
que para eso son estas tutorías en principio para aclarar dudas que podéis tener bueno alguna

278
00:27:22,380 --> 00:27:34,259
cosilla más pues hoy yo creo que hoy mismo os abro os abro el tema 2 y como en el tema 1 ya

279
00:27:34,259 --> 00:27:39,960
lo habíamos repasado y no tiene grandes cosas que hacer pues lo vamos a hablar sobre contenidos que

280
00:27:39,960 --> 00:27:46,619
tenéis que se os abren aquí en este tema entre lo que comentemos hoy y bueno durante la semana

281
00:27:46,619 --> 00:27:50,579
cosas que podéis ir viendo incluso la tutoría de la semana que viene si es necesario pues

282
00:27:50,579 --> 00:27:55,960
terminamos de finiquitarlo porque este tema tiene solo una semana de vida y luego ya la siguiente

283
00:27:55,960 --> 00:28:05,009
pues nos vamos a ir al tema 3. Vamos a ir directamente ya aquí a Eclipse y vamos a empezar

284
00:28:05,009 --> 00:28:11,829
a hablar de diferentes conceptos de los que van a aparecer por ahí. El lenguaje, cuando trabajamos

285
00:28:11,829 --> 00:28:18,210
con un lenguaje de programación, pues hay un montón de... ese lenguaje tiene una semántica,

286
00:28:18,210 --> 00:28:28,670
que es como se entienden las cosas, una sintaxis, típico como en lengua castellana tenemos palabras que tienen su sujeto, su predicado,

287
00:28:28,769 --> 00:28:35,890
pues aquí es necesario para hablar en castellano, pues seguir una determinada estructura, pues los lenguajes de programación tienen su sintaxis.

288
00:28:37,250 --> 00:28:45,599
¿Quién se encarga de comprobar esa sintaxis? Pues el compilador.

289
00:28:45,599 --> 00:28:50,779
cuando nosotros le pasamos a un código java con código fuente

290
00:28:50,779 --> 00:28:53,559
el compilador lo que verifica es todas estas cosas

291
00:28:53,559 --> 00:28:58,740
el compilador en sí no sabe si tu propósito es

292
00:28:58,740 --> 00:29:02,759
en tu algoritmo es una suma y tú le pones

293
00:29:02,759 --> 00:29:06,839
el signo de resta, pues el compilador no sabe interpretar que tú lo que querías

294
00:29:06,839 --> 00:29:10,660
era sumar, pero sí sabe que si en lugar de

295
00:29:10,660 --> 00:29:14,619
si tú tienes dos variables y pones a más b, pues le gusta porque

296
00:29:14,619 --> 00:29:32,859
el más lo entiende como un símbolo que hace sumas, el a menos b lo entiende también y si pones a, z, b, pues esto no lo sé, porque con una variable que pueda haber por aquí y otra aquí, no hay nada que me realice una operación entre dos variables poniendo la etiqueta de una z.

297
00:29:32,859 --> 00:29:37,480
Entonces, este no le gustaría y estas, pues en principio sí le gustaría.

298
00:29:39,200 --> 00:29:45,980
En Java, dentro de la sintaxis que tenemos, todas las instrucciones, que no necesariamente tienen por qué estar en una línea,

299
00:29:46,140 --> 00:29:49,019
pero lo que sí que sucede es que todas las instrucciones acaban con un punto y coma.

300
00:29:49,160 --> 00:29:51,259
Pues bueno, eso forma parte de la sintaxis de Java.

301
00:29:52,180 --> 00:29:58,779
¿No vamos a otro lenguaje? Pues podrá tener una sintaxis un poquito diferente y obligarnos a seguir unas determinadas pautas que hay igual Java, ¿no?

302
00:29:58,779 --> 00:30:12,440
En cada uno de los lenguajes tendremos que aprender esa síntesis, igual que si queremos hablar en castellano, en vasco, en catalán o en gallego. Cada uno tiene sus reglas y hay que trabajar sobre ellas.

303
00:30:12,440 --> 00:30:29,140
Entonces tendremos una serie de palabras que son reservadas en cada uno de los lenguajes y que terminarán utilizándolas o tokens que terminarán utilizándolas para validar que sean correctas las estructuras.

304
00:30:29,140 --> 00:30:39,140
Entonces fijaros por aquí, public, static, void, todas estas que nos aparecen por aquí en rosita, son palabras de esas reservadas que tenemos en Java.

305
00:30:41,440 --> 00:30:50,839
String, esta no nos aparece en rosita, pero también es una palabra reservada que necesariamente tenemos que utilizar para darle ciertas funcionalidades

306
00:30:50,839 --> 00:30:59,279
y que no podemos definir, por ejemplo, nosotros variables que tengan estos nombres porque confundirían estas palabras claves con aquellas variables que queremos ir utilizando en nuestro programa.

307
00:31:00,220 --> 00:31:07,259
Hola2, en cambio, no es una palabra que esté reservada por Java, con lo cual lo podemos utilizar nosotros para dar nombre a una clase.

308
00:31:07,480 --> 00:31:14,059
Pues ahí tenemos la clase Hola2, que no utiliza una de las etiquetas propias de Java y que tiene reservadas.

309
00:31:14,059 --> 00:31:23,960
Bueno, entonces, ¿con qué tipo de cosas trabajamos nosotros en Java?

310
00:31:24,119 --> 00:31:29,599
Pues una de las cosas con las que trabajamos, bueno, en cualquier lenguaje de programación, una de las cosas que necesitamos son variables.

311
00:31:29,599 --> 00:31:42,829
¿Las variables para qué nos sirven? Pues nos sirven para ir teniendo información del desarrollo de nuestro programa mientras está en ejecución, cosas que no queremos perder.

312
00:31:43,289 --> 00:31:54,170
Mira, si queremos hacer un programa que sume números, pues cogemos y podemos definir con una etiqueta de las definidas en Java, int.

313
00:31:54,170 --> 00:31:59,769
esta está asociada a un tipo de datos entero, es decir, un valor numérico entero

314
00:31:59,769 --> 00:32:03,390
que se almacenará en la memoria RAM con 32 bits

315
00:32:03,390 --> 00:32:10,170
y lo siguiente que vamos a identificar va a ser una variable de tipo entero

316
00:32:10,170 --> 00:32:15,960
entonces ponemos int a, entonces ponemos aquí un punto y coma

317
00:32:15,960 --> 00:32:18,980
pues a sería una variable de tipo entero

318
00:32:18,980 --> 00:32:24,759
y en esta a podríamos guardar números para ir utilizando luego en el programa

319
00:32:24,759 --> 00:32:35,609
entre un determinado rango que es el que acepta guardar información de tipo sin decimales, números sin decimales en 32 bits.

320
00:32:37,730 --> 00:32:42,650
Aquí podríamos coger y decir, pues mira, que directamente va teniendo ya un valor, un 7 de inicio.

321
00:32:42,650 --> 00:32:48,069
Lo que hacemos es aquí, en una variable que es de tipo entero, guardar un número.

322
00:32:49,529 --> 00:32:53,670
Igual que tenemos los tipos enteros, pues podemos tener cadenas de caracteres.

323
00:32:53,769 --> 00:32:58,269
Las cadenas de caracteres en Java, estas son cosas que tenemos que aprender de cada uno de los lenguajes,

324
00:32:58,730 --> 00:33:02,170
No tanto el algoritmo de pensar cómo vamos a resolver un problema,

325
00:33:02,289 --> 00:33:05,730
porque ese algoritmo sí que puede ser común a muchos lenguajes.

326
00:33:06,930 --> 00:33:10,730
Y lo podríamos escribir incluso antes de programar en un lenguaje o en otro con pseudocódigo.

327
00:33:11,789 --> 00:33:17,390
Pero sí que cada uno de los lenguajes, luego cuando vamos a llegar a la concreción de escribirlo en él,

328
00:33:17,390 --> 00:33:26,089
pues tendrá unas, a lo mejor otro lenguaje utilizará entero para guardar un valor numérico que no tenga decimales.

329
00:33:26,089 --> 00:33:57,119
Pues Java utiliza int. ¿Qué utiliza Java para guardar cadenas de caracteres? Pues string. Entonces lo que definamos como string es nombre. Los string los metemos en Java entre comillados. El texto que queremos que vaya en esta cadena de caracteres que en el contexto de este método lo hemos llamado nombre y es de tipo cadena de caracteres porque lo hemos definido como un string, pues lo ponemos entre comillas aquí.

330
00:33:57,119 --> 00:34:18,579
Entonces, por ejemplo, ponemos aquí José, con lo cual la variable José en este momento tiene un valor, la variable ese nombre en este momento tiene un valor que es José y el tipo de información que ha sido capaz de guardar al definirla como un string es una cadena caracteres, que la sintaxis para ponerlo en Java es entrecomillado.

331
00:34:18,579 --> 00:34:46,929
Pues igual que tenemos estos dos tipos, pues tenemos otro tipo para guardar números enteros que es el tipo long, pues también guarda valores enteros, pero este cuando hace una reserva en la memoria RAM, y ahora os hablo de la memoria RAM, para albergar el valor que tiene B, reserva más bits, entonces como reserva más espacio en memoria, el rango de valores puede ser mayor.

332
00:34:46,929 --> 00:35:03,090
Si quisiéramos guardar, por ejemplo, no sé si en el tema habla de la población mundial o cuando habla un poco del ejemplo de esto, el número de habitantes que tenemos en el mundo, pues a lo mejor en 32 bits no dan como para guardar un número de la población mundial.

333
00:35:03,090 --> 00:35:08,929
O sí, bueno, siempre habrá un número más grande que ya no entrará dentro del rango de los que aceptan los enteros.

334
00:35:09,510 --> 00:35:15,429
Entonces, en ese caso, lo que haríamos sería definir otra variable que también es de tipo entero, sin decimales, long,

335
00:35:16,130 --> 00:35:20,989
y entonces este, como ocupa más espacio, reserva más espacio de memoria para guardar el valor,

336
00:35:21,170 --> 00:35:23,510
pues su rango de valores que puede guardar es mayor.

337
00:35:26,750 --> 00:35:32,090
En cuanto a los enteros, tenemos estos, luego tenemos otro tipo, que es el tipo byte, que también guarda enteros.

338
00:35:32,090 --> 00:36:23,269
Y en cuanto a los valores que almacenan con decimales numéricos, pues tenemos el float, tenemos el double, estos dos nos permiten guardar valores con decimales, punto, como carácter, a ver qué es lo que está pasando aquí, bueno, con float me decía que hiciera un casting ahí, float, no sé muy bien por qué, bueno, luego os hablo de los casting también.

339
00:36:24,170 --> 00:36:39,829
Pues estos admiten números decimales. Los tipos de datos que tenemos predefinidos en Java, pues para enteros estos tres, para números incluyendo el float, que me está dando ahora un mensajillo de error, luego lo investigamos.

340
00:36:39,829 --> 00:36:45,670
cadena de caracteres, tenemos los string, hay algunos más, pero estos son los más típicos.

341
00:36:46,349 --> 00:36:51,789
Para un solo carácter, es decir, un valor alfanumérico, pero uno solo,

342
00:36:52,369 --> 00:36:59,469
pues podemos definir un char, los char, si las cadenas de caracteres se guardan entre dos comillas,

343
00:36:59,750 --> 00:37:03,050
pues los char se guardan con una comilla simple.

344
00:37:03,050 --> 00:37:21,780
Y luego tenemos también los Boolean, que son tipos de datos que almacenan dos posibles valores, que son o bien verdadero, true, o bien falso, la otra alternativa. Iremos trabajando mucho sobre ellos.

345
00:37:21,780 --> 00:37:30,199
¿Qué pasa cuando nosotros queremos dar de alta una variable que vamos a ir utilizando en nuestro programa?

346
00:37:31,059 --> 00:37:46,440
Pues esto se traduce en que el intérprete en este caso necesitará para guardar esta información que A, hasta que termine de estar en uso A, si la queremos volver a utilizar por aquí,

347
00:37:46,440 --> 00:37:50,039
que este dato sea capaz de guardarse relacionado

348
00:37:50,039 --> 00:37:52,860
con una variable A en nuestro programa, implicará

349
00:37:52,860 --> 00:37:54,980
que se tendrá que guardar ese valor en algún sitio.

350
00:37:55,599 --> 00:37:58,860
¿Qué tenemos en el ordenador para guardar este tipo de información

351
00:37:58,860 --> 00:38:01,960
de los programas en ejecución?

352
00:38:02,039 --> 00:38:03,179
Pues tenemos la memoria RAM.

353
00:38:04,699 --> 00:38:07,920
Si abrimos el ordenador en la asignatura

354
00:38:07,920 --> 00:38:10,699
de sistemas informáticos, veremos que es un dispositivo

355
00:38:10,699 --> 00:38:14,099
que está penchado junto al procesador y junto al resto

356
00:38:14,099 --> 00:38:18,059
de componentes hardware. El sistema operativo hace una gestión

357
00:38:18,059 --> 00:38:22,000
intermedia entre los programas que necesitan hacer uso de la RAM

358
00:38:22,000 --> 00:38:26,099
y el hardware que está pinchado en nuestro ordenador. El hardware

359
00:38:26,099 --> 00:38:29,760
nos queda muy lejos, entonces nosotros desde el lenguaje, cuando estemos hablando

360
00:38:29,760 --> 00:38:34,360
de nuestros programas, diremos, nuestro intérprete en este momento

361
00:38:34,360 --> 00:38:37,880
está dando de alta una variable de tipo entero

362
00:38:37,880 --> 00:38:41,980
que sabemos que en memoria RAM ocupa 7 bytes y queremos que guarde

363
00:38:41,980 --> 00:38:46,179
un valor de un 7. Por lo que hará el intérprete será decir al sistema operativo

364
00:38:46,179 --> 00:38:52,679
vete a buscar en el sistema operativo, busca en la memoria RAM

365
00:38:52,679 --> 00:38:58,659
espacio de 32 bits al menos, y relacionalo con que tiene que ver

366
00:38:58,659 --> 00:39:01,440
con esta variable A del programa que estoy ejecutando.

367
00:39:01,780 --> 00:39:07,579
Y guarda el valor 7. Esto es lo que hará el sistema operativo

368
00:39:07,579 --> 00:39:11,420
y hará esa reserva. ¿Hasta cuándo tendrá reservado

369
00:39:11,420 --> 00:39:15,500
nuestro programa esa memoria RAM para guardar

370
00:39:15,500 --> 00:39:19,340
información en nuestra variable? Hasta que esta variable se salga de ámbito.

371
00:39:20,219 --> 00:39:23,480
El ámbito es un término que tiene que ver con el momento

372
00:39:23,480 --> 00:39:27,599
en el que está viviendo, tiene vida

373
00:39:27,599 --> 00:39:31,340
nuestra variable en el programa. Y los ámbitos los marcan las llaves.

374
00:39:32,400 --> 00:39:35,760
Entonces, esta variable A está en el ámbito

375
00:39:35,760 --> 00:39:37,639
de este método main

376
00:39:37,639 --> 00:39:41,460
entonces cuando acabe el método main

377
00:39:41,460 --> 00:40:03,889
finalizará la variable a que está definida dentro de este ámbito

378
00:40:03,889 --> 00:40:05,110
si, bueno

379
00:40:05,110 --> 00:40:09,329
el recolector de basura es una herramienta

380
00:40:09,329 --> 00:40:12,289
me preguntaba, lo digo porque en la grabación

381
00:40:12,289 --> 00:40:15,269
vuestro audio no se escucha, me preguntaba

382
00:40:15,269 --> 00:40:18,269
un compañero si hay alguna forma

383
00:40:18,269 --> 00:40:21,150
de saber cuando el recolector de basura va a liberar

384
00:40:21,150 --> 00:40:24,909
la memoria RAM que ha reservado para una determinada variable

385
00:40:24,909 --> 00:40:26,429
en nuestros programas de Java.

386
00:40:27,130 --> 00:40:30,409
El recolector de basura es un programa que corre por ahí detrás,

387
00:40:30,789 --> 00:40:33,289
que nosotros no tenemos que preocupar en principio por él,

388
00:40:33,909 --> 00:40:38,809
y que es el encargado de irse dando cuenta de aquellas variables

389
00:40:38,809 --> 00:40:41,130
que han dejado de utilizarse dentro de nuestro programa

390
00:40:41,130 --> 00:40:46,369
y cuando se da cuenta de esto, avisa al sistema operativo

391
00:40:46,369 --> 00:40:49,130
de que esa variable ya no tiene sentido en nuestro programa

392
00:40:49,130 --> 00:40:55,110
y el sistema operativo libera esa memoria RAM para que pueda ser utilizada por otras variables en nuestro programa

393
00:40:55,110 --> 00:40:59,090
o por otras variables de otros programas diferentes. Ese es el recolector de basura.

394
00:40:59,710 --> 00:41:04,070
El recolector de basura es un proceso que corre de forma independiente a nuestro programa.

395
00:41:04,389 --> 00:41:12,170
Entonces se activa cuando él quiere. No sé exactamente, bueno, cuando él quiere, entiendo que habrá que en sí Java en su estructura

396
00:41:12,170 --> 00:41:16,210
tendrá unos criterios para activar el recolector de basura, pero no es algo que nosotros,

397
00:41:16,210 --> 00:41:18,989
normalmente nuestros programas

398
00:41:18,989 --> 00:41:20,469
hagamos, si que hay

399
00:41:20,469 --> 00:41:22,949
la posibilidad para objetos de clase

400
00:41:22,949 --> 00:41:25,090
que ya os comentaré lo que son los objetos

401
00:41:25,090 --> 00:41:27,070
de clase y como trabajan con la memoria RAM

402
00:41:27,070 --> 00:41:29,289
si que creo recordar

403
00:41:29,289 --> 00:41:31,190
que tiene un método que es el método destroy

404
00:41:31,190 --> 00:41:32,670
en el cual podemos

405
00:41:32,670 --> 00:41:34,909
obligar sin que sea

406
00:41:34,909 --> 00:41:36,849
el recolector de basura de forma

407
00:41:36,849 --> 00:41:38,369
independiente cuando el

408
00:41:38,369 --> 00:41:39,710
le toque

409
00:41:39,710 --> 00:41:42,909
liberar la memoria RAM, obligar a nosotros

410
00:41:42,909 --> 00:41:44,889
a que se libere, pero normalmente a no ser

411
00:41:44,889 --> 00:41:47,710
que tengamos un lenguaje de altísimo

412
00:41:47,710 --> 00:41:50,710
rendimiento, pues nos despreocupamos de liberar

413
00:41:50,710 --> 00:41:53,809
la memoria RAM y ya será el recolector de basura quien se encargue

414
00:41:53,809 --> 00:41:56,150
de hacerlo. Esto es una

415
00:41:56,150 --> 00:41:59,650
ventaja que tiene Java, la existencia del recolector de basura

416
00:41:59,650 --> 00:42:02,690
porque luego hay otros lenguajes como C, que creo

417
00:42:02,690 --> 00:42:05,849
que os hablaba de él el primer día, una pregunta que me planteabais

418
00:42:05,849 --> 00:42:08,929
algunos de vosotros, que no tiene recolector de basura.

419
00:42:09,289 --> 00:42:11,690
Entonces, si tú reservas memoria para

420
00:42:11,690 --> 00:42:14,570
variables y tú por código no la liberas,

421
00:42:14,889 --> 00:42:19,429
lo que vas haciendo es dejar bloqueada esa memoria continuamente en el ordenador.

422
00:42:19,710 --> 00:42:22,769
Y si haces muchísimas reservas de memoria sin liberar nunca,

423
00:42:23,369 --> 00:42:26,809
podrías llegar a comerte todos los recursos de memoria RAM que tiene el ordenador

424
00:42:26,809 --> 00:42:31,130
y dejarte de funcionar no solo tu programa, sino todos los demás que estén ejecutándose en tu ordenador.

425
00:42:31,250 --> 00:42:32,730
¿Por qué? Por falta de memoria RAM.

426
00:42:33,429 --> 00:42:38,949
En este caso con Java, somos afortunados que el recolector de basura lo va a ir haciendo a su aire.

427
00:42:39,510 --> 00:42:42,829
Él va a chequear que hay variables que ya no están usándose. ¿Por qué?

428
00:42:42,829 --> 00:42:55,389
Porque el ámbito donde se estaban ejecutando ha dejado de estar en funcionamiento, entonces ya no son necesarias esas variables y como no lo son, el recolector de basura coordinado con el sistema operativo liberará esa memoria RAM.

429
00:42:55,389 --> 00:42:58,590
y os decía antes

430
00:42:58,590 --> 00:43:00,449
creo que el método

431
00:43:00,449 --> 00:43:02,530
destroy durante el curso

432
00:43:02,530 --> 00:43:04,110
lo veremos en algún momento

433
00:43:04,110 --> 00:43:06,250
puede con independencia

434
00:43:06,250 --> 00:43:08,230
de que el recolector de basura

435
00:43:08,230 --> 00:43:10,309
libere memoria RAM creo que puede dar

436
00:43:10,309 --> 00:43:11,949
la orden de liberar memoria RAM

437
00:43:11,949 --> 00:43:14,110
pero

438
00:43:14,110 --> 00:43:16,250
generalmente no lo hacemos y os decía

439
00:43:16,250 --> 00:43:18,289
a no ser que sea un programa de alto rendimiento

440
00:43:18,289 --> 00:43:20,369
que necesitemos que todos los recursos

441
00:43:20,369 --> 00:43:22,230
estén muy muy disponibles en todo

442
00:43:22,230 --> 00:43:24,190
momento, que pasa que

443
00:43:24,190 --> 00:43:26,530
normalmente si vamos a hacer un programa de este estilo

444
00:43:26,530 --> 00:43:27,829
no solemos trabajar con Java

445
00:43:27,829 --> 00:43:30,690
es un programa que su máximo objetivo

446
00:43:30,690 --> 00:43:32,510
sea sacar el mejor de los

447
00:43:32,510 --> 00:43:34,130
rendimientos y el tiempo real

448
00:43:34,130 --> 00:43:36,469
como podrían ser otros programas

449
00:43:36,469 --> 00:43:38,630
imaginaros yo que sé un programa que está

450
00:43:38,630 --> 00:43:40,489
un día os hablaba de ello también

451
00:43:40,489 --> 00:43:42,289
una central nuclear y

452
00:43:42,289 --> 00:43:44,630
de un sensor tiene que detectar una fuga

453
00:43:44,630 --> 00:43:46,710
y no le vale cada milisegundo

454
00:43:46,710 --> 00:43:48,550
a lo mejor es oro para bloquear

455
00:43:48,550 --> 00:43:49,989
o sellar unas puertas

456
00:43:49,989 --> 00:43:52,409
entonces esos programas a lo mejor

457
00:43:52,409 --> 00:43:53,849
tienen que ser en tiempo real

458
00:43:53,849 --> 00:43:58,230
de cuando pasa ya tiene que estar el aviso dado, pues esos programas

459
00:43:58,230 --> 00:44:01,809
no los haríamos en Java en ningún caso. Utilizarían otros lenguajes más

460
00:44:01,809 --> 00:44:11,300
enfocados a ese tipo de funciones. Continúo con esto.

461
00:44:12,480 --> 00:44:15,340
Me vais interrumpiendo si tenéis consultas que hacerme.

462
00:44:15,920 --> 00:44:19,159
O si me preguntáis alguna cosa y no queda muy clara, pues también

463
00:44:19,159 --> 00:44:22,659
me decís. Cuando trabajamos

464
00:44:22,659 --> 00:44:27,079
con variables en nuestros programas, ya os digo

465
00:44:27,079 --> 00:44:29,880
las variables tienen que guardarse

466
00:44:29,880 --> 00:44:33,079
en memoria RAM. El primero

467
00:44:33,079 --> 00:44:35,760
de los días, os decía, un programa normalmente

468
00:44:35,760 --> 00:44:38,880
y Java en particular es un lenguaje orientado a

469
00:44:38,880 --> 00:44:42,139
utiliza programación orientada a objetos

470
00:44:42,139 --> 00:44:45,159
con lo cual tenemos clases y de esas clases creamos

471
00:44:45,159 --> 00:44:48,340
objetos. Y os hablaba del desarrollo de una clase

472
00:44:48,340 --> 00:44:50,960
donde había profesores y creábamos diferentes clases

473
00:44:50,960 --> 00:44:53,760
y luego interactuaban unas con otras.

474
00:44:53,760 --> 00:44:58,159
estos objetos, vamos a crear en este programa una clase

475
00:44:58,159 --> 00:45:08,699
esto que estoy haciendo ahora es comentar el código

476
00:45:08,699 --> 00:45:13,000
en Java hay dos opciones, puedes comentar el código línea a línea

477
00:45:13,000 --> 00:45:16,559
que es con

478
00:45:16,559 --> 00:45:20,860
las dos barritas estas o bloquer de código multilínea

479
00:45:20,860 --> 00:45:24,860
con la barra y el asterisco y al finalizar asterisco

480
00:45:24,860 --> 00:45:28,760
barra, esto que implica aquel código que pongamos entre

481
00:45:28,760 --> 00:45:33,960
comentarios, bien sea código o bien sea texto. Todo lo que se encuentre el compilador

482
00:45:33,960 --> 00:45:38,219
Javad cuando vaya a compilar nuestro programa, lo que encuentre como comentario, es decir,

483
00:45:38,219 --> 00:45:44,440
a la línea que hayamos antepuesto el barra barra o le hayamos puesto la barra asterisco

484
00:45:44,440 --> 00:45:49,719
con cierre asterisco barra, lo considera como comentarios al código, no código propiamente

485
00:45:49,719 --> 00:45:56,420
dicho y no lo tiene en cuenta en la compilación. Este código no lo voy a borrar ahora de momento

486
00:45:56,420 --> 00:46:00,519
por si lo queremos reutilizar, pero como no me interesa por el momento, lo voy a poner como comentado.

487
00:46:04,099 --> 00:46:09,360
Y mirad, vamos a crear en este proyecto otra clase, en el proyecto hola2, que es justo sobre el que estamos,

488
00:46:09,559 --> 00:46:19,210
este a, vamos a crear la clase, por ejemplo, la clase profesor o la clase alumno.

489
00:46:25,730 --> 00:46:32,849
Fijaros que ahora ya nuestro programa tiene dos clases, una hola2.java, que es donde está ese punto de entrada

490
00:46:32,849 --> 00:46:38,969
del programa, el módulo main y otra clase alumno que tendrá una serie de características

491
00:46:38,969 --> 00:46:43,929
propias de los alumnos y definiremos unos métodos que serán aquellas acciones que

492
00:46:43,929 --> 00:46:48,510
hacen los alumnos. Y luego podremos ir dando de alta alumnos para que vayan participando

493
00:46:48,510 --> 00:46:57,269
en nuestro programa. Vamos a suponer que los alumnos tienen un nombre y los nombres en

494
00:46:57,269 --> 00:47:02,389
qué tipo de variables los almacenamos. Los almacenamos en variables de tipo string.

495
00:47:02,849 --> 00:47:29,510
Pues mira, vamos a definir aquí que cuando yo luego dé de alto a un alumno, tendrá unos parámetros, madre mía, teclado, bueno, tendrá unos parámetros, no lo corrijo porque la letra del teclado de retroceso no me va muy bien.

496
00:47:29,510 --> 00:47:34,750
de hecho tendrá unos parámetros que caracterizarán a los alumnos

497
00:47:34,750 --> 00:47:35,989
por ejemplo tendrán un nombre

498
00:47:35,989 --> 00:47:56,110
y luego vamos a suponer que tienen una edad

499
00:47:56,110 --> 00:48:00,369
los parámetros numéricos hemos dicho

500
00:48:00,369 --> 00:48:02,809
la edad será un número entero

501
00:48:02,809 --> 00:48:05,489
no será muy grande, vamos a definirlo como un entero

502
00:48:05,489 --> 00:48:10,340
y luego los alumnos podrán hacer una serie de cosas

503
00:48:10,340 --> 00:48:14,179
os acordáis que os comentaba que las cosas que pueden hacer

504
00:48:14,179 --> 00:48:16,099
las identificamos como métodos

505
00:48:16,099 --> 00:48:44,750
Entonces, dentro de las etiquetas, pues tenemos public, que ya hablaremos de qué es, o private, o protected, public void, saludar, vamos a poner. Ponemos aquí otras llaves. System.out, ahora repasamos todo este código.

506
00:48:44,750 --> 00:49:03,690
mirad aquí, respecto a los ámbitos que os decía

507
00:49:03,690 --> 00:49:08,170
hemos definido un ámbito que corresponde a toda la clase

508
00:49:08,170 --> 00:49:12,309
he abierto aquí una llave, Eclipse me está archivando que se cierra aquí

509
00:49:12,309 --> 00:49:15,230
con lo cual las variables que definamos en este ámbito

510
00:49:15,230 --> 00:49:19,690
como puede ser el senombre o el iedad

511
00:49:19,690 --> 00:49:24,150
están activas en todo momento

512
00:49:24,150 --> 00:49:28,210
en el que tengamos un alumno, cuando creemos una variable de tipo alumno

513
00:49:28,210 --> 00:49:34,730
ahora la vamos a crear después, su ámbito de vida es el que hemos definido con código entre estas dos llaves.

514
00:49:35,670 --> 00:49:42,989
Como estas variables están definidas en todo el ámbito, esas variables se habrá reservado en memoria RAM

515
00:49:42,989 --> 00:49:52,230
para ellas mientras el alumno exista. En cambio, si cogemos y ponemos aquí saludar y definimos una variable

516
00:49:52,230 --> 00:50:10,539
de tipo string, que la definamos como misal hola desde saludar, esta variable misal, que viene a significar

517
00:50:10,539 --> 00:50:17,659
de mi saludo, está definida en este otro ámbito, con lo cual esta variable está disponible dentro del método saludar

518
00:50:17,659 --> 00:50:25,039
y estas para toda acción que realice un alumno, por ser su ámbito. Si cogemos y ponemos aquí otro método

519
00:50:25,039 --> 00:50:45,670
que sea despedirse. La variable misal está disponible en el método saludar pero como está

520
00:50:45,670 --> 00:50:51,809
definido en este método una vez que se encuentra la llave de cierre de saludar misal desaparece y

521
00:50:51,809 --> 00:50:57,010
será el recolector de basura el que termine eliminando ese espacio de memoria y no estará

522
00:50:57,010 --> 00:51:03,710
disponible en despedir. ¿Por qué? Porque solamente está en este ámbito. En cambio ese nombre eiedad

523
00:51:03,710 --> 00:51:07,409
como está disponible en todo el ámbito de la clase alumno

524
00:51:07,409 --> 00:51:10,530
podríamos utilizarla dentro de saludar o podríamos utilizarla

525
00:51:10,530 --> 00:51:14,460
dentro de despedir. Fijaros como

526
00:51:14,460 --> 00:51:16,659
si yo le doy un valor aquí a iedad

527
00:51:16,659 --> 00:51:25,599
no se queja el compilador, no se pone en rojo

528
00:51:25,599 --> 00:51:28,739
si le doy un nuevo valor a mi sal

529
00:51:28,739 --> 00:51:34,929
tampoco se queja, ¿por qué?

530
00:51:34,929 --> 00:51:37,889
porque estas dos variables en esta zona

531
00:51:37,889 --> 00:51:40,829
están dentro del ámbito donde están definidas, una porque

532
00:51:40,829 --> 00:51:43,869
está definida en toda la clase y otra porque está definida dentro del método

533
00:51:43,869 --> 00:51:46,929
saludar. Pero si yo trabajo con

534
00:51:46,929 --> 00:51:49,050
esas dos variables dentro del método despedir

535
00:51:49,050 --> 00:51:53,010
y edad sí que le sigue gustando, pero mi sal

536
00:51:53,010 --> 00:51:55,869
ya no. ¿Por qué? Porque no existe en el ámbito de despedir,

537
00:51:55,969 --> 00:52:04,500
solamente existe en el ámbito de saludar. Se entiende

538
00:52:04,500 --> 00:52:07,579
más o menos supongo esto de los ámbitos donde están definidas

539
00:52:07,579 --> 00:52:11,860
las variables. Mirad, aquí

540
00:52:11,860 --> 00:52:15,300
en este proyecto tenemos

541
00:52:15,300 --> 00:52:17,440
el main y la clase alumno.

542
00:52:18,320 --> 00:52:24,539
En este proyecto cogemos y podemos definir en el método main, que decimos que es el punto de entrada a nuestro programa,

543
00:52:25,099 --> 00:52:26,280
podemos definir una variable.

544
00:52:26,820 --> 00:52:35,679
Entonces decimos string sbar y la inicializamos como variable 1.

545
00:52:38,199 --> 00:52:41,360
Nuevamente esta variable estará definida dentro del ámbito del main.

546
00:52:41,360 --> 00:52:45,159
Todo lo que pase dentro del main podrá utilizar la variable sbar.

547
00:52:47,460 --> 00:52:52,340
String es una clase que está definida en las librerías de Java.

548
00:52:52,340 --> 00:52:53,340
Como vamos a...

549
00:52:54,139 --> 00:52:55,340
Bueno, string luego tiene...

550
00:52:55,960 --> 00:52:58,039
Sí, string está definida dentro de las clases de Java.

551
00:52:58,119 --> 00:52:59,559
En particular, el tipo string, sí.

552
00:53:01,019 --> 00:53:04,820
Java tiene definidas una serie de variables

553
00:53:04,820 --> 00:53:07,219
que son estas que os había puesto por aquí.

554
00:53:08,420 --> 00:53:10,719
Las voy a rescatar, todas estas.

555
00:53:11,179 --> 00:53:13,340
Que las llama variables primitivas.

556
00:53:14,119 --> 00:53:15,039
Primitivas de Java.

557
00:53:16,699 --> 00:53:18,199
Es decir, que las tiene definidas

558
00:53:18,199 --> 00:53:20,559
para que las utilice cualquiera en cualquier momento.

559
00:53:20,559 --> 00:53:25,179
son características muy habituales en todo programa,

560
00:53:25,320 --> 00:53:29,300
que existan cadenas de caracteres, con lo cual nos han despreocupado

561
00:53:29,300 --> 00:53:31,920
de que tengamos que nosotros definir los componentamientos

562
00:53:31,920 --> 00:53:36,800
de estos tipos de variables y las han definido ellos en las librerías.

563
00:53:37,099 --> 00:53:42,179
En cambio, no todo proyecto tiene una clase que sea alumno.

564
00:53:42,300 --> 00:53:45,300
Esta es muy particular del problema que queremos resolver nosotros.

565
00:53:45,300 --> 00:53:47,840
Entonces, aquí es donde empezamos a nosotros a actuar

566
00:53:47,840 --> 00:53:50,480
definiendo nuestras clases propias de nuestro ejercicio.

567
00:53:50,559 --> 00:54:01,400
Nuestro ejercicio utilizará cosas que definamos nosotros particulares para él y utilizará cosas que están disponibles desde las clases de Java.

568
00:54:01,699 --> 00:54:12,579
Fijaros, hemos querido definir una variable que al llegar aquí habrá pedido nuestro programa sistema operativo que haga una reserva de memoria para guardar con ese nombre el valor jose.

569
00:54:12,579 --> 00:54:17,320
y podremos definir una nueva variable que en este caso

570
00:54:17,320 --> 00:54:21,059
en lugar de ser de tipo string sea de un tipo que hemos creado nosotros

571
00:54:21,059 --> 00:54:25,260
en nuestro programa, que tenemos un esquema de qué características tiene

572
00:54:25,260 --> 00:54:28,880
y cómo se comporta. Entonces cogemos y definimos un alumno aquí

573
00:54:28,880 --> 00:54:34,869
alumno al 1, vamos a llamarlo alumno 1

574
00:54:34,869 --> 00:54:48,039
Entonces ahora acabamos de definir una variable

575
00:54:48,039 --> 00:54:52,760
de tipo alumno. ¿Al 1 qué tendrá? Pues tendrá las características

576
00:54:52,760 --> 00:54:55,400
string, ese nombre que tendrá, pues

577
00:54:55,400 --> 00:54:58,539
aquellas características que se hayan definido en las librerías

578
00:54:58,539 --> 00:55:01,179
de Java para toda variable que sea de tipo string.

579
00:55:01,659 --> 00:55:04,519
Ya veremos cosas que se pueden hacer con los strings. Sobre todo

580
00:55:04,519 --> 00:55:07,500
es trabajar con cadenas de caracteres. Al 1, ¿qué

581
00:55:07,500 --> 00:55:10,400
será? Pues será una variable en nuestro programa, igual que

582
00:55:10,400 --> 00:55:13,280
ese nombre lo es, que es de tipo objeto

583
00:55:13,280 --> 00:55:16,039
de una clase que tendrá como características

584
00:55:16,039 --> 00:55:19,219
y cosas que puede hacer aquello que hayamos definido

585
00:55:19,219 --> 00:55:22,119
para este tipo de datos. Este tipo de datos es un tipo que hemos

586
00:55:22,119 --> 00:55:25,860
incorporado a nosotros en nuestro programa como una clase, que es la clase

587
00:55:25,860 --> 00:55:29,940
alumno. ¿Y qué es en particular lo que puede hacer? Pues lo que hayamos puesto nosotros aquí en el

588
00:55:29,940 --> 00:55:33,760
programa Java, tendrá estas características y estos métodos, estas

589
00:55:33,760 --> 00:55:41,039
propiedades. Los tipos que ya están disponibles en Java,

590
00:55:44,690 --> 00:55:47,909
string es un poco particular, pero bueno, aquí en este contexto lo vamos a meter

591
00:55:47,909 --> 00:55:51,869
también entre los tipos propiamente definidos en Java para lo que os voy a contar,

592
00:55:51,869 --> 00:55:56,170
como puede ser, por ejemplo, el tipo string, el tipo int, son los tipos primitivos

593
00:55:56,170 --> 00:56:01,570
de Java. Y los tipos como alumno, que son clases que definimos

594
00:56:01,570 --> 00:56:05,150
nosotros, de los cuales podemos crear también variables, son

595
00:56:05,150 --> 00:56:09,409
variables referenciadas. Ahora os desarrollo lo de referenciadas.

596
00:56:09,570 --> 00:56:14,670
Tipos primitivos, variables referenciadas. ¿Qué sucede cuando

597
00:56:14,670 --> 00:56:19,619
en nuestro programa, si os pierdo en algún momento me cortáis

598
00:56:19,619 --> 00:56:23,820
o me vais diciendo? ¿Qué sucede cuando en mi programa yo defino

599
00:56:23,820 --> 00:56:26,079
una variable de un tipo primitivo.

600
00:56:26,840 --> 00:56:29,739
Pues directamente, como os decía antes,

601
00:56:29,840 --> 00:56:32,099
el intérprete va a preguntar al sistema operativo

602
00:56:32,099 --> 00:56:34,840
por espacio donde guardar una información

603
00:56:34,840 --> 00:56:37,559
tipo cadena de caracteres, porque la hemos dicho string,

604
00:56:37,900 --> 00:56:40,219
o entero, si siguiéramos con este otro ejemplo,

605
00:56:41,780 --> 00:56:44,380
le va a asociar a esa zona de memoria

606
00:56:44,380 --> 00:56:46,619
el nombre de la variable, ese nombre,

607
00:56:46,619 --> 00:56:48,000
y va a guardar su información.

608
00:56:49,719 --> 00:56:51,699
Es decir, en esta línea de texto,

609
00:56:51,699 --> 00:57:05,210
cuando llegamos a esta línea de código

610
00:57:05,210 --> 00:57:08,090
cogerá mi intérprete y dirá

611
00:57:08,090 --> 00:57:11,090
sistema operativo, necesito

612
00:57:11,090 --> 00:57:16,079
espacio para almacenar

613
00:57:16,079 --> 00:57:17,639
un string

614
00:57:17,639 --> 00:57:22,000
el sistema operativo buscará en la memoria RAM y dirá

615
00:57:22,000 --> 00:57:24,400
una vez en un sitio, otra vez en otro

616
00:57:24,400 --> 00:57:27,340
es una gestión que hace el sistema operativo con independencia

617
00:57:27,340 --> 00:57:29,960
de que nosotros la podamos controlar, pues dirá

618
00:57:29,960 --> 00:57:32,079
en la posición de la memoria RAM, en la 20.000

619
00:57:32,079 --> 00:57:35,059
resulta que tengo espacio para guardar

620
00:57:35,059 --> 00:57:36,719
tu stream

621
00:57:36,719 --> 00:57:37,860
y te lo reservo

622
00:57:37,860 --> 00:57:40,019
con lo cual

623
00:57:40,019 --> 00:57:43,019
desde la 20.000 hasta un determinado

624
00:57:43,019 --> 00:57:44,679
espacio que ocupará para la cadena stream

625
00:57:44,679 --> 00:57:47,019
vamos a suponer que es hasta la 20.020

626
00:57:47,840 --> 00:57:51,300
este espacio

627
00:57:51,300 --> 00:57:52,820
está reservado y ahí voy a guardar

628
00:57:52,820 --> 00:57:54,360
tu información que es José

629
00:57:54,360 --> 00:57:56,239
y cuando quieras

630
00:57:56,239 --> 00:57:58,579
preguntarme por ella, lo voy a dejar asociado

631
00:57:58,579 --> 00:58:00,219
a una variable que me has dicho que es ese nombre

632
00:58:00,219 --> 00:58:02,199
cuando tú me preguntes por ese nombre, me iré

633
00:58:02,199 --> 00:58:06,159
a la posición 20.000 y sabiendo que en el espacio

634
00:58:06,159 --> 00:58:10,219
entre la 20.000 y 20.030 está la información relacionada con ese nombre, te diré

635
00:58:10,219 --> 00:58:14,139
que lo que había ahí es José. Si yo cojo

636
00:58:14,139 --> 00:58:17,219
en el programa para esa misma variable y le pongo ese

637
00:58:17,219 --> 00:58:21,940
nombre igual a José2, pues dirá, como ese nombre está

638
00:58:21,940 --> 00:58:25,659
asociado a esta zona de memoria, para la cual he reservado ya

639
00:58:25,659 --> 00:58:30,179
un espacio, pues en ese espacio de memoria guardo ese 2. Cuando me preguntes

640
00:58:30,179 --> 00:58:32,980
por ese nombre, ahora lo que pondrás será jose2

641
00:58:32,980 --> 00:58:36,420
y te devolveré que esa variable en esa posición de memoria

642
00:58:36,420 --> 00:58:40,019
tiene jose2, en la forma en la que va a ir trabajando Java.

643
00:58:41,960 --> 00:58:51,960
Para cuando hacemos la definición de una variable primitiva de Java,

644
00:58:53,260 --> 00:58:56,079
el sistema operativo ya hace esta reserva.

645
00:58:57,079 --> 00:59:00,940
Pero cuando hacemos la definición de una variable

646
00:59:00,940 --> 00:59:06,800
que es referenciada, es decir, un objeto, la variable que apunta a un objeto

647
00:59:06,800 --> 00:59:12,119
de una clase nuestra o incluso de una clase de Java, pero un objeto de una clase

648
00:59:12,119 --> 00:59:17,840
en una de las variables primitivas, lo que estamos reservando es una referencia

649
00:59:17,840 --> 00:59:24,579
en memoria. ¿Esto cómo funciona? Esta instrucción está escrita aquí en dos fases

650
00:59:24,579 --> 00:59:35,929
que la vamos a romper ahora. Vamos a quitar este trozo aquí y ahora vamos a poner esto.

651
00:59:36,030 --> 00:59:54,989
En estos dos trozos. Cuando nosotros cogemos y hacemos esto, estamos definiendo una variable que va a ser de tipo alumno. Pero no, el sistema operativo en este caso no reserva el espacio de memoria necesario para albergar toda la información de un alumno.

652
00:59:54,989 --> 01:00:15,349
Fijaros, como poco, un alumno necesita espacio de memoria para guardar un nombre y una edad. Lo que hace es guardar una referencia. Dice, vale, esta variable, cuando vayas a querer referirte a ella, tienes para esta variable, busco en memoria RAM y te doy la posición 30.000 en este caso.

653
01:00:15,349 --> 01:00:19,809
esa referencia es donde

654
01:00:19,809 --> 01:00:22,769
vas a ir a buscar información cuando

655
01:00:22,769 --> 01:00:25,949
hagas referencia en tu programa al 1

656
01:00:25,949 --> 01:00:28,130
que es un objeto de la clase alumno

657
01:00:28,130 --> 01:00:31,590
pero no te he reservado de la 30.000

658
01:00:31,590 --> 01:00:35,570
a un determinado número de memoria RAM

659
01:00:35,570 --> 01:00:38,010
donde puedas guardar el nombre y la edad

660
01:00:38,010 --> 01:00:41,409
solamente te voy a reservar un trocito de memoria

661
01:00:41,409 --> 01:00:44,210
pequeño para que se almacene

662
01:00:44,210 --> 01:00:48,769
una referencia. Es decir, aquí voy a decirte

663
01:00:48,769 --> 01:00:52,909
que si tú ahora coges y me haces este otro bloque de código

664
01:00:52,909 --> 01:00:57,070
new, con este new es el momento

665
01:00:57,070 --> 01:01:00,789
en el que te voy a reservar espacio para guardar todos estos datos.

666
01:01:02,849 --> 01:01:05,010
Entonces, con este new se fija

667
01:01:05,010 --> 01:01:08,909
en cómo está construido el alumno, que tiene

668
01:01:08,909 --> 01:01:12,230
un nombre y una edad, y dice, para un string necesito

669
01:01:12,230 --> 01:01:14,610
20 bytes y para

670
01:01:14,610 --> 01:01:16,989
un entero necesito

671
01:01:16,989 --> 01:01:18,869
32. Entonces aquí es cuando

672
01:01:18,869 --> 01:01:20,469
yo cojo y busco en memoria RAM

673
01:01:20,469 --> 01:01:22,349
un espacio mucho más grande

674
01:01:22,349 --> 01:01:24,869
donde poder guardar esa información

675
01:01:24,869 --> 01:01:26,829
que imaginemos que es del 50.000

676
01:01:26,829 --> 01:01:29,010
al 50.050.

677
01:01:30,489 --> 01:01:33,269
En este espacio de 50.000 al 50.050

678
01:01:33,269 --> 01:01:34,389
en el 50.000

679
01:01:34,389 --> 01:01:36,849
estará para

680
01:01:36,849 --> 01:01:37,769
alumno 1

681
01:01:37,769 --> 01:01:40,409
el nombre

682
01:01:40,409 --> 01:01:59,920
desde el 50.000 al 50.030, vamos a suponer, y del 50.030 al 50.050 es donde estará la edad.

683
01:02:02,670 --> 01:02:11,190
Y aquí, en este espacio entre el 30.000 y el 30.002, lo que guardará es que la información DAL1 se encuentra a partir del 50.000.

684
01:02:18,139 --> 01:02:18,699
Recapitulamos.

685
01:02:20,039 --> 01:02:25,840
Las variables primitivas hacen, cuando tú defines una variable directamente de las primitivas de Java,

686
01:02:25,840 --> 01:02:30,719
hacen ya la reserva del espacio donde se va a guardar su información

687
01:02:30,719 --> 01:02:33,239
sin que tengamos nosotros que hacer nada más.

688
01:02:33,739 --> 01:02:36,739
Dice ya, reservo memoria para que tú pongas ahí el dato, José 2.

689
01:02:38,320 --> 01:02:42,980
Cuando definimos un objeto de una clase, lo que se guarda es,

690
01:02:44,989 --> 01:02:46,969
estamos aquí definiendo un objeto de una clase,

691
01:02:47,969 --> 01:02:54,550
lo que se guarda es en memoria run la posición donde luego

692
01:02:54,550 --> 01:02:58,230
vamos a ser capaces de guardar los datos de ese objeto

693
01:02:58,230 --> 01:03:02,590
si ese objeto tiene un nombre y una edad

694
01:03:02,590 --> 01:03:06,269
necesitará un espacio de memoria RAM que hemos hecho un supuesto aquí que es del

695
01:03:06,269 --> 01:03:10,289
50.000 a 50.050, pero si aquí tienes 50 parámetros

696
01:03:10,289 --> 01:03:14,289
pues necesitará más espacio para guardar todos esos datos, pues entonces el

697
01:03:14,289 --> 01:03:17,610
espacio para guardar el objeto iría del 50.000 al 60.000

698
01:03:17,610 --> 01:03:21,929
y en esta definición donde no hemos hecho este new

699
01:03:21,929 --> 01:03:29,530
lo único que se requiere de memoria RAM es el espacio necesario e imprescindible

700
01:03:29,530 --> 01:03:37,090
a donde luego va a guardarse la información de todo el objeto de la clase.

701
01:03:39,389 --> 01:03:41,869
Una posibilidad podría ser definir esto a nul, mirad.

702
01:03:43,289 --> 01:03:50,210
Esto lo que implica es, si lo definimos a nul, lo que implica es que este objeto no apunta a ninguna posición de memoria.

703
01:03:50,210 --> 01:03:52,570
en este espacio

704
01:03:52,570 --> 01:03:55,949
pondríamos null, no estamos apuntando a ningún sitio

705
01:03:55,949 --> 01:03:57,550
y luego cuando hacemos el new

706
01:03:57,550 --> 01:03:59,530
lo que hacemos es cargar

707
01:03:59,530 --> 01:04:04,349
en esta referencia que está entre la 30.000 y la 30.002

708
01:04:04,349 --> 01:04:07,590
ese 50.000 que es donde el sistema operativo

709
01:04:07,590 --> 01:04:09,949
ha encontrado espacio en memoria RAM

710
01:04:09,949 --> 01:04:11,449
para guardar sus datos

711
01:04:11,449 --> 01:04:14,329
eso pasa con el new

712
01:04:14,329 --> 01:04:18,960
si nosotros cogemos y ponemos la instrucción esta

713
01:04:18,960 --> 01:04:20,179
como la habíamos puesto al principio

714
01:04:20,179 --> 01:04:34,400
con las dos cosas de una atacada al 2 y hacemos aquí un niño alumno es una atacada digamos que

715
01:04:34,400 --> 01:04:42,239
hace estos dos procesos y haciendo estos dos procesos ya lo que tenemos es algo que se empieza

716
01:04:42,239 --> 01:04:47,639
a parecer mucho a lo que en una sola instrucción hacemos para las variables de primitivas dejaba

717
01:04:47,639 --> 01:05:12,429
Que es que para ALDOS ya tenemos un espacio de memoria donde poder guardar información para sus variables. ¿Se entiende más o menos? La parte de la gestión de memoria no es fácil del todo, eso ya lo digo, pero bueno, como lo repasaremos mucho.

718
01:05:12,429 --> 01:05:32,570
estáis ahí verdad me oís sí sí vale se entiende esto es lioso un poco lioso sí bueno vamos a

719
01:05:32,570 --> 01:05:40,250
vamos a repetirlo intentando simplificarlo definimos una variable de tipo entero que

720
01:05:40,250 --> 01:05:49,070
son las que existen en java y igual a 10 a 20 el sistema operativo busca espacio para esta

721
01:05:49,070 --> 01:05:54,989
variable y los enteros tienen un tamaño de 32 y en ese espacio no es necesario hacer un

722
01:05:54,989 --> 01:06:02,630
nosotros específico específico por código y directamente cuando nosotros pongamos una

723
01:06:02,630 --> 01:06:11,110
referencia de y ya directamente nos dirá el valor de 20 entonces el sistema operativo habrá ido y

724
01:06:11,110 --> 01:06:18,070
y habrá buscado en un espacio de memoria el 40.000 y dirá, pues a partir de ahí guardo con los siguientes 32 bits, 20.

725
01:06:18,469 --> 01:06:29,360
Si yo digo, escríbeme, escribe el valor de i por pantalla, con System of Println, por pantalla me saldrá un 20,

726
01:06:29,360 --> 01:06:48,639
y la variable i vale 20. Si yo cojo y digo, alumno, mi alum, esto lo que está haciendo es, fijaros, si yo digo, alumno, mi alum,

727
01:06:48,639 --> 01:06:53,340
¿qué es? Información que puede tener en su nombre,

728
01:06:53,500 --> 01:06:56,920
información que puede tener en su edad, o algo

729
01:06:56,920 --> 01:07:01,039
que puede llegar a ser, del cual podemos expresar su nombre

730
01:07:01,039 --> 01:07:04,199
y su edad. Pues todavía no es ninguna de las cosas. Si yo digo

731
01:07:04,199 --> 01:07:15,760
alumno1 ese nombre, defino un alumno y digo ahora aquí

732
01:07:15,760 --> 01:07:19,719
mi alumno, mi alumno ese nombre, pues aquí me estoy

733
01:07:19,719 --> 01:07:22,800
refiriendo al nombre del alumno.

734
01:07:23,599 --> 01:07:28,900
Si yo cojo y digo mi ALU1 y edad, me estoy refiriendo a la edad del alumno.

735
01:07:29,460 --> 01:07:33,559
Pero si digo mi ALU, ¿a qué me refiero?

736
01:07:33,599 --> 01:07:38,019
Al nombre, a la edad, a otra de sus características, a ninguna de ellas en particular.

737
01:07:39,619 --> 01:07:46,300
Entonces, como un alumno, digamos que tendríamos la posibilidad de tener diferentes parámetros,

738
01:07:46,300 --> 01:07:51,739
uno que es el nombre, otro que es la edad, y todos ellos son comunes a mi ALU,

739
01:07:51,739 --> 01:07:54,920
con Mialu no nos referimos a ninguno de ellos

740
01:07:54,920 --> 01:07:58,320
sino a algo desde lo que podemos llegar a cualquiera de ellos

741
01:07:58,320 --> 01:08:00,579
entonces lo que tenemos es una referencia

742
01:08:00,579 --> 01:08:04,840
al objeto en memoria RAM

743
01:08:04,840 --> 01:08:06,739
que no es ninguno de todos esos valores

744
01:08:06,739 --> 01:08:14,010
en este caso, esa referencia a todos los posibles valores

745
01:08:14,010 --> 01:08:16,310
a los que vamos a ir accediendo este alumno Mialu

746
01:08:16,310 --> 01:08:19,029
pues sería una posición de memoria en memoria RAM

747
01:08:19,029 --> 01:08:22,529
es decir, un espacio que nos reserva el sistema operativo en memoria RAM

748
01:08:22,529 --> 01:08:25,909
en una determinada posición. A partir de la posición 90.000

749
01:08:25,909 --> 01:08:30,170
vas a poder empezar a localizar información del alumno.

750
01:08:31,670 --> 01:08:33,130
Y luego cuando tú coges y haces

751
01:08:33,130 --> 01:08:41,220
mialu igual a new y pones esta expresión de new

752
01:08:41,220 --> 01:08:45,579
y pones aquí el mismo nombre de la clase que es un método constructor del cual hablaremos

753
01:08:45,579 --> 01:08:49,060
con este new es cuando de verdad hacemos

754
01:08:49,060 --> 01:08:53,279
reserva para todos estos valores. Con lo cual

755
01:08:53,279 --> 01:08:55,319
ya sí que podemos empezar a acceder a cada uno

756
01:08:55,319 --> 01:09:13,539
de ellos. Si yo pongo

757
01:09:13,539 --> 01:09:15,699
System.out, con las

758
01:09:15,699 --> 01:09:17,760
instrucciones, la instrucción System.out

759
01:09:17,760 --> 01:09:19,760
println, println es un

760
01:09:19,760 --> 01:09:21,699
método que tenemos

761
01:09:21,699 --> 01:09:23,800
en Java, en las librerías de la

762
01:09:23,800 --> 01:09:25,840
clase System.out, y que

763
01:09:25,840 --> 01:09:27,420
nos permite escribir por pantalla,

764
01:09:28,060 --> 01:09:30,300
pues yo podría poner, entrecomillado,

765
01:09:30,500 --> 01:09:31,680
información como si fuese un

766
01:09:31,680 --> 01:09:33,000
string aquí, que os decía,

767
01:09:35,880 --> 01:09:37,239
el valor de

768
01:09:37,239 --> 01:09:38,479
i es,

769
01:09:41,220 --> 01:09:42,359
si hago esta ejecución,

770
01:09:42,359 --> 01:09:50,590
¿Veis? Me muestra el valor de i es, que es lo que le acabo de decir yo, que nos muestre por pantalla este método.

771
01:09:51,369 --> 01:09:56,409
Y en println podemos enlazar diferentes variables para ir mostrando por pantalla datos.

772
01:09:56,409 --> 01:10:08,050
Entonces, si yo digo, le pongo aquí un más i, pues este i no lo pongo entrecomillado, con lo cual ya no es una cadena de caracteres, sino que es una variable que tenemos disponible en el código, que es i.

773
01:10:08,050 --> 01:10:24,859
Entonces, si yo pongo aquí mi valor de i es más i, lo que hará será juntar esta cadena de caracteres con esta variable. Entonces, si yo cojo y hago esto, me dice mi valor de i es 20.

774
01:10:24,859 --> 01:10:40,159
¿Qué es lo que ha pasado en este programa? En relación a memoria rank, os decía, cuando hemos llegado aquí, se ha reservado en la posición 80.000, digamos, una que elige el sistema operativo, un espacio donde guardar información para un entero y ha puesto el valor 20.

775
01:10:40,159 --> 01:10:55,199
Y cuando ha llegado aquí, ha dicho, quiero saber la información de esta variable, pues el programa tiene que la variable i está en la posición 80.000 y coge su valor y lo muestra por pantalla, que es este 20.

776
01:10:55,199 --> 01:12:01,319
Sí, te cuento. Una de las características que tiene la programación orientada a objetos es la sobrecarga. Se utiliza mucho en métodos y nosotros podemos sobrecargar métodos que es que métodos como este que pone aquí saludar, poniendo aquí unos determinados parámetros extras, pues podemos hacer que salude de diferentes formas.

777
01:12:01,319 --> 01:12:15,479
Entonces, con el mismo método saludar está sobrecargado y puede tener comportamientos diferentes según llames al método saludar que no tiene aquí dentro de los paréntesis nada o uno que sí que tenga ciertas cosas. Esa es la sobrecarga de métodos.

778
01:12:15,479 --> 01:12:31,439
Luego hay otra cosa en los lenguajes de programación orientado a objeto que es la sobrecarga de operadores, que tiene que ver justo con lo que tú dices. Que Java no permite definir sobrecarga de operadores. Existe la que hay ya predefinida en Java, pero no te permite darle nuevos comportamientos al operador más.

779
01:12:32,399 --> 01:12:33,100
Entonces, ¿qué pasa?

780
01:12:33,140 --> 01:12:35,079
Que si tú en el código pones un más,

781
01:12:35,500 --> 01:12:37,800
depende si te encuentras una cosa por aquí,

782
01:12:38,439 --> 01:12:40,399
a la izquierda y a la derecha se comporta de una forma

783
01:12:40,399 --> 01:12:43,060
y si te encuentras otra, se comporta de otra.

784
01:12:43,779 --> 01:12:46,619
Entonces, si tú a la izquierda y a la derecha del más

785
01:12:46,619 --> 01:12:49,119
pones números, lo que hace es sumártelo como números.

786
01:12:49,760 --> 01:12:52,399
Pero si a la izquierda tienes una cadena de caracteres,

787
01:12:52,520 --> 01:12:55,640
lo que hace es concatenar cadenas de caracteres,

788
01:12:55,880 --> 01:12:57,119
es decir, unir una con otra.

789
01:12:59,229 --> 01:13:01,569
O sea, es diferente comportamiento de un mismo operador

790
01:13:01,569 --> 01:13:03,489
porque el operador está sobrecargado.

791
01:13:03,850 --> 01:13:06,550
¿Y por qué se comporta de una forma o de otra?

792
01:13:06,789 --> 01:13:09,670
En función de lo que va encontrando a izquierda o derecha.

793
01:13:12,310 --> 01:13:19,109
Mira, si ponemos aquí, para que lo veas.

794
01:13:29,930 --> 01:13:33,109
Mira, aquí nos ha sacado el valor de i es,

795
01:13:34,489 --> 01:13:36,529
y como esto es una cadena de caracteres,

796
01:13:37,390 --> 01:13:38,930
ha concatenado cadena de caracteres.

797
01:13:38,930 --> 01:13:42,510
Entonces pone i, que es 20, y luego i2, que es 10.

798
01:13:44,149 --> 01:13:45,710
Si tú coges y haces así, mira,

799
01:13:46,310 --> 01:13:48,189
Le pones aquí unos paréntesis como en matemáticas.

800
01:13:49,229 --> 01:13:54,810
Antes de esto, de este más, antes de operar con este más, va a dar prioridad a los paréntesis.

801
01:13:55,229 --> 01:13:56,729
Entonces, fíjate con los paréntesis.

802
01:13:57,890 --> 01:14:00,770
Le das aquí y te pone el valor de i es 30.

803
01:14:00,909 --> 01:14:01,170
¿Por qué?

804
01:14:01,710 --> 01:14:05,489
Porque aquí hace esta operación antes y como lo que se encuentra este más,

805
01:14:05,489 --> 01:14:11,010
a la izquierda y a la derecha son números, hace la operación, en este caso, el más de sumar dos números.

806
01:14:11,649 --> 01:14:13,149
Y ya no le dice el valor de i es 30.

807
01:14:13,149 --> 01:14:20,149
En cambio, este más se sigue comportando como una concatenación de cadenas, de caracteres, porque a la izquierda se ha encontrado una cadena de caracteres.

808
01:14:26,720 --> 01:14:31,899
Vale, pues continuamos por aquí para intentar llegar a lo de la...

809
01:14:32,600 --> 01:14:37,279
No es fácil entender la memoria RAM, por lo menos los primeros días, pero insistiremos mucho con ella.

810
01:14:38,560 --> 01:14:43,140
Y unos días u otros terminarán con la tecla de explicarlo para que lo entendáis seguro.

811
01:14:43,140 --> 01:14:45,659
bueno, aquí estábamos mostrando

812
01:14:45,659 --> 01:14:48,119
y, mirad, si cogemos y ponemos

813
01:14:48,119 --> 01:14:52,239
alumno

814
01:14:52,239 --> 01:14:54,140
mial

815
01:14:54,140 --> 01:14:56,199
sin poner lo del new que os decía

816
01:14:56,199 --> 01:14:58,439
si yo ahora pongo aquí un system.out.println

817
01:14:58,439 --> 01:15:01,800
y lo que muestro es esto

818
01:15:01,800 --> 01:15:13,069
bueno, fijaros que ni siquiera

819
01:15:13,069 --> 01:15:15,229
me deja por no haberlo inicializado

820
01:15:15,229 --> 01:15:17,069
por ser una variable local

821
01:15:17,069 --> 01:15:18,149
vamos a ponerle aquí

822
01:15:18,149 --> 01:15:25,100
vamos a inicializarlo a nulo

823
01:15:25,100 --> 01:15:29,079
que no tenga ningún valor

824
01:15:29,079 --> 01:15:53,079
¿vale? Dice el valor de mi al es null. Mira, si yo cojo y, en este caso, si yo cojo y pongo aquí y le hago el new, que es como empieza a reservar memoria este new en las primitivas, no es necesario hacer un new para que ya el sistema operativo haga reserva de memoria RAM.

825
01:15:53,079 --> 01:16:21,060
Para los objetos de las clases es necesario este new. Entonces, si yo ahora hago esto, le he quitado el null este y lo he inicializado después de hacer un new, fijaros que lo que me muestra aquí es esto que me acaba de decir mi alumno, me di cuenta que pertenece a la clase alumno y me he puesto aquí un identificador que yo creo que tiene que ver con la posición de memoria en la que va a estar referenciado el alumno.

826
01:16:21,060 --> 01:16:23,479
Ese 80.000 que os decía antes, o 90.000,

827
01:16:23,800 --> 01:16:27,039
tiene que ver con, este número tiene que ver con ese dato de

828
01:16:27,039 --> 01:16:27,380
verdad.

829
01:16:28,239 --> 01:16:32,420
Y ahora si cojo y digo, mi al punto, ese nombre,

830
01:16:33,420 --> 01:16:44,100
igual a Rubén, y el system.out.println lo pongo de mi al,

831
01:16:44,420 --> 01:16:47,939
pero no de mi al ya, que es una referencia en memoria a lo que

832
01:16:47,939 --> 01:16:55,420
va a ser un alumno, sino de ese Rubén, de ese nombre, perdón.

833
01:17:01,840 --> 01:17:03,159
Aquí ya sí que me dice que es Rubén.

834
01:17:03,159 --> 01:17:18,699
Bien, ¿qué es lo que está pasando aquí? Aquí necesitábamos hacer un new, nos reservaba memoria RAM directamente y con i accedíamos ya a su valor. Como es un valor único, porque es un valor primitivo, que es un entero, no hay lugar a dudas, pues ya me muestra el 20.

835
01:17:18,699 --> 01:17:23,779
aquí para el alumno en realidad es un objeto

836
01:17:23,779 --> 01:17:27,100
y lo que tenemos es una referencia a lo que va a ser un alumno

837
01:17:27,100 --> 01:17:30,079
digamos que un puntero a donde va a estar el alumno Mial

838
01:17:30,079 --> 01:17:33,619
pero todavía no le hemos dado información ni a nombres ni a nada

839
01:17:33,619 --> 01:17:38,319
y con este new lo que hacemos es ya reservar espacio de memoria RAM

840
01:17:38,319 --> 01:17:42,180
para que pueda albergar toda la información que hemos definido aquí como parámetros

841
01:17:42,180 --> 01:17:48,710
y para acceder en sí a un nombre que ya es, fijaros, de tipo string

842
01:17:48,710 --> 01:17:58,369
es una variable primitiva, pero que está embebida, digamos, dentro de la clase, pues aquí ya sí que podemos coger y mostrar su nombre,

843
01:17:58,550 --> 01:18:10,619
mial y con el punto accedemos a la variable ese nombre. Bueno, lo iremos retomando. Las variables primitivas no necesitan un new,

844
01:18:10,859 --> 01:18:16,420
que son todas aquellas que son tipos básicos, digamos, de Java y que tenemos predefinidos.

845
01:18:16,420 --> 01:18:30,800
Los objetos, que van a ser aquellas variables que vamos a ir definiendo nosotros relacionadas con nuestras clases, necesitan utilizar la etiqueta new para hacer la reserva de memoria RAM, porque si no, no tenemos ese espacio.

846
01:18:42,699 --> 01:18:56,579
Aquí relacionado con los ámbitos, antes hemos definido unas variables por aquí que tienen que ver con todo que está en el ámbito del objeto alumno y otras con un método.

847
01:18:56,579 --> 01:19:08,720
Estas variables que definimos para un método en particular se llaman variables locales y las que definimos en toda una clase se llaman variables miembro de la clase.

848
01:19:11,479 --> 01:19:18,779
Fijaros, puede haber variables que durante el proceso de saludar vayamos a necesitar pero que no tienen que ver con un alumno.

849
01:19:18,779 --> 01:19:25,260
imaginaos que el alumno está haciendo unos determinados cálculos

850
01:19:25,260 --> 01:19:28,479
calcular una operación trigonométrica

851
01:19:28,479 --> 01:19:33,449
vamos a llamarla trigo

852
01:19:33,449 --> 01:19:37,529
los alumnos tienen capacidad

853
01:19:37,529 --> 01:19:41,109
de hacer cálculos trigonométricos

854
01:19:41,109 --> 01:19:44,270
como una de sus funciones

855
01:19:44,270 --> 01:19:47,390
pueden saludar, pueden despedirse

856
01:19:47,390 --> 01:19:49,970
y pueden hacer cálculos de operaciones trigonométricas

857
01:19:49,970 --> 01:19:53,329
para hacer el cálculo de operación trigonométrica

858
01:19:53,329 --> 01:19:59,510
a lo mejor hay un momento en el que tenemos que guardar, necesitamos conocer pi.

859
01:20:00,210 --> 01:20:11,270
Entonces podemos definir una variable de tipo double, al cual podemos llamar pi, que sea igual a 3.14.

860
01:20:18,069 --> 01:20:24,909
En este caso, cuando por aquí este alumno que hemos creado, queramos, según la lógica de nuestro programa,

861
01:20:24,909 --> 01:20:31,529
que haga un cálculo trigonométrico, pues pondríamos mi al punto trigo.

862
01:20:32,949 --> 01:20:36,590
Y estaríamos diciendo, alumno, este en particular,

863
01:20:36,909 --> 01:20:38,550
podríamos tener más alumnos en nuestro programa,

864
01:20:38,729 --> 01:20:42,130
pero hemos dado de alta uno, realiza una función trigonométrica.

865
01:20:42,710 --> 01:20:46,489
¿Y qué va a hacer cuando realice esta acción el alumno?

866
01:20:47,130 --> 01:20:50,010
Pues lo que va a hacer va a ser lo que hayamos descrito dentro de este método.

867
01:20:50,010 --> 01:20:57,590
y por aquí tendríamos diferentes cálculos que tuvieran que ver con la resolución

868
01:20:57,590 --> 01:21:01,829
de esta operación trigonométrica, todo el código Java que corresponda.

869
01:21:02,550 --> 01:21:05,930
A lo mejor para apoyarnos en estos cálculos va a haber un momento en el que necesitemos pi

870
01:21:05,930 --> 01:21:10,310
porque vamos a hacer unos cálculos de senos y cosenos y vamos a necesitar pi.

871
01:21:11,229 --> 01:21:16,590
Entonces cogemos y definimos esta variable en el ámbito del método trigo

872
01:21:16,590 --> 01:21:19,750
y desaparecerá cuando termine este método.

873
01:21:20,010 --> 01:21:23,390
Esta variable dejará de existir y el recolector de basura la eliminará.

874
01:21:24,949 --> 01:21:29,750
¿Esta variable tiene sentido dentro de las operaciones trigonométricas?

875
01:21:30,010 --> 01:21:35,729
¿O cuando nosotros damos de alta a un alumno tiene sentido que esta variable esté definida aquí?

876
01:21:36,710 --> 01:21:48,310
Pi sería una característica de todo alumno, que normalmente tenemos asociado con un alumno su nombre, su edad, su DNI, características propias del alumno,

877
01:21:48,310 --> 01:21:52,590
pero pi típicamente va a ser una característica propia de los alumnos

878
01:21:52,590 --> 01:21:54,189
en principio no, ¿verdad?

879
01:21:54,909 --> 01:21:56,529
pi, ¿cuándo lo vamos a necesitar?

880
01:21:56,649 --> 01:22:00,449
lo vamos a necesitar cuando realicemos la operación trigonométrica

881
01:22:00,449 --> 01:22:02,989
porque aquí sí que nos va a ser necesaria con toda seguridad

882
01:22:02,989 --> 01:22:06,109
en cambio pi lo vamos a necesitar cuando saludemos

883
01:22:06,109 --> 01:22:09,569
pues no, para saludarnos es raro que el alumno salude

884
01:22:09,569 --> 01:22:12,109
despidiéndose adiós soy pi o adiós pi

885
01:22:12,109 --> 01:22:13,789
o para despedirse igual

886
01:22:13,789 --> 01:22:16,289
pero en cambio en el contexto de la operación trigonométrica

887
01:22:16,729 --> 01:22:18,550
Oye, ahí sí parece tener sentido la cosa.

888
01:22:19,909 --> 01:22:23,949
Con lo cual, esta, a todas luces, es una variable que por diseño

889
01:22:23,949 --> 01:22:28,350
pega en este método, con lo cual la vamos a definir aquí

890
01:22:28,350 --> 01:22:30,750
como variable local a este método trigo,

891
01:22:31,529 --> 01:22:35,550
y de hecho, se va a dar de alta en el momento en el que llamemos a este método,

892
01:22:35,710 --> 01:22:37,489
es decir, va a existir desde esta llamada,

893
01:22:38,029 --> 01:22:40,930
cuando hagamos esta llamada se va a ejecutar esta parte del código hasta aquí,

894
01:22:41,329 --> 01:22:43,130
y luego va a desaparecer, porque ya no la queremos.

895
01:22:43,489 --> 01:22:45,390
Si no estamos haciendo operaciones trigonométricas,

896
01:22:45,390 --> 01:22:49,149
no queremos esta variable, que el recolector de basura nos libere la RAM

897
01:22:49,149 --> 01:22:52,710
para que vaya más fluido nuestro ordenador, en cambio

898
01:22:52,710 --> 01:22:59,180
y por eso la definimos como una variable local, en cambio están las variables

899
01:22:59,180 --> 01:23:03,319
de clase, que sí que tienen sentido con el

900
01:23:03,319 --> 01:23:06,979
alumno, entonces si nosotros cogemos y damos de aquí, aquí de alta un alumno

901
01:23:06,979 --> 01:23:11,239
todo el tiempo que existe este alumno, fijaros que esta es una

902
01:23:11,239 --> 01:23:14,760
variable que existe en el ámbito del método main, por aquí lo seguimos utilizando

903
01:23:14,760 --> 01:23:18,199
queremos tener disponible por si nos hace falta su nombre

904
01:23:18,199 --> 01:23:20,159
porque es una característica propia del nombre

905
01:23:20,159 --> 01:23:21,800
y queremos tener disponible su edad

906
01:23:21,800 --> 01:23:23,739
porque es una característica propia de su edad

907
01:23:23,739 --> 01:23:26,920
si nosotros el nombre lo definiésemos aquí

908
01:23:26,920 --> 01:23:30,420
como una variable local del método trigo

909
01:23:30,420 --> 01:23:31,840
¿qué pasaría?

910
01:23:32,500 --> 01:23:33,920
pues que aquí, fijaros

911
01:23:33,920 --> 01:23:36,380
como no está disponible para el alumno

912
01:23:36,380 --> 01:23:38,739
¿veis que ahora se me queja y no me compila el programa?

913
01:23:38,739 --> 01:23:39,619
aquí en ese nombre

914
01:23:39,619 --> 01:23:42,779
nombre es una característica propia de los alumnos

915
01:23:42,779 --> 01:23:47,039
¿cuándo tiene vida el alumno? Desde que lo creo hasta que desaparece.

916
01:23:47,100 --> 01:23:50,920
Es una variable de este tipo, con lo cual tiene sentido que el nombre

917
01:23:50,920 --> 01:23:54,739
esté en todo el ámbito de la clase. Con lo cual, ese nombre,

918
01:23:55,000 --> 01:23:58,439
lejos de ser una variable del método trigo,

919
01:23:58,939 --> 01:24:02,859
es una variable del alumno en sí y la tenemos que definir en el ámbito del alumno.

920
01:24:04,060 --> 01:24:07,140
Y estas variables son las que llamamos variables de clase.

921
01:24:08,640 --> 01:24:09,800
La variable de clase

922
01:24:09,800 --> 01:24:14,859
pertenecen a los objetos de la clase e identifican a la clase.

923
01:24:15,840 --> 01:24:18,779
¿Podría compilarnos el programa si la definimos esta aquí?

924
01:24:18,939 --> 01:24:19,920
Nos compila seguro.

925
01:24:20,239 --> 01:24:22,520
¿Pero por diseño sería correcto que pille este aquí?

926
01:24:22,720 --> 01:24:23,140
Pues no.

927
01:24:23,819 --> 01:24:26,380
Es algo local al método trigo.

928
01:24:29,789 --> 01:24:32,930
Retomando un momentito lo de la memoria RAM que decíamos antes.

929
01:24:33,750 --> 01:24:38,550
Cuando nosotros aquí hacemos un new de un objeto mial,

930
01:24:38,550 --> 01:24:41,229
para qué variables

931
01:24:41,229 --> 01:24:43,310
se reserva

932
01:24:43,310 --> 01:24:45,090
el sistema operativo

933
01:24:45,090 --> 01:24:47,310
espacio en memoria RAM, para aquellas que son

934
01:24:47,310 --> 01:24:49,510
propias del alumno, ¿cuáles son propias del alumno?

935
01:24:49,930 --> 01:24:51,689
estas, las variables de clase

936
01:24:51,689 --> 01:24:53,489
para pi

937
01:24:53,489 --> 01:24:55,449
en este momento en el que estoy

938
01:24:55,449 --> 01:24:56,970
dando de alta un alumno

939
01:24:56,970 --> 01:24:58,529
se reserva memoria RAM, no

940
01:24:58,529 --> 01:25:01,229
porque es una variable local

941
01:25:01,229 --> 01:25:05,970
a trigo, de hecho, fijaros

942
01:25:05,970 --> 01:25:07,510
como no existe, que si yo pongo aquí

943
01:25:07,510 --> 01:25:12,079
ni al punto

944
01:25:12,079 --> 01:25:13,079
pi

945
01:25:13,079 --> 01:25:15,680
igual a 3

946
01:25:15,680 --> 01:25:17,859
pues no me compila, ¿por qué?

947
01:25:17,939 --> 01:25:20,140
porque pi no es una variable propia de los

948
01:25:20,140 --> 01:25:21,960
alumnos, no es una característica de los alumnos

949
01:25:21,960 --> 01:25:23,979
pi es una variable que

950
01:25:23,979 --> 01:25:24,659
tiene su

951
01:25:24,659 --> 01:25:27,800
vida durante su ámbito

952
01:25:27,800 --> 01:25:29,800
su vida vive dentro del método trigo

953
01:25:29,800 --> 01:25:32,100
y cuando lo ejecuten se creará

954
01:25:32,100 --> 01:25:33,359
esa variable y cuando no

955
01:25:33,359 --> 01:25:35,880
desaparecerá, porque el

956
01:25:35,880 --> 01:25:37,819
recolector de basura la liberará

957
01:25:37,819 --> 01:25:38,920
su espacio de memoria RAM

958
01:25:38,920 --> 01:25:43,239
entonces, si damos de alta esta variable

959
01:25:43,239 --> 01:25:45,640
se hace una solicitud al sistema operativo

960
01:25:45,640 --> 01:25:47,500
para guardar esta información.

961
01:25:48,180 --> 01:25:48,720
Pi, no.

962
01:25:49,659 --> 01:25:50,739
Si luego vengo por aquí

963
01:25:50,739 --> 01:25:52,979
y llamo al método trigo,

964
01:25:53,119 --> 01:25:55,140
que es un método propio

965
01:25:55,140 --> 01:25:57,020
de las acciones que son

966
01:25:57,020 --> 01:25:58,300
capaces de hacer los alumnos,

967
01:25:58,779 --> 01:25:59,880
en el momento que entro aquí

968
01:25:59,880 --> 01:26:02,739
se encuentra esta variable y hará una reserva

969
01:26:02,739 --> 01:26:04,520
de memoria al sistema operativo para pi

970
01:26:04,520 --> 01:26:05,859
y guardará 3.14

971
01:26:05,859 --> 01:26:08,479
que estará activa en el ámbito

972
01:26:08,479 --> 01:26:09,460
del método trigo.

973
01:26:10,180 --> 01:26:11,880
Cuando termine el método trigo, ¿qué pasa?

974
01:26:11,880 --> 01:26:14,680
que desaparece pi y ya no está disponible

975
01:26:14,680 --> 01:26:17,600
para seguir utilizándolo por aquí. ¿Por qué? Porque su ámbito era

976
01:26:17,600 --> 01:26:20,760
el tiempo de ejecución de ese método.

977
01:26:26,649 --> 01:26:27,569
¿Se entiende más o menos?

978
01:26:28,729 --> 01:26:31,649
Mirad, aquí hemos cogido y ¿qué hemos hecho? Hemos definido

979
01:26:31,649 --> 01:26:34,989
dos variables primitivas de Java, de tipo entero

980
01:26:34,989 --> 01:26:37,609
las dos. Pues en la posición

981
01:26:37,609 --> 01:26:41,149
80.000 guardo un 20 y la reserva

982
01:26:41,149 --> 01:26:44,010
para la variable i y para la variable i2

983
01:26:44,010 --> 01:26:48,210
el sistema operativo buscará otra posición, que aquí pone 80.000 del copy y pega de antes,

984
01:26:48,890 --> 01:26:52,430
que será la 80.300, por ejemplo, y guardará el 10.

985
01:26:53,170 --> 01:26:56,270
Cada variable, lógicamente, tiene un espacio de memoria diferente.

986
01:26:57,630 --> 01:27:01,649
Si yo muestro la información de i, me mostrará lo que hay en la posición de memoria 80.000

987
01:27:01,649 --> 01:27:05,729
y escribirá un 20. Si muestro la información de la variable i2,

988
01:27:06,329 --> 01:27:09,770
pues buscará 80.300 y mostrará un 10.

989
01:27:09,770 --> 01:27:14,649
pues igual que para dos variables de tipos primitivos de Java

990
01:27:14,649 --> 01:27:19,449
tenemos espacios de memoria distintos, aunque los dos sean de tipo entero

991
01:27:19,449 --> 01:27:22,390
pues si yo he creado aquí un alumno

992
01:27:22,390 --> 01:27:26,510
que le he llamado Mial y ahora creo aquí un segundo alumno

993
01:27:26,510 --> 01:27:32,529
que llamo, vamos a llamarlo con un nombre propio, vamos a poner Sandra

994
01:27:32,529 --> 01:27:43,380
creo el alumno Sandra, pues cuando hice esta operación

995
01:27:43,380 --> 01:27:46,920
del new se me reservó en una posición de memoria, vamos a poner

996
01:27:46,920 --> 01:27:50,039
las 90.000, por decir una,

997
01:27:51,159 --> 01:27:54,779
será la que sea, el sistema operativo localizará una, la 99.000,

998
01:27:55,479 --> 01:27:57,699
reservará un espacio de memoria para los datos

999
01:27:57,699 --> 01:28:02,899
de un alumno que en el programa lo hemos nombrado como Mial

1000
01:28:02,899 --> 01:28:06,979
y que en un momento dado, ya que tiene estas características, tendrá una edad

1001
01:28:06,979 --> 01:28:10,960
y un nombre. De hecho, le hemos puesto un nombre que ha sido Rubén.

1002
01:28:12,260 --> 01:28:13,319
Y ahora, cuando hago este new,

1003
01:28:13,319 --> 01:28:16,779
el intérprete pedirá al sistema

1004
01:28:16,779 --> 01:28:18,279
operativo, el intérprete de Java

1005
01:28:18,279 --> 01:28:20,699
un espacio de memoria y el sistema

1006
01:28:20,699 --> 01:28:22,779
operativo localizará por ahí un espacio de memoria

1007
01:28:22,779 --> 01:28:24,600
igual teníamos corriendo Excel

1008
01:28:24,600 --> 01:28:26,800
y se ha apagado y ha liberado

1009
01:28:26,800 --> 01:28:28,479
memoria Excel y ahora tengo

1010
01:28:28,479 --> 01:28:30,140
la posición 60.000

1011
01:28:30,140 --> 01:28:34,100
y en la posición 60.000

1012
01:28:34,100 --> 01:28:36,100
es la que reserva

1013
01:28:36,100 --> 01:28:38,020
para que Sandra pueda guardar sus datos

1014
01:28:38,020 --> 01:28:41,760
¿Sí? ¿No me escucháis?

1015
01:28:45,520 --> 01:28:45,840
Vaya

1016
01:28:45,840 --> 01:28:48,279
Bueno, hoy no se ha aguantado más

1017
01:28:48,279 --> 01:28:54,600
por lo menos. El otro día, bueno, avisé por aquí a ver si pueden hacer algo con la red. ¿Se recupera o no?

1018
01:28:59,409 --> 01:29:07,829
Bueno, voy a pausar un poco la grabación hasta que lo recuperemos. Nada, ¿no me oís? Y nada, continuamos aquí

1019
01:29:07,829 --> 01:29:16,470
después de este pequeño lapsus que hemos tenido con la red. Mirad, os estaba contando que, igual que para las clases

1020
01:29:16,470 --> 01:29:21,970
primitivas, cada vez que definimos una variable se hace una reserva de memoria RAM diferente, pues para nuestras

1021
01:29:21,970 --> 01:29:25,630
variables que creamos como objetos y

1022
01:29:25,630 --> 01:29:29,890
tras hacer el new, donde finalmente se termina haciendo la reserva

1023
01:29:29,890 --> 01:29:33,449
de memoria RAM para nuestro objeto alumno en este caso

1024
01:29:33,449 --> 01:29:37,449
será donde se va a ir guardando esta información, si creamos

1025
01:29:37,449 --> 01:29:41,909
diferentes objetos de la misma clase, tendremos diferentes espacios de memoria

1026
01:29:41,909 --> 01:29:45,550
si ponemos aquí Sandra ese nombre

1027
01:29:45,550 --> 01:29:51,220
ay no, es verdad, no, no, no estoy

1028
01:29:51,220 --> 01:29:58,460
compartiendo, bien avisado, como he tenido que reiniciar

1029
01:29:58,460 --> 01:30:14,779
no la he puesto a compartir, ahora la pongo ya, ahí estamos

1030
01:30:14,779 --> 01:30:18,460
ya, compartiendo, ya me veis, ¿verdad? Pues

1031
01:30:18,460 --> 01:30:22,460
esto que os decía, vale, pues ahora para la variable Sandra, pues

1032
01:30:22,460 --> 01:30:26,539
también tiene disponible, como ya que es un alumno, tiene entre sus características que puede

1033
01:30:26,539 --> 01:30:30,439
tener un nombre y una edad, pues para Sandra podemos decir que su nombre

1034
01:30:30,439 --> 01:30:34,220
sea, precisamente ya que hemos llamado al objeto Sandra, vamos a decir que

1035
01:30:34,220 --> 01:30:39,020
sí que se llama Sandra. Fijaros, que se guarde

1036
01:30:39,020 --> 01:30:42,960
Sandra en memoria RAM en una zona reservada por el sistema operativo

1037
01:30:42,960 --> 01:30:46,079
para la variable ese nombre de el objeto Sandra implicará

1038
01:30:46,079 --> 01:30:50,859
que a partir de la posición 60.000 habrá un sitio

1039
01:30:50,859 --> 01:30:54,359
donde pondrá Sandra. Cuando queramos acceder a esta variable

1040
01:30:54,359 --> 01:30:58,739
el sistema operativo dirá Sandra empieza en el 60.000 y justo es

1041
01:30:58,739 --> 01:31:02,859
el nombre que queremos recuperar, pues llegaremos al 60.000

1042
01:31:02,859 --> 01:31:06,199
y dirá, pues el nombre se encuentra a partir de esta posición

1043
01:31:06,199 --> 01:31:08,399
y el dato que tiene es Sandra.

1044
01:31:08,579 --> 01:31:13,380
Si cogemos y decimos Sandra.iedad igual a 30,

1045
01:31:16,050 --> 01:31:19,069
pues probablemente saltando desde el 60.000

1046
01:31:19,069 --> 01:31:21,590
todo el espacio que necesite para guardar un string

1047
01:31:21,590 --> 01:31:24,770
que es el que corresponde al nombre,

1048
01:31:25,510 --> 01:31:28,310
pues a lo mejor en la posición 60.000,

1049
01:31:31,310 --> 01:31:34,670
bueno, este dato de cantidad es inventada,

1050
01:31:34,670 --> 01:31:36,729
pero ahí pues cogerá y guardará 30.

1051
01:31:36,829 --> 01:31:39,310
entonces si ahora nosotros cogemos y decimos

1052
01:31:39,310 --> 01:31:41,569
system.out.println, sácame por pantalla

1053
01:31:41,569 --> 01:31:43,170
el nombre de Sandra

1054
01:31:43,170 --> 01:31:45,229
pues muéstrame

1055
01:31:45,229 --> 01:31:48,810
por pantalla, system.out.println

1056
01:31:48,810 --> 01:31:53,000
si decimos muéstrame Sandra

1057
01:31:53,000 --> 01:31:59,260
pues nos mostraría 60.000

1058
01:31:59,260 --> 01:32:01,680
que es la posición de memoria

1059
01:32:01,680 --> 01:32:03,859
que tiene, no como cuando pulsábamos

1060
01:32:03,859 --> 01:32:05,880
decíamos muéstrame y que ya directamente

1061
01:32:05,880 --> 01:32:07,659
mostraba el dato, no, Sandra mostrará

1062
01:32:07,659 --> 01:32:09,140
60.000

1063
01:32:09,140 --> 01:32:10,520
si cogemos y decimos

1064
01:32:10,520 --> 01:32:15,880
system.sandra.sedaz

1065
01:32:15,880 --> 01:32:17,119
ese nombre

1066
01:32:17,119 --> 01:32:19,720
pues que es lo que

1067
01:32:19,720 --> 01:32:21,640
hará, pues dirá, tengo que sacar por pantalla

1068
01:32:21,640 --> 01:32:22,939
Sandra

1069
01:32:22,939 --> 01:32:25,920
sé que empieza en la posición 60.000

1070
01:32:25,920 --> 01:32:27,619
y como es

1071
01:32:27,619 --> 01:32:28,479
el primer parámetro

1072
01:32:28,479 --> 01:32:31,520
este sería el caso

1073
01:32:31,520 --> 01:32:33,520
de que estuviera así, como primer parámetro

1074
01:32:33,520 --> 01:32:35,180
como es el primer parámetro

1075
01:32:35,180 --> 01:32:37,260
guardo un string, pues ese string es el que

1076
01:32:37,260 --> 01:32:39,319
corresponde al nombre, según me han identificado

1077
01:32:39,319 --> 01:32:40,659
entonces 60.000 más

1078
01:32:40,659 --> 01:32:43,420
un desplazamiento de 0 al ser el primer parámetro

1079
01:32:43,420 --> 01:32:45,720
muestro el contenido que tiene, pues muestro Sandra

1080
01:32:45,720 --> 01:32:47,619
y si cojo y digo

1081
01:32:47,619 --> 01:32:49,539
System.off.println Sandra

1082
01:32:49,539 --> 01:32:51,880
y edad

1083
01:32:51,880 --> 01:32:53,539
pues lo que hará será decir

1084
01:32:53,539 --> 01:32:54,640
me voy al 60.000

1085
01:32:54,640 --> 01:32:57,720
que es el punto de inicio en memoria RAM

1086
01:32:57,720 --> 01:32:59,800
para la que el sistema operativo me ha reservado

1087
01:32:59,800 --> 01:33:01,760
espacio, y el que quiero mostrar

1088
01:33:01,760 --> 01:33:02,979
en particular es si edad

1089
01:33:02,979 --> 01:33:05,520
se dará cuenta que antes había un nombre

1090
01:33:05,520 --> 01:33:07,920
y sabiendo la cantidad de espacio

1091
01:33:07,920 --> 01:33:09,079
que reserva para un string

1092
01:33:09,079 --> 01:33:13,159
mira, el siguiente es la edad, pues mostrará el contenido que hay a partir de

1093
01:33:13,159 --> 01:33:16,439
en este ejemplo que hemos puesto, el 6400, que sería un 30

1094
01:33:16,439 --> 01:33:23,680
lo pulsamos aquí y veis, aquí tenemos zona de memoria, que este

1095
01:33:23,680 --> 01:33:27,960
corresponde a este, no es ni un dato ni otro, ni el nombre

1096
01:33:27,960 --> 01:33:31,939
ni la edad, aquí cuando hemos mostrado el nombre y aquí cuando hemos mostrado

1097
01:33:31,939 --> 01:33:35,560
la edad, y esa misma jugada si la hacemos

1098
01:33:35,560 --> 01:33:44,979
en lugar de para una variable de tipo clase

1099
01:33:44,979 --> 01:33:48,560
alumno, es decir, un objeto de la clase alumno

1100
01:33:48,560 --> 01:33:51,359
que era Sandra, lo hacemos para otro que hemos definido con anterioridad

1101
01:33:51,359 --> 01:33:56,579
aquí, que lo llamábamos Mial, pues al ejecutar

1102
01:33:56,579 --> 01:34:02,140
fijaros como la posición de memoria

1103
01:34:02,140 --> 01:34:05,000
que tenemos para Sandra es una, que nos da

1104
01:34:05,000 --> 01:34:08,079
el sistema operativo, y la que tenemos para Mial es otra

1105
01:34:08,079 --> 01:34:11,119
y luego sus datos, bueno, pues son diferentes, es decir

1106
01:34:11,119 --> 01:34:14,060
un comportamiento, como es lógico

1107
01:34:14,060 --> 01:34:17,220
al ser variables distintas, diferente a la hora de mostrarlo

1108
01:34:17,220 --> 01:34:22,460
por pantalla y los espacios de memoria que ha utilizado el programa para guardar uno y otro

1109
01:34:22,460 --> 01:34:27,579
diferentes de la misma forma que había sucedido aquí con los enteros, que cuando enseñábamos sí

1110
01:34:27,579 --> 01:34:46,699
mostraba 20, cuando enseñábamos sí 2 mostraba 10. ¿Se entiende más o menos? Variables, referencias,

1111
01:34:46,840 --> 01:34:50,880
objetos, estoy haciendo un repaso de las cosas que tengo por aquí, variables locales y variables

1112
01:34:50,880 --> 01:34:54,140
en miembro, también hemos hablado un poco, el alcance de las variables.

1113
01:34:55,619 --> 01:34:59,119
Las variables de tipo

1114
01:34:59,119 --> 01:35:02,840
primitivo, dependiendo si son variables

1115
01:35:02,840 --> 01:35:06,880
locales o son variables de clase, es necesario inicializarlas

1116
01:35:06,880 --> 01:35:10,340
o no, antes de utilizarlas. Las variables locales

1117
01:35:10,340 --> 01:35:14,880
es necesario inicializarlas, las variables de clase no. Y si no las

1118
01:35:14,880 --> 01:35:18,800
inicializamos, ¿qué valor tienen al principio? Pues hay una serie de valores por

1119
01:35:18,800 --> 01:35:29,840
defecto las variables numéricas me da igual que tengan decimales o no tienen como valor cero su

1120
01:35:29,840 --> 01:35:35,359
valor inicial si no le damos un valor por defecto inicial escoger el de por defecto que es cero si

1121
01:35:35,359 --> 01:35:40,460
tú quieres que una variable inicialmente tenga un valor distinto de cero obligatoriamente se

1122
01:35:40,460 --> 01:35:49,720
lo tienes que dar igual que estamos haciendo aquí las las variables tipo cadena de caracteres

1123
01:35:49,720 --> 01:35:52,399
es decir las string

1124
01:35:52,399 --> 01:35:55,500
tienen comillas comillas

1125
01:35:55,500 --> 01:35:57,340
es decir tienen una cadena de caracteres vacía

1126
01:35:57,340 --> 01:35:58,420
sin ningún dato

1127
01:35:58,420 --> 01:36:01,359
las variables booleanas

1128
01:36:01,359 --> 01:36:05,340
estas variables son las que

1129
01:36:05,340 --> 01:36:07,899
sus dos alternativas

1130
01:36:07,899 --> 01:36:09,000
son verdadero o falso

1131
01:36:09,000 --> 01:36:11,659
el verdadero o falso se utiliza mucho

1132
01:36:11,659 --> 01:36:13,340
luego en las condiciones

1133
01:36:13,340 --> 01:36:15,319
y en los bucles que iremos viendo

1134
01:36:15,319 --> 01:36:17,739
en las próximas tutorías y en los próximos

1135
01:36:17,739 --> 01:36:19,579
temas, por defecto

1136
01:36:19,579 --> 01:36:22,779
tiene false, es decir, si tú defines una variable booleana

1137
01:36:22,779 --> 01:36:25,560
y de inicio no le das un valor, pues esa variable va a

1138
01:36:25,560 --> 01:36:30,159
valer falso, y bueno, y ya está

1139
01:36:30,159 --> 01:36:32,880
estos son los valores que hay por defecto

1140
01:36:32,880 --> 01:36:35,939
otra cosa de la que hemos hablado también han sido los comentarios

1141
01:36:35,939 --> 01:36:39,180
en Java, los ponemos para una línea

1142
01:36:39,180 --> 01:36:42,239
bueno, para lo que hay a partir de las dos

1143
01:36:42,239 --> 01:36:45,260
barras en una línea, son comentarios, entonces si la ponemos

1144
01:36:45,260 --> 01:36:48,359
al principio de la línea, toda la línea es un comentario, es típico

1145
01:36:48,359 --> 01:36:52,560
poner ciertos comentarios en los programas, sobre todo en zonas de código que son un poco

1146
01:36:52,560 --> 01:36:56,479
difíciles de interpretar, pues nos ponemos unas pistas por si luego

1147
01:36:56,479 --> 01:37:00,359
repasamos el código o tenemos que hacerle un mantenimiento, saber un poco de qué va

1148
01:37:00,359 --> 01:37:04,680
lo que hicimos ahí, cuando hicimos ese código. Y si lo ponemos en una

1149
01:37:04,680 --> 01:37:08,859
línea, puede ser que haya código anteriormente y a partir

1150
01:37:08,859 --> 01:37:12,539
de un determinado momento poner un comentario. Entonces lo que hay a partir de aquí es

1151
01:37:12,539 --> 01:37:15,920
un comentario y en este caso sería la línea entera.

1152
01:37:15,920 --> 01:37:18,939
y si lo que queremos es comentarios multiliña

1153
01:37:18,939 --> 01:37:21,760
ya hemos dicho que el compilador de Java

1154
01:37:21,760 --> 01:37:24,520
considera comentarios multiliña lo que se encuentre

1155
01:37:24,520 --> 01:37:27,840
entre la barra y el asterisco

1156
01:37:27,840 --> 01:37:30,979
y asterisco y barra, todo lo que pongamos aquí, ya veis que el id

1157
01:37:30,979 --> 01:37:34,020
me lo muestra en verde, quiere decir que son comentarios

1158
01:37:34,020 --> 01:37:36,600
no lo va a tener en cuenta el compilador, cuando

1159
01:37:36,600 --> 01:37:39,579
el compilador coja el punto Java y genera el bytecode

1160
01:37:39,579 --> 01:37:42,699
todo esto será como que lo borra y como si no existiera

1161
01:37:42,699 --> 01:37:45,819
no le interesa para generar bytecode que luego

1162
01:37:45,819 --> 01:37:55,859
sea ejecutable. Otra cosa que también es

1163
01:37:55,859 --> 01:38:00,000
que podemos comentar aquí que es rápida ya que no nos queda

1164
01:38:00,000 --> 01:38:03,899
mucho tiempo es las constantes. Hay variables

1165
01:38:03,899 --> 01:38:08,279
que irán, normalmente una variable reserva una zona de memoria

1166
01:38:08,279 --> 01:38:11,140
y podremos ir cambiando su valor. Aquí i vale 20

1167
01:38:11,140 --> 01:38:14,579
pues aquí decimos que a partir de aquí i vale la 30.

1168
01:38:15,239 --> 01:38:20,279
En la zona de memoria RAM, en la 80.000 pasará su valor de 20 a 30

1169
01:38:20,279 --> 01:38:23,060
y a partir de ahora, cuando queramos acceder ahí,

1170
01:38:23,840 --> 01:38:25,859
pues nos mostrará el valor que justo tenga la RAM,

1171
01:38:25,979 --> 01:38:27,739
que si se ha ido sobreescribiendo será el nuevo.

1172
01:38:29,829 --> 01:38:31,890
En Java podemos definir constantes.

1173
01:38:32,029 --> 01:38:34,310
Una constante no es más que una variable,

1174
01:38:35,729 --> 01:38:37,890
la definimos de partida como una variable,

1175
01:38:38,069 --> 01:38:41,289
con lo cual hará la reserva en memoria RAM para guardar su valor,

1176
01:38:42,029 --> 01:38:44,310
pero al ponerle la etiqueta final,

1177
01:38:45,609 --> 01:38:47,590
pues ya no podremos modificarla.

1178
01:38:49,329 --> 01:38:51,649
No sé si como variable local me deja.

1179
01:38:51,850 --> 01:39:04,369
Sí, pues fijaros, si le ponemos la etiqueta final, si ahora yo intento cambiar el valor de pi aquí, digo que no, que ya pi me gusta más como 3.15, ¿veis? No me deja.

1180
01:39:05,229 --> 01:39:13,430
Y si le quito la etiqueta final, pues como es una variable normal, podría cambiar su valor como cualquier variable de un valor que tiene ahora mismo a otro diferente.

1181
01:39:14,210 --> 01:39:17,850
Entonces, si a una variable le ponemos la etiqueta final, se convierte en una constante.

1182
01:39:18,829 --> 01:39:19,750
¿Para qué nos sirve?

1183
01:39:19,850 --> 01:39:23,010
Bueno, pues nos sirve para ir utilizándola

1184
01:39:23,010 --> 01:39:25,630
como parte de las operaciones,

1185
01:39:25,850 --> 01:39:27,170
pero no ir modificando su valor.

1186
01:39:27,550 --> 01:39:28,229
Es una constante.

1187
01:39:30,279 --> 01:39:31,520
Y es con la etiqueta final.

1188
01:39:33,819 --> 01:39:34,920
Normalmente las...

1189
01:39:35,779 --> 01:39:38,960
Fijaros, aquí hemos puesto pi minúscula

1190
01:39:38,960 --> 01:39:40,840
cuando hay un convenio

1191
01:39:40,840 --> 01:39:45,720
que se suele seguir a la hora de programar en Java,

1192
01:39:45,859 --> 01:39:47,220
que no es obligado para el compilador,

1193
01:39:48,119 --> 01:39:49,399
pero que si lo seguimos todos

1194
01:39:49,399 --> 01:39:52,159
es de buenas prácticas y así cuando vayamos

1195
01:39:52,159 --> 01:39:54,199
encontrando diferentes personas códigos

1196
01:39:54,199 --> 01:39:56,220
si todos hemos seguido los mismos

1197
01:39:56,220 --> 01:39:58,300
criterios, pues nos resultará

1198
01:39:58,300 --> 01:40:00,579
un poco más fácil mantenerlo

1199
01:40:00,579 --> 01:40:02,460
entonces las constantes

1200
01:40:02,460 --> 01:40:04,300
se suelen definir con letras

1201
01:40:04,300 --> 01:40:06,239
mayúsculas todas, entonces si vamos

1202
01:40:06,239 --> 01:40:07,760
a definir una constante ponemos pi

1203
01:40:07,760 --> 01:40:10,439
y si tiene varios valores

1204
01:40:10,439 --> 01:40:12,000
imaginaros que

1205
01:40:12,000 --> 01:40:14,000
queremos definir una constante

1206
01:40:14,000 --> 01:40:16,159
que tiene el número

1207
01:40:16,159 --> 01:40:18,479
máximo de espectadores que pueden entrar en un estadio

1208
01:40:18,479 --> 01:40:22,539
sería num y si lo queremos poner con dos palabras

1209
01:40:22,539 --> 01:40:26,340
num más, aquí lo definimos como

1210
01:40:26,340 --> 01:40:30,359
final de tipo entero y

1211
01:40:30,359 --> 01:40:32,880
el número máximo de espectadores serían 50.000

1212
01:40:32,880 --> 01:40:38,560
y la forma de nombrar la constante con mayúsculas

1213
01:40:38,560 --> 01:40:42,539
y si está formada por varias palabras con un guión bajo

1214
01:40:42,539 --> 01:40:49,310
las variables normalmente el convenio

1215
01:40:49,310 --> 01:40:59,909
que hay es que empiecen por una letra minúscula y si tienen varias varias palabras que cada una

1216
01:40:59,909 --> 01:41:06,149
de las palabras empiece con letra mayúscula entonces imaginaos que te definimos un int y

1217
01:41:06,149 --> 01:41:12,569
queremos es número de entradas pues una forma sería ponerlo así en un número o num entradas

1218
01:41:12,569 --> 01:41:19,850
o entrada entradas entonces esto sería siguiendo un convenio muy utilizado una forma de definir

1219
01:41:19,850 --> 01:41:25,609
una variable la primera letra minúscula y luego cada una de las nuevas palabras que formasen

1220
01:41:25,609 --> 01:41:33,359
parte de esa variable entradas yo tengo costumbre ya lo ir viendo cuando voy haciendo los programas

1221
01:41:33,359 --> 01:41:39,420
que no es obligado ni mucho menos de poner una primera letra aquí en minúscula para seguir este

1222
01:41:39,420 --> 01:41:45,899
criterio con el que más o menos me dé una idea si luego veo y edad por ahí en mitad del código

1223
01:41:45,899 --> 01:41:49,699
de qué tipo es entonces si empieza por una y pues sé que es una variable de tipo entero si empieza

1224
01:41:49,699 --> 01:41:56,739
por una s de tipo string en cierto momento estuve trabajando una empresa que seguía en esta

1225
01:41:56,739 --> 01:42:01,020
nomenclatura y ahí se me quedó y siempre me salen las variables de esta forma pero esto es un

1226
01:42:01,020 --> 01:42:07,100
criterio más particular mío o del contexto es en el que trabajé yo que el que es de verdad está como

1227
01:42:07,100 --> 01:42:11,960
muy aceptado que es este otro no necesariamente identificar el tipo pero sin minúsculas y

1228
01:42:11,960 --> 01:42:17,720
siguientes letras con mayúsculas las clases

1229
01:42:17,720 --> 01:42:23,739
la empiezan con una letra mayúscula aquí alumno lo tengo correcto y los métodos

1230
01:42:23,739 --> 01:42:27,500
empiezan con letra minúscula que yo lo he hecho mal aquí vale no seguido el

1231
01:42:27,500 --> 01:42:33,380
convenio sería trigo con té minúscula saluda saludo con saludar con ese

1232
01:42:33,380 --> 01:42:38,199
minúscula y despedir con de minúscula

1233
01:42:38,199 --> 01:42:43,100
No lo he hecho de acuerdo al criterio de buenas prácticas, el nombre de los métodos.

1234
01:42:43,560 --> 01:42:52,039
Pero bueno, ya veis que antes puse pi aquí como constante con minúsculas y el compilador le vale.

1235
01:42:52,239 --> 01:42:54,220
Esto también está de esta forma y le vale.

1236
01:42:54,500 --> 01:43:00,119
Con lo cual, bueno, pues está bien seguirlo, pero no va a bloquear los programas el no utilizarlos así.

1237
01:43:04,550 --> 01:43:08,369
Y bueno, pues de mi guión de aquí, de cosas que os quería contar relacionadas con el tema 2,

1238
01:43:08,369 --> 01:43:10,369
he tachado unos cuantos y la

1239
01:43:10,369 --> 01:43:12,609
semana siguiente yo creo que continuamos

1240
01:43:12,609 --> 01:43:14,289
con otros pocos. Nos quedan

1241
01:43:14,289 --> 01:43:15,550
cinco minutos para cerrar

1242
01:43:15,550 --> 01:43:18,270
y bueno, aprovecho por si queréis

1243
01:43:18,270 --> 01:43:20,109
hacerme alguna pregunta o alguna

1244
01:43:20,109 --> 01:43:22,590
o alguna

1245
01:43:22,590 --> 01:43:24,510
sugerencia un poco desesperada de la clase

1246
01:43:24,510 --> 01:43:25,989
ahí con la memoria y eso, si

1247
01:43:25,989 --> 01:43:27,829
os ha costado mucho seguirlo.

1248
01:43:28,550 --> 01:43:30,289
Esto de la memoria hablaremos mucho de ello, entonces

1249
01:43:30,289 --> 01:43:32,590
no os preocupéis, pero sí que es importante entenderlo.

1250
01:43:45,289 --> 01:43:45,729
Ya, claro.

1251
01:43:48,520 --> 01:43:49,260
Claro, si

1252
01:43:49,260 --> 01:43:51,979
tienen letras, pues

1253
01:43:51,979 --> 01:43:56,899
El significado que tiene el símbolo de más es concatenar, unir unos con otros.

1254
01:43:57,539 --> 01:43:59,300
Si tienes números, lo que te hace es sumar.

1255
01:44:02,100 --> 01:44:07,220
Sobrecarga de operador, es decir, el operador se comporta de diferentes formas según lo que tenga por ahí alrededor.

1256
01:44:14,220 --> 01:44:15,619
¿Alguna otra cosilla por ahí?

1257
01:44:21,350 --> 01:44:26,869
De las clases, bueno, pues un poco lo que vengo haciendo, este es el tercer año que doy distancia

1258
01:44:26,869 --> 01:44:29,170
y un poco las organizamos

1259
01:44:29,170 --> 01:44:30,609
siempre así, estamos

1260
01:44:30,609 --> 01:44:33,010
pues os pregunto si tenéis dudas, intentamos

1261
01:44:33,010 --> 01:44:35,029
aclararlas o ponernos sobre la

1262
01:44:35,029 --> 01:44:36,229
pista de alguna duda que tengáis

1263
01:44:36,229 --> 01:44:38,270
y luego os voy contando cosas

1264
01:44:38,270 --> 01:44:40,670
si en un momento dado veis

1265
01:44:40,670 --> 01:44:42,829
no sé, que alguna

1266
01:44:42,829 --> 01:44:44,770
otra técnica creéis que va a resultar

1267
01:44:44,770 --> 01:44:46,649
más provechosa, me decís, yo no tengo

1268
01:44:46,649 --> 01:44:48,649
inconveniente y si hay alguna cosa en particular

1269
01:44:48,649 --> 01:44:50,670
que queráis que tratemos en

1270
01:44:50,670 --> 01:44:52,850
alguna reunión, si la adelantáis

1271
01:44:52,850 --> 01:44:54,829
en los foros, pues siempre está bien, no va a ser

1272
01:44:54,829 --> 01:44:58,750
que me preguntéis algo durante la tutoría

1273
01:44:58,750 --> 01:45:00,710
que en ese momento no sea capaz de resolveros.

1274
01:45:01,130 --> 01:45:04,770
Si me la comentáis con anterioridad, pues la preparo yo un poquillo.

1275
01:45:05,930 --> 01:45:07,750
Y si no, pues bueno, yo siempre vendré con un guión

1276
01:45:07,750 --> 01:45:09,770
para contaros alguna peli por ahí.

1277
01:45:16,470 --> 01:45:17,869
¿Alguna otra cosa? Sí.

1278
01:45:28,210 --> 01:45:28,949
Sí, sí, sí.

1279
01:45:30,829 --> 01:45:33,590
Tenéis bastantes ejercicios para hacer.

1280
01:45:34,409 --> 01:45:37,630
Ahora ya veréis ya en el tema 2, ya hay colecciones de ejercicios

1281
01:45:37,630 --> 01:45:39,890
por ahí un poco relacionados con el nivel

1282
01:45:39,890 --> 01:45:41,149
del tema que vamos viendo

1283
01:45:41,149 --> 01:45:43,810
para que podáis practicar. Están resueltos

1284
01:45:43,810 --> 01:45:44,930
en líneas generales todos

1285
01:45:44,930 --> 01:45:47,329
pero bueno, pues está bien

1286
01:45:47,329 --> 01:45:49,550
que los intentéis hacer vosotros antes de

1287
01:45:49,550 --> 01:45:50,689
mirar las soluciones

1288
01:45:50,689 --> 01:45:52,850
para entrenaros programando

1289
01:45:52,850 --> 01:45:55,270
que ya os comentaba días atrás

1290
01:45:55,270 --> 01:45:57,430
que si no le echas

1291
01:45:57,430 --> 01:45:58,630
ratos ahí programando

1292
01:45:58,630 --> 01:46:01,430
viendo el código solo, luego no te sale

1293
01:46:01,430 --> 01:46:02,770
pero sí, sí, hay

1294
01:46:02,770 --> 01:46:05,569
muchos ejercicios propuestos

1295
01:46:05,569 --> 01:46:07,289
y bueno, si queréis

1296
01:46:07,289 --> 01:46:10,270
vosotros investigar más, supongo que habréis

1297
01:46:10,270 --> 01:46:13,109
hecho alguna búsqueda por internet, te salen miles, pero vamos

1298
01:46:13,109 --> 01:46:16,109
también dentro de nuestro curso también ofrecemos enunciados

1299
01:46:16,109 --> 01:46:18,270
de ejercicios y estos ejercicios resueltos

1300
01:46:18,270 --> 01:46:28,770
bueno, pues nada, si no tenéis nada más voy a ir deteniendo

1301
01:46:28,770 --> 01:46:36,100
dime, si en

1302
01:46:36,100 --> 01:46:37,939
mira, un momentito

1303
01:46:37,939 --> 01:46:41,380
te pide contraseña, voy a poner la misma en todas

1304
01:46:41,380 --> 01:46:45,079
las clases, mira

1305
01:46:45,079 --> 01:46:47,199
aquí justo que está el enlace, aquí

1306
01:46:47,199 --> 01:46:49,560
os he puesto enlace a la contraseña

1307
01:46:49,560 --> 01:46:51,640
y le pongo PROC 2024 a todas

1308
01:46:51,640 --> 01:46:53,600
ellas. Entonces, os iré

1309
01:46:53,600 --> 01:46:55,800
poniendo enlaces a cada una de las tutorías

1310
01:46:55,800 --> 01:46:57,619
y en todas le pongo la misma

1311
01:46:57,619 --> 01:46:59,640
contraseña para que no

1312
01:46:59,640 --> 01:47:01,579
os volváis locos. Y además lo tenéis aquí

1313
01:47:01,579 --> 01:47:03,800
chivado justo al lado de los enlaces.

1314
01:47:06,460 --> 01:47:06,600
Sí.

1315
01:47:10,220 --> 01:47:11,720
Bueno, pues nada.