1
00:00:00,000 --> 00:00:07,719
grabando lo que decía que el mañana comenzamos un nuevo tema y es un tema introductorio a la

2
00:00:07,719 --> 00:00:13,339
programación orientada objetos entonces formalmente se habla de lo que ya bien más de lo que es una

3
00:00:13,339 --> 00:00:20,160
clase de lo que es un objeto en ese tema hablaremos de los métodos hablaremos de los atributos

4
00:00:21,480 --> 00:00:27,219
y en realidad desde el día cero pues hemos estado hablando de todo esto porque estos primeros temas

5
00:00:27,219 --> 00:00:31,539
por ejemplo el tema en el que estamos ahora estructurar de control si hablamos de un for

6
00:00:31,539 --> 00:00:37,979
y de forma aislada casi es imposible cuando estás haciendo el programa evitar hablar de que va metido

7
00:00:37,979 --> 00:00:42,939
en una clase y ya que decimos que ante una clase hablar un poquito de que va y que está dentro de

8
00:00:42,939 --> 00:00:47,740
un método con lo cual desde el día cero ya estamos hablando de todos estos conceptos bueno pues

9
00:00:47,740 --> 00:00:55,219
formalmente volvemos a repasarlos y profundizaremos algo más ya en este nuevo tema hoy bueno vamos a

10
00:00:55,219 --> 00:01:01,460
a terminar de hablar un poquito de bucles y haremos algún ejercicio no sé si nos da si no

11
00:01:01,460 --> 00:01:06,579
tenéis dudas para mucho ya los contenidos que tenemos abiertos pero bueno echaremos un rato

12
00:01:06,579 --> 00:01:15,400
hasta que hasta que se nos acabe la gasolina digamos mirad en lo que hay en la cuenta no sé

13
00:01:15,400 --> 00:01:21,379
si insistir suficientemente en las estructuras de control de repetición la clase anterior bueno

14
00:01:21,379 --> 00:01:47,719
Decíamos, por ejemplo, en el for que teníamos estos tres elementos por aquí, que venía a ser inicialización de variables, aquí la condición en un segundo campo dentro de los paréntesis del for y luego aquí teníamos normalmente la evolución de la variable que comparamos aquí y que nos permite esta evolución garantizar que el bucle no es infinito, sino que termina en algún momento.

15
00:01:47,719 --> 00:02:17,909
pero en realidad en esta estructura podemos poner casi cualquier cosa, aquí va una instrucción de código que podríamos poner lo que fuese, de hecho aquí estamos poniendo una instrucción en la cual estamos incrementando ahí, pero podría ser, no sé, podríamos poner aquí probablemente, yo creo que nos dejaría un system out, vamos a ver, println por ejemplo, de i++,

16
00:02:17,909 --> 00:02:19,830
fijaros como esto compila

17
00:02:19,830 --> 00:02:21,689
durante la ejecución

18
00:02:21,689 --> 00:02:24,349
cada vuelta en el bucle hará esto

19
00:02:24,349 --> 00:02:26,210
y también hará esto

20
00:02:26,210 --> 00:02:27,409
igual que si lo pusiéramos

21
00:02:27,409 --> 00:02:29,469
fuera de un

22
00:02:29,469 --> 00:02:32,289
como una instrucción cualquiera

23
00:02:32,289 --> 00:02:34,789
entonces vamos a hacer una ejecución

24
00:02:34,789 --> 00:02:36,669
de esto

25
00:02:36,669 --> 00:02:40,129
fijaros como

26
00:02:40,129 --> 00:02:42,129
aquí nos va mostrando

27
00:02:42,129 --> 00:02:43,889
esto justo es el

28
00:02:43,889 --> 00:02:46,270
consecuencia de esta instrucción

29
00:02:46,270 --> 00:02:46,750
que hay aquí

30
00:02:46,750 --> 00:03:17,110
Lo que quiero decir es que aquí podemos tener cualquier instrucción, si tenemos un método dentro de la clase que sea el método saludar, por ejemplo, poner public void saludar, que nos diga system.out.println un saludo, pues aquí podríamos llamar también al método saludar.

31
00:03:17,110 --> 00:03:37,580
podríamos hacer una llamada al método saludar a ver qué es lo que pasa aquí pues éste no le gusta

32
00:03:38,719 --> 00:03:57,669
a ver qué nos dice dice que no estamos en un tricat vamos a definirlo estático estático como

33
00:03:57,669 --> 00:04:03,270
estático así que nos deja necesitamos un objeto para ejecutar este vale bueno luego os cuento

34
00:04:03,270 --> 00:04:08,289
un poco el tema del static ya hemos hablado de él en algún momento si acaso os cuento luego un

35
00:04:08,289 --> 00:04:13,530
poquillo de bueno fijaros como hemos hecho una llamada aquí a un método entonces en cada vuelta

36
00:04:13,530 --> 00:04:19,269
aquí lo que podemos poner es código bueno llamará cada vez a saludar es cierto que en este caso como

37
00:04:19,269 --> 00:04:24,990
hemos dejado de incrementar aquí pues resulta que esto se va a convertir en un bucle infinito si no

38
00:04:24,990 --> 00:04:30,009
modificamos el valor de y en ningún sitio continuamente valdrá cero y todo el rato se

39
00:04:30,009 --> 00:04:36,050
igual será menor que la longitud de la raíz entonces fijaros el y en realidad que aprovechamos

40
00:04:36,050 --> 00:04:40,670
la estructura del for para ir incrementando lo habitualmente aquí pues lo podemos incrementar

41
00:04:40,670 --> 00:04:47,790
aquí entonces en cada vuelta y incrementará y es cierto que aquí no lo estamos incrementando pero

42
00:04:47,790 --> 00:04:53,910
sí que llegará a cumplir la condición en la que sea ella al menos igual que la longitud de la

43
00:04:53,910 --> 00:05:00,470
raíz y termine de ejecutar el bucle decidamos aquí fijaros como cada vez nos llama al método

44
00:05:00,470 --> 00:05:08,209
un saludo definitiva que aquí podemos poner código el que toque y normalmente está pensado en el for

45
00:05:08,209 --> 00:05:16,680
para trabajar sobre la variable que nos sacará en un momento dado del bucle para que no se convierta

46
00:05:16,680 --> 00:05:24,639
en infinito pero no es obligatorio aquí fijaros podríamos poner mirad podríamos poner aquí una

47
00:05:24,639 --> 00:05:34,439
variable de tipo entero también j que sea igual a cero y aquí utilizar en realidad j

48
00:05:34,439 --> 00:05:40,300
es también me compila fijaros que la variable que inicial hizo aquí es una variable y que a

49
00:05:40,300 --> 00:05:46,879
lo mejor la puede utilizar dentro del ford para alguna otra cosa y sobre la que realmente busco

50
00:05:46,879 --> 00:05:58,439
la condición para salirme sobre j les podría poner aquí jota más más expulsamos aquí y fijaros tiene

51
00:05:58,439 --> 00:06:02,459
ese comportamiento. Ahora va iterando mientras j sea menor que la longitud

52
00:06:02,459 --> 00:06:04,920
de la raíz y el sitio donde incrementamos j es aquí.

53
00:06:06,279 --> 00:06:10,379
Lo que estoy haciendo es cambiar un poco el uso que tenemos

54
00:06:10,379 --> 00:06:14,439
pensado de estos tres campos, que la verdad, su idea, tal como dice

55
00:06:14,439 --> 00:06:18,319
la teoría, es definir la variable con la que trabajamos

56
00:06:18,319 --> 00:06:22,459
principalmente para ir comparando aquí y luego ir manejándola

57
00:06:22,459 --> 00:06:26,639
aquí, pero no necesariamente es así. Se traga prácticamente for cualquier cosa

58
00:06:26,639 --> 00:06:36,639
en tanto en cuanto, esto sean instrucciones, en tanto en cuanto aquí trabajamos para inicializar una primera vez ciertas variables que a lo mejor nos interesen por aquí

59
00:06:36,639 --> 00:06:40,420
y no obligatoriamente tengan que ser la que utilizamos aquí en la condición.

60
00:06:42,279 --> 00:06:55,199
Y luego el ejercicio más típico, pues ya os digo, es poner aquí un i++ y si queremos recorrer, por ejemplo, todos los elementos de un array, ir uno a uno,

61
00:06:55,199 --> 00:07:00,240
incrementando y más más pero podría ser que quisiéramos mostrar con un bucle todos los

62
00:07:00,240 --> 00:07:08,199
valores pares pues que podríamos hacer aquí es decir igual a cero mientras si se amen parece

63
00:07:08,199 --> 00:07:15,800
entre cero vamos a suponer entre 0 y 5 y 30 y 20 porque no nos hagan tantos números pues este

64
00:07:15,800 --> 00:07:22,199
bucle lo que nos haría aquí es seguir incrementando y de uno en uno aquí podríamos hacer para comprobar

65
00:07:22,199 --> 00:07:32,730
si es par, un if. Imaginaos que lo que buscamos es que sea par, es decir, mientras i hacemos un tanto por ciento

66
00:07:32,730 --> 00:07:40,329
el módulo de la división. Fijaros, esto no me compila porque el if aquí espera algo que se pueda evaluar

67
00:07:40,329 --> 00:07:47,129
como verdadero o falso. Realmente el i tanto por ciento dos me va a devolver un número, que será un cero o un uno,

68
00:07:47,129 --> 00:08:03,470
Es decir, no es verdadero o falso. Para comprobarlo, podríamos poner aquí que sea cero, y ahora ya sí que me compila porque esta comparación valdrá cero o uno, pero si es igual a cero me devolverá true, si es distinto de cero, falso.

69
00:08:03,470 --> 00:08:06,930
Es decir, ya lo del if sí que se puede evaluar como un verdadero o falso.

70
00:08:07,769 --> 00:08:13,149
Entonces ponemos aquí un system.out.println de i.

71
00:08:15,449 --> 00:08:18,350
Entonces esta ejecución, fijaros que este código,

72
00:08:19,829 --> 00:08:29,649
me ha resultado ser un bucle infinito y fijaros que no terminaba nunca

73
00:08:29,649 --> 00:08:33,889
porque aquí mantenía la j como condición para salirse del bucle.

74
00:08:33,889 --> 00:08:38,490
Entonces j siempre era menor que 20 porque lo habíamos inicializado aquí a 0

75
00:08:38,490 --> 00:08:41,870
y no modificábamos su valor, tendría que ser aquí una i

76
00:08:41,870 --> 00:08:44,610
entonces damos de nuevo a la ejecución

77
00:08:44,610 --> 00:08:48,009
y efectivamente me muestra los números pares

78
00:08:48,009 --> 00:08:52,710
habrá entrado tantas veces

79
00:08:52,710 --> 00:08:56,049
habrá entrado 20 veces porque estamos haciendo el incremento de i

80
00:08:56,049 --> 00:08:59,169
de uno en uno, pero solamente escribe aquellos que sean pares

81
00:08:59,169 --> 00:09:01,690
que son los que cumplen la condición de

82
00:09:01,690 --> 00:09:04,230
validar si es par el número aquí o no

83
00:09:04,230 --> 00:09:07,470
pero fijaros en este caso lo que podríamos haber hecho

84
00:09:07,470 --> 00:09:13,230
en lugar de este código, que efectivamente responde a lo que nosotros buscamos en el enunciado,

85
00:09:13,889 --> 00:09:17,990
lo que podríamos haber hecho es, sabemos que vamos a entrar con i igual a 0,

86
00:09:18,210 --> 00:09:21,870
que lo estamos considerando como un número par, ¿verdad? Porque de hecho lo es.

87
00:09:22,450 --> 00:09:27,970
Y el siguiente que tiene que mostrar es el 2 y el siguiente el 4, es decir, vamos dando saltos de 2 en 2.

88
00:09:28,110 --> 00:09:30,549
Entonces aquí podríamos poner 1 y más 2.

89
00:09:35,080 --> 00:09:39,700
Entonces i, una vez que ejecuta cada uno de los bucles, lo que hace es sumarle 2

90
00:09:39,700 --> 00:09:41,500
y ahora no hacemos ninguna comprobación

91
00:09:41,500 --> 00:09:43,240
aquí, sino que mostramos directamente i.

92
00:09:44,500 --> 00:09:45,279
Ya los números

93
00:09:45,279 --> 00:09:45,879
impares,

94
00:09:46,980 --> 00:09:49,379
para números impares no entraría aquí en el

95
00:09:49,379 --> 00:09:51,580
for. Iría incrementando

96
00:09:51,580 --> 00:09:53,240
de dos en dos. Entonces si damos aquí,

97
00:09:54,759 --> 00:09:55,039
ahora,

98
00:09:55,500 --> 00:09:57,399
efectivamente, nos ha mostrado los números pares

99
00:09:57,399 --> 00:09:59,360
porque hemos ido dando saltos de dos

100
00:09:59,360 --> 00:10:01,360
en dos aquí, en el incremento

101
00:10:01,360 --> 00:10:04,809
de i. ¿Dónde quiero ir a parar?

102
00:10:04,950 --> 00:10:06,950
Pues que aquí trabajaremos con

103
00:10:06,950 --> 00:10:10,700
la instrucción que nos interese en un momento dado.

104
00:10:11,039 --> 00:10:12,879
Imaginaos que...

105
00:10:13,220 --> 00:10:24,379
Que bueno, que en el algoritmo que pongamos por aquí, lo que tenga que pasar durante el código, puede resultar que el valor de i lo queramos modificar por algún motivo.

106
00:10:24,799 --> 00:10:34,279
Entonces podría ser que además de esta instrucción que va modificándome i, pues coger y decir que i lo incrementamos aquí.

107
00:10:34,279 --> 00:10:36,700
vamos a hacer un supuesto

108
00:10:36,700 --> 00:10:38,820
o sea, en este caso

109
00:10:38,820 --> 00:10:40,620
lo que he hecho ha sido modificar que no sea

110
00:10:40,620 --> 00:10:42,200
necesariamente el incremento de 1 en 1

111
00:10:42,200 --> 00:10:44,759
aquí podemos trabajar con cualquier operación

112
00:10:44,759 --> 00:10:45,960
para ir actuando sobre i

113
00:10:45,960 --> 00:10:48,600
y aquí lo que quiero enseñar es que

114
00:10:48,600 --> 00:10:50,620
no necesariamente los cambios de la

115
00:10:50,620 --> 00:10:52,259
variable sobre la que trabajamos aquí

116
00:10:52,259 --> 00:10:54,639
igual que nos ha pasado antes cuando hemos definido j

117
00:10:54,639 --> 00:10:57,039
los podemos también ir manipulando

118
00:10:57,039 --> 00:10:57,340
aquí

119
00:10:57,340 --> 00:11:00,580
entonces aquí i se modificará

120
00:11:00,580 --> 00:11:01,639
tanto aquí como aquí

121
00:11:01,639 --> 00:11:12,840
Y al definirlo como un parámetro de la etiqueta for, de la instrucción for, actúa como una variable local para el ámbito del for.

122
00:11:13,419 --> 00:11:21,720
Entonces existe aquí, aquí se inicializa, por aquí se modifica, aquí dentro del for está disponible y también podemos ir actualizándola.

123
00:11:21,720 --> 00:11:33,600
Entonces en este caso iremos con i de 3 en 3, 1, 4, 7, 10, 13, porque 2 se están incrementando aquí, y en cada iteración 1 más aquí.

124
00:11:35,159 --> 00:11:48,340
Vamos a suponer que nos dicen, mete 5 números, se introduce por teclado, 5 números entre el 1 y el 10, por ejemplo.

125
00:11:48,340 --> 00:12:00,720
Entonces podríamos decir, mira, lo que quiero es meter cinco números, hacemos aquí el for, quiero cinco, con lo cual voy a hacer un i++, y quiero que sean cinco números, sí o sí.

126
00:12:00,720 --> 00:12:30,289
Entonces, como es por teclado, recordad, podríamos coger aquí y definir una variable de tipo scanner, scanner, myscan, igual a new scanner, y aquí decir que lo enlazamos con system in, y esto lo vamos a importar desde las librerías de Java útil.

127
00:12:32,370 --> 00:12:34,889
Repasamos un momentito lo que hemos hecho aquí con esta instrucción.

128
00:12:36,779 --> 00:12:43,000
Decíamos que en Java tenemos flujos de datos que permiten comunicar nuestro programa con el mundo exterior.

129
00:12:43,299 --> 00:12:46,340
Es como si tuviéramos una tubería y un extremo de la tubería.

130
00:12:46,899 --> 00:12:51,799
En cualquier caso de los flujos de datos, un extremo de la tubería está pinchado en nuestro ordenador

131
00:12:51,799 --> 00:12:55,000
y el otro extremo lo queremos enchufar por ahí en algún sitio.

132
00:12:55,600 --> 00:13:02,120
En particular, el flujo de datos System.in, el otro extremo de la tubería donde está pinchado es el teclado.

133
00:13:02,120 --> 00:13:08,179
y nos permite desde teclado meter información dentro de nuestro programa.

134
00:13:09,440 --> 00:13:15,580
System.in no he tenido que hacer un import como si lo hemos hecho de escáner

135
00:13:15,580 --> 00:13:21,639
porque System.in está definido en el paquete Java, Java lang

136
00:13:21,639 --> 00:13:26,840
y todo lo que he definido en ese paquete se considera de tal importancia en los programas de Java

137
00:13:26,840 --> 00:13:31,039
o de uso tan común que directamente se importa de forma automática.

138
00:13:32,120 --> 00:13:50,080
Entonces, con System.in ya podríamos leer desde teclado. Y luego, también en los paquetes de Java, pues han hecho en otras librerías otros paquetes que tienen información quizás menos habitual, no me atrevería a decir menos importante, pero igual menos habitual que Java.lang.

139
00:13:50,080 --> 00:13:55,059
y por lo tanto se considera que no se van a utilizar en todos los programas.

140
00:13:55,480 --> 00:13:59,600
Y como es así, pues han dicho, pues directamente no se importa de forma automática

141
00:13:59,600 --> 00:14:05,039
y quien necesite cada cosa particular de cada uno de los paquetes, que se preocupe de importarlo.

142
00:14:05,039 --> 00:14:09,919
Y así no cargamos todos los programas con todas las clases de todos los paquetes

143
00:14:09,919 --> 00:14:12,759
que tenemos definidas en absolutamente todas nuestras librerías.

144
00:14:13,320 --> 00:14:18,940
Entonces, como Scanner no está definido en JavaLang, sino que está definido en la librería JavaUtil,

145
00:14:20,080 --> 00:14:24,000
nos importa de forma automática y si queremos utilizarlo tenemos al principio

146
00:14:24,000 --> 00:14:27,460
de nuestro programa que indicárselo en la cabecera con un import

147
00:14:27,460 --> 00:14:31,759
esto es importame desde la librería java útil

148
00:14:31,759 --> 00:14:36,120
la clase scanner y a partir de ese momento esta clase estará definida

149
00:14:36,120 --> 00:14:40,240
allí en aquella librería y bueno por suerte

150
00:14:40,240 --> 00:14:44,419
habrán hecho un montón de código que nos resulta

151
00:14:44,419 --> 00:14:48,220
a nosotros útil para ir llamándolo de forma fácil a través de sus métodos y sus

152
00:14:48,220 --> 00:14:52,320
parámetros. Entonces, la clase Scanner nos facilita

153
00:14:52,320 --> 00:14:56,159
un acceso más sencillo a flujos de datos, que no

154
00:14:56,159 --> 00:14:59,919
necesariamente tienen que ser SystemIn, podría ser el flujo de datos

155
00:14:59,919 --> 00:15:04,100
la entrada de nuestro programa de información desde un fichero particular, como lo que

156
00:15:04,100 --> 00:15:08,399
queremos ahora hacer es desde teclado, pues lo hacemos desde SystemIn. Y definimos

157
00:15:08,399 --> 00:15:11,279
un objeto para nuestro programa

158
00:15:11,279 --> 00:15:16,159
de la clase Scanner, igual que hemos hecho en otros casos, con el

159
00:15:16,159 --> 00:15:19,899
new, pedimos al sistema operativo que genere la estructura

160
00:15:19,899 --> 00:15:23,659
en memoria RAM necesaria para que este objeto sea capaz de funcionar

161
00:15:23,659 --> 00:15:28,580
y luego, siempre después del new, acordaros que os comentaba

162
00:15:28,580 --> 00:15:32,399
de esto hablaremos justo en el siguiente tema, lo volveremos a repasar

163
00:15:32,399 --> 00:15:35,440
llamamos a un método que se llama igual que la clase

164
00:15:35,440 --> 00:15:39,360
que son los métodos constructores que típicamente están pensados

165
00:15:39,360 --> 00:15:42,720
para inicializar el objeto que estamos dando de alta

166
00:15:43,600 --> 00:15:48,259
Primeras acciones que son necesarias para que ese objeto tenga el comportamiento que esperamos

167
00:15:48,259 --> 00:15:51,720
luego durante la ejecución de nuestro programa.

168
00:15:52,720 --> 00:15:58,019
En este caso, hará lo que esté programado en este método de la clase Scanner constructor

169
00:15:58,019 --> 00:16:03,919
y además le pasamos por aquí información como parámetro para que tenga en consideración Scanner

170
00:16:03,919 --> 00:16:08,220
que este objeto tiene que trabajar en particular con el flujo de datos Systeming

171
00:16:08,220 --> 00:16:09,720
que es entrada desde teclado.

172
00:16:09,720 --> 00:16:25,580
Bueno, un repasazo aquí a la línea esta por hablar un poco de terminología de Java y de la que hemos ido comentando y pegar un pequeño repaso. Una vez hecho esto, que la hemos importado desde esta librería, queremos utilizarla por aquí.

173
00:16:25,580 --> 00:16:43,080
Y estábamos planteándonos que el programa queríamos, a través de un bucle lo estábamos pensando, recoger cinco números enteros y que su información estuviera entre 0 y 10.

174
00:16:43,080 --> 00:17:08,720
era la condición que nos estábamos poniendo, entonces vamos a leer esa información desde aquí, entonces si yo pongo, digo aquí int string s info, aquí estoy definiendo una variable s info y digo s info igual a mi scan,

175
00:17:08,720 --> 00:17:12,480
estoy diciendo voy a utilizar algo del objeto

176
00:17:12,480 --> 00:17:15,500
en mi scan que voy a cargar en ese info y en particular lo que quiero

177
00:17:15,500 --> 00:17:20,380
hacer es leer una línea, next line, y esta

178
00:17:20,380 --> 00:17:23,299
información, bueno, pues podría, si voy a

179
00:17:23,299 --> 00:17:26,359
trabajar con la información por aquí como tipo de

180
00:17:26,359 --> 00:17:29,380
datos entero, pues podría hacer un parseInt, os acordáis

181
00:17:29,380 --> 00:17:32,720
integer parseInt para pasar una variable entero, como simplemente

182
00:17:32,720 --> 00:17:35,640
de momento lo voy a escribir en un system out, no lo voy a transformar

183
00:17:35,640 --> 00:17:38,259
directamente, me voy a quedar aunque sea un número

184
00:17:38,259 --> 00:17:40,680
bueno, sí, sí lo voy a transformar mejor

185
00:17:40,680 --> 00:17:42,359
para una condición que voy a hacer ahora

186
00:17:42,359 --> 00:17:44,200
entonces pongo int y val

187
00:17:44,200 --> 00:17:46,759
vamos a definir aquí una variable de tipo

188
00:17:46,759 --> 00:17:47,440
entero

189
00:17:47,440 --> 00:17:50,200
y voy a decir que i val

190
00:17:50,200 --> 00:17:51,759
sea igual

191
00:17:51,759 --> 00:17:54,420
integer punto

192
00:17:54,420 --> 00:17:56,480
parse int de un string que sea

193
00:17:56,480 --> 00:17:57,200
ese info

194
00:17:57,200 --> 00:18:00,960
nos paramos un par de minutitos en esta instrucción

195
00:18:00,960 --> 00:18:02,380
para recordaros que

196
00:18:02,380 --> 00:18:04,380
luego lo retomo también

197
00:18:04,380 --> 00:18:06,500
para contaros otra cosa, pero en Java tenemos

198
00:18:06,500 --> 00:18:13,819
tipos de datos primitivos algunos que que bueno pues que están digamos integrados y se consideran

199
00:18:13,819 --> 00:18:18,859
con este nombre dentro de java y luego otros referenciados que por ejemplo podrían ser objetos

200
00:18:18,859 --> 00:18:24,680
de clases que construyamos nosotros de la clase persona cuando la tengamos generamos un objeto

201
00:18:24,680 --> 00:18:32,099
pues estaría referenciado fijaros los tipos de datos primitivos si ponemos aquí y val y un punto

202
00:18:32,099 --> 00:18:58,119
¿Veis? Eclipse no me ofrece métodos que utilizar, no me está dando la posibilidad de trabajar con métodos. Los tipos primitivos no nos dan opciones, simplemente el tipo de datos con un espacio de memoria RAM donde guardar, en este caso en particular, un valor que sea de tipo entero, pero no tiene métodos para trabajar con ellos.

203
00:18:58,119 --> 00:19:22,839
Al contrario de los referenciados, este por ejemplo es uno referenciado, es un objeto de esta clase y si le ponemos aquí miScan, al pulsar aquí, no me lo está ofreciendo porque no está compilando aquí, yo creo, aquí sí que me ofrece métodos.

204
00:19:22,839 --> 00:19:37,740
¿Por qué? Porque este es un objeto referenciado, que es una variable referenciada correspondiente a un objeto de una clase que tiene definido, a la hora de haberlo programado, métodos, igual que el main aquí para esta clase, y atributos.

205
00:19:38,599 --> 00:19:43,920
Es decir, los primitivos no tienen métodos atributos y los referenciados sí que los tienen.

206
00:19:43,920 --> 00:19:48,539
pero sí que es cierto que nos interesa que los tengan

207
00:19:48,539 --> 00:19:53,019
o sea, sí que es verdad que relacionado con lo que sería un valor entero

208
00:19:53,019 --> 00:19:56,259
pues hay cosas, hay funciones que me van a resultar útiles

209
00:19:56,259 --> 00:20:00,920
como los primitivos no tienen esa posibilidad de tener

210
00:20:00,920 --> 00:20:04,940
métodos definidos, hay definidas una serie de clases que le dan

211
00:20:04,940 --> 00:20:08,839
ese soporte a los variables primitivas

212
00:20:08,839 --> 00:20:12,839
que son los wrapper, como hemos dicho, entonces para variables

213
00:20:12,839 --> 00:20:17,160
de tipo int, pues tenemos la clase Integer, que si la pulsamos

214
00:20:17,160 --> 00:20:20,819
por aquí, pues nos da ciertas funciones que típicamente

215
00:20:20,819 --> 00:20:23,940
van a estar muy relacionadas con los tipos enteros.

216
00:20:25,140 --> 00:20:28,960
Entonces esto sería una clase Wrapper que va de la mano de un tipo de datos

217
00:20:28,960 --> 00:20:32,759
primitivo, que al no tener esa posibilidad de definir los datos primitivos

218
00:20:32,759 --> 00:20:37,160
métodos para manipular ese tipo de datos, pues los tenemos

219
00:20:37,160 --> 00:20:38,559
a través de la clase Wrapper.

220
00:20:38,559 --> 00:20:42,720
envoltoria, clase envoltoria

221
00:20:42,720 --> 00:20:45,420
que diríamos, un poco traduciendo

222
00:20:45,420 --> 00:20:47,539
a la vez del inglés, entonces aquí

223
00:20:47,539 --> 00:20:51,519
utilizando la clase grouper y el método parseInt

224
00:20:51,519 --> 00:20:53,680
pasamos como parámetro

225
00:20:53,680 --> 00:20:57,160
un string que en principio va a ser un número pero en formato cadena

226
00:20:57,160 --> 00:21:00,140
de caracteres y nos lo convierte a ese mismo número

227
00:21:00,140 --> 00:21:02,900
pero en formato numérico y lo guardamos

228
00:21:02,900 --> 00:21:05,900
en esta variable de tipo entero que es

229
00:21:05,900 --> 00:21:12,150
un tipo de datos primitivo. Se tiene que apoyar los datos primitivos en las

230
00:21:12,150 --> 00:21:16,230
clases Grouper para disponer de ciertos métodos que nos den

231
00:21:16,230 --> 00:21:19,930
funcionalidades. La ventaja es que no tenemos que andar

232
00:21:19,930 --> 00:21:24,130
de forma explícita en el código haciendo reservas con

233
00:21:24,130 --> 00:21:27,809
métodos, con el instruccionio, igual que sí que hemos hecho aquí para el objeto

234
00:21:27,809 --> 00:21:31,609
que es una variable referenciada del tipo Scanner.

235
00:21:35,279 --> 00:21:38,240
Otra vueltecilla, le damos a unos cuantos conceptos para

236
00:21:38,240 --> 00:21:45,059
poner esta línea aquí y en definitiva aquí tendremos un valor y en el ejercicio estábamos

237
00:21:45,059 --> 00:21:52,119
diciendo recibir cinco valores que todos ellos estén entre 0 y 10 si no están entre 0 y 10 no

238
00:21:52,119 --> 00:21:58,480
me interesan esos valores yo lo que quiero es que sean 5 fijaros no me estoy obligando tanto a que

239
00:21:58,480 --> 00:22:03,299
se ejecute cinco veces el for sino que los cinco valores que me dan estén entre 0 y 10 en este

240
00:22:03,299 --> 00:22:07,000
enunciado que estamos proponiéndonos para el ejercicio.

241
00:22:07,819 --> 00:22:11,039
Entonces resulta que aquí habré podido coger un valor que estará entre 0 y 10

242
00:22:11,039 --> 00:22:15,200
que me gustará y un valor que no estará entre 0 y 10 y no me gustará

243
00:22:15,200 --> 00:22:19,039
tanto, con lo cual querré seguir dando vueltas aquí en el

244
00:22:19,039 --> 00:22:22,740
bucle. Con esta condición que tenemos aquí en el for

245
00:22:22,740 --> 00:22:27,039
en cada iteración incrementamos en 1 el valor

246
00:22:27,039 --> 00:22:30,720
de i, con lo cual lo que tenemos es que va a dar 5 vueltas al for.

247
00:22:31,720 --> 00:22:42,160
Pues resulta que si en las cinco vueltas metemos el número 20, ninguno va a estar entre 0 y 10 y no habré cogido absolutamente ninguno de los números en el rango que tenía, en el que estaba yo interesado.

248
00:22:42,440 --> 00:22:52,660
Pues aquí, por ejemplo, podríamos utilizar otra sentencia esta de control, en este caso una condicional para ver si este valor es de los que me interesan.

249
00:22:52,660 --> 00:23:01,680
Entonces digo, if sí. Dentro del if tengo que meter aquí una condición que se evalúe a verdadero o falso y que cumpla con mis expectativas.

250
00:23:01,680 --> 00:23:21,880
Entonces puedo decir, si i es menor de 0 o i es mayor de 10, en ese caso, si se da una de estas condiciones, el dato no me interesa.

251
00:23:21,880 --> 00:23:24,779
entonces aquí que podría hacer

252
00:23:24,779 --> 00:23:28,380
no considerarlo, me interesa cuando el dato

253
00:23:28,380 --> 00:23:31,720
en este caso, ahora intentamos dar la vuelta a ese if

254
00:23:31,720 --> 00:23:34,740
para tener la instrucción de cuando me interesa en el if

255
00:23:34,740 --> 00:23:37,599
system.auth.println

256
00:23:37,599 --> 00:23:43,690
ponemos aquí, dato

257
00:23:43,690 --> 00:23:50,539
leído, y lo he leído y lo he cargado aquí

258
00:23:50,539 --> 00:23:55,650
en ival, bueno he cometido un error porque el dato

259
00:23:55,650 --> 00:23:58,890
en realidad que quiero evaluar no es la i

260
00:23:58,890 --> 00:24:00,930
sino que es el dato que estoy leyendo

261
00:24:00,930 --> 00:24:02,609
desde teclado, que es ival

262
00:24:02,609 --> 00:24:04,430
sería aquí, si ival

263
00:24:04,430 --> 00:24:06,150
e ival

264
00:24:06,150 --> 00:24:08,950
y si no me interesa

265
00:24:08,950 --> 00:24:11,069
no escribo nada

266
00:24:11,069 --> 00:24:12,789
¿pero qué pasa si no escribo nada? pues

267
00:24:12,789 --> 00:24:14,009
no ejecuta lels

268
00:24:14,009 --> 00:24:17,430
me termina la estructura

269
00:24:17,430 --> 00:24:19,130
llega al final del ámbito

270
00:24:19,130 --> 00:24:21,069
del for, y que sea lo siguiente

271
00:24:21,069 --> 00:24:22,210
que haga, y más más

272
00:24:22,210 --> 00:24:25,170
aquí leo 5 veces, como os digo un 20

273
00:24:25,170 --> 00:24:26,970
ninguna de las veces me entrará por aquí

274
00:24:26,970 --> 00:24:30,670
todas por aquí, no me mostrará nada por pantalla y se saldrá del bucle

275
00:24:30,670 --> 00:24:34,190
y no habremos mostrado ningún número que tenga ese dato

276
00:24:34,190 --> 00:24:38,369
vamos a hacer una ejecución, aunque antes de, bueno

277
00:24:38,369 --> 00:24:42,789
voy a ejecutarlo sin modificar lo que iba a hacer, para que veáis la

278
00:24:42,789 --> 00:24:47,150
consecuencia que tiene, fijaros que el programa lo tengo en ejecución

279
00:24:47,150 --> 00:24:50,809
y muy bien, y estoy un poco desamparado, sin saber lo que voy a hacer

280
00:24:50,809 --> 00:24:54,829
porque me ha ejecutado el programa, me ha entrado aquí y se me ha quedado aquí

281
00:24:54,829 --> 00:25:01,390
en el next line esperando recibir un dato pero como no he puesto un sistema println pidiéndome

282
00:25:01,390 --> 00:25:05,970
el dato que quiero leer aquí por teclado pues el programa se me ha quedado aquí no sé muy bien lo

283
00:25:05,970 --> 00:25:13,710
que va a pasar o lo que espera el programa de mí es mejor vamos lo paro por aquí y vamos a poner

284
00:25:13,710 --> 00:25:30,559
aquí un sistema println pidiendo ese dato dime un número entre 0 y 10 si ponemos un sistema

285
00:25:30,559 --> 00:25:36,259
print el n, me va a mostrar esto y me va a saltar a otra línea. Si utilizo el método system print,

286
00:25:36,839 --> 00:25:41,940
me va a poner esto y se va a mantener ahí en la misma línea. Quizás sea más interesante para que

287
00:25:41,940 --> 00:25:49,059
el cursor se me quede a continuación de los dos puntos y poder escribir el número. Entonces lo doy

288
00:25:49,059 --> 00:25:56,759
por aquí, ejecutar, me dice dime un número, mira si le digo 20, se me va a otra iteración, como el

289
00:25:56,759 --> 00:26:03,400
número no ha cumplido, ha cumplido esta condición, el 20 es mayor que 10, se me ha metido por aquí,

290
00:26:03,480 --> 00:26:09,880
no ha hecho nada, ha dado una vuelta y me vuelve a pedir esto. Pongo ahora menos 2 aquí, otra vez

291
00:26:09,880 --> 00:26:17,079
las mismas, fijaros que ha salido y en realidad no me ha mostrado nunca el dato. ¿Qué podríamos

292
00:26:17,079 --> 00:26:22,019
hacer aquí para descontar cada iteración en la que el número no nos ha interesado? Pues este

293
00:26:22,019 --> 00:26:30,519
incremento que me hace aquí pues se lo podría incrementar aquí es entonces trabajando con la

294
00:26:30,519 --> 00:26:38,140
y no solamente en esta parte del foro sino como parte según no lo exija nuestro algoritmo como

295
00:26:38,140 --> 00:26:44,420
parte del código dentro del ámbito del foro pues tenemos la posibilidad de hacer que nuestro

296
00:26:44,420 --> 00:26:51,200
programa se comporte como quiera si hemos incrementa esto en 1 y el número como metido

297
00:26:51,200 --> 00:26:54,519
ha sido menos 20, al

298
00:26:54,519 --> 00:26:56,059
decrementarlo aquí, pues vuelve a valer

299
00:26:56,059 --> 00:26:58,440
si valía 0, valía 1

300
00:26:58,440 --> 00:27:00,140
en esta iteración y he metido un 20,

301
00:27:01,259 --> 00:27:02,460
pues aquí hago que valga

302
00:27:02,460 --> 00:27:04,220
0 para que aquí vuelva a valer 1

303
00:27:04,220 --> 00:27:06,279
y decrementar el que estoy incrementando aquí

304
00:27:06,279 --> 00:27:08,180
porque realmente no ha sido un dato válido

305
00:27:08,180 --> 00:27:09,519
al no salirnos por

306
00:27:09,519 --> 00:27:12,240
dato leído. Es decir, que trabajamos con

307
00:27:12,240 --> 00:27:13,960
la i según nos interese.

308
00:27:17,279 --> 00:27:18,740
Entonces, si ponemos aquí 33,

309
00:27:19,160 --> 00:27:20,819
pues no le gusta. En realidad

310
00:27:20,819 --> 00:27:22,619
no sabemos qué valor tiene i, pero si ahora nos deja

311
00:27:22,619 --> 00:27:25,019
coger 5 números, voy a poner otro 33.

312
00:27:25,160 --> 00:27:28,299
tampoco le gusta, vamos a poner menos 1

313
00:27:28,299 --> 00:27:31,400
menos 1, menos 1, menos 1

314
00:27:31,400 --> 00:27:35,000
66 y fijaros que ya hemos dado más de 5 vueltas

315
00:27:35,000 --> 00:27:37,599
a mostrar esto más de 5 veces y no nos hemos salido

316
00:27:37,599 --> 00:27:39,619
porque estamos corrigiendo el valor de la i

317
00:27:39,619 --> 00:27:43,599
a nuestro interés aquí como parte del código

318
00:27:43,599 --> 00:27:46,019
entonces ahora voy a meter 4 números que si están bien

319
00:27:46,019 --> 00:27:48,980
y ahora ya si que se nos sale

320
00:27:48,980 --> 00:27:52,019
1, 2, 3, 4 y 5

321
00:27:52,019 --> 00:27:54,059
efectivamente recogemos esos 5 números

322
00:27:54,059 --> 00:28:15,549
Mira, vamos a suponer que dentro de este ejercicio resulta que, bueno, somos muy, muy supersticiosos y el número 13 no nos interesa. Mira, si metes el 13 me enfada tanto que te voy a sacar del bucle y no te voy a pedir más números.

323
00:28:15,549 --> 00:28:20,200
entonces resulta que le podemos decir aquí que si es igual a 13

324
00:28:20,200 --> 00:28:23,420
pues poner aquí una condición que haga que nos salgamos del bucle

325
00:28:23,420 --> 00:28:31,740
una posible condición podría ser poner aquí i igual a un valor mayor de 5

326
00:28:31,740 --> 00:28:36,319
con lo cual de golpe ya hace que esta condición no se cumpla y se salga

327
00:28:36,319 --> 00:28:39,420
si ponemos aquí por ejemplo, bueno con 6 sería suficiente

328
00:28:39,420 --> 00:28:41,039
vamos a poner que i sea igual a 10

329
00:28:41,039 --> 00:28:47,230
o sea seguimos trabajando a nuestro antojo aquí

330
00:28:47,230 --> 00:28:53,170
decrementamos para buscar que se escribieran cinco números. Aquí estamos buscando un mecanismo de salida

331
00:28:53,170 --> 00:28:58,710
porque resulta que es que el 13 no nos gusta nada. Entonces, si ponemos un 13, no vamos a salir de él.

332
00:28:59,809 --> 00:29:07,869
Le damos una ejecución, ponemos un 5, que es un número que está bien, ponemos un número que no se va a considerar,

333
00:29:07,869 --> 00:29:18,920
y ahora si ponemos aquí un 13, no se me ha salido. Ah, vale, bien, cierto, no se ha salido.

334
00:29:18,920 --> 00:29:25,859
y no es casual porque que ha pasado os acordáis que el if es auto excluyente pues el 13 cumple

335
00:29:25,859 --> 00:29:31,539
esta condición y cumple está como se ha encontrado primero la condición del if ha ejecutado esto

336
00:29:33,160 --> 00:29:40,480
y no me ha ejecutado el shift del 13 con lo cual ahora mismo este código no se va a ejecutar nunca

337
00:29:40,480 --> 00:29:45,420
porque cuando sea 13 ya habrá cumplido esta condición y le valdrá está entonces vamos a

338
00:29:45,420 --> 00:29:48,099
salir, vamos a modificar un poquito el código

339
00:29:48,099 --> 00:29:51,619
voy a poner este antes

340
00:29:51,619 --> 00:29:58,559
ahí está, para que juzgue antes el de 13

341
00:29:58,559 --> 00:30:01,180
te lo doy por aquí

342
00:30:01,180 --> 00:30:04,299
si le pongo un 5 le gusta, le pongo un

343
00:30:04,299 --> 00:30:08,019
99 no le gusta, le pongo un menos 1 no le gusta

344
00:30:08,019 --> 00:30:11,000
y si le pongo un 13 ya sí que se nos sale directamente

345
00:30:11,000 --> 00:30:13,619
del bucle, al pasar, al valer

346
00:30:13,619 --> 00:30:22,230
igual a 10, habrá un momento en el que nos interesará

347
00:30:22,230 --> 00:30:24,930
seguramente hacer nuestros programas

348
00:30:24,930 --> 00:30:28,109
que sean muy versátiles. Entonces aquí estamos

349
00:30:28,109 --> 00:30:31,009
haciendo un programa que nos está recogiendo

350
00:30:31,009 --> 00:30:33,910
si tenéis cualquier dudilla

351
00:30:33,910 --> 00:30:37,190
o lo que se os ocurra me va a ir diciendo y variamos

352
00:30:37,190 --> 00:30:39,190
un poco porque estoy un poco improvisando

353
00:30:39,190 --> 00:30:42,630
sobre la temática justo que estamos viendo en este

354
00:30:42,630 --> 00:30:46,109
aquí en el tema 2, pero vamos, no me importa

355
00:30:46,109 --> 00:30:49,190
irme hacia otras cosillas. Bueno, pues

356
00:30:49,190 --> 00:30:52,930
si queremos hacer que nuestro programa sea más versátil y no solamente que recoja

357
00:30:52,930 --> 00:31:00,859
cinco números, fijaros, pues podríamos coger aquí, aprovechando además

358
00:31:00,859 --> 00:31:04,079
que tenemos una entrada aquí de Scanner, si no, pues la podríamos definir

359
00:31:04,079 --> 00:31:10,960
y decir, dime cuántos

360
00:31:10,960 --> 00:31:15,220
números quieres leer.

361
00:31:16,339 --> 00:31:18,660
Cuántos números que estén entre 0 y 10,

362
00:31:19,680 --> 00:31:25,960
cuántos números tienen que cumplir esta condición. Entonces aquí podríamos coger

363
00:31:25,960 --> 00:31:44,500
y definir una variable y un número de números, lo leemos con un slide y hacemos un parseInt a este número de números

364
00:31:44,500 --> 00:31:52,180
y este número de números lo podemos utilizar aquí, en lugar de este 5 que tenemos aquí fijo, lo podemos poner aquí.

365
00:31:52,180 --> 00:32:04,619
Es decir, mientras el valor de la variable i sea menor que el valor de la variable inunumer, pues se irá ejecutando el ámbito del for, dará tantas vueltas como eso.

366
00:32:07,079 --> 00:32:17,900
Y en este caso, el número de números, digamos que vamos a leer, lo estamos cargando desde teclado, en esta instrucción, y luego convirtiéndolo a un valor entero.

367
00:32:17,900 --> 00:32:43,000
Entonces ahora ejecutamos por aquí y decimos mira lo que queremos leer son dos números, decimos 4 y 5, pues ahí ya está, se nos terminó con dos números, si decimos lo que queremos leer son cuatro números, 3, 2, 4 y 5, pues se nos termina ahora con cuatro números, conseguimos un programa mucho más versátil.

368
00:32:43,000 --> 00:32:48,299
desde teclado, estamos recogiendo el número de números que queremos leer

369
00:32:48,299 --> 00:32:52,500
y luego trabajando en el for con variables en lugar

370
00:32:52,500 --> 00:32:55,599
con un número entero, con un número fijo

371
00:32:55,599 --> 00:32:59,660
podemos hacer que la cantidad de números sean diferentes

372
00:32:59,660 --> 00:33:05,769
mira, imaginaos que tenemos un programa, eso no es tanto el bucle

373
00:33:05,769 --> 00:33:10,150
sino de buscar, lo que os voy a comentar, de buscar que nuestro programa sea versátil

374
00:33:10,150 --> 00:33:14,190
imaginaos que tenemos un programa que lo que nos

375
00:33:14,190 --> 00:33:20,789
permite es, es capaz de imprimir el listado de los grupos que tenemos aquí en el instituto.

376
00:33:21,869 --> 00:33:30,210
Entonces, pues está el grupo que viene a la asignatura de programación y el grupo que va a la asignatura de sistemas informáticos.

377
00:33:30,630 --> 00:33:33,009
Probablemente muchos de vosotros estéis matriculados en los dos.

378
00:33:34,910 --> 00:33:42,680
Entonces, lo que podríamos hacer es tener un método, en este caso quizás más que un FOR,

379
00:33:42,680 --> 00:33:45,980
podríamos tener un método que nos cogiese desde teclado

380
00:33:45,980 --> 00:33:50,259
el grupo sobre el que queremos recuperar la información

381
00:33:50,259 --> 00:33:53,480
probablemente en una base de datos y sacarla por impresora.

382
00:33:54,019 --> 00:33:57,799
Haríamos un programa versátil en tanto en cuanto nos serviría

383
00:33:57,799 --> 00:34:00,420
para imprimir el listado de unos grupos o de otros.

384
00:34:01,200 --> 00:34:05,220
Eso lo conseguimos metiendo información a través del teclado,

385
00:34:05,319 --> 00:34:08,980
desde base de datos, desde ficheros y cargándolo en variables

386
00:34:08,980 --> 00:34:11,860
que lo utilizaremos como parámetros en los métodos

387
00:34:11,860 --> 00:34:15,679
aquí tenéis un parámetro para el método parseInt

388
00:34:15,679 --> 00:34:19,639
o como variables que forman parte de la

389
00:34:19,639 --> 00:34:27,869
información que tiene el form, en este caso. Mirad

390
00:34:27,869 --> 00:34:33,019
otra cosilla, os voy a comentar, si nos venimos por aquí

391
00:34:33,019 --> 00:34:40,599
al workspace de Eclipse, pues el programa

392
00:34:40,599 --> 00:34:44,340
el proyecto sobre el que estamos haciendo estos ejercicios

393
00:34:44,340 --> 00:34:50,139
no sé si es el prueba, clase print tiene pinta de ser el prueba

394
00:34:50,139 --> 00:34:54,639
pues me meto al proyecto prueba

395
00:34:54,639 --> 00:34:56,559
me meto al bin

396
00:34:56,559 --> 00:34:59,380
y aquí tenemos el bytecode

397
00:34:59,380 --> 00:35:02,800
consecuencia de la compilación a través del javaz

398
00:35:02,800 --> 00:35:05,159
como hablábamos en las primeras clases

399
00:35:05,159 --> 00:35:07,820
del código que tenemos aquí en clase print

400
00:35:07,820 --> 00:35:11,699
si vamos al intérprete y ponemos java class print

401
00:35:11,699 --> 00:35:15,639
pues fijaros, dice dime cuantos números quieres leer

402
00:35:15,639 --> 00:35:17,980
vamos a poner aquí 3

403
00:35:17,980 --> 00:35:21,849
vamos a poner un número grande

404
00:35:21,849 --> 00:35:24,650
no le vale, vamos a poner 13 y se sale

405
00:35:24,650 --> 00:35:28,590
es el código efectivamente con el que estamos trabajando

406
00:35:28,590 --> 00:35:31,469
y a ver, no me acuerdo muy bien

407
00:35:31,469 --> 00:35:33,530
a ver, por aquí en java

408
00:35:33,530 --> 00:35:37,369
podemos poner run configuration

409
00:35:37,369 --> 00:35:44,059
a ver, a ver, dame un minuto a ver si encuentro una cosa

410
00:35:44,059 --> 00:35:45,719
si no ya la contaré en otro momento

411
00:35:45,719 --> 00:35:52,769
si, aquí mirad

412
00:35:52,769 --> 00:35:58,449
disculpad

413
00:35:58,449 --> 00:36:17,570
Mira, aunque os lo comentaré, pues en otros días, ya que estamos hablando de que los programas sean versátiles, aquí estamos cogiendo información desde teclado, pues la clase main tiene aquí un parámetro que siempre escribo y bueno, no se había comentado hasta ahora.

414
00:36:17,570 --> 00:36:23,429
Vamos a hacer un primer comentario, aunque más adelante volveré a repetir lo mismo que voy a decir.

415
00:36:25,230 --> 00:36:29,289
La clase Main nos comentaba que es el punto de entrada en nuestro programa.

416
00:36:30,070 --> 00:36:33,929
Y este punto de entrada resulta que este método, que es el que se empieza ejecutando,

417
00:36:34,610 --> 00:36:36,769
de hecho hemos visto que efectivamente es así,

418
00:36:37,630 --> 00:36:42,050
este punto de entrada es capaz de recibir aquí información.

419
00:36:42,050 --> 00:36:56,849
Igual que al escáner le hemos dicho que el flujo de datos al construir su objeto era System.in, al constructor escáner de la clase escáner, al método main, le podemos meter información en el momento que se va a ejecutar.

420
00:36:56,849 --> 00:37:19,369
Si nosotros hacemos un programa que queremos que tenga alternativas sin tener que estar tocando su código en el momento en el que llamemos a su ejecución a través del intérprete, por ejemplo, desde aquí, desde terminal, podemos coger y meter la información en el momento de la ejecución separando.

421
00:37:19,369 --> 00:37:36,789
Fijaros aquí la instrucción de ejecución, el intérprete, el programa que queremos ejecutar que es el bytecode sobre el que estamos programando y luego podemos meterle aquí ciertos datos que tendrán un significado durante la ejecución del programa.

422
00:37:36,789 --> 00:37:56,769
Aquí, por ejemplo, un 5 lo podríamos meter. Podríamos meter uno o tantos como fueran necesarios. 5 o la, los que fuesen. Esto lo que está haciendo es intérprete de Java, ejecútame este programa y considera para tu ejecución estos dos parámetros que luego, muy probablemente, en la ejecución del código utilizarás para algo.

423
00:37:56,769 --> 00:38:08,110
Por ejemplo, en lo que os comentaba antes de imprimir el listado de una determinada asignatura, pues podríamos poner aquí clase print y poner aquí programación.

424
00:38:09,010 --> 00:38:17,989
Pues entonces cogería y esto, desde el programa, leería esta programación y escogería y nos imprimiría el listado de los alumnos de programación o sistemas.

425
00:38:18,710 --> 00:38:20,130
Bueno, pues como fuese, ¿no?

426
00:38:20,130 --> 00:38:27,869
¿Cómo se capturan estos datos que metemos adicionales cuando estamos haciendo la llamada a la ejecución al programa?

427
00:38:27,869 --> 00:38:34,530
Vamos a poner aquí un 5, pues se capturan a través de esta información.

428
00:38:34,929 --> 00:38:40,030
Fijaros que aquí tenemos una variable y esta variable es un array de strings.

429
00:38:40,750 --> 00:38:48,010
Entonces en cada posición de este array de strings se van a ir cargando valores de los que le pasamos aquí como parámetros.

430
00:38:48,010 --> 00:39:11,139
Fijaros, si cogemos aquí y ponemos system.out.println y vamos a poner esta variable, ars, que es ars s, recordad, es un array de strings.

431
00:39:11,139 --> 00:39:13,960
si ponemos aquí los corchetes

432
00:39:13,960 --> 00:39:15,460
y ponemos la posición 0

433
00:39:15,460 --> 00:39:17,579
resulta que

434
00:39:17,579 --> 00:39:19,400
ars s y

435
00:39:19,400 --> 00:39:21,679
los corchetes ya sería

436
00:39:21,679 --> 00:39:23,579
un string, entonces esto es un string

437
00:39:23,579 --> 00:39:25,860
mira, si hacemos una ejecución

438
00:39:25,860 --> 00:39:26,480
de este código

439
00:39:26,480 --> 00:39:30,960
pero desde aquí, veis que

440
00:39:30,960 --> 00:39:32,679
me ha impreso, bueno me ha sacado esto

441
00:39:32,679 --> 00:39:34,340
porque luego el programa sigue por aquí

442
00:39:34,340 --> 00:39:36,739
diciendo dime cuantos números

443
00:39:36,739 --> 00:39:38,980
pero lo primero que me ha mostrado ha sido

444
00:39:38,980 --> 00:39:40,980
un 5, pues este 5

445
00:39:40,980 --> 00:39:42,219
resulta que es este 5

446
00:39:43,829 --> 00:39:50,269
que se ha cargado durante la ejecución en el array ARCHS como primer elemento.

447
00:39:51,409 --> 00:39:53,269
Voy a dar control-C para parar el programa.

448
00:39:59,130 --> 00:40:04,400
Si yo cojo y digo aquí System.out.println a posición 1,

449
00:40:06,320 --> 00:40:09,840
si yo ejecuto aquí el 5 y pongo aquí hola,

450
00:40:11,179 --> 00:40:13,840
fijaros cómo me muestra un 5 y un hola.

451
00:40:14,679 --> 00:40:18,840
Este en ARCHS se carga en la posición 0 y este en la posición 1.

452
00:40:20,300 --> 00:40:22,320
que son los dos que estoy mostrando aquí, como veis.

453
00:40:23,860 --> 00:40:28,659
Entonces, otra forma, además de pedir cuántos números quieres leer,

454
00:40:28,800 --> 00:40:32,260
que podríamos haber utilizado, pues resulta que en lugar de leerlo

455
00:40:32,260 --> 00:40:35,880
durante la ejecución en cada uno de los programas,

456
00:40:35,880 --> 00:40:39,460
desde teclado, pues lo podríamos llamar en la llamada.

457
00:40:39,780 --> 00:40:43,599
Entonces, el número este de iteraciones, podríamos decir que sea

458
00:40:43,599 --> 00:40:46,420
args cero.

459
00:40:46,420 --> 00:40:56,179
entonces también conseguimos un programa versátil que el número de vueltas que va a dar el for lo cargue en una variable

460
00:40:56,179 --> 00:41:03,440
esta variable antes hemos probado para que se cogiese desde teclado la pedíamos por aquí

461
00:41:03,440 --> 00:41:12,199
y en este caso el diseño del programa en realidad pedía el número de veces que queremos que se ejecute

462
00:41:12,199 --> 00:41:19,079
pero no tanto pidiéndolo en cada ejecución por teclado, sino indicándoselo en el momento en el que lanzamos el programa.

463
00:41:21,119 --> 00:41:28,739
Salgo de la ejecución anterior y si yo digo ahora, vamos a poner aquí, ejecútamelo para tres veces,

464
00:41:29,199 --> 00:41:32,820
este valor, como es el primer parámetro, se cargará en ARS0.

465
00:41:37,320 --> 00:41:46,179
El valor ARS0, fijaros, esto es un string, es decir, es un string de la misma forma que esto era un string que cargábamos con Nestline

466
00:41:46,179 --> 00:41:51,260
y como tenemos el número en un string y queremos trabajar con él como un dato numérico

467
00:41:51,260 --> 00:41:54,940
utilizamos el wrapper, le hacemos el parseInt y en este caso

468
00:41:54,940 --> 00:41:59,199
el parseInt se lo estábamos haciendo de ese info cuando lo cogíamos por teclado

469
00:41:59,199 --> 00:42:03,199
pues ahora en lugar de esta variable de tipo string que hemos cargado

470
00:42:03,199 --> 00:42:07,739
con el nestline del escáner, le enchufamos el ars0

471
00:42:07,739 --> 00:42:10,559
entonces si hacemos esta ejecución

472
00:42:10,559 --> 00:42:14,300
bueno, me ha pegado aquí un fallo, vamos a ver por qué

473
00:42:14,300 --> 00:42:18,619
bueno, se me ha pegado un fallo, ya os cuento por qué

474
00:42:18,619 --> 00:42:22,679
mira, dice que he intentado hacer a la posición 1

475
00:42:22,679 --> 00:42:27,320
de ARS 0, y le he hecho la ejecución, este es la posición 0

476
00:42:27,320 --> 00:42:31,440
y no le he metido un valor en la posición 1, es el motivo

477
00:42:31,440 --> 00:42:34,820
para evitar ese error, había comentado esta línea, como podéis ver

478
00:42:34,820 --> 00:42:38,880
es en esta línea, a ver si me dice la línea también, fijaros, me dice que en la línea 8

479
00:42:38,880 --> 00:42:43,380
efectivamente, veis en la línea 8, es decir, ha sido durante la ejecución de esta línea

480
00:42:43,380 --> 00:42:44,800
cuando me ha dado el error, ¿por qué?

481
00:42:45,679 --> 00:42:47,260
intentaba acceder en una raya

482
00:42:47,260 --> 00:42:49,139
a una posición que realmente no existe

483
00:42:49,139 --> 00:42:51,000
porque solo le había pasado un parámetro

484
00:42:51,000 --> 00:42:52,940
entonces existe ARS 0 pero no ARS 1

485
00:42:52,940 --> 00:42:55,320
¿qué ha sucedido? ¿por qué

486
00:42:55,320 --> 00:42:56,800
me ha dado el error?

487
00:42:56,980 --> 00:42:58,780
a pesar de haberlo compilado, pues porque

488
00:42:58,780 --> 00:43:01,400
lo había modificado pero no había salvado

489
00:43:01,400 --> 00:43:02,360
ahora lo salvo

490
00:43:02,360 --> 00:43:07,070
ahora no me da el error ya

491
00:43:07,070 --> 00:43:09,929
fijaros, ARS 0, que sí que me lo está mostrando

492
00:43:09,929 --> 00:43:11,690
según el código que hay aquí

493
00:43:11,690 --> 00:43:13,389
en la línea 7, me dice que vale 3

494
00:43:13,389 --> 00:43:14,329
cargado desde aquí

495
00:43:14,329 --> 00:43:17,590
ahora claro, no me ha hecho esta petición

496
00:43:17,590 --> 00:43:19,269
de dime cuantos números quiere leer

497
00:43:19,269 --> 00:43:21,329
aunque en inumbar ha cargado

498
00:43:21,329 --> 00:43:23,769
el valor de ar0 con el parseint

499
00:43:23,769 --> 00:43:25,110
de integer, con lo cual esto

500
00:43:25,110 --> 00:43:27,650
se entiende que va a valer 3, vamos a comprobarlo

501
00:43:27,650 --> 00:43:29,550
y el for lo estoy

502
00:43:29,550 --> 00:43:31,289
haciendo en función a este valor, con lo cual

503
00:43:31,289 --> 00:43:33,590
me estará pidiendo 3 valores

504
00:43:33,590 --> 00:43:35,469
entre 0 y 10, siempre y cuando

505
00:43:35,469 --> 00:43:37,630
no metamos 13 y si metemos valores

506
00:43:37,630 --> 00:43:39,429
mayores o menores que 0 y 10

507
00:43:39,429 --> 00:43:41,670
pues se me vendrá

508
00:43:41,670 --> 00:43:42,750
por aquí, descontará

509
00:43:42,750 --> 00:43:45,630
como hacíamos antes, entonces ponemos

510
00:43:45,630 --> 00:43:47,730
el valor 4 que es válido, el 6

511
00:43:47,730 --> 00:43:49,630
vamos a poner el 99

512
00:43:49,630 --> 00:43:51,849
que no lo es, el menos 1 que tampoco

513
00:43:51,849 --> 00:43:53,489
vamos a poner el 5

514
00:43:53,489 --> 00:43:55,050
y veis, pues ya termino

515
00:43:55,050 --> 00:43:57,510
termino con 3 vueltas

516
00:43:57,510 --> 00:43:59,730
¿por qué ha dado 3 vueltas? porque habíamos puesto

517
00:43:59,730 --> 00:44:01,889
aquí un 3, hemos conseguido

518
00:44:01,889 --> 00:44:03,150
que nuestro programa

519
00:44:03,150 --> 00:44:04,170
sea

520
00:44:04,170 --> 00:44:07,190
versátil, nos dé alternativas

521
00:44:07,190 --> 00:44:09,809
tanto en cuanto al número que queremos utilizar

522
00:44:09,809 --> 00:44:11,309
pues sí, poniéndolo por aquí

523
00:44:11,309 --> 00:44:57,480
¿Alguna pregunta por ahí? ¿Se sigue bien más o menos? Bueno, pues mira, es un array, pero que no veamos que se está inicializando no quiere decir que no se esté inicializando.

524
00:44:58,099 --> 00:45:04,480
¿Qué sucede? Pues que antes de que se empiece a ejecutar este código, el código que haya por detrás por ahí,

525
00:45:04,480 --> 00:45:12,420
el que sea capaz de poner, habrá un código por ahí por detrás en Java que yo desconozco, nunca he visto cómo está,

526
00:45:12,940 --> 00:45:20,900
pero vamos, me atrevería a decirte que en algún sitio, cuando tú haces esto, tendrá que redirigirse ya empezando a ejecutarse el código

527
00:45:20,900 --> 00:45:24,280
para que busque la clase main que se ponga en marcha.

528
00:45:24,440 --> 00:45:26,880
Y muy probablemente, antes de hacer eso,

529
00:45:27,239 --> 00:45:30,019
habrá hecho una lectura de cuántos campos hay aquí

530
00:45:30,019 --> 00:45:33,400
y si hay uno, habrá hecho un new para este array

531
00:45:33,400 --> 00:45:35,500
que será un new de un solo string.

532
00:45:35,739 --> 00:45:37,920
Y si hay cinco, pues habrá hecho un new de cinco.

533
00:45:39,559 --> 00:45:41,880
Pero si es un array, se habrá hecho la reserva de memoria

534
00:45:41,880 --> 00:45:43,940
con toda seguridad.

535
00:45:44,159 --> 00:45:45,360
O sea, no sería una colección.

536
00:45:47,449 --> 00:45:49,650
Otra cosa es que nosotros no lo estemos viendo aquí en el código.

537
00:45:49,650 --> 00:46:12,170
Y mira, ya que dices esto de los arrays, ahora después continúo con otras cosas que tengo por aquí apuntadas. Vamos a suponer un programa y así metemos también un bucle que nos pida información hasta que, por ejemplo, pongamos un menos uno.

538
00:46:12,170 --> 00:46:34,380
Es decir, vamos a ir metiendo datos hasta que el dato metido sea menos uno. Y nosotros cogemos y trabajando con los arrays, podríamos hacer una primera suposición y decir, pues mira, seguro que en este programa se ejecute una mil veces, nunca vamos a meter más de cuatro números.

539
00:46:34,380 --> 00:46:39,019
números siempre vamos a poner menos uno antes de cuatro números no sé ponlo en el contexto que te

540
00:46:39,019 --> 00:46:44,119
parezca que es un poco descabellado el que haya que ejecutarlo más de cuatro veces no vamos a

541
00:46:44,119 --> 00:46:49,440
buscar si quieres un una funcionalidad particular que responda a esto pero bueno sería sería lo que

542
00:46:49,440 --> 00:46:58,719
se daría entonces podríamos coger y decir y vamos a definir un array de enteros los coches de los

543
00:46:58,719 --> 00:47:01,880
podemos poner antes o después del nombre de la variable,

544
00:47:02,019 --> 00:47:02,760
nos lo acepta Java.

545
00:47:03,860 --> 00:47:10,199
New, int, vamos a suponer que acepta cuatro valores.

546
00:47:10,559 --> 00:47:12,699
Estos cuatro valores serán los que estén en el índice

547
00:47:12,699 --> 00:47:16,099
entre cero y tres, entre estos índices.

548
00:47:19,139 --> 00:47:23,579
Entonces, vamos a introducir otra cosa más, fijaros,

549
00:47:24,219 --> 00:47:26,139
que son las constantes.

550
00:47:26,199 --> 00:47:29,679
Las constantes en Java pueden ser de diferentes tipos,

551
00:47:29,800 --> 00:47:31,400
también de tipos primitivos.

552
00:47:31,400 --> 00:47:45,460
Imaginaos que tenemos una constante de tipo int y decimos que número, vamos a poner cantNum, vamos a definirlo que sea igual a 4.

553
00:47:46,760 --> 00:47:59,139
Vamos a definir de forma constante que la cantidad de números, esa que estábamos planteando aquí como máxima cantidad de números que vamos a meter, sea de 4.

554
00:47:59,139 --> 00:48:04,599
para que esto sea, si nosotros

555
00:48:04,599 --> 00:48:06,679
aunque hayamos puesto esto en mayúsculas

556
00:48:06,679 --> 00:48:08,800
que es la forma que por estándar

557
00:48:08,800 --> 00:48:10,920
se suele decir que se pongan las constantes

558
00:48:10,920 --> 00:48:13,059
si nosotros ahora ponemos aquí que esto sea igual a 5

559
00:48:13,059 --> 00:48:20,429
voy a definir la static

560
00:48:20,429 --> 00:48:22,269
lo de static

561
00:48:22,269 --> 00:48:23,869
en otro rato lo

562
00:48:23,869 --> 00:48:26,070
volveré a contar, ya os he hecho referencia

563
00:48:26,070 --> 00:48:28,070
a la static, hoy

564
00:48:28,070 --> 00:48:29,949
no lo sé si hoy lo contaré, pero bueno

565
00:48:29,949 --> 00:48:31,989
como estoy centrado en otras cosas, la defino static

566
00:48:31,989 --> 00:48:34,050
para que me compile, fijaros

567
00:48:34,050 --> 00:48:35,730
como esta variable

568
00:48:35,730 --> 00:48:42,150
me permite modificar su valor porque porque es una variable si queremos que realmente actúe como

569
00:48:42,150 --> 00:48:47,550
una constante que tenga un valor inamovible lo que es una constante lo podríamos poner la etiqueta

570
00:48:47,550 --> 00:48:54,750
de final y en lo que normalmente sería un parámetro si se identifica lo identificamos como final

571
00:48:54,750 --> 00:49:01,920
estamos haciendo la constante entonces fijaros cómo hará esto ya me deja de compilar es pues

572
00:49:01,920 --> 00:49:05,099
este valor se lo vamos a poder poner aquí

573
00:49:05,099 --> 00:49:06,380
a la definición del array

574
00:49:06,380 --> 00:49:09,019
y así lo ponemos como un final

575
00:49:09,019 --> 00:49:10,699
si hay 5 o 6

576
00:49:10,699 --> 00:49:13,179
imaginaos que en el código, en el desarrollo

577
00:49:13,179 --> 00:49:15,159
del main hay 4 o 5 sitios

578
00:49:15,159 --> 00:49:16,980
donde nos interesa ir haciendo

579
00:49:16,980 --> 00:49:18,960
comprobaciones de este dato porque es la

580
00:49:18,960 --> 00:49:21,079
cantidad máxima de números que vamos a poner

581
00:49:21,079 --> 00:49:23,239
si no lo ponemos en una constante

582
00:49:23,239 --> 00:49:24,960
pues tendríamos que poner 4

583
00:49:24,960 --> 00:49:26,039
por todas esas partes

584
00:49:26,039 --> 00:49:28,420
en tantas como apareciera

585
00:49:28,420 --> 00:49:30,260
si luego resulta que

586
00:49:30,260 --> 00:49:49,780
Si decidimos que 4 se nos ha quedado corto y queremos que sea 5, tendríamos que ir a 5 o 6 sitios a modificar este 4 y poner un 5 para que quedara coherente en todas partes, ya que se está refiriendo al número máximo en todos los sitios del código, al número máximo de números que queremos leer.

587
00:49:49,780 --> 00:49:57,840
En cambio, si trabajamos en todas partes con cantNum y cambiamos de 4 a 5, pues el único sitio que tenemos que poner el 5 sería aquí.

588
00:49:59,039 --> 00:50:09,539
Y si está en un solo sitio, no tenemos lugar a equivocaciones que sí se podrían llegar a producir si el 4 lo tenemos esparcido por muchas partes del código

589
00:50:09,539 --> 00:50:12,519
y resulta que en un sitio se me olvida cambiarlo.

590
00:50:12,519 --> 00:50:31,719
Entonces podría llevar a equívocos o a ejecuciones erróneas del programa y de esta forma, si resulta que su comportamiento es como una constante, utilizando cant num, el único sitio donde cambiamos es aquí y ya queda perfectamente definido en todas las partes donde ese dato sea importante.

591
00:50:31,719 --> 00:50:35,219
bueno, mirad, hemos cogido

592
00:50:35,219 --> 00:50:38,139
y hemos definido esto, entonces ponemos aquí for

593
00:50:38,139 --> 00:50:40,880
definimos int i

594
00:50:40,880 --> 00:50:44,099
igual a cero, mientras i sea

595
00:50:44,099 --> 00:50:49,840
menor, no, hemos dicho que queríamos

596
00:50:49,840 --> 00:50:51,320
estar aquí dando vueltas

597
00:50:51,320 --> 00:50:55,000
mientras no introduzcamos un menos uno

598
00:50:55,000 --> 00:50:57,579
entonces ponemos int i val aquí

599
00:50:57,579 --> 00:51:00,579
igual a cero para que nos entre una vez

600
00:51:00,579 --> 00:51:09,519
o vamos a hacer un do while, para que entre al menos una vez

601
00:51:09,519 --> 00:52:11,199
Hacemos un do while, definimos una variable, y val, hemos dado demasiadas cosas antes aquí, vamos a poner aquí string, ese info, mi scan punto, next line, dime número, vamos a poner un print, y aquí la misma jugada de antes, hacemos un integer, parse int, de ese info, aquí tenemos el dato que estamos leyendo.

602
00:52:11,199 --> 00:52:40,239
Y queremos que esto se esté ejecutando mientras, fijaros que no vamos a ejecutar en base a que ya hayamos leído cuatro números, sino que vamos a ejecutar el bucle en base a que el número que se lea sea menos uno.

603
00:52:41,219 --> 00:52:46,340
Entonces diremos que se está ejecutando mientras i val sea diferente de menos uno.

604
00:52:46,920 --> 00:52:53,539
Esto que puede darse la situación de que aquí carguemos más números que el máximo que permite el array.

605
00:52:56,889 --> 00:53:04,150
Entonces aquí vamos a poner que cada vez que leamos un número vamos a incrementar in un leídos.

606
00:53:05,510 --> 00:53:06,429
Más, más.

607
00:53:06,429 --> 00:53:25,380
Y aquí vamos a hacer una comprobación diciendo que si el número de datos leídos es mayor que esto, corremos el riesgo de que se nos desborde el array, ¿verdad?

608
00:53:26,019 --> 00:53:39,239
Fijaros, si ya hemos leído, si tenemos que el array lo hemos definido para 4 y resulta que hemos leído más de 4, resulta que cuando vayamos a guardar la información en el array puede ser que nos dé un error.

609
00:53:39,239 --> 00:53:45,489
entonces lo que vamos a hacer aquí va a ser

610
00:53:45,489 --> 00:53:49,019
al array

611
00:53:49,019 --> 00:53:50,599
a la posición del array

612
00:53:50,599 --> 00:53:52,539
ahora repasamos todo el código de nuevo

613
00:53:52,539 --> 00:53:59,460
se está colando un micro por ahí

614
00:53:59,460 --> 00:54:00,440
alguien lo tenéis abierto

615
00:54:00,440 --> 00:54:02,900
y no es que me moleste a mi mucho pero

616
00:54:02,900 --> 00:54:05,280
a ver si luego la grabación se va a quedar con ruido

617
00:54:05,280 --> 00:54:07,500
entonces, bueno no se os escucha

618
00:54:07,500 --> 00:54:07,980
creo ¿no?

619
00:54:09,300 --> 00:54:11,000
echar un ojillo para apagarlo

620
00:54:11,000 --> 00:54:11,840
si nos importa

621
00:54:11,840 --> 00:54:15,119
bueno, no, y val

622
00:54:15,119 --> 00:54:18,380
mira, mi idea

623
00:54:18,380 --> 00:54:23,500
para hacer una ejecución a ver qué es lo que va pasando por aquí ahora vemos que ponemos aquí en

624
00:54:23,500 --> 00:54:30,019
él tenemos en esta variable es donde estamos cargando cada uno de los datos que cogemos

625
00:54:30,019 --> 00:54:37,000
desde teclado en esta variable vamos a llevar un contador de cuántos datos hemos leído

626
00:54:38,559 --> 00:54:42,519
anteriormente hemos definido una raíz que es donde vamos a ir guardando los datos a los guardamos

627
00:54:42,519 --> 00:54:46,920
aquí, que lo estamos guardando aquí. ¿Veis? Cada dato que cogemos

628
00:54:46,920 --> 00:54:50,480
lo estamos guardando en una posición del array. Para que sea una

629
00:54:50,480 --> 00:54:54,400
posición distinta, cada vez incrementamos el

630
00:54:54,400 --> 00:55:01,519
inum datos leído. Para que la primera lo guarde en el cero, vamos a poner

631
00:55:01,519 --> 00:55:06,300
esto aquí después de guardarlo. Entramos por aquí.

632
00:55:07,340 --> 00:55:10,980
Coge un número, dice el número de datos leído

633
00:55:10,980 --> 00:55:13,860
es mayor

634
00:55:13,860 --> 00:55:19,139
o igual a la cantidad de datos que podemos guardar

635
00:55:19,139 --> 00:55:21,039
en el array? Pues si es el caso

636
00:55:21,039 --> 00:55:28,659
lo que vamos a hacer aquí va a ser rehacer el array

637
00:55:28,659 --> 00:55:35,800
para darle más tamaño. Ahora vamos a ver qué pasa si le damos más tamaño

638
00:55:35,800 --> 00:55:41,519
que es donde quiero llegar también. Si no se da el caso de que

639
00:55:41,519 --> 00:55:44,880
ya hayamos leído más datos, lo que voy a hacer va a ser guardar el dato en el array

640
00:55:44,880 --> 00:55:49,659
y voy a incrementar el número de datos leídos para saber ya que hay un dato más leído

641
00:55:49,659 --> 00:55:58,980
que estoy utilizándolo para, entre otras cosas, para ir aumentando el índice en el que voy escribiendo en el array.

642
00:55:59,380 --> 00:56:11,780
Vamos a hacer una ejecución inicial, damos aquí, dime un número y decimos 2, 3, si meto menos 1, el programa se me acaba.

643
00:56:12,000 --> 00:56:13,719
En ese aspecto el programa funciona bien.

644
00:56:16,449 --> 00:56:24,000
Para ver cómo se nos queda el array, lo que podemos hacer es otro bucle aquí.

645
00:56:24,000 --> 00:56:48,940
Este bucle lo vamos a utilizar para coger información y lo vamos a hacer otro bucle, en este caso con un for int i igual a cero, mientras i sea menor que ir.length, es decir, para recorrer todo el array, mientras i sea menor que la longitud del array, y digo un i más más.

646
00:56:48,940 --> 00:57:19,090
Aquí voy a poner system.out.println, la información del array es, y aquí un system.out.print, y vamos a poner cada uno de los elementos del array.

647
00:57:19,210 --> 00:57:27,449
Fijaros que este bucle, este segundo bucle, lo que hace es iterar por todos los elementos del array mostrándolos por pantalla.

648
00:57:29,070 --> 00:57:32,809
Vamos a hacer una primera ejecución, ahora seguimos metiendo más código, dime un número.

649
00:57:32,809 --> 00:57:37,449
decimos un 3, decimos un 4, si metemos menos 1 termina

650
00:57:37,449 --> 00:57:39,309
y dice la información del array es

651
00:57:39,309 --> 00:57:44,429
3, 4, bueno, menos 1, 0

652
00:57:44,429 --> 00:57:47,630
el menos 1 lo ha guardado también por aquí en la posición array

653
00:57:47,630 --> 00:57:51,730
y los datos que me ha metido es el 3, el 1

654
00:57:51,730 --> 00:57:55,590
el menos 1 que me ha sacado del bucle, que también lo ha guardado en una posición del array

655
00:57:55,590 --> 00:57:59,690
y la cuarta posición, como era un entero, está inicializada a 0

656
00:57:59,690 --> 00:58:01,309
me ha mostrado todos los datos

657
00:58:01,309 --> 00:58:04,969
mira, si como el array lo hemos

658
00:58:04,969 --> 00:58:07,030
dimensionado para 4, vamos a seguir

659
00:58:07,030 --> 00:58:08,809
haciendo casos, ahora metemos más código

660
00:58:08,809 --> 00:58:10,030
imaginaos que metemos

661
00:58:10,030 --> 00:58:12,969
no metemos menos 1, metemos 4, 5

662
00:58:12,969 --> 00:58:14,909
6, 7, ya llevamos 4

663
00:58:14,909 --> 00:58:16,690
8, y que me da

664
00:58:16,690 --> 00:58:18,690
me da un error, porque

665
00:58:18,690 --> 00:58:21,030
me dice array fuera de rango

666
00:58:21,030 --> 00:58:23,090
array index out of bounds

667
00:58:23,090 --> 00:58:24,510
he intentado meter

668
00:58:24,510 --> 00:58:26,590
en esta línea

669
00:58:26,590 --> 00:58:27,590
fijaros en la línea

670
00:58:27,590 --> 00:58:30,230
26 del código

671
00:58:30,230 --> 00:58:34,250
en una posición del array para la que ya no había definido

672
00:58:34,250 --> 00:58:37,429
variables, esta es la posición 0, posición 1, posición 2

673
00:58:37,429 --> 00:58:40,690
posición 3, para la posición 4 cuando el índice

674
00:58:40,690 --> 00:58:43,469
del array va entre el 0 y el 3, he intentado meter

675
00:58:43,469 --> 00:58:45,809
un valor y como no he reservado memoria para él

676
00:58:45,809 --> 00:58:48,929
pues no le ha gustado y entonces ha dado

677
00:58:48,929 --> 00:58:51,449
un fallo, un pete aquí el programa, ¿vale?

678
00:58:54,000 --> 00:58:57,519
Para tener eso en cuenta he puesto este if en el cual todavía no he hecho

679
00:58:57,519 --> 00:59:00,400
nada, entonces lo que vamos a hacer va a ser rehacer

680
00:59:00,400 --> 00:59:03,679
o redimensionar el array. ¿Por qué? Porque nos hemos dado cuenta

681
00:59:03,679 --> 00:59:09,739
que estamos metiendo más datos de los que hemos reservado

682
00:59:09,739 --> 00:59:12,880
en memoria RAM para este array. Entonces aquí podríamos coger

683
00:59:12,880 --> 00:59:18,079
y hacer, mira, igual que aquí le di este tamaño, pues vamos a volver

684
00:59:18,079 --> 00:59:25,340
a hacerlo, pero en lugar de utilizar este índice, vamos a utilizar

685
00:59:25,340 --> 00:59:36,329
como índice este cuando entre por aquí resultará que el tamaño ya es yo creo vamos a probar con

686
00:59:36,329 --> 00:59:44,130
mayor si no lo miramos resultará que el número de datos leídos ya va a resultar mayor que la

687
00:59:44,130 --> 00:59:52,210
cantidad de números es decir se va a dar este caso cuando llegamos a este caso este número ya

688
00:59:52,210 --> 00:59:57,590
será mayor que la cantidad de números que la bueno todavía no porque incrementamos aquí vamos

689
00:59:57,590 --> 01:00:05,329
a poner mayor o igual en el momento en el que aquí hemos leído el quinto dato que es este que nos ha

690
01:00:05,329 --> 01:00:10,269
dado un error esto ya se va a cumplir y se cumple esto lo que voy a hacer va a ser dar un nuevo

691
01:00:10,269 --> 01:00:17,909
tamaño a la raíz para que no me dé este fallo con el nuevo tamaño que es en un dato leído vamos a

692
01:00:17,909 --> 01:00:25,469
a poner un dato leído vamos a darle de tamaño más 2 luego si acaso lo ajustamos estamos

693
01:00:25,469 --> 01:00:30,090
redimensionando lo escogemos y decimos vale si lo redimensionamos ya no me va a dar ese

694
01:00:30,090 --> 01:00:35,070
error efectivamente vamos a darle yo creo que no nos va a dar el error ahora entonces metemos

695
01:00:35,070 --> 01:00:43,769
un número dos tres cuatro hasta ahora con estos cuatro números hemos entrado por ha pasado por

696
01:00:43,769 --> 01:00:50,010
aquí no habrá pasado por aquí ninguna vez todavía y ha pasado por aquí tantas veces como están

697
01:00:50,010 --> 01:00:54,369
permitidas según esta dimensión si ahora metemos otro número ha sido cuanto antes nos ha fallado

698
01:00:54,369 --> 01:01:01,809
y ahora no falla veis por qué porque se ha dado cuenta que ya hay más números y ha redimensionado

699
01:01:01,809 --> 01:01:06,570
el array para que sea más grande si antes teníamos un tamaño de 4 pues ahora tendremos un tamaño de

700
01:01:06,570 --> 01:01:12,889
6 y si mete otro número volverá a darse cuenta y como éste lo hemos vuelto a incrementar pues

701
01:01:12,889 --> 01:01:19,309
ahora tendrá ya un nuevo tamaño de 7. ¿Veis? Sigue sin fallarme. Voy a poner menos 1 para que se salga.

702
01:01:20,789 --> 01:01:26,530
Y mirad lo que ha pasado en los primeros datos. ¿Os acordáis que habíamos puesto aquí un 4, un 3, un 4, un 5?

703
01:01:27,329 --> 01:01:33,210
Mirad qué datos me saca aquí. ¿Veis que son todos los primeros datos un 0? ¿Esto por qué ha sucedido?

704
01:01:33,909 --> 01:01:41,590
Pues cuando yo cogí y hice esta instrucción con este new, me pidió al sistema operativo un espacio

705
01:01:41,590 --> 01:01:45,809
de memoria RAM y vamos a suponer que el espacio, el sistema operativo dijo tu posición de memoria

706
01:01:45,809 --> 01:01:49,769
es la 30.000. Una aleatoria, donde veo un hueco

707
01:01:49,769 --> 01:01:53,750
del sistema operativo en memoria RAM. Y tu espacio para este array

708
01:01:53,750 --> 01:01:57,510
va a ir entre el 30.000, que es el punto de inicio, y el tamaño que necesitas

709
01:01:57,510 --> 01:02:01,449
para 4 enteros. Es decir, entre 30.000 y 30.000

710
01:02:01,449 --> 01:02:15,159
más el espacio de 4 enteros. Durante el

711
01:02:15,159 --> 01:02:19,119
tiempo en el que hemos estado haciendo ejecuciones y no ha entrado por aquí, por este código

712
01:02:19,119 --> 01:02:26,619
del if, como la primera vez esto valía 0, en la posición 30.000, según esta ejecución, habría metido un 4.

713
01:02:26,940 --> 01:02:45,010
Es decir, en la posición 30.000, un 4. En la posición 30.000 más espacio de un entero, pues habrá metido el dato

714
01:02:45,010 --> 01:03:00,400
que hemos capturado, el dato que hemos capturado, que es un 3, ¿veis? Pues habrá metido un 3. En la posición 30.000

715
01:03:00,400 --> 01:03:02,639
más el espacio de dos enteros

716
01:03:02,639 --> 01:03:04,179
habrá metido un 4.

717
01:03:06,019 --> 01:03:08,460
O sea, todo según es previsible.

718
01:03:09,219 --> 01:03:10,239
Pero, ¿qué pasa cuando

719
01:03:10,239 --> 01:03:12,579
ya hemos sobrepasado 4

720
01:03:12,579 --> 01:03:13,619
y hacemos esto?

721
01:03:14,460 --> 01:03:16,480
Pues esto, dice, para esta variable

722
01:03:16,480 --> 01:03:18,340
estoy pidiendo un new porque

723
01:03:18,340 --> 01:03:19,880
me he quedado corto en el array.

724
01:03:20,360 --> 01:03:22,300
Y como me he quedado corto en el array, lo hago más grande.

725
01:03:22,599 --> 01:03:24,420
Pero este new, ¿qué es lo que hace? Pues busca

726
01:03:24,420 --> 01:03:26,360
en el sistema operativo un hueco y este

727
01:03:26,360 --> 01:03:28,440
nuevo new hace que esto ahora apunte

728
01:03:28,440 --> 01:03:32,239
probablemente a la posición, a otra posición aleatoria que no es 30.000

729
01:03:32,239 --> 01:03:38,719
a la 60.000. Entonces la posición 60.000

730
01:03:38,719 --> 01:03:42,940
y reserva espacio de memoria va desde el 60.000

731
01:03:42,940 --> 01:03:46,099
hasta más el espacio

732
01:03:46,099 --> 01:03:50,840
del número de elementos que llevemos hasta ahora más 2 que hemos puesto

733
01:03:50,840 --> 01:03:54,840
aquí. Imaginaos que son 6, 6 enteros.

734
01:03:57,530 --> 01:04:00,630
Entonces la posición donde antes teníamos

735
01:04:00,630 --> 01:04:02,630
guardado el primero de los valores

736
01:04:02,630 --> 01:04:04,210
que habíamos metido que era la 30.000

737
01:04:04,210 --> 01:04:06,630
no es la misma posición donde ahora apunta la array

738
01:04:06,630 --> 01:04:08,590
que es la 60.000, entonces esta nueva posición

739
01:04:08,590 --> 01:04:10,789
vale 0, con lo cual

740
01:04:10,789 --> 01:04:12,750
como consecuencia

741
01:04:12,750 --> 01:04:14,769
de esto, lo que ha pasado es que hemos perdido

742
01:04:14,769 --> 01:04:16,750
este 4, hemos perdido este 3

743
01:04:16,750 --> 01:04:18,110
y hemos perdido este 6

744
01:04:18,110 --> 01:04:20,170
es decir

745
01:04:20,170 --> 01:04:22,789
cuando nosotros damos de alta una array

746
01:04:22,789 --> 01:04:25,699
su dimensión

747
01:04:25,699 --> 01:04:27,659
no puede cambiar ya nunca

748
01:04:27,659 --> 01:04:30,159
y si hacemos por código

749
01:04:30,159 --> 01:04:31,460
que cambie, en realidad

750
01:04:31,460 --> 01:04:36,159
no estamos cambiando la dimensión de esta array, sino lo que estamos haciendo

751
01:04:36,159 --> 01:04:40,320
es crear un nuevo array que es verdad que está apuntado

752
01:04:40,320 --> 01:04:43,659
por una variable que se llama igual que se llamaba aquí, de hecho es la misma variable

753
01:04:43,659 --> 01:04:48,000
pero ya es un nuevo array con un nuevo tamaño, pero todos los datos que teníamos

754
01:04:48,000 --> 01:04:51,840
en esta array se pierden. Entonces esto es lo que nos lleva a

755
01:04:51,840 --> 01:04:55,940
que los arrays no pueden modificar su tamaño, son

756
01:04:55,940 --> 01:04:59,480
estructuras de datos estáticas, porque esto ya sería

757
01:04:59,480 --> 01:05:03,460
digamos un nuevo array diferente a este otro. Los datos que teníamos

758
01:05:03,460 --> 01:05:07,639
de antes se han perdido. Vamos a hacer una ejecución para confirmar

759
01:05:07,639 --> 01:05:11,400
esto ejecutando el código de tal forma que esta

760
01:05:11,400 --> 01:05:15,159
instrucción no se ejecute nunca. Es decir, antes de llegar a esta cantidad de números

761
01:05:15,159 --> 01:05:19,619
de datos metidos vamos a meter menos uno

762
01:05:19,619 --> 01:05:23,659
para que esto no se ejecute. Con lo cual todo el rato es la misma estructura

763
01:05:23,659 --> 01:05:26,539
y nos mostrará los datos que hayamos metido

764
01:05:26,539 --> 01:05:29,079
en esa primera reserva que habíamos hecho

765
01:05:29,079 --> 01:05:30,539
para el array en este new

766
01:05:30,539 --> 01:05:32,860
entonces si damos una ejecución y ponemos

767
01:05:32,860 --> 01:05:34,679
dime un número, 3, el 4

768
01:05:34,679 --> 01:05:35,900
y le decimos menos 1

769
01:05:35,900 --> 01:05:38,960
fijaros como si me muestra el 3 y el 4

770
01:05:38,960 --> 01:05:41,260
como no ha pasado por aquí, no hemos rehecho el array

771
01:05:41,260 --> 01:05:43,199
si yo hago otra

772
01:05:43,199 --> 01:05:44,219
ejecución aquí y digo

773
01:05:44,219 --> 01:05:47,260
3, 4, 5, 6, 7, 8

774
01:05:47,260 --> 01:05:48,900
9, fijaros que ya he metido

775
01:05:48,900 --> 01:05:50,980
suficientes datos como para sobrepasar

776
01:05:50,980 --> 01:05:53,280
esta cantidad, me habrá hecho esta ejecución

777
01:05:53,280 --> 01:05:54,400
más de una vez

778
01:05:54,400 --> 01:05:56,440
con lo cual cada vez habrá hecho

779
01:05:56,440 --> 01:06:01,300
un nuevo array. Y cada vez que hace un nuevo array, estará reservando la memoria

780
01:06:01,300 --> 01:06:05,360
para este tamaño en un nuevo

781
01:06:05,360 --> 01:06:09,119
espacio de memoria RAM. Y cada una de las ejecuciones

782
01:06:09,119 --> 01:06:13,019
anteriores habría ido perdiendo los datos que tenían. Entonces, si ahora pongo aquí menos uno

783
01:06:13,019 --> 01:06:17,400
para ser capaz de terminar, fijaros como ya esas primeras posiciones se han perdido.

784
01:06:20,909 --> 01:06:26,239
¿Sí? ¿Lo veis? ¿Sí? ¿Bien? ¿Más o menos?

785
01:06:29,090 --> 01:06:37,500
Bueno, si no me comentáis nada, entiendo que...

786
01:06:37,500 --> 01:06:49,719
Si esto fuera una colección, que ya os digo que hay un tema de colecciones en las que volveremos a repasar la diferencia entre array y colección y trabajaremos con los diferentes tipos de colecciones que hay, que son varias.

787
01:06:50,840 --> 01:06:56,440
Si esto fuese una colección, no se hace esta reserva inicial.

788
01:06:56,440 --> 01:07:00,559
Entonces tú lo que defines es un identificador de la colección.

789
01:07:00,559 --> 01:07:19,409
Este identificador de la colección, igual que el array tiene este identificador, que en este caso es IR, tendrá un determinado nombre como una variable de colección en nuestro programa.

790
01:07:19,409 --> 01:07:35,869
Y esa colección no tendrá inicialmente ningún elemento metido, pero tampoco habrá hecho una reserva inicial del tamaño del número de elementos que puede guardar.

791
01:07:35,869 --> 01:07:39,550
entonces si por ejemplo tuviéramos una colección de enteros

792
01:07:39,550 --> 01:07:43,250
inicialmente no tendríamos ninguna posición de memoria

793
01:07:43,250 --> 01:07:45,949
y si vamos a llamar call por ejemplo

794
01:07:45,949 --> 01:07:47,949
el supuesto nombre de la colección

795
01:07:47,949 --> 01:07:49,550
solo por ponerlo en contexto

796
01:07:49,550 --> 01:07:52,389
la forma de añadir elementos

797
01:07:52,389 --> 01:07:54,710
un nuevo elemento sería con el método add

798
01:07:54,710 --> 01:07:57,670
según la colección que sea hay diferentes formas

799
01:07:57,670 --> 01:07:59,630
entonces aquí lo que diríamos es

800
01:07:59,630 --> 01:08:01,550
añádeme un entero que es el 7

801
01:08:01,550 --> 01:08:03,250
por ejemplo, si fuese una colección

802
01:08:03,250 --> 01:08:05,829
y en este momento este método add

803
01:08:05,829 --> 01:08:09,730
lo que hace es hacer el new para ese entero

804
01:08:09,730 --> 01:08:12,289
y internamente la colección se organiza

805
01:08:12,289 --> 01:08:15,570
para que si luego pongo aquí otro elemento

806
01:08:15,570 --> 01:08:17,909
añado a la colección otro elemento

807
01:08:17,909 --> 01:08:19,710
pues hará una segunda reserva de memoria

808
01:08:19,710 --> 01:08:22,689
y de alguna forma enlazará estos dos datos

809
01:08:22,689 --> 01:08:24,550
para ir pudiendo pasar de uno a otro

810
01:08:24,550 --> 01:08:28,630
si yo tengo un callremove

811
01:08:28,630 --> 01:08:30,569
o no me acuerdo exactamente como es el método

812
01:08:30,569 --> 01:08:32,909
de la posición del valor 7

813
01:08:32,909 --> 01:08:34,630
pues me borraría este

814
01:08:34,630 --> 01:08:40,250
y además de eliminar este elemento de la colección, lo que haría sería liberar su memoria RAM,

815
01:08:40,369 --> 01:08:42,770
con lo cual la reserva de memoria RAM es dinámica.

816
01:08:42,930 --> 01:08:47,010
Si luego meto otra vez el 7, pues volvería a hacer la reserva.

817
01:08:47,869 --> 01:08:53,149
No tenemos el incordio este del tamaño que no puede modificarse de los arrays.

818
01:08:54,729 --> 01:08:59,789
Lo que sí que es cierto es que si tienes garantías de que el array no se va a modificar su tamaño,

819
01:08:59,789 --> 01:09:06,930
fijaros que el acceder a variables en una raíz es muy rápido porque esto ya sabe que empieza en el

820
01:09:06,930 --> 01:09:12,449
30.000 y si accedes a la posición 2 pues lo único que tienes que hacer es llegar al 30.000 más en

821
01:09:12,449 --> 01:09:18,569
espacio en zona de memoria 2 el espacio ocupan dos enteros y ya estoy en ese número directamente el

822
01:09:18,569 --> 01:09:25,470
programa va como un tiro cambio estos son métodos en los cuales cada datos habrá ido enlazando como

823
01:09:25,470 --> 01:09:34,369
haya podido a lo mejor el primer entero el 9 apunta al 7 y el 7 apunta para ir haciendo una

824
01:09:34,369 --> 01:09:39,409
secuencia a cada uno de ellos al 4 y dependiendo del tipo de colección a lo mejor si quiero llegar

825
01:09:39,409 --> 01:09:45,329
al 4 tengo que leer el 9 tengo que leer el 7 tengo que leer el 4 y si tiene muchos registros a lo

826
01:09:45,329 --> 01:09:51,270
mejor tengo que ir de uno en uno con una algoritmia que tienen programadas las colecciones en los

827
01:09:51,270 --> 01:09:56,329
paquetes de colecciones de Java. Entonces, toda esta búsqueda

828
01:09:56,329 --> 01:10:01,430
del dato que yo quiero cuando no tengo garantías donde se encuentra, pues tiene un coste.

829
01:10:01,609 --> 01:10:06,350
En cambio, este acceso es inmediato porque es al sitio

830
01:10:06,350 --> 01:10:10,510
de memoria RAM donde apunta el array más este número de posiciones

831
01:10:10,510 --> 01:10:16,050
que tiene que ocupar el tipo de datos que tiene ese array entero. Pues llego en un segundo a él.

832
01:10:17,210 --> 01:10:21,130
Entonces, bueno, pues los arrays tienen sus ventajas también respecto a las colecciones y las colecciones

833
01:10:21,130 --> 01:10:26,329
un montón de ventajas en cuanto a la manera en cuanto al manejo y la gestión de los datos que

834
01:10:26,329 --> 01:10:40,789
ya veremos cuando llegue su tema si bien vale pues a ver otras cosas que os puedo contar por

835
01:10:40,789 --> 01:11:02,720
ahí vale mirad otra otra cosa por ahí que os cuento mirad hay una etiqueta que es la etiqueta

836
01:11:02,720 --> 01:11:10,529
return la etiqueta return lo que hace es finalizar la ejecución de un método se sale de un método

837
01:11:10,529 --> 01:11:35,579
Vamos a poner el return aquí. Bueno, antes del return, os voy a contar otra cosa. Mirad, hemos hablado de los tipos de datos primitivos y de los referenciados. Los tipos de datos primitivos son en líneas generales, pues int, long, boolean.

838
01:11:35,579 --> 01:11:38,100
para estos tipos de datos

839
01:11:38,100 --> 01:11:40,460
hemos dicho que había dos características

840
01:11:40,460 --> 01:11:42,359
una, no necesitamos hacer el new

841
01:11:42,359 --> 01:11:44,560
no lo hace Java directamente

842
01:11:44,560 --> 01:11:46,560
al final se tendrá que hacer una reserva

843
01:11:46,560 --> 01:11:47,960
en memoria RAM por ahí

844
01:11:47,960 --> 01:11:50,640
porque en algún sitio se tienen que guardar estas variables

845
01:11:50,640 --> 01:11:52,720
bueno, pues por ahí la hará Java

846
01:11:52,720 --> 01:11:53,800
métete a saber cómo

847
01:11:53,800 --> 01:11:55,199
en sus librerías

848
01:11:55,199 --> 01:11:58,000
y luego por otro lado no tienen métodos

849
01:11:58,000 --> 01:11:59,619
no tienen

850
01:11:59,619 --> 01:12:02,079
los tipos de datos primitivos, no tienen métodos

851
01:12:02,079 --> 01:12:04,199
ni parámetros

852
01:12:04,199 --> 01:12:09,159
es decir, si ponemos, hemos visto antes que poníamos int y value

853
01:12:09,159 --> 01:12:12,680
o poníamos y val punto, no nos ofrecía nada, y para eso un método

854
01:12:12,680 --> 01:12:17,359
si los parámetros están las clases estas wrap en las envoltorio

855
01:12:17,359 --> 01:12:24,140
un tipo de datos primitivo podría ser este

856
01:12:24,140 --> 01:12:28,060
un tipo de datos referenciado, pues podría ser el que hemos visto antes

857
01:12:28,060 --> 01:12:32,479
el scanner, miScan, igual año

858
01:12:32,479 --> 01:12:36,500
el scanner, como parámetro recibe el system.in

859
01:12:36,500 --> 01:12:39,039
este sería referenciado

860
01:12:39,039 --> 01:12:41,300
en este caso

861
01:12:41,300 --> 01:12:43,420
hemos necesitado, porque no es primitivo

862
01:12:43,420 --> 01:12:45,300
hacer el new y tiene

863
01:12:45,300 --> 01:12:49,750
métodos, como veis

864
01:12:49,750 --> 01:12:51,930
hay un tipo

865
01:12:51,930 --> 01:12:54,010
de datos que es un poco intermedio

866
01:12:54,010 --> 01:12:55,890
entre unos y otros, que es el string

867
01:12:55,890 --> 01:12:59,609
el string en verdad

868
01:12:59,609 --> 01:13:01,369
es un tipo de datos referenciados

869
01:13:01,369 --> 01:13:03,789
referenciado, fijaros ese info

870
01:13:03,789 --> 01:13:12,619
veis, me ofrece

871
01:13:12,619 --> 01:13:14,819
métodos, con lo cual sigue la característica

872
01:13:14,819 --> 01:13:16,359
esta de referenciado

873
01:13:16,359 --> 01:13:18,279
pero no lo hacemos el new

874
01:13:18,279 --> 01:13:20,760
bueno, ¿por qué no lo hacemos el new?

875
01:13:21,079 --> 01:13:22,840
bueno, han considerado hacerlo

876
01:13:22,840 --> 01:13:24,319
referenciado y no hacer un wrapper

877
01:13:24,319 --> 01:13:26,560
como en los otros tipos

878
01:13:26,560 --> 01:13:28,939
pues ya está, así es como es la cosa

879
01:13:28,939 --> 01:13:30,920
y no hacemos

880
01:13:30,920 --> 01:13:32,300
el new, bueno, pues porque

881
01:13:32,300 --> 01:13:34,840
podrían habernos obligado

882
01:13:34,840 --> 01:13:36,619
al ser referenciado a haberlo hecho y tendríamos

883
01:13:36,619 --> 01:13:38,760
el hábito de hacerlo y ya está, no pasaría

884
01:13:38,760 --> 01:13:40,859
nada, pero yo creo que

885
01:13:40,859 --> 01:13:42,760
bueno, se dieron cuenta que hay tantas variables de tipo

886
01:13:42,760 --> 01:13:44,659
string en los programas que aparecen

887
01:13:44,659 --> 01:13:47,899
tanto o más como los otros tipos de datos primitivos

888
01:13:47,899 --> 01:13:50,760
que a lo mejor pensaron, pues vamos a hacer la reserva de memoria

889
01:13:50,760 --> 01:13:53,680
porque reserva de memoria se tendrá que hacer, en algún sitio se tiene que

890
01:13:53,680 --> 01:13:57,039
guardar la información de hola cuando se esté ejecutando el programa

891
01:13:57,039 --> 01:13:59,880
pero igual que dijeron, pues bueno, lo hacemos nosotros

892
01:13:59,880 --> 01:14:02,420
por detrás y os ahorramos que estéis escribiendo siempre el new

893
01:14:02,420 --> 01:14:05,760
de todas formas, como es referenciado

894
01:14:06,300 --> 01:14:08,699
lo podemos poner así, fijaros, podemos hacer

895
01:14:08,699 --> 01:14:12,800
un new string y también compila

896
01:14:12,800 --> 01:14:21,119
o sea tratarlo por completo como un tipo de datos referenciado sale le vale le vale esta jugada vale

897
01:14:21,119 --> 01:14:35,079
bien los tipos de datos referenciados cuando tú tienes un tipo de datos primitivo un int si

898
01:14:35,079 --> 01:14:45,880
ponemos aquí int y val igual a 3 ya os digo que es el string es que se comporta en una forma un

899
01:14:45,880 --> 01:14:58,439
poco intermedia. Si nosotros ponemos int ival igual a 3 y hacemos un system.out.println de ival,

900
01:14:59,340 --> 01:15:04,260
pues ¿qué nos muestra? Nos muestra el 3, el valor que tiene. Es un tipo de datos primitivo, nos muestra

901
01:15:04,260 --> 01:15:15,739
el 3. Si nosotros utilizamos un tipo de datos referenciado como escáner, decimos un system.out.println

902
01:15:15,739 --> 01:15:24,069
de mi scan, mi scan es un tipo de datos, es una variable que tenemos

903
01:15:24,069 --> 01:15:28,069
en mi programa, es un objeto de la clase scanner

904
01:15:28,069 --> 01:15:32,390
no es primitivo, es referenciado, lo hacemos el new, llamamos a su constructor

905
01:15:32,390 --> 01:15:39,399
entonces si yo pongo aquí mi scan y damos a una ejecución

906
01:15:39,399 --> 01:15:44,500
fijaros, bueno, pues este saca un churro, yo creo que iba a sacar

907
01:15:44,500 --> 01:15:48,420
menos churro todavía, pero un churro aquí importante, veis, de cosas

908
01:15:48,420 --> 01:15:52,260
no es un valor en sí que tenga, saca ahí un montón de información

909
01:15:52,260 --> 01:15:55,220
mirad, si yo de la clase print

910
01:15:55,220 --> 01:16:02,619
defino un objeto, la clase print

911
01:16:02,619 --> 01:16:05,119
es una clase, digamos que es un esquema

912
01:16:05,119 --> 01:16:08,600
que define el comportamiento que van a poder

913
01:16:08,600 --> 01:16:11,500
tener diferentes objetos de esa clase

914
01:16:11,500 --> 01:16:14,460
entonces yo cojo, como es un tipo de dato referenciado

915
01:16:14,460 --> 01:16:16,439
le hago un new de clase print

916
01:16:16,439 --> 01:16:20,399
pongo aquí un constructor, los constructores os hablo

917
01:16:20,399 --> 01:16:23,359
en el próximo tema, pero fijaros que sigue

918
01:16:23,359 --> 01:16:36,119
un esquema muy parecido a éste se llama un sistema println de este objeto fijaros que lo que me saca

919
01:16:36,119 --> 01:16:43,819
el sistema println de este me saca que es de esta clase identifica la clase a la que pertenece ese

920
01:16:43,819 --> 01:16:49,560
objeto y saca aquí un número que no me atrevería a decir al cien por cien que es la posición de

921
01:16:49,560 --> 01:16:55,100
memoria en la que se ha reservado espacio para las gestiones de este objeto pero podría serlo

922
01:16:55,100 --> 01:16:58,239
mirad esta clase

923
01:16:58,239 --> 01:17:00,500
podríamos coger, imaginaos que en lugar de la clase

924
01:17:00,500 --> 01:17:01,760
clase print fuera

925
01:17:01,760 --> 01:17:04,079
una clase persona y

926
01:17:04,079 --> 01:17:05,960
definiésemos int y edad

927
01:17:05,960 --> 01:17:14,770
y para este objeto miop

928
01:17:14,770 --> 01:17:17,050
punto

929
01:17:17,050 --> 01:17:18,890
y edad y decimos que sea

930
01:17:18,890 --> 01:17:19,270
10

931
01:17:19,270 --> 01:17:22,789
y si yo doy aquí a ejecutar

932
01:17:22,789 --> 01:17:24,890
me sigue

933
01:17:24,890 --> 01:17:25,630
sacando lo mismo

934
01:17:25,630 --> 01:17:28,329
para el entero me sacó un valor

935
01:17:28,329 --> 01:17:30,949
y podríamos pensar, oye clase print

936
01:17:30,949 --> 01:17:32,949
tiene aquí un entero. ¿Por qué no me saca aquí un 10?

937
01:17:33,310 --> 01:17:34,489
Me saca ese dato.

938
01:17:36,029 --> 01:17:37,050
Si fuese a la clase

939
01:17:37,050 --> 01:17:38,489
persona, también podría tener un nombre.

940
01:17:52,600 --> 01:17:53,640
Y si le doy a ejecutar,

941
01:17:54,680 --> 01:17:55,979
fijaros que me sigue sacando algo

942
01:17:55,979 --> 01:17:57,880
de este estilo. Está claro que

943
01:17:57,880 --> 01:18:00,100
el programa no tiene criterio

944
01:18:00,100 --> 01:18:02,100
para saber si lo que...

945
01:18:02,100 --> 01:18:03,939
De partida no tiene criterio para saber

946
01:18:03,939 --> 01:18:06,079
si a mí me interesa, cuando

947
01:18:06,079 --> 01:18:08,279
hago un System.out.printl de la clase,

948
01:18:08,699 --> 01:18:10,020
si me interesa sacar la edad,

949
01:18:10,159 --> 01:18:11,859
el nombre, una combinación de los dos.

950
01:18:12,380 --> 01:18:13,479
Y como no tiene criterio,

951
01:18:14,100 --> 01:18:22,460
Lo único que sabe es que es de esta clase y que hay aquí un identificador que posiblemente tendrá que ver con la posición de memoria

952
01:18:22,460 --> 01:18:27,279
donde se empiezan a guardar datos de ese objeto por ahí en memoria RAM.

953
01:18:28,279 --> 01:18:38,340
En cambio, para un tipo de dato que sí que es primitivo, no me saca posiciones de memoria ni me dice que es un entero, me saca directamente el dato.

954
01:18:38,340 --> 01:18:42,800
pues aquí tenemos otra diferencia entre los tipos de datos que son primitivos

955
01:18:42,800 --> 01:18:45,960
que me saca directamente la información de la variable

956
01:18:45,960 --> 01:18:49,699
y los que son referenciados que me saca algo de este estilo

957
01:18:49,699 --> 01:19:04,770
mirad que pasa con un string, este es info, lo hemos inicializado a hola

958
01:19:04,770 --> 01:19:10,050
pues este si que me saca hola, veis, entonces

959
01:19:10,050 --> 01:19:14,869
los tipos de datos string tienen un comportamiento

960
01:19:14,869 --> 01:19:18,630
intermedio, es necesario hacer el new

961
01:19:18,630 --> 01:19:46,159
aquí lo tengo hecho, pero hemos visto que no, con lo cual podríamos pensar es primitivo, muestra la información, efectivamente muestra la información, con lo cual podríamos pensar que es primitivo, pero luego tiene métodos, pues si tiene métodos, eso corresponde más a los referenciados, en realidad es referenciado con un comportamiento ahí mezclado,

962
01:19:46,159 --> 01:19:49,939
hay cosas en las que se comporta como los primitivos, no me obliga a hacer el new

963
01:19:49,939 --> 01:19:54,199
y el system.out.println, por ejemplo, me saca este hola en lugar de

964
01:19:54,199 --> 01:19:57,479
la referencia en la posición de memoria donde andamos.

965
01:19:57,880 --> 01:20:01,640
Luego ya os contaré en algún momento cómo modificar

966
01:20:01,640 --> 01:20:06,000
que me saca el system.out.println aquí para que no me saque esto, pero de partida

967
01:20:06,000 --> 01:20:09,359
lo hace así. Mirad otro comportamiento que

968
01:20:09,359 --> 01:20:13,579
en el que anda un poco mezclado

969
01:20:13,579 --> 01:20:17,180
en el que anda un poco mezclado el string

970
01:20:17,180 --> 01:20:20,020
es el siguiente, mira, si ponemos nosotros aquí if

971
01:20:20,020 --> 01:20:22,859
con un tipo de datos primitivo

972
01:20:22,859 --> 01:20:26,020
y val, este y val

973
01:20:26,020 --> 01:20:29,300
es este entero que he definido aquí, si es igual a 3

974
01:20:29,300 --> 01:20:37,359
digo system.out.println

975
01:20:38,039 --> 01:20:45,460
y val vale 3

976
01:20:45,460 --> 01:20:48,659
entonces yo cojo

977
01:20:48,659 --> 01:20:51,359
fijaros que cuando hago el system.out.println

978
01:20:51,359 --> 01:20:57,500
de ival me da un 3 aquí y aquí estoy comparando ival con un 3 entonces yo cojo y le doy aquí a la

979
01:20:57,500 --> 01:21:02,779
ejecución y me dice ival vale 3 es decir ha entrado por este if y me ha mostrado esta información

980
01:21:02,779 --> 01:21:16,100
es un tipo de dato primitivo si yo cojo y pongo aquí if ese info ese info recuerdo que es un

981
01:21:16,100 --> 01:21:27,699
string que hemos inicializado a hola es igual a hola justo lo mismo que he puesto aquí veis

982
01:21:27,699 --> 01:21:38,420
y hago un system.out.println, digo, ese info vale hola.

983
01:21:40,890 --> 01:21:44,250
Pues bueno, en principio nos haría pensar que si val vale 3,

984
01:21:45,029 --> 01:21:49,710
eso es cierto, nos muestra aquí 3, ese info lo hemos cargado con hola,

985
01:21:50,189 --> 01:21:52,409
de hecho el system.out.println aquí me muestra hola,

986
01:21:52,829 --> 01:21:54,470
pues me va a decir que ese info vale hola.

987
01:21:55,210 --> 01:22:02,119
Entonces si ejecuto esto, pues sí, me lo ha dicho.

988
01:22:12,390 --> 01:22:15,770
Pues mirad, aquí me ha dicho ese info vale hola cuando,

989
01:22:15,770 --> 01:22:20,859
teóricamente, además he hecho una prueba hoy en casa

990
01:22:20,859 --> 01:22:21,720
antes de venir para acá

991
01:22:21,720 --> 01:22:27,159
en realidad esta gestión, a ver si la hacemos aquí

992
01:22:27,159 --> 01:22:31,909
un momentito, vamos a hacerlo así

993
01:22:31,909 --> 01:22:35,869
con unido string, a ver si tiene un comportamiento

994
01:22:35,869 --> 01:22:40,810
diferente, vale, bien, pues aquí está

995
01:22:40,810 --> 01:22:44,149
la diferencia, si lo tratamos

996
01:22:44,149 --> 01:22:46,109
como un tipo de dato referenciado

997
01:22:46,109 --> 01:22:50,090
pues no me entra, porque el dato que considera es el mismo que me muestra

998
01:22:50,090 --> 01:22:52,489
cuando hacemos un system of println

999
01:22:52,489 --> 01:23:01,060
Pero si lo definimos de esta otra forma, sin hacer el new, sí me lo está considerando.

1000
01:23:03,439 --> 01:23:05,819
Esta comparación como que vale hola.

1001
01:23:07,100 --> 01:23:09,140
¿Veis? De esta otra forma sí que sale.

1002
01:23:10,520 --> 01:23:12,979
Entonces, ¿qué es lo que se dice siempre?

1003
01:23:13,119 --> 01:23:21,460
Pues en el código, cuando vayas a hacer esta comparación trabajando con una variable de tipo string,

1004
01:23:21,680 --> 01:23:26,220
como puede venir de una definición que en un momento dado ha podido ser de este tipo,

1005
01:23:26,520 --> 01:23:30,800
referenciada, igual esta línea de código queda lejos

1006
01:23:30,800 --> 01:23:34,720
de donde tienes esta otra zona de código

1007
01:23:34,720 --> 01:23:38,359
y no está a la vista, en lugar de hacer esta comparación, pues es como que

1008
01:23:38,359 --> 01:23:42,760
la tienes siempre como muy prohibida de hacerla así, y lo que se dice

1009
01:23:42,760 --> 01:23:51,189
es que se utilice un método que tiene los string

1010
01:23:51,189 --> 01:23:56,850
que es o bien el método equals o también se puede hacer

1011
01:23:56,850 --> 01:23:58,250
con el método compareTo

1012
01:23:58,250 --> 01:24:12,699
compareTo, vamos a hacerlo primero con el equals y luego

1013
01:24:12,699 --> 01:24:16,479
probamos si queréis con el compareTo, este método sea como sea

1014
01:24:16,479 --> 01:24:20,779
la hayas definido esta como la hayas definido, como un string directamente sin el new

1015
01:24:20,779 --> 01:24:24,699
o como un string con el new, este en principio

1016
01:24:24,699 --> 01:24:27,880
pues tiene que funcionar, entonces el método equals

1017
01:24:27,880 --> 01:24:33,100
como se comporta, es que devuelve

1018
01:24:33,100 --> 01:24:36,779
un verdadero o falso, si el valor

1019
01:24:36,779 --> 01:24:44,119
de la variable ese info es igual a la información que tengo aquí, es decir, el valor de la variable

1020
01:24:44,119 --> 01:24:51,159
ese info es igual a la información que tiene, con la que quiero comparar, devuelve un true.

1021
01:24:51,840 --> 01:25:02,850
Entonces, en este caso, ¿veis? Nos dice que ese info vale hola. No funcionaría en cualquier caso.

1022
01:25:02,989 --> 01:25:09,109
Entonces, cuando vayamos a comparar con strings, nunca comparamos, ya que tiene esa dualidad

1023
01:25:09,109 --> 01:25:15,470
hay entre tipo de datos primitivo y referenciado en realidad es un referencia en lugar de comparar

1024
01:25:15,470 --> 01:25:20,449
así que sí que es como lo hacemos con los tipos de datos primitivos lo que vamos a hacer va a

1025
01:25:20,449 --> 01:25:31,500
ser utilizar siempre el método y con el método compare tú el método de cuáles devuelve este

1026
01:25:31,500 --> 01:25:36,500
método devuelve un boolean el método de cuáles verdadero o falso si es igual devuelve verdadero

1027
01:25:36,500 --> 01:25:41,760
si no lo es devuelve falso mirada si no lo es vamos a hacer una ejecución sin que lo sea

1028
01:25:41,760 --> 01:25:50,399
sabiendo que ese info vale hola, lo vamos a comparar con hola2 para que no sea igual.

1029
01:25:50,619 --> 01:25:53,439
Entonces, al ser falso, esto no debería mostrarse ya.

1030
01:25:54,600 --> 01:25:58,340
Entonces, le damos aquí, ¿veis? Y ya nos muestra el mensaje, ese info vale hola.

1031
01:26:05,680 --> 01:26:08,279
¿Sí? ¿Alguien me dice que quiere comentar algo? ¿Sí?

1032
01:26:09,739 --> 01:26:26,689
¿Dime? ¿Hola? ¿Sí? ¿Alguien ha puesto un mensaje que dice que quería hablar, pero no te oigo?

1033
01:26:26,689 --> 01:26:39,760
No sé si estás hablando. A ver, por el chat, si habéis puesto algo.

1034
01:26:49,800 --> 01:26:57,220
¿José, querías hablar? Si quieres ponérmelo en el chat, porque no te escucho.

1035
01:27:02,489 --> 01:27:03,430
Bueno, continúo mientras.

1036
01:27:06,470 --> 01:27:11,229
Bueno, como os decía, el método equals devuelve verdadero o falso, como hemos visto por aquí.

1037
01:27:11,670 --> 01:27:17,670
Y luego está el método compareTo, que permite, bueno, da un poco más alternativa,

1038
01:27:17,670 --> 01:27:19,890
pero también permite ver si es verdadero o falso.

1039
01:27:19,890 --> 01:27:41,770
fijaros, el método compareTo, este método devuelve un entero, como podéis ver aquí, y si el valor es igual, lo que devuelve como entero es un 0.

1040
01:27:42,310 --> 01:27:52,229
Si uno de los valores, si este es mayor que este, devuelve un 1, un valor mayor de 0, y si este es mayor que este, devuelve un valor menor que 0.

1041
01:27:52,229 --> 01:28:00,670
Esto permite hacer ordenación, ordenar elementos según, por ejemplo, alfabéticamente si fuesen strings o bajo cualquier otro criterio de otra forma.

1042
01:28:01,310 --> 01:28:11,729
Esto ahora mismo no me compila porque los if hemos dicho que necesitan evaluar entre un boolean.

1043
01:28:11,850 --> 01:28:18,590
Entonces, como esto está devolviendo un número, pues tendremos que hacer una comparación, en este caso a cero.

1044
01:28:18,590 --> 01:28:37,779
Entonces si es cero es cuando los dos son iguales y en este caso como lo son, pues sería equivalente al equals este, le damos aquí, damos a la ejecución y dice ese info vale hola, también sería una forma para poder comparar los strings.

1045
01:28:37,779 --> 01:28:43,859
a ver, me ponían por aquí

1046
01:28:43,859 --> 01:28:47,739
me ponían por aquí

1047
01:28:47,739 --> 01:28:49,239
una consulta

1048
01:28:49,239 --> 01:28:51,460
una duda sobre el ejemplo de los euros

1049
01:28:51,460 --> 01:28:55,800
a ver si lo localizamos

1050
01:28:55,800 --> 01:28:56,840
el ejemplo de los euros

1051
01:28:56,840 --> 01:28:58,600
no sé dónde está exactamente

1052
01:28:58,600 --> 01:29:12,960
hotstream, tipos enumerados

1053
01:29:12,960 --> 01:29:21,979
uy, si no

1054
01:29:21,979 --> 01:29:25,020
no sé si no se te activa

1055
01:29:25,020 --> 01:29:26,539
el micro, si te parece

1056
01:29:26,539 --> 01:29:28,899
ponme justo dónde está

1057
01:29:28,899 --> 01:29:30,060
la duda en el

1058
01:29:30,060 --> 01:29:32,880
porque es que no sé localizarlo, por no marear mucho

1059
01:29:32,880 --> 01:29:40,079
aquí ahora con la grabación. Pónmelo en el foro y lo miro y te respondo luego, si no te importa.

1060
01:29:40,880 --> 01:29:45,399
O si podemos hablar para ir más directo, me dice justo dónde está el ejercicio ese y lo vemos más

1061
01:29:45,399 --> 01:29:50,100
directo. Es que me está poniendo en el chat la consulta sobre una duda del ejercicio de los euros.

1062
01:29:50,819 --> 01:30:04,800
Pónmela en el chat, si no te importa. Y si no te funciona el micro. No, yo no, me dice... Vale, lo dejamos

1063
01:30:04,800 --> 01:30:13,100
para el foro. Vale, perfecto, así lo hacemos, si no te importa. Vale, pues nada, para comparar streams

1064
01:30:13,100 --> 01:30:16,119
aunque hemos visto que sí que hay alguna alternativa

1065
01:30:16,119 --> 01:30:19,300
en la que parece que se traga este tipo de comparación

1066
01:30:19,300 --> 01:30:22,180
mejor es lo que se recomienda

1067
01:30:22,180 --> 01:30:24,899
en todas partes y además hemos visto que en algún caso

1068
01:30:24,899 --> 01:30:28,340
podría no funcionar, strings acordaros de hacer la comparación

1069
01:30:28,340 --> 01:30:31,340
con el compare to o con el equals

1070
01:30:31,340 --> 01:30:34,140
mejor que con esta otra técnica

1071
01:30:34,140 --> 01:30:46,199
a ver que más cosas podemos hablar

1072
01:30:46,199 --> 01:30:54,210
sobre ellas, bueno habréis visto

1073
01:30:54,210 --> 01:31:02,010
en, bueno habéis visto que ya vamos utilizando otra y en la teoría

1074
01:31:02,010 --> 01:31:05,149
que en Java podemos meter comentarios, los comentarios

1075
01:31:05,149 --> 01:31:10,010
no los considera para nada el compilador y tenemos comentarios de una

1076
01:31:10,010 --> 01:31:13,789
línea, que son los que aparecen con las dos barras

1077
01:31:13,789 --> 01:31:17,189
o de multilínea, que son los que aparecen

1078
01:31:17,189 --> 01:31:22,050
entre la barra y el asterisco, podemos meter

1079
01:31:22,050 --> 01:31:26,090
tantas líneas como sean y asterisco y barra, Eclipse para identificarnos

1080
01:31:26,090 --> 01:31:30,649
las zonas que son de comentarios pues no lo pone en verde nada nos echa una manilla de esa forma

1081
01:31:30,649 --> 01:31:38,390
cuando llamamos al compilador de java si encuentra algo de esto pues directamente no lo considera y

1082
01:31:38,390 --> 01:31:42,590
se queda simplemente para el fichero esa información se queda simplemente para el

1083
01:31:42,590 --> 01:31:48,529
fichero punto java y bueno los comentarios pues pues sí que siempre están muy recomendados porque

1084
01:31:48,529 --> 01:31:54,149
luego ayudar mucho para mantener el código si de repente nos da tenemos que hacer un mantenimiento

1085
01:31:54,149 --> 01:32:00,789
y hay alguna zona de código un poco más complicada, si tiene sus comentarios, pues viene muy bien.

1086
01:32:02,029 --> 01:32:08,270
Luego hay otros comentarios, esto yo creo que lo veréis en la asignatura de entorno de desarrollo,

1087
01:32:08,989 --> 01:32:14,390
hay otros comentarios que son los que empiezan, para que el compilador de Java no lo considere,

1088
01:32:14,470 --> 01:32:22,090
tiene que empezar con asterisco y esa barra asterisco, terminar con asterisco barra, así en multilínea.

1089
01:32:22,090 --> 01:32:46,569
Pero si ponemos barra y dos asteriscos, esto lo que le estamos diciendo al compilador de Java es no lo consideres porque está empezando así, pero luego hay otros programas como por ejemplo Javadoc, que es un programita que viene incluido en el JDK también cuando lo instalamos.

1090
01:32:46,569 --> 01:32:50,390
ahí está el programita, este javadoc, igual que tenemos el programa

1091
01:32:50,390 --> 01:32:54,250
javaz o java, el intérprete, pues está este, y este

1092
01:32:54,250 --> 01:32:58,130
cuando ejecutas este, lo que busca es esta etiqueta de inicio

1093
01:32:58,130 --> 01:33:02,310
no esta, que esta es la que utiliza el compilador, sino que

1094
01:33:02,310 --> 01:33:05,689
utiliza esta otra, y si ponemos aquí una serie de etiquetas

1095
01:33:05,689 --> 01:33:10,550
que tienen que ser acordes a lo que espera encontrar

1096
01:33:10,550 --> 01:33:14,869
javadoc, luego automáticamente este programa te genera documentación

1097
01:33:14,869 --> 01:33:17,970
cosa que te ahorra mucho trabajo

1098
01:33:17,970 --> 01:33:21,850
crear la estructura de las clases, los métodos

1099
01:33:21,850 --> 01:33:24,430
el autor

1100
01:33:24,430 --> 01:33:27,890
pero para eso dentro de estas etiquetas

1101
01:33:27,890 --> 01:33:30,649
que son las que va a leer este programa

1102
01:33:30,649 --> 01:33:33,289
pues hay que meterlo con una determinada sintaxis

1103
01:33:33,289 --> 01:33:34,729
no vale poner cualquier cosa

1104
01:33:34,729 --> 01:33:38,170
eso es si estudias Javadoc, solo comentarlo

1105
01:33:38,170 --> 01:33:41,590
y creo que algo lo veréis en la asignatura de entornos de desarrollo

1106
01:33:41,590 --> 01:33:51,789
si no la habéis cursado todavía las los comentarios estos de una sola línea se considera desde que lo

1107
01:33:51,789 --> 01:33:56,470
encuentras hasta final de línea comentario entonces si quieres poner un comentario directamente en

1108
01:33:56,470 --> 01:34:04,789
toda la línea lo pones así y si no podrías poner algo de código igual igual a 3 y luego bueno pues

1109
01:34:04,789 --> 01:34:11,189
pones aquí variable que haga lo que sea entonces realmente el compilador tendrá en cuenta de aquí

1110
01:34:11,189 --> 01:34:13,609
para allá y todo esto ya lo considera

1111
01:34:13,609 --> 01:34:14,989
comentario

1112
01:34:14,989 --> 01:34:17,710
no lo tienen consideración

1113
01:34:17,710 --> 01:34:18,869
para generar el bytecode

1114
01:34:18,869 --> 01:34:24,760
y a ver si tengo más cositas por aquí

1115
01:34:24,760 --> 01:34:29,579
apuntadas, bueno pues

1116
01:34:29,579 --> 01:34:31,260
tengo también anotado por ahí

1117
01:34:31,260 --> 01:34:33,600
pero bueno, durante el curso

1118
01:34:33,600 --> 01:34:35,000
y en otros temas también

1119
01:34:35,000 --> 01:34:37,159
lo desarrollamos un poco más

1120
01:34:37,159 --> 01:34:39,739
pues hablar un poco de algunas clases

1121
01:34:39,739 --> 01:34:41,640
como es de las librerías que tenemos

1122
01:34:41,640 --> 01:34:42,619
como la clase math

1123
01:34:42,619 --> 01:34:45,800
o la clase scanner, ya hemos hablado de ella un poco

1124
01:34:45,800 --> 01:34:50,699
o la clase string

1125
01:34:50,699 --> 01:34:54,920
que fijaros, string al ser un tipo referenciado

1126
01:34:54,920 --> 01:34:58,640
es una clase, no lo hacemos el new por aquella mezcla

1127
01:34:58,640 --> 01:35:02,779
entre primitivos y referenciados que decíamos, pero luego tiene sus métodos

1128
01:35:02,779 --> 01:35:08,289
y los métodos de la clase string, pues es que

1129
01:35:08,289 --> 01:35:13,640
hay muchos métodos que son muy interesantes, pues otro día

1130
01:35:13,640 --> 01:35:18,039
hablamos sobre ellos también un rato, si está vacía

1131
01:35:18,039 --> 01:35:20,979
el último hace búsquedas de cadenas

1132
01:35:20,979 --> 01:35:22,899
de caracteres dentro de toda la cadena

1133
01:35:22,899 --> 01:35:29,000
el equals este que hemos dicho, el compare to

1134
01:35:29,000 --> 01:35:32,779
si termina con un determinado sufijo, prefijo, tiene un montón de métodos

1135
01:35:32,779 --> 01:35:37,180
para trabajar con strings

1136
01:35:37,180 --> 01:35:43,359
otra etiqueta que os comentaba antes

1137
01:35:43,359 --> 01:35:46,600
y yo creo que con esta ya vamos a ir finiquitando

1138
01:35:46,600 --> 01:35:50,800
es otra palabra reservada, la palabra

1139
01:35:50,800 --> 01:35:54,739
return. La palabra return lo que hace es sacarnos de un determinado

1140
01:35:54,739 --> 01:35:58,239
método. Entonces fijaros, si cogemos nosotros, ponemos aquí

1141
01:35:58,239 --> 01:36:05,310
llamamos al método saludar, decimos saludar, vamos a decirle

1142
01:36:05,310 --> 01:36:12,529
que diga hola. Estamos llamando un método, fijaros, el método

1143
01:36:12,529 --> 01:36:18,039
saludar, y en particular la definición de este método saludar no tiene

1144
01:36:18,039 --> 01:36:21,939
ningún parámetro aquí definido. Y en cambio estoy intentando

1145
01:36:21,939 --> 01:36:27,180
hacer una llamada pasándole un parámetro con lo cual como no existe un método que

1146
01:36:27,180 --> 01:36:33,939
definido para saludar que tenga que recibe un método que sea del tipo cadena de caracteres

1147
01:36:33,939 --> 01:36:40,720
pues no me está compilando entonces yo pongo aquí string ese info pues ahora ya me compila

1148
01:36:40,720 --> 01:36:46,840
durante la ejecución de este método de los métodos hablamos en el siguiente tema también sabe todo

1149
01:36:46,840 --> 01:36:53,859
esto lo repetiré cuando llega el código a esta línea lo que hará será hacer un salto para ponerse

1150
01:36:53,859 --> 01:36:58,739
ejecutar este método se vendrá a ejecutar lo que haya por aquí y antes de empezar a ejecutar el

1151
01:36:58,739 --> 01:37:05,180
código que hay en su ámbito mirará el parámetro este y su información se lo cargará a esta variable

1152
01:37:05,180 --> 01:37:16,460
entonces es info en esta ejecución valdrá hola si hacemos un saludar con adiós pues este es info

1153
01:37:16,460 --> 01:37:25,479
valdrá a dios mira así para ver cómo puede funcionar el retorno vamos a poner aquí un

1154
01:37:25,479 --> 01:37:45,369
sistema punto out punto println saliendo del método saludar fijaros que aquí no me está

1155
01:37:45,369 --> 01:37:51,829
si me queja no me compila y si nos ponemos sobre él me dice que lo borre porque es un código

1156
01:37:51,829 --> 01:37:58,369
inalcanzable y por qué nunca lo va a alcanzar pues porque aquí tiene un retorno si decimos que el

1157
01:37:58,369 --> 01:38:04,850
método acaba cuando se encuentra el retorno pues este código nunca lo va a alcanzar entonces para

1158
01:38:04,850 --> 01:38:11,090
para que sí que lo alcance y hacer alguna prueba podríamos poner aquí un if y decir que si ese info

1159
01:38:11,090 --> 01:38:21,050
es igual por ejemplo a dios que se salga pues ese info podríamos pedir cuerpo nos pediría poner esto

1160
01:38:21,050 --> 01:38:29,489
pero esto no nos gusta vale esto lo consideraremos como que está mal lo que haríamos sería punto como

1161
01:38:29,489 --> 01:38:41,510
es un string punto de quals y aquí ponemos adiós fijaros en una ejecución primera ese info valdrá

1162
01:38:41,510 --> 01:38:48,050
hola este no será igual a dios con lo cual no ejecutaría el código de leaf vamos a ponerlo

1163
01:38:48,050 --> 01:38:56,069
entre llaves mejor y en la segunda ejecución adiós ese info valdría adiós porque lo ha cargado aquí

1164
01:38:56,069 --> 01:39:02,310
con lo cual esto sería verdadero y nos mostraría un retorno fijaros como ahora ya sí que hay algún

1165
01:39:02,310 --> 01:39:07,689
momento en el que este código se puede ejecutar y ya nos ha pasado a compilar que antes no lo

1166
01:39:07,689 --> 01:39:13,229
hacía porque porque el retorno no necesariamente se va a producir en todos los casos cuando valga

1167
01:39:13,229 --> 01:39:19,500
algo cuando ese info valga diferente de adiós este código sí que se ejecutará entonces si lanzamos la

1168
01:39:19,500 --> 01:39:34,000
ejecución fijaros como entra con hola veis nos muestra este un saludo por aquí y nos muestra

1169
01:39:34,000 --> 01:39:41,460
saliendo del método saludar vuelve aquí nos hace una ejecución con adiós ese info valdrá adiós nos

1170
01:39:41,460 --> 01:39:47,699
muestra un saludo pero ahora como vale adiós hace un return y ya este no aparece es decir return lo

1171
01:39:47,699 --> 01:39:58,079
que hace es sacarnos del método que se recomienda pues en un código podéis poner más de un return

1172
01:39:58,079 --> 01:40:15,189
fijaros podéis poner aquí es y si es bye vamos a suponer que haga lo mismo veis pues tenemos aquí

1173
01:40:15,189 --> 01:40:20,890
dos retos validaría uno se va por el retorno valía daría otro seguiría por el retorno en cualquiera

1174
01:40:20,890 --> 01:40:27,210
de los dos casos en este caso como hace lo mismo podríamos poner aquí una condición or para que

1175
01:40:27,210 --> 01:40:31,890
fuese si es esto o es lo otro pero bueno me interesaba ahora ponerlo separado porque quería

1176
01:40:31,890 --> 01:40:41,670
poner los dos retos se desaconseja un poco el utilizar muchos retos dentro de una dentro de

1177
01:40:41,670 --> 01:40:49,350
un método está en línea que lo desaconsejan porque porque si siempre estos casos lo mejor es irse un

1178
01:40:49,350 --> 01:40:55,649
poco hacer el bruto imaginaos que esto tiene mil líneas de código y en las y claro no te no te

1179
01:40:55,649 --> 01:40:59,890
permite ver todo el método en una pantalla para ver exactamente de un vistazo de lo que pasa

1180
01:40:59,890 --> 01:41:04,489
entonces igual tú estar centrado en una parte de código en las últimas 50 líneas

1181
01:41:04,489 --> 01:41:08,250
que crees que te está dando un error, das a ejecuciones, te estás fijando

1182
01:41:08,250 --> 01:41:12,149
en esas 50 líneas y el código nunca te llega allí y a lo mejor es porque

1183
01:41:12,149 --> 01:41:15,130
en las primeras hay un return y se te está yendo por allí

1184
01:41:15,130 --> 01:41:20,229
entonces lo que suelen recomendar un poco es que las condiciones para que

1185
01:41:20,229 --> 01:41:24,090
se vaya, pues solo pongas un return más bien hacia el final

1186
01:41:24,090 --> 01:41:27,789
del método y si tienes que tener diferentes condiciones

1187
01:41:27,789 --> 01:41:31,430
las vayas cargando con, a lo mejor con un if en una variable

1188
01:41:31,430 --> 01:41:36,029
para asegurarte que no se sale

1189
01:41:36,029 --> 01:41:39,569
en cualquier sitio y que el punto de salida del método es único

1190
01:41:39,569 --> 01:41:43,909
pero bueno, Java permite poner muchos returns aunque lo que

1191
01:41:43,909 --> 01:41:49,489
suelen aconsejar es lo otro, solo poner uno. La etiqueta está return

1192
01:41:49,489 --> 01:41:52,550
a veces la veremos que

1193
01:41:52,550 --> 01:41:57,710
aparte de decir simplemente return salen, salir, devuelva

1194
01:41:57,710 --> 01:42:01,949
una información que podrá ser un número, podrá ser una cadena

1195
01:42:01,949 --> 01:42:06,210
de caracteres, podrá ser lo que sea, podrá devolver

1196
01:42:06,210 --> 01:42:09,949
algo, para que cuando salga meter algo más

1197
01:42:09,949 --> 01:42:13,869
información aquí, lo que se hace en los métodos

1198
01:42:13,869 --> 01:42:17,890
es que el método cuando sea llamado devuelva

1199
01:42:17,890 --> 01:42:21,270
algo, pero bueno eso lo vemos en el siguiente tema porque es justo

1200
01:42:21,270 --> 01:42:26,189
sobre lo que trata, entonces cuando estemos repasando echamos un ratillo

1201
01:42:26,189 --> 01:42:42,989
Es decir, ahora quedaros solo con que return puede no tener nada, dependerá del caso o podrá estar devolviendo algo, a lo mejor un número entero o un valor, un código de cómo ha ido la ejecución de este método para que luego sea valorado o sea evaluado desde el sitio donde se ha llamado.

1202
01:42:42,989 --> 01:42:48,829
ya os digo esto lo vemos en las siguientes clases que yo creo que se trata justo en el tema que viene

1203
01:42:48,829 --> 01:42:57,300
y bueno no sé si yo creo que no voy a arrancar con nada nuevo ya son las 7 y cuarto

1204
01:42:57,300 --> 01:43:03,399
si tenéis alguna duda de lo que hemos visto hoy o alguna cosa que queréis comentar comentemos

1205
01:43:03,399 --> 01:43:10,479
el ejercicio ese que me sugeríais ahí en el chat poner en el foro y luego lo echo un ojo y os respondo

1206
01:43:10,479 --> 01:43:14,659
esta noche o mañana. La clase la subo como siempre

1207
01:43:14,659 --> 01:43:18,539
para que la tengáis disponible si alguien quiere volver a echarle

1208
01:43:18,539 --> 01:43:22,500
un ojo. Y nada, si me queréis comentar

1209
01:43:22,500 --> 01:43:25,260
alguna cosita, a vuestra disposición estoy este ratito.

1210
01:43:33,130 --> 01:43:37,289
¿No tenéis nada? Pues yo creo que vamos a ir parando entonces

1211
01:43:37,289 --> 01:43:43,289
ya si os parece. El siguiente tema

1212
01:43:43,289 --> 01:43:46,510
esta noche, a lo largo del día de mañana os lo abro

1213
01:43:46,510 --> 01:43:56,470
y nada pues seguimos trabajando sobre él vale bueno pues nada voy deteniendo aquí