1
00:00:01,649 --> 00:00:08,550
Y para empezar, como habitualmente, pues preguntaros si tenéis alguna duda por ahí que queráis que comentemos antes de nada.

2
00:00:10,369 --> 00:00:12,210
Relación al módulo.

3
00:00:16,629 --> 00:00:25,929
Si no tenéis nada así en particular, bueno, pues había pensado, lo que vengo haciendo estos años anteriores es el primer día después de cerrar un tema,

4
00:00:26,329 --> 00:00:31,329
pues repasar un poco para cerrar el tema, la tarea, hacerla aquí en conjunto.

5
00:00:31,329 --> 00:00:34,070
de forma, bueno, pues en la tarea

6
00:00:34,070 --> 00:00:36,030
para compartirla con vosotros y que os quede grabada

7
00:00:36,030 --> 00:00:37,329
como lo vamos haciendo poco a poco

8
00:00:37,329 --> 00:00:40,030
y luego pues empezamos

9
00:00:40,030 --> 00:00:42,229
a comentar algunas cosas por ahí del tema 4

10
00:00:42,229 --> 00:00:46,030
¿Os parece? ¿Tenéis alguna cosita

11
00:00:46,030 --> 00:00:46,390
por ahí

12
00:00:46,390 --> 00:00:49,289
que queréis que veamos?

13
00:00:49,729 --> 00:00:52,090
Bueno, pues hacemos este plan

14
00:00:52,090 --> 00:00:57,869
entonces. Bueno, mirad por aquí

15
00:00:57,869 --> 00:00:59,689
vamos a ver

16
00:00:59,689 --> 00:01:01,070
el enunciado de la tarea

17
00:01:01,070 --> 00:01:11,239
por aquí lo tenemos, independientemente de que

18
00:01:11,239 --> 00:01:15,060
la resolvamos ahora, sabéis que la tenemos, he abierto

19
00:01:15,060 --> 00:01:18,959
una solución ahí en el aula virtual y bueno, ya corregida con

20
00:01:18,959 --> 00:01:25,379
comentario la tenéis todos los que me habéis entregado. Me ha llamado la atención

21
00:01:25,379 --> 00:01:29,700
una cosa que os he puesto de comentario a algunos, que no es que esté mal

22
00:01:29,700 --> 00:01:33,840
ni mucho menos, pero habéis utilizado bastante los

23
00:01:33,840 --> 00:01:38,280
bucles con el while true y luego utilizando una instrucción

24
00:01:38,280 --> 00:01:41,799
que hace un break, o sea una rotura del bucle

25
00:01:41,799 --> 00:01:43,040
dentro de

26
00:01:43,040 --> 00:01:46,459
dentro del código

27
00:01:46,459 --> 00:01:47,260
del propio bucle

28
00:01:47,260 --> 00:01:48,879
lo pongo por aquí

29
00:01:48,879 --> 00:01:50,620
en el código

30
00:01:50,620 --> 00:01:55,950
vamos a crear el proyecto

31
00:01:55,950 --> 00:02:10,080
vamos a crear el método public

32
00:02:10,080 --> 00:02:11,419
el método main

33
00:02:11,419 --> 00:02:23,289
mirad en la tarea esta

34
00:02:23,289 --> 00:02:24,289
ahora lo hemos anunciado

35
00:02:24,289 --> 00:02:26,389
tiene que se esté realizando una

36
00:02:26,389 --> 00:02:28,949
acción, ir cogiendo información

37
00:02:28,949 --> 00:02:30,210
las opciones de menú

38
00:02:30,210 --> 00:02:32,629
por teclado hasta que introduzcamos

39
00:02:32,629 --> 00:02:36,650
lo que es salir o fin, entonces hacemos

40
00:02:36,650 --> 00:02:39,629
un bucle hasta que lo introducido sea salir o fin

41
00:02:39,629 --> 00:02:44,629
parece que la lógica a la que nos empuja un poco

42
00:02:44,629 --> 00:02:47,889
el enunciado es a pensar en que en el while

43
00:02:47,889 --> 00:02:52,969
en el do while aquí, que al final es donde metemos la condición

44
00:02:52,969 --> 00:02:56,689
de finalización del bucle, pues ponemos realmente

45
00:02:56,689 --> 00:03:00,409
la que nos dice el enunciado, hasta que lo leído sea fin o

46
00:03:00,409 --> 00:03:04,650
o salir. Imaginaos que tenemos un código

47
00:03:04,650 --> 00:03:08,490
muy grande, que no está todo a la vista, como

48
00:03:08,490 --> 00:03:12,490
este que es así muy sencillo. También es cierto que se sugiere

49
00:03:12,490 --> 00:03:16,129
cuando los códigos son muy grandes se partan en funciones o métodos

50
00:03:16,129 --> 00:03:20,870
que hablaremos de ellos en esta tutoría o en las siguientes.

51
00:03:21,430 --> 00:03:24,009
Pero bueno, imaginaos que por lo que sea nos ha quedado un código aquí muy grande.

52
00:03:24,669 --> 00:03:28,250
Entonces, si tú ves aquí un while, esperas que

53
00:03:28,250 --> 00:03:34,949
es lo que pasa dentro de este wild se ejecute mientras suceda esto no con un wild true que

54
00:03:34,949 --> 00:03:41,750
se ejecute siempre y luego en alguna zona de código por ahí con una instrucción break rompo

55
00:03:41,750 --> 00:03:47,330
la ejecución del bucle está esta o sea java funciona así si dentro de un vuelto encuentras

56
00:03:47,330 --> 00:03:53,330
un dentro una instrucción de control de repetición tú encuentras una instrucción break te va a sacar

57
00:03:53,330 --> 00:03:55,469
del bucle, es cierto, y funciona

58
00:03:55,469 --> 00:03:56,509
y los que lo tenéis así

59
00:03:56,509 --> 00:03:59,330
el programa da los resultados

60
00:03:59,330 --> 00:04:00,009
esperados

61
00:04:00,009 --> 00:04:03,270
pero simplemente por, bueno, pues un poco

62
00:04:03,270 --> 00:04:05,569
por lógica, por facilidad, luego de mantenimiento

63
00:04:05,569 --> 00:04:07,069
por todo un poco

64
00:04:07,069 --> 00:04:09,129
yo creo que cuando está bien definida

65
00:04:09,129 --> 00:04:10,909
la condición que nos saca del bucle

66
00:04:10,909 --> 00:04:13,169
es mejor ponerla aquí, más que poner

67
00:04:13,169 --> 00:04:15,449
un while true y luego una instrucción

68
00:04:15,449 --> 00:04:15,789
break

69
00:04:15,789 --> 00:04:20,279
además, bueno, pues

70
00:04:20,279 --> 00:04:22,500
la tendencia de siempre, aunque

71
00:04:22,500 --> 00:04:24,439
hoy en día, por ejemplo, la inteligencia

72
00:04:24,439 --> 00:04:26,680
artificial da mucho este tipo de soluciones

73
00:04:26,680 --> 00:04:27,160
también

74
00:04:27,160 --> 00:04:30,560
lo que siempre

75
00:04:30,560 --> 00:04:32,579
se ha venido a decir de las instrucciones break

76
00:04:32,579 --> 00:04:34,560
es que se intenten evitar

77
00:04:34,560 --> 00:04:36,019
siempre que sea posible, por ejemplo

78
00:04:36,019 --> 00:04:38,480
en el switch, la instrucción

79
00:04:38,480 --> 00:04:40,220
switch de selección que

80
00:04:40,220 --> 00:04:41,779
estuvimos viendo la semana pasada

81
00:04:41,779 --> 00:04:44,139
en la clásica, donde

82
00:04:44,139 --> 00:04:46,779
se ponen

83
00:04:46,779 --> 00:04:48,600
las condiciones con dos puntos

84
00:04:48,600 --> 00:04:50,860
a partir de cierta

85
00:04:50,860 --> 00:04:52,879
versión del

86
00:04:52,879 --> 00:05:02,769
jdk que ya permite hacerlo con con el símbolo este verdad de flecha excepto en este caso que

87
00:05:02,769 --> 00:05:07,110
no son auto excluyente las opciones sí que se recomienda poner un break porque si es que

88
00:05:07,110 --> 00:05:13,430
quieres que convertir cada una de las de las opciones del switch cada uno de los keys en auto

89
00:05:13,430 --> 00:05:18,089
excluyente pues tienes que meter un break pero luego en líneas generales siempre se ha recomendado

90
00:05:18,089 --> 00:05:25,050
e intentar evitar los break y por qué se intentan evitar evitar los break pues fijaros aquí en una

91
00:05:25,050 --> 00:05:31,949
instrucción while si es muy fácil hacer un mantenimiento y entender bien el código si la

92
00:05:31,949 --> 00:05:36,069
condición por la que nos salimos del whale está aquí definida nos salimos cuando esto luego ya

93
00:05:36,069 --> 00:05:40,370
miraremos a ver qué pasa por aquí en el código que tenemos que hacer que algoritmo implementa

94
00:05:40,370 --> 00:05:46,410
pero este bucle se sale aquí si te pones aquí un while true resulta que aquí puedes empezar a

95
00:05:46,410 --> 00:05:50,389
tener códigos con if, con switch, mucho código diferente

96
00:05:50,389 --> 00:05:54,389
y puedes meter 10 breaks. Y en cada

97
00:05:54,389 --> 00:05:58,290
break puede tener una condición por ahí diferente, no ser exactamente

98
00:05:58,290 --> 00:06:02,029
la misma. Entonces, en una ejecución de programa se saldrá de aquí

99
00:06:02,029 --> 00:06:06,149
porque ha encontrado un break, pero ¿qué break será el que ha encontrado y el que provoca que

100
00:06:06,149 --> 00:06:10,110
se esté marchando? Entonces, este tipo de instrucciones siempre

101
00:06:10,110 --> 00:06:14,009
las desaconsejan dentro de lo posible y bueno, pues yo

102
00:06:14,009 --> 00:06:16,730
un poco en esa línea pues intento evitar hacer

103
00:06:16,730 --> 00:06:19,730
wild true. Igual en algún momento hago alguno

104
00:06:19,730 --> 00:06:22,810
y en la asignatura de programación de servicios

105
00:06:22,810 --> 00:06:24,449
y procesos que hay en segundo

106
00:06:24,449 --> 00:06:28,790
hay ciertos momentos en los que viene muy bien utilizar

107
00:06:28,790 --> 00:06:31,610
el wild true y sí que se utiliza porque

108
00:06:31,610 --> 00:06:35,050
la condición de salirse es un poco ajena

109
00:06:35,050 --> 00:06:37,850
al código que pongamos de aquí sino que realmente

110
00:06:37,850 --> 00:06:40,910
la salida de este bucle en ese contexto

111
00:06:40,910 --> 00:06:43,790
que os comento viene por cosas que pasan en otras

112
00:06:43,790 --> 00:06:48,649
aplicaciones entonces como pasa en otras aplicaciones es bueno pues como no lo

113
00:06:48,649 --> 00:06:51,889
puedo tener tan controlado aquí a lo mejor sí que una vez que sea una

114
00:06:51,889 --> 00:06:56,089
condición de esas en otra aplicación sí que meto aquí un break pero siempre y

115
00:06:56,089 --> 00:06:59,569
cuando sea posible bueno pues mejor evitarlo

116
00:06:59,569 --> 00:07:05,509
y luego otra cosa así en grandes rasgos que os ha pasado a algunos es algo que

117
00:07:05,509 --> 00:07:10,170
hemos comentado ya en otras prácticas que tiene que ver con la lectura con

118
00:07:10,170 --> 00:07:25,300
Scanner. Bueno, recordad aquí la clase Scanner está, como no está en Java Lange, hay que importarla

119
00:07:25,300 --> 00:07:31,339
al estar en Java útil, ya queda integrada en mi proyecto a través de meter la instrucción

120
00:07:31,339 --> 00:07:37,680
importa aquí de esa clase y ya podemos instanciar objetos de esa clase. Entonces, esto lo que nos

121
00:07:37,680 --> 00:07:43,699
permite es, bueno, trabajar de una forma razonablemente cómoda con flujos de datos, entendiendo

122
00:07:43,699 --> 00:07:48,899
flujos de datos, como hemos dicho otras veces, mecanismos con los que conectamos nuestra aplicación

123
00:07:48,899 --> 00:07:52,939
a elementos externos, bien sea fichero, bien sea

124
00:07:52,939 --> 00:07:57,079
un flujo de datos al teclado o si es de salida a la pantalla o sockets

125
00:07:57,079 --> 00:08:00,420
y utilizando SystemIn, justo este flujo de datos

126
00:08:00,420 --> 00:08:03,959
por defecto se establece en todo programa con el teclado

127
00:08:03,959 --> 00:08:08,899
utilizando el flujo de datos SystemIn lo encasulamos para trabajar con un objeto

128
00:08:08,899 --> 00:08:13,100
de la clase Scanner. Los flujos de datos, una cosa

129
00:08:13,100 --> 00:08:16,800
que es aconsejable, bueno muchos lo habéis hecho, es cuando voy a dejar

130
00:08:16,800 --> 00:08:20,339
de usarlos, cerrarlos, para que no me queden en la ejecución del programa

131
00:08:20,339 --> 00:08:24,879
flujos de datos abiertos. Entonces, por ejemplo, a través

132
00:08:24,879 --> 00:08:28,980
de la clase Scanner podemos utilizar el método Close, con lo cual

133
00:08:28,980 --> 00:08:32,139
si hemos establecido aquí una conexión con el teclado

134
00:08:32,139 --> 00:08:36,639
podemos entenderlo como una tubería que está pinchada

135
00:08:36,639 --> 00:08:40,740
en un lado en nuestro programa y en el otro en el teclado, pues aquí ya liberamos

136
00:08:40,740 --> 00:08:44,399
la tubería. ¿Qué pasa en nuestro programa? Pues que

137
00:08:44,399 --> 00:08:48,820
se está ejecutando un main, necesitamos esa conexión al teclado

138
00:08:48,820 --> 00:08:52,759
todo el rato, con lo cual hasta el final no lo podemos cerrar y realmente el único sitio

139
00:08:52,759 --> 00:08:56,500
donde podemos terminar cerrando este flujo de datos es cuando acaba el main

140
00:08:56,500 --> 00:09:00,799
cuando acaba el main acaba el programa en verdad, con lo cual si no

141
00:09:00,799 --> 00:09:04,580
lo cerramos, si no ponemos esta instrucción, el hecho de acabar el programa lo va a cerrar

142
00:09:04,580 --> 00:09:09,039
él, con lo cual no tiene grandes consecuencias ponerlo o no ponerlo

143
00:09:09,039 --> 00:09:13,139
no me va a dejar el ordenador en sí con recursos

144
00:09:13,139 --> 00:09:15,279
hay enganchados por no cerrarlo.

145
00:09:16,600 --> 00:09:16,820
Pero

146
00:09:16,820 --> 00:09:19,179
este programa es así, pero otro programa

147
00:09:19,179 --> 00:09:20,840
podría ser que después de esto, aquí

148
00:09:20,840 --> 00:09:22,259
siguiera haciendo un montón de cosas.

149
00:09:23,139 --> 00:09:24,639
Incluso ser un programa de

150
00:09:24,639 --> 00:09:26,980
trabajar 24-7, que estuviera

151
00:09:26,980 --> 00:09:29,200
siempre arrancado. Entonces, si aquí

152
00:09:29,200 --> 00:09:31,000
he dejado enganchado un

153
00:09:31,000 --> 00:09:32,820
recurso, pues igual no

154
00:09:32,820 --> 00:09:34,460
es interesante, pues ya está.

155
00:09:34,779 --> 00:09:36,399
Cogemos la costumbre de cerrarlo

156
00:09:36,399 --> 00:09:38,840
y listo. ¿El programa no se va a funcionar

157
00:09:38,840 --> 00:09:40,899
aunque no cerremos la tarea que hemos

158
00:09:40,899 --> 00:09:42,899
hecho? Sí. En este caso se va

159
00:09:42,899 --> 00:09:45,799
a liberar, sí, porque termina el programa, pero como

160
00:09:45,799 --> 00:09:50,759
cosa habitual, pues mucho mejor que cuando abramos un flujo

161
00:09:50,759 --> 00:09:54,720
de datos, sea a System.in o a quien sea, terminamos

162
00:09:54,720 --> 00:09:59,340
cerrándolo. Y además de eso, bueno, pues

163
00:09:59,340 --> 00:10:04,539
si nosotros, acordaros que a través de mi scan, pues nos ofrece

164
00:10:04,539 --> 00:10:08,639
un montón de métodos por aquí. Están los

165
00:10:08,639 --> 00:10:12,720
métodos hash, hashness line, hashness by, hashness

166
00:10:12,720 --> 00:10:17,220
lo que sea, que nos indica, devuelve un boolean y nos indica

167
00:10:17,220 --> 00:10:21,139
si hay algo que leer, bueno, tiene más métodos por ahí, pero bueno, están los

168
00:10:21,139 --> 00:10:24,960
has, algo, y luego están los nest, que son los que

169
00:10:24,960 --> 00:10:29,039
hacen la lectura en sí. Entonces, este ejercicio,

170
00:10:29,200 --> 00:10:32,220
como era una calculadora, había momentos en los que nos pedía

171
00:10:32,220 --> 00:10:37,139
cargar valores numéricos o float, entonces tenemos

172
00:10:37,139 --> 00:10:40,960
el nest int o el nest float, bueno, pues

173
00:10:40,960 --> 00:10:43,480
para leer valores que tengan

174
00:10:43,480 --> 00:10:46,840
o nest double para valores que tengan comas

175
00:10:46,840 --> 00:10:48,120
o los que no los tengan.

176
00:10:49,320 --> 00:10:51,519
Estos valores son perfectos para leer esta información.

177
00:10:54,639 --> 00:11:03,039
De hecho, vamos a poner aquí un system.out.println

178
00:11:03,039 --> 00:11:07,529
mete un entero

179
00:11:07,529 --> 00:11:17,220
y valor.

180
00:11:22,269 --> 00:11:24,409
Entonces, bueno, pues imaginaos que tenemos esto

181
00:11:24,409 --> 00:11:27,070
y luego mete un entero

182
00:11:27,070 --> 00:11:32,860
y a continuación tu nombre. Vamos a poner

183
00:11:32,860 --> 00:11:36,799
este supuesto ejercicio. Queremos meter un entero y luego una cadena de caracteres

184
00:11:36,799 --> 00:11:40,700
que sea el nombre. Entonces si nosotros cogemos y hacemos esto, string

185
00:11:40,700 --> 00:11:46,399
ese valor igual a mi scan.

186
00:11:48,399 --> 00:11:52,549
nestLine y la cojo y pongo aquí

187
00:11:52,549 --> 00:11:55,350
system.out.println

188
00:11:55,350 --> 00:12:06,919
el entero ha sido, meto el valor del entero y valor

189
00:12:06,919 --> 00:12:12,279
y luego pongo el nombre

190
00:12:12,279 --> 00:12:19,149
ha sido ese valor

191
00:12:19,149 --> 00:12:25,629
y luego pongo aquí por ejemplo un system.out.println

192
00:12:25,629 --> 00:12:31,080
saliendo del programa

193
00:12:31,080 --> 00:12:34,460
vale, pues aquí estamos esperando

194
00:12:34,460 --> 00:12:39,649
yo creo que si lo pongo aquí

195
00:12:39,649 --> 00:12:43,129
me va a valer igualmente

196
00:12:43,129 --> 00:12:46,850
no, bueno, a ver, aquí lo dejo

197
00:12:46,850 --> 00:12:53,110
Vale, pues aquí se supone que vamos a meter un entero, un 20 y luego después vamos a meter el nombre.

198
00:12:54,269 --> 00:13:03,590
Entonces si ejecutamos esto y ponemos, bueno mete un entero y el nombre, meto el 5, le doy enter, pues fijaros como el programa termina.

199
00:13:05,070 --> 00:13:13,950
¿Qué es lo que ha sucedido? Que NSYNC coge un entero, pero no coge el enter que he utilizado yo cuando he puesto el 5 y el enter.

200
00:13:13,950 --> 00:13:28,389
Entonces, el siguiente Enter lo está cogiendo con el Slime, es decir, aquí en esta instrucción ha cogido 5 y en esta otra instrucción ha cogido el Enter que he pulsado yo para confirmar este 5 por teclado.

201
00:13:29,409 --> 00:13:42,690
Con lo cual, en el S-Valor se ha cargado el Enter, es decir, el Enter nada, o sea, hace como si no escribiera nada un Enter y en I-Valor se ha cargado el 5, que son los datos que efectivamente estos dos System of Println me están mostrando aquí.

202
00:13:42,690 --> 00:13:48,759
leer de esta forma nos puede provocar estos errores. Entonces, ¿cómo es

203
00:13:48,759 --> 00:13:52,799
cómo lo podemos manejar? Pues, sabiendo que la lectura

204
00:13:52,799 --> 00:13:55,980
de valores numéricos nos pueden provocar esta situación,

205
00:13:56,860 --> 00:14:00,559
pues, lo que habéis hecho algunos, que es correcto, es limpiar el buffer.

206
00:14:02,460 --> 00:14:04,220
Limpiar del buffer

207
00:14:04,220 --> 00:14:08,519
de lectura el Enter

208
00:14:08,519 --> 00:14:12,960
a sabiendas de que esta lectura

209
00:14:12,960 --> 00:14:17,940
no me va a leer no va a cargar el ente de mi valor porque solamente va a cargar el valor numérico y

210
00:14:17,940 --> 00:14:30,159
luego pues bueno pues habéis hecho otro next line para lo que es la lectura del del valor del nombre

211
00:14:31,440 --> 00:14:38,740
fijarse después de esta lectura que está limpiando ese ente del entero cogemos y hacemos así 5 enter

212
00:14:38,740 --> 00:14:44,220
fijaros como todavía sigue pidiendo datos porque el 5 se ha cargado aquí este ente del 5 se ha

213
00:14:44,220 --> 00:14:50,000
cargado aquí y ahora se me ha quedado aquí y ahora pongo aquí jose y ya veis ahora ya funcionaría

214
00:14:50,000 --> 00:14:54,720
bien el programa después de esta lectura es decir hacemos una lectura de un slime para quitar de

215
00:14:54,720 --> 00:14:59,080
en medio el enter y en realidad no lo utilizamos para nada lo podríamos hacer sin cargarlo en

216
00:14:59,080 --> 00:15:05,980
ningún sitio quitando así es decir lo leo pero no lo cargo hacia la izquierda en ningún sitio

217
00:15:05,980 --> 00:15:17,610
simplemente limpio el buffer o aquí el 4 si lo tenéis y otra alternativa es hacer la lectura

218
00:15:17,610 --> 00:15:23,950
siempre con slime y haciendo la conversión entonces si yo cogí defino aquí un string ese

219
00:15:23,950 --> 00:15:38,090
info que es la que yo os he comentado que yo hago habitualmente escojo y la información por mucho

220
00:15:38,090 --> 00:15:48,529
que vaya a ser un número la cojo con un slide con lo cual esta información va a el 5 y como

221
00:15:48,529 --> 00:15:54,549
lea hasta que encuentra un nuevo inter también limpia del buffer en el ente entonces lo que se

222
00:15:54,549 --> 00:16:08,750
me carga aquí es el 5 pero está este método next line ya os digo limpia el buffer también ahora

223
00:16:08,750 --> 00:16:14,169
qué pasa que tengo con esta técnica tengo la información en una variable de tipo string y

224
00:16:14,169 --> 00:16:20,350
lo que quiero tenerla es una variable de tipo y valor que podemos hacer pues vamos a buscar

225
00:16:20,350 --> 00:16:24,730
algún método que en este caso los tenemos disponibles en las librerías de java para

226
00:16:24,730 --> 00:16:31,269
convertir un string que tenga en realidad como literal un número a un valor que sea en realidad

227
00:16:31,269 --> 00:16:36,129
numérico para guardar una variable de este tipo lo primero que nos pediría el cuerpo sería poner

228
00:16:36,129 --> 00:16:41,049
un valor aquí punto para decir a ver si me ofrece un método como hacemos siempre con los objetos

229
00:16:41,049 --> 00:16:47,549
pero ya hemos comentado en varias ocasiones que los tipos de datos primitivos no tienen métodos

230
00:16:47,549 --> 00:16:53,669
disponibles tiene la ventaja de no tener que hacer el niño pero no tienen esa estructura de clase que

231
00:16:53,669 --> 00:17:00,350
sí que tienen los tipos referenciados pero como sí que es algo que vamos a necesitar en ocasiones de

232
00:17:00,350 --> 00:17:05,869
hecho ahora mismo no lo está demandando el programa pasar un string a un valor numérico pues lo que

233
00:17:05,869 --> 00:17:11,609
podemos hacer es utilizar las clases Wrapper esta que van de la manita de los tipos de datos

234
00:17:11,609 --> 00:17:17,430
primitivos y lo que hacen es implementar funciones de este tipo. Pues como estamos trabajando con un

235
00:17:17,430 --> 00:17:27,519
valor de tipo entero aquí, pues la clase Wrapper es la integer. Integer punto y al pulsar aquí ya

236
00:17:27,519 --> 00:17:34,539
tenemos el parse int, que lo que recibe es, como fijáis por aquí, nos ofrece la información Eclipse,

237
00:17:34,539 --> 00:17:37,279
recibe como parámetro de entrada un string

238
00:17:37,279 --> 00:17:40,220
que será el número y devuelve un entero

239
00:17:40,220 --> 00:17:43,099
que será el valor numérico del

240
00:17:43,099 --> 00:17:46,079
número en modo literal que tiene el string

241
00:17:46,079 --> 00:17:51,680
que le estamos pasando como parámetro. Efectivamente

242
00:17:51,680 --> 00:17:54,559
Eclipse nos intenta echar una mano y ya dice que

243
00:17:54,559 --> 00:17:57,819
aquí coge el valor de ese valor. Bueno,

244
00:17:58,279 --> 00:17:59,799
en realidad queremos coger el de ese info.

245
00:18:01,420 --> 00:18:03,599
Con lo cual, haciéndolo de esta forma

246
00:18:03,599 --> 00:18:07,240
no tenemos necesidad de hacer

247
00:18:07,240 --> 00:18:13,119
un slide aquí para cargar el para limpiar el buffer porque porque efectivamente ya lo tenemos

248
00:18:13,119 --> 00:18:21,880
limpio y bueno pues nada luego si acaso ya cogeríamos el nombre vamos a poner aquí un

249
00:18:21,880 --> 00:18:37,609
mensajito para que nos resulte más cómodo ahora el nombre y este el nombre pues sí que lo vamos

250
00:18:37,609 --> 00:18:46,119
a cargar utiliza la variable ese valor ese valor por aquí sí que lo utilizamos con un slide que

251
00:18:46,119 --> 00:18:51,519
en este caso no hay que convertir nada porque un nombre como es un literal de carácter es alfa

252
00:18:51,519 --> 00:18:56,259
numérico es por directamente lo cargamos con es line que es lo que nos devuelven es line la

253
00:18:56,259 --> 00:19:06,259
información como literal pues ya damos aquí ejecutar me ponemos el 5 se me ha quedado un

254
00:19:06,259 --> 00:19:16,480
es line por ahí que no sé cuál es ahora mismo bueno se me ha quedado en este mes

255
00:19:16,480 --> 00:19:29,369
vale que no lo había quitado lo quito de aquí hacemos el line para el número y lo pasamos

256
00:19:29,369 --> 00:19:37,490
ahí valor lo medirá esto y ya me llegará el line este entonces estamos aquí ponemos 6 ahora el

257
00:19:37,490 --> 00:19:43,390
nombre jose y también nos funciona ya una precaución hay que tener precaución de no

258
00:19:43,390 --> 00:19:50,230
poner un mes sin un es double uno de estos que cogen números sin limpiar el buffer después con

259
00:19:50,230 --> 00:19:55,329
un slide muchos lo habéis hecho en la tarea algunos no se os ha pasado y os acaba por

260
00:19:55,329 --> 00:20:01,210
ejemplo dos veces la información del menú o bien cogerlo con es line siempre y hacer la

261
00:20:01,210 --> 00:20:10,910
conversión otra otra cosa así que comentaros así en líneas generales y ahora nos ponemos a

262
00:20:10,910 --> 00:20:21,809
resolver la tarea es que si tenemos por aquí un while es que tenemos aquí un while aquí la

263
00:20:21,809 --> 00:20:28,309
condición que sea. Voy a poner true aunque os estoy diciendo que mejor no lo utilicemos pero para que

264
00:20:28,309 --> 00:20:36,049
compile de momento. Luego en el ejercicio no pondremos un while true. Aquí en el ejercicio tenemos una

265
00:20:36,049 --> 00:20:43,250
serie de opciones y en las opciones a lo mejor hay falta definir dos enteros y es la opción de

266
00:20:43,250 --> 00:20:54,329
menú que suma dos enteros entonces tenemos definimos el entero y val 1 y el entero y val 2

267
00:20:54,329 --> 00:21:03,420
imaginaos que este bucle aquí no voy a poner las opciones luego ya en el ejercicio así que las

268
00:21:03,420 --> 00:21:09,299
ponemos imaginaos que lo ejecutamos 100 veces vale pues ya la vez número 100 pondremos la

269
00:21:09,299 --> 00:21:13,779
condición de ruptura del bucle que habremos programado aquí que será diferente del while

270
00:21:13,779 --> 00:21:17,940
true, pues eso habremos pulsado salir para irnos. Pero antes

271
00:21:17,940 --> 00:21:21,339
hemos hecho 100 veces la operación. Entonces,

272
00:21:22,559 --> 00:21:26,019
hablando un poquito de las variables que comentábamos durante este tema,

273
00:21:26,839 --> 00:21:29,799
las variables se definían en un determinado ámbito. Y el ámbito que

274
00:21:29,799 --> 00:21:33,720
tenemos aquí, para estar dos variables, ¿cuál es? Pues en el que

275
00:21:33,720 --> 00:21:37,779
están definidos. Es el ámbito del while. Esta otra variable,

276
00:21:38,319 --> 00:21:41,680
la scanner, está definido en el ámbito, en este caso,

277
00:21:41,680 --> 00:21:45,980
un poquito a nivel superior de donde está definida, pues sería el main.

278
00:21:46,160 --> 00:21:50,460
Esta variable existe en todo momento, mi scan, mientras

279
00:21:50,460 --> 00:21:54,500
estemos ejecutando el método main. Y si tuviésemos aquí una variable

280
00:21:54,500 --> 00:21:58,460
de clase, en este caso de la clase tarea 3,

281
00:21:58,859 --> 00:22:03,119
que fuese int y var, una variable

282
00:22:03,119 --> 00:22:06,680
miembro de la clase var clase, vamos a poner

283
00:22:06,680 --> 00:22:10,740
aquí, es un nombre muy significativo, pero como tampoco

284
00:22:10,740 --> 00:22:13,839
la vamos a utilizar, pues esta estaría definida

285
00:22:13,839 --> 00:22:16,720
al nivel de la clase. Entonces si aparte de tener

286
00:22:16,720 --> 00:22:19,599
un método main aquí, tuviéramos otro, un segundo método

287
00:22:19,599 --> 00:22:28,240
yo que sé, pues si vamos aquí, public

288
00:22:28,240 --> 00:22:31,940
void, el método que llamemos hola por poner

289
00:22:31,940 --> 00:22:39,640
algo. Entonces la variable

290
00:22:39,640 --> 00:22:42,240
y var clase está definido en el ámbito

291
00:22:42,240 --> 00:22:45,160
de la clase, con lo cual podríamos utilizarla tanto dentro del

292
00:22:45,160 --> 00:22:47,559
método main como dentro del método hola.

293
00:22:48,480 --> 00:22:51,019
La variable miScan, como está definida

294
00:22:51,019 --> 00:22:55,079
en el ámbito de la clase main, podemos utilizarla dentro del main, pero no podríamos utilizarla

295
00:22:55,079 --> 00:22:57,920
dentro de la clase hola. Y

296
00:22:57,920 --> 00:23:02,940
estas dos variables están definidas en el ámbito de las llaves que las cierran

297
00:23:02,940 --> 00:23:06,279
de las llaves más cercanas que las están encerrando, es decir, están definidas

298
00:23:06,279 --> 00:23:11,019
en while, con lo cual están disponibles aquí, pero fijaros como si aquí yo

299
00:23:11,019 --> 00:23:17,650
pongo, mirad, aquí no me está compilando ahora porque

300
00:23:17,650 --> 00:23:21,150
con un while true sin ninguna condición break por aquí

301
00:23:21,150 --> 00:23:25,710
este código está muerto, nunca llegaría, entonces se me queja Eclipse

302
00:23:25,710 --> 00:23:30,339
vamos a poner una condición, inum

303
00:23:30,339 --> 00:23:39,640
igual a 4, y vamos a poner que mientras inum

304
00:23:39,640 --> 00:23:44,099
cualquier condición, no vamos a ejecutar el código, mientras inum

305
00:23:44,099 --> 00:23:48,200
sea distinto de 9, por ejemplo, vale, ahora ya esto me compila, como veis

306
00:23:48,200 --> 00:23:52,099
¿por qué? porque ya no es un bucle infinito y el programa entiende que habrá

307
00:23:52,099 --> 00:23:55,839
un momento en el que podría llegar aquí, aunque en realidad no lo iba a hacer

308
00:23:55,839 --> 00:24:15,079
Bueno, lo iba a hacer aquí, por ejemplo, no lo haría nunca, pero ya este nivel no lo mira el compilador. Dice, bueno, inum vale 4, no lo estás cambiando nunca, se va a quedar aquí en un bucle infinito, pero ya no es un while true, el programa quiere pensar que alguna vez terminaría y ya me compila.

309
00:24:15,079 --> 00:24:28,460
Pues si pongo aquí, por ejemplo, ival1 igual a 5, fijaros que en este caso no me compila. ¿Por qué no me compila? Pues porque ival1 está definido en el ámbito del while.

310
00:24:29,160 --> 00:24:40,960
Fuera del ámbito del while, esta variable no existe. Si yo ival1 la definiese aquí, ya me compila. ¿Por qué? Porque ival1 está en el ámbito del main y ya sería una variable disponible

311
00:24:40,960 --> 00:24:50,170
en esta zona de código. Mira, si este programa que ejecutamos

312
00:24:50,170 --> 00:24:54,630
100 veces, ¿cómo tendría su gestión de memoria haciendo

313
00:24:54,630 --> 00:24:58,230
un análisis del programa poquito a poco? Bueno, pues vendría

314
00:24:58,230 --> 00:25:02,049
por aquí, no nos vamos a detener, llegamos al while, entra

315
00:25:02,049 --> 00:25:06,529
a ejecutarse y nada más entrar aquí, necesita dar de alta

316
00:25:06,529 --> 00:25:09,950
una nueva variable. ¿Esta nueva variable qué implicaría?

317
00:25:10,069 --> 00:25:13,950
Pues una nueva variable supone que el programa se va al sistema

318
00:25:13,950 --> 00:25:17,289
operativo y le dice, oye, necesito recursos donde guardar una variable

319
00:25:17,289 --> 00:25:21,630
de tipo entero. En este caso, en el código no hemos puesto el new por ser

320
00:25:21,630 --> 00:25:25,769
un tipo de datos primitivo, pero lógicamente su información se guardará

321
00:25:25,769 --> 00:25:29,630
en algún sitio en la memoria RAM. Y luego llegará aquí y hará lo mismo

322
00:25:29,630 --> 00:25:33,589
para esta otra variable. Dos veces pedirá al sistema operativo

323
00:25:33,589 --> 00:25:36,670
espacio en memoria RAM donde guardar información de un entero.

324
00:25:38,009 --> 00:25:41,470
Llegados aquí, ¿qué es lo que sucede? Pues que estas variables

325
00:25:41,470 --> 00:25:45,730
dejan de existir y ya no están disponibles en el programa.

326
00:25:46,109 --> 00:25:50,089
El recolector de basura por detrás, que es un programa que va liberando

327
00:25:50,089 --> 00:25:54,069
memoria RAM de aquellas variables y objetos que han dejado de utilizarse,

328
00:25:54,170 --> 00:25:57,410
habrá un momento en el que liberará la memoria RAM y la pondrá a disposición

329
00:25:57,410 --> 00:26:01,269
del sistema operativo de nuevo para que sea utilizada bien por nuestro programa

330
00:26:01,269 --> 00:26:04,170
o por otras aplicaciones que puedan estar corriendo en el ordenador.

331
00:26:04,829 --> 00:26:07,269
¿Pero qué pasa en la siguiente iteración de este bucle?

332
00:26:07,809 --> 00:26:10,869
Pues que lo primero que se encuentra es una variable local a este ámbito,

333
00:26:10,869 --> 00:26:26,190
Entonces cogerá y le pedirá al sistema operativo espacio de memoria para reservar, para poder guardar su información. Igualmente de este. Pues coge aquí, llega y de nuevo queda fuera del ámbito de estas dos variables, recolector de basura, limpieza.

334
00:26:26,190 --> 00:26:35,329
Tercera pasada, la misma jugada, sistema operativo, sistema operativo, sistema operativo, recolector de basura, recolector de basura, recolector de basura.

335
00:26:36,589 --> 00:26:45,769
Entonces esta definición de estas variables aquí, incluso aunque no vayamos a utilizarlas por aquí, igual nos podría llegar a interesar definirlas aquí.

336
00:26:45,769 --> 00:27:13,269
Pues tiene su matiz. Es verdad que es un programa que no consume muchos recursos de procesamiento, pero si queremos buscar que nuestro programa sea óptimo en cuanto al tiempo de ejecución, si la definimos aquí, ya tenemos las variables y aunque des aquí 100.000 vueltas o las que sean 100.000 o 1.000.000 o 10.000.000 de vueltas, no estamos pidiendo al sistema operativo un millón de veces que nos haga la reserva de memoria y aquí que el recolector de basura lo libere.

337
00:27:13,269 --> 00:27:21,490
¿Por qué? Porque según se lo encuentra aquí, nos cogerá ese espacio de memoria y luego por aquí cogerá y ya no volverá a utilizarlo.

338
00:27:23,029 --> 00:27:33,990
Bueno, al final son elecciones de compromiso, porque imaginaos que este bucle se ejecuta dos veces, por lo que sea, solo dos veces.

339
00:27:33,990 --> 00:28:02,099
Pues a lo mejor podría llegar a interesar ponerlo aquí para que después de esa segunda vez estas variables no estén ocupando nunca más memoria RAM que ponerlo aquí y si luego el programa aquí tiene mucho que hacer, dejar el espacio de estas dos variables en memoria RAM ocupadas para siempre porque aquí siguen estando disponibles al pertenecer al ámbito del main.

340
00:28:02,099 --> 00:28:13,460
O sea, que no necesariamente siempre, siempre, siempre tiene por qué ser mejor definirlas aquí, pero bueno, pues como todo en esta vida, pues tiene sus ventajas y sus desventajas.

341
00:28:13,880 --> 00:28:23,859
Aquí ganamos en cuanto a rendimiento porque no estamos molestando al sistema operativo continuamente en cada iteración y luego al recolector de basura a la hora de liberarlo.

342
00:28:23,859 --> 00:28:26,960
solamente lo hacemos una vez, pero sí que es cierto

343
00:28:26,960 --> 00:28:29,900
que si esto tiene muy pocas iteraciones o igual

344
00:28:29,900 --> 00:28:33,119
ninguna, imaginaos que la primera vez ya no se cumple

345
00:28:33,119 --> 00:28:36,200
este while, pues sí que hemos dejado aquí bloqueado

346
00:28:36,200 --> 00:28:39,140
espacio de memoria RAM para estar dos variables

347
00:28:39,140 --> 00:28:42,180
todo el tiempo que se esté ejecutando el main por aquí

348
00:28:42,180 --> 00:28:45,240
porque su ámbito de actuación es ahora

349
00:28:45,240 --> 00:28:48,160
estas llaves, cuando ya no

350
00:28:48,160 --> 00:28:50,839
van a ser utilizadas y simplemente son variables

351
00:28:50,839 --> 00:28:52,380
para trabajar dentro del while

352
00:28:52,380 --> 00:28:55,900
bueno, pues que tengáis un poco

353
00:28:55,900 --> 00:28:58,400
en consideración esa diferencia, ¿no?

354
00:28:58,400 --> 00:29:00,819
que podríamos pensar en ella

355
00:29:00,819 --> 00:29:07,779
si no se entienden cosas, me vais avisando, ¿vale?

356
00:29:11,190 --> 00:29:13,109
entonces, mira, vamos a ver el ejercicio entonces

357
00:29:13,109 --> 00:29:16,250
pues bueno, el ejercicio está construido aparte

358
00:29:16,250 --> 00:29:20,089
sí, bueno, alguien me quería hacer una pregunta

359
00:29:20,089 --> 00:29:23,150
por ahí, pues dime, no digo tu nombre para que no quede grabado

360
00:29:23,150 --> 00:29:24,549
en la grabación

361
00:29:24,549 --> 00:29:32,319
ah, vale, bien, nada

362
00:29:32,319 --> 00:29:40,349
ha sido un error por nada perfecto pues ahora pues seguimos entonces bueno el programa entonces

363
00:29:40,349 --> 00:29:47,069
que es que es lo que lo que pretende pues quiere quiere hacer un bucle en principio hasta que

364
00:29:47,069 --> 00:29:52,769
pulsemos esto entonces tendremos una opción que elegir durante el bucle queremos cogiendo por

365
00:29:52,769 --> 00:30:01,130
teclado el programa nos va a mostrar algo así es un menú de este tipo vamos a ir programando

366
00:30:01,130 --> 00:30:04,069
mirad como el menú

367
00:30:04,069 --> 00:30:09,559
la opción que tenemos, si utilizamos un bucle while

368
00:30:09,559 --> 00:30:13,220
pues podemos sacar una primera vez el menú

369
00:30:13,220 --> 00:30:16,140
y luego tener un while, o podríamos hacer un do while

370
00:30:16,140 --> 00:30:19,440
y directamente ponerlo ya la primera vez

371
00:30:19,440 --> 00:30:22,000
que sabemos que tiene una primera ejecución

372
00:30:22,000 --> 00:30:24,880
aquí podemos coger y decir

373
00:30:24,880 --> 00:30:26,140
vamos a escribir el menú

374
00:30:26,140 --> 00:30:32,319
system.out.println

375
00:30:32,319 --> 00:30:38,859
programa matemático

376
00:30:38,859 --> 00:30:51,750
tenemos las secuencias de escape

377
00:30:51,750 --> 00:30:53,250
con el barra T

378
00:30:53,250 --> 00:30:54,950
nos muestra una tabulación

379
00:30:54,950 --> 00:30:57,529
y luego dice pulsa

380
00:30:57,529 --> 00:30:59,049
cualquier

381
00:30:59,049 --> 00:31:02,849
combinación de

382
00:31:02,849 --> 00:31:04,950
salir o

383
00:31:04,950 --> 00:31:06,509
fin para terminar

384
00:31:06,509 --> 00:31:12,980
a ver que nos va diciendo por ahí

385
00:31:12,980 --> 00:31:14,759
lo hacemos rápido esta parte

386
00:31:14,759 --> 00:31:17,079
S para sumar dos números reales

387
00:31:17,079 --> 00:31:18,779
R para restar dos enteros

388
00:31:18,779 --> 00:31:43,849
dos números enteros

389
00:31:43,849 --> 00:31:49,420
M para ver el máximo

390
00:31:49,420 --> 00:33:07,880
de tres números, p para si par o impar, p para indicar si es par o impar, vale, pues nada, entonces luego nos dice aquí, aquí tenemos, no sé qué he hecho aquí, que he dejado de compilarme, vale, he quitado la t, barra t por aquí, opción deseada, dos puntos y este le voy a poner un system out print para que se me quede ahí el cursor y

391
00:33:07,880 --> 00:33:13,200
a poner un barra n aquí para que me incluya una nueva entrada vamos a darle a ver si me muestra

392
00:33:13,200 --> 00:33:20,980
bien el menú bueno más o menos no tiene mala pinta voy a meter aquí otro barra n mirad este

393
00:33:20,980 --> 00:33:26,400
este bloque lo voy a poner aquí una vez y luego dentro del while lo voy a poner una segunda vez

394
00:33:26,400 --> 00:33:33,099
entonces como lo voy a poner dos veces pues vamos a podemos crear una opción aprovechando que ya

395
00:33:33,099 --> 00:33:44,630
estamos en el tema 4 que sea una opción menú entonces para que haga esto se lo puedo poner

396
00:33:44,630 --> 00:33:52,430
aquí y ahora para que me ejecute desde el main la opción menú se la puedo poner aquí puedo hacer

397
00:33:52,430 --> 00:34:03,900
una llamada mirad porque no me compila ahora pues hace esto este tiempo atrás en alguna tutoría os

398
00:34:03,900 --> 00:34:11,900
he hablado de variables y métodos de tipo static cuando algo es static resulta que se puede llamar

399
00:34:11,900 --> 00:34:16,940
sin haber instanciado sin haber definido ningún objeto de esa clase aquí tenemos la clase tarea

400
00:34:16,940 --> 00:34:26,679
que tiene un método por aquí entonces si yo cojo y pongo aquí intento utilizar el método un método

401
00:34:26,679 --> 00:34:36,840
un parámetro y bar clase igual a 3 resulta que este y bar clase no me funciona a pesar de que

402
00:34:36,840 --> 00:34:44,320
sí que es un método un parámetro definido para la clase tarea y está definido en su ámbito porque no

403
00:34:44,320 --> 00:34:51,059
funciona porque el método main es estático y es común a todos los posibles objetos que tenga la

404
00:34:51,059 --> 00:35:06,760
clase tarea. Si yo tuviera aquí un objeto, defino un objeto tarea 3, mi objeto 1 igual a new, tarea 3, constructor y

405
00:35:06,760 --> 00:35:18,820
defino otro, mi objeto 2, resulta que cada uno de estos objetos tendrá una variable de este tipo.

406
00:35:19,599 --> 00:35:22,639
Imaginaos que esto es la clase Persona y esta es la edad.

407
00:35:24,099 --> 00:35:27,280
Pues al instanciar dos objetos estaríamos instanciando dos personas,

408
00:35:27,460 --> 00:35:29,679
estaríamos dando de alta dos personas en nuestro programa

409
00:35:29,679 --> 00:35:32,659
y cada uno de ellos tendría su variable de edad.

410
00:35:33,760 --> 00:35:35,239
Entonces, ¿qué es lo que sucede aquí?

411
00:35:35,559 --> 00:35:41,119
Que en este método que es estático, que es común a todos los objetos de la clase,

412
00:35:41,920 --> 00:35:45,940
resulta que estoy intentando utilizar esta variable y el programa se pregunta

413
00:35:45,940 --> 00:35:49,539
vale, si este método que se puede ejecutar para todos los objetos

414
00:35:49,539 --> 00:35:52,980
no tiene cada objeto de la clase tarea 3 un método main

415
00:35:52,980 --> 00:35:57,739
resulta que se está ejecutando y me dicen que ibarclase

416
00:35:57,739 --> 00:36:02,159
vale 3, será el ibarclase de mi objeto 1, de mi objeto 2

417
00:36:02,159 --> 00:36:05,119
de otro objeto que defina luego después, de cual de ellos

418
00:36:05,119 --> 00:36:09,559
si yo pongo aquí que es de mi objeto 1

419
00:36:09,559 --> 00:36:13,639
ahora ya me compila, ahora ya no hay lugar a dudas

420
00:36:13,639 --> 00:36:23,940
Este ibarClase, que es una variable definida en la clase, queremos poner el valor 3, pero no para el objeto 2, sino para el objeto 1, para ningún otro.

421
00:36:24,920 --> 00:36:34,900
Si no lo pongo aquí, esta variable podría ser para cualquiera de los dos objetos y como hay una ambigüedad ahí, el programa directamente no me lo permite.

422
00:36:39,849 --> 00:36:42,929
Mirad, cuando nosotros ponemos aquí, por ejemplo, el método integer,

423
00:36:43,769 --> 00:36:49,769
ponemos integer punto, resulta que integer es una clase definida en las librerías de Java.

424
00:36:50,510 --> 00:36:54,110
Y lo que vamos a definir aquí, por ejemplo, antes hemos dicho el método parseInt.

425
00:36:54,110 --> 00:37:00,010
El método parseInt lo estamos utilizando, antes lo hemos utilizado,

426
00:37:00,150 --> 00:37:03,750
ahora lo podríamos utilizar de igual forma, lo estamos utilizando

427
00:37:03,750 --> 00:37:08,789
sin definir ningún objeto de la clase integer.

428
00:37:09,150 --> 00:37:11,630
¿Pero por qué me compila y me funciona parseInt?

429
00:37:11,710 --> 00:37:14,309
Porque es un método que está definido de forma estática.

430
00:37:14,889 --> 00:37:18,570
Es común a todos los posibles objetos que tuviéramos de la clase Integer.

431
00:37:21,719 --> 00:37:23,820
Pues igual que pasa esto con los métodos, resulta que,

432
00:37:24,739 --> 00:37:27,360
igual con esto que acabamos de ver, para ir a clase,

433
00:37:27,599 --> 00:37:28,840
es lo que nos está sucediendo aquí.

434
00:37:28,960 --> 00:37:32,340
Por eso nos compila menú ahora mismo cuando lo hemos puesto aquí.

435
00:37:32,340 --> 00:37:35,679
El método menú está definido dentro de la clase,

436
00:37:35,820 --> 00:37:37,920
con lo cual estaría disponible para main,

437
00:37:37,920 --> 00:37:45,179
pero resulta que menú no es un método estático es decir cada objeto nuevo que definamos tendría

438
00:37:45,179 --> 00:37:51,440
su propio método menú entonces si yo pongo aquí que quiero ejecutar desde algo que es estático

439
00:37:51,440 --> 00:37:57,960
que es común a todos los objetos el método menú le vuelve a surgir la misma dura duda y cuando hemos

440
00:37:57,960 --> 00:38:05,400
utilizado antes el para ver el atributo y bar clase me dirá si tú quieres ejecutar menú pero

441
00:38:05,400 --> 00:38:07,539
el menú del objeto 1 o del objeto 2.

442
00:38:08,780 --> 00:38:10,320
¿Cómo podríamos solucionar esto?

443
00:38:10,440 --> 00:38:12,940
Pues si tenemos definido un objeto, pondríamos esto

444
00:38:12,940 --> 00:38:16,219
y ahora ya me compila porque ya no habría lugar a dudas

445
00:38:16,219 --> 00:38:20,880
que el menú, este método disponible dentro de la clase,

446
00:38:21,199 --> 00:38:25,079
el menú, este método, lo queremos ejecutar para el objeto 1,

447
00:38:25,679 --> 00:38:26,860
sería una de las posibilidades,

448
00:38:28,019 --> 00:38:30,079
o si lo queremos mantener así,

449
00:38:30,860 --> 00:38:33,860
tendríamos que definir el método menú también como estático.

450
00:38:33,860 --> 00:38:39,730
static, entonces en este caso ya me compila, desde un sitio que es

451
00:38:39,730 --> 00:38:42,969
común para todos los objetos de la clase tarea 3

452
00:38:42,969 --> 00:38:47,650
ejecuto algo que también es común para todos los objetos de la clase 3

453
00:38:47,650 --> 00:38:51,929
no hay lugar a dudas que el único método menú definido en la clase

454
00:38:51,929 --> 00:38:55,829
es este y como es el método común para todos los objetos no hay ambigüedades

455
00:38:55,829 --> 00:39:04,420
ya cojo y compilo, bueno si no se entiende muy bien esto del static

456
00:39:04,420 --> 00:39:08,380
decirme seguramente en algún otro momento volveremos a hablar

457
00:39:08,380 --> 00:39:15,010
de ello, en cualquier caso. No nos vale decir

458
00:39:15,010 --> 00:39:19,070
a lo loco me pongo a definir todo estático porque parece que compila todo mejor

459
00:39:19,070 --> 00:39:23,429
porque si esto fuese la clase persona y definimos un atributo, con los atributos

460
00:39:23,429 --> 00:39:27,269
siempre se ve un poco más claro, y definimos un atributo y edad

461
00:39:27,269 --> 00:39:31,250
pues la edad tiene que ser distinta para cada

462
00:39:31,250 --> 00:39:34,369
una de las posibles personas, si esto fuese la clase persona

463
00:39:34,369 --> 00:39:39,309
que definamos, entonces si tenemos la persona 1 tendrá una edad, si tenemos la persona

464
00:39:39,309 --> 00:39:43,809
2 tendrá otra edad. Cada una de ellas necesitará su trocito

465
00:39:43,809 --> 00:39:47,090
de memoria RAM donde guardar su propiedad. No nos valdría

466
00:39:47,090 --> 00:39:51,650
un dato común como este de este tipo. Si fuese un programa

467
00:39:51,650 --> 00:39:55,590
para, o sea, que dependiendo del uso que vaya a tener

468
00:39:55,590 --> 00:39:59,369
el parámetro o el método, podrá ser estático o no. Dentro de

469
00:39:59,369 --> 00:40:03,309
una posible clase persona o alumno que tuviésemos

470
00:40:03,309 --> 00:40:06,530
para nuestra clase, pues igual sí que podríamos poner aquí

471
00:40:06,530 --> 00:40:11,050
un parámetro que fuera string que identificase

472
00:40:11,050 --> 00:40:14,730
el grupo o

473
00:40:14,730 --> 00:40:20,840
el ciclo en este caso y este podríamos ponerlo quizás

474
00:40:20,840 --> 00:40:24,480
estático. ¿Por qué? Porque aunque definiésemos 10 alumnos

475
00:40:24,480 --> 00:40:27,079
todos vosotros tendríais

476
00:40:27,079 --> 00:40:38,360
el mismo ciclo que sería DUM.

477
00:40:39,179 --> 00:40:43,280
Este para un ejercicio en el que todo alumno que se diera de alta

478
00:40:43,280 --> 00:40:47,119
fuese de nuestro grupo, podría ser estático, solo tendríamos una zona

479
00:40:47,119 --> 00:40:51,320
común y sería común a todos los

480
00:40:51,320 --> 00:40:55,159
alumnos. En cambio, la edad no lo sería. En un caso nos permitiría

481
00:40:55,159 --> 00:40:59,039
que fuese estático, en otro no. Vamos a definir el menú como

482
00:40:59,039 --> 00:41:03,000
estático y lo llamamos aquí. ¿Por qué lo he pasado

483
00:41:03,000 --> 00:41:06,940
un menú? Porque como lo vamos a utilizar varias veces, así solamente escribo

484
00:41:06,940 --> 00:41:11,280
su código una vez y hago la llamada varias. Imaginaos que luego el menú

485
00:41:11,280 --> 00:41:16,300
aquí cuando he puesto impar me he equivocado y he puesto impaz

486
00:41:16,300 --> 00:41:19,860
en lugar de impar. He hecho copy y pega esto

487
00:41:19,860 --> 00:41:24,239
en dos sitios en este ejercicio pero podría ser en 20. De repente me di

488
00:41:24,239 --> 00:41:28,440
cuenta y tengo que irme a tocar a 20 sitios para actualizar del impaz

489
00:41:28,440 --> 00:41:32,280
al impar si no he utilizado un método. Si lo que hago es llamar

490
00:41:32,280 --> 00:41:36,300
al método con ir aquí y actualizar el impaz

491
00:41:36,300 --> 00:41:40,179
por impar ya he corregido el problema en todas partes donde estoy haciendo

492
00:41:40,179 --> 00:41:43,739
la llamada al método menú para corregir, para

493
00:41:43,739 --> 00:41:46,059
meter nuevas cosas, para lo que hiciera falta.

494
00:41:47,599 --> 00:41:51,400
¿Alguien tenía por ahí alguna pregunta que hacer? ¿Alguna consultita?

495
00:41:58,320 --> 00:42:01,599
Pues sí, por ahí. ¿Me querías comentar algo, alguien?

496
00:42:04,599 --> 00:42:08,440
No sé si estás hablando. Estás silenciado, yo creo. Tienes que desactivar el

497
00:42:08,440 --> 00:42:12,099
altavoz. Sí, sí.

498
00:42:30,530 --> 00:42:39,019
¿Esto? Claro, sí, pues nada, lo cuento.

499
00:42:39,019 --> 00:42:41,800
mira, para que quede grabado

500
00:42:41,800 --> 00:42:43,699
para que quede en la grabación la pregunta

501
00:42:43,699 --> 00:42:45,500
porque solo se escucha mi micrófono

502
00:42:45,500 --> 00:42:46,460
no el vuestro

503
00:42:46,460 --> 00:42:48,920
me preguntan que qué significa esto

504
00:42:48,920 --> 00:42:51,260
bueno, el asterisco no significa nada

505
00:42:51,260 --> 00:42:53,360
es un carácter más que aparece por ahí

506
00:42:53,360 --> 00:42:54,840
pues como pulsa o como una A

507
00:42:54,840 --> 00:42:57,039
forma parte del contenido, lo que pasa es que para

508
00:42:57,039 --> 00:42:59,300
como aparece luego aquí

509
00:42:59,300 --> 00:43:01,760
inmediatamente después, pues está pegado

510
00:43:01,760 --> 00:43:03,179
y la

511
00:43:03,179 --> 00:43:04,780
y qué significa

512
00:43:04,780 --> 00:43:07,739
pues existen unas cuantas secuencias de escape

513
00:43:07,739 --> 00:43:11,039
que tienen ciertos significados. Las dos más típicas

514
00:43:11,039 --> 00:43:13,840
pues es el barra N, que lo que hace es meter una nueva línea

515
00:43:13,840 --> 00:43:17,119
y el barra T, que lo que te hace es tabular.

516
00:43:17,800 --> 00:43:19,840
Y luego, bueno, pues hay algunos otros por ahí que

517
00:43:19,840 --> 00:43:22,659
se pueden utilizar, que hay una tabla por ahí que sin la intentar

518
00:43:22,659 --> 00:43:25,239
localizar. Entonces mira, aquí por ejemplo que pone

519
00:43:25,239 --> 00:43:28,739
pulsa cualquier combinación, fíjate

520
00:43:28,739 --> 00:43:31,820
como antes del asterisco, que es lo primero

521
00:43:31,820 --> 00:43:34,760
que vemos, hay una tabulación aquí. Pues esta tabulación es

522
00:43:34,760 --> 00:43:36,940
este barra T. Si en este

523
00:43:36,940 --> 00:43:38,059
metemos tres barras T

524
00:43:38,059 --> 00:43:40,960
Eclipse me lo duplica

525
00:43:40,960 --> 00:43:42,539
pero bueno, metemos ahí tres barras T

526
00:43:42,539 --> 00:43:44,400
pues mira, coge

527
00:43:44,400 --> 00:43:46,880
y este, el pulsa S que le hemos

528
00:43:46,880 --> 00:43:48,900
metido tres barras C, pues tiene tres tabuladores

529
00:43:48,900 --> 00:43:49,980
uno, dos y tres.

530
00:43:50,860 --> 00:43:52,659
Bueno, pues sirve un poquito para dar cierto

531
00:43:52,659 --> 00:43:54,739
formato. Y si aquí metemos

532
00:43:54,739 --> 00:44:05,900
barra N, dos barra N

533
00:44:05,900 --> 00:44:07,820
pues aparte de una nueva

534
00:44:07,820 --> 00:44:09,940
línea, que es la típica que nos permite

535
00:44:09,940 --> 00:44:11,800
que nos haga a continuación un texto de otro

536
00:44:11,800 --> 00:44:14,739
aparte va a meter dos nuevas líneas

537
00:44:14,739 --> 00:44:16,340
aquí, entonces si le damos aquí a enter

538
00:44:16,340 --> 00:44:18,719
fijaros como después de este reales

539
00:44:18,719 --> 00:44:20,340
hay dos líneas, esas dos barras

540
00:44:20,340 --> 00:44:27,820
que hemos metido, bueno esto es

541
00:44:27,820 --> 00:44:29,880
el uso que tiene y justo

542
00:44:29,880 --> 00:44:31,840
en el bloque

543
00:44:31,840 --> 00:44:33,780
del barra T no es que participe

544
00:44:33,780 --> 00:44:35,719
del asterisco sino

545
00:44:35,719 --> 00:44:37,440
que es el primer carácter que he puesto aquí

546
00:44:37,440 --> 00:44:39,599
como para que nos fueran mostrando

547
00:44:39,599 --> 00:44:41,960
la información, si quitamos este asterisco

548
00:44:41,960 --> 00:44:43,900
pues igualmente funciona el barra T

549
00:44:43,900 --> 00:44:45,480
en el pulsa

550
00:44:45,480 --> 00:44:47,239
pero claro pues no aparece el asterisco

551
00:44:47,239 --> 00:44:49,659
aparece aquí

552
00:44:49,659 --> 00:44:51,860
pero sin el asterisco, eso sí con el tabulador

553
00:44:51,860 --> 00:44:53,539
que implica el barra T

554
00:44:53,539 --> 00:44:55,440
tenemos el barra T, fijaros

555
00:44:55,440 --> 00:44:58,119
un espacio, una tabulación

556
00:44:58,119 --> 00:44:59,900
y un espacio

557
00:44:59,900 --> 00:45:00,659
tendríamos aquí

558
00:45:00,659 --> 00:45:06,360
bueno pues esto sería

559
00:45:06,360 --> 00:45:11,809
si alguien más tiene alguna pregunta por ahí

560
00:45:11,809 --> 00:45:21,050
vale pues nada, pues esto es

561
00:45:21,050 --> 00:45:23,250
bien pues continuamos

562
00:45:23,250 --> 00:45:27,050
aquí nos saca el menú, lo siguiente que podemos

563
00:45:27,050 --> 00:45:30,789
hacer es intentar coger la opción, entonces podemos poner aquí string, esa opción

564
00:45:30,789 --> 00:45:44,550
y después del menú podemos coger la opción con

565
00:45:44,550 --> 00:45:48,650
mi scan.nestline

566
00:45:49,909 --> 00:45:52,710
ya os digo que yo tengo la costumbre de coger todo con nestline

567
00:45:52,710 --> 00:45:55,670
en este caso además es un string, pues bueno, pues con más razón

568
00:45:55,670 --> 00:46:00,590
fijaros aquí como en la opción esta he metido

569
00:46:00,590 --> 00:46:04,650
un barra n para darle este espacio

570
00:46:04,650 --> 00:46:08,829
he metido dos barras T en lugar de uno para que

571
00:46:08,829 --> 00:46:12,230
queden alineadas, vamos a hacer una ejecución

572
00:46:12,230 --> 00:46:21,940
para que queden alineadas con un barra T, a ver que todavía tengo por ahí metidas

573
00:46:21,940 --> 00:46:24,940
cosas, aquí he metido alguno de más

574
00:46:24,940 --> 00:46:34,190
para que queden todas alineadas y este, pues bueno, esté desplazado una tabulación

575
00:46:34,190 --> 00:46:37,869
más, y justo este en lugar de println

576
00:46:37,869 --> 00:46:41,130
he puesto print para que se me quede el cursor aquí a la hora de escribir

577
00:46:41,130 --> 00:46:45,510
que me parece que, bueno, pues como voy a escribir, pues después de la opción deseada

578
00:46:45,510 --> 00:46:49,489
me parece que queda mejor aquí que no, que se me quede el cursor para escribir

579
00:46:49,489 --> 00:46:53,309
la nueva línea, para cargar la opción

580
00:46:53,309 --> 00:46:56,929
pues pongo aquí esa opción, vale, aquí la cargo

581
00:46:56,929 --> 00:47:00,889
y ahora ya entraría en el bucle hasta que

582
00:47:00,889 --> 00:47:05,369
pulse salir, fin o lo que sea, como estábamos

583
00:47:05,369 --> 00:47:09,269
diciendo que cualquier combinación de mayúsculas, minúsculas de salir

584
00:47:09,269 --> 00:47:13,730
o de fin, pues bueno, tenemos

585
00:47:13,730 --> 00:47:19,070
dos opciones. Una, convertir lo que cojamos de la opción

586
00:47:19,070 --> 00:47:22,829
para que sea cualquiera de estas combinaciones a todo mayúsculas

587
00:47:22,829 --> 00:47:26,630
o a todo minúsculas y luego comparar con eso. Si queremos

588
00:47:26,630 --> 00:47:30,590
hacer esa opción, podríamos decir que esa opción, la misma variable, sea

589
00:47:30,590 --> 00:47:34,550
igual a... vamos a ver cómo

590
00:47:34,550 --> 00:47:38,349
podríamos hacerlo esto. Decirle, hacerle un

591
00:47:38,349 --> 00:47:50,090
Tu uppercase, tenemos un método, esa opción, punto, tenemos tu lowercase o tu uppercase.

592
00:47:50,210 --> 00:47:54,429
Esto lo que hace es convertir todos los caracteres que estén en minúsculas en mayúsculas,

593
00:47:54,530 --> 00:47:59,409
con lo cual se nos queda un texto en mayúsculas por completo, con lo cual cualquier combinación,

594
00:47:59,510 --> 00:48:04,750
por ejemplo, de salir poniendo mayúsculas o minúsculas, nos quedaría en salir todo con mayúsculas.

595
00:48:04,750 --> 00:48:07,349
Y lo mismo sucedería si hemos metido un fin.

596
00:48:08,349 --> 00:48:13,190
Entonces podemos poner toUpperCase, por ejemplo, o toLowerCase, vamos a hacerlo.

597
00:48:13,190 --> 00:48:35,750
Y ahora aquí, en el while, queremos permanecer dentro del while mientras sea distinto de cualquiera de estas.

598
00:48:39,659 --> 00:48:48,280
Para que sea, lo primero que podemos hacer aquí es, para poner la condición, fijaros que dentro del while al final nos tiene que devolver algo que sea verdadero o falso.

599
00:48:48,280 --> 00:48:59,860
Entonces, si lo que queremos es, primero podemos decir, vamos a comprobar que salí, que la opción es, si es salir. Entonces, cogemos y decimos, ese opción, punto.

600
00:49:01,639 --> 00:49:14,960
Podemos utilizar el método equals. Este equals lo que hace es hacer una comparación del valor que tiene con otro que reciba como parámetro.

601
00:49:14,960 --> 00:49:20,179
y nos devolverá un boolean, verdadero si es igual y falso si es diferente.

602
00:49:22,409 --> 00:49:28,969
Aquí podríamos utilizar el equals directamente con la información de salir o de fin en minúsculas,

603
00:49:29,070 --> 00:49:34,349
porque aquí le hemos hecho un to lower case, o podríamos habernos ahorrado hacer aquí el to lower case

604
00:49:34,349 --> 00:49:40,630
y haber utilizado el equals ignore case, es decir, compáramelo que también devuelve un boolean

605
00:49:40,630 --> 00:49:47,409
con la información que te estoy pasando, pero la comparación considero que son iguales

606
00:49:47,409 --> 00:49:50,329
aunque uno tenga caracteres en minúsculas y otro en mayúsculas.

607
00:49:50,670 --> 00:49:55,329
Es decir, si utilizamos el Equals Ignore Case, nos podríamos ahorrar esta conversión

608
00:49:55,329 --> 00:49:59,030
que hemos hecho al To Lower Case. O podemos utilizar el Equals y haber hecho

609
00:49:59,030 --> 00:50:06,900
la conversión a To Lower Case aquí. Ya tenemos al To Lower Case, vamos a poner aquí el Equals

610
00:50:06,900 --> 00:50:12,800
y lo que queremos comparar es con salir.

611
00:50:13,260 --> 00:50:19,460
Fijaros que aquí lo pongo en minúsculas porque esa opción tendrá el valor en minúsculas

612
00:50:19,460 --> 00:50:22,360
como consecuencia de haber utilizado aquí el método toLowerCase.

613
00:50:29,889 --> 00:50:36,110
Esto me debería verdadero en caso de que la opción que he metido sea salir.

614
00:50:36,969 --> 00:50:42,690
También me interesa la opción fin porque son las dos que me exige el enunciado.

615
00:50:42,690 --> 00:50:48,909
descojo y hago aquí y pongo aquí un fin

616
00:50:48,909 --> 00:50:52,849
ahora resulta que estoy, que me devuelve

617
00:50:52,849 --> 00:50:57,010
este conjunto verdadero, como es un or, en el caso

618
00:50:57,010 --> 00:51:01,050
de que sea salir o en el caso de que sea fin

619
00:51:01,050 --> 00:51:05,269
cualquiera de las dos me vale y cualquiera de los dos obtendría en su conjunto

620
00:51:05,269 --> 00:51:07,829
si pongo aquí unos paréntesis, un verdadero

621
00:51:07,829 --> 00:51:12,730
y resulta que en verdad lo que pretendo es

622
00:51:12,730 --> 00:51:17,090
no que se me quede en el while cuando sea verdadero, este me está devolviendo

623
00:51:17,090 --> 00:51:21,130
verdadero si he pulsado salir o fin, sino que cuando pase esto

624
00:51:21,130 --> 00:51:24,710
lo que quiero es que se salga, entonces si yo cojo y niego esto aquí

625
00:51:24,710 --> 00:51:29,050
ya tengo la condición que necesito en el while, cuando

626
00:51:29,050 --> 00:51:32,789
lo que tenga esa opción, mientras

627
00:51:32,789 --> 00:51:36,590
mientras, no cuando, mientras lo que tenga esa opción

628
00:51:36,590 --> 00:51:41,309
sea distinto, tanto de salir

629
00:51:41,309 --> 00:51:44,969
como de fin, el geomu también es lo que hay en el while

630
00:51:44,969 --> 00:51:48,349
y cuando sea cualquiera de los dos, este conjunto

631
00:51:48,349 --> 00:51:53,289
me da igual que haya sido fin o salir, será verdadero

632
00:51:53,289 --> 00:51:55,530
con lo cual este conjunto será verdadero

633
00:51:55,530 --> 00:52:01,289
este, y ya este que sigue siendo verdadero, si lo niego

634
00:52:01,289 --> 00:52:08,760
se convierte en falso, bueno, vamos a ir haciéndolo poco a poco y lo comprobamos

635
00:52:08,760 --> 00:52:13,719
entonces aquí cogemos y decimos, vamos a poner un

636
00:52:13,719 --> 00:52:15,059
system.out

637
00:52:15,059 --> 00:52:17,960
println

638
00:52:17,960 --> 00:52:20,280
de esa opción

639
00:52:20,280 --> 00:52:21,679
aunque esto luego lo quitemos

640
00:52:21,679 --> 00:52:28,369
vale, y

641
00:52:28,369 --> 00:52:30,949
fijaros, si aquí hemos cogido

642
00:52:30,949 --> 00:52:32,610
un valor que es diferente de

643
00:52:32,610 --> 00:52:35,130
de salir o de fin, cualquiera

644
00:52:35,130 --> 00:52:35,929
lo que sea

645
00:52:35,929 --> 00:52:38,750
esto va a ser cierto

646
00:52:38,750 --> 00:52:39,869
se me va a meter aquí

647
00:52:39,869 --> 00:52:42,449
va a ejecutar todo lo que tenga el while

648
00:52:42,449 --> 00:52:44,789
va a llegar aquí y se va a venir a comparar de nuevo

649
00:52:44,789 --> 00:52:47,170
si vuelve a ser cierto, volverá a ejecutarlo

650
00:52:48,030 --> 00:52:50,929
Dentro del while, para que no se nos convierta en un bucle infinito,

651
00:52:50,989 --> 00:52:53,070
pero en este caso un bucle infinito indeseado,

652
00:52:53,550 --> 00:52:58,869
tendremos que tener en algún sitio algo que nos haga cambiar esa opción.

653
00:52:58,869 --> 00:53:04,590
Si no, si esa opción en una primera entrada hace que entre en el while,

654
00:53:04,809 --> 00:53:06,250
pues no va a cambiar esto nunca.

655
00:53:06,630 --> 00:53:09,170
¿Y cómo hacemos cambiar esa opción?

656
00:53:09,349 --> 00:53:12,550
Pues la hacemos cambiar solicitándolo desde luego desde teclado.

657
00:53:13,809 --> 00:53:15,929
Entonces es tan fácil como coger estas tres líneas de nuevo,

658
00:53:15,929 --> 00:53:20,170
que nos vuelva a mostrar el menú, leemos del menú

659
00:53:20,170 --> 00:53:24,050
la opción que queremos, la convertimos

660
00:53:24,050 --> 00:53:28,289
a lowercase de nuevo y aquí terminal while vuelve

661
00:53:28,289 --> 00:53:31,150
y vuelve a hacer la comprobación de ese opción

662
00:53:31,150 --> 00:53:38,250
entonces si damos aquí a ejecutar, nos sale este primer menú

663
00:53:38,250 --> 00:53:42,590
este primer menú es este y se me ha quedado

664
00:53:42,590 --> 00:53:47,230
el menú al final, como veis, me escribe opción deseada

665
00:53:47,230 --> 00:53:50,829
con un system of print, ha acabado el menú y se me ha quedado aquí

666
00:53:50,829 --> 00:53:55,289
en esta instrucción parado, en el line, entonces si yo cojo y pongo

667
00:53:55,289 --> 00:54:00,809
hola aquí, fijaros como me muestra aquí un hola, este hola

668
00:54:00,809 --> 00:54:04,869
como no he puesto ni salir ni fin, le ha gustado, me ha mostrado

669
00:54:04,869 --> 00:54:08,269
la opción que había escrito, me ha vuelto a mostrar el menú

670
00:54:08,269 --> 00:54:12,849
opción deseada, del menú habrá

671
00:54:12,849 --> 00:54:16,869
hecho un lowercase, finaliza, se ha venido

672
00:54:16,869 --> 00:54:22,630
a ver perdón, bueno me ha mostrado esto

673
00:54:22,630 --> 00:54:25,250
el menú y se me ha quedado aquí parado

674
00:54:25,250 --> 00:54:30,110
en el next line, entonces si ahora pongo adiós aquí

675
00:54:30,110 --> 00:54:34,650
pues vuelve a pasar lo mismo, me lo muestra, fijaros que después de meter el adiós

676
00:54:34,650 --> 00:54:39,050
se ha actualizado opción, que luego me lo muestra

677
00:54:39,050 --> 00:54:42,690
aquí, pero continúa en la entrada, y si yo en cambio aquí

678
00:54:42,690 --> 00:54:46,849
pongo fin, cualquiera de las combinaciones se me marcha

679
00:54:46,849 --> 00:55:18,219
Si yo pongo aquí un System.out.println después del bucle, fijaros como si yo pongo aquí, pongo la n y la f mayúscula y la i minúscula, lo doy a Enter, en cualquier caso, en esta impresión después de un bucle, fin, mostrando opción, me lo muestra en minúsculas porque he utilizado aquí el tool over case.

680
00:55:18,219 --> 00:55:23,420
vale, pues nada, la condición para entrar y salir ya la tenemos aquí

681
00:55:23,420 --> 00:55:28,559
y tenemos claro que después de lo que hagamos aquí

682
00:55:28,559 --> 00:55:33,840
luego hay que mostrar el menú y volver a cargar la opción que nos interese

683
00:55:33,840 --> 00:55:37,940
fijaros, lo primero que nos pide por aquí como opciones es

684
00:55:37,940 --> 00:55:41,400
sumar dos números reales

685
00:55:41,400 --> 00:55:48,340
podríamos definir aquí, por aquí en algún sitio esos dos números reales como variables

686
00:55:48,340 --> 00:55:51,440
o lo podemos definir aquí, por lo que os decía

687
00:55:51,440 --> 00:56:02,860
Que cada vuelta del while, o al menos cada vuelta en la que definamos sumar dos reales, no esté molestando al sistema operativo para coger espacio de memoria y liberarlo.

688
00:56:02,860 --> 00:56:38,860
Entonces una opción que podríamos hacer aquí es definir un double de valor 1, voy a inicializar a 0 y aquí tenemos una estructura de control de repetición con el while y ahora lo que vamos a hacer aquí va a ser utilizar una estructura de control de selección.

689
00:56:38,860 --> 00:57:00,860
Entonces, por ejemplo, podríamos poner if, sí, o podríamos hacerlo con un switch, a quien más os guste. Entonces podríamos decir que si la opción es igual, acordaros que la opción la tenemos en minúscula, si la opción es igual a S, resulta que es cuando queremos sumar.

690
00:57:00,860 --> 00:57:12,139
Como lo he hecho un tool over case, pondré aquí una S y aquí pongo estamos sumando dos números reales.

691
00:57:18,380 --> 00:57:22,820
System.println para ir pidiendo, vamos a pedir los dos datos, println.

692
00:57:33,880 --> 00:57:35,840
Fijaros, podríamos poner aquí un barra n aquí.

693
00:57:37,980 --> 00:57:40,480
Esto lo podemos tabular, si queréis, barra t.

694
00:57:41,539 --> 00:57:47,099
En lugar de meter otro system.println, podríamos meter aquí un barra n y luego dos tabuladores, por ejemplo.

695
00:57:47,099 --> 00:57:55,190
y decir, dime, aunque no me gusta mucho esto, ahora lo voy a cambiar,

696
00:57:55,309 --> 00:57:57,909
pero lo voy a poner ya que lo estoy diciendo, el primer número.

697
00:58:03,380 --> 00:58:17,679
Entonces si yo le doy aquí, digo sumar, y dice sumando dos números reales,

698
00:58:17,679 --> 00:58:21,920
dime el primer número, fijaros como este dime el primer número está en una línea

699
00:58:21,920 --> 00:58:26,460
diferente del sumando dos números reales, esto es consecuencia de que hemos puesto

700
00:58:26,460 --> 00:58:31,179
aquí este barra n y está más tabulado que el sumando dos números reales

701
00:58:31,179 --> 00:58:35,199
porque le hemos metido dos tabulaciones en lugar de una

702
00:58:35,199 --> 00:58:38,800
que le hemos puesto al tabulando. Como hemos puesto aquí un println

703
00:58:38,800 --> 00:58:43,239
al final de este número el cursor se me ha quedado en una nueva línea.

704
00:58:43,820 --> 00:58:46,920
Entonces lo voy a quitar ahora, pero bueno, quería que vierais como dentro

705
00:58:46,920 --> 00:58:51,019
de un solo system of println, bueno, podemos meter varias

706
00:58:51,019 --> 00:58:54,739
líneas utilizando estas secuencias de escape de las que hablábamos antes.

707
00:58:59,110 --> 00:59:01,289
Vamos a ponerlo como un system of println cada uno.

708
00:59:01,289 --> 00:59:04,190
aquí sumando dos números reales

709
00:59:04,190 --> 00:59:06,230
podemos hacer que aquí quede

710
00:59:06,230 --> 00:59:08,010
un poquito más bonito haciendo así

711
00:59:08,010 --> 00:59:11,960
después de la opción deseada

712
00:59:11,960 --> 00:59:13,460
vamos a meter otra línea más aquí

713
00:59:13,460 --> 00:59:15,860
para que se separe ahí un poquito

714
00:59:15,860 --> 00:59:18,699
aquí vamos a poner

715
00:59:18,699 --> 00:59:20,380
print

716
00:59:20,380 --> 00:59:23,780
y vamos a meterle dos tabuladores

717
00:59:23,780 --> 00:59:25,579
sumando dos números

718
00:59:25,579 --> 00:59:28,079
ya no quiero sumando, aquí vamos a decir el dime

719
00:59:28,079 --> 00:59:30,920
dime el primer número

720
00:59:30,920 --> 00:59:32,980
y ese primer número

721
00:59:32,980 --> 00:59:37,300
lo vamos a cargar en esta variable. ¿Cómo vamos a cargarlo? Pues lo vamos a cargar

722
00:59:37,300 --> 00:59:42,760
con, vamos a definir aquí, podría

723
00:59:42,760 --> 00:59:46,659
definir aquí una variable string auxiliar para hacer un S line

724
00:59:46,659 --> 00:59:50,679
y luego hacer el parse double, pero en lugar de hacerlo aquí, que cada

725
00:59:50,679 --> 00:59:54,679
vuelta me va a pedir al sistema operativo

726
00:59:54,679 --> 00:59:57,840
espacio para ella, pues voy a definir aquí un S aus.

727
00:59:59,559 --> 01:00:05,869
Una variable de tipo S aus. Bueno, en particular

728
01:00:05,869 --> 01:00:10,409
los stream ya os contaré son un poco tramposos porque éste sí que molesta el sistema operativo

729
01:00:10,409 --> 01:00:18,880
cada vez para pedir una reserva de memoria pero bueno los cojo y hago que me es campo

730
01:00:23,190 --> 01:00:32,639
camp punto a un net line y ahora cojo y en esta variable de bar 1

731
01:00:32,639 --> 01:00:37,420
hago, quiero convertir

732
01:00:37,420 --> 01:00:41,360
un literal que tiene un número en

733
01:00:41,360 --> 01:00:46,099
una variable numérica. Acordaros que

734
01:00:46,099 --> 01:00:49,400
este es primitivo, con lo cual no dispone de métodos, pero

735
01:00:49,400 --> 01:00:54,000
al ser un tipo de dato primitivo, en este caso de tipo double, pues

736
01:00:54,000 --> 01:00:57,980
tiene una clase wrapper, que se llama como él. Entonces hacemos un parse

737
01:00:57,980 --> 01:01:02,099
double y de esta forma hemos dejado limpio

738
01:01:02,099 --> 01:01:09,230
el buffer de la jugada esta del enter que os comentaba antes y ahora vamos a pedir el segundo

739
01:01:09,230 --> 01:01:23,840
número hacemos next line volvemos a utilizar la misma variable ya tenemos ahí los dos números

740
01:01:23,840 --> 01:01:34,139
entonces aquí podemos poner un system.out.println es decir la suma de los dos números de los números

741
01:01:34,139 --> 01:02:23,400
podríamos hacerlo así, vamos a hacerlo así para que quede un poquito más claro vamos a hacer la

742
01:02:23,400 --> 01:02:29,760
operación numérica antes de imprimirlo hay y así no metemos tantas cosas dentro

743
01:02:29,760 --> 01:03:04,119
del println a ver me falta por aquí es ahí está y aquí me falta un más entonces

744
01:03:04,119 --> 01:03:09,820
si ejecutamos por aquí vamos a ver qué pinta va teniendo esto hicimos sumar

745
01:03:09,820 --> 01:03:15,139
dime el primer número vale es con el punto nunca me acuerdo

746
01:03:15,139 --> 01:03:17,619
para coger el real, sumar

747
01:03:17,619 --> 01:03:21,159
5.5 y el segundo número

748
01:03:21,159 --> 01:03:24,300
voy a poner 2.2, con lo cual me dice

749
01:03:24,300 --> 01:03:26,940
la suma de los dos números es, bueno pues ahí me saca

750
01:03:26,940 --> 01:03:30,000
el resultado y me vuelve a mostrar

751
01:03:30,000 --> 01:03:32,480
una vez que he hecho esta ejecución con el if

752
01:03:32,480 --> 01:03:35,940
me vuelve a mostrar el menú y se queda esperando

753
01:03:35,940 --> 01:03:39,119
a que recoja la opción de menú

754
01:03:39,119 --> 01:03:41,460
que queremos, vamos a poner salir

755
01:03:41,460 --> 01:03:49,039
y después de bucle salir se me marcha para que nos quede más bonito vamos a tabular esto también

756
01:03:49,039 --> 01:04:04,050
y vamos con la segunda opción si no es este ya os digo esto lo podemos hacer con un switch también

757
01:04:04,050 --> 01:04:11,269
perfectamente la segunda de las alternativas que nos pide es la resta de dos números enteros pues

758
01:04:11,269 --> 01:04:32,880
igual que hemos hecho esto aquí pues podríamos coger y valor 1 y vamos a utilizar este código

759
01:04:32,880 --> 01:04:36,860
la resta y así nos ahorramos escribir

760
01:04:36,860 --> 01:04:40,500
muchas cosas. Lo adaptamos. Decimos en el shift

761
01:04:40,500 --> 01:04:44,420
si en lugar de sumar lo que queremos es restar dos reales

762
01:04:44,420 --> 01:04:48,480
en la R, pues entonces la condición que hay que cumplir es R

763
01:04:48,480 --> 01:04:52,900
estamos restando dos enteros.

764
01:04:58,869 --> 01:05:00,989
Restando dos enteros.

765
01:05:04,300 --> 01:05:07,760
Dime el primer número. Bueno, lo cogemos por aquí.

766
01:05:07,760 --> 01:05:12,159
ahora el primer número lo vamos a guardar en la variable y valor 1

767
01:05:12,159 --> 01:05:19,559
y como lo que queremos es convertir un string a un entero

768
01:05:19,559 --> 01:05:22,519
pues ya no le gustan los tipos, dice esto no me gusta, pero

769
01:05:22,519 --> 01:05:27,059
en lugar de utilizar el método wrapper de la clase double

770
01:05:27,059 --> 01:05:30,860
pues utilizamos el método wrapper de la clase integer

771
01:05:30,860 --> 01:05:34,599
y lo tenemos, y para el segundo de los valores

772
01:05:34,599 --> 01:05:42,760
hacemos lo mismo aquí, 2 y aquí ponemos

773
01:05:42,760 --> 01:05:57,510
y result, será igual a i valor 1, en este caso estamos restando, menos el valor 2.

774
01:06:01,500 --> 01:06:11,760
La resta de los números i valor 1, i valor 2 es i result.

775
01:06:18,760 --> 01:06:24,679
Si os surgen dudas me vais diciendo, pues pulso por aquí, voy a decir que ahora que restamos,

776
01:06:24,679 --> 01:06:28,880
dime el primer número, voy a decir que quiero restar 3 menos 6

777
01:06:28,880 --> 01:06:32,920
y nos dice que el resultado es menos 3, bueno me ha puesto 6 menos 6

778
01:06:32,920 --> 01:06:42,300
porque he puesto y valor 2 las dos veces aquí, ahí, no

779
01:06:42,300 --> 01:06:50,179
control c, ahí está, pues ese sería, ejecuto de nuevo

780
01:06:50,179 --> 01:06:54,159
digo que quiero restar, digo que quiero restar

781
01:06:54,159 --> 01:06:57,860
3 menos 8 y dice que 3 menos 8 es menor 5

782
01:06:57,860 --> 01:07:04,059
después de la opción del else, que ha sido con la opción r

783
01:07:04,059 --> 01:07:06,599
he puesto aquí R minúscula, si la pongo mayúscula

784
01:07:06,599 --> 01:07:08,699
hubiera dado igual por el tool over case

785
01:07:08,699 --> 01:07:09,940
que hubiéramos puesto por aquí

786
01:07:09,940 --> 01:07:14,739
y aquí

787
01:07:14,739 --> 01:07:16,159
para las siguientes opciones

788
01:07:16,159 --> 01:07:18,900
pues ahora si le digo

789
01:07:18,900 --> 01:07:19,619
sumar

790
01:07:19,619 --> 01:07:22,960
sumando dos reales, dime el primer número

791
01:07:22,960 --> 01:07:25,000
real, pues pongo 6.3

792
01:07:26,480 --> 01:07:26,960
y

793
01:07:26,960 --> 01:07:28,480
0.4

794
01:07:28,480 --> 01:07:31,239
pues 6.7

795
01:07:31,239 --> 01:07:32,719
y si damos a fin

796
01:07:32,719 --> 01:07:34,699
pues nada, se nos va

797
01:07:34,699 --> 01:07:39,079
el código que tenemos hasta ahora funciona razonablemente bien

798
01:07:39,079 --> 01:07:41,059
vamos a la siguiente opción

799
01:07:41,059 --> 01:07:44,260
voy a hacer copy y pega por aquí

800
01:07:44,260 --> 01:07:50,739
la siguiente opción es el máximo de tres números

801
01:07:50,739 --> 01:07:53,960
y nos pide una M

802
01:07:53,960 --> 01:08:01,730
pues ponemos aquí máximo de tres números

803
01:08:01,730 --> 01:08:06,360
como vamos a coger tres números vamos a definir

804
01:08:06,360 --> 01:08:08,420
no sé si dice tres números enteros

805
01:08:08,420 --> 01:08:12,340
es un poco igual, es solo definir un tipo de dato o otro

806
01:08:12,340 --> 01:08:15,599
tres enteros, se ha apuntado yo aquí, vamos a definir otro

807
01:08:15,599 --> 01:08:31,390
dato entero, máximo, vamos a poner aquí

808
01:08:31,390 --> 01:08:38,210
tres números enteros, dime el primer número, dime el segundo, vamos a coger el tercero

809
01:08:38,210 --> 01:08:52,250
el tercer número, la misma jugada, pero ahora

810
01:08:52,250 --> 01:08:58,819
aquí lo guardamos en el tres, mirad, una posibilidad para

811
01:08:58,819 --> 01:09:04,840
una posibilidad que tenemos para calcular el máximo, bueno, pues

812
01:09:04,840 --> 01:09:09,279
hay diferentes opciones, mirad, tenemos, si no queremos

813
01:09:09,279 --> 01:09:13,199
estar comparando con mayores y menores, por ejemplo

814
01:09:13,199 --> 01:09:22,420
la clase, existe igual que tenemos la clase

815
01:09:22,420 --> 01:09:26,060
double, tenemos la integer

816
01:09:26,060 --> 01:09:30,600
que son clases que tienen métodos estáticos definidos en la librería

817
01:09:30,600 --> 01:09:34,159
de Java, pues otra de las librerías de Java que hay disponibles es la clase mat

818
01:09:34,159 --> 01:09:38,479
fijaros que hemos puesto aquí mat y directamente me ha funcionado sin importar nada

819
01:09:38,479 --> 01:09:42,460
sin hacer ningún import, no importar del verbo

820
01:09:42,460 --> 01:09:49,220
importar sino de importar sin hacer un import esto es porque más estará definido en la librería

821
01:09:49,220 --> 01:09:56,399
java lang que se importa directamente en todos los proyectos entonces la clase está más lo que

822
01:09:56,399 --> 01:10:01,319
tiene son pues muchas funciones matemáticas fijaros por aquí tenemos valor absoluto muy

823
01:10:01,319 --> 01:10:08,420
útil cuando queramos hacer cosas operaciones matemáticas fijaros a ver si no el seno por

824
01:10:08,420 --> 01:10:15,319
ejemplo es una de las opciones que tiene es más fijaros tiene la opción más para comparar dos

825
01:10:15,319 --> 01:10:21,939
para devolver el valor máximo que hay entre dos entre dos valores que metamos por aquí para dos

826
01:10:21,939 --> 01:10:29,039
double para dos flores parados enteros está el min bueno pues hay un montón de opciones si no

827
01:10:29,039 --> 01:10:35,739
queremos acudir a la clase más en este caso una forma la forma que me parece más rápida y más

828
01:10:35,739 --> 01:10:39,779
sencilla, es considerar uno de ellos el máximo de partida.

829
01:10:40,020 --> 01:10:43,899
Es decir, mira, antes de hacer más comparaciones, digo que el valor

830
01:10:43,899 --> 01:10:47,720
1 es el máximo de ellos, con lo cual entiendo aquí

831
01:10:47,720 --> 01:10:51,600
en el irresult, aprovechando que tengo esta variable, voy a guardar el máximo. Entonces digo

832
01:10:51,600 --> 01:10:55,659
que irresult es igual al primero.

833
01:10:55,659 --> 01:10:59,359
Estoy haciendo la suposición de que este ya es el máximo. Ya digo que en irresult

834
01:10:59,359 --> 01:11:05,789
estamos guardando el máximo. Y ahora digo, si el segundo

835
01:11:05,789 --> 01:11:07,829
valor resulta

836
01:11:07,829 --> 01:11:08,449
que es mayor

837
01:11:08,449 --> 01:11:11,729
que lo que tengo ya como máximo

838
01:11:11,729 --> 01:11:20,890
no me hace el enter

839
01:11:20,890 --> 01:11:21,789
el teclado ahora

840
01:11:21,789 --> 01:11:24,989
pues resulta que si el nuevo

841
01:11:24,989 --> 01:11:26,510
valor es mayor que este

842
01:11:26,510 --> 01:11:28,670
pues resulta que desbanca al que tengo

843
01:11:28,670 --> 01:11:30,250
considerado como máximo hasta ahora

844
01:11:30,250 --> 01:11:32,569
pues cogido aquí result sea igual

845
01:11:32,569 --> 01:11:34,409
hay valor 2

846
01:11:34,409 --> 01:11:38,939
y aquí bueno pues podría

847
01:11:38,939 --> 01:11:42,020
hacer otra comparación así directa

848
01:11:42,020 --> 01:11:44,039
de esto diciendo que si el valor 3

849
01:11:44,039 --> 01:11:49,699
es mayor, pues desbanca el 3 al máximo que lleva acumulado hasta ahora

850
01:11:49,699 --> 01:11:53,819
con lo cual el máximo pasa a ser el valor 3, con lo cual aquí en irresult

851
01:11:53,819 --> 01:11:58,960
ya tengo el valor máximo de los 3. Si tuviéramos

852
01:11:58,960 --> 01:12:03,159
un array de valores enteros, pues podríamos recurrer todo

853
01:12:03,159 --> 01:12:07,100
el array y hacer en un bucle toda esta misma

854
01:12:07,100 --> 01:12:11,340
validación que hemos hecho de los dos valores, del segundo y el tercero, para el resto

855
01:12:11,340 --> 01:12:15,340
de valores. En este caso no tenemos un array, pues así lo podemos hacer.

856
01:12:15,359 --> 01:13:05,430
Entonces aquí, para sacar el resultado, diríamos el máximo de los números y valor 1, ponemos aquí una coma, más y valor 3, nos dice el máximo de los números, el 1, el 2 y el 3, es el result que hemos hecho aquí, nos hemos buscado aquí las mañas para poner un algoritmo

857
01:13:05,430 --> 01:13:08,750
que nos termine guardando ni resuelve el valor máximo de los tres.

858
01:13:11,119 --> 01:13:19,189
Entonces damos por aquí a ejecutar, máximo, pues decimos, dime un número,

859
01:13:19,369 --> 01:13:23,470
decimos aquí un cinco, el segundo número un ocho,

860
01:13:23,710 --> 01:13:26,630
y el tercer número un dos, y nos dice que es el ocho.

861
01:13:26,710 --> 01:13:28,970
Vamos a hacer otra prueba con el máximo, poniéndolo el primero,

862
01:13:28,970 --> 01:13:34,270
para ver que nos funciona, seis, dos y tres, nos dice el seis,

863
01:13:35,369 --> 01:13:37,909
vamos a hacer un máximo poniéndolo el tercero, el mayor de todos,

864
01:13:37,909 --> 01:13:49,739
5, 6, 7, vale pues en los tres casos nos funciona y ponemos aquí salir y nos queda una última opción

865
01:13:49,739 --> 01:14:06,479
que es la opción de mirar a ver si es par o impar, vamos a copiar esta de restar por ejemplo, ponemos

866
01:14:06,479 --> 01:14:18,119
aquí una p, ponemos el indicador que ponemos para hacer este tipo de operación, indicar si es par o

867
01:14:18,119 --> 01:15:01,619
impar, comprobar si un número es par o impar, aquí solo necesitamos un número, indica el número, decimos, lo podemos guardar en, he quitado un parse int, bueno me preguntan que si lo voy a subir este programa en algún sitio,

868
01:15:01,619 --> 01:15:17,640
Yo creo que, no creo que sea muy diferente de la solución que os he dado en, a ver, mira aquí en el aula, esta solución a las tareas que vamos entregando, os doy una solución.

869
01:15:17,640 --> 01:15:33,939
Entonces, mira, voy a pulsar por aquí y bueno, la clase se llama programa matemático, pero en líneas generales, fijaros, aquí está haciendo el while, aquí en lugar de tool over case habíamos trabajado con el tool per case, pero bueno, fijaros que vamos haciendo más o menos lo mismo.

870
01:15:33,939 --> 01:15:36,779
Entonces este programa sí que lo tenéis disponible

871
01:15:36,779 --> 01:15:38,000
Aquí está cerrando el close

872
01:15:38,000 --> 01:15:39,560
Aquí repite esto

873
01:15:39,560 --> 01:15:41,159
Lo único que sí que es verdad es que fijaros

874
01:15:41,159 --> 01:15:42,779
Que aquí en lugar de un método

875
01:15:42,779 --> 01:15:45,220
Menú al que hemos llamado aquí

876
01:15:45,220 --> 01:15:46,640
Y al que hemos llamado aquí

877
01:15:46,640 --> 01:15:47,779
Pues lo he escrito dos veces

878
01:15:47,779 --> 01:15:49,119
Pero en líneas generales

879
01:15:49,119 --> 01:15:51,180
Prácticamente el mismo programa

880
01:15:51,180 --> 01:15:54,300
Si queréis alguna variante

881
01:15:54,300 --> 01:15:56,479
Pues viendo el vídeo

882
01:15:56,479 --> 01:15:59,420
Pues hacer la variante que os parezca oportuno

883
01:15:59,420 --> 01:16:01,800
Y si queréis

884
01:16:01,800 --> 01:16:02,140
Yo qué sé

885
01:16:02,140 --> 01:16:03,319
Si queréis que lo suba

886
01:16:03,319 --> 01:16:11,180
pues nada pues luego lo me lo ponéis en los foros si nos parece bien resuelto o tenéis algunas dudas

887
01:16:11,180 --> 01:16:18,500
y lo recupero aquí de la máquina virtual y os lo subo no tengo problema pero en principio echar un

888
01:16:18,500 --> 01:16:30,970
ojo a ver si os resulta suficiente con eso bueno pues entonces tenemos por aquí el DS el a ver si

889
01:16:30,970 --> 01:16:36,989
es par o impar de aquí ya tenemos cogido el número hacemos el parse in con lo cual lo tenemos aquí

890
01:16:36,989 --> 01:16:43,770
de forma numérica y en algún momento creo que hemos comentado que para ver si un número es par

891
01:16:43,770 --> 01:16:50,189
o impar lo mejor de las maneras es utilizar el resto de la división entonces si el resto de a

892
01:16:50,189 --> 01:16:55,470
la hora de dividir nos devuelve cero pues quiere decir que el número es par cualquier número dividido

893
01:16:55,470 --> 01:17:01,050
entre dos su resto el cero si es par su resto el cero cualquier número dividido entre dos si su

894
01:17:01,050 --> 01:17:06,550
resto es impar, es un 1, es un 1, es impar. Entonces podemos hacer ahí esa

895
01:17:06,550 --> 01:17:14,869
comprobación. Entonces decimos if, si el valor, si pusiéramos esto, estaríamos

896
01:17:14,869 --> 01:17:20,130
haciendo la división. Si tenemos un 5, nos devolvería, nos devolvería lógicamente

897
01:17:20,130 --> 01:17:27,149
un 2, si el valor fuera un 5. Pero si utilizamos el operador tanto por ciento,

898
01:17:27,149 --> 01:17:34,289
este lo que nos devuelve es el resto de la división ahora mismo nos compila porque esto

899
01:17:34,289 --> 01:17:38,729
no está devolviendo un verdadero falso no está devolviendo un valor numérico 0 o 1 entonces

900
01:17:38,729 --> 01:17:44,189
dentro de una estructura de control de selección o de condición lo que tiene que ir entre los

901
01:17:44,189 --> 01:17:49,590
paréntesis tiene que ser resoluble se tiene que poder resolver como un verdadero falso entonces

902
01:17:49,590 --> 01:17:57,029
para que pase lo que queremos lo que le decimos que si esto es igual a 0 si el resto de la

903
01:17:57,029 --> 01:18:01,029
división es igual a cero. Esto no funcionaría ya, pero si ponemos

904
01:18:01,029 --> 01:18:04,109
aquí unos paréntesis ya nos queda ya más súper claro el orden

905
01:18:04,109 --> 01:18:09,010
de evaluar la condición. Entonces aquí estamos

906
01:18:09,010 --> 01:18:18,149
hablando de que es el número es par. Else

907
01:18:18,149 --> 01:18:22,430
que vendría a ser comparar, es hacer esta misma comparación, pero a uno

908
01:18:22,430 --> 01:18:26,310
como solo tenemos dos opciones, vamos a utilizar el else directamente, pues sería

909
01:18:26,310 --> 01:18:30,229
el caso en el que tendríamos que el número es

910
01:18:30,229 --> 01:18:39,140
impar. System.out.println

911
01:18:39,140 --> 01:18:43,819
y aquí podemos poner, para que nos quede tabulado así

912
01:18:43,819 --> 01:18:46,840
un poquito más bonito, ponemos dos barrastes

913
01:18:46,840 --> 01:18:59,069
y decimos el número, vamos a poner

914
01:18:59,069 --> 01:19:05,859
el número con el que estamos trabajando, pongo más para seguir

915
01:19:05,859 --> 01:19:09,899
concatenando cadenas de caracteres, aquí dejo un espacio para que me quede

916
01:19:09,899 --> 01:19:13,939
más chulo, otro espacio, es, y si estamos aquí

917
01:19:13,939 --> 01:19:20,260
dentro pues resulta que estamos hablando de un número par pues es par podemos decir y en este

918
01:19:20,260 --> 01:19:28,819
caso podemos decir que es impar esto no me está cumpliendo probablemente porque falta un paréntesis

919
01:19:28,819 --> 01:19:42,829
ahí está le doy a la ejecución vamos a ver si nos funciona con el par

920
01:19:42,829 --> 01:19:53,630
dimos par dime un número decimos un 3 me dice que es impar ponemos la p de la opción y ponemos un 6

921
01:19:53,630 --> 01:19:55,090
me dice que es par

922
01:19:55,090 --> 01:19:58,029
vamos a sumar

923
01:19:58,029 --> 01:19:59,250
vamos a hacer un ejercicio rápido

924
01:19:59,250 --> 01:20:00,670
4.4

925
01:20:00,670 --> 01:20:03,050
2.2

926
01:20:03,050 --> 01:20:05,930
bueno pues me da ahí el resultado

927
01:20:05,930 --> 01:20:07,069
6.6

928
01:20:07,069 --> 01:20:09,989
fijaros ahí me da un número

929
01:20:09,989 --> 01:20:12,029
larguísimo y termina aquí completándolo

930
01:20:12,029 --> 01:20:12,689
con un 5

931
01:20:12,689 --> 01:20:15,449
pues tiene una pequeña deriva esto ahí

932
01:20:15,449 --> 01:20:16,970
a la hora de hacer la operación

933
01:20:16,970 --> 01:20:21,449
si damos aquí resta

934
01:20:21,449 --> 01:20:23,289
ponemos 7

935
01:20:23,289 --> 01:20:24,930
menos 2

936
01:20:24,930 --> 01:20:30,720
nos da el resultado de 5, el máximo de 3 números

937
01:20:30,720 --> 01:20:34,840
3, 3, 3, 4, 2, me dice que es 4

938
01:20:34,840 --> 01:20:38,399
y el par, ponemos el 88

939
01:20:38,399 --> 01:20:42,279
y me dice que es un número par, ponemos

940
01:20:42,279 --> 01:20:46,180
una opción no válida y no me dice nada, ahora

941
01:20:46,180 --> 01:20:50,100
terminamos de implementar la opción no válida

942
01:20:50,100 --> 01:20:54,119
si ponemos salir, pues nada, se marcha

943
01:20:54,119 --> 01:20:59,079
Fijaros que aquí se me ha quedado una T, porque probablemente no he puesto la barra.

944
01:20:59,880 --> 01:21:03,159
En la opción, pulsa P para indicar si es par.

945
01:21:06,359 --> 01:21:07,399
Bueno, se me ha quedado esta T.

946
01:21:08,359 --> 01:21:10,659
Pulsa T para indicar si es par.

947
01:21:10,899 --> 01:21:11,880
Tengo una T ahí extra.

948
01:21:13,039 --> 01:21:17,800
Y luego, bueno, pues aquí podríamos decir, para completar el ejercicio,

949
01:21:17,800 --> 01:21:20,300
podríamos poner un else.

950
01:21:23,079 --> 01:21:38,329
Y aquí decir, system.out.println, opción no.

951
01:21:38,430 --> 01:21:53,340
Bueno, como lo queréis formatear. Entonces, si yo pongo aquí cualquier cosa que no sea válida, pues dice opción no válida y tras mostrar por el else la opción no válida, me vuelve a mostrar aquí el menú.

952
01:21:58,510 --> 01:22:06,829
Y bueno, esto en líneas generales era la práctica que os proponía para practicar, para trabajar un poquillo con esto, con esto del tema 3.

953
01:22:06,829 --> 01:22:10,989
al ejercicio le queda, bueno, pues para que sea

954
01:22:10,989 --> 01:22:14,890
algo entregable, digamos, a un cliente todavía le quedaría recorrido

955
01:22:14,890 --> 01:22:18,970
un ejercicio habría que validar, por ejemplo, que si yo cojo aquí

956
01:22:18,970 --> 01:22:22,689
digo sumar, si yo dice ponme aquí el primer número

957
01:22:22,689 --> 01:22:26,869
y pongo aquí unas teclas, pues no me pase esto, entonces esto ahí

958
01:22:26,869 --> 01:22:30,109
tema más adelante, pues veremos como podemos hacer

959
01:22:30,109 --> 01:22:34,250
una gestión de excepciones que se puedan producir en el programa para que

960
01:22:34,250 --> 01:22:36,890
detecte un error, nos dé un aviso, pero el programa

961
01:22:36,890 --> 01:22:38,869
no se termine. Imaginaros que esta

962
01:22:38,869 --> 01:22:40,649
calculadora, no sé qué deciros,

963
01:22:40,829 --> 01:22:43,010
fuese un programa de un cajero

964
01:22:43,010 --> 01:22:44,789
automático que tiene que estar funcionando

965
01:22:44,789 --> 01:22:46,829
continuamente y coge y da

966
01:22:46,829 --> 01:22:48,890
un error de estos y de repente se apaga el cajero

967
01:22:48,890 --> 01:22:51,090
y ya deja de funcionar. Pues no es admisible.

968
01:22:51,750 --> 01:22:52,970
Entonces tenemos la posibilidad

969
01:22:52,970 --> 01:22:55,050
de hacer un control de errores

970
01:22:55,050 --> 01:22:56,970
para luego

971
01:22:57,489 --> 01:22:58,670
con código estabilizar

972
01:22:58,670 --> 01:23:01,029
el programa después de que se haya producido ese error

973
01:23:01,029 --> 01:23:03,050
y que siga funcionando a pesar de haberse

974
01:23:03,050 --> 01:23:07,109
producido ese error, igual mostrándonos un mensaje, ¿no? La opción que has puesto no es

975
01:23:07,109 --> 01:23:11,170
válida, pero has intentado meter una cadena de caracteres

976
01:23:11,170 --> 01:23:15,229
donde se esperaba un número, pero que no se acabe así de golpe. Eso, por ejemplo,

977
01:23:15,310 --> 01:23:18,390
es algo que veremos en un tema que es el de controles de excepciones.

978
01:23:19,689 --> 01:23:23,229
Y, bueno, no mucho más que contaros

979
01:23:23,229 --> 01:23:28,590
ya de este ejercicio. No sé si os ha resultado muy complicado,

980
01:23:28,829 --> 01:23:32,649
si tenéis algunas dudas de él, si queréis que comentemos

981
01:23:32,649 --> 01:24:11,279
alguna cosa extra. Sí, sí. Bueno, he puesto, sí, me comenta aquí para que quede en la grabación

982
01:24:11,279 --> 01:24:18,739
una pregunta de que utilizando el Nest, el Nest Sync, bueno, pues ha funcionado. Depende un poco

983
01:24:18,739 --> 01:24:25,680
de la gestión que hagas luego en las siguientes lecturas. Al final, si hay sitios donde luego

984
01:24:25,680 --> 01:24:27,760
hacer lecturas con Nest, es diferente

985
01:24:27,760 --> 01:24:29,600
que si lo haces con NestLine

986
01:24:29,600 --> 01:24:31,760
si en

987
01:24:31,760 --> 01:24:33,600
algún sitio del código

988
01:24:33,600 --> 01:24:35,460
está limpiando el buffer

989
01:24:35,460 --> 01:24:37,760
lo que sí que

990
01:24:37,760 --> 01:24:39,640
te digo es que si tú

991
01:24:39,640 --> 01:24:41,699
haces una lectura con Nessint

992
01:24:41,699 --> 01:24:42,939
y no limpias el buffer

993
01:24:42,939 --> 01:24:45,579
o la alternativa de leerlo

994
01:24:45,579 --> 01:24:46,560
con el NestLine

995
01:24:46,560 --> 01:24:49,500
estás dejando ahí sembrada

996
01:24:49,500 --> 01:24:51,439
una posibilidad de que luego te dé un problema

997
01:24:51,439 --> 01:24:53,100
que a lo mejor no te da

998
01:24:53,100 --> 01:25:12,260
Pues yo que sé, por la secuencia de ejecución del programa, pero dejas ahí un puntito que te lo puede dar. Y en un programa que es muy lineal, más o menos cae rápido en la cuenta. Este ejemplo que os he puesto yo, que sí que se producía el error, no sé si lo has observado, que el siguiente en S-Line.

999
01:25:12,260 --> 01:25:33,000
Sí, pues en este programa se ve muy directo, pero cuando realmente tienes pues a lo mejor un bucle y luego se va a otra opción y pues ya como que visualmente las líneas según el siguiente Nes que puedas hacer, el siguiente Nesline igual no está próximo en el código al Nesync que acabas de hacer.

1000
01:25:33,000 --> 01:25:37,000
y entonces tú ves que no te funciona en esa zona de código

1001
01:25:37,000 --> 01:25:41,420
por ejemplo, la variable está vacía como me estaba sucediendo

1002
01:25:41,420 --> 01:25:45,140
antes cuando pedía el nombre y como no tienes el otro

1003
01:25:45,140 --> 01:25:49,340
nesting visualmente cerca en el código, cuesta a veces mucho

1004
01:25:49,340 --> 01:25:52,859
terminar deduciendo que es que en la secuencia de ejecución pasó aquello

1005
01:25:52,859 --> 01:25:55,960
y es más, si además es un programa que

1006
01:25:55,960 --> 01:26:01,100
unas veces no tienes por qué llegar a ese nestline directamente siempre después

1007
01:26:01,100 --> 01:26:04,239
de un Nessint anterior, de un Nessdouble, sino que depende

1008
01:26:04,239 --> 01:26:07,319
de opciones que vayas o ejecuciones que vayan pasando en el programa

1009
01:26:07,319 --> 01:26:10,239
unas veces van por ahí, otras no. Entonces esto te puede

1010
01:26:10,239 --> 01:26:12,739
dar situaciones a lo típico de

1011
01:26:12,739 --> 01:26:16,140
jolín, ¿por qué siempre me está funcionando el programa y ciertas

1012
01:26:16,140 --> 01:26:19,380
veces no? Me voy aquí al código, yo veo el Nessline

1013
01:26:19,380 --> 01:26:21,300
donde debería coger el nombre y no me lo coge.

1014
01:26:22,220 --> 01:26:24,640
O sea, dejas como una semillita de

1015
01:26:24,640 --> 01:26:28,560
una posibilidad de problema futuro, que la libras

1016
01:26:28,560 --> 01:26:30,840
con cualquiera de las dos alternativas

1017
01:26:30,840 --> 01:26:32,739
que hemos dicho, si quiero leer un número

1018
01:26:32,739 --> 01:26:34,420
y lo voy a leer desde el teclado

1019
01:26:34,420 --> 01:26:36,760
voy a limpiar y utilizo

1020
01:26:36,760 --> 01:26:38,539
un nest double, que no es que esté incorrecto

1021
01:26:38,539 --> 01:26:40,699
es código disponible ahí

1022
01:26:40,699 --> 01:26:41,960
en la librería de Java

1023
01:26:41,960 --> 01:26:44,420
voy a dejar limpio el buffer del enter

1024
01:26:44,420 --> 01:26:46,279
no lo voy a dejar ahí, no va a ser que

1025
01:26:46,279 --> 01:26:48,619
luego el diablo enrede por ahí, en otra zona

1026
01:26:48,619 --> 01:26:50,720
de código, o otra posibilidad

1027
01:26:50,720 --> 01:26:52,380
ya te digo que es la que yo suelo utilizar

1028
01:26:52,380 --> 01:26:54,600
es el nest line, cojo mi número

1029
01:26:54,600 --> 01:26:56,760
entero, mi número double con el line

1030
01:26:56,760 --> 01:26:58,119
lo convierto a un número

1031
01:26:58,119 --> 01:27:04,140
y mi buffer se queda totalmente limpio cuando tenga que pasar cosas con la lectura de teclado, pues ahí está.

1032
01:27:06,300 --> 01:27:11,539
No pongo en duda que te está funcionando, pero ahí dejas una posibilidad, algo sin leer,

1033
01:27:11,699 --> 01:27:15,439
que luego vete tú a saber si en algún sitio te puede dar un comportamiento que no esperas.

1034
01:27:22,789 --> 01:27:25,329
¿Alguna otra cosita por ahí? ¿Queréis comentarme alguien?

1035
01:27:27,939 --> 01:27:53,649
Sí, mira, sí, bueno, preguntaba un poco por el funcionamiento de estas líneas.

1036
01:27:53,649 --> 01:28:15,819
Entonces, en el API de Java, para la clase Scanner, si tú pones aquí mi scan, el objeto que tenemos definido y ponemos aquí netline, si leemos una línea, fíjate aquí que lo que me devuelve es un string.

1037
01:28:15,819 --> 01:28:18,500
este string será, si es un nombre

1038
01:28:18,500 --> 01:28:20,380
será Rubén, será

1039
01:28:20,380 --> 01:28:22,300
Noah y si es un número

1040
01:28:22,300 --> 01:28:24,359
será el número pero cargado en una

1041
01:28:24,359 --> 01:28:25,800
variable string, es decir

1042
01:28:25,800 --> 01:28:28,260
es una cadena de caracteres

1043
01:28:28,260 --> 01:28:28,600
entonces

1044
01:28:28,600 --> 01:28:32,399
nestline, eso es, siempre te lee

1045
01:28:32,399 --> 01:28:32,979
un string

1046
01:28:32,979 --> 01:28:36,319
sí, bien, pues entonces

1047
01:28:36,319 --> 01:28:38,220
bueno, ya completo la

1048
01:28:38,220 --> 01:28:40,220
consulta por si alguien

1049
01:28:40,220 --> 01:28:42,220
luego ve el vídeo, entonces nestline

1050
01:28:42,220 --> 01:28:44,460
siempre te cogerá un string, entonces esa variable

1051
01:28:44,460 --> 01:28:45,619
la estás cargando en un string

1052
01:28:45,619 --> 01:28:53,079
fíjate como si yo pongo aquí y valor 2 que sabemos por la definición que tenemos arriba que es un

1053
01:28:53,079 --> 01:28:58,680
entero no he puesto aquí el indicador este de la y para que me lo chive y yo digo mi scan

1054
01:29:00,300 --> 01:29:09,340
punto next line punto y coma fíjate que no me compila porque porque él como devuelve el

1055
01:29:09,340 --> 01:29:14,699
next line devuelve un string dice una variable de tipo entero no lo puedo cargar pues como lo

1056
01:29:14,699 --> 01:29:18,600
tenemos aquí cargado con independencia que si metemos el dato bien desde el

1057
01:29:18,600 --> 01:29:24,939
teclado será un literal será un string aunque realmente vemos aquí un número

1058
01:29:24,939 --> 01:29:30,539
pero será un string no será 444 pues para convertirlo a un entero por eso es

1059
01:29:30,539 --> 01:29:33,119
por lo que hacemos el parse int en este caso

1060
01:29:33,119 --> 01:29:44,520
esta era un poco la jugada de por qué lo hacemos así bueno nos hemos metido en

1061
01:29:44,520 --> 01:30:07,239
Son las 7 y 5 ya y bueno, pues no me importa en absoluto. Tengo aquí el guioncillo de cosas que os quiero contar del tema 4. Se nos ha ido la clase resolviendo la tarea 3, pero bueno, a mí me parece que ha podido ser interesante porque hemos hecho un repaso ahí de muchas cosas y haciendo un ejercicio desde cero para que veáis como más o menos se me ha ocurrido a mí ir planteándolo.

1062
01:30:07,239 --> 01:30:20,939
Lo que sí que no vamos a hacer, yo creo, ya es arrancar con el tema 4. El tema 4 lo tenemos, todavía lo tenemos abierto alguna semana más, pues hacemos repaso del tema 4 ya a partir de la semana que viene.

1063
01:30:22,920 --> 01:30:31,039
Estos minutillos, si tenéis alguna otra cosa que queráis comentar, pues adelante y si no, pues yo creo que lo vamos a ir dejando por aquí ya.

1064
01:30:31,039 --> 01:30:56,979
Uy, pues no sé decirte ningún libro así especialmente recomendado. Bueno, si has hecho alguna búsqueda por internet, que entiendo que sí, habrás visto que hay miles de colecciones de Java, es un lenguaje tan popular.

1065
01:30:56,979 --> 01:31:00,899
pero así alguno decirte, mira este sí que te lo recomiendo

1066
01:31:00,899 --> 01:31:04,779
que podría ser especialmente útil, pues no sabría decirte

1067
01:31:04,779 --> 01:31:08,579
de todas formas, como esta asignatura la damos también aquí en presencial

1068
01:31:08,579 --> 01:31:12,579
y tenemos varios ciclos, le voy a preguntar a otros compañeros que dan

1069
01:31:12,579 --> 01:31:16,899
la asignatura a ver si a ellos se les ocurre algún libro

1070
01:31:16,899 --> 01:31:28,069
en particular y os lo pongo en el foro. Bueno, pues nada

1071
01:31:28,069 --> 01:31:33,069
voy a parar la grabación y si no tenéis alguna otra cosita por ahí

1072
01:31:33,069 --> 01:31:34,949
que comentarme, aquí lo dejamos.