1
00:00:00,880 --> 00:00:14,300
Ya estamos grabando. Pues nada, ¿tenéis alguna cosilla por ahí que queréis que comentemos antes de repasar otras cosas por ahí? ¿Alguna duda que tengáis de lo que hayáis podido ver en el tema 2?

2
00:00:14,300 --> 00:00:25,579
Este tema 2 es sencillo en principio, el tema 3 tampoco introduce así gran complejidad

3
00:00:25,579 --> 00:00:31,420
Pero claro, es muy fácil decirlo si ya has programado antes, como es mi caso y el caso de muchos de vosotros

4
00:00:31,420 --> 00:00:37,780
Por lo que he podido ver en las tareas, pero claro, para quien está empezando quizás sí que sea un nuevo mundo

5
00:00:37,780 --> 00:00:43,060
Y necesite su tiempo para asentar los conceptos

6
00:00:43,060 --> 00:01:01,380
En cualquier caso, no me habéis preguntado mucho por ahí por el foro, así que entiendo que algunos no habréis podido dedicar quizás el tiempo que os hubiera gustado y otros no habéis tenido dudas. ¿Alguna cosita queréis comentarme antes de arrancar?

7
00:01:01,380 --> 00:01:29,280
Vale, pues mañana abrimos el tema 3 ya. El tema 3 introduce, digamos, normalmente cuando tenemos un proyecto, ya hemos hablado que arrancan nuestros proyectos, arrancan en una determinada clase.

8
00:01:29,280 --> 00:01:35,269
en Java todos son clases en principio, voy a crear un proyecto

9
00:01:35,269 --> 00:01:44,290
que se llame prueba y todo proyecto necesita tener un método

10
00:01:44,290 --> 00:01:47,750
en una de sus clases que sea el método main, porque el inicio

11
00:01:47,750 --> 00:01:52,209
de los programas, como hemos dicho ya, empiezan en ese método.

12
00:01:52,750 --> 00:01:56,329
Es cierto que varias clases pueden tener un método main y

13
00:01:56,329 --> 00:01:59,930
digamos tener diferentes puntos de entrada, bueno, pues porque

14
00:01:59,930 --> 00:02:04,049
si queremos probar ciertas cosas en particular de una clase, podemos ponerle el método main

15
00:02:04,049 --> 00:02:08,090
para probarla de forma individual, pero como proyecto

16
00:02:08,090 --> 00:02:11,810
en su conjunto, lo normal es que haya un único método de este tipo, método main

17
00:02:11,810 --> 00:02:15,729
para todo el proyecto y a partir de ahí, bueno, pues se empiece a llamar

18
00:02:15,729 --> 00:02:18,889
a diferentes métodos o a quien vaya correspondiendo.

19
00:02:19,770 --> 00:02:23,949
Se vayan creando objetos, todo lo que venimos hablando ya estos días y que continuaremos

20
00:02:23,949 --> 00:02:30,780
a lo largo del curso. Entonces, cuando tú tienes

21
00:02:30,780 --> 00:02:33,960
una, bueno, pues a partir del método main o en cualquier otra

22
00:02:33,960 --> 00:02:36,620
sentencia, pues el código va

23
00:02:36,620 --> 00:02:39,120
de forma secuencial ejecutándose de arriba a abajo.

24
00:02:41,110 --> 00:02:44,449
Vamos a poner aquí clase print, voy a crear una clase.

25
00:02:48,379 --> 00:02:50,180
La asignatura o

26
00:02:50,180 --> 00:02:53,020
digamos cabecera de

27
00:02:53,020 --> 00:02:56,000
un método, se suele llamar asignatura

28
00:02:56,000 --> 00:02:59,219
como firma, firsignatur, del método

29
00:02:59,219 --> 00:03:01,520
main es esta public static

30
00:03:01,520 --> 00:03:03,180
void main

31
00:03:03,180 --> 00:03:05,639
string

32
00:03:05,639 --> 00:03:09,580
al s

33
00:03:09,580 --> 00:03:13,360
todas estas palabras claves

34
00:03:13,360 --> 00:03:15,560
aportan algo al método

35
00:03:15,560 --> 00:03:17,400
y ya lo iremos comentando

36
00:03:17,400 --> 00:03:19,280
a lo mejor hoy vamos hablando ya un poquillo de ello

37
00:03:19,280 --> 00:03:20,939
aunque en temas posteriores

38
00:03:20,939 --> 00:03:22,919
se va haciendo un desarrollo

39
00:03:22,919 --> 00:03:25,439
se va haciendo una revisión de cada una de estas

40
00:03:25,439 --> 00:03:27,219
etiquetas para lo que sirven

41
00:03:27,219 --> 00:03:29,199
de la de static ya estuvimos hablando

42
00:03:29,199 --> 00:03:30,819
estos días atrás

43
00:03:30,819 --> 00:03:33,219
cuando vayamos haciendo algún ejercicio

44
00:03:33,219 --> 00:03:35,500
redundamos un poquito en su

45
00:03:35,500 --> 00:03:43,240
descripción y luego los métodos os decía cuando teníamos una clase en este caso la clase print

46
00:03:43,240 --> 00:03:49,460
pues estaba compuesta por una serie de atributos que son características propias de todo objeto

47
00:03:49,460 --> 00:03:54,919
que tenga que ver con esta clase y clase print bueno pues una clase que he creado para trabajar

48
00:03:54,919 --> 00:03:59,900
en el proyecto pero típicamente pues sería como os decía la clase persona pues sus atributos serían

49
00:03:59,900 --> 00:04:05,120
características particulares de toda persona todo objeto de la clase persona que fuéramos

50
00:04:05,120 --> 00:04:09,939
construyendo como podrían ser en diferentes contextos serían diferentes atributos pero

51
00:04:09,939 --> 00:04:14,780
bueno podría ser en este caso el nombre el apellido el dni todo este tipo de información

52
00:04:14,780 --> 00:04:21,319
típica de las personas en un coche pues si fuera la clase coche pues los objetos de clase coche

53
00:04:21,319 --> 00:04:28,980
con atributos podrían tener pues la cilindrada ser el motor tipo de motor marca bueno diferentes

54
00:04:28,980 --> 00:04:34,639
características propias de los coches y luego decíamos que teníamos los métodos que son los

55
00:04:34,639 --> 00:04:37,660
a los que invocamos, a los que vamos llamando

56
00:04:37,660 --> 00:04:40,420
para que vayan realizando acciones.

57
00:04:40,740 --> 00:04:43,759
Los métodos que tienen que ver con acciones

58
00:04:43,759 --> 00:04:46,800
dentro del método tienen un ámbito,

59
00:04:47,040 --> 00:04:49,620
una llave de apertura y cierre, que es

60
00:04:49,620 --> 00:04:52,740
todo el ámbito donde trabaja el método y por aquí

61
00:04:52,740 --> 00:04:55,480
iremos metiendo la secuencia de instrucciones

62
00:04:55,480 --> 00:04:58,740
que se ejecutan cuando invocamos ese

63
00:04:58,740 --> 00:05:03,509
método en particular. La ejecución de un método,

64
00:05:03,509 --> 00:05:06,949
de todo método en Java, pues se hace de forma secuencial, va de arriba a abajo.

65
00:05:09,120 --> 00:05:15,100
En esta asignatura vemos, el año que viene veréis una asignatura que es la asignatura

66
00:05:15,100 --> 00:05:21,439
de programación de servicios y procesos, que permiten la ejecución de diferentes líneas de código

67
00:05:21,439 --> 00:05:27,500
de forma paralela, aprovechando que las máquinas, los ordenadores, pues pueden tener varios procesadores,

68
00:05:27,500 --> 00:05:32,519
pues decir, mira, si no es obligatorio tener los resultados de unas instrucciones anteriores

69
00:05:32,519 --> 00:05:37,160
para ejecutar las siguientes, podemos dividir esas instrucciones en dos bloques

70
00:05:37,160 --> 00:05:41,540
y que cada uno de esos bloques lo ejecute uno de los procesadores que tiene mi equipo.

71
00:05:42,379 --> 00:05:49,139
De tal forma que ganamos ahí en velocidad de ejecución, en rendimiento de nuestro programa.

72
00:05:49,800 --> 00:05:54,500
Para eso lo tiene que permitir el programa, no tiene que haber una obligatoriedad

73
00:05:54,500 --> 00:05:57,019
de secuenciación de unas instrucciones con otras.

74
00:05:57,019 --> 00:06:08,720
y bueno, esto sería una forma de trabajar en base a procesos o a hilos, pero bueno, si ya os digo que corresponde a la asignatura de programación de servicios y procesos que igual curséis el año que viene.

75
00:06:09,579 --> 00:06:16,920
En esta solamente trabajamos con un procesador y va todo de seguido, con lo cual el método main, si tenemos aquí una instrucción 1,

76
00:06:18,980 --> 00:06:26,959
instrucción 1, pues después de la instrucción 1, pues ejecuta la instrucción 2, luego la 3 y de esta forma secuencial una detrás de otra.

77
00:06:27,019 --> 00:06:32,519
es decir, el flujo de programa por defecto es una instrucción detrás de otra

78
00:06:32,519 --> 00:06:37,740
pero tenemos la opción de poder ejecutar un bloque de instrucciones

79
00:06:37,740 --> 00:06:42,980
y que se repita o meter una condición en un momento dado

80
00:06:42,980 --> 00:06:45,360
para que unas instrucciones se ejecuten o no

81
00:06:45,360 --> 00:06:50,500
estas son las estructuras de control que vamos a ver en el tema que viene

82
00:06:50,500 --> 00:06:55,100
y que muchos de vosotros en esta primera tarea

83
00:06:55,100 --> 00:07:02,540
ya incluso habéis utilizado, bien porque las habéis investigado o bien porque tenéis ya cierta experiencia programando

84
00:07:02,540 --> 00:07:08,240
y como son conceptos de inicio de todos los lenguajes de programación, pues ya más o menos lo conocíais.

85
00:07:10,910 --> 00:07:19,029
Bien, esto es lo que vemos en el tema 2. En el tema 3, las secuencias de control condicionales, es decir,

86
00:07:19,029 --> 00:07:26,579
Si pasa algo, se cumple una determinada condición, pues ejecuto una serie de instrucciones.

87
00:07:26,740 --> 00:07:28,899
La A, la B, la C.

88
00:07:29,480 --> 00:07:37,699
Si no pasa eso, si no pasa ese algo, pues podemos ejecutar otras instrucciones.

89
00:07:38,360 --> 00:07:41,920
Entonces, en esa secuencia lineal del programa, de arriba a abajo, cuando llega aquí,

90
00:07:42,220 --> 00:07:47,740
si esto es cierto, lo que se ejecuta son este primer bloque de instrucciones, pero estas no.

91
00:07:47,740 --> 00:07:52,620
Y si eso no es cierto, estas no se ejecutan y las que se ejecutan serían estas otras.

92
00:07:53,879 --> 00:07:57,959
Es decir, son instrucciones de control de selección.

93
00:07:58,620 --> 00:08:06,139
Y luego están las instrucciones de control de repetición que vienen a ser mientras hay diferentes alternativas con la sintaxis,

94
00:08:06,420 --> 00:08:13,180
pero mientras esté pasando algo, mientras un número sea menor de 10.

95
00:08:13,180 --> 00:08:16,420
pues entonces ejecuto aquí una serie de instrucciones

96
00:08:16,420 --> 00:08:17,959
las que pongamos

97
00:08:17,959 --> 00:08:20,800
y se va repitiendo

98
00:08:20,800 --> 00:08:23,079
normalmente dentro de este código

99
00:08:23,079 --> 00:08:25,300
se producirá algún cambio

100
00:08:25,300 --> 00:08:27,360
para que esto no se convierta en un bucle infinito

101
00:08:27,360 --> 00:08:29,139
y se quede el programa eternamente aquí

102
00:08:29,139 --> 00:08:32,940
imaginaos que la condición es una variable de tipo entero

103
00:08:32,940 --> 00:08:35,600
mientras la variable S sea menor de 10

104
00:08:35,600 --> 00:08:38,720
entonces aquí típicamente podríamos tener que

105
00:08:38,720 --> 00:08:42,639
esa variable va incrementando su valor

106
00:08:42,639 --> 00:08:47,500
de uno en uno, de dos en dos, bueno, según el algoritmo nos lo requiera

107
00:08:47,500 --> 00:08:53,740
y tras una serie de pasadas, como esto va cambiando su valor x,

108
00:08:54,059 --> 00:08:56,299
pues habrá un momento en el que dejará esto de ser cierto

109
00:08:56,299 --> 00:08:58,919
y dejará de producirse la repetición.

110
00:08:58,919 --> 00:09:03,460
En ese caso, este bloque que está relacionado con este bucle,

111
00:09:03,879 --> 00:09:09,759
esta estructura de control repetitiva, terminaría y el programa seguiría por aquí.

112
00:09:11,100 --> 00:09:12,480
Bueno, sobre esto trabajaremos.

113
00:09:12,639 --> 00:09:16,539
tenemos, me parece que son dos o tres semanas para este segundo tema

114
00:09:16,539 --> 00:09:20,399
y los conceptos, aunque son imprescindibles de manejar bien

115
00:09:20,399 --> 00:09:23,179
porque en todos los programas nos van a aparecer estructuras de control

116
00:09:23,179 --> 00:09:28,259
de estos dos tipos, yo creo que se cogen más o menos rápido

117
00:09:28,259 --> 00:09:31,919
entre que repasamos los conceptos y luego hagamos ejercicios

118
00:09:31,919 --> 00:09:34,340
pues lo tendremos ahí resuelto.

119
00:09:37,309 --> 00:09:38,889
Probablemente hablemos de esto la semana que viene

120
00:09:38,889 --> 00:09:43,090
o no sé si hay un poquito, si luego nos apetece

121
00:09:43,090 --> 00:09:44,450
antes de arrancar el tema.

122
00:09:45,309 --> 00:09:49,389
¿Cosas del tema 2 que quedaron por comentar?

123
00:09:49,529 --> 00:09:51,149
Pues bueno, en verdad pocas, ¿no?

124
00:09:51,970 --> 00:09:58,250
Sí que he visto, bueno, las prácticas, los que habéis tenido la oportunidad del ratillo para poder hacerlas y entregarlas,

125
00:09:58,389 --> 00:10:00,350
estaban bastante bien en líneas generales.

126
00:10:00,350 --> 00:10:04,309
Es cierto que todavía no tenían mucha complejidad la práctica de este tema.

127
00:10:05,509 --> 00:10:08,429
Y bueno, simplemente comentaros al menos un par de cosas.

128
00:10:08,429 --> 00:10:12,690
cuando hablábamos en las

129
00:10:12,690 --> 00:10:15,710
tutorías anteriores que nuestros programas los comunicamos

130
00:10:15,710 --> 00:10:18,009
con el mundo exterior a través de flujos de datos

131
00:10:18,009 --> 00:10:21,429
y teníamos estos flujos de datos

132
00:10:21,429 --> 00:10:24,330
decíamos que había tres flujos de datos estándar, ahora

133
00:10:24,330 --> 00:10:27,269
los retomamos y luego podíamos habilitar otro tipo de

134
00:10:27,269 --> 00:10:30,049
flujos de datos para comunicación entre aplicaciones como

135
00:10:30,049 --> 00:10:33,149
podían ser los sockets, un flujo de datos para leer

136
00:10:33,149 --> 00:10:36,049
información o escribir información en ficheros

137
00:10:36,049 --> 00:10:39,669
pues ahí abrimos también un flujo de datos, una tubería

138
00:10:39,669 --> 00:10:41,929
desde nuestro programa, cuyo destino en este caso

139
00:10:41,929 --> 00:10:45,490
si vamos a escribir es un fichero y la lectura

140
00:10:45,490 --> 00:10:48,330
pues el origen de los datos sería el fichero y el otro lado

141
00:10:48,330 --> 00:10:51,429
de la tubería del flujo de datos se enchufa

142
00:10:51,429 --> 00:10:52,750
en nuestro programa.

143
00:10:54,289 --> 00:10:57,590
Cuando es un socket, pues un lado de la tubería está enchufado

144
00:10:57,590 --> 00:11:00,309
en nuestro programa y el otro lado en otro programa diferente.

145
00:11:00,470 --> 00:11:03,629
Al final es un caminito por el cual trasladamos información

146
00:11:03,629 --> 00:11:06,309
a nuestro programa desde el mundo exterior.

147
00:11:07,610 --> 00:11:10,789
Y por defecto, os decía el otro día que se habilitan

148
00:11:10,789 --> 00:11:13,289
tres flujos de datos en todos los programas,

149
00:11:13,289 --> 00:11:25,070
que son el STDIN, el STDOUT y el STSTANDARDERROR.

150
00:11:25,710 --> 00:11:30,570
El STDIN está asociado, los tres tienen uno de los lados

151
00:11:30,570 --> 00:11:32,289
de la tubería enganchado en nuestro programa

152
00:11:32,289 --> 00:11:40,789
y el otro, en el caso del STD in en el teclado, el STD out en pantalla y el STD air en pantalla.

153
00:11:43,129 --> 00:11:49,710
Java tiene medios para poder enchufar el otro extremo, el que no está conectado a nuestro programa,

154
00:11:49,809 --> 00:11:57,629
de cualquiera de estos tres flujos, digamos a otro elemento que no sean los que tienen considerados por defecto,

155
00:11:57,629 --> 00:11:59,669
pero en principio, bueno, no nos interesa.

156
00:12:01,289 --> 00:12:03,629
Junto a los flujos de datos que se activan por defecto,

157
00:12:04,669 --> 00:12:07,850
existen, bueno, se te di en System Name, ¿no?

158
00:12:08,029 --> 00:12:10,830
System Name, ¿no?

159
00:12:11,389 --> 00:12:14,629
Vale, junto con los flujos de entrada,

160
00:12:15,409 --> 00:12:17,090
pues tenemos una serie de librerías.

161
00:12:17,269 --> 00:12:19,629
Y estas librerías en Java, lo que nos proporcionan,

162
00:12:20,549 --> 00:12:23,350
en nuestros programas, decíamos dos días atrás,

163
00:12:23,850 --> 00:12:26,629
que están compuestos por las clases que nosotros desarrollamos,

164
00:12:26,629 --> 00:12:34,590
que en principio buscarán dar respuesta, tendrán los elementos principales para dar respuesta al algoritmo que queremos resolver

165
00:12:34,590 --> 00:12:44,529
y junto a nuestras clases sobre las que trabajamos nosotros directamente incluimos otras clases que Java ha desarrollado para nosotros

166
00:12:44,529 --> 00:12:54,509
y que las tiene en librerías. Las librerías de Java ya tienen por ejemplo desarrolladas clases que nos facilitan cómo poder acceder

167
00:12:54,509 --> 00:12:57,830
a la información desde teclado, de este flujo de datos.

168
00:12:59,289 --> 00:13:04,149
Entonces, el hecho de tener esa posibilidad nos permite que simplemente

169
00:13:04,149 --> 00:13:08,830
llamando a esas clases, a sus métodos y a sus parámetros, podamos tener

170
00:13:08,830 --> 00:13:12,210
un mecanismo sencillo y no tengamos que hacer nosotros ese desarrollo

171
00:13:12,210 --> 00:13:17,289
por completo. Una de esas clases, en particular, para acceder, para leer

172
00:13:17,289 --> 00:13:22,649
información desde flujos de datos externos, podría ser desde el teclado,

173
00:13:22,649 --> 00:13:26,590
desde System.in o podría ser desde un fichero, pero para

174
00:13:26,590 --> 00:13:30,570
inyectar, digamos, información en nuestro programa, en la clase Scanner.

175
00:13:33,740 --> 00:13:36,860
Habíamos hablado el otro día de ella. Vamos a hacer un mini repaso y

176
00:13:36,860 --> 00:13:38,899
aprovecho para comentaros algo que os he puesto

177
00:13:38,899 --> 00:13:44,620
en los comentarios de las tareas alguno. Entonces,

178
00:13:49,179 --> 00:13:57,679
y como siempre, nos vamos parando muy poco a poco

179
00:13:57,679 --> 00:14:01,419
en cada instrucción y vamos repasando un poco conceptos

180
00:14:01,419 --> 00:14:03,539
de los que tenemos en este tema.

181
00:14:04,159 --> 00:14:08,240
Mirad, directamente en cualquiera de nuestros programas,

182
00:14:08,940 --> 00:14:12,500
junto a nuestras clases, tenemos importadas,

183
00:14:12,500 --> 00:14:17,519
es decir, tenemos ya disponibles sin necesidad de informarlo

184
00:14:17,519 --> 00:14:19,779
de forma explícita, como estamos haciendo aquí para Scanner,

185
00:14:20,559 --> 00:14:24,379
todas aquellas clases que pertenecen al paquete JavaLang.

186
00:14:26,509 --> 00:14:30,070
Es decir, hay una serie de cosas en un paquete que es el JavaLang

187
00:14:30,070 --> 00:14:34,269
desarrolladas y como son de uso tan común, dicen

188
00:14:34,269 --> 00:14:37,970
mira, lo vas a tener disponible sin necesidad de importarlo. Y luego existen

189
00:14:37,970 --> 00:14:41,950
muchas otras clases que están en otros paquetes.

190
00:14:42,450 --> 00:14:46,289
Muchas también se utilizan habitualmente, aunque no

191
00:14:46,289 --> 00:14:50,070
con tanta frecuencia como pueden ser las de Java Lang. Es el caso

192
00:14:50,070 --> 00:14:54,129
de la clase Scanner. La clase Scanner se encuentra en el paquete Java

193
00:14:54,129 --> 00:14:57,570
útil. Entonces, si nosotros por defecto no ponemos aquí este import,

194
00:14:57,570 --> 00:15:01,529
Scanner se nos queja. Dice, oye, la clase Scanner no la conozco.

195
00:15:02,149 --> 00:15:06,049
¿Por qué? Porque no la tengo definida en mi proyecto y tampoco es

196
00:15:06,049 --> 00:15:09,289
de aquellas clases que están importadas de forma

197
00:15:09,289 --> 00:15:14,309
estándar, de forma directa. Entonces, para poder utilizarla

198
00:15:14,309 --> 00:15:18,009
tengo que identificarla en mi programa y avisarle al programa

199
00:15:18,009 --> 00:15:22,070
que, oye, mira, quiero utilizar la clase Scanner en particular del paquete

200
00:15:22,070 --> 00:15:25,590
JavaLang. Y a partir de ese momento, en ese paquete, tiene definida esta clase

201
00:15:25,590 --> 00:15:27,970
y ya me deja hacer uso de ella.

202
00:15:29,110 --> 00:15:32,049
Esta instrucción, ¿qué es lo que estamos haciendo?

203
00:15:32,169 --> 00:15:35,129
Pues mirad, de una clase existente ya en mi programa,

204
00:15:35,330 --> 00:15:36,470
aunque no la he codificado yo,

205
00:15:37,309 --> 00:15:38,330
defino un objeto.

206
00:15:41,110 --> 00:15:44,370
Recordad, las clases en sí vienen a ser un esquema

207
00:15:44,370 --> 00:15:47,190
de cómo se comportarían los objetos.

208
00:15:47,710 --> 00:15:49,509
La clase persona, en principio,

209
00:15:49,590 --> 00:15:51,190
no es ninguna persona en particular.

210
00:15:52,149 --> 00:15:54,169
Es el esquema de aquellas características

211
00:15:54,169 --> 00:15:57,509
que van a tener aquellos objetos de la clase persona que definamos

212
00:15:57,509 --> 00:16:01,149
como parámetros, definidos como parámetros, y los métodos que van a ser

213
00:16:01,149 --> 00:16:04,289
cómo se van a comportar aquellas personas a las que demos vida

214
00:16:04,289 --> 00:16:06,490
en nuestro programa a través de distanciarlas.

215
00:16:07,470 --> 00:16:09,669
Pues es lo mismo que sucede aquí. Scanner, en principio,

216
00:16:10,070 --> 00:16:13,090
es el esquema de una clase. Es una clase y tendrá un esquema

217
00:16:13,090 --> 00:16:15,809
de parámetros y métodos disponibles.

218
00:16:16,450 --> 00:16:20,690
En sí, para utilizar algo de Scanner, necesito definir un objeto.

219
00:16:20,690 --> 00:16:28,289
Y este objeto ya sí que es algo que cobra vida en mi programa y que se instancia de acuerdo a esta clase.

220
00:16:32,139 --> 00:16:37,679
Si definimos mi scan así, directamente con punto y coma, sin hacer el resto de esta instrucción,

221
00:16:38,340 --> 00:16:46,139
lo que vendría a ser es, como un dedito, un puntero que señala hacia un objeto de la clase Scanner,

222
00:16:46,139 --> 00:16:59,100
Pero no sería el objeto en sí. ¿Por qué? Porque necesito solicitar al sistema operativo espacio en memoria RAM y recursos para que este objeto pueda participar activamente en mi programa.

223
00:16:59,100 --> 00:17:15,759
Entonces, eso lo hago con la palabra reservada new. Entonces, aquí ya sí que el programa le solicita al sistema operativo ese espacio para que haga todas las reservas necesarias para el objeto MyScan, que es de este tipo de clase.

224
00:17:16,140 --> 00:17:35,660
Y después de este new siempre aparece aquí algo que si os fijáis está entre paréntesis, entonces los paréntesis hemos venido diciendo que cuando hablamos de una clase corresponden a los métodos, tenemos los parámetros que definimos más los métodos.

225
00:17:35,660 --> 00:17:42,940
Fijaros, main, un método, en este caso de la clase print, está entre paréntesis.

226
00:17:44,039 --> 00:17:47,779
Entonces, esto es un método definido en la clase scanner.

227
00:17:48,359 --> 00:17:52,839
Si os fijáis, en particular, este método tiene el mismo nombre exactamente que la clase.

228
00:17:53,240 --> 00:17:56,319
Entonces, estos métodos se llaman métodos constructores.

229
00:17:56,579 --> 00:18:00,500
Es el constructor, un constructor de la clase scanner.

230
00:18:00,500 --> 00:18:25,660
Y estos métodos, los constructores, se suelen utilizar o están pensados para ser utilizados en la inicialización del objeto. Entonces, fijaros que junto al momento en el cual definimos el objeto, hacemos la reserva de memoria y llamamos a un constructor que inicializará, según el código que tenga, este objeto de la clase Scanner.

231
00:18:25,660 --> 00:18:45,980
Luego, tenemos aquí que otra de las características que tenemos en la programación orientada a objetos, aprovechamos fijaros en cada línea para hablar un poco de todos los conceptos y hacer un repaso, otra de las características que tenemos en la programación orientada a objetos es la sobrecarga.

232
00:18:45,980 --> 00:18:56,920
Sobrecargar viene a decir que, digamos, reutilizar algo para que tenga diferentes funcionalidades.

233
00:18:56,920 --> 00:19:06,059
Podríamos pensarlo de esta forma. Entonces, fijaros, podemos coger y tener sobrecargados operadores.

234
00:19:06,400 --> 00:19:12,539
En otras clases hablábamos, por ejemplo, el más. El operador más, dependiendo de lo que se encuentre

235
00:19:12,539 --> 00:19:16,259
a la izquierda o a la derecha, hace diferentes cosas.

236
00:19:16,420 --> 00:19:18,940
Si se encuentra una variable numérica a la izquierda y a la derecha,

237
00:19:19,940 --> 00:19:21,259
lo que hace es sumar dos números.

238
00:19:21,259 --> 00:19:26,720
Si se encuentra un 3 y un 5, lo que hará será dar como resultado

239
00:19:26,720 --> 00:19:30,940
hacia la izquierda de esta suma, es una suma típica de números, un 8.

240
00:19:31,660 --> 00:19:34,480
Pero si lo que tenemos son dos cadenas de caracteres,

241
00:19:34,480 --> 00:19:49,630
Que las cadenas de caracteres, recordadlas, encerramos entre dobles comillas.

242
00:19:50,369 --> 00:19:56,309
Lo que hace es concatenarlas. Lógicamente AA más WWW no tiene ningún sentido.

243
00:19:56,529 --> 00:20:02,089
Entonces esto lo que devuelve hacia la izquierda es otra cadena de caracteres que sería de este estilo.

244
00:20:02,089 --> 00:20:23,069
Es decir, el operador más está sobrecargado y tiene diferentes comportamientos dependiendo de lo que se encuentra a derecha e izquierda. Java permite la sobrecarga de operadores, como estamos comentando, pero no permite, este lenguaje en particular, crear nuevas funcionalidades para un operador, cosa que sí sucede en otros lenguajes de programación.

245
00:20:23,069 --> 00:20:27,450
podríamos definir nuevos comportamientos y lo que te encuentras a la izquierda es algo en particular

246
00:20:27,450 --> 00:20:33,869
que el más haga una cosa diferente de las que tiene preestablecidas por defecto para lo que

247
00:20:33,869 --> 00:20:39,390
esté programado hasta ahora java no lo permite está sobrecargado los operadores pero no permite

248
00:20:39,390 --> 00:20:45,450
sobrecarga definir tus sobrecargas para operadores pero en cambio si lo permite para métodos entonces

249
00:20:45,450 --> 00:20:52,450
imaginaros que aquí en clase principal tuviésemos un método que es public void saludar

250
00:20:57,900 --> 00:21:08,069
Y aquí ponemos un System, Intel N.

251
00:21:16,000 --> 00:21:19,599
Bueno, aquí tendríamos un método que es una de las acciones

252
00:21:19,599 --> 00:21:23,819
que es capaz de hacer todo objeto de la clase, clase print.

253
00:21:24,960 --> 00:21:27,759
En particular, si llamamos para un objeto de la clase print

254
00:21:27,759 --> 00:21:31,799
al método saludar, lo que hará será sacar por pantalla un hola.

255
00:21:31,799 --> 00:21:40,079
Si ponemos aquí el método saludar de nuevo para que saque un hola 2,

256
00:21:40,640 --> 00:21:42,359
fijaros cómo ahora ya no le gusta.

257
00:21:42,359 --> 00:21:46,579
nos deja de compilar aquí, veis que se ha puesto los dos saludar en rojo

258
00:21:46,579 --> 00:21:49,880
y aquí me avisa, que es lo que sucede, que si yo ahora cojo

259
00:21:49,880 --> 00:21:54,119
y llamo a un objeto de la clase print

260
00:21:54,119 --> 00:21:59,920
vamos a definir un objeto de la clase print, mi objeto

261
00:21:59,920 --> 00:22:12,329
hacemos un new, si yo ahora hiciese

262
00:22:12,329 --> 00:22:14,369
esto, mi off y pusiera aquí saludar

263
00:22:14,369 --> 00:22:20,430
este objeto intentaría saludar, pero resulta que en mi código

264
00:22:20,430 --> 00:22:24,789
hay dos opciones, es decir, no se puede ir a una de ellas

265
00:22:24,789 --> 00:22:28,769
de forma particular. No sabe si ejecutar esta parte del código o esta

266
00:22:28,769 --> 00:22:32,390
cuando le digo saludar. Con lo cual, ante esta discrepancia, me dice

267
00:22:32,390 --> 00:22:36,390
esto no es posible, no dejo que compiles. Y eso que los dos métodos

268
00:22:36,390 --> 00:22:40,890
reciben el nombre saludar. Existe la posibilidad de sobrecargar

269
00:22:40,890 --> 00:22:44,609
el método saludar si aquí dentro de los paréntesis

270
00:22:44,609 --> 00:22:48,670
meto algo diferente. Entonces, aquí le estoy diciendo

271
00:22:48,670 --> 00:22:52,549
un método saludar con los parámetros en blanco y aquí podría poner

272
00:22:52,549 --> 00:22:55,670
por ejemplo un string ssal

273
00:22:55,670 --> 00:23:00,630
entonces fijaros como ya si que me compila, ya se ha quitado

274
00:23:00,630 --> 00:23:04,650
el error, el hecho de que se quite el error quiere decir que si yo ahora

275
00:23:04,650 --> 00:23:08,509
llamo a mi og y llamo a saludar sin nada entre los paréntesis

276
00:23:08,509 --> 00:23:12,670
no hay lugar a dudas entre si quiero ejecutar este o este

277
00:23:12,670 --> 00:23:16,450
porque cual de los dos es el que no tiene nada entre los paréntesis, este verdad

278
00:23:16,450 --> 00:23:33,029
En definitiva, me pondría hola. Si yo ahora cojo y pongo mi obj.saludar, fijaros, este tiene la posibilidad de recibir aquí una variable que es de tipo string.

279
00:23:33,029 --> 00:23:53,630
¿Veis? Entonces aquí le podría pasar yo una variable de tipo string o un string. Voy a poner hola desde main. Entonces si yo llamo a este, está claro que durante la ejecución, en el momento de ejecución, sabe si llamar a este saludar o llamar a este otro.

280
00:23:53,630 --> 00:24:02,150
¿Por qué? Porque el único que recibe una cadena de caracteres es este segundo saludar, con lo cual este otro, la ejecución que haría sería esta.

281
00:24:03,690 --> 00:24:14,849
Entonces esto, como el método en ambos casos se llama saludar, se entiende que ese método está sobrecargado y tiene comportamientos diferentes en función de los parámetros de entrada que tenga el método.

282
00:24:14,849 --> 00:24:49,690
estos parámetros de entrada se pueden utilizar como variables internas dentro del método esto ya hablaremos de ello pero bueno os voy contando cosas aunque luego lo volvamos a contar fijaros aquí podemos poner un system of println de ese sal y mirad si aquí definimos un string para que tengáis toda la jugada ponemos aquí variable interna podríamos poner un system of println de esta otra variable

283
00:24:49,690 --> 00:25:08,599
Mira, si repasamos este código, ¿qué es lo que haría? Bueno, tenemos aquí el escáner y luego vamos a empezar a hacer estas cosas para hablaros de la sobrecarga y que entendáis por qué este tiene algo aquí en la llamada.

284
00:25:08,599 --> 00:25:33,539
Esta llamada es equivalente a esta otra. ¿Por qué? Porque es un método constructor que en particular es capaz de recibir como parámetro un flujo de datos, igual que este es un método, en este caso no es constructor, es el método saludar, que es capaz de recibir como parámetro una cadena de caracteres.

285
00:25:33,539 --> 00:25:36,579
ahora retomamos lo del escáner que os iba a contar

286
00:25:36,579 --> 00:25:39,619
pero vamos a terminar de ver esto que os estaba poniendo

287
00:25:39,619 --> 00:25:42,099
por aquí, la secuencia del programa

288
00:25:42,099 --> 00:25:45,940
aquí definiríamos un flujo de datos al teclado

289
00:25:45,940 --> 00:25:48,779
que en principio en este código no estamos utilizando

290
00:25:48,779 --> 00:25:50,059
después, pero bueno, ahí está

291
00:25:50,059 --> 00:25:54,579
luego definimos un objeto, miog, de la clase print

292
00:25:54,579 --> 00:25:57,059
le pedimos al sistema operativo

293
00:25:57,059 --> 00:26:00,099
que haga las reservas necesarias para que miog

294
00:26:00,099 --> 00:26:03,160
tenga sus espacios de memoria y sus recursos

295
00:26:03,160 --> 00:26:07,940
para ir trabajando, llamamos a un método, fijaros que es un método

296
00:26:07,940 --> 00:26:11,619
como os digo, en este caso se llama igual que la clase

297
00:26:11,619 --> 00:26:16,279
con lo cual es un método constructor, que nos serviría

298
00:26:16,279 --> 00:26:19,380
para meter cosas de inicialización a este objeto

299
00:26:19,380 --> 00:26:23,980
si no lo hemos construido, se crea uno por defecto que hace poca

300
00:26:23,980 --> 00:26:28,019
cosa, pero bueno, para poder hacer el new de un constructor

301
00:26:28,019 --> 00:26:31,900
aunque no lo tengamos nosotros puesto aquí en el programa, y luego para ese objeto

302
00:26:31,900 --> 00:26:36,059
hemos hecho una sobrecarga del método saludar, definiendo

303
00:26:36,059 --> 00:26:39,980
dos veces ese método, como veis, y está

304
00:26:39,980 --> 00:26:44,079
sobrecargado, porque es el mismo método, en ambos casos se saluda

305
00:26:44,079 --> 00:26:47,779
y nos permite la compilación porque hemos puesto en su

306
00:26:47,779 --> 00:26:51,680
asignatura, en su cabecera, la diferencia

307
00:26:51,680 --> 00:26:55,839
en tanto en cuanto tiene parámetros de entrada diferentes, este no recibe ningún

308
00:26:55,839 --> 00:26:59,960
parámetro de entrada y este recibe uno. Por aquí, no hay

309
00:26:59,960 --> 00:27:04,119
lugar a dudas a qué método saludar llamamos al no pasarle parámetros con lo cual se ejecutaría

310
00:27:04,119 --> 00:27:09,559
este hola y cuando llamemos a este tampoco hay lugar a dudas porque estamos llamando al que

311
00:27:09,559 --> 00:27:16,180
tiene una cadena de caracteres de entrada con lo cual correspondería a este fijaros si aquí

312
00:27:16,180 --> 00:27:26,759
pusiésemos mi op punto saludar y decidimos pasarle algo diferente a que este vacío o a que sea una

313
00:27:26,759 --> 00:27:32,140
cadena de caracteres, ponemos aquí un número, un 1, pues ya este se queja, dice mira, sé que quieres

314
00:27:32,140 --> 00:27:39,480
llamar a un método saludar, tengo conocimiento de que lo tienes sobrecargado, pero justo no has

315
00:27:39,480 --> 00:27:44,559
hecho una sobrecarga en la cual se reciba como parámetro de entrada un número, con lo cual este

316
00:27:44,559 --> 00:27:51,099
no te lo acepto. Si quieres poder llamar a un método saludar en el cual se recibe un número

317
00:27:51,099 --> 00:27:58,140
entero, tendrás que definirme el método sobrecargado que tenga como parámetro de entrada un entero.

318
00:27:58,400 --> 00:28:22,559
Este lo quitamos de momento y cuando llamamos a este fijaros lo que pasa. El código viene por aquí, la secuencia del código vendría, haría esto, haría este saludar, haría un paréntesis aquí en el main y se vendría a ejecutar esto, ejecutaría todo el código del método y a la que termina volvería por aquí y continuaría con la secuencia de instrucciones que tenemos en el main.

319
00:28:22,559 --> 00:28:26,839
luego llamaría a este otro y se pondría a ejecutar todo este método main

320
00:28:26,839 --> 00:28:31,119
al ejecutar este método main estamos definiendo una variable

321
00:28:31,119 --> 00:28:35,940
sbar int, la hemos dado un valor inicial de variable interna

322
00:28:35,940 --> 00:28:39,259
sacamos por pantalla un literal

323
00:28:39,259 --> 00:28:43,099
con lo cual pondrá holador directamente, sacamos por pantalla

324
00:28:43,099 --> 00:28:46,000
la información que tiene sbar int

325
00:28:46,000 --> 00:28:50,759
con lo cual es previsible que nos va a decir hola var interna

326
00:28:50,759 --> 00:28:59,859
Y luego sacamos por pantalla la información que tiene una variable, ese sal, que justo es la que hemos recibido aquí como parámetro.

327
00:29:00,359 --> 00:29:06,220
Y en esta variable lo que se carga es justo el valor que le hemos puesto aquí en la llamada.

328
00:29:07,160 --> 00:29:13,940
Con lo cual, en el momento de llamarlo, ese sal cogerá el valor que le estemos pasando aquí en la llamada como parámetro.

329
00:29:14,240 --> 00:29:16,980
Con lo cual, ese sal valdrá hola desde main.

330
00:29:16,980 --> 00:29:20,559
mirad, si hacemos aquí una ejecución

331
00:29:20,559 --> 00:29:22,779
pues nos dice

332
00:29:22,779 --> 00:29:24,599
un hola, que corresponde a este

333
00:29:24,599 --> 00:29:26,680
hola, cuando llega por aquí

334
00:29:26,680 --> 00:29:28,579
me muestra

335
00:29:28,579 --> 00:29:29,220
este hola

336
00:29:29,220 --> 00:29:31,940
luego llama a saludar2

337
00:29:31,940 --> 00:29:34,339
que nos muestra un hola2

338
00:29:34,339 --> 00:29:36,660
nos muestra la información

339
00:29:36,660 --> 00:29:38,819
de ese var interna, hola var interna

340
00:29:38,819 --> 00:29:40,400
veis, y luego

341
00:29:40,400 --> 00:29:42,420
hola desde main, que es la información

342
00:29:42,420 --> 00:29:44,440
que tiene ese sal, porque se ha

343
00:29:44,440 --> 00:29:45,980
cargado hola desde main aquí

344
00:29:45,980 --> 00:30:08,049
Si hiciéramos otra llamada a este mismo método, cambiando la información de la cadena de caracteres que pasamos como información en el parámetro, si le damos otra ejecución nueva, fijaros cómo nos muestra este hola primero, que corresponde a esta llamada.

345
00:30:08,049 --> 00:30:11,410
luego llama este y nos dice

346
00:30:11,410 --> 00:30:13,509
hola2

347
00:30:13,509 --> 00:30:17,009
la información que tiene la variable interna

348
00:30:17,009 --> 00:30:19,970
que es lo siguiente que mostramos es hola var interna

349
00:30:19,970 --> 00:30:22,730
ese sal y en esta primera llamada es

350
00:30:22,730 --> 00:30:26,089
hola desde main y luego en la segunda

351
00:30:26,089 --> 00:30:29,289
llamada volvemos a mostrar hola2 ese var interna

352
00:30:29,289 --> 00:30:31,309
y en esta ocasión ese sal

353
00:30:31,309 --> 00:30:36,759
dice hola desde main2 pues concepto de sobrecarga

354
00:30:36,759 --> 00:30:41,420
concepto de sobrecarga y ver

355
00:30:41,420 --> 00:30:43,380
la posibilidad de pasar parámetros

356
00:30:43,380 --> 00:30:45,579
a un método, este caso es el método

357
00:30:45,579 --> 00:30:47,660
constructor, pero podría ser

358
00:30:47,660 --> 00:30:49,460
cualquier otro método de los que tengamos

359
00:30:49,460 --> 00:30:51,740
definidos, como por ejemplo el método saludar

360
00:30:51,740 --> 00:30:56,069
si os surge en duda

361
00:30:56,069 --> 00:30:57,509
me vais parando, me vais diciendo

362
00:30:57,509 --> 00:30:59,569
si no yo os sigo contando

363
00:30:59,569 --> 00:31:02,220
pues

364
00:31:02,220 --> 00:31:05,839
hablado un poquito de eso, seguimos con

365
00:31:05,839 --> 00:31:07,299
lo que os iba a comentar del escáner

366
00:31:07,299 --> 00:31:11,500
disculpad, vale pues aquí

367
00:31:11,500 --> 00:31:17,039
Lo que hemos hecho, haciendo un repaso de esta instrucción, ha sido crear en definitiva un objeto MiSCAN.

368
00:31:17,039 --> 00:31:25,599
Y le hemos dicho que el otro lado de la tubería se conecta a System.im, que hemos comentado que es uno de los flujos de entrada estándar, que es el teclado.

369
00:31:27,500 --> 00:31:33,980
Para que en el programa nos salga algo por pantalla cuando nos pide información, podemos poner un System.out.

370
00:31:45,779 --> 00:31:50,339
Dime un valor numérico.

371
00:31:50,339 --> 00:32:24,200
Mira, antes os he dicho, en Java son todo clases, siempre son todo clases. Para trabajar con un objeto, para llamar a métodos, la norma general es crear un objeto. ¿Por qué? Pues como hemos hecho antes con la clase, clase print, que hemos creado un objeto y luego hemos llamado a los diferentes métodos saludar que estaban sobrecargados.

372
00:32:24,200 --> 00:32:27,720
cada vez que creamos un nuevo objeto

373
00:32:27,720 --> 00:32:31,779
se hace con el new, se hace una reserva de memoria

374
00:32:31,779 --> 00:32:36,160
para las variables de ese objeto y se llaman a una serie de métodos

375
00:32:36,160 --> 00:32:39,079
que están particularizados para ese objeto, es decir, cada uno

376
00:32:39,079 --> 00:32:44,079
tiene cada nuevo objeto, si pensamos en la clase persona

377
00:32:44,079 --> 00:32:47,420
si creamos la clase persona per1 new persona

378
00:32:47,420 --> 00:32:51,220
pues cada per1 tendrá su espacio de memoria donde podremos

379
00:32:51,220 --> 00:32:55,400
a guardar su nombre, su edad y podremos llamar a unos métodos

380
00:32:55,400 --> 00:32:59,480
que son particulares suyos. Si aclaramos la clase persona

381
00:32:59,480 --> 00:33:03,299
per dos, pues al hacer el new en otro espacio de memoria

382
00:33:03,299 --> 00:33:07,559
de la RAM, reservaremos un trocito en el cual

383
00:33:07,559 --> 00:33:11,539
podremos guardar su nombre, su edad, los parámetros que hayamos definido

384
00:33:11,539 --> 00:33:13,859
en ese proyecto para la clase persona.

385
00:33:15,119 --> 00:33:19,299
La semana pasada ya os hablaba de la etiqueta static.

386
00:33:19,299 --> 00:33:40,299
La etiqueta static lo que hacía era que los parámetros y los métodos, en este caso está aplicado al método main, los parámetros y los métodos que definamos como estáticos, en lugar de ser particulares de cada objeto y tener una copia para cada uno de los objetos que definamos,

387
00:33:40,299 --> 00:34:00,859
Por ejemplo, como decía, el objeto per1 de persona tendrá un espacio para su nombre y sus apellidos y su DNI y el objeto per2 de la misma forma. Si definimos algún parámetro o algún método de forma estática, eso es común para todos los objetos que pertenezcan a esa clase.

388
00:34:00,859 --> 00:34:10,059
Es decir, que si modificamos el espacio de memoria es único correspondiente a la clase y en un espacio de memoria diferente para cada uno de los objetos.

389
00:34:10,659 --> 00:34:19,099
¿Qué es lo que sucede aquí? Fijaros, println tiene pinta de ser un método, ¿verdad? Porque está aquí entre paréntesis.

390
00:34:19,099 --> 00:34:30,940
un método que recibe un parámetro alfanumérico, pero para utilizar println en nuestro código por aquí no hemos instanciado un objeto de ninguna clase,

391
00:34:31,079 --> 00:34:43,239
directamente lo hemos llamado. ¿Por qué sucede esto? Pues porque el método println, en primer lugar, system.out pertenecerá a la clase java.lang,

392
00:34:43,239 --> 00:34:44,840
porque no hemos necesitado importarlo.

393
00:34:46,239 --> 00:34:48,960
Y en segundo lugar, hemos llamado a println un método

394
00:34:48,960 --> 00:34:52,000
sin haber instanciado, sin haber hecho un new de ningún objeto.

395
00:34:52,280 --> 00:34:55,260
¿Eso por qué es? Porque println está definida

396
00:34:55,260 --> 00:34:58,579
en las librerías de Java, en particular

397
00:34:58,579 --> 00:35:01,300
la librería java.lang está definido como un método

398
00:35:01,300 --> 00:35:04,239
estático, con lo cual podemos poner el nombre de la clase

399
00:35:04,239 --> 00:35:06,179
que es out del paquete system

400
00:35:06,179 --> 00:35:10,360
y utilizar directamente el método sin haber instanciado

401
00:35:10,360 --> 00:35:17,920
nada. Puedo ir fijando conceptos del estático y ir entendiendo cada una de las líneas que vamos

402
00:35:17,920 --> 00:35:29,289
poniendo. Bien, pues entonces aquí podríamos definir una variable int y valor. Y valor, volvemos a repasar

403
00:35:29,289 --> 00:35:35,929
conceptos del otro día. Y valor es una variable de tipo int. Hay una serie de tipos de datos que son

404
00:35:35,929 --> 00:35:43,329
los tipos de datos primitivos de Java. Estos tipos de datos dan un pasito más allá y para hacer la

405
00:35:43,329 --> 00:35:47,389
reserva de memoria RAM en la cual se van a guardar estos, es un tipo

406
00:35:47,389 --> 00:35:50,929
de datos primitivo. Entonces, para hacer la reserva de memoria RAM

407
00:35:50,929 --> 00:35:55,570
no necesitamos, como en los referenciados, hacer el new para solicitarse

408
00:35:55,570 --> 00:35:59,429
al sistema operativo. Directamente, a la hora de definir un tipo

409
00:35:59,429 --> 00:36:03,389
de datos de los primitivos, que son el int, el long, el float, todos estos,

410
00:36:04,050 --> 00:36:07,510
ya se hace esa reserva de memoria, donde se va a guardar

411
00:36:07,510 --> 00:36:11,210
la información. Y aquí ponemos mi scan,

412
00:36:11,210 --> 00:36:15,159
ponemos un igual por aquí

413
00:36:15,159 --> 00:36:22,219
igual miScan

414
00:36:22,219 --> 00:36:26,449
punto, entonces decimos que

415
00:36:26,449 --> 00:36:28,469
esta variable, hacemos una lectura de derecha

416
00:36:28,469 --> 00:36:30,650
a izquierda, a esta variable se le va a asignar

417
00:36:30,650 --> 00:36:32,630
lo que pongamos por aquí

418
00:36:32,630 --> 00:36:34,389
devuelva hacia la izquierda

419
00:36:34,389 --> 00:36:36,429
miScan es un objeto de la clase Scanner

420
00:36:36,429 --> 00:36:38,269
y tiene un montón de métodos

421
00:36:38,269 --> 00:36:38,730
por aquí

422
00:36:38,730 --> 00:36:41,409
este es un objeto

423
00:36:41,409 --> 00:36:43,869
que tiene a su disposición todo

424
00:36:43,869 --> 00:36:46,090
método que esté definido en el esquema

425
00:36:46,090 --> 00:36:47,150
de la clase Scanner

426
00:36:47,150 --> 00:36:49,809
y entre ellos, pues fijaros, tenemos un

427
00:36:49,809 --> 00:36:58,030
si lo seleccionamos aquí nos dice que busca el siguiente token de una entrada que sea de tipo entero

428
00:36:58,030 --> 00:37:07,329
entonces utilizamos nesynth, en principio esto leerá un entero desde el flujo de entrada que hayamos definido

429
00:37:07,329 --> 00:37:12,929
para mi scan, objeto de la clase scanner, que en particular en el constructor le hemos dicho que sea system.min

430
00:37:12,929 --> 00:37:19,710
con lo cual sabemos que es el teclado, si nosotros hacemos aquí un system.out.print

431
00:37:19,710 --> 00:37:22,809
el n de y valor

432
00:37:22,809 --> 00:37:32,260
si ejecutamos ahora, se me queda aquí, dime un valor numérico porque me ha mostrado

433
00:37:32,260 --> 00:37:36,260
esto, el programa no ha continuado porque se ha quedado aquí esperando hacer esta

434
00:37:36,260 --> 00:37:40,239
lectura, si yo ahora pongo aquí un 4, este 4 lo he escrito yo con

435
00:37:40,239 --> 00:37:44,199
el teclado, doy enter, pues fijaros, carga el 4

436
00:37:44,199 --> 00:37:47,639
aquí, me lo muestra por pantalla y ha ido todo correcto

437
00:37:47,639 --> 00:37:52,139
lo que pasa es que cuando nosotros, si estamos haciendo con

438
00:37:52,139 --> 00:37:58,539
escáner una lectura desde teclado si nosotros ponemos un 4 y enter lo que estamos haciendo es

439
00:37:58,539 --> 00:38:05,519
meter digamos dos caracteres uno que es el 4 y otro el carácter así no me acuerdo qué número es

440
00:38:05,519 --> 00:38:11,639
que es el enter o incluso el ente a lo mejor son dos son retorno de carro y nueva línea en

441
00:38:11,639 --> 00:38:18,059
definitiva para que esto siga adelante hemos metido el 4 y el ente y éste en el sindh me

442
00:38:18,059 --> 00:38:22,360
se encarga de coger el número entero, el 4

443
00:38:22,360 --> 00:38:26,360
y el enter no le preocupa tanto. Entonces fijaros,

444
00:38:26,619 --> 00:38:30,559
imaginaros que nosotros estuviésemos aquí en nuestro

445
00:38:30,559 --> 00:38:34,460
programa lo siguiente. Queremos coger un valor entero

446
00:38:34,460 --> 00:38:42,030
y decimos system out, println

447
00:38:42,030 --> 00:38:49,190
dime tu nombre.

448
00:38:50,230 --> 00:38:54,190
Porque queremos coger un valor entero, imaginaos en lugar de un valor

449
00:38:54,190 --> 00:39:01,949
numérico dime tu edad y luego dice dime tu nombre dice pues mira la edad la vamos a con un es ind y

450
00:39:01,949 --> 00:39:11,170
el nombre vamos a definir una variable de tipo string ese nombre y aquí cogemos y hacemos un

451
00:39:11,170 --> 00:39:16,989
scan y aquí para el nombre bueno pues queremos una línea porque podemos poner un nombre con varias

452
00:39:16,989 --> 00:39:26,579
palabras pues hacemos un es line vale pues parece que tiene sentido que aquí cogemos y decimos vamos

453
00:39:26,579 --> 00:39:34,579
a meter de edad 18 años 18 y luego cuando me pida el nombre vamos a poner un nombre que sea noa por

454
00:39:34,579 --> 00:39:42,190
ejemplo y luego ya una vez que tengo todos los datos vamos a coger y vamos a sacar el resultado

455
00:39:42,190 --> 00:39:48,070
aquí ese nombre que me diga primero la edad me escriba por pantalla la edad y luego el nombre

456
00:39:48,070 --> 00:40:14,769
Aquí ponemos edad, utilizamos el operador más para concatenar y nombre. Entonces fijaros, si yo cojo ahora y le doy aquí a ejecutar esto, dice dime tu edad, voy a poner que tiene 18 años y le doy enter y fijaros lo que pasa.

457
00:40:14,769 --> 00:40:17,469
que me ha mostrado nombre y me lo ha mostrado

458
00:40:17,469 --> 00:40:19,289
en blanco, que es lo que ha sucedido

459
00:40:19,289 --> 00:40:21,710
cuando yo he puesto

460
00:40:21,710 --> 00:40:23,130
aquí 18 y le he dado enter

461
00:40:23,130 --> 00:40:25,250
el 18 me lo ha cargado en iValor

462
00:40:25,250 --> 00:40:27,690
el enter no me lo ha considerado

463
00:40:27,690 --> 00:40:29,670
ha escrito dime tu nombre

464
00:40:29,670 --> 00:40:31,369
y

465
00:40:31,369 --> 00:40:33,230
en el siguiente nestline

466
00:40:33,230 --> 00:40:35,349
ha considerado el enter pero el enter

467
00:40:35,349 --> 00:40:37,210
que había metido cuando he puesto el 18 del

468
00:40:37,210 --> 00:40:39,210
nesint, con lo cual ha cogido

469
00:40:39,210 --> 00:40:41,050
un enter, aquí ha cargado algo vacío

470
00:40:41,050 --> 00:40:42,949
y cuando ha mostrado nombre

471
00:40:42,949 --> 00:40:44,110
no me ha puesto ningún dato

472
00:40:44,110 --> 00:40:52,650
aquí es muy lineal y se ve claro, pero si en diferentes partes

473
00:40:52,650 --> 00:40:56,550
del programa estuviera este código, hubiera muchas líneas

474
00:40:56,550 --> 00:41:00,670
entre medias o incluso un bucle que parece que te lleva a otra zona de código

475
00:41:00,670 --> 00:41:03,530
a verlo o la llamada a una función o algo de eso

476
00:41:03,530 --> 00:41:08,789
podríamos perder de vista que es esto lo que está pasando y es un típico

477
00:41:08,789 --> 00:41:12,550
error que para darte cuenta que el problema es que el enter de este

478
00:41:12,550 --> 00:41:16,670
es el que está leyendo aquí, cuesta a veces

479
00:41:16,670 --> 00:41:22,409
y te puede volver loco puedes revisar el programa mil veces y parecerte que está correcto qué

480
00:41:22,409 --> 00:41:28,010
soluciones tenemos pues como si queréis mantener utilizando el nes int porque alguien le gusta

481
00:41:28,010 --> 00:41:33,889
mucho en la práctica no se daba este error pero como yo lo conozco ya otras veces pues os lo he

482
00:41:33,889 --> 00:41:38,929
advertido en los comentarios de la práctica y os lo lo refiero aquí una de las posibilidades que

483
00:41:38,929 --> 00:41:50,340
podríamos tener aquí es poner hacer un es line aquí me va a leer el número y aquí va a leer el

484
00:41:50,340 --> 00:41:55,400
enter pero en realidad después de la lectura como no se lo estoy asignando a nadie por aquí es como

485
00:41:55,400 --> 00:42:04,039
que no pasa nada entonces esto con esto limpiaría el enter del nes int y luego ya se me quedaría

486
00:42:04,039 --> 00:42:11,079
aquí porque no he introducido dos enter cuando meto la edad de si yo ejecuto esto ahora dice

487
00:42:11,079 --> 00:42:15,000
dime tu edad. Y digo 18. Y ahora dice dime tu nombre. ¿Veis que no ha ido

488
00:42:15,000 --> 00:42:18,320
todo de corrido? ¿Por qué? Porque el enter del nesin lo he limpiado aquí.

489
00:42:19,659 --> 00:42:23,059
Y ahora pongo aquí noa. Voy a enter

490
00:42:23,059 --> 00:42:27,119
y ya lo coge bien. Aquí carga noa. Ya me dice la edad y el nombre.

491
00:42:27,619 --> 00:42:31,179
Esa sería una alternativa. Limpiarlo haciendo un nesline

492
00:42:31,179 --> 00:42:35,000
para quitar ese enter que en realidad está asociado con el número que hemos metido

493
00:42:35,000 --> 00:42:41,900
desde teclado. Y otra de las opciones, yo no la suelo utilizar más

494
00:42:41,900 --> 00:42:44,940
pero bueno, si tenéis cuidado para que no os pase

495
00:42:44,940 --> 00:42:48,239
pues vale cualquiera y si no se da esta situación

496
00:42:48,239 --> 00:42:50,440
pues vale con que lo leáis con un Synth

497
00:42:50,440 --> 00:42:54,280
y la otra opción es hacer siempre

498
00:42:54,280 --> 00:42:57,579
aquí un Sline, es decir, cogerlo

499
00:42:57,579 --> 00:43:02,250
siempre como una cadena de caracteres

500
00:43:02,250 --> 00:43:11,119
claro, una cadena de caracteres nos recoge

501
00:43:11,119 --> 00:43:15,659
el valor como un String, vamos a crear una variable

502
00:43:15,659 --> 00:43:22,880
auxiliar y ahora en sí

503
00:43:22,880 --> 00:43:26,940
aquí lo que haríamos sería coger el número, pero

504
00:43:26,940 --> 00:43:31,039
si metemos un 18, en realidad

505
00:43:31,039 --> 00:43:35,400
estaría cargando el 18, pero lo estaría cargando de esta forma, porque lo estamos cargando

506
00:43:35,400 --> 00:43:39,239
en una cadena de caracteres, en un string. Y lo que

507
00:43:39,239 --> 00:43:42,920
queremos, finalmente, para luego operar con ello, en el ejercicio es

508
00:43:42,920 --> 00:43:47,139
un valor entero, el que nos vale a partir

509
00:43:47,139 --> 00:43:50,800
de aquí es este y no este, que es el que hemos cargado desde el

510
00:43:50,800 --> 00:43:54,679
next line. Entonces aquí lo que vamos a utilizar es la clase

511
00:43:54,679 --> 00:44:02,219
integer, parseInt, que recibe como parámetro

512
00:44:02,219 --> 00:44:06,119
una cadena de caracteres, que es la variable

513
00:44:06,119 --> 00:44:10,199
en este caso que tiene el número de esta forma, como cadena de caracteres, y lo que

514
00:44:10,199 --> 00:44:14,000
hace es convertirlo a una variable de tipo entero, devuelve

515
00:44:14,000 --> 00:44:18,000
una variable de tipo entero, con lo cual ya tendríamos aquí el iValor.

516
00:44:21,030 --> 00:44:23,590
Aquí no tenemos el problema del enter de esto, porque

517
00:44:23,590 --> 00:44:26,650
del problema que se nos daba antes con el enter

518
00:44:26,650 --> 00:44:29,550
cuando hacíamos un nesint, porque estamos leyendo una línea entera

519
00:44:29,550 --> 00:44:32,789
ya, con lo cual nos estamos ya quitando del medio

520
00:44:32,789 --> 00:44:36,050
el enter, cogemos el número, lo convertimos

521
00:44:36,050 --> 00:44:38,809
a entero y luego nos pedirá el nombre

522
00:44:38,809 --> 00:44:41,269
que cogemos el nombre y ya mostramos los dos datos.

523
00:44:44,469 --> 00:44:46,530
Entonces decimos 18, dime tu nombre

524
00:44:46,530 --> 00:44:50,130
Noah y ya nos funciona bien.

525
00:44:50,130 --> 00:44:51,769
Entonces esta sería otra alternativa.

526
00:44:53,449 --> 00:44:56,130
Si ponéis esto siempre, pues sabéis que luego no vais a tener

527
00:44:56,130 --> 00:45:02,969
problemas posteriores no si lo manejáis cogiéndolo con un slide y haciendo la conversión que toque

528
00:45:04,469 --> 00:45:13,019
mira si lo que tenéis es un double pues existe la clase double punto parce double

529
00:45:14,159 --> 00:45:22,159
según el tipo suele haber una clase de asociada a ese tipo que nos permite bueno que tiene muchos

530
00:45:22,159 --> 00:45:26,900
parámetros tienen muchos métodos y parámetros por aquí como podéis ver pero uno de ellos es

531
00:45:26,900 --> 00:45:28,840
es el parse, parse double

532
00:45:28,840 --> 00:45:31,019
recibe una cadena de caracteres y la convierte

533
00:45:31,019 --> 00:45:32,019
en este caso a un double

534
00:45:32,019 --> 00:45:34,239
una variable con

535
00:45:34,239 --> 00:45:39,289
decimales, otra cosa

536
00:45:39,289 --> 00:45:42,050
bueno esta

537
00:45:42,050 --> 00:45:44,030
era la jugada de lo del

538
00:45:44,030 --> 00:45:46,530
escáner que os quería comentar, de la mano

539
00:45:46,530 --> 00:45:48,429
de esto, fijaros

540
00:45:48,429 --> 00:45:50,090
como aquí estamos utilizando

541
00:45:50,090 --> 00:45:52,010
una clase integer

542
00:45:52,010 --> 00:45:54,469
resulta

543
00:45:54,469 --> 00:45:56,429
que los tipos primitivos

544
00:45:56,429 --> 00:45:58,510
cuando nosotros

545
00:45:58,510 --> 00:45:59,469
definimos en java

546
00:45:59,469 --> 00:46:03,869
por ejemplo, la clase Scanner en las librerías o una de nuestras clases,

547
00:46:03,969 --> 00:46:05,730
decimos que tenemos parámetros sin métodos.

548
00:46:07,030 --> 00:46:10,150
Para estas clases, además, tenemos que hacer un new.

549
00:46:11,010 --> 00:46:16,489
Los tipos primitivos de Java no tenemos que hacer el new, como hemos dicho.

550
00:46:17,869 --> 00:46:25,510
Pero, además, no tienen disponible en principio métodos, las variables primitivas.

551
00:46:25,510 --> 00:46:51,989
Cuando trabajamos con una variable primitiva y queremos utilizar métodos que típicamente estarían definidas en una clase relacionada con este tipo de datos, por ejemplo, la posibilidad de convertir una cadena de caracteres que tenga un valor entero en lo que es el número, en Java existen unas clases que se llaman clases envoltorio, clases wrapper y cada uno de los tipos primitivos tiene una asociada.

552
00:46:51,989 --> 00:47:14,769
Entonces el tipo int tiene la clase WrapperInteger que tiene a nuestra disposición una serie de métodos y parámetros que suelen estar relacionados con tipos de datos enteros que vamos a tener típicamente almacenados en el tipo primitivo int.

553
00:47:14,769 --> 00:47:19,860
la clase double de valor

554
00:47:19,860 --> 00:47:23,880
pues de valor es un tipo primitivo

555
00:47:23,880 --> 00:47:28,380
para de valor no vamos a tener que hacer un new de la memoria RAM

556
00:47:28,380 --> 00:47:32,420
porque es un tipo primitivo, pero normalmente no va a tener definidos métodos

557
00:47:32,420 --> 00:47:36,440
si queremos trabajar con métodos relacionados con lo que sería el tipo

558
00:47:36,440 --> 00:47:39,719
primitivo double, existe una clase

559
00:47:39,719 --> 00:47:42,920
envoltorio para double que es double

560
00:47:42,920 --> 00:47:56,920
y esta tiene una serie de parámetros y una serie de métodos

561
00:47:56,920 --> 00:48:00,300
que nos permiten trabajar con ello, fijaros aquí tenemos

562
00:48:00,300 --> 00:48:04,699
para double, para integer, tenemos el máximo valor que es capaz

563
00:48:04,699 --> 00:48:08,079
de almacenarse en una variable de tipo double, el mínimo valor

564
00:48:08,079 --> 00:48:12,500
el mínimo valor, el normal value, no sé cuál es

565
00:48:12,500 --> 00:48:18,739
mínimo normal, no sé qué será, bueno y luego métodos

566
00:48:18,739 --> 00:48:22,820
el máximo, fijaros, la clase grupper double nos permite

567
00:48:22,820 --> 00:48:26,480
tiene un método que nos devuelve cuál de los dos

568
00:48:26,480 --> 00:48:31,300
double que le pasemos como parámetros, double A y double B, es mayor

569
00:48:31,300 --> 00:48:34,820
el máximo de los dos, el mínimo, el pase double

570
00:48:34,820 --> 00:48:38,559
que es el que os estoy comentando ahora, bueno, pues un montón, algo que te

571
00:48:38,559 --> 00:48:42,519
devuelve, hace una suma de dos double y te devuelve otro double

572
00:48:42,519 --> 00:48:45,619
bueno, pues sería como poner un más, ¿no? bueno, ya veis aquí

573
00:48:45,619 --> 00:48:50,960
un montón de cosas, ¿vale? es decir, existen las clases

574
00:48:50,960 --> 00:48:52,440
Rapper para los

575
00:48:52,440 --> 00:48:54,059
Tipos primitivos

576
00:48:54,059 --> 00:48:59,590
¿Dudas? ¿Alguna cosilla por ahí?

577
00:49:04,960 --> 00:49:06,280
¿Seguís por ahí, verdad? Eso sí

578
00:49:06,280 --> 00:49:11,840
Ah, vale, vale

579
00:49:11,840 --> 00:49:13,820
Bien, bien, no, no, por si acaso

580
00:49:13,820 --> 00:49:15,119
Yo que sé, os pierdo y como

581
00:49:15,119 --> 00:49:17,780
En alguna otra ocasión nos ha pasado

582
00:49:17,780 --> 00:49:20,219
Que estaba hablando yo solo

583
00:49:20,219 --> 00:49:22,179
Y luego al ratillo me habéis avisado

584
00:49:22,179 --> 00:49:24,400
Como la red a veces va un poquillo mal

585
00:49:24,400 --> 00:49:25,880
Vale, bueno, pues hasta aquí

586
00:49:25,880 --> 00:49:26,699
Alguna cosilla

587
00:49:26,699 --> 00:49:30,059
Intento ir muy despacito contándoos

588
00:49:30,059 --> 00:49:33,320
Cada línea hay mil películas de cada una de las líneas.

589
00:49:33,579 --> 00:49:34,840
Si os aburro, me avisáis.

590
00:49:35,699 --> 00:49:36,840
Si no, pues sigo así.

591
00:49:37,539 --> 00:49:37,960
Vale.

592
00:49:38,900 --> 00:49:40,900
Si no, pues sigo así para ir contando,

593
00:49:41,079 --> 00:49:42,840
haciendo repaso todo el rato de la teoría.

594
00:49:43,679 --> 00:49:46,059
Mirad, otra cosa de las que...

595
00:49:46,059 --> 00:49:46,320
Sí.

596
00:49:51,519 --> 00:49:53,119
Sí, sí, igual que las otras clases.

597
00:50:02,289 --> 00:50:03,789
Sí, sí, la estoy grabando.

598
00:50:03,889 --> 00:50:06,530
Si no tenemos algún problema por ahí técnico

599
00:50:06,530 --> 00:50:08,170
y termina por no grabarse,

600
00:50:08,170 --> 00:50:10,010
en principio he chequeado la grabación

601
00:50:10,010 --> 00:50:12,610
antes de arrancar y parecía que lo hacía bien.

602
00:50:12,730 --> 00:50:15,690
Y las tres últimas no habéis tenido problemas para verlas luego, ¿no?

603
00:50:16,210 --> 00:50:17,130
O sea, ¿están bien?

604
00:50:18,130 --> 00:50:19,550
¿Sí? ¿Bien? Vale.

605
00:50:19,989 --> 00:50:22,570
Pues bueno, pues en principio está igual.

606
00:50:22,730 --> 00:50:24,590
Estoy grabándola igual que las otras, sí.

607
00:50:25,989 --> 00:50:30,130
Vale, pues mirad otra de las cosas que aparecía en el tema 2

608
00:50:30,130 --> 00:50:34,469
y me pusisteis en uno de los silos una pregunta.

609
00:50:34,949 --> 00:50:37,050
Alguien fue en relación a los castings.

610
00:50:37,050 --> 00:50:42,389
como tenemos los tipos de datos primitivos

611
00:50:42,389 --> 00:50:44,789
vuelvo a ellos, por ejemplo el int y valor

612
00:50:44,789 --> 00:50:49,969
pues valor será una variable de tipo entero

613
00:50:49,969 --> 00:50:54,050
y tiene un determinado espacio en memoria RAM para guardar

614
00:50:54,050 --> 00:50:57,949
enteros, de hecho tiene un rango

615
00:50:57,949 --> 00:51:02,409
mirad, integer.masvalue

616
00:51:02,409 --> 00:51:07,530
system.out.println

617
00:51:07,530 --> 00:51:25,480
minValue, vamos a sacar el valor máximo y mínimo que puede tener un entero

618
00:51:25,480 --> 00:51:29,739
pues nada, mirad, cuando definimos una variable de tipo entero

619
00:51:29,739 --> 00:51:34,159
su valor puede ir entre este numerajo en positivo y este numerajo en negativo

620
00:51:34,159 --> 00:51:36,960
si definimos un long

621
00:51:36,960 --> 00:51:43,960
long también es un tipo de valor que admite

622
00:51:43,960 --> 00:51:47,699
enteros, pues aquí podríamos utilizar la clase

623
00:51:47,699 --> 00:51:51,320
graper como os decía antes, long.masValue

624
00:51:51,320 --> 00:51:57,760
para el long y long.minValue

625
00:51:57,760 --> 00:52:02,300
entonces si hacemos otra ejecución por aquí, fijaros

626
00:52:02,300 --> 00:52:06,119
como los long hacen una reserva de un mayor

627
00:52:06,119 --> 00:52:10,219
número de bytes en memoria RAM cuando para este tipo

628
00:52:10,219 --> 00:52:13,559
primitivo se coge espacio y

629
00:52:13,559 --> 00:52:18,559
por lo tanto es capaz de almacenar un rango mucho más grande, los enteros

630
00:52:18,559 --> 00:52:22,340
este, los long este, si nuestro

631
00:52:22,340 --> 00:52:26,679
programa no va a necesitar números mayores que éste, pues definimos enteros y menos memoria RAM

632
00:52:26,679 --> 00:52:33,920
que estamos consumiendo. Si se nos quedan cortos estos números, el número de gotas de agua que

633
00:52:33,920 --> 00:52:38,280
tiene el océano, pues lógicamente esto no nos va a valer, seguramente este tampoco, pero con este

634
00:52:38,280 --> 00:52:44,440
tendremos más posibilidades o una piscina. Entonces tendremos que saber un poco los rangos de valores

635
00:52:44,440 --> 00:52:51,619
que va a manejar nuestro programa para definirlo como long o como entero. ¿Qué sucede si nosotros

636
00:52:51,619 --> 00:52:59,880
cogemos y decimos que y valor es igual a 5 y lo decimos pues mira dentro de mi programa yo quiero

637
00:52:59,880 --> 00:53:09,409
como son los dos valores enteros quiero que el valor que es el long sea igual a y valor pues

638
00:53:09,409 --> 00:53:16,849
esto le vale porque porque algo que podemos guardar un número entero que va desde este rango a este

639
00:53:16,849 --> 00:53:23,369
este negativo si este tiene un rango mucho mayor lógicamente también se podrá guardar tenga me da

640
00:53:23,369 --> 00:53:27,429
igual el valor que tenga el entero, tanto si es un 5 como si es este valor

641
00:53:27,429 --> 00:53:31,690
máximo o este valor mínimo, que entra dentro del rango que es capaz de almacenarme

642
00:53:31,690 --> 00:53:34,969
el long. Con lo cual, coge y dice, esta asignación me gusta.

643
00:53:36,010 --> 00:53:39,070
En cambio, si ahora cojo y digo, iValor

644
00:53:39,070 --> 00:53:43,349
igual a lValor, esto no me

645
00:53:43,349 --> 00:53:46,170
compila. No sé si lo he puesto bien.

646
00:53:47,329 --> 00:53:51,309
No me compila. ¿Y por qué no me compila? Porque el long podría tener

647
00:53:51,309 --> 00:53:54,989
un valor almacenado, dado que su rango lo permite, mayor

648
00:53:54,989 --> 00:53:59,269
que el que podemos guardar un entero. Entonces, si aquí tenemos

649
00:53:59,269 --> 00:54:02,369
en lugar de este numerajo, este número pero acabado en 8,

650
00:54:03,190 --> 00:54:07,309
este número podría ser el que tuviera L valor y si se lo intento meter a un

651
00:54:07,309 --> 00:54:11,590
I valor, no va a entrar. ¿Qué sucedería? Pues que perderíamos

652
00:54:11,590 --> 00:54:15,210
ahí o bien precisión o se podría provocar ahí un error

653
00:54:15,210 --> 00:54:19,429
en ese entero y decir, oye, mira, a partir del programa

654
00:54:19,429 --> 00:54:26,510
no es me fío mucho cuando vayas a trabajar con este entero porque su resultado puede ser erróneo

655
00:54:26,510 --> 00:54:32,869
porque las ha asignado se se prevé que tiene el valor del long y en cambio vete tú sabes lo que

656
00:54:32,869 --> 00:54:38,449
tiene porque no entraba el programa aquí no nos va a dejar continuar no va a compilar no vamos a

657
00:54:38,449 --> 00:54:45,710
tener los puntos class con él con el vice code con lo cual el programa nos sale adelante ahora que

658
00:54:45,710 --> 00:55:14,650
Java dice, yo no quiero que a mí me culpes de este posible error, si se te da más adelante cuando ejecutes el programa. Pero Java dice, si tú aquí de forma explícita me dices que asumes que esto puede tener un error y dices que este L valor lo ajuste al tamaño de un entero, que probablemente si tú lo estás poniendo esto es porque el valor que va a tener el long normalmente va a estar en este rango, con lo cual no va a haber errores.

659
00:55:15,710 --> 00:55:25,349
Pero podría ser que no, claro. Si tú me lo dices de forma explícita, yo aquí ya acabo de firmar un contrato contigo y si luego hay un error, allá tú, tú eres el culpable, no yo, Java.

660
00:55:25,829 --> 00:55:36,670
Entonces esto se llama casting. Cuando un valor que permite un rango mayor de enteros, se lo asignamos a un valor con un rango menor, pues necesitamos hacer un casting.

661
00:55:36,670 --> 00:55:42,070
aquí es necesario el casting no en ningún caso porque java ya tiene seguridad de que no va a

662
00:55:42,070 --> 00:55:48,550
haber error todo lo que guarden en un entero de tipo int va a entrar en el rango de un entero

663
00:55:48,550 --> 00:55:55,570
de tipo logo entonces esto es lo que lo que hace referencia al casting está asignada esta

664
00:55:55,570 --> 00:56:02,090
confirmación desde el código de que a pesar de que ahí se puede producir un error yo lo asumo

665
00:56:02,090 --> 00:56:07,369
y sigue adelante programa si luego se da el error pues aquí lo asumiste esto ya es culpa tuya por

666
00:56:07,369 --> 00:56:14,269
haberlo por haber hecho esta suposición de que el dato del dato del long era válido y de la

667
00:56:14,269 --> 00:56:24,090
misma forma pasa si nosotros cogemos y definimos un double los double pues acordaros que tienen

668
00:56:24,090 --> 00:56:36,340
decimales decimos que vale 2,5 si yo ahora cojo y digo y valor que el entero tenga la información

669
00:56:36,340 --> 00:56:44,460
de mi double, pues se vuelve a quejar. ¿Por qué? En este caso, aparte de que a lo mejor tienen rangos

670
00:56:44,460 --> 00:56:50,579
que no lo aceptaría el entero la información del double, probablemente, pero además es por una cuestión

671
00:56:50,579 --> 00:56:55,559
de precisión. Si aquí voy a tener un valor entero y este tiene decimales, pues todos los decimales

672
00:56:55,559 --> 00:57:03,889
se van a perder. No me compila la misma jugada que estaba sucediendo aquí. Si yo aún así digo,

673
00:57:03,889 --> 00:57:09,949
mira es que en realidad aquí del valor este que viene arrastrando este double lo que me interesa

674
00:57:09,949 --> 00:57:13,849
en la parte entera en esta variable porque voy a hacer no sé qué operaciones con la parte entera

675
00:57:13,849 --> 00:57:21,349
pues le puede hacer un casting entonces puedo y decirle que lo asuma como un entero

676
00:57:22,309 --> 00:57:35,699
si yo hago un sistema punto out punto println del double lógicamente tiene 2,5 que lo que

677
00:57:35,699 --> 00:57:50,030
le hemos asignado y si lo hago de y valor ejecutó pues se perdió 0.5 se ha producido una pérdida de

678
00:57:50,030 --> 00:57:55,130
precisión pues sí efectivamente porque estamos guardando un valor con decimales en un valor

679
00:57:55,130 --> 00:58:04,159
entero pero yo aquí he dicho que eso lo de por hecho si la jugada al agua al revés necesitaré

680
00:58:04,159 --> 00:58:12,739
un casting pues no porque si digo me da bol que sea igual al valor que tiene y valor esto le

681
00:58:12,739 --> 00:58:21,969
parece bien si hay aquí valor igual a 10 habrá algún problema pues ahora esto será una variable

682
00:58:21,969 --> 00:58:29,389
con decimales a la que si asignó el valor 10 entero pues su valor decimal será 10.0 pero no

683
00:58:29,389 --> 00:58:36,510
hay pérdida de precisión es del 10 al 10.0 el mismo número de si yo aquí vuelvo a mostrar los

684
00:58:36,510 --> 00:58:49,159
dos bueno fijaros como el double vale 10.0 porque sólo hemos asignado aquí desde el entero aquí es

685
00:58:49,159 --> 00:58:56,579
necesario un casting no porque porque no hay lugar no hay opción de perder precisión en el otro caso

686
00:58:56,579 --> 00:59:02,260
era necesario el casting pues sí porque se podía pero era había opción de perder precisión entonces

687
00:59:02,260 --> 00:59:11,650
si quieres seguir adelante reconocerlo tú de forma explícita si alguna cosilla se entiende bien esto

688
00:59:11,650 --> 00:59:33,539
también vale pues a ver estoy mirando bueno entre daba un long tenemos el mismo problema que entre

689
00:59:33,539 --> 00:59:46,469
int y double porque como el double admite decimales y el long no sé en la misma circunstancia que

690
00:59:46,469 --> 00:59:52,349
tenemos aquí entre un int y un long ya que el long admite un rango mayor que el link lo tenemos con

691
00:59:52,349 --> 01:00:05,219
decimales entre el double y el float el float tiene un rango menor que el double entonces si

692
01:00:05,219 --> 01:00:19,900
yo aquí cojo y digo 3 perdón vamos a poner vamos a inicializar el labor si digo 3.2 entonces yo hago

693
01:00:19,900 --> 01:00:29,099
efe vale igual a de bal aquí también se me quejas no se me queja en este caso porque uno tenga

694
01:00:29,099 --> 01:00:35,639
decimales y otro no y se pierda la precisión esa sino porque el double al ser un tipo que ocupa

695
01:00:35,639 --> 01:00:41,500
mayor espacio en memoria ram tiene un rango mayor y su valor aunque este no es el caso simplemente

696
01:00:41,500 --> 01:00:46,480
vale 32 en este caso y también lo acepta un flow at pero a la hora de hacer esta validación el

697
01:00:46,480 --> 01:00:53,940
compilador lo que mira es en los tipos entonces dice la información de un double podría llegar

698
01:00:53,940 --> 01:01:07,130
de tener un valor que no me entrase en un flow at que si yo cojo de aquí a un casting a ver no

699
01:01:07,130 --> 01:01:28,550
era hecho a ver que lo que he hecho aquí no me deja ahora aquí hacer esto yo juraría que el

700
01:01:28,550 --> 01:01:37,710
otro día estoy mirando esto y sí que sí que me funcionó desde una variable no me deja el otro

701
01:01:37,710 --> 01:01:53,900
día lo mire a ver perdón a sí vale vale es porque se vale bien es porque utilizado la grupper se

702
01:01:53,900 --> 01:02:23,619
utilizo el dato primitivo, creo que es por eso, a ver, vamos a hacer la prueba y os lo reviso, aquí sí lo traga, vale, no me estaba dejando hacer una conversión desde este double que era la clase stackwrapper que os he dicho que tenía luego parámetros por aquí para poder utilizar, pero si utilizamos los tipos primitivos, igual que habíamos hecho con el long, es decir, en lugar de definir la variable double, la he definido con este double,

703
01:02:23,619 --> 01:02:29,599
pero con la d minúscula, veis que se ha puesto así, ya es el dato primitivo y ya sí que me deja hacer el casting.

704
01:02:31,099 --> 01:02:40,170
Y en cambio aquí, pues no me dejaba. Por el mismo motivo del int y del long de antes, por el tamaño.

705
01:02:41,210 --> 01:02:50,469
Y luego otra cosilla que veíamos era que si poníamos fval igual a 3.4, esto no le gustaba.

706
01:02:50,469 --> 01:02:59,090
Y esto tampoco le gusta, porque este tipo de dato, si lo ponemos aquí directamente, Java lo considera como un double.

707
01:02:59,829 --> 01:03:05,190
Entonces estamos en la misma jugada que si ponemos una variable tipo double asignándosela a un float.

708
01:03:08,170 --> 01:03:12,590
En el momento de no indicar si es un double o un float, Java tendría que tomar una decisión.

709
01:03:12,730 --> 01:03:15,889
¿Lo guardo en un espacio de memoria float o en un espacio de memoria double?

710
01:03:16,289 --> 01:03:19,170
Y por lo que sea, Java está programado para considerarlo un double.

711
01:03:19,170 --> 01:03:24,409
como se lo intentó meter luego un flow at por dice no va a esta información que es un double

712
01:03:24,409 --> 01:03:30,869
en este valor que es un flow at aquí podríamos hacer un casting también y se lo tragaría

713
01:03:32,369 --> 01:03:41,449
o indicar al número si le aquí después le ponemos una f estamos diciendo que este 3.4 en realidad es

714
01:03:41,449 --> 01:03:46,289
un valor que lo considere flow at ya desde este momento entonces aunque no pongamos el casting

715
01:03:46,289 --> 01:03:50,590
le deja, porque este 3,4 en realidad es un float, que se lo estoy asignando

716
01:03:50,590 --> 01:03:54,110
a una variable float. ¿La f minúscula también se la deja?

717
01:03:54,309 --> 01:03:58,610
Sí. Podemos poner la f minúscula, f mayúscula, después del número

718
01:03:58,610 --> 01:04:01,469
para decir, oye, que esto es un float, no es un double.

719
01:04:02,110 --> 01:04:05,510
Si no ponemos nada, lo considero un double. Si ponemos una d, no.

720
01:04:05,889 --> 01:04:09,769
Para que sea un... A ver, si ponemos una d

721
01:04:09,769 --> 01:04:17,550
y hacemos el casting. Bien. Si ponemos una d, lo considera

722
01:04:17,550 --> 01:04:21,130
double, que es igual que no poner nada, si ponemos una F, lo considera float.

723
01:04:31,210 --> 01:04:36,110
¿Sí? ¿Bien? Vale.

724
01:04:36,789 --> 01:04:40,750
Pues mirad. Vale, borro por aquí, si no tenéis ninguna pregunta más

725
01:04:40,750 --> 01:04:45,110
de esto del casting, que era otra de las cosas que nos había quedado un poco por ahí pendientes.

726
01:04:51,420 --> 01:04:55,980
Mirad, más cosas. Cuando nosotros

727
01:04:55,980 --> 01:04:59,920
ponemos el método system.out.println

728
01:05:00,659 --> 01:05:06,570
aquí, entre

729
01:05:06,570 --> 01:05:13,409
paréntesis este método recordar system out para escribir por pantalla si éste no tiene diferentes

730
01:05:13,409 --> 01:05:18,570
opciones fijaros tiene muchos métodos típicamente utilizamos el println pero podemos escribir de

731
01:05:18,570 --> 01:05:28,679
muchas formas tiene muchas alternativas println otra que tiene sprint sin el en el ln que nos

732
01:05:28,679 --> 01:05:36,050
deja el cursor al final de lo que acabamos de escribir normalmente aquí lo que ponemos es una

733
01:05:36,050 --> 01:05:40,989
cadena de caracteres algo o bueno ponemos una cadena caracteres o

734
01:05:40,989 --> 01:05:46,070
cualquier otra cosa pero aquí lo que nos escribe es un texto

735
01:05:46,070 --> 01:05:49,130
si ponemos

736
01:05:49,130 --> 01:06:05,159
in a y val igual a 3 y ponemos aquí el número es igual pues fijaros aquí

737
01:06:05,159 --> 01:06:12,900
tenemos una cadena de caracteres aquí tenemos un valor numérico vamos a ejecutar y lo que nos

738
01:06:12,900 --> 01:06:20,500
saca por pantalla es toda una cadena de caracteres al final todo este conjunto se convierte en una

739
01:06:20,500 --> 01:06:24,500
cadena de caracteres lo que hay entre paréntesis tengamos aquí lo que tengamos una combinación de

740
01:06:24,500 --> 01:06:33,699
cosas una variable solo un literal solo una variable string un literal y un número de

741
01:06:33,699 --> 01:06:39,159
De alguna forma, todo esto lo va a terminar convirtiendo en una cadena de caracteres que nos va a mostrar por aquí por pantalla.

742
01:06:39,159 --> 01:07:01,980
Eso es porque todas las clases de Java, todas, tienen un método que es el método toString, que viene a ser convierte a una cadena de caracteres.

743
01:07:04,440 --> 01:07:15,539
Pero podemos decir, vale, me puedo creer que en las clases que tú importes desde las librerías han puesto el método este toString.

744
01:07:15,639 --> 01:07:19,920
me lo puedo creer. Pero en esta clase que estás definiendo

745
01:07:19,920 --> 01:07:23,719
tú aquí en este programa, yo no veo que hayas programado un método

746
01:07:23,719 --> 01:07:27,480
toString por aquí, por ningún sitio. Luego podremos programar el método

747
01:07:27,480 --> 01:07:31,719
a saludar como antes, los que vayan requiriendo nuestro programa, pero yo no veo que hayas

748
01:07:31,719 --> 01:07:35,719
programado ningún método toString. Y en cambio estamos afirmando

749
01:07:35,719 --> 01:07:38,239
que todas las clases disponen de ese método.

750
01:07:39,559 --> 01:07:43,980
En Java y en otros lenguajes en la programación orientada a objetos,

751
01:07:43,980 --> 01:08:03,880
Otra de las características que tenemos con los temas, hablaremos en profundidad si hay temas que tratan de esto en particular, pero vamos anticipando cosas. Igual que tenemos, por ejemplo, la sobrecarga, principio de métodos que hemos visto antes con el método saludar.

752
01:08:04,719 --> 01:08:06,639
Otra de las características que tenemos es la herencia.

753
01:08:09,219 --> 01:08:12,739
Esto quiere decir que existe una jerarquía de clases en Java

754
01:08:12,739 --> 01:08:20,029
y las va nombrando una jerarquía, digamos, en una estructura tipo árbol,

755
01:08:20,029 --> 01:08:27,350
podemos considerar, en la cual tenemos una clase aquí, clase 1 o clase padre

756
01:08:27,350 --> 01:08:33,130
y luego vamos teniendo, podemos a través de la herencia,

757
01:08:33,130 --> 01:08:42,310
hacer que una clase sea una clase hija de una determinada clase padre esto que implica la

758
01:08:42,310 --> 01:08:47,170
herencia hablaremos de ella vale en uno de los temas esto lo que implica es que esta clase hija

759
01:08:47,170 --> 01:08:57,250
cuando la definimos podemos decir que sea hija de una determinada eres hija de una clase padre

760
01:08:57,250 --> 01:09:04,220
en particular. En este caso, la que hemos llamado clase

761
01:09:04,220 --> 01:09:09,800
p. Entonces, todo lo que hay que definir, la clase

762
01:09:09,800 --> 01:09:13,640
hija tendrá como atributos y como métodos todo lo que definamos

763
01:09:13,640 --> 01:09:17,600
en ella, pues igual que estamos haciendo por aquí, sus métodos

764
01:09:17,600 --> 01:09:21,960
y sus atributos, y por herencia, todos los atributos

765
01:09:21,960 --> 01:09:29,149
y métodos que tenga la clase padre. La forma

766
01:09:29,149 --> 01:09:33,090
en Java, ya os digo que hay temas en los que se habla

767
01:09:33,090 --> 01:09:39,010
en particular de esto. La forma de decir en Java que una clase es hija de otra es a través

768
01:09:39,010 --> 01:09:46,430
de la etiqueta extend. Se extiende o hereda, esta clase hereda de una determinada clase

769
01:09:46,430 --> 01:09:54,550
padre. Sería en la clase hija, pondríamos extends clase p. Y en este caso, todo lo que

770
01:09:54,550 --> 01:10:02,909
tiene definida la clase p, lo tenemos disponible nosotros. Cuando definimos una clase, esta

771
01:10:02,909 --> 01:10:10,819
clase puede ser hija de una única clase padre, de una solo. ¿Por qué? Porque

772
01:10:10,819 --> 01:10:18,510
imaginaos que si pudiera ser hija de varias clases al mismo tiempo y cada una

773
01:10:18,510 --> 01:10:22,470
de estas clases definiese un método saludar diferente, con un comportamiento

774
01:10:22,470 --> 01:10:26,229
diferente, volveríamos a tener discrepancias. Imaginaos que en la clase

775
01:10:26,229 --> 01:10:31,750
P, como parte de su código aquí, hemos definido el método saludar. Y en la clase

776
01:10:31,750 --> 01:10:38,720
J también definimos un método saludar con un comportamiento

777
01:10:38,720 --> 01:10:42,600
distinto. Uno dice hola y otro dice buenos días. Entonces, si

778
01:10:42,600 --> 01:10:46,380
la clase H fuese hija de forma

779
01:10:46,380 --> 01:10:50,539
simultánea de la clase P y de la clase J y un objeto de la

780
01:10:50,539 --> 01:10:54,560
clase H intenta saludar, no sabría si ejecutar lo que tiene la clase P

781
01:10:54,560 --> 01:10:58,739
definido para saludar o lo que tiene la clase J. Habría una discrepancia

782
01:10:58,739 --> 01:11:02,720
ahí y no sería posible. Hay algunos lenguajes de programación orientada a objetos

783
01:11:02,720 --> 01:11:10,399
que lo permiten la herencia múltiple aunque hay que manejarla hay que gestionarla pero en java

784
01:11:10,399 --> 01:11:15,920
no se permite herencia múltiple solamente se puede tener ser hija de una clase en particular no de

785
01:11:15,920 --> 01:11:22,060
varias en este caso por ejemplo la clase p entonces si yo no tengo definido aquí cómo saludar saludaría

786
01:11:22,060 --> 01:11:29,439
de la misma forma que esté definido en la clase p además de la herencia está que podemos identificar

787
01:11:29,439 --> 01:11:33,300
nosotros mediante la etiqueta extend, hay una especie de herencia

788
01:11:33,300 --> 01:11:37,220
en todas las clases de Java de una clase

789
01:11:37,220 --> 01:11:41,439
que está arriba del todo en la jerarquía de clases

790
01:11:41,439 --> 01:11:48,340
de Java, que es la clase object. Y esta clase, aunque no le pongamos

791
01:11:48,340 --> 01:11:52,260
el extend, de esta clase sí que heredan todas, todas.

792
01:11:52,979 --> 01:11:56,279
Y en esta clase object existe, entre otras cosas,

793
01:11:56,579 --> 01:12:00,399
el método toString, que os decía, por aquí

794
01:12:00,399 --> 01:12:09,939
arriba en definitiva en cualquier cualquier objeto de cualquier clase tiene un método tu string que

795
01:12:09,939 --> 01:12:15,180
aunque no lo programamos por esa herencia general no por la que identificamos nosotros en nuestro

796
01:12:15,180 --> 01:12:25,760
programa con stand de la clase object todo objeto tendrá ese método tu string disponible se entiende

797
01:12:25,760 --> 01:12:59,180
Sí, más o menos, sí, vale. Entonces, de forma implícita, no es necesario indicarlo, todo lo que pongamos aquí entre la apertura y cierre de paréntesis, sea una cadena de caracteres, un literal, una variable string, un entero, un long o lo que sea,

798
01:12:59,180 --> 01:13:03,760
antes de escribirse por pantalla en el println

799
01:13:03,760 --> 01:13:07,319
llama al método toString y concatena

800
01:13:07,319 --> 01:13:11,420
todas esas variables. Como consecuencia aquí nos sale siempre

801
01:13:11,420 --> 01:13:14,619
un método toString. Fijaros que toString

802
01:13:14,619 --> 01:13:18,560
viene a significar convertir a string, lo que sea.

803
01:13:19,560 --> 01:13:23,380
Si fijáis, por ejemplo, si ponemos aquí integer, la clase griper de integer, si ponemos

804
01:13:23,380 --> 01:13:27,239
aquí toString, ¿veis? Existe una clase toString que

805
01:13:27,239 --> 01:13:31,380
recibe un entero, el valor entero y nos devuelve

806
01:13:31,380 --> 01:13:35,220
¿qué? nos devuelve una cadena de caracteres, con cualquiera

807
01:13:35,220 --> 01:13:38,619
todas ellas, mira si definimos aquí

808
01:13:38,619 --> 01:13:43,300
clase print

809
01:13:43,300 --> 01:13:48,720
un objeto de mi clase

810
01:13:48,720 --> 01:14:02,289
si pongo mi object.toString, ¿veis?

811
01:14:02,890 --> 01:14:06,409
también la tengo disponible, siempre cualquier objeto

812
01:14:06,409 --> 01:14:10,270
aunque no lo haya identificado, tanto la clase grupper de las librerías

813
01:14:10,270 --> 01:14:14,710
integer, como cualquier otra, como un objeto de una clase

814
01:14:14,710 --> 01:14:18,050
mía propia, aunque no lo haya definido, siempre tiene disponible

815
01:14:18,050 --> 01:14:22,829
el método toString y fijaros, lo tiene disponible, devuelve un string

816
01:14:22,829 --> 01:14:26,550
lo tiene disponible desde una clase, digamos

817
01:14:26,550 --> 01:14:29,409
padre, que es la clase object que os comentaba

818
01:14:29,409 --> 01:14:34,750
esto es lo que permite que el system of println tengas aquí

819
01:14:34,750 --> 01:14:41,449
el tipo de variable que tengas, este método espera siempre que todo esto se resuelva a una cadena de caracteres

820
01:14:41,449 --> 01:14:48,930
que es la que él va a mostrar por pantalla. Y lo que no es cadena de caracteres llamará de forma implícita,

821
01:14:48,970 --> 01:14:55,970
no hace falta que lo hagamos nosotros, al toString que tenga definido para convertirlo en una cadena de caracteres

822
01:14:55,970 --> 01:15:02,689
y que el println lo muestre por aquí. Si es un entero, pues el toString de la clase grupper del entero,

823
01:15:02,689 --> 01:15:11,770
¿qué hará? Pues convertirá este valor numérico, convertirá en este caso como iVal vale 3.

824
01:15:13,550 --> 01:15:20,750
Justo antes de hacer esta conversión, lo que hará será llamar al toString y convertirá ese 3 a este 3,

825
01:15:21,289 --> 01:15:29,050
para que esta cadena de caracteres la pueda concatenar con esta otra y así se nos muestre el resultado de esta forma por pantalla.

826
01:15:29,050 --> 01:15:48,449
Bueno, de momento sobre la clase toString trabajaremos porque la sobrescribiremos en ciertos momentos, pero más adelante.

827
01:15:48,449 --> 01:15:55,210
Ahora bueno, simplemente que tengáis la idea de herencia en Java, vamos introduciéndola.

828
01:15:56,010 --> 01:16:05,750
Nosotros por código podemos poner aquí la etiqueta extends y aquí poner una clase de la cual haría clase print,

829
01:16:05,750 --> 01:16:11,149
con lo cual tendríamos disponible todo lo que pusiéramos aquí, todo lo que tuviéramos definido en la clase que pongamos aquí

830
01:16:11,149 --> 01:16:23,430
y que a partir de esta herencia que tiene que ser única con Stents, tenemos la posibilidad, sabemos que toda clase tiene ciertas características

831
01:16:23,430 --> 01:16:32,510
heredadas directamente, todas ellas, de una clase que digamos está en la jerarquía más alta de las clases en Java, que es la clase Object.

832
01:16:32,510 --> 01:16:51,260
Y entre ellas, pues tenemos, por ejemplo, no solamente este, pero tenemos el método toString, que convierte cualquier valor de esa clase en una cadena de caracteres. A ver qué más cosas por ahí puedo contar.

833
01:16:51,260 --> 01:17:41,020
Mira, si tenemos, aprovechando que estamos hablando del toString, hemos dicho antes que teníamos la posibilidad de poner ival, imaginaos que tenemos un string, ese info, que tiene un valor numérico, un 3.

834
01:17:41,020 --> 01:17:45,880
antes en los ejemplos anteriores lo estábamos cogiendo con netzint a través de

835
01:17:45,880 --> 01:17:49,800
escáner, si este 3 que es una cadena de caracteres

836
01:17:49,800 --> 01:17:53,220
la queremos meter en un valor entero

837
01:17:53,220 --> 01:17:57,779
habíamos visto que tenemos integer, parseInt

838
01:17:57,779 --> 01:17:59,380
esta opción, este método

839
01:17:59,380 --> 01:18:05,460
nos transforma a un valor numérico de tipo entero

840
01:18:05,460 --> 01:18:10,380
un valor que es un número pero que lo tenemos capturado como una cadena de caracteres

841
01:18:11,140 --> 01:18:24,060
Otro método que tenemos también para hacer esto mismo, igual de válida, también de la clase Grouper, Integer y en todas las clases Grouper lo tenemos, es el método ValueOf.

842
01:18:24,840 --> 01:18:35,010
ValueOf viene a hacer lo mismo. Podemos poner aquí ese info y también nos convertiría, la cadena es equivalente a esta otra.

843
01:18:35,010 --> 01:18:39,670
nos metería en el valor numérico el valor de la cadena

844
01:18:39,670 --> 01:18:42,449
y si lo que queremos hacer es lo contrario

845
01:18:42,449 --> 01:18:47,430
es decir, tenemos un valor 3

846
01:18:47,430 --> 01:18:51,569
hemos dicho que si metemos system.out

847
01:18:51,569 --> 01:18:55,479
.println

848
01:18:55,479 --> 01:19:04,390
de ival, println espera sacar por pantalla

849
01:19:04,390 --> 01:19:08,289
lo que tenga aquí dentro pero como una cadena de caracteres

850
01:19:08,289 --> 01:19:24,489
Entonces hemos dicho que de forma implícita llama al método toString, esto es para sacarlo por pantalla, pero imaginaros que de verdad no queremos sacarlo por pantalla, lo que queremos es tenerlo a nuestra disposición una variable de tipo string de momento porque queremos hacer otras cosas diferentes a sacarlo por pantalla.

851
01:19:24,489 --> 01:19:43,409
Entonces podríamos tener una variable de tipo string y para cargar este número como una cadena de caracteres, si yo cojo y pongo y val, pues esto no le gusta, ¿por qué? Porque son tipos incompatibles, una cadena de caracteres con un número no le va bien.

852
01:19:43,409 --> 01:19:47,329
Entonces, ¿qué podríamos hacer? Pues podríamos coger y utilizar de la clase

853
01:19:47,329 --> 01:19:52,090
grouper integer el método toString, que es el que estamos diciendo.

854
01:19:55,819 --> 01:19:59,319
Tenemos un entero en este caso, clase grouper integer toString,

855
01:19:59,539 --> 01:20:03,460
le pasamos el valor y nos devuelve una cadena de caracteres.

856
01:20:04,199 --> 01:20:07,640
Con lo cual, ese val, ¿qué información tendrá? Pues tendrá este 3,

857
01:20:08,340 --> 01:20:10,899
pero lo tendrá en formato de cadena de caracteres, así.

858
01:20:25,439 --> 01:20:35,079
Bien, ¿alguna preguntilla tenéis por ahí? ¿Queréis alguna consulta?

859
01:20:35,199 --> 01:20:42,600
Está siendo un poco cajón desastre, os estoy contando muchas cosas, pero bueno, son conceptos que antes o después nos irán viniendo bien.

860
01:20:58,439 --> 01:21:15,920
Sí, mira, en línea general, bueno, repito la pregunta para que quede en la grabación, me dicen que si podemos repasar un poco otra vez lo de las clases wrapper, el sentido que tienen y para qué se utilizan.

861
01:21:16,279 --> 01:21:19,060
Hemos hablado antes un poquito de ellas, pero bueno, le pegamos otra vuelta.

862
01:21:20,279 --> 01:21:45,520
Los, toda clase, tanto las propias como las de las librerías, están compuestas por una serie de parámetros y una serie de métodos. En las variables referenciadas para hacer la reserva de memoria que necesitan, recordad que tenemos que hacer el new y luego el constructor para inicializar ese objeto.

863
01:21:45,520 --> 01:22:02,279
En cambio, estos días ya, durante esta tutoría y las anteriores, hemos dicho que hay una serie de variables en Java que son las variables primitivas. El int, el long, el string, el double, el float, el boolean, todas estas.

864
01:22:02,279 --> 01:22:06,399
estas variables son un poquito diferentes a las

865
01:22:06,399 --> 01:22:09,300
referenciadas, en primer lugar no necesitamos hacer su new

866
01:22:09,300 --> 01:22:12,359
para tener espacio de memoria, pero luego no tienen

867
01:22:12,359 --> 01:22:15,159
a su disposición una serie de métodos

868
01:22:15,159 --> 01:22:17,359
si os fijáis, si yo defino

869
01:22:17,359 --> 01:22:20,760
vamos a aprovecharnos un poquito de Eclipse

870
01:22:20,760 --> 01:22:26,920
si yo defino un objeto

871
01:22:26,920 --> 01:22:30,020
de la clase que he creado yo aquí

872
01:22:30,020 --> 01:22:32,619
en el proyecto, clase print, si ahora pongo aquí

873
01:22:32,619 --> 01:22:36,840
un punto, Eclipse me está ofreciendo

874
01:22:36,840 --> 01:22:40,840
todos los métodos que están definidos para la clase

875
01:22:40,840 --> 01:22:44,760
print, para el objeto de la clase print y para la clase

876
01:22:44,760 --> 01:22:48,659
print en particular. Fijaros que yo en clase print no he

877
01:22:48,659 --> 01:22:52,340
definido métodos, pero en cambio tengo todos estos, ¿por qué?

878
01:22:52,560 --> 01:22:55,479
Pues los tendré por herencia desde la clase object.

879
01:22:56,760 --> 01:23:00,640
Fijaros como todos aquí a la derecha me dicen object base, ¿por qué los

880
01:23:00,640 --> 01:23:03,460
tiene disponible por esa herencia que os decía de la clase

881
01:23:03,460 --> 01:23:06,420
Object. La única que me aparece aquí como clase Print

882
01:23:06,420 --> 01:23:09,500
es precisamente el método Main, que es el único que tengo definido por aquí.

883
01:23:09,699 --> 01:23:12,600
Todos los demás disponibles a través de la clase Object.

884
01:23:14,319 --> 01:23:15,560
Y Eclipse me los ha ofrecido

885
01:23:15,560 --> 01:23:18,180
poniendo aquí un punto para poder llamarlos.

886
01:23:18,539 --> 01:23:21,560
Si yo pongo aquí valor punto, no me ofrece nada.

887
01:23:21,720 --> 01:23:24,319
¿Veis? ¿Por qué sucede esto?

888
01:23:24,720 --> 01:23:27,920
Porque los tipos primitivos son especiales

889
01:23:27,920 --> 01:23:48,079
En dos aspectos al menos. Uno, que no necesitamos hacer el new como a los referenciados y otro, que no tienen definidos los tipos primitivos métodos que utilizar. Pero a veces nos resultará útil hacer cosas con un entero. Nos vendría bien tener métodos relacionados con este valor de tipo entero.

890
01:23:48,079 --> 01:23:55,319
entonces para tener eso a nuestra disposición en las librerías de java a cada uno de los tipos

891
01:23:55,319 --> 01:24:01,359
primitivos se le para cada uno de los tipos primitivos se han desarrollado de forma paralela

892
01:24:01,359 --> 01:24:08,880
una clase que es la clase grupper en este caso para el tipo entero pues tenemos la clase grupper

893
01:24:08,880 --> 01:24:15,939
integer y este si ponemos aquí sí que nos ofrece ya cosas para hacer todas ellas relacionadas con

894
01:24:15,939 --> 01:24:19,520
enteros, fijaros que casi todas aceptan mínimo

895
01:24:19,520 --> 01:24:23,260
valor de un entero, máximo valor de un entero, tamaño de un entero

896
01:24:23,260 --> 01:24:27,920
entradas de entre dos como parámetros, ¿por qué? porque está pensada

897
01:24:27,920 --> 01:24:31,699
o bien de salida o bien de entrada, siempre hay enteros, está pensada

898
01:24:31,699 --> 01:24:35,699
para dar funcionalidades al tipo primitivo

899
01:24:35,699 --> 01:24:39,020
entero, y esta es la clase Grouper Integer

900
01:24:39,020 --> 01:24:45,060
volviendo a conceptos de los que hemos hablado antes, para la clase

901
01:24:45,060 --> 01:24:49,520
integer, ¿hemos necesitado definir un objeto y utilizarlo?

902
01:24:49,600 --> 01:24:53,180
No, directamente hemos puesto el nombre de la clase y un punto y ya me ofrece

903
01:24:53,180 --> 01:24:57,180
cosas. ¿Qué pasará con todos estos parámetros y métodos que

904
01:24:57,180 --> 01:25:01,520
son estáticos? Son parámetros y métodos de la clase en su conjunto,

905
01:25:01,640 --> 01:25:04,819
no de objetos en particular, por eso están disponibles.

906
01:25:06,079 --> 01:25:09,220
Y estas son las clases graper, clases asociadas a los

907
01:25:09,220 --> 01:25:13,140
tipos primitivos que nos dan aquellas funcionalidades que nos

908
01:25:13,140 --> 01:25:18,180
Vendría bien tener para esos tipos, pero que no están disponibles cuando se definieron.

909
01:25:20,760 --> 01:25:23,720
Y estamos utilizando, ahora hemos hablado de, por ejemplo, en el caso de Integer,

910
01:25:24,199 --> 01:25:28,659
que las tenemos en diferentes, pues tenemos el parseInt, tenemos el valueOf.

911
01:25:29,300 --> 01:25:33,239
Bueno, tenemos muchas, como habéis visto antes, el valor máximo y el valor mínimo.

912
01:25:35,079 --> 01:25:38,840
Tenemos el toString. Bueno, pues muchas de ellas por ahí, ¿vale?

913
01:25:41,220 --> 01:25:46,800
Tenemos todas las que nos salen aquí. Estas son las clases de Wrapper.

914
01:25:46,920 --> 01:25:53,800
no sé si queda claro más o menos

915
01:25:53,800 --> 01:25:57,479
sí, vale

916
01:25:57,479 --> 01:26:00,640
vale, vale

917
01:26:00,640 --> 01:26:02,319
mirad en la

918
01:26:02,319 --> 01:26:03,140
de la

919
01:26:03,140 --> 01:26:04,520
tarea

920
01:26:04,520 --> 01:26:06,720
bueno pues

921
01:26:06,720 --> 01:26:09,319
no sé si habéis tenido la oportunidad de leerla

922
01:26:09,319 --> 01:26:11,260
supongo unos sí, otros no

923
01:26:11,260 --> 01:26:13,119
pedía

924
01:26:13,119 --> 01:26:14,720
meter por teclado

925
01:26:14,720 --> 01:26:17,680
unos números de tres entradas

926
01:26:17,680 --> 01:26:19,600
que las identificaba

927
01:26:19,600 --> 01:26:21,439
un número y luego si era par o impar

928
01:26:21,439 --> 01:26:26,619
nos permitía decir si tenía que ir a una grada azul o a una grada verde.

929
01:26:26,760 --> 01:26:28,840
Bueno, pues por separarlo en pares e impares.

930
01:26:30,319 --> 01:26:33,399
Cosas de la práctica que tenemos.

931
01:26:34,760 --> 01:26:35,439
¿Qué he visto?

932
01:26:35,579 --> 01:26:38,220
Pues, por un lado, el nest int,

933
01:26:39,000 --> 01:26:40,939
aunque no provocaba error en esta práctica,

934
01:26:41,340 --> 01:26:43,199
pues cuidado con el enter del nest int,

935
01:26:43,239 --> 01:26:45,119
que hemos hablado antes de ello.

936
01:26:45,859 --> 01:26:48,960
Luego, si hacíamos la lectura con un nest line,

937
01:26:48,960 --> 01:27:01,500
como pedía que la información se metiera desde el teclado

938
01:27:01,500 --> 01:27:05,399
en una única entrada separado por espacios

939
01:27:05,399 --> 01:27:09,699
tenemos esta cadena, claro, pero esto no es un número, son tres

940
01:27:09,699 --> 01:27:12,380
entonces si lo tenemos en una variable de tipo string

941
01:27:12,380 --> 01:27:17,649
teniendo en cuenta que esto lo hemos cogido desde teclado

942
01:27:17,649 --> 01:27:23,710
con un slide, al final tendríamos en la variable

943
01:27:23,710 --> 01:27:26,930
algo así, pues bueno, os comentaba el otro día que

944
01:27:26,930 --> 01:27:29,689
la clase

945
01:27:29,689 --> 01:27:31,390
stream precisamente

946
01:27:31,390 --> 01:27:33,850
tiene un método que es el método

947
01:27:33,850 --> 01:27:35,789
split. Y el método

948
01:27:35,789 --> 01:27:38,050
split permite separar

949
01:27:38,050 --> 01:27:39,789
en diferentes trozos

950
01:27:39,789 --> 01:27:41,850
considerando un carácter

951
01:27:41,850 --> 01:27:43,869
separador. En este caso podría ser el espacio.

952
01:27:44,189 --> 01:27:45,270
Si hubiéramos dicho en el enunciado

953
01:27:45,270 --> 01:27:48,229
por ejemplo la almohadilla

954
01:27:48,229 --> 01:27:49,789
pues podríamos considerar como carácter

955
01:27:49,789 --> 01:27:51,069
espaciador la almohadilla.

956
01:27:53,850 --> 01:27:55,750
Y lo que querríamos en este caso

957
01:27:55,750 --> 01:27:59,850
es obtener, por un lado el 7, por otro el 6, por otro el 5, sabiendo que está

958
01:27:59,850 --> 01:28:03,869
identificado con la almohadilla del separador, en este caso, el enunciado de la práctica

959
01:28:03,869 --> 01:28:07,710
decía un espacio, pues lo que podríamos hacer es

960
01:28:07,710 --> 01:28:10,869
dividirlo, utilizar un array, que os hablaba el otro día de él,

961
01:28:16,399 --> 01:28:20,239
si ponemos sval.split en el método este,

962
01:28:22,000 --> 01:28:24,539
aquí podemos meter información de la

963
01:28:24,539 --> 01:28:28,819
separación, en este caso sería la almohadilla, y nos cargaría

964
01:28:28,819 --> 01:28:39,039
en un array en esta variable que es un array de strings nos cargaría todos los datos recibidos

965
01:28:39,039 --> 01:28:46,840
desde esta variable que sería un 5 un 6 y un 7 y los array os comentaba el otro día ya hablaremos

966
01:28:46,840 --> 01:28:58,479
de ellos son variables que comparten el nombre pero son tantas variables de este tipo en este

967
01:28:58,479 --> 01:29:02,539
caso string, como el tamaño que tenga el array. Y para acceder a cada una

968
01:29:02,539 --> 01:29:08,460
de ellas, de esas variables, entre los

969
01:29:08,460 --> 01:29:11,779
corchetes ponemos aquí un índice que va desde 0

970
01:29:11,779 --> 01:29:16,420
hasta un número menos del tamaño que tiene el array. En este

971
01:29:16,420 --> 01:29:20,420
caso sería hasta 2. Fijaros, tiene 3 elementos, 1, 2 y

972
01:29:20,420 --> 01:29:24,279
3. Pues la posición 0 en el índice sería

973
01:29:24,279 --> 01:29:28,300
el 5, la posición 1 el 6 y la posición 2 el 7. Y cada uno de ellos

974
01:29:28,300 --> 01:29:35,800
serían un string fijaros esta variable si leemos hacia el

975
01:29:35,800 --> 01:29:43,829
izquierda sería un array de strings conjunto de strings esto que sería la

976
01:29:43,829 --> 01:29:47,689
variable leyendo derecha izquierda en la línea de abajo está de izquierda a

977
01:29:47,689 --> 01:29:52,850
derecha con la información del corchete cada una de ellas sería un string

978
01:29:52,850 --> 01:29:58,649
con lo cual esto es un string esto es un array de strings esto es un string cada

979
01:29:58,649 --> 01:30:02,810
una de ellas. Entonces aquí con el string ya podríamos utilizar

980
01:30:02,810 --> 01:30:05,649
el valueOf, este para pasarlo al número

981
01:30:05,649 --> 01:30:09,909
entero o podríamos utilizar el parseInt

982
01:30:09,909 --> 01:30:17,430
de la clase GrouperInteger. Y luego para comprobar

983
01:30:17,430 --> 01:30:21,649
si es par o impar, tenéis una solución

984
01:30:21,649 --> 01:30:23,430
de las posibles puestas en el

985
01:30:23,430 --> 01:30:29,270
aula virtual. Bueno, pues la forma en la que

986
01:30:29,270 --> 01:30:34,430
lo utiliza teníamos con lo que hemos visto en el contenido del tema 2 una

987
01:30:34,430 --> 01:30:40,909
posibilidad que era la instrucción está con dos operadores

988
01:30:40,909 --> 01:30:46,850
entonces esta que tiene la opción que dices algo

989
01:30:46,850 --> 01:30:55,329
es igual a un valor y dice si vale una si vale verdadero una cosa y si no pues

990
01:30:55,329 --> 01:31:02,270
es otra cosa con esta instrucción es un poco liosa y yo creo mucho más clara lo

991
01:31:02,270 --> 01:31:07,090
que vais a ver ahora en el tema 3 que es utilizar una instrucción de condición

992
01:31:07,090 --> 01:31:12,310
que es si if y aquí pondremos algo que se puede

993
01:31:12,310 --> 01:31:18,449
evaluar como verdadero o falso y hacemos en el ámbito del if una serie

994
01:31:18,449 --> 01:31:27,789
de cosas que pondríamos aquí y el else que es si no es cierto lo que hay aquí pues entonces hace

995
01:31:27,789 --> 01:31:33,350
esta otra serie de cosas mirad aunque esto pertenezca al tema 3 vamos a poner aquí si

996
01:31:33,350 --> 01:31:38,369
es cierto lo más cierto en java a la hora de evaluarlo es poner aquí que es cierto ya

997
01:31:38,369 --> 01:31:40,449
directamente. Entonces decimos

998
01:31:40,449 --> 01:31:41,029
si es true

999
01:31:41,029 --> 01:31:44,449
system.auth.println

1000
01:31:45,630 --> 01:31:51,680
escribo

1001
01:31:51,680 --> 01:31:52,180
true

1002
01:31:52,180 --> 01:31:54,680
y si no es true

1003
01:31:54,680 --> 01:31:59,060
escribo false. ¿Esto cómo

1004
01:31:59,060 --> 01:32:00,619
funciona? Pues cuando hará

1005
01:32:00,619 --> 01:32:02,380
todo este código que no tiene

1006
01:32:02,380 --> 01:32:05,100
consecuencias por pantalla ni nada

1007
01:32:05,100 --> 01:32:07,060
y luego dirá si es verdadero

1008
01:32:07,060 --> 01:32:09,420
lo que hay aquí entre paréntesis

1009
01:32:09,420 --> 01:32:11,239
que en este caso lo que evalúa

1010
01:32:11,239 --> 01:32:12,640
es que directamente es verdadero

1011
01:32:12,640 --> 01:32:17,119
hace el código que hay en el ámbito del if, que es

1012
01:32:17,119 --> 01:32:21,140
lo que hay entre esta llave de apertura y cierre. Podríamos tener aquí una serie

1013
01:32:21,140 --> 01:32:25,180
de instrucciones, pero en particular hemos puesto una solo, que sería

1014
01:32:25,180 --> 01:32:28,680
escribo true. Y si esto se evaluase a falso,

1015
01:32:29,939 --> 01:32:33,000
pues entonces, en lugar de ejecutar la serie de instrucciones

1016
01:32:33,000 --> 01:32:36,619
que hay en el if, haría la serie de instrucciones que hay en el else, que sería

1017
01:32:36,619 --> 01:32:40,880
escribo false. Este if true y else

1018
01:32:40,880 --> 01:32:43,520
lo podríamos

1019
01:32:43,520 --> 01:32:45,300
hacer con

1020
01:32:45,300 --> 01:32:46,239
una instrucción

1021
01:32:46,239 --> 01:32:49,300
de la que tiene dos operadores

1022
01:32:49,300 --> 01:32:51,020
esta en la que algo es igual

1023
01:32:51,020 --> 01:32:53,260
que mira una condición, no sé si habéis visto

1024
01:32:53,260 --> 01:32:54,960
la teoría, y si

1025
01:32:54,960 --> 01:32:57,199
es cierta pasa una cosa y si es falsa

1026
01:32:57,199 --> 01:33:01,640
pasa otra, entonces con el true

1027
01:33:01,640 --> 01:33:03,260
yo no sé si alguien

1028
01:33:03,260 --> 01:33:05,760
directamente lo ha hecho así, entre los que habéis entrado a la práctica

1029
01:33:05,760 --> 01:33:07,579
yo creo que nadie, habéis ido

1030
01:33:07,579 --> 01:33:09,220
a este que es el método en el que luego

1031
01:33:09,220 --> 01:33:11,000
programaremos durante todo el curso

1032
01:33:11,000 --> 01:33:14,199
lo que pasa es que esto en verdad todavía no lo habíamos visto en teoría

1033
01:33:14,199 --> 01:33:17,760
por eso yo la solución no la he dado con esta otra alternativa

1034
01:33:17,760 --> 01:33:20,340
entonces si ejecutamos por aquí dice escribo true

1035
01:33:20,340 --> 01:33:23,619
porque esto se ha evaluado como true y si esto fuese false

1036
01:33:23,619 --> 01:33:27,680
escribiría el otro

1037
01:33:27,680 --> 01:33:31,140
normalmente los if y los self no tienen aquí true o false

1038
01:33:31,140 --> 01:33:34,520
sino que tienen una expresión que se evalúa a verdadero o falso

1039
01:33:34,520 --> 01:33:37,319
por ejemplo un valor entero

1040
01:33:37,319 --> 01:33:39,199
la edad de una persona

1041
01:33:39,199 --> 01:33:42,979
imaginaos que estamos aquí chequeando mayor de edad o menor de edad

1042
01:33:42,979 --> 01:33:59,340
Y tenemos aquí una variable int y edad. Aquí llegará con un determinado valor que será consecuencia de la ejecución anterior del código. Entonces si ponemos aquí 15, pues en principio sería menor de edad.

1043
01:33:59,340 --> 01:34:06,659
como esto es lo que queremos que pase cuando sea mayor de edad pues podríamos decir si y edad es

1044
01:34:06,659 --> 01:34:15,960
mayor de 17 años esto se evalúa true porque y edad efectivamente es mayor que 17 en este caso no si

1045
01:34:15,960 --> 01:34:27,640
ponemos aquí de mayor de edad vamos a poner 19 pues si edad es mayor que 17 diría mayor de edad

1046
01:34:27,640 --> 01:34:35,859
y si no pues sería menor pero esto lo que vais a ver en este tema este tipo de instrucciones entonces

1047
01:34:35,859 --> 01:34:43,899
esta ejecución esto se evalúa a verdadero porque de verdad es verdadera esa comparación de mayor

1048
01:34:43,899 --> 01:34:52,090
de edad en cambio si tuviera un 15 aquí como esto se evalúa a falso pues nos mostraría esto

1049
01:34:54,489 --> 01:35:02,689
y la otra cosa que es interesante aunque el programa funcionaba perfectamente sin ello

1050
01:35:02,689 --> 01:35:07,829
pero es bueno hacer también, es que si abrimos flujos de comunicación

1051
01:35:07,829 --> 01:35:14,149
de nuestro programa con el mundo exterior, en este caso teníamos el escáner

1052
01:35:14,149 --> 01:35:28,279
al teclado, System.in, por aquí lo utilizamos convenientemente

1053
01:35:28,279 --> 01:35:33,060
y en un programa en línea general interesa siempre los flujos de datos

1054
01:35:33,060 --> 01:35:36,079
cuando terminas de utilizarlos, pues no dejar pillados recursos.

1055
01:35:36,079 --> 01:35:42,979
entonces aquí sería mejor poner un scan close voy a cerrarlo igual que lo abierto aquí por lo

1056
01:35:42,979 --> 01:35:52,149
cierro aquí después de haber estado utilizándolo aquí que sucedía en el programa que como el

1057
01:35:52,149 --> 01:35:57,829
programa se ejecutaba en el método main hacíamos todo lo que correspondiese y aunque no tuviéramos

1058
01:35:57,829 --> 01:36:03,069
esto como acaba el método main acaba el programa y el hecho de acabar el programa liberaba los

1059
01:36:03,069 --> 01:36:09,329
recursos y al final pasa un poco lo mismo pero nuestros programas no tienen por qué ser así

1060
01:36:09,329 --> 01:36:14,550
de sencillos de empezar y terminar en un método de hecho no lo son normalmente pues tienen mucho

1061
01:36:14,550 --> 01:36:18,989
más código y a veces son programas que tienen que permanecer en el tiempo a lo mejor están

1062
01:36:18,989 --> 01:36:25,710
dando un servicio de 24 horas entonces interesa que cuando dejemos de utilizar un recurso pues

1063
01:36:25,710 --> 01:36:31,050
liberarlo todo lo que no vayamos a utilizar si ya no tenemos que leer más cosas desde el teclado

1064
01:36:31,050 --> 01:36:38,010
pues vamos a cerrar ese recurso y no dejamos pillado hay una conexión al teclado que bueno

1065
01:36:38,010 --> 01:36:41,550
vete tú a saber si en algún momento me puede terminar dando un problema

1066
01:36:41,550 --> 01:36:46,949
y resultarme muy costoso el depurar el código hasta darme cuenta del problema

1067
01:36:46,949 --> 01:36:49,329
en otra zona de código puede ser ese

1068
01:36:49,329 --> 01:36:52,409
entonces esto también era una cosa interesante de hacer

1069
01:36:52,409 --> 01:36:58,210
cerrar los flujos, siempre que usemos un flujo ya no precisemos de su uso

1070
01:36:58,210 --> 01:37:09,710
y nada, hay poco más, yo creo que os voy a contar ya por hoy

1071
01:37:09,710 --> 01:37:11,029
por aquí

1072
01:37:11,029 --> 01:37:14,289
porque no tengo del tema este 2

1073
01:37:14,289 --> 01:37:16,569
no tengo más cosas, la semana que viene empezamos a hablar

1074
01:37:16,569 --> 01:37:18,170
de lo del tema 3

1075
01:37:18,170 --> 01:37:20,770
os abro mañana los contenidos

1076
01:37:20,770 --> 01:37:23,569
y si no tenéis

1077
01:37:23,569 --> 01:37:25,890
alguna pregunta por ahí que hacerme

1078
01:37:25,890 --> 01:37:28,329
pues voy a ir parando la grabación yo creo

1079
01:37:28,329 --> 01:37:29,810
y lo vamos dejando por aquí

1080
01:37:29,810 --> 01:37:33,289
¿alguna cosita por ahí?

1081
01:37:33,970 --> 01:37:34,789
¿qué me queréis comentar?

1082
01:37:42,869 --> 01:37:43,409
¿todo bien?

1083
01:37:47,800 --> 01:37:49,039
pues si os parece

1084
01:37:49,039 --> 01:37:50,640
si no tenéis ninguna pregunta más

1085
01:37:50,640 --> 01:37:53,060
paramos para no adelantaros más cosas

1086
01:37:53,060 --> 01:37:55,399
ya hemos introducido

1087
01:37:55,399 --> 01:37:57,039
un montón de conceptos y hemos repasado

1088
01:37:57,039 --> 01:37:58,899
un montón de cosas, así que si

1089
01:37:58,899 --> 01:38:00,920
reviséis otra vez la clase

1090
01:38:00,920 --> 01:38:02,600
tenéis para entretenernos un poquito

1091
01:38:02,600 --> 01:38:03,720
con ella yo creo

1092
01:38:03,720 --> 01:38:10,430
pues nada, por aquí lo dejamos entonces

1093
01:38:10,430 --> 01:38:10,630
vale

1094
01:38:10,630 --> 01:38:15,140
pues nada

1095
01:38:15,140 --> 01:38:16,579
la grabación

1096
01:38:16,579 --> 01:38:19,760
creo que ahora la voy subiendo

1097
01:38:19,760 --> 01:38:21,840
necesito un tiempo de procesamiento hasta que

1098
01:38:21,840 --> 01:38:23,979
está disponible, o bien esta noche

1099
01:38:23,979 --> 01:38:28,140
Mañana ya os pongo el enlace disponible para que podáis verla de nuevo si queréis.