1
00:00:02,100 --> 00:00:07,559
alguna cosita por ahí alguna duda que queráis plantear antes de arrancar con la clase a contaros

2
00:00:07,559 --> 00:00:47,289
yo cosas bueno al final sí bueno para dar una pequeña vuelta vale para terminar respondiendo

3
00:00:47,289 --> 00:00:53,049
de la lectura en realidad se hace a través en las comunicaciones de nuestras aplicaciones de

4
00:00:53,049 --> 00:00:59,829
enjaba se hacen a través de flujos de datos los flujos de datos son digamos para entendernos

5
00:00:59,829 --> 00:01:04,310
podríamos considerarlo como unas tuberías que en un lado tienen pinchado

6
00:01:04,310 --> 00:01:08,310
una entrada o salida de datos exterior y en el otro lado tenemos

7
00:01:08,310 --> 00:01:11,790
puesto la conexión a nuestro programa.

8
00:01:12,790 --> 00:01:16,150
En este caso es para leer datos, con lo cual el flujo de datos es de entrada.

9
00:01:16,890 --> 00:01:20,450
Y en particular el flujo de datos que leemos es el flujo

10
00:01:20,450 --> 00:01:24,730
SystemIn. Recuerda cuando utilizamos la clase

11
00:01:24,730 --> 00:01:28,230
Scanner que en el constructor del objeto de la clase Scanner decimos

12
00:01:28,230 --> 00:01:30,909
utiliza el flujo de datos SystemIn.

13
00:01:32,510 --> 00:01:36,250
Los flujos de datos, es decir, para comunicar nuestra aplicación

14
00:01:36,250 --> 00:01:39,590
con elementos externos, pues tenemos para la entrada

15
00:01:39,590 --> 00:01:43,030
de teclado el SystemIn, para salida por consola

16
00:01:43,030 --> 00:01:45,370
la típica, la estándar es la SystemOut.

17
00:01:45,930 --> 00:01:52,010
De hecho, fijaros cómo a la hora de escribir en pantalla

18
00:01:52,010 --> 00:01:55,189
directamente en lugar de utilizar clases adicionales

19
00:01:55,189 --> 00:01:57,269
trabajamos sobre el propio flujo de datos.

20
00:01:57,269 --> 00:02:11,370
Fijaros que ponemos System.out.println. Trabajamos ya directamente sobre el System.out. En cambio, la entrada normalmente la manejamos con otras clases adicionales que nos facilitan, digamos, un poquito la entrada.

21
00:02:11,370 --> 00:02:37,310
¿Vale? Los flujos de datos, pues tenemos, ya os digo, el System Out para escribir, por ejemplo, en pantalla, el System In para leer desde teclado. Podemos tener flujos de datos a otras aplicaciones a través de conexiones con Socket, que son las típicas conexiones que utilizamos en nuestro día a día cuando comunicamos, por ejemplo, un navegador a un servidor web para descargar nuestra página de tenis de marca.

22
00:02:37,310 --> 00:02:42,229
pues se establece un socket al servidor web desde el navegador.

23
00:02:42,629 --> 00:02:44,750
Y bueno, y así con prácticamente todos los servicios.

24
00:02:44,849 --> 00:02:46,770
Las comunicaciones se suelen hacer por sockets.

25
00:02:48,150 --> 00:02:50,909
Diferentes lenguajes implementan conexiones por socket.

26
00:02:51,050 --> 00:02:51,949
Java también lo hace.

27
00:02:52,110 --> 00:02:55,009
Pues eso sería también un flujo de datos que comunicaría nuestra aplicación

28
00:02:55,009 --> 00:02:56,189
con otro elemento externo.

29
00:02:56,449 --> 00:02:57,330
Es decir, flujos de datos.

30
00:02:58,409 --> 00:03:01,150
El de lectura, como bien comentas, es el systeming.

31
00:03:01,530 --> 00:03:02,870
¿Qué me sucede con systeming?

32
00:03:02,870 --> 00:03:24,909
Pues que la forma de trabajar, digamos, nosotros podríamos hacer lecturas, igual que hacemos un System.out.println, podríamos hacer directamente lecturas desde System.in, pero igual nos viene como bytes y tenemos que hacer una gestión un poquito más engorrosa, un poquito más complicada en nuestro código para terminar de convertirlo, por ejemplo, en cadenas de caracteres.

33
00:03:24,909 --> 00:03:28,449
pero tenemos que convertirlas para

34
00:03:28,449 --> 00:03:31,509
trabajar con ellas en ciertos casos. Entonces, ¿qué podemos

35
00:03:31,509 --> 00:03:34,990
hacer? Pues apoyarnos en otras clases adicionales

36
00:03:34,990 --> 00:03:37,270
que ya están disponibles en las librerías.

37
00:03:37,610 --> 00:03:40,629
La clase quizás más cómoda es la Scanner, pero

38
00:03:40,629 --> 00:03:42,710
en la Scanner, de hecho, siempre le decimos que

39
00:03:42,710 --> 00:03:46,430
el flujo de entrada sobre el que queremos ir trabajando

40
00:03:46,430 --> 00:03:49,689
con datos y Scanner ya nos da de forma adicional

41
00:03:49,689 --> 00:03:52,430
un formato de estos datos, es el Sistening

42
00:03:52,430 --> 00:03:58,370
cuando leemos directamente desde el teclado, pero en un objeto de la clase Scanner

43
00:03:58,370 --> 00:04:02,770
podríamos coger y hacer la lectura no de System.in, sino hacerlo, por ejemplo,

44
00:04:02,810 --> 00:04:06,710
de un fichero, que sería otro flujo de datos, y sobre ese flujo de datos

45
00:04:06,710 --> 00:04:10,590
trabajar de una forma con datos formateados con Scanner.

46
00:04:11,090 --> 00:04:15,870
Otra posibilidad para, digamos, que le pone una capa por encima al System.in

47
00:04:15,870 --> 00:04:21,870
es utilizar la clase InputStream y la BufferReader y todo esto.

48
00:04:22,430 --> 00:04:44,170
Ahora, en uno de los, no sé si es el siguiente tema o dentro de dos temas, hablamos de la lectura de ficheros y la lectura de ficheros siempre, aunque la podríamos hacer con escáner, pero siempre se suele trabajar con las clases estas, justo con la que propone el ejercicio para leer el system in, que es la input reader y la buffer reader.

49
00:04:44,170 --> 00:04:46,750
puedes leer información

50
00:04:46,750 --> 00:04:50,529
como bytes

51
00:04:50,529 --> 00:04:52,129
o como caracteres

52
00:04:52,129 --> 00:04:54,730
y para eso hay diferentes clases en las librerías

53
00:04:54,730 --> 00:04:55,110
de Java

54
00:04:55,110 --> 00:04:57,470
el hecho

55
00:04:57,470 --> 00:05:00,089
de leer carácter a carácter

56
00:05:00,089 --> 00:05:01,990
te lo permite la input stream

57
00:05:01,990 --> 00:05:04,350
y luego si quieres tener un buffer para leer

58
00:05:04,350 --> 00:05:06,990
de forma global conjuntos de caracteres

59
00:05:06,990 --> 00:05:08,589
puedes meter todos estos

60
00:05:08,589 --> 00:05:10,430
caracteres que lees en la input stream

61
00:05:10,430 --> 00:05:12,389
en una buffer reader y ya tienes un buffer

62
00:05:12,389 --> 00:05:17,329
con un conjunto de caracteres para leerlos de golpe, que es un poco lo que termina haciendo

63
00:05:17,329 --> 00:05:26,389
cuando hacemos un redline en la escáner. Es decir, que son dos alternativas que nos permiten leer el system in

64
00:05:26,389 --> 00:05:32,389
o leer ficheros, por ejemplo, de una forma más cómoda que leer directamente el system in

65
00:05:32,389 --> 00:05:38,069
y que las tenemos ambas dos alternativas disponibles en librerías de Java.

66
00:05:38,069 --> 00:05:43,970
¿Cuál es mejor o cuál es peor? Pues no sabría decirte, si una te gusta más u otra

67
00:05:43,970 --> 00:05:46,029
pues puedes utilizar cualquiera de las dos

68
00:05:46,029 --> 00:05:51,910
Es verdad que típicamente la lectura del teclado se suele hacer

69
00:05:51,910 --> 00:05:56,089
más con escáner y la lectura de ficheros más con las otras

70
00:05:56,089 --> 00:06:00,129
Si no tienes mucha intriga

71
00:06:00,129 --> 00:06:03,850
en saber cómo funciona, te invito a posponerlo

72
00:06:03,850 --> 00:06:07,829
dos o tres tutorías y cuando veamos el tema vamos a trabajar con esas clases

73
00:06:07,829 --> 00:06:12,470
y hacemos también un acercamiento a leer el teclado directamente desde ahí.

74
00:06:13,089 --> 00:06:16,529
Y si está muy intrigado, pues echamos un rato y lo vemos.

75
00:06:18,029 --> 00:06:36,149
Sí, al final la clase Scanner,

76
00:06:37,110 --> 00:06:39,949
bueno, no sé cómo está programada para serte sincero,

77
00:06:40,009 --> 00:06:42,870
porque no me he ido a buscar su código y me he puesto a analizarlo,

78
00:06:42,870 --> 00:06:47,029
pero sí que es verdad que nos devuelve directamente a través de un Redline

79
00:06:47,029 --> 00:06:50,250
grupos de caracteres y digamos que

80
00:06:50,250 --> 00:06:52,870
con estas otras clases lo haces

81
00:06:52,870 --> 00:06:56,230
ese grupo de caracteres lo haces en dos pasos

82
00:06:56,230 --> 00:06:59,769
directamente el flujo de datos te devuelve bytes

83
00:06:59,769 --> 00:07:02,550
pero si normalmente en tu programa vas a querer

84
00:07:02,550 --> 00:07:05,529
trabajar con caracteres pues digamos que le pones

85
00:07:05,529 --> 00:07:08,509
una primera cubierta para que esos bytes

86
00:07:08,509 --> 00:07:11,790
directamente los puedas leer tú ya como caracteres con un input reader

87
00:07:11,790 --> 00:07:14,750
pero este input reader la idea es que leas

88
00:07:14,750 --> 00:07:16,910
carácter a carácter, ya no byte a byte

89
00:07:16,910 --> 00:07:18,209
sino carácter a carácter

90
00:07:18,209 --> 00:07:20,810
y si quieres coger un

91
00:07:20,810 --> 00:07:22,790
conjunto de caracteres con

92
00:07:22,790 --> 00:07:23,730
una lectura de golpe

93
00:07:23,730 --> 00:07:26,730
del input reader te va metiendo en un

94
00:07:26,730 --> 00:07:28,689
buffer, es decir, va haciendo ahí una montañita

95
00:07:28,689 --> 00:07:30,670
va agrupando los diferentes caracteres

96
00:07:30,670 --> 00:07:32,790
que puedes leer y se escapa

97
00:07:32,790 --> 00:07:34,750
de volverte, digamos, grupos

98
00:07:34,750 --> 00:07:36,850
de caracteres, ¿por qué? porque está en un buffer

99
00:07:36,850 --> 00:07:38,930
ya te hace la lectura directamente desde un buffer

100
00:07:38,930 --> 00:07:40,569
en lugar de consultar cada

101
00:07:40,569 --> 00:07:42,790
carácter directamente al flujo

102
00:07:42,790 --> 00:07:44,410
desde donde se está recibiendo la información

103
00:07:44,410 --> 00:07:46,810
entonces se hace como en dos pasos, es verdad

104
00:07:46,810 --> 00:07:49,970
pero

105
00:07:49,970 --> 00:07:53,389
lo dejamos, cuando lleguemos al tema

106
00:07:53,389 --> 00:07:55,050
de ficheros ya veremos como lo tratamos

107
00:07:55,050 --> 00:07:57,329
y si no entonces me das un tironcillo

108
00:07:57,329 --> 00:07:59,269
de orejas y me dices, te recuerdo que habíamos dicho

109
00:07:59,269 --> 00:08:01,209
de ver esto, pero ya te digo yo que

110
00:08:01,209 --> 00:08:03,490
lo veremos porque es la forma de leer ficheros

111
00:08:03,490 --> 00:08:04,529
y a ver

112
00:08:04,529 --> 00:08:07,410
exactamente en que tema es

113
00:08:07,410 --> 00:08:09,490
porque no recuerdo si es el siguiente tema

114
00:08:09,490 --> 00:08:10,569
y si es el siguiente tema

115
00:08:10,569 --> 00:08:12,490
colecciones de datos, mira

116
00:08:12,490 --> 00:08:15,029
el siguiente tema es colecciones de datos

117
00:08:15,029 --> 00:08:19,029
y el tema 10, que todavía no lo estáis viendo vosotros, es este

118
00:08:19,029 --> 00:08:22,769
el de lectura y escritura de información y aquí trabajamos con

119
00:08:22,769 --> 00:08:26,970
fíjate como por aquí aparece flujos de datos, por aquí habla de

120
00:08:26,970 --> 00:08:30,889
ficheros, veis, esto lo tenéis vosotros ocultado todavía hasta que llega el momento de abrirlo

121
00:08:30,889 --> 00:08:34,870
y por aquí, mira, escritura, lectura, información

122
00:08:34,870 --> 00:08:39,149
ficheros binarios y de texto y mira, ves

123
00:08:39,149 --> 00:08:42,850
justo por aquí como te habla de input stream directamente

124
00:08:42,850 --> 00:08:46,269
y luego por ahí, mira, y buffer al reader, un poco esto es lo que me estás

125
00:08:46,269 --> 00:08:50,110
refiriendo. Bueno, esta es otra clase, file reader, hay diferentes clases,

126
00:08:50,669 --> 00:08:53,090
pero todas estas son las que trabajan con esto que comentas.

127
00:08:54,149 --> 00:08:58,129
Y en este caso, fíjate cómo en sí la lectura

128
00:08:58,129 --> 00:09:02,350
la hace en lugar de, en el constructor de este file input stream,

129
00:09:02,350 --> 00:09:06,370
ya entraremos en detalle cuando lleguemos al tema 10, en lugar de poner

130
00:09:06,370 --> 00:09:10,129
aquí systeming, pues la entrada, el flujo de datos de entrada es desde un fichero

131
00:09:10,129 --> 00:09:18,350
que está en este caso en el fichero texto punto txt del sistema archivos en la carpeta c pues este

132
00:09:18,350 --> 00:09:24,649
programa está pensado para que corra en un windows porque el sistema archivo está referido a hace dos

133
00:09:24,649 --> 00:09:31,970
puntos barra barra entonces el tema 10 que a ver creo que lo tengo por aquí puesta las fechas pues

134
00:09:31,970 --> 00:09:37,230
que la abrimos el mediador del mes que viene pues a mediador del mes que viene arrancamos con esto

135
00:09:37,230 --> 00:09:56,279
Y lo vemos. Nada, nada, nada, sin problema. No sé, ¿alguna otra cosita por ahí queríais que comentáramos? Bueno, pues si no, os cuento la historia de lo que tenía pensado para hoy.

136
00:09:56,279 --> 00:09:59,320
el tema este de control de manejo de excepciones

137
00:09:59,320 --> 00:10:03,320
fijaros que abría la semana pasada y cierra mañana

138
00:10:03,320 --> 00:10:06,279
para este tema en principio solo tenemos planificada

139
00:10:06,279 --> 00:10:09,299
una semana, mañana abrimos ya el siguiente tema

140
00:10:09,299 --> 00:10:12,179
que es el de colecciones, el de colecciones si que es un poco más amplio

141
00:10:12,179 --> 00:10:15,419
vamos a ver que tiempo tiene, fijaros que tenemos prácticamente

142
00:10:15,419 --> 00:10:18,720
un mes, este si que da, tiene más cosas que hacer

143
00:10:18,720 --> 00:10:21,240
nuevos conceptos y tiene

144
00:10:21,240 --> 00:10:23,460
tenemos que trabajarlo algo más

145
00:10:23,460 --> 00:10:26,259
sabéis que, recordad que cuando

146
00:10:26,259 --> 00:10:28,620
acabamos un tema, pues para cerrarlo

147
00:10:28,620 --> 00:10:30,379
me gusta normalmente resolver

148
00:10:30,379 --> 00:10:32,539
la tarea en una tutoría

149
00:10:32,539 --> 00:10:34,200
entonces hoy

150
00:10:34,200 --> 00:10:36,039
como la semana pasada

151
00:10:36,039 --> 00:10:37,460
no tuvimos clase, verdad

152
00:10:37,460 --> 00:10:39,480
o hace dos semanas, bueno vamos

153
00:10:39,480 --> 00:10:42,019
con una pizca de retraso y como esta

154
00:10:42,019 --> 00:10:43,960
tarea solamente dura una semana

155
00:10:43,960 --> 00:10:45,559
este tema solo dura una semana

156
00:10:45,559 --> 00:10:48,379
hoy tocaría, siguiendo esas pautas

157
00:10:48,379 --> 00:10:50,159
corregir la

158
00:10:50,159 --> 00:10:51,360
tarea del tema 7

159
00:10:51,360 --> 00:10:55,379
pero antes de dejar pasar más tiempo con esta tarea ya que

160
00:10:55,379 --> 00:10:59,259
mañana arrancamos con la unidad 9 pues he pensado que hoy

161
00:10:59,259 --> 00:11:03,000
podemos pegar un repasillo a las excepciones

162
00:11:03,000 --> 00:11:07,179
y bueno pues dejamos pendientes estas dos tareas y el siguiente día

163
00:11:07,179 --> 00:11:11,200
dado que luego para el tema 9 tenemos prácticamente un mes

164
00:11:11,200 --> 00:11:14,720
pues una de las tutorías, una tutoría y algo pues la resolvemos

165
00:11:14,720 --> 00:11:19,320
las tareas para pegar otro repasillo a los conceptos de cada una de ellas

166
00:11:19,320 --> 00:11:26,240
así que vamos con el tema de excepciones a pegar un pequeño repaso de la teoría

167
00:11:26,240 --> 00:11:29,440
este tema, el tema de excepciones tiene dos bloques

168
00:11:29,440 --> 00:11:35,220
aunque en realidad solamente venimos trabajando uno todo este tiempo

169
00:11:35,220 --> 00:11:38,139
porque el otro lo veis algo en entorno de desarrollo

170
00:11:38,139 --> 00:11:41,360
la primera parte es el control y manejo de excepciones

171
00:11:41,360 --> 00:11:44,179
como os digo ahora entramos en detalle

172
00:11:44,179 --> 00:11:48,740
y la segunda parte es, bueno pues habla de documentación del código

173
00:11:48,740 --> 00:12:02,899
A este lo voy a dedicar dos minutos, sin entrar mucho más, ya os digo porque lo trabajáis más en entornos y si tuvierais dudas, pues bueno, me lo planteéis por los foros y otro día echamos más rato.

174
00:12:02,899 --> 00:12:07,940
una parte cuando dedicamos

175
00:12:07,940 --> 00:12:11,019
cuando vamos a hacer un desarrollo, pues en principio

176
00:12:11,019 --> 00:12:14,460
tiene que ser una serie de pautas, una serie de procesos

177
00:12:14,460 --> 00:12:17,320
y la asignatura está cerrada justo

178
00:12:17,320 --> 00:12:20,059
en la parte de implementación, de pruebas

179
00:12:20,059 --> 00:12:22,539
implementación y pruebas, es decir, hacemos un programa

180
00:12:22,539 --> 00:12:26,220
mediante código y lo probamos ahí, le lanzamos unas cuantas

181
00:12:26,220 --> 00:12:29,240
ejecuciones, pero en realidad

182
00:12:29,240 --> 00:12:32,039
pensando en un proyecto global, pues estas son dos

183
00:12:32,039 --> 00:12:36,340
fases entre muchas otras. Típicamente habría una definición

184
00:12:36,340 --> 00:12:40,139
de requisitos, habría un diseño previo a ponernos a hacer el código

185
00:12:40,139 --> 00:12:44,539
y posteriormente después de hacer el desarrollo del código y sus pruebas

186
00:12:44,539 --> 00:12:48,279
habría una implantación y habría un posible mantenimiento correctivo

187
00:12:48,279 --> 00:12:52,759
o evolutivo del código. En realidad la asignatura

188
00:12:52,759 --> 00:12:56,919
se olvida de todo eso y nos quedamos centrados solamente en hacer el código

189
00:12:56,919 --> 00:13:00,659
y en probarlo. Pero todas estas

190
00:13:00,659 --> 00:13:12,019
otras fases traen consigo mucha documentación. Hay que definir muy bien el diseño cómo va y hay que hacer los manuales de usuario y los manuales de instalación del código.

191
00:13:12,019 --> 00:13:26,940
Todo esto que en un ciclo completo de un proyecto habría que tener en cuenta. Como parte de esta documentación, Java nos permite meter ciertas pautas dentro del código

192
00:13:26,940 --> 00:13:39,799
que luego de forma automática, a través de otro ejecutable diferente al intérprete de Java, genera una estructura de páginas y se autodocumenta el código, se puede decir.

193
00:13:40,600 --> 00:13:49,139
Entonces, si nosotros dentro del código, el programa en Java que permite hacer esta documentación automática del código es Javadoc.

194
00:13:49,139 --> 00:14:10,679
Aquí lo tenéis indicado. Cuando tú instalas el JDK dentro de la carpeta BIM, pues típicamente está el Java, el compilador Java C, está el intérprete que es Java, pues bueno, además de estos dos, hay otros cuantos ejecutables más que con el JDK se instalan y uno de ellos es, como os digo, el Javadoc.

195
00:14:10,679 --> 00:14:15,909
cuando nosotros estamos haciendo código

196
00:14:15,909 --> 00:14:18,549
recordad que tenemos la posibilidad de meter

197
00:14:18,549 --> 00:14:21,049
comentarios o bien con dos barras

198
00:14:21,049 --> 00:14:23,629
de estas, dos barras del 7

199
00:14:23,629 --> 00:14:26,850
que viene con el teclado con el número 7

200
00:14:26,850 --> 00:14:29,710
o bloquer de comentarios, si ponemos

201
00:14:29,710 --> 00:14:32,970
barra asterisco, estos comentarios son

202
00:14:32,970 --> 00:14:35,629
para meter varias líneas de comentario

203
00:14:35,629 --> 00:14:37,850
y lo terminamos con asterisco barra

204
00:14:37,850 --> 00:14:41,610
pues cuando queremos, una de las posibilidades

205
00:14:41,610 --> 00:14:45,809
cuando vamos a utilizar las pautas que considera el programa

206
00:14:45,809 --> 00:14:49,490
JavaDoc para implementar, para crear

207
00:14:49,490 --> 00:14:52,970
de forma automática documentación, es que metas

208
00:14:52,970 --> 00:14:57,870
comentarios, bloques de comentarios, entre barra, asterisco, asterisco

209
00:14:57,870 --> 00:15:01,110
y luego terminas con asterisco, barra. ¿Qué pasa

210
00:15:01,110 --> 00:15:05,389
con esto si se lo encuentra el intérprete de Java? Pues que como

211
00:15:05,389 --> 00:15:09,789
empieza con barra, asterisco, asterisco, barra, no lo tiene en consideración

212
00:15:09,789 --> 00:15:21,929
a la hora de ejecutar el programa. En cambio, si tú ejecutas Javadoc, este otro programa, al contrario que el intérprete de Java, lo que sí que intenta localizar en el código

213
00:15:21,929 --> 00:15:33,830
es aquello que está encerrado entre estas pautas. Es decir, para el intérprete esto es un comentario a no considerar, pero en cambio para Javadoc esto es lo que le importa.

214
00:15:33,830 --> 00:15:42,710
El resto no lo considera. Digamos que tiene la lógica inversa en tanto en cuanto considera las líneas que aparecen en los ficheros .java.

215
00:15:43,669 --> 00:15:54,309
Y por aquí dentro lo que se hace es meter una serie de etiquetas que tienen que ser las que tienen que ser. Están especificadas en la forma de implementar documentación con javadoc.

216
00:15:54,309 --> 00:15:59,490
y si tú en el código metes entre estos comentarios esas etiquetas,

217
00:15:59,769 --> 00:16:03,730
pues luego cuando ejecuta el javadoc se viene a buscarlo dentro de los ficheros .java

218
00:16:03,730 --> 00:16:09,139
y automáticamente el programa te crea esa documentación.

219
00:16:09,139 --> 00:16:13,940
Ya os digo que tenéis algo de información aquí en el tema.

220
00:16:14,539 --> 00:16:18,320
Nosotros no preguntaremos nada de javadoc en el examen

221
00:16:18,320 --> 00:16:23,980
porque nos parece un poco más que está más planteado para entornos de desarrollo.

222
00:16:23,980 --> 00:16:39,879
Pero bueno, ahí lo tenéis y si tenéis dudas, ya que aparece aquí en el temario, pues ya os digo, me ponéis alguna entrada ahí en el foro y si la podemos responder por el foro estos días, la respondemos y si vemos necesario, pues en la siguiente tutoría le echamos un ratillo.

223
00:16:39,879 --> 00:16:57,600
Lo que sí que es particular de esta asignatura, aunque luego se vaya utilizando en otras si programáis en Java, son las excepciones, que es el otro bloque que se considera aquí en este tema. Está la parte de excepciones y la parte de documentación.

224
00:16:57,600 --> 00:17:11,660
Entonces el 8A que trabaja con excepciones, ahora vamos al código como siempre para trabajar con ello, pero me parece interesante que veamos un poquito esta imagen, pues sigue esta estructura.

225
00:17:11,660 --> 00:17:34,460
Recordad que decíamos que las clases en Java estaban organizadas en una estructura de árbol. Arriba del todo, estaría por encima de esta azuable incluso, estaría la clase Object. Siempre decimos que aunque en Java la herencia es única, toda clase hija solo puede tener una clase padre, sí que tiene ciertas características heredadas siempre de la clase Object.

226
00:17:34,460 --> 00:17:43,680
Y parcialmente en ese árbol, esta es una zona en la cual tenemos también una estructura de clases.

227
00:17:44,980 --> 00:17:51,619
Entonces, todo lo que tiene que ver con este tema, con lo que vamos a hablar ahora, cuelga de esta, de la excepción.

228
00:17:52,920 --> 00:17:55,920
Y por encima tiene la clase throughable.

229
00:17:55,920 --> 00:18:07,920
La clase está ThroughAble, o sea, si nosotros hacemos que una clase nuestra herede de excepción, pues tendrá las características de ThroughAble más lo que tenga aquí el excepción.

230
00:18:09,460 --> 00:18:12,920
Ahora después vamos al detalle en código para ir trabajándolo.

231
00:18:14,460 --> 00:18:24,640
Fijaros, el ThroughAble, pues Through es, si no estoy equivocado, es lanzar, ¿verdad?, en inglés, y con el Able, pues que tiene la capacidad de ser lanzado.

232
00:18:24,640 --> 00:18:39,720
Entonces las excepciones, que es sobre lo que vamos a trabajar en este tema, se lanzan de forma automática, por eso heredan características de suable, cuando suceden ciertas cosas, ciertas cosas que son anómalas en nuestro programa.

233
00:18:39,720 --> 00:19:05,720
Y esas cosas suelen estar encasilladas dentro de estas cajitas. Excepciones aritméticas, index out of bounds, such as element excesion, null pointer, illegal argument, bueno, pues con cualquiera de estas genera una situación anómala en nuestro programa que si nosotros consideramos, manejamos estas situaciones anórmalas, las trabajamos como excepciones.

234
00:19:05,720 --> 00:19:12,380
excepciones y con el código correspondiente se lanza otras zonas de código para que trabajen

235
00:19:12,380 --> 00:19:20,859
sobre ellas. Mirad, en los programas tenemos, yo creo, igual hay alguna más, pero bueno, yo considero

236
00:19:20,859 --> 00:19:27,440
que tenemos tres posibles momentos en los cuales se nos pueden dar errores, momentos o tres posibles

237
00:19:27,440 --> 00:19:33,799
situaciones. Un primer momento es cuando estamos codificando el programa, pues el IDE nos chiva

238
00:19:33,799 --> 00:19:37,619
que eso no compila, pues porque tenemos errores sintácticos

239
00:19:37,619 --> 00:19:40,640
dentro de nuestro código. Tenemos que resolverlo hasta que compile

240
00:19:40,640 --> 00:19:44,960
y se pueda poner en marcha. Bueno, pues esos son errores de compilación

241
00:19:44,960 --> 00:19:49,799
que quedan fuera del ámbito de lo que vamos a ver en este tema

242
00:19:49,799 --> 00:19:53,619
porque todos estos posibles errores sobre los que vamos a trabajar

243
00:19:53,619 --> 00:19:56,480
es cuando estamos ya ejecutando nuestros programas.

244
00:19:56,740 --> 00:20:00,279
Y lógicamente los puntos class no se nos van a crear

245
00:20:00,279 --> 00:20:02,420
si tenemos errores de compilación.

246
00:20:03,799 --> 00:20:08,539
venimos programando desde hace tiempo y sobre el tanto esos errores de compilación que se nos van

247
00:20:08,539 --> 00:20:13,579
presentando para que nuestro programa se pueda poner en marcha con lo cual esa faceta mejor o

248
00:20:13,579 --> 00:20:20,480
peor ya la conocemos cuando ya tenemos que nuestro programa es capaz de ejecutarse pues es cuando se

249
00:20:20,480 --> 00:20:26,559
pueden producir estos dos tipos de errores bien errores de los que aparecen colgando aquí de

250
00:20:26,559 --> 00:20:32,180
error que no tiene más no no de éste no están colgando más estructura de árbol o de los de

251
00:20:32,180 --> 00:20:48,680
¿Qué diferencia hay entre estos dos? Pues los errores que aparecen aquí etiquetados como error directamente son aquellos que se pueden dar en nuestro programa, pero nosotros no tenemos capacidad desde el código de gestionarlos.

252
00:20:48,680 --> 00:20:53,039
hay un caso claro de esto

253
00:20:53,039 --> 00:20:56,259
o yo por lo menos el que me parece a mi más claro y más entendible

254
00:20:56,259 --> 00:20:59,180
imaginaros que estamos, nuestro ordenador

255
00:20:59,180 --> 00:21:01,759
tiene un determinado hardware, una memoria RAM determinada

256
00:21:01,759 --> 00:21:05,259
y bueno pues demanda muchos news nuestro programa

257
00:21:05,259 --> 00:21:07,880
con lo cual vamos acogiendo más reservas de memoria RAM

258
00:21:07,880 --> 00:21:11,140
y aunque no hagamos muchos nosotros en nuestro programa

259
00:21:11,140 --> 00:21:14,180
pues a lo mejor están corriendo en paralelo otras aplicaciones diferentes

260
00:21:14,180 --> 00:21:16,420
que también están cogiendo recursos de memoria RAM

261
00:21:16,420 --> 00:21:33,539
Bueno, pues al final la memoria RAM de nuestro ordenador será finita, no será infinita, ¿verdad? Habrá un momento en el que se acabe y a lo mejor ante un nuevo new, el programa ya directamente dice, mira, ya el sistema operativo no es capaz de darme más recursos para seguir ejecutándome.

262
00:21:33,799 --> 00:21:45,579
Eso es algo que se nos escapa a nosotros del alcance para poder controlarlo, con lo cual se producirá un error y ese error estará gestionado a través de este campo de errores.

263
00:21:46,420 --> 00:21:51,460
bueno pues sabiendo que existe y habiéndolo identificado nos olvidamos de ello porque

264
00:21:51,460 --> 00:21:56,359
nosotros en el código no vamos a poder manejarlo lo que sí vamos a poder manejar va a ser los

265
00:21:56,359 --> 00:22:05,289
aquellos errores que cuelguen de este otro lado de excepción dicho esto y por ponernos un poco

266
00:22:05,289 --> 00:22:11,950
en situación minimiza esta parte si luego tenemos que volver y no vamos al código vamos a crear un

267
00:22:11,950 --> 00:22:23,900
proyecto como siempre si tenéis alguna duda que vaya surgiendo me vais diciendo

268
00:22:31,009 --> 00:22:33,670
vamos a crear una clase

269
00:22:33,670 --> 00:22:43,720
con cualquier nombre, este por ejemplo

270
00:22:43,720 --> 00:22:57,200
y le metemos el main

271
00:22:57,200 --> 00:23:02,819
vale, pues, ¿de qué estamos hablando?

272
00:23:03,019 --> 00:23:06,380
fijaros, este programa, mirad, si cogemos y ponemos

273
00:23:06,380 --> 00:23:08,000
aquí, vamos a hacer una primera

274
00:23:08,000 --> 00:23:11,980
vamos a provocar una primera excepción ahí sencillota

275
00:23:11,980 --> 00:23:15,200
vamos a poner para que sea más realista

276
00:23:15,200 --> 00:23:18,240
no aparezca directamente ahí el error ya

277
00:23:18,240 --> 00:23:20,920
en el código sea identificable

278
00:23:20,920 --> 00:24:05,269
Vamos a definir un objeto de la clase Scanner, ponemos el flujo SystemIn, flujo de datos de entrada, y bueno, imaginaos que queremos hacer un programa, mirad lo que os comentaba antes, fijaros como la entrada de datos normalmente la encasulamos en otras posibles clases que tenemos en la librería de Java,

279
00:24:05,269 --> 00:24:10,009
o en la clase scanner que también la tenemos en la librería de Java

280
00:24:10,009 --> 00:24:14,130
porque nos resulta más cómodo trabajar con una capa, como si fuera una cebolla

281
00:24:14,130 --> 00:24:17,369
con una capa más sobre un objeto de la clase scanner, pero en cambio

282
00:24:17,369 --> 00:24:21,630
el flujo de salida de datos, System.out, lo solemos utilizar directamente

283
00:24:21,630 --> 00:24:28,430
sin meterle ninguna otra capa de cebolla, aunque también lo podríamos hacer

284
00:24:28,430 --> 00:24:31,109
pero típicamente lo solemos trabajar así.

285
00:24:31,109 --> 00:24:51,230
Entonces, imaginaos que es un programa en el cual queremos dividir 10 entre el número que se meta por teclado. Introduce el número por el que quieres dividir 10.

286
00:24:51,230 --> 00:25:05,000
lo cogemos por

287
00:25:05,000 --> 00:25:08,319
teclado, me ha escrito aquí

288
00:25:08,319 --> 00:25:09,920
lo que ha querido

289
00:25:09,920 --> 00:25:10,740
nextline

290
00:25:10,740 --> 00:25:18,960
hacemos la conversión

291
00:25:18,960 --> 00:25:21,920
parseInt dsaus

292
00:25:21,920 --> 00:25:23,759
y luego podríamos poner

293
00:25:23,759 --> 00:25:25,619
aquí un

294
00:25:25,619 --> 00:25:27,240
int i result

295
00:25:27,240 --> 00:25:29,900
igual a i

296
00:25:29,900 --> 00:25:31,859
dividido, que vale 10

297
00:25:31,859 --> 00:25:34,099
dividido entre lo que metamos por teclado

298
00:25:34,099 --> 00:25:48,859
bueno, aquí tenemos un programa

299
00:25:48,859 --> 00:26:01,369
que, como veis, sin errores compila. Un programa que compila

300
00:26:01,369 --> 00:26:05,549
sin errores. Y, bueno, aparentemente tendría que ir bien

301
00:26:05,549 --> 00:26:09,289
en todos los casos. Si lo ejecutamos, decimos, bueno, pues 10

302
00:26:09,289 --> 00:26:13,170
vamos a decir que lo divida entre 5 y me dice, mira, el resultado es 2.

303
00:26:13,309 --> 00:26:17,490
¿Vale? Correcto, el programa está bien. Pero, ¿qué sucede si cuando lo ejecutamos

304
00:26:17,490 --> 00:26:21,230
metemos aquí como dato un 0? Pues, bueno, se produce

305
00:26:21,230 --> 00:26:25,230
una división por 0 y el programa termina. No es capaz de sacar el resultado

306
00:26:25,230 --> 00:26:33,650
porque cualquier 10 dividido entre 0 nos da un valor de infinito y eso no lo puede, un número lógicamente infinito no lo puede gestionar el programa.

307
00:26:34,509 --> 00:26:45,890
¿Qué se ha producido? Pues se ha producido una excepción. Esa excepción era controlable en el momento de compilación, no, el programa compila y de hecho para la mayor parte de los valores funciona bien.

308
00:26:45,890 --> 00:27:07,150
Es un problema que se da en tiempo de ejecución. Fijaros cómo por aquí, ¿qué provoca cuando se genera una excepción de cualquiera de todas estas si no la hemos controlado? Ahora vemos cómo las controlamos. Pues que el programa pega un pete aquí y coge y termina directamente.

309
00:27:07,970 --> 00:27:11,529
¿Qué sucede? Que se genera una excepción, fijaros por aquí.

310
00:27:12,130 --> 00:27:17,769
Esa excepción en particular cuando se produce una división por cero es una excepción de tipo aritmético.

311
00:27:18,269 --> 00:27:21,230
La excepción de tipo aritmético la tenemos aquí, ¿veis?

312
00:27:21,390 --> 00:27:25,029
Se ha producido dentro de este árbol una excepción de este tipo.

313
00:27:26,470 --> 00:27:31,269
Como no hemos hecho nosotros una gestión para controlar esa excepción, ¿qué es lo que ha pasado?

314
00:27:31,269 --> 00:27:33,109
Pues que el programa ha terminado directamente.

315
00:27:33,109 --> 00:27:49,430
Y lo máximo que tenemos aquí es una que nos chiva el tipo de excepción aquí en consola. Imaginaos que esto fuese un cajero automático, que queremos que tenga su funcionamiento las 24 horas del día durante todos los días de la semana.

316
00:27:49,950 --> 00:28:10,490
En mitad de una de las operaciones se produce una división y esa división, este valor puede ir cambiando. En el 99,9999% de las veces el programa no tiene ahí un valor de cero y funciona correctamente, pero resulta que una vez sí que ese valor termina siendo cero.

317
00:28:10,490 --> 00:28:25,890
¿Qué sucedería si no hemos hecho una gestión de esa excepción? El programa no finaliza y el cajero queda inactivo. ¿Es correcto una división por cero? No, esa división por cero no la vamos a poder gestionar, está claro.

318
00:28:25,890 --> 00:28:30,349
pero tenemos la posibilidad a través de la gestión de excepciones

319
00:28:30,349 --> 00:28:34,029
que vamos a ver aquí en este tema de estabilizar el programa

320
00:28:34,029 --> 00:28:38,329
quizás enviar un informe, guardar en un fichero, hacer una entrada en una base

321
00:28:38,329 --> 00:28:42,430
de datos diciendo que se ha producido esa situación anómala o directamente no hacer nada

322
00:28:42,430 --> 00:28:46,430
y permitir que el programa siga ejecutándose

323
00:28:46,430 --> 00:28:50,230
y no termina, con lo cual nuestro cajero ese servicio no lo ha podido dar pero sigue

324
00:28:50,230 --> 00:28:54,369
el programa activo para seguir haciendo su funcionalidad

325
00:28:54,369 --> 00:28:58,869
¿Cómo gestionamos las excepciones? Pues

326
00:28:58,869 --> 00:29:02,109
en las zonas donde creemos que se puedan producir una excepción

327
00:29:02,109 --> 00:29:06,329
decimos que intente ejecutarlas y le ponemos un try

328
00:29:06,329 --> 00:29:14,369
intenta, en verdad la excepción se va a dar aquí, esto lo podríamos poner

329
00:29:14,369 --> 00:29:19,220
fuera o lo dejamos ahí como queráis

330
00:29:19,220 --> 00:29:25,390
vamos a dejarlo ahí, entonces dice intenta este código

331
00:29:25,390 --> 00:29:28,470
que antes no teníamos el try

332
00:29:28,470 --> 00:29:33,250
y captura la excepción

333
00:29:33,250 --> 00:29:37,089
que se produce, que si no la estoy gestionando yo aquí a través

334
00:29:37,089 --> 00:29:41,049
de código, lo que va a hacer va a ser terminar el programa y sacar un mensajito por consola

335
00:29:41,049 --> 00:29:44,910
y ya está, pero aquí le estoy diciendo captúrala, la excepción que va a ser

336
00:29:44,910 --> 00:29:48,750
lanzada, fijaros como aquí teníamos la palabra throughable

337
00:29:48,750 --> 00:29:52,130
es decir, se lanza algo, se lanza una excepción

338
00:29:52,130 --> 00:29:56,509
que nosotros podemos capturar con el catch esa excepción

339
00:29:56,509 --> 00:30:00,470
y si no tenemos el try-catch, no la captura nadie y el programa termina.

340
00:30:01,190 --> 00:30:04,769
Pero en cambio, si le ponemos un catch, estamos capturando esa excepción.

341
00:30:05,990 --> 00:30:09,650
Y aquí podemos decir la excepción que queremos calcular.

342
00:30:09,809 --> 00:30:12,730
Podemos poner excepción e.

343
00:30:16,309 --> 00:30:22,049
Entonces, aquí lo que estamos diciendo, captura una excepción que se va a lanzar

344
00:30:22,049 --> 00:30:26,210
y fijaros que aquí tenemos un objeto e de la clase excepción.

345
00:30:26,210 --> 00:30:44,650
Este objeto se carga con información que se produce en el contexto del error. Cuando se produce el error en este contexto, se rellena antes de terminar un objeto y ese objeto, si lo estamos capturando, lo tenemos aquí como entrada.

346
00:30:44,650 --> 00:30:54,109
Fijaros que esto se podría considerar como una especie de método. Tiene sus llaves y esto un parámetro de entrada que tiene catch como si fuese un método.

347
00:30:55,529 --> 00:31:00,990
En los métodos, en los parámetros de entrada, en el momento que los llamamos, ponemos nosotros los datos.

348
00:31:00,990 --> 00:31:18,809
no sé si es un método, tenemos aquí un public void a, ponemos int i aquí, pues este i en el momento que llamamos al método a, se lo pasamos justo en la llamada.

349
00:31:18,809 --> 00:31:48,529
Si esto lo consideramos a todos los efectos como si fuese un método y esto es un parámetro de entrada, este objeto E de la clase excepción se cargará cuando sea llamada. ¿Y en qué momento se llama? ¿Lo llamamos nosotros por código o no? Se llama de forma automática por esta característica de ThroughAble, con lo cual en ese momento en el que automáticamente se llama, este objeto se carga con cierta información que tiene datos de lo que está sucediendo en el momento en el que se produce la excepción.

350
00:31:48,809 --> 00:31:51,289
si ponemos aquí un system

351
00:31:51,289 --> 00:31:52,470
aquí

352
00:31:52,470 --> 00:31:55,029
podríamos poner el código que quisiéramos

353
00:31:55,029 --> 00:31:57,009
podríamos dar de alta nuevas clases

354
00:31:57,009 --> 00:31:59,029
acceder a una base de datos para

355
00:31:59,029 --> 00:32:01,269
guardar un registro avisando

356
00:32:01,269 --> 00:32:03,170
que en esta zona de código se ha producido

357
00:32:03,170 --> 00:32:05,170
un error o podemos

358
00:32:05,170 --> 00:32:06,869
poner un system of println para

359
00:32:06,869 --> 00:32:09,069
nuestro seguimiento aquí en nuestro programa de andar

360
00:32:09,069 --> 00:32:11,049
por casa, pero aquí podríamos poner

361
00:32:11,049 --> 00:32:13,190
tanto código como quisiéramos en este

362
00:32:13,190 --> 00:32:20,160
cache, vamos a poner aquí

363
00:32:20,160 --> 00:32:27,099
error, entonces mira si hacemos

364
00:32:27,099 --> 00:32:28,000
una ejecución

365
00:32:28,920 --> 00:32:32,299
que no nos dé error, es decir, no ponemos un cero,

366
00:32:33,599 --> 00:32:37,180
bueno, pues se ejecuta bien y fijaros como este system out de error

367
00:32:37,180 --> 00:32:42,519
no nos lo muestra. Si en cambio provocamos un error,

368
00:32:43,759 --> 00:32:46,500
fijaros como el programa ahora no ha dado

369
00:32:46,500 --> 00:32:50,720
unos mensajes feos de error como antes, pero como se ha

370
00:32:50,720 --> 00:32:54,579
producido el error, ha cogido y nos ha mostrado la gestión que

371
00:32:54,579 --> 00:32:58,880
queremos hacer de ese error que hemos capturado

372
00:32:58,880 --> 00:33:02,920
a través del catch, hemos puesto un system of println error, pues ahí tenemos

373
00:33:02,920 --> 00:33:13,599
fijaros, aquí en la estructura esta, lo que hemos hecho

374
00:33:13,599 --> 00:33:16,640
ha sido capturar una excepción del tipo exception

375
00:33:16,640 --> 00:33:21,460
¿qué sucede si en el catch ponemos exception e?

376
00:33:21,460 --> 00:33:25,240
pues que si se produce en la zona del código

377
00:33:25,240 --> 00:33:29,319
donde tenemos el try, una excepción

378
00:33:29,319 --> 00:33:33,640
de cualquiera de todos estos tipos, me da igual el que sea

379
00:33:33,640 --> 00:33:38,000
el error que va a hacer la captura

380
00:33:38,000 --> 00:33:41,440
del catch, todas estas excepciones, sea la que sea

381
00:33:41,440 --> 00:33:44,900
son de tipo excepción porque están por debajo de ella en el árbol

382
00:33:44,900 --> 00:33:46,960
la arithmetic excepción también es excepción

383
00:33:46,960 --> 00:33:50,720
la index out of bounds excepción también es excepción

384
00:33:50,720 --> 00:33:53,559
todas ellas, entonces cualquiera de ellas

385
00:33:53,559 --> 00:33:56,720
si ponemos solo ese código, al capturarla con excepción

386
00:33:56,720 --> 00:34:01,960
pues nos ejecuta las instrucciones que tengamos

387
00:34:01,960 --> 00:34:04,819
dentro del catch. Fijaros, otra posibilidad

388
00:34:04,819 --> 00:34:08,860
de excepción que tendríamos, voy a provocarla aquí antes

389
00:34:08,860 --> 00:34:12,719
del try para que nos falle el programa y la podamos ver sin capturar

390
00:34:12,719 --> 00:34:16,480
por aquí en la consola, pues imaginemos que tenemos un array

391
00:34:16,480 --> 00:34:25,440
de caracteres que tenga, de caracteres no, de enteros

392
00:34:25,440 --> 00:34:29,199
perdón, que tenga tres posiciones, pues si yo

393
00:34:29,199 --> 00:34:35,769
cojo ahora y digo aquí que quiero que valga 6

394
00:34:35,769 --> 00:34:40,530
aquel entero que en el array esté en la posición 6, pues lógicamente no existe

395
00:34:40,530 --> 00:34:54,849
Si tiene tres posiciones, tendrá la 0, la 1 y la 2. Todo lo que no sea eso, no tendremos reservada en memoria RAM espacio para un elemento de tipo entero asociado a esta array en esa posición.

396
00:34:54,849 --> 00:35:16,289
Entonces si ejecutamos por aquí, bueno me saca este mensajillo, da igual lo que ponga porque se va a producir sí o sí el error aquí, entonces aquí me vuelve a dar una excepción, fijaros como es una excepción y en este caso me está indicando que es array index out of bounds excepción.

397
00:35:16,289 --> 00:35:20,969
excepción. Si nos venimos por aquí, fijaros, se ha producido

398
00:35:20,969 --> 00:35:24,929
esta, index auto points excepción. Diferentes situaciones

399
00:35:24,929 --> 00:35:28,750
en el programa provocan diferentes tipos de excepciones.

400
00:35:29,389 --> 00:35:38,559
Si este código lo pongo aquí, es decir,

401
00:35:38,679 --> 00:35:42,400
no lo dejo a las bravas aquí, que si se produce la excepción me finaliza el programa

402
00:35:42,400 --> 00:35:46,480
y como mucho me saca esta información por aquí, pues si se

403
00:35:46,480 --> 00:35:50,420
produce la excepción ya la capturará y

404
00:35:50,420 --> 00:35:54,039
hará el tratamiento de esa excepción que tengamos puesto en el catch.

405
00:35:54,760 --> 00:35:58,360
Fijaros que aquí el catch está a nivel de excepción,

406
00:35:59,159 --> 00:36:02,019
como os enseñaba antes, está a este nivel, con lo cual cubre

407
00:36:02,019 --> 00:36:06,219
tanto la aritmética excepción como la index out of both excepción,

408
00:36:06,820 --> 00:36:12,599
ambas dos las cubre. Voy a comentar esto para que no se nos

409
00:36:12,599 --> 00:36:18,019
produzca, bueno, no, lo voy a mantener y si ahora ejecuto

410
00:36:18,019 --> 00:36:22,139
por aquí, se me viene aquí esta línea de código,

411
00:36:22,139 --> 00:36:54,769
digo que el número sea un 2, voy a poner un 2 para que no se produzca excepción aquí en esta instrucción, le doy, se ejecuta esto bien, 10 dividido entre 2, 5, me saca el resultado por pantalla, hace esta reserva en el array y en el momento de este acceso se produce la excepción in this auto bounce exception, que lo que ha provocado como está dentro de un trade y el cache que tenemos es este, pues me ha sacado el system of println error, aquí lo tenéis.

412
00:37:00,739 --> 00:37:25,380
Otra cosita os cuento, fijaros, voy a comentar esto para que no se produzca esta excepción y tenemos solamente candidato para excepción esta parte de código, esta parte de código en el caso de que por teclado metamos un 0.

413
00:37:26,579 --> 00:37:43,909
Hacemos una ejecución normal, sabiendo que los datos no nos van a provocar excepción, pongo un 2, me da el resultado un 5, hace esta reserva que en realidad no lo estoy utilizando, de hecho me lo está chivando aquí yo creo, no es usada esta variable.

414
00:37:44,570 --> 00:37:51,170
Como no tengo esto, lo tengo comentado, no se produce la excepción, no se viene por error y luego me saca el mensaje terminando el programa.

415
00:37:51,550 --> 00:37:53,789
Bueno, todo lo razonable hasta aquí todo.

416
00:37:57,050 --> 00:38:04,590
Si yo le pongo aquí un cero, bueno, pues vuelve a suceder algo parecido, pero se me viene por el error.

417
00:38:05,150 --> 00:38:09,190
Y luego ya, una vez hecho eso, se viene aquí al terminando el programa.

418
00:38:09,190 --> 00:38:37,199
Mira, si yo cojo y pongo aquí un mensaje que sea terminando el try, ejecuto, vuelvo a poner un código, un valor 2 que no me provoca el error, pues bueno, hace todo, me dice terminando el try, no me muestra el error y luego dice terminando el programa.

419
00:38:37,199 --> 00:38:56,980
Y ahora hago una ejecución provocando un error y fijaros que cuando tenemos cierto código dentro de un try, en el momento en el que se produce una excepción, el resto del código que tenemos por delante ya no se ejecuta, que sería todo este en este caso.

420
00:38:56,980 --> 00:39:00,440
directamente se viene al catch y una vez que termina el catch

421
00:39:00,440 --> 00:39:03,559
continúa el programa, como ahora no me ha mostrado

422
00:39:03,559 --> 00:39:06,739
el terminando el try ya que se ha producido la excepción

423
00:39:06,739 --> 00:39:09,260
en este momento y lo que ha hecho ha sido

424
00:39:09,260 --> 00:39:12,679
dirigirse la ejecución del código aquí al catch

425
00:39:12,679 --> 00:39:15,280
me ha mostrado el error, ha terminado el catch

426
00:39:15,280 --> 00:39:18,139
y el programa continúa, fijaros como

427
00:39:18,139 --> 00:39:21,099
al haber hecho una gestión de captura de la excepción

428
00:39:21,099 --> 00:39:24,199
el programa no ha terminado de golpe como sucedía

429
00:39:24,199 --> 00:39:28,099
antes cuando no hacíamos esta gestión, que ya el código que hubiera por delante

430
00:39:28,099 --> 00:39:32,139
no lo ejecutaba. En este caso, una vez que se ha producido el error

431
00:39:32,139 --> 00:39:36,039
es verdad que esta parte del código no la ejecuta. Aquí tenemos una zona

432
00:39:36,039 --> 00:39:39,800
de código donde deberíamos intentar estabilizar el programa.

433
00:39:40,360 --> 00:39:44,139
Si han pasado cosas que lo deja el programa instable en lo que se ha

434
00:39:44,139 --> 00:39:48,059
ejecutado por aquí arriba, ya que el resto de código no se ha ejecutado

435
00:39:48,059 --> 00:39:51,940
vamos a dejarlo estable. Y luego posteriormente

436
00:39:51,940 --> 00:39:54,460
después del catch, el programa sin terminar

437
00:39:54,460 --> 00:39:56,500
continúa. Esto nos daría

438
00:39:56,500 --> 00:39:58,519
garantías en ese supuesto

439
00:39:58,519 --> 00:39:59,619
cajero que os decía

440
00:39:59,619 --> 00:40:02,480
del que el programa iba a seguir ejecutándose

441
00:40:02,480 --> 00:40:03,099
igual que

442
00:40:03,099 --> 00:40:06,260
y en cambio si no hacemos el

443
00:40:06,260 --> 00:40:08,340
trade catch, el programa finalizaría y no

444
00:40:08,340 --> 00:40:09,639
se ejecutaría más.

445
00:40:12,800 --> 00:40:14,800
Mirad, cuando ponemos

446
00:40:14,800 --> 00:40:16,579
los catch

447
00:40:16,579 --> 00:40:18,760
hemos utilizado un catch

448
00:40:18,760 --> 00:40:20,739
común a este

449
00:40:20,739 --> 00:40:22,780
nivel de la clase exception que nos recoge

450
00:40:22,780 --> 00:40:29,880
todas estas, pero podría ser que nosotros quisiéramos hacer cosas diferentes en función del posible error que se dé.

451
00:40:30,719 --> 00:40:37,840
En nuestro programa podríamos decir, mira, si se produce una visión por cero, yo quiero guardar un mensaje de error

452
00:40:37,840 --> 00:40:47,699
en un fichero que se llama ceros.txt y si se produce en mi programa un error de un acceso, una raya, una posición

453
00:40:47,699 --> 00:40:50,519
para la que no hemos hecho reserva, pues a lo mejor quiero

454
00:40:50,519 --> 00:40:53,139
guardar información en un fichero que sea

455
00:40:53,139 --> 00:40:55,920
Arrays.txt

456
00:40:55,920 --> 00:40:59,559
Aquí que es lo que está pasando, que tanto si se produce una

457
00:40:59,559 --> 00:41:02,519
como si se produce otra, si les comentamos

458
00:41:02,519 --> 00:41:05,500
esta y pasa esta, nos vamos

459
00:41:05,500 --> 00:41:07,500
a un catch que es común

460
00:41:07,500 --> 00:41:10,199
ya que estamos capturando exception

461
00:41:10,199 --> 00:41:14,519
y en ambos casos hemos tenido el mensaje

462
00:41:14,519 --> 00:41:16,820
System.out.ln error

463
00:41:17,719 --> 00:41:25,840
¿Qué sucede? Que tenemos la posibilidad de sacar mensajes diferentes en función de si lo que capturamos es de un tipo o es de otro.

464
00:41:26,699 --> 00:41:38,599
Si nosotros podemos encadenar a un try más de un catch y en cada uno de estos catch tener una consideración diferente a la hora de procesarlo.

465
00:41:38,900 --> 00:41:41,039
Por ejemplo, escribir en un fichero el error o en otro.

466
00:41:41,039 --> 00:42:20,409
Si en lugar de poner aquí exception, yo cojo y pongo arithmetic exception, si lo que se produce ahora es un arithmetic exception, tengo la posibilidad de, en este catch, hacer un procesamiento diferente a si se produce cualquier otra excepción, dependiendo del código que ponga yo aquí.

467
00:42:20,409 --> 00:42:49,639
entonces yo ahora ejecuto, la arithmetic exception se produce cuando hacemos aquí una división por cero, recordad, estoy provocando aquí, si aquí no meto un cero, el código va a darme excepción aquí por este acceso a la posición 6 de un array para el cual solo hemos reservado tres enteros, entonces aquí sin provocar error de arithmetic exception, fijaros como el procesamiento que me sigue haciendo es el de error, por pantalla,

468
00:42:49,639 --> 00:43:11,260
Y ahora si cojo y aquí meto un 0 para provocar arithmetic exception, fijaros cómo ahora ya lo que hace es, bueno, pues me saca este mensajito de error. Error arithmetic exception. Es decir, he hecho un procesamiento diferente en función de la excepción que estoy gestionando.

469
00:43:11,260 --> 00:43:29,889
Las excepciones, las capturas de las excepciones hay que ponerlas, hay que poner en el momento que se ejecuta la captura de una excepción el resto ya no se ejecuta. Fijaros que la aritmética excepción también es una excepción.

470
00:43:29,889 --> 00:43:35,630
viendo aquí el árbol aritmética excepción también es excepción

471
00:43:35,630 --> 00:43:39,869
cuelga de ella pero en el momento que se ha capturado como aritmética

472
00:43:39,869 --> 00:43:43,809
excepción esta ya no se considera es decir cuando se produce

473
00:43:43,809 --> 00:43:47,750
una excepción en un try en orden según

474
00:43:47,750 --> 00:43:51,829
aparezcan en la ejecución irá evaluando a ver si la

475
00:43:51,829 --> 00:43:55,670
excepción que se ha producido corresponde a una y cuando corresponde a esa

476
00:43:55,670 --> 00:43:59,730
la ejecuta y una vez que ejecuta esa el resto de catch ya no

477
00:43:59,730 --> 00:44:06,219
los tiene en consideración. Aquí hemos puesto la aritmética excepción, la otra que se nos había

478
00:44:06,219 --> 00:44:09,900
dado era la de index out of bounds

479
00:44:09,900 --> 00:44:14,119
excepción. Para no cometer error, vamos a hacerlo

480
00:44:14,119 --> 00:44:18,219
así, mirad. Y así, con toda seguridad

481
00:44:18,219 --> 00:44:22,900
la voy a poner ahí, un momento fuera del try

482
00:44:22,900 --> 00:44:29,539
y así no lo escribo mal. Aquí lo tengo

483
00:44:29,539 --> 00:44:32,380
bueno, lo he hecho esto para hacer ahora copy-paste

484
00:44:32,380 --> 00:44:49,559
lo copio, lo voy a pegar ahí de momento, voy a hacer un try cast de nuevo y de la excepción, ahora le digo aquí animatic autoboss excepción.

485
00:44:49,679 --> 00:44:55,119
Entonces, ¿qué sucederá? Ya quito esto de aquí, que solamente lo había puesto para que me saliera el mensaje aquí.

486
00:44:55,119 --> 00:44:58,400
fijaros como en esta ejecución que lo tenía fuera del try

487
00:44:58,400 --> 00:45:01,280
el programa se rompe por completo

488
00:45:01,280 --> 00:45:03,739
y al contrario que cuando capturamos las excepciones

489
00:45:03,739 --> 00:45:07,159
no sigue ejecutando, no nos ha sacado el mensaje terminando programa

490
00:45:07,159 --> 00:45:10,480
que es lo que nos viene pasando hasta que hemos empezado

491
00:45:10,480 --> 00:45:13,880
a trabajar hoy justo con la captura de excepciones

492
00:45:13,880 --> 00:45:16,480
para controlar errores en el código

493
00:45:16,480 --> 00:45:18,920
bueno pues ahora

494
00:45:18,920 --> 00:45:23,719
¿qué estamos haciendo? le hemos puesto un catch

495
00:45:23,719 --> 00:45:27,400
para la arithmetic exception, si se produce una de estas

496
00:45:27,400 --> 00:45:31,699
le valdrá este catch, se dará cuenta y hará esta ejecución

497
00:45:31,699 --> 00:45:35,320
si en cambio la excepción que se produce es

498
00:45:35,320 --> 00:45:39,300
de que nos hemos ido fuera del índice en un array

499
00:45:39,300 --> 00:45:43,940
pues no cuadrará con una arithmetic exception, en cambio cuadrará con esta

500
00:45:43,940 --> 00:45:48,119
y el mensaje será este, es decir, en una situación podemos hacer una gestión del error

501
00:45:48,119 --> 00:45:50,719
que codificaremos aquí cuando sea aritmética

502
00:45:50,719 --> 00:45:54,739
y cuando sea que la RAI se va fuera de rango lo podremos gestionar aquí.

503
00:45:55,480 --> 00:46:03,559
Y aún así podemos poner una excepción general aquí por si la excepción que se produce no es ni aritmética ni de índice fuera de rango,

504
00:46:03,559 --> 00:46:13,559
no es ninguna de estas dos, en todos estos casos la gestión que se haría para la excepción sería la que pongamos a nivel general de excepción.

505
00:46:13,559 --> 00:46:29,579
y la por ahí o tengo que salvar salvo algo que no se dé error aritmético en la excepción como

506
00:46:29,579 --> 00:46:36,639
no es aritmético no me ha mostrado el aritmético ahora es que he puesto el mensaje en los dos

507
00:46:36,639 --> 00:46:46,400
aquí a raíz fuera de rango ejecutó de nuevo algo que no sea aritmética entonces no ha entrado por

508
00:46:46,400 --> 00:46:54,159
aquí no me mostró este mensaje entra por esta y me muestra este y luego existen otra etiqueta

509
00:46:54,159 --> 00:47:06,119
que la etiqueta si no recuerdo mal finally cuando se les en esta podemos poner aquí también un

510
00:47:06,119 --> 00:47:12,159
cierto código que se ejecutará por lo que creo recordar siempre y siempre es siempre tanto si

511
00:47:12,159 --> 00:47:21,139
funciona el try como si se produce una excepción y nos vamos por el catch pues para que nos podría

512
00:47:21,139 --> 00:47:26,280
servir esto pues imaginaros que yo que sé qué deciros que en todos los casos aunque aquí lo

513
00:47:26,280 --> 00:47:31,800
tenemos cerrando el escáner queremos cerrar el escáner pero no lo hacemos aquí pues sería una

514
00:47:31,800 --> 00:47:38,920
cosa podríamos poner aquí si el programa va bien yo voy a querer que se cierre el escáner con lo

515
00:47:38,920 --> 00:47:43,980
cual hará el try completo sin irse por ningún catch pero si se va por un catch también ejecuta

516
00:47:43,980 --> 00:47:52,000
el final y para probarlo vamos a meter un mensajito para que no lo muestren por consola

517
00:47:52,000 --> 00:48:08,460
pasando por final y les hacemos aquí una ejecución vamos a hacer voy a parar un segundo voy a quitar

518
00:48:08,460 --> 00:48:14,380
para que no de error la primera vez porque es que con esto me va de error sí o sí bueno para

519
00:48:14,380 --> 00:48:19,119
que no me de error mira voy a hacer el acceso a la posición 2 que sí que existe con la reserva

520
00:48:19,119 --> 00:48:26,699
de memoria entonces le digo aquí un 2 y mira ha ido correcto ha terminado el programa ha terminado

521
00:48:26,699 --> 00:48:54,250
el try y dice terminando el programa, hago una ejecución por cero, en este caso se produce una excepción aritmética, me dice que pasa por finally, la ejecución ha venido por aquí, no ha completado, ya que se produce aquí la excepción aritmética, no continúa en el try, no me muestra el terminando el try,

522
00:48:54,250 --> 00:48:57,190
es de tipo aritmético la excepción

523
00:48:57,190 --> 00:48:58,670
con lo cual la captura este catch

524
00:48:58,670 --> 00:49:00,750
me muestra este mensaje

525
00:49:00,750 --> 00:49:03,309
y luego el finally como se ejecuta siempre

526
00:49:03,309 --> 00:49:04,849
pues me lo muestra

527
00:49:04,849 --> 00:49:06,730
y una vez que terminan los catch

528
00:49:06,730 --> 00:49:09,369
el programa sigue ya que hemos capturado la excepción

529
00:49:09,369 --> 00:49:11,250
y me muestra el terminando

530
00:49:11,250 --> 00:49:14,900
el programa y bueno por

531
00:49:14,900 --> 00:49:16,880
completar la jugada con estas

532
00:49:16,880 --> 00:49:18,880
excepciones que tenemos puestas aquí voy a meter

533
00:49:18,880 --> 00:49:20,920
un valor diferente de 0 para que aquí no

534
00:49:20,920 --> 00:49:23,119
de error pero este me dará

535
00:49:23,119 --> 00:49:24,679
un array index

536
00:49:24,679 --> 00:49:31,010
autobounce excepción. Ahí lo tenéis y vuelve a ejecutar el

537
00:49:31,010 --> 00:49:39,570
finally. Bueno, las

538
00:49:39,570 --> 00:49:43,289
diferentes excepciones podemos intentar provocar algunas

539
00:49:43,289 --> 00:49:47,409
de ellas. Mira, si creamos, vamos a crear

540
00:49:47,409 --> 00:49:51,449
otra clase, vamos a crear, vamos a provocar algunas excepciones más

541
00:49:51,449 --> 00:49:54,769
que vamos a llamar

542
00:49:54,769 --> 00:49:59,369
manejo el cep. Y ya esta clase me va a

543
00:49:59,369 --> 00:50:03,389
servir luego para enseñaros alguna cosa más. Bueno, aquí

544
00:50:03,389 --> 00:50:08,090
tenemos una clase que está en el proyecto, en el mismo paquete

545
00:50:08,090 --> 00:50:19,139
default. Entonces aquí podríamos coger y decir, vamos a definir

546
00:50:19,139 --> 00:50:27,780
un objeto B igual a nul. No le hago un new. Aquí vamos a poner

547
00:50:27,780 --> 00:50:33,679
un int y valor. Vamos a definirle un atributo de tipo entero

548
00:50:33,679 --> 00:50:37,320
a esta clase, esta clase tendría sus métodos, sus atributos

549
00:50:37,320 --> 00:50:41,400
entonces si yo pongo aquí b.yvalor igual a 5

550
00:50:41,400 --> 00:50:44,820
¿qué sucede? que para b no he hecho

551
00:50:44,820 --> 00:50:49,539
un new, con lo cual no hay reserva de memoria para sus valores

552
00:50:49,539 --> 00:50:53,320
ni para, no hay reserva, no hay gestión de memoria

553
00:50:53,320 --> 00:50:56,039
para los recursos que necesita el objeto b

554
00:50:56,039 --> 00:51:01,380
en cambio estoy intentando acceder a uno de sus valores por aquí, entonces ¿qué sucede con el

555
00:51:01,380 --> 00:51:12,050
programa de aquí un valor 3 fijaros que en este caso me vuelve a dar una excepción por este motivo

556
00:51:12,050 --> 00:51:30,070
que es la excepción null pointer excepción null pointer excepción aquí la tenemos si este código

557
00:51:30,070 --> 00:51:35,389
no lo traemos aquí es decir que ha sucedido que como lo teníamos fuera del try pues el programa

558
00:51:35,389 --> 00:51:42,449
ha finalizado lo mismo que nos viene pasando termina de golpe no se sigue ejecutando fijaros

559
00:51:42,449 --> 00:51:46,409
como no ha salido el mensaje, la misma idea que antes, si lo meto dentro de un try

560
00:51:46,409 --> 00:51:50,110
pues pongo los catch por aquí que van a hacer la gestión

561
00:51:50,110 --> 00:51:54,429
de esa excepción igual que del resto, la excepción

562
00:51:54,429 --> 00:51:58,190
null pointer exception no la he metido como un caso particular dentro de los catch

563
00:51:58,190 --> 00:52:02,130
con lo cual estará considerada en principio dentro de él la categoría

564
00:52:02,130 --> 00:52:06,570
exception, con lo cual esa captura me dará un println error

565
00:52:06,570 --> 00:52:12,960
pues hago una ejecución por aquí

566
00:52:12,960 --> 00:52:17,280
fijaros como me ha dejado el error y pasa por el

567
00:52:17,280 --> 00:52:20,940
finally, bueno pues otro tipo de excepción que podemos manejar aquí

568
00:52:20,940 --> 00:52:25,320
lo está provocando el hecho de que no hayamos reservado memoria

569
00:52:25,320 --> 00:52:28,679
para este objeto, pues si hacemos un new, manejo

570
00:52:28,679 --> 00:52:37,889
le reservamos memoria como siempre, si ahora le damos aquí a la ejecución

571
00:52:37,889 --> 00:52:42,289
fijaros como ya no ha saltado

572
00:52:42,289 --> 00:52:44,929
excepción aquí en este acceso, como es lógico

573
00:52:44,929 --> 00:52:49,570
me ha saltado, excepción aquí, de hecho la excepción que me ha capturado

574
00:52:49,570 --> 00:52:53,769
es la de array index outbound excepción que es esta

575
00:52:53,769 --> 00:52:56,429
o el acceso a la posición del array

576
00:52:56,429 --> 00:53:06,250
para la cual no hemos hecho reserva, pero esta ya no, mirad otro tipo de excepción

577
00:53:06,250 --> 00:53:11,630
yo creo que se produce cuando tenemos por ejemplo un objeto

578
00:53:11,630 --> 00:53:15,849
de la clase scanner, intentamos hacer una lectura, un objeto de la clase scanner

579
00:53:15,849 --> 00:53:18,329
cerrado, si hacemos aquí un next line

580
00:53:18,329 --> 00:53:23,030
es decir, intentamos leer de un flujo de datos que está asociado

581
00:53:23,030 --> 00:53:27,150
a un objeto de la clase Scanner cuando el

582
00:53:27,150 --> 00:53:31,030
flujo de datos está ya cerrado, es decir, esa tubería que os decía que pinchábamos

583
00:53:31,030 --> 00:53:34,690
en un extremo y el otro extremo de nuestro programa ha desaparecido esa tubería

584
00:53:34,690 --> 00:53:38,469
entonces si intentamos leer a través de esa tubería, pues no existe

585
00:53:38,469 --> 00:53:45,619
nos debería dar un error. Lo voy a poner fuera del try

586
00:53:45,619 --> 00:53:52,679
fijaros, entonces aquí el programa va bien por completo

587
00:53:52,679 --> 00:53:56,559
y en este caso, bueno, aquí me chiva un poco el mensaje

588
00:53:56,559 --> 00:53:59,139
y me dice

589
00:53:59,139 --> 00:54:02,960
Illegal State Exception, que es otra de las que andan por aquí

590
00:54:02,960 --> 00:54:09,809
o Illegal, no, pues esta justo no está, bueno, es incompleto

591
00:54:09,809 --> 00:54:13,690
por lo que veo este dibujo, ¿vale? Bueno, pues en diferentes

592
00:54:13,690 --> 00:54:18,130
circunstancias tenemos diferentes tipos de excepciones

593
00:54:18,130 --> 00:54:28,440
vamos a hacer una cosa

594
00:54:28,440 --> 00:54:44,320
escáner para probarla capturándola y pasamos a otra cosa ya sigo contando claro lo que estoy

595
00:54:44,320 --> 00:54:55,000
haciendo aquí es bueno utilizo el escáner y scan close lo cierro el escáner es decir aquí ya está

596
00:54:55,000 --> 00:55:00,260
cerrado y aquí pero metiéndolo dentro del try intento hacer el next line para evitar que el

597
00:55:00,260 --> 00:55:10,829
programa termine ya que lo estoy capturando con el try salvo por aquí y bueno pues ahora este el

598
00:55:10,829 --> 00:55:14,750
tipo de excepción que se produce en la excepción que se produce aquí como no la tengo capturada

599
00:55:14,750 --> 00:55:22,019
en particular se me viene por el excepción y me da un error bueno así para diferentes diferentes

600
00:55:22,019 --> 00:55:29,730
excepciones se producen en diferentes situaciones continuamos mirad os decía que cuando se produce

601
00:55:29,730 --> 00:55:35,239
una excepción y si consideramos los catch

602
00:55:35,239 --> 00:55:38,440
como posibles métodos, estos catch están recibiendo aquí

603
00:55:38,440 --> 00:55:43,320
un objeto. En este caso es un objeto de la clase

604
00:55:43,320 --> 00:55:46,920
arithmeticException y claro, si lo consideramos como

605
00:55:46,920 --> 00:55:50,960
una especie de método, en el momento en el que se lanza con el

606
00:55:50,960 --> 00:55:55,199
throughAble este el catch, ese objeto se tendrá que pasar

607
00:55:55,199 --> 00:55:58,579
información relativa a él y antes de lanzarlo se coge

608
00:55:58,579 --> 00:56:01,579
información relativa al contexto en el cual

609
00:56:01,579 --> 00:56:03,380
se produce esa excepción.

610
00:56:10,449 --> 00:56:12,530
Mira, por aquí para el arithmetic exception

611
00:56:12,530 --> 00:56:14,630
si yo pongo un System.out.println

612
00:56:14,630 --> 00:56:23,380
de E, no sé si recordáis que en algún

613
00:56:23,380 --> 00:56:25,400
momento os he contado que cuando ponemos

614
00:56:25,400 --> 00:56:27,079
algo dentro del

615
00:56:27,079 --> 00:56:32,579
el método println de la clase System.out

616
00:56:32,579 --> 00:56:33,679
que es el flujo de salida

617
00:56:33,679 --> 00:56:38,219
lo que hace es mostrar una cadena de caracteres que tengamos

618
00:56:38,219 --> 00:56:42,219
aquí, pero aquí no siempre ponemos cadenas de caracteres, a veces ponemos

619
00:56:42,219 --> 00:56:45,960
int i, int i a y ponemos aquí

620
00:56:45,960 --> 00:57:09,360
más i a. Bueno, lo quito, se me queja

621
00:57:09,360 --> 00:57:13,300
al mezclarlo con la e. Bueno, a lo que voy es que ponemos aquí i a, ¿veis?

622
00:57:14,039 --> 00:57:17,460
Entonces, si println espera aquí una

623
00:57:17,460 --> 00:57:21,139
cadena de caracteres, ¿por qué me acepta meter un i a?

624
00:57:21,139 --> 00:57:25,039
Pues cuando estamos trabajando con el método println, cualquier

625
00:57:25,039 --> 00:57:27,340
cosa que pongamos aquí, lo que hace es buscar

626
00:57:27,340 --> 00:57:33,539
su método, lo que tenga

627
00:57:33,539 --> 00:57:36,380
el método, ¿qué método era? A ver un momentito

628
00:57:36,380 --> 00:57:38,519
que lo tengo por aquí apuntado creo en algún sitio

629
00:57:38,519 --> 00:57:41,780
toString, sí, toString, no me acordaba

630
00:57:41,780 --> 00:57:46,800
toda clase tiene un método toString

631
00:57:46,800 --> 00:57:50,699
que es el que se llama para

632
00:57:50,699 --> 00:57:53,880
convertir cualquier tipo de objeto, sea del tipo que sea

633
00:57:53,880 --> 00:57:56,960
en este caso entero, a una cadena de caracteres

634
00:57:56,960 --> 00:57:59,320
este método devuelve, es como si tuviéramos

635
00:57:59,320 --> 00:58:03,699
un public string, devuelve un string

636
00:58:03,699 --> 00:58:07,820
toString y ahora aquí en el código

637
00:58:07,820 --> 00:58:11,239
tendrá que haber un return de algo que sea un string.

638
00:58:14,079 --> 00:58:18,079
Entonces al ponerlo aquí es como si estuviéramos poniendo i.toString

639
00:58:18,079 --> 00:58:21,519
llamará al método ese.

640
00:58:22,440 --> 00:58:25,679
Vendría a ser algo equivalente así. Ahora después cuando hagamos

641
00:58:25,679 --> 00:58:30,960
una excepción personalizada lo veréis. Y dentro

642
00:58:30,960 --> 00:58:36,860
de este método cada clase habrá codificado aquí lo que queramos que se devuelva como una cadena

643
00:58:36,860 --> 00:58:43,480
de caracteres en relación a ese método si nosotros ponemos aquí que lo que queremos es que se nos

644
00:58:43,480 --> 00:58:52,420
muestre en el sistema println el objeto e lo que estará haciendo es utilizar el código que tenga

645
00:58:52,420 --> 00:59:00,980
el método toString de la clase ArithmeticException para devolverlo como un string y que lo pueda

646
00:59:00,980 --> 00:59:10,570
mostrar System.out.println. Vamos a ver qué es lo que nos muestra. Ponemos aquí un 0 para que se

647
00:59:10,570 --> 00:59:26,739
produzca una ArithmeticException y me ha dado error porque se ha producido esta, ¿no? ¿Por qué me ha dado error?

648
00:59:26,739 --> 00:59:33,489
este es ArithmeticException al dividir por 0

649
00:59:33,489 --> 00:59:43,639
se ha venido por aquí

650
00:59:43,639 --> 00:59:45,880
en lugar de venir por aquí

651
00:59:45,880 --> 00:59:51,320
ArithmeticException, println

652
00:59:51,320 --> 00:59:58,719
a ver, la voy a provocar

653
00:59:58,719 --> 01:00:01,380
ah bueno, bien, se ha producido

654
01:00:01,380 --> 01:00:02,679
bien, se ha venido por error

655
01:00:02,679 --> 01:00:06,420
porque la excepción se ha producido en esta línea

656
01:00:06,420 --> 01:00:10,059
del escáner que teníamos aquí cerrado

657
01:00:10,059 --> 01:00:12,619
por eso no ha provocado una ArithmeticException

658
01:00:12,619 --> 01:00:13,599
de división por 0

659
01:00:13,599 --> 01:00:16,019
y se ha venido por el catch este del error

660
01:00:16,019 --> 01:00:17,980
ya que ha sido esta línea la que ha

661
01:00:17,980 --> 01:00:19,480
provocado la excepción

662
01:00:19,480 --> 01:00:20,820
la comento

663
01:00:20,820 --> 01:00:25,710
divido por cero y ahora

664
01:00:25,710 --> 01:00:27,849
si se produce la aritmética excepción

665
01:00:27,849 --> 01:00:29,929
y fijaros

666
01:00:29,929 --> 01:00:31,489
que lo que me muestra

667
01:00:31,489 --> 01:00:32,969
el sistema of println

668
01:00:32,969 --> 01:00:35,530
de este objeto ha sido

669
01:00:35,530 --> 01:00:37,750
este mensaje java lang aritmética

670
01:00:37,750 --> 01:00:39,710
excepción división by cero

671
01:00:39,710 --> 01:00:41,809
¿por qué tiene este dato

672
01:00:41,809 --> 01:00:43,690
el aritmética excepción? pues lo tiene

673
01:00:43,690 --> 01:00:48,170
porque se ha cargado en el objeto E cierta información.

674
01:01:03,480 --> 01:01:11,440
Mira, si yo, como os decía, cuando ponemos algo aquí es equivalente a llamar al método toString de ese objeto.

675
01:01:11,440 --> 01:01:15,539
Eso pasa siempre en el println, no solo para las excepciones, sino en cualquier caso.

676
01:01:16,139 --> 01:01:21,900
Entonces, si yo ejecuto ahora la visión por cero, fijaros cómo poner el system.out.println de E

677
01:01:21,900 --> 01:01:25,260
es lo mismo que poner el System.out.println.de.toString

678
01:01:25,260 --> 01:01:27,019
con la llamada a este método.

679
01:01:27,519 --> 01:01:29,760
¿Veis que aparece aquí por duplicado ese código?

680
01:01:31,059 --> 01:01:33,199
Un poco por justificar lo que os decía antes.

681
01:01:34,599 --> 01:01:37,239
Y otro método que tiene las excepciones

682
01:01:37,239 --> 01:01:40,139
es el método getMessage.

683
01:01:41,619 --> 01:01:43,039
Vamos a hacer una ejecución

684
01:01:43,039 --> 01:01:45,380
con el método getMessage

685
01:01:45,380 --> 01:01:47,380
para que veáis el contenido,

686
01:01:47,900 --> 01:01:49,380
lo que nos devuelve el getMessage.

687
01:01:49,380 --> 01:01:53,639
fijaros, el método getMessage es parte

688
01:01:53,639 --> 01:01:57,960
de lo que nos devuelve el toString, que es esta descripción

689
01:01:57,960 --> 01:02:01,920
es decir, el toString devuelve el tipo de excepción que se da

690
01:02:01,920 --> 01:02:05,320
dos puntos y luego un mensaje indicando

691
01:02:05,320 --> 01:02:08,840
el motivo de la excepción, entonces si utilizáis el método getMessage

692
01:02:08,840 --> 01:02:13,500
te devuelve sin indicar la clase el mensaje

693
01:02:13,500 --> 01:02:17,679
bueno, métodos que tenemos disponibles en todo tipo de excepciones

694
01:02:17,679 --> 01:02:21,119
que se cargan en el objeto

695
01:02:21,119 --> 01:02:25,719
que recibimos como parámetro de entrada, considerando

696
01:02:25,719 --> 01:02:29,199
el cache como si fuera un método, cuya información

697
01:02:29,199 --> 01:02:33,679
nos viene de forma automática, no la ponemos

698
01:02:33,679 --> 01:02:37,619
nosotros, en el momento en el que se lanza la excepción

699
01:02:37,619 --> 01:02:40,579
ya que es de tipo throughable, como hemos visto aquí.

700
01:02:49,349 --> 01:02:53,670
Resumiendo por un momento, antes de pasar a la siguiente cosa que os voy a contar.

701
01:02:53,670 --> 01:02:58,010
en nuestro programa se pueden dar errores de compilación

702
01:02:58,010 --> 01:03:01,030
que los tenemos resueltos antes de tener un ejecutable

703
01:03:01,030 --> 01:03:04,110
suelen ser de sintaxis, una vez salvados estos

704
01:03:04,110 --> 01:03:07,349
los programas ya corren, pero pueden darse situaciones

705
01:03:07,349 --> 01:03:10,130
en las cuales durante una ejecución

706
01:03:10,130 --> 01:03:13,130
se produzcan ciertos errores

707
01:03:13,130 --> 01:03:16,230
que no corresponden a la sintaxis sino al momento particular

708
01:03:16,230 --> 01:03:19,050
de la ejecución, como aquí en el escáner metamos un 0

709
01:03:19,050 --> 01:03:22,150
eso produce ciertas excepciones que provocan que el programa

710
01:03:22,150 --> 01:03:25,690
se rompa. Si queremos evitar que el programa se rompa,

711
01:03:26,150 --> 01:03:30,010
tenemos que decirle que vamos a intentar esa zona de código a sabiendas

712
01:03:30,010 --> 01:03:34,030
de que podrían llegar a producirse ciertas excepciones. Si se produce

713
01:03:34,030 --> 01:03:36,789
la excepción, como estamos en el modo de intentarlo,

714
01:03:38,469 --> 01:03:40,949
las capturamos y aquí no resolvemos

715
01:03:40,949 --> 01:03:44,750
el problema de que la división por cero no se pueda gestionar. De hecho, el programa

716
01:03:44,750 --> 01:03:48,650
todo este trozo tenemos que tener en cuenta que no se va a ejecutar si se produce

717
01:03:48,650 --> 01:03:52,889
la excepción. Pero sí que nos permite, por un lado, poner el código

718
01:03:52,889 --> 01:03:56,530
que toque, que aquí estamos poniendo solo System.out para estabilizar el programa

719
01:03:56,530 --> 01:04:00,610
y por otro tener la garantía que después de hacerse el catch, nuestro programa no

720
01:04:00,610 --> 01:04:04,909
terminará y seguiremos aquí con el control de él. Ahora estamos mostrando solo un mensaje

721
01:04:04,909 --> 01:04:08,210
pero si esto lo metiéramos dentro de un while, pues

722
01:04:08,210 --> 01:04:12,449
ante un intento de error nos mostraría el catch y el while por aquí

723
01:04:12,449 --> 01:04:16,610
nos volvería al código para seguir trabajando sobre esta misma zona de código incluso.

724
01:04:23,510 --> 01:04:25,349
Si os surgen dudas, me avisáis, ¿vale?

725
01:04:28,070 --> 01:04:34,730
Mirad, ahí en la teoría os aparecen también lo que son las excepciones personalizadas.

726
01:04:34,829 --> 01:04:36,449
Vamos a repasarlas un poquito.

727
01:04:36,449 --> 01:04:49,380
En Java, en todo programa, se consideran ciertas situaciones excepcionales, excepciones que son comunes a todo programa que tengamos en Java.

728
01:04:49,579 --> 01:04:55,239
Da igual que sea un programa relacionado en un contexto o en otro.

729
01:04:55,239 --> 01:04:59,440
si se produce una división por cero, pues eso es ingestionable

730
01:04:59,440 --> 01:05:03,079
por parte del programa, con lo cual se producirá una aritmética excepción

731
01:05:03,079 --> 01:05:06,940
como es un caso claro que se produce el 100% de las veces

732
01:05:06,940 --> 01:05:10,840
por dentro de la arquitectura en árbol de clases de Java

733
01:05:10,840 --> 01:05:15,199
han definido la aritmética excepción y nos dan la posibilidad de controlarla

734
01:05:15,199 --> 01:05:18,619
como hemos estado viendo. Si accedemos a un

735
01:05:18,619 --> 01:05:22,780
a una posición para la cual no hemos hecho reserva de memoria

736
01:05:22,780 --> 01:05:26,079
pues pasa exactamente lo mismo, el 100% de los programas

737
01:05:26,079 --> 01:05:30,599
tendrán esa casuística y si se da eso, como no hemos hecho reserva de memoria

738
01:05:30,599 --> 01:05:34,579
todos ellos fallarán, pues como todos ellos fallan, vamos a tenerlo en consideración

739
01:05:34,579 --> 01:05:38,639
en las librerías de Java y ya te lo dejo dentro de esta

740
01:05:38,639 --> 01:05:42,599
estructura de árbol de excepciones. Pero luego

741
01:05:42,599 --> 01:05:46,340
podemos considerar nosotros, en nuestros programas en particular, situaciones

742
01:05:46,340 --> 01:05:49,179
excepcionales que no lo son para todos los casos

743
01:05:49,179 --> 01:06:06,179
Y bueno, pues en ese contexto podemos tener en cuenta las excepciones que me parece que es de la que os habla en la teoría. Yo que sé, en el contexto de una aerolínea de aviones que no quiere vender la fila 13, pues bueno, porque son supersticiosos.

744
01:06:06,179 --> 01:06:25,139
Entonces, si vas a hacer una reserva y dar un valor de número 13 a la línea, a la fila en la que vas a vender los asientos, pues tú en tu programa quieres que se gestione como una excepción, igual que está pasando aquí en la aritmética excepción, porque es algo que no es aceptable en tu programa.

745
01:06:25,139 --> 01:06:50,219
Pero obviamente no puedes considerar el 13 como una excepción en todo programa porque es un número igualmente válido en el 99,9999% de los casos. Es un valor más. Con lo cual, no ha lugar el definir una excepción global para ese caso, con lo cual no está recogido en la librería de Java, pero sí puedo yo considerarlo en mi programa en particular.

746
01:06:50,219 --> 01:07:09,630
Mira, cuando se produce una excepción, lo que estamos haciendo es utilizar, a través del throughable este, se lanza el catch y se le pasa un objeto de una clase que es aritmética excepción que está en las librerías.

747
01:07:09,630 --> 01:07:23,150
Si nosotros queremos considerar una excepción particular, lo que haremos será definir nuestra propia clase en nuestro programa, independiente de las que ya están en las librerías, y gestionarla como un catch.

748
01:07:24,769 --> 01:07:36,630
Para que nuestra aplicación pueda ser lanzada igual que lo son las que están puestas en las librerías, necesita tener recogidas ciertas características.

749
01:07:36,630 --> 01:07:54,849
¿Qué podríamos hacer? Desconocemos cuáles son, la verdad, porque están programadas en las librerías de Java, pero si las conociéramos podríamos coger aquí nosotros en nuestro código, si consideramos este manejo de excepciones como esa excepción particular, y programarlas a base de métodos y a base de parámetros.

750
01:07:54,849 --> 01:08:18,630
Sería una opción. Y la otra opción es, oye, todo aquello que hace que una clase, cualquiera de estas, se pueda considerar como para la gestión de excepciones que se produzcan en mi programa, todas aquellas características, voy a aprovechar que tengo en Java la característica asociada a la programación orientada a objetos de la herencia,

751
01:08:18,630 --> 01:08:39,510
pues voy a intentar heredar todo esto para que se pueda comportar como una excepción y luego, junto con todo eso que heredo, igual que hemos visto en otros casos, voy a programar mis propios métodos para completar el funcionamiento que a mí me interesa de esa excepción, ya que es particular mía y quiero que se comporte de una determinada manera dentro de mi programa.

752
01:08:39,510 --> 01:08:44,069
que es lo que nos puede dar todas esas características

753
01:08:44,069 --> 01:08:47,350
de que tenga la parte de comportamiento de una excepción

754
01:08:47,350 --> 01:08:50,109
pues la podemos hacer que herede de excepción

755
01:08:50,109 --> 01:08:53,050
entonces si yo aquí pusiera otra rayita

756
01:08:53,050 --> 01:08:56,250
y pusiera mi clase como hija

757
01:08:56,250 --> 01:08:58,550
de la clase excepción, todo lo particular

758
01:08:58,550 --> 01:09:01,930
que tiene excepción, que ya hemos visto que puede ser capturado

759
01:09:01,930 --> 01:09:04,109
como una excepción aquí

760
01:09:04,109 --> 01:09:07,789
lo tendremos disponible por herencia en mi clase y luego además

761
01:09:07,789 --> 01:09:29,300
podré programar yo aquellas cosas que me interesen. En mi código normal, que lo tendré aquí en el main o distribuido en los métodos que sea mi código normal, lo que pasará es que dentro de un try se podrá producir, igual que se producen ciertas excepciones ya consideradas en Java, esta nueva excepción que estoy definiendo.

762
01:09:29,300 --> 01:09:46,819
Y si se produce esa excepción, querré que se capture. Y si se captura, tendré que recibir como parámetro en este catch un objeto de la excepción nueva que es la mía particular. Y para que esto suceda, tiene que existir esa excepción en el programa.

763
01:09:46,819 --> 01:10:04,060
Entonces, la clase en nuestro proyecto que vamos a definir como esta nueva excepción es la que he puesto hoy aquí, manejo de except. Este manejo de except, para que pueda trabajar dentro de un cache, tiene que tener las características heredadas de exception.

764
01:10:04,060 --> 01:10:20,640
Pues, ¿qué hacemos? Pues, vamos a poner que extends de exception. Ya puede ser capturada como una excepción, porque todo lo que tiene exception lo tengo yo en mis objetos de la clase manejo except capturado por aquí.

765
01:10:20,640 --> 01:10:32,840
fijaros, en el contexto del programa este del que hablábamos

766
01:10:32,840 --> 01:10:35,399
vamos a suponer que a través del escáner hemos

767
01:10:35,399 --> 01:10:41,000
int y fila, hemos dicho que esto

768
01:10:41,000 --> 01:10:44,819
tiene, es la fila 13 para la que vamos a hacer la reserva

769
01:10:44,819 --> 01:10:49,399
vamos a suponer que lo hemos cogido ese valor a través de por aquí el escáner

770
01:10:49,399 --> 01:10:51,979
es verdad que

771
01:10:51,979 --> 01:10:57,079
con un número 13 en un entero no va a haber una situación en la cual

772
01:10:57,079 --> 01:11:02,140
se va a producir una excepción de forma automática como sucede aquí pero lo que sí puedo hacer yo es

773
01:11:02,140 --> 01:11:10,960
mediante un if es decir si la fila es igual a la 13 oye este esta es la situación de excepción que

774
01:11:10,960 --> 01:11:18,579
no quiero que se produzca en mi programa lo que puede hacer es que se lance una excepción

775
01:11:19,800 --> 01:11:25,720
del tipo manejo de excepciones si es así el código que no me acuerdo bien con el

776
01:11:25,720 --> 01:11:29,380
new, tendré que poner aquí constructor, efectivamente. Con lo cual aquí

777
01:11:29,380 --> 01:11:32,899
lo que estoy haciendo es lanzar una excepción. Este through

778
01:11:32,899 --> 01:11:37,600
new manejo excepciones es lo que no vemos en el código

779
01:11:37,600 --> 01:11:41,340
y se lanza de forma automática cuando se produce una división por cero. Aquí

780
01:11:41,340 --> 01:11:45,220
estaría pasando, aunque no lo estamos viendo,

781
01:11:45,539 --> 01:11:49,479
lo hará por detrás la máquina virtual de Java, estará haciendo un

782
01:11:49,479 --> 01:11:55,689
through new arithmetic

783
01:11:55,689 --> 01:12:01,460
exception y aquí

784
01:12:01,460 --> 01:12:04,739
estará pasándole un objeto de la clase

785
01:12:04,739 --> 01:12:07,640
excepción, el que sea, yo que sé

786
01:12:07,640 --> 01:12:10,880
este código ya os digo

787
01:12:10,880 --> 01:12:13,479
es el que no vemos, pues estaría pasando algo

788
01:12:13,479 --> 01:12:36,130
como esto, y aquí estaríamos

789
01:12:36,130 --> 01:12:38,529
completando información, a punto

790
01:12:38,529 --> 01:12:42,250
lo que sea, de lo que tengan los objetos de esta clase

791
01:12:42,250 --> 01:12:44,850
igual a lo que toque, por aquí

792
01:12:44,850 --> 01:13:04,170
Y luego, este objeto es el que le pasa aquí, en la llamada. Entonces, con esta llamada saltaría el ArithmeticException y la información de esta A que la hemos cargado aquí, la tendría este objeto E de ArithmeticException, como sucede en los métodos para poder trabajar con él aquí.

793
01:13:04,170 --> 01:13:09,229
esto que no lo vemos, porque para estas que son generales

794
01:13:09,229 --> 01:13:13,210
está oculto y lo hace directamente, entiendo que la máquina virtual por nosotros

795
01:13:13,210 --> 01:13:17,350
para una excepción nuestra particular, lo tenemos que hacer nosotros

796
01:13:17,350 --> 01:13:21,310
entonces aquí estoy lanzando un manejador

797
01:13:21,310 --> 01:13:24,529
de excepciones, y aquí podría hacer

798
01:13:24,529 --> 01:13:40,800
un catch, igual que estoy manejando esas, veis, el catch

799
01:13:40,800 --> 01:13:44,819
como muchos otros, ahora me lo acepta bien, ¿por qué?

800
01:13:44,819 --> 01:13:47,579
tiene la categoría de excepción

801
01:13:47,579 --> 01:13:49,100
gracias a que hemos hecho

802
01:13:49,100 --> 01:13:51,159
un extend de excepción

803
01:13:51,159 --> 01:13:56,649
aquí. La lanzo aquí, la excepción

804
01:13:56,649 --> 01:14:02,609
lanzo aquí la excepción

805
01:14:02,609 --> 01:14:14,460
y si

806
01:14:14,460 --> 01:14:15,500
hacemos una ejecución

807
01:14:15,500 --> 01:14:26,170
fijaros como este

808
01:14:26,170 --> 01:14:28,149
de la excepción me ha venido por aquí

809
01:14:28,149 --> 01:14:31,670
me ha hecho un system.out

810
01:14:31,670 --> 01:14:33,430
println que me ha dicho

811
01:14:33,430 --> 01:14:35,710
el nombre de la excepción, el toString

812
01:14:35,710 --> 01:14:37,010
me ha dicho el nombre de la excepción

813
01:14:37,010 --> 01:14:39,789
y el mesis este me ha devuelto un null

814
01:14:39,789 --> 01:14:43,319
es decir

815
01:14:43,319 --> 01:14:46,039
he lanzado mi excepción con el through

816
01:14:46,039 --> 01:14:47,880
en el try

817
01:14:47,880 --> 01:14:50,079
igual que se producía el lanzamiento de otro tipo

818
01:14:50,079 --> 01:14:52,020
de excepciones y lo he capturado con

819
01:14:52,020 --> 01:14:53,739
el catch. Vamos a poner aquí

820
01:14:53,739 --> 01:14:58,699
vamos a poner aquí otro mensaje más

821
01:14:58,699 --> 01:15:00,739
anterior para

822
01:15:00,739 --> 01:15:02,699
no tener dudas

823
01:15:02,699 --> 01:15:03,560
de qué pasa por aquí

824
01:15:03,560 --> 01:15:06,060
lanzando

825
01:15:06,060 --> 01:15:17,390
veis pone lanzando manejo de excepciones

826
01:15:17,390 --> 01:15:19,390
y estas tres líneas son estas tres

827
01:15:19,390 --> 01:15:24,859
líneas que tenemos por aquí. ¿Qué es lo que

828
01:15:24,859 --> 01:15:26,359
hemos dicho que se muestra

829
01:15:26,359 --> 01:15:29,500
con el método toString o cuando no ponemos

830
01:15:29,500 --> 01:15:32,579
el toString con el e, este e

831
01:15:32,579 --> 01:15:36,140
transforma el e en el toString para cargarlo en el println.

832
01:15:36,140 --> 01:15:39,060
¿Y qué está devolviendo el método toString

833
01:15:39,060 --> 01:15:41,899
de mi excepción?

834
01:15:41,979 --> 01:15:43,939
Está devolviendo manejo de excepción.

835
01:15:45,920 --> 01:15:48,539
¿Qué podríamos hacer que hemos visto en

836
01:15:48,539 --> 01:15:52,479
clases anteriores? Pues podríamos sobreescribir

837
01:15:52,479 --> 01:15:55,640
el método toString para que el mensaje que nos muestre

838
01:15:55,640 --> 01:15:58,920
la excepción toString nos resulte de interés

839
01:15:58,920 --> 01:16:02,100
porque esto la verdad es que nos resulta de poco interés

840
01:16:02,100 --> 01:16:05,279
esto que nos pone aquí manejo excepción nos resulta de poco interés

841
01:16:05,279 --> 01:16:08,060
en cambio tenemos la posibilidad de controlar

842
01:16:08,060 --> 01:16:09,640
el mensaje que vamos a devolver

843
01:16:09,640 --> 01:16:13,699
al tener a nuestra mano

844
01:16:13,699 --> 01:16:16,500
el código de la clase manejo toString

845
01:16:16,500 --> 01:16:18,300
entonces si ponemos aquí un override

846
01:16:18,300 --> 01:16:23,140
utilizamos la característica de la programación orientada a objetos

847
01:16:23,140 --> 01:16:29,899
de la sobre escritura de métodos podríamos poner un public string

848
01:16:31,039 --> 01:16:52,189
tu string return devuelvo desde tu string aquí pongo un cierto código y que me está haciendo

849
01:16:52,189 --> 01:16:57,829
esto sobre escribir el método tu string que tiene heredado desde la clase excepción y

850
01:16:57,829 --> 01:17:05,390
Y desde la clase excepción para arriba, posiblemente el de object, la clase excepción estará sobrescribiendo el de object probablemente,

851
01:17:06,869 --> 01:17:12,250
pero si lo vuelvo a sobrescribir yo para esta clase, lo que me devolverá será justo lo que ponga yo en el método toString.

852
01:17:12,250 --> 01:17:36,130
Estamos cogiendo por las manos la clase manejo excepción para poder dar los mensajes que a nosotros nos interesen, poder tener el control y poder dar los mensajes que nos interesen cuando se produzca esta excepción y no algo tan genérico como esto que lo tengo simplemente disponible porque hereda de la clase excepción.

853
01:17:36,130 --> 01:17:58,880
Entonces, si yo ejecuto ahora por aquí, fijaros cómo el método, esta impresión y esta, realmente a lo que acceden, como venimos diciendo, voy a quitar el null este, a lo que acceden es al método toString del objeto de la clase manejoExcepciones.

854
01:17:58,880 --> 01:18:21,640
Fijaros como pone aquí devuelvo desde tu stream justo lo que tenemos puesto aquí en el tu stream. Pero esto quizás todavía no sea algo muy útil, es verdad que vemos que nos devuelve lo del tu stream, pero nos gustaría tener todavía información más fina de cuando se produce esa excepción, por qué ha sido.

855
01:18:21,640 --> 01:18:42,500
Entonces, imaginaros que, por ejemplo, son especialmente supersticiosos, y agrandamos un poquito el enunciado que tenemos en la teoría, y no les gusta ni vender la fila 13, porque está justo al lado la 14 tampoco.

856
01:18:42,500 --> 01:19:08,850
Son así, ¿vale? En esta aerolínea. Entonces podríamos lanzar la excepción si se produce una reserva en la 13 o una reserva en la fila 14. Si hacemos esta ejecución, fijaros, nos dice devuelvo toString, lo que tenemos en el toString aquí. ¿Por qué? Porque hemos intentado hacer una reserva en la fila 13.

857
01:19:08,850 --> 01:19:29,289
Y el mensaje que tenemos es devuelvo tu string. Y si ponemos aquí 14, pues yo espero que nos funcione también por este or que tenemos aquí. Vamos a verlo. Efectivamente funciona, pero dice devuelvo tu string. Pues lógicamente, ha lanzado la excepción y utiliza el tu string. Pues en ambos dos casos dice devuelvo desde tu string.

858
01:19:29,289 --> 01:19:32,869
pero oye, es que nos gustaría

859
01:19:32,869 --> 01:19:35,329
es verdad que eso provoca situación excepcional

860
01:19:35,329 --> 01:19:37,710
queremos que se lance la excepción, manejo excepción

861
01:19:37,710 --> 01:19:41,729
pero me gustaría saber si realmente se ha producido

862
01:19:41,729 --> 01:19:44,869
porque la excepción ha sido en la fila 13 o en la fila 14

863
01:19:44,869 --> 01:19:47,270
me gustaría que este mensaje, tener disponible

864
01:19:47,270 --> 01:19:50,590
ese dato, se ha producido excepción pero porque se hizo una reserva

865
01:19:50,590 --> 01:19:53,630
en la 13 o la 14, quiero hacer una estadística de futuro

866
01:19:53,630 --> 01:19:56,510
de si realmente la gente cuando

867
01:19:56,510 --> 01:20:02,390
hace su reserva sabiendo que esta fila no nos gustan intenta buscarnos las cosquillas más

868
01:20:02,390 --> 01:20:09,529
reservando en la 13 o en la 14 a pesar de que me salta la recepción no tengo no tengo el dato aquí

869
01:20:09,529 --> 01:20:15,510
porque lo único que tengo es que se ha producido la recepción con el devuelvo de tu stream donde

870
01:20:15,510 --> 01:20:22,489
tengo el dato fijaros lo tengo directamente aquí en esta clase de momento no me gustaría tenerlo

871
01:20:22,489 --> 01:20:26,569
aquí en el catch, me gustaría tenerlo aquí, porque es donde estoy

872
01:20:26,569 --> 01:20:30,489
lanzando este system of println y es desde donde estoy accediendo

873
01:20:30,489 --> 01:20:34,510
al toString. ¿En qué momento sé si

874
01:20:34,510 --> 01:20:38,149
se está produciendo la excepción por la fila 13 o la 14? Aquí,

875
01:20:38,149 --> 01:20:42,229
que es la zona donde se genera la excepción, donde tengo el try.

876
01:20:43,670 --> 01:20:45,890
Es decir, aquí se produce el error y luego

877
01:20:45,890 --> 01:20:50,090
el mensaje lo escribo aquí, que son sitios de código diferentes. ¿Cómo puedo

878
01:20:50,090 --> 01:20:59,130
hacer llegar la fila 13 o la 14 a este catch? Pues fijaros, si yo cojo aquí, estoy creando un nuevo

879
01:20:59,130 --> 01:21:06,369
objeto con el new que sabemos que lo captura aquí, la información que tengamos ahí. Entonces, vamos a

880
01:21:06,369 --> 01:21:10,970
aprovechar que aquí estamos creando un objeto que luego lo tenemos aquí disponible para pasarle esa

881
01:21:10,970 --> 01:21:16,350
información, que es esa información de contexto que os decía que tenemos aquí y que se carga

882
01:21:16,350 --> 01:21:19,489
directamente en estas excepciones del sistema

883
01:21:19,489 --> 01:21:24,510
cuando se genera la excepción. Pues vamos a utilizar ese truquito nosotros también

884
01:21:24,510 --> 01:21:28,649
desde nuestro programa. Entonces fijaros, podemos coger

885
01:21:28,649 --> 01:21:32,390
aquí en la excepción, pues este y valor lo podemos

886
01:21:32,390 --> 01:21:36,550
llamar y fila, un entero de y fila. En esta clase, aparte

887
01:21:36,550 --> 01:21:40,090
de tener todo lo que tengamos de excepción e incluso un método que hemos

888
01:21:40,090 --> 01:21:44,170
sobrescrito como toString, pues vamos a coger y como tenemos

889
01:21:44,170 --> 01:21:47,829
una clase, sabemos que podemos programarla, entonces podemos poner aquí un public

890
01:21:47,829 --> 01:21:55,029
manejo, except, constructor

891
01:21:55,029 --> 01:21:59,069
de la clase, acordaros, constructor, mismo nombre que la clase

892
01:21:59,069 --> 01:22:03,310
no devuelve nada, pero no se lo indicamos con el void, y nos interesa

893
01:22:03,310 --> 01:22:06,569
un constructor sobre el cargado del que no tiene ningún dato

894
01:22:06,569 --> 01:22:15,319
que reciba en el constructor el número de fila

895
01:22:15,319 --> 01:22:21,989
entonces ahora puedo hacer aquí esta variable, la información

896
01:22:21,989 --> 01:22:25,989
que reciba el constructor en esta variable, que sabemos que esta variable al ser

897
01:22:25,989 --> 01:22:30,050
un parámetro del método es local al método, podemos guardarla

898
01:22:30,050 --> 01:22:33,729
en esta otra variable, en este otro atributo

899
01:22:33,729 --> 01:22:38,189
que en este caso es de clase. Y como este es un atributo de clase, estará disponible

900
01:22:38,189 --> 01:22:41,909
en todo este ámbito mientras exista el objeto. Entonces, si en este atributo

901
01:22:41,909 --> 01:22:45,510
de clase somos capaces de guardar la fila,

902
01:22:46,149 --> 01:22:49,989
va a resultar que va a estar disponible para todo el

903
01:22:49,989 --> 01:22:53,909
objeto y dentro de este objeto tenemos toString, esta es una variable que

904
01:22:53,909 --> 01:22:58,050
podemos utilizar en toString, entonces aquí en el constructor decimos

905
01:22:58,050 --> 01:23:02,029
dis.ifila, con el dis nos referimos al

906
01:23:02,029 --> 01:23:05,289
atributo, recordad que sea igual a ifila

907
01:23:05,289 --> 01:23:10,130
al no poner el dis nos referimos a este, es decir el valor que recibe el constructor

908
01:23:10,130 --> 01:23:13,829
me lo guardo en el atributo de clase, el atributo de clase

909
01:23:13,829 --> 01:23:17,069
lo tengo disponible en toda la clase y en toda la clase

910
01:23:17,069 --> 01:23:23,760
está por ende disponible en el toString. Entonces ponemos aquí

911
01:23:23,760 --> 01:23:27,180
por reserva de la fila

912
01:23:27,180 --> 01:23:38,090
el toString ya tiene información que tengo en este atributo

913
01:23:38,090 --> 01:23:41,350
que lo he recibido en el constructor y el constructor

914
01:23:41,350 --> 01:23:46,229
lo estoy llamando aquí. ¿En qué zona del código lo estoy llamando? En la zona

915
01:23:46,229 --> 01:23:49,970
de código donde se produce la excepción. Fijaros, si yo pongo aquí

916
01:23:49,970 --> 01:23:54,229
este ifila, resulta que si la excepción se produce por la fila

917
01:23:54,229 --> 01:23:58,250
13, el ifila, se lo paso al constructor a través

918
01:23:58,250 --> 01:24:03,680
en la llamada por el parámetro, que le llega aquí al constructor

919
01:24:03,680 --> 01:24:07,359
que se lo guarda en el atributo de clase, y este atributo de clase

920
01:24:07,359 --> 01:24:10,840
lo estoy utilizando en el mensaje de toString, y donde

921
01:24:10,840 --> 01:24:15,840
estoy utilizando el método toString, en el

922
01:24:15,840 --> 01:24:19,579
catch, entonces he pasado información del contexto

923
01:24:19,579 --> 01:24:23,859
donde se produce la excepción, a la zona de código, a través

924
01:24:23,859 --> 01:24:31,680
de el objeto este, donde manejamos esa excepción, entonces si yo ahora hago aquí una ejecución,

925
01:24:33,300 --> 01:24:37,100
bueno, he metido esto y me ha producido una excepción diferente, que no tengo controlada

926
01:24:37,100 --> 01:24:43,460
aquí, porque he metido una W en un número, o en el parseInt, de hecho, como esto ahora

927
01:24:43,460 --> 01:24:49,119
no me interesa, voy a comentarlo, fijaros que el número de fila con el que estoy haciendo

928
01:24:49,119 --> 01:24:53,000
la ejecución ahora es el 14, he llegado aquí

929
01:24:53,000 --> 01:25:02,170
la ejecución, tengo una variable aquí, como he comentado arriba

930
01:25:02,170 --> 01:25:06,270
sin definir, por aquí otra sin definir

931
01:25:06,270 --> 01:25:15,170
ya compila, bueno fijaros como ahora ya

932
01:25:15,170 --> 01:25:20,090
en los mensajes me dice aquí que la fila es la 14

933
01:25:20,090 --> 01:25:23,970
y si tengo aquí un 13, vamos a hacer otra ejecución

934
01:25:23,970 --> 01:25:26,630
pues ya me dice que la fila es la 13

935
01:25:26,630 --> 01:25:45,210
He pasado el número de fila, en este caso, del contexto donde se produce la excepción a la zona donde se captura. ¿A través de quién? A través de este objeto que estoy recibiendo en el catch y que he cargado al hacer este new.

936
01:25:45,210 --> 01:25:51,010
y la información se la he pasado a través de parámetros.

937
01:25:52,329 --> 01:26:00,619
Fijaros que, pensad por ejemplo que, aparte, se está pidiendo por teclado

938
01:26:00,619 --> 01:26:06,579
el nombre de la persona que está haciendo la reserva, Valeria.

939
01:26:07,359 --> 01:26:11,260
Y en el mensaje, a la hora de guardarlo, me interesa guardar el número de fila

940
01:26:11,260 --> 01:26:14,000
y el nombre de la persona que hizo esa reserva.

941
01:26:14,140 --> 01:26:15,960
Pues, ¿qué tendré que hacer? Pues me vengo aquí,

942
01:26:15,960 --> 01:26:19,680
defino otra variable de clase, string ese nombre

943
01:26:19,680 --> 01:26:26,470
obligo en el constructor a recibir también el nombre

944
01:26:26,470 --> 01:26:33,930
para poder guardarlo, pongo this ese nombre

945
01:26:33,930 --> 01:26:39,840
igual a ese nombre, en el atributo de clase

946
01:26:39,840 --> 01:26:43,239
guardo el valor que tiene la variable local

947
01:26:43,239 --> 01:26:47,520
del constructor, recordad que si estos

948
01:26:47,520 --> 01:26:51,399
nombres se podrían llamar de una forma diferente estas variables a estas, pero bueno

949
01:26:51,399 --> 01:26:54,819
Aprovechamos, las ponemos iguales y así repasamos el list.

950
01:26:55,600 --> 01:27:07,500
A través de este constructor ya tenemos la información que le voy a pasar aquí en la zona D, donde se produce la excepción, en el new, ¿veis?

951
01:27:07,760 --> 01:27:18,640
A través del constructor, new, manejo, nombre del constructor, se lo paso aquí y me guardo esa información de estas dos variables locales que se han cargado en la llamada a dos atributos de clase.

952
01:27:18,640 --> 01:27:44,789
Y estos atributos de clase están definidos en el ámbito de la clase en su conjunto, con lo cual disponibles en el método toString, entonces aquí podemos poner, fijaros, ahora ese nombre, quien sea, el nombre que sea, reserva la fila, y aquí ponemos la fila que reserva en el toString.

953
01:27:44,789 --> 01:27:51,949
entonces ejecuto por aquí y ya dice Valeria

954
01:27:51,949 --> 01:27:54,869
reserva la fila 13, bueno dos veces porque

955
01:27:54,869 --> 01:27:57,170
en el catch recordamos el e y el toStream

956
01:27:57,170 --> 01:28:04,319
si en cambio ser Valeria es Rubén

957
01:28:04,319 --> 01:28:07,420
y en la fila 14

958
01:28:07,420 --> 01:28:10,119
pues del contexto donde se produce la recepción

959
01:28:10,119 --> 01:28:13,560
el nombre y la fila, se la pasamos nuevamente por aquí

960
01:28:13,560 --> 01:28:15,920
y en el catch

961
01:28:15,920 --> 01:28:19,020
con esa información disponible, pues ahora nos dice que

962
01:28:19,020 --> 01:28:21,319
Rubén quien reserva la fila 14

963
01:28:21,319 --> 01:28:40,189
Bueno, pues estas son las excepciones personalizadas. Una clase que definimos nosotros, que lógicamente no pertenece a las librerías porque no es una cosa general que se produzca en todos los programas, pero si es particular de nuestro programa, queremos que se considere como una excepción.

964
01:28:40,189 --> 01:28:44,130
podemos definir una clase que para que tenga características

965
01:28:44,130 --> 01:28:46,109
de ser capturada con el catch

966
01:28:46,109 --> 01:28:50,569
necesita aquellas cosas que en las librerías

967
01:28:50,569 --> 01:28:53,390
tiene programado exception o programado

968
01:28:53,390 --> 01:28:55,850
o heredado desde throughable probablemente

969
01:28:55,850 --> 01:28:59,189
pues nosotros obligamos a que

970
01:28:59,189 --> 01:29:02,270
herede de exception con lo cual todas esas características ya las tiene

971
01:29:02,270 --> 01:29:05,449
y por aquí podemos poner tanto código

972
01:29:05,449 --> 01:29:08,310
como nosotros queramos nosotros particular de nuestra

973
01:29:08,310 --> 01:29:18,989
clase que estará añadido aquello heredado desde excepción si alguna duda

974
01:29:18,989 --> 01:29:41,159
se entiende bueno esto es si quieres manejar la excepción podrías utilizarlo

975
01:29:41,159 --> 01:29:45,140
pero de los flujos de datos no tengo término de entender muy bien por ejemplo

976
01:29:45,140 --> 01:29:48,420
de un sistema de

977
01:29:49,279 --> 01:30:10,760
sí bueno o sea si solamente se le hizo al final y

978
01:30:10,760 --> 01:30:15,420
no vas a hacer ningún manejo de la excepción posible de componer el ipod

979
01:30:15,420 --> 01:30:16,699
puede poner aquí un System.out.

980
01:30:17,140 --> 01:30:19,119
Si pones esto, oye, no me gusta

981
01:30:19,119 --> 01:30:21,340
esta fila. Coge otra.

982
01:30:21,880 --> 01:30:22,779
Pero bueno, si quieres

983
01:30:22,779 --> 01:30:24,699
en una clase tener

984
01:30:24,699 --> 01:30:27,319
todo un manejo así más especial

985
01:30:27,319 --> 01:30:29,439
de la excepción, pues lo puedes

986
01:30:29,439 --> 01:30:31,560
programar dentro de una clase

987
01:30:31,560 --> 01:30:32,500
y hacerlo así.

988
01:30:34,819 --> 01:30:36,079
Sería posible.

989
01:30:57,500 --> 01:31:01,270
Sí, puede ser.

990
01:31:01,270 --> 01:31:01,770
Puede ser.

991
01:31:03,770 --> 01:31:04,590
Al final,

992
01:31:04,590 --> 01:31:08,369
podría ser que si se da una determinada

993
01:31:08,369 --> 01:31:11,189
situación, pues en el catch

994
01:31:11,189 --> 01:31:14,470
realmente aquí puede dejar reflejado

995
01:31:14,470 --> 01:31:17,350
el error 2047, si ha sido por

996
01:31:17,350 --> 01:31:20,270
un error en particular y si ha sido por otro, pues a lo mejor

997
01:31:20,270 --> 01:31:24,520
tienes otro catch

998
01:31:24,520 --> 01:31:27,579
con otra excepción particular, otra

999
01:31:27,579 --> 01:31:32,039
excepción que tiene otro código. Las

1000
01:31:32,039 --> 01:31:35,300
excepciones en líneas generales,

1001
01:31:35,300 --> 01:31:39,420
bueno, esto te permite generarlas tú particularizadas. Estas, ya os digo

1002
01:31:39,420 --> 01:31:45,369
que se lanzan de forma directa, suelen ser en situaciones en las

1003
01:31:45,369 --> 01:31:49,270
que el programa, pues bueno, es que esta no te determina el programa.

1004
01:31:49,430 --> 01:31:53,409
Esta en verdad es que la codificas tú. Pues si la excepción tiene un manejo

1005
01:31:53,409 --> 01:31:57,229
digamos más general, se puede decir. O sea, más código. Si simplemente

1006
01:31:57,229 --> 01:32:01,010
va a ser un mensaje en un ficherito que

1007
01:32:01,010 --> 01:32:05,430
guardas o que sacas por pantalla un mensaje, pues a lo mejor

1008
01:32:05,430 --> 01:32:09,449
no te vale la pena programar una excepción y lanzarla y simplemente poner aquí, escribir

1009
01:32:09,449 --> 01:32:13,510
aquí en el fichero, ¿sabes? Como veremos en el otro tema. Y no tratarlo

1010
01:32:13,510 --> 01:32:17,510
como una excepción. Porque aquí el programa no se te

1011
01:32:17,510 --> 01:32:20,989
rompe. No es como en estas otras excepciones que sí se te rompen. En estas

1012
01:32:20,989 --> 01:32:25,510
mal vas si no las capturas con un try-catch porque el programa se te

1013
01:32:25,510 --> 01:32:29,409
rompe. En esta particular, en realidad el programa no se

1014
01:32:29,409 --> 01:32:33,449
rompe. Si la fila no es la 13, pues ahí sigue, ¿no? Ejecutándose.

1015
01:32:33,449 --> 01:32:37,189
O sea, aunque tú funcionalmente no te gusta y lo puedes manejar de esta forma.

1016
01:32:38,869 --> 01:32:43,189
Si el tratamiento de que sea la fila 13 es simplemente sacar por pantalla un,

1017
01:32:44,609 --> 01:32:50,689
oye, que has puesto la fila 13, pues a lo mejor no te vale la pena montar una clase con una excepción

1018
01:32:50,689 --> 01:32:53,909
porque puedes poner aquí un system out, la fila 13 no es válida.

1019
01:32:54,890 --> 01:32:59,630
Si realmente tiene más proceso, pues a lo mejor te podría valer la pena hacer una excepción

1020
01:32:59,630 --> 01:33:03,390
y todo el código gestionado por la excepción meterlo aquí en una clase.

1021
01:33:03,449 --> 01:33:11,789
Esto podría ser una clase o desde esta clase llamar a muchas otras, hacer su base de datos o generar mensajes a otras aplicaciones.

1022
01:33:20,470 --> 01:33:27,010
Sí, bueno, un poco terminando de responder a lo que me preguntabas, que no sé si al final con lo que te cuento te he respondido.

1023
01:33:27,810 --> 01:33:35,689
Si realmente cuando se produce en una aplicación de un banco de cualquiera un error es porque la han gestionado aquí.

1024
01:33:35,689 --> 01:33:38,529
aquí han dicho si el número de fila es 13

1025
01:33:38,529 --> 01:33:41,869
esto lo considero un error y el error es 13 o 20

1026
01:33:41,869 --> 01:33:44,890
50 o lo que sea y ellos tendrán una tabla con

1027
01:33:44,890 --> 01:33:47,869
códigos de errores de diferentes situaciones. Dentro

1028
01:33:47,869 --> 01:33:50,630
del programa ¿cómo podrán haber gestionado ese error? Pues simplemente

1029
01:33:50,630 --> 01:33:53,649
si no es un programa que se vaya a terminar poniendo aquí un system out

1030
01:33:53,649 --> 01:33:56,630
o creando en código si es en Java una excepción

1031
01:33:56,630 --> 01:33:59,529
que procese esta situación. Entonces

1032
01:33:59,529 --> 01:34:02,350
se podría hacer de esta forma lanzando la excepción y

1033
01:34:02,350 --> 01:34:04,989
capturándola con el catch. Aquí

1034
01:34:04,989 --> 01:34:15,939
mirad otra cosa, por terminar de cerrar el círculo

1035
01:34:15,939 --> 01:34:20,159
de esto de las excepciones, entiendo que en verdad estamos yendo un poco rápido

1036
01:34:20,159 --> 01:34:24,000
no sé si os da tiempo a digerirlo, pero como no tenemos muchas semanas

1037
01:34:24,000 --> 01:34:28,520
para esto y me gusta intentar repasarlo cuanto más mejor

1038
01:34:28,520 --> 01:34:32,520
la gestión

1039
01:34:32,520 --> 01:34:38,010
de excepciones es, yo intento un código y yo

1040
01:34:38,010 --> 01:34:41,250
capturo los posibles errores que hay dentro de ese try

1041
01:34:41,250 --> 01:34:44,189
pero también tengo la posibilidad

1042
01:34:44,189 --> 01:34:46,789
de delegar

1043
01:34:46,789 --> 01:34:48,649
la gestión de los errores

1044
01:34:48,649 --> 01:34:50,149
es decir, yo puedo intentar un código

1045
01:34:50,149 --> 01:34:53,819
y no poner aquí los

1046
01:34:53,819 --> 01:34:55,819
cuts donde

1047
01:34:55,819 --> 01:34:57,460
lo gestiono, imaginaos que

1048
01:34:57,460 --> 01:34:59,619
tengo, bueno

1049
01:34:59,619 --> 01:35:01,819
que lo puedo intentar

1050
01:35:01,819 --> 01:35:03,159
delegar, mirad

1051
01:35:03,159 --> 01:35:07,350
voy a modificar un poco por aquí, me voy a

1052
01:35:07,350 --> 01:35:09,489
llevar este código

1053
01:35:09,489 --> 01:35:11,470
vamos a crear una nueva

1054
01:35:11,470 --> 01:35:15,100
clase en el proyecto

1055
01:35:15,100 --> 01:35:42,140
delegar vamos a poner vamos a llamarlo así vamos a crear un método public void generar el cep un

1056
01:35:42,140 --> 01:35:52,029
método y en este método vamos a poner un código que nos dé una excepción como los que hemos visto

1057
01:35:52,029 --> 01:35:59,270
por ejemplo a igual nos olvidamos un poco de nuestra excepción personalizada igual año

1058
01:35:59,270 --> 01:36:00,590
int

1059
01:36:00,590 --> 01:36:03,829
le damos un tamaño de 3, justo vamos a poner

1060
01:36:03,829 --> 01:36:05,369
el mismo que antes y ahora

1061
01:36:05,369 --> 01:36:07,609
hacemos aquí un acceso a la

1062
01:36:07,609 --> 01:36:08,909
posición 4

1063
01:36:08,909 --> 01:36:16,899
bueno, esto lo hemos hecho en otra clase, podríamos

1064
01:36:16,899 --> 01:36:18,960
no haberlo hecho en otra clase, de hecho

1065
01:36:18,960 --> 01:36:21,039
mira, vamos a hacerlo

1066
01:36:21,039 --> 01:36:22,300
dentro de esta misma clase

1067
01:36:22,300 --> 01:36:25,119
vamos a definir aquí

1068
01:36:25,119 --> 01:36:26,420
un método, public

1069
01:36:26,420 --> 01:36:29,119
voy a ponerle static, porque lo voy a

1070
01:36:29,119 --> 01:36:31,060
llamar desde el main, public static

1071
01:36:31,060 --> 01:36:32,779
void

1072
01:36:32,779 --> 01:36:40,020
delegar, es lo mismo ponerlo aquí que en la otra clase

1073
01:36:40,020 --> 01:36:45,789
pero que se quede un poco más recogido, y este código que habíamos puesto

1074
01:36:45,789 --> 01:36:49,670
aquí para provocar la excepción, lo ponemos

1075
01:36:49,670 --> 01:36:54,369
aquí, aquí no, aquí

1076
01:36:54,369 --> 01:36:58,949
en el método delegar, fijaros que esto genera una excepción, intenta acceder a la posición

1077
01:36:58,949 --> 01:37:04,840
4 cuando he hecho una reserva de 3, el método lo voy a poner en minúsculas

1078
01:37:04,840 --> 01:37:09,289
ya sabéis, todo este código

1079
01:37:09,289 --> 01:37:13,789
lo voy a comentar, que no nos esté molestando

1080
01:37:13,789 --> 01:37:25,680
y voy a hacer una llamada al método delegar, el main

1081
01:37:25,680 --> 01:37:38,250
irá por aquí, por delegar, llamará al método delegar y luego irá

1082
01:37:38,250 --> 01:37:42,270
terminando el programa, cuando llamemos al método delegar, observad como

1083
01:37:42,270 --> 01:37:45,949
aquí se produce una excepción de

1084
01:37:45,949 --> 01:37:50,590
index out of bounds, fuera de rango el índice

1085
01:37:50,590 --> 01:37:54,069
efectivamente, por aquí se produce

1086
01:37:54,069 --> 01:38:00,250
fijaros como me dice por aquí que la línea en la que se en la que sucede es en la línea en

1087
01:38:00,250 --> 01:38:13,289
delegar en la línea 84 aquí aquí podría yo coger y hacer un try voy a intentar este código con lo

1088
01:38:13,289 --> 01:38:25,539
cual estamos yendo a lo mismo que hemos visto antes en el método main catch excepción y la

1089
01:38:25,539 --> 01:38:30,079
captura fijaros no voy a poner ningún código aquí simplemente capturó para que el programa no se me

1090
01:38:30,079 --> 01:38:33,119
termine de romper, hará el catch que es nada, se terminará

1091
01:38:33,119 --> 01:38:35,979
a delegar y después de delegar continuará el programa

1092
01:38:35,979 --> 01:38:38,899
y ahora es previsible que saque este mensajillo.

1093
01:38:40,140 --> 01:38:41,159
Vamos a poner aquí,

1094
01:38:43,800 --> 01:38:47,180
tardamos un minuto y así vemos bien todo el recorrido

1095
01:38:47,180 --> 01:38:57,779
por caso de delegar, ponemos,

1096
01:38:58,579 --> 01:39:01,119
ejecutamos, efectivamente se produce

1097
01:39:01,119 --> 01:39:03,460
el error, pasa por el catch, ya no sé,

1098
01:39:04,000 --> 01:39:06,840
el programa no termina porque he capturado la excepción

1099
01:39:06,840 --> 01:39:08,779
y me dice terminando el programa.

1100
01:39:10,060 --> 01:39:17,159
El tema de delegar el error que se produce en este try me lo captura aquí.

1101
01:39:20,390 --> 01:39:24,010
Recordad que si esto no lo ponemos en un try, se nos acaba el programa.

1102
01:39:24,949 --> 01:39:28,130
Si lo ponemos en un try, gestión por aquí.

1103
01:39:28,810 --> 01:39:36,949
Pues puede ser que no queramos tener la gestión de ese error aquí y que no se nos acabe el programa.

1104
01:39:36,949 --> 01:39:57,850
Entonces, la opción que tenemos es, al método delegar, por aquí, le podemos decir que puede ser que lance la excepción, voy a ejecutarlo un momento para hacer copy-pega, y no es que tenga que escribirlo, la excepción que provoca es este, el de array index out of bounds.

1105
01:39:57,850 --> 01:40:05,819
podemos decir que este método no va a gestionar con un try catch

1106
01:40:05,819 --> 01:40:10,140
esta excepción, puede lanzar esta excepción

1107
01:40:10,140 --> 01:40:13,899
pero sí que sabemos que se puede producir

1108
01:40:13,899 --> 01:40:17,579
esa excepción, entonces aquí en esta cabecera, en la asignatura

1109
01:40:17,579 --> 01:40:21,100
en la cabecera de delegar, lo advertimos de esta forma

1110
01:40:21,100 --> 01:40:25,859
en algún momento durante esa ejecución puede ser que se llegue a dar esa excepción

1111
01:40:25,859 --> 01:40:30,100
que en realidad va a ser aquí, y ahora el try catch

1112
01:40:30,100 --> 01:40:45,420
lo ponemos aquí. Bueno, exception, vamos a poner en lugar de la general, vamos a poner

1113
01:40:45,420 --> 01:41:08,090
array auto both exception. Básicamente lo que decimos,

1114
01:41:08,390 --> 01:41:12,550
intenta ejecutar esto. Es verdad que en este trozo

1115
01:41:12,550 --> 01:41:16,170
hemos dicho que se podía producir esta excepción o no, quizás,

1116
01:41:16,289 --> 01:41:20,350
dependerá de cómo se dé la situación, pero aquí está, según el código, sí que se va a

1117
01:41:20,350 --> 01:41:25,380
producir. Y en lugar de tener un trade catch aquí, pues

1118
01:41:25,380 --> 01:41:29,920
intentamos delegar y el catch lo hacemos aquí. La excepción se produce

1119
01:41:29,920 --> 01:41:35,100
a la vista en el método main? No. ¿Dónde se produce?

1120
01:41:35,220 --> 01:41:38,100
¿Dentro de este try? Sí. ¿Aquí está a la vista? No.

1121
01:41:39,140 --> 01:41:42,800
Delegar está aquí y decimos que puede producir esa excepción y efectivamente

1122
01:41:42,800 --> 01:41:47,060
aquí la produce. Entonces la captura en el catch aquí. Esto es lo que

1123
01:41:47,060 --> 01:41:50,720
os hablo en los apuntes de delegar o de

1124
01:41:50,720 --> 01:41:54,859
creo que lo pone con el término delegar la excepción, pues al

1125
01:41:54,859 --> 01:41:58,979
método que está llamándome, en lugar de gestionar yo esa excepción, se lo paso

1126
01:41:58,979 --> 01:42:05,550
para que la gestión la haga este otro método. Entonces fijaros cómo efectivamente sale

1127
01:42:05,550 --> 01:42:13,760
lanzada excepción, array, auto bounce excepción, pues porque la ha capturado aquí.

1128
01:42:14,920 --> 01:42:25,560
Si no se produce la excepción, si ponemos aquí un 2, como no se produce la excepción, pues ahí está.

1129
01:42:27,819 --> 01:42:33,119
Bueno, pues se la pasamos a alguien que me está llamando para que tenga diferentes gestiones.

1130
01:42:33,119 --> 01:42:39,819
podemos decir esto en para qué podría valer pues bueno pues por ejemplo buscando un posible caso

1131
01:42:39,819 --> 01:42:48,199
imaginaros que estamos llamando a este método desde desde el main y también lo estamos llamando

1132
01:42:48,199 --> 01:43:11,029
desde bueno pues otro método diferente mira aquí tenemos este método vamos a utilizarlo bueno este

1133
01:43:11,029 --> 01:43:24,130
ponemos lanzado desde a fijaros aquí estamos llamando a delegar desde a y aquí lo estamos

1134
01:43:24,130 --> 01:43:41,069
llamando desde desde el mail si lo estoy llamando desde el mail me sacar este mensaje si lo estoy

1135
01:43:41,069 --> 01:43:47,109
llamando desde a mes se lanzará este otro donde pone esto entonces hacemos una llamada de a del

1136
01:43:47,109 --> 01:44:00,390
método a desde aquí voy a separar las largas con un sistema 30 ln para que veamos claramente la

1137
01:44:00,390 --> 01:44:05,369
diferencia de una de donde se está llamando al método de legar desde el mail por aquí y

1138
01:44:05,369 --> 01:44:09,689
y luego después de los asteriscos llamamos a, y es desde a desde donde se llama,

1139
01:44:11,800 --> 01:44:16,920
pues fijaros aquí el mensaje, en esta zona de código, por lo que fuese en nuestro enunciado,

1140
01:44:17,479 --> 01:44:21,680
nos interesaba que si se producía un array in this auto bout exception,

1141
01:44:22,199 --> 01:44:27,380
el mensaje a guardar fuese este, desde el main, pero si se llama desde a,

1142
01:44:27,380 --> 01:44:33,260
que el mensaje sea este otro, tenemos la posibilidad de diferenciar una gestión

1143
01:44:33,260 --> 01:44:37,199
de un ArrayIndexAutoVaultException en delegar

1144
01:44:37,199 --> 01:44:40,760
si la llamada se hace desde un sitio o se hace desde otro.

1145
01:44:42,060 --> 01:44:43,539
Bueno, pues nos da esa opción.

1146
01:44:43,979 --> 01:44:46,199
Si el try-catch lo tuviéramos aquí en delegar,

1147
01:44:47,579 --> 01:44:49,220
como llamamos a delegar en ambos casos,

1148
01:44:49,340 --> 01:44:50,380
el mensaje sería común.

1149
01:44:52,060 --> 01:44:55,159
Otra posibilidad es que, por ejemplo, desde el main,

1150
01:44:56,159 --> 01:45:00,079
por buscar otro momento en el que podríamos decir,

1151
01:45:00,079 --> 01:45:22,930
¿Y por qué vas a derivar la gestión del error? Pues imaginaros que tenemos un método delegar2 y quieres que tenga el mismo, siempre que llames a delegar o a delegar2, pues quieres que tenga exactamente el mismo comportamiento en el catch.

1152
01:45:22,930 --> 01:45:24,649
pues si aquí pones

1153
01:45:24,649 --> 01:45:27,289
delegar y delegar dos

1154
01:45:27,289 --> 01:45:29,109
si se produce la array

1155
01:45:29,109 --> 01:45:30,989
in this auto both exception

1156
01:45:30,989 --> 01:45:32,189
tanto en una como en otra

1157
01:45:32,189 --> 01:45:34,210
la gestión de ese error

1158
01:45:34,210 --> 01:45:36,930
va a ser común porque está dentro del mismo try

1159
01:45:36,930 --> 01:45:37,970
con este catch

1160
01:45:37,970 --> 01:45:44,380
y yendo un paso más allá imaginaros que

1161
01:45:44,380 --> 01:45:46,560
bueno pues ya aunque yo creo

1162
01:45:46,560 --> 01:45:48,399
no lo vamos a hacer entre otras cosas

1163
01:45:48,399 --> 01:45:50,539
por las horas y porque por la hora que ya

1164
01:45:50,539 --> 01:45:52,579
y porque tendríamos que desarrollar

1165
01:45:52,579 --> 01:45:53,300
mucho más código

1166
01:45:53,300 --> 01:45:56,500
pero aquí estamos haciendo el catch

1167
01:45:56,500 --> 01:46:00,380
este es el método main que ya es como muy final

1168
01:46:00,380 --> 01:46:02,939
pero si este método no fuese el método main

1169
01:46:02,939 --> 01:46:05,220
sino que fuese otro método que hemos llamado

1170
01:46:05,220 --> 01:46:08,159
que está capturando las excepciones de delegar

1171
01:46:08,159 --> 01:46:10,979
en este método que pudiera ser diferente de main

1172
01:46:10,979 --> 01:46:12,399
también podríamos poner un thrush

1173
01:46:12,399 --> 01:46:18,920
que lanza la array index vote of bounds exception

1174
01:46:18,920 --> 01:46:21,779
y entonces delegar se lo pasaría a este

1175
01:46:21,779 --> 01:46:24,680
que no lo gestionaríamos aquí y este se lo pasaría

1176
01:46:24,680 --> 01:46:27,359
a quien ha llamado a este método que en particular es el main

1177
01:46:27,359 --> 01:46:30,859
pero estamos haciendo la suposición de que fuese uno diferente

1178
01:46:30,859 --> 01:46:34,060
o sea que podemos ir digamos elevando

1179
01:46:34,060 --> 01:46:36,979
el error sin gestionar de método

1180
01:46:36,979 --> 01:46:44,159
en método hacia arriba y bueno todo así

1181
01:46:44,159 --> 01:46:46,680
muy concentrado y en dos horas

1182
01:46:46,680 --> 01:46:50,039
yo creo que lo que os contamos hay decepciones

1183
01:46:50,039 --> 01:46:53,039
lo hemos podido resumir un poquito

1184
01:46:53,039 --> 01:46:56,220
no sé si os he

1185
01:46:56,220 --> 01:46:58,260
generado más dudas de las que teníais antes de empezar

1186
01:46:58,260 --> 01:47:00,380
la clase o os he aclarado alguna, pero

1187
01:47:00,380 --> 01:47:02,260
bueno, esta es un poco

1188
01:47:02,260 --> 01:47:04,060
la jugada de las excepciones.

1189
01:47:05,600 --> 01:47:06,420
En la próxima

1190
01:47:06,420 --> 01:47:08,520
tutoría nos ponemos

1191
01:47:08,520 --> 01:47:10,279
un poco por orden a resolver las

1192
01:47:10,279 --> 01:47:12,119
tareas, vemos la tarea

1193
01:47:12,119 --> 01:47:14,300
del tema anterior y si terminamos empezamos

1194
01:47:14,300 --> 01:47:16,060
con esta y si no, en dos tutorías

1195
01:47:16,060 --> 01:47:18,260
hacemos la tarea de esta y volvemos a

1196
01:47:18,260 --> 01:47:19,359
dar otro repasín allá

1197
01:47:19,359 --> 01:47:21,220
a estos contenidos.

1198
01:47:22,739 --> 01:47:24,399
¿Alguna cosilla queréis

1199
01:47:24,399 --> 01:47:25,739
comentarme antes de terminar?

1200
01:47:26,220 --> 01:47:39,840
No hay dudas de momento. Bueno, si os surgen luego más adelante, pues ya sabéis, podéis ir

1201
01:47:39,840 --> 01:47:46,560
poniéndolas por ahí en los foros e intentamos aclararlas. Si no me decís nada, voy cerrando

1202
01:47:46,560 --> 01:47:57,569
la grabación y vamos terminando ya por hoy. Bueno, nada, vosotros, pues nada, os