Saltar navegación

Clase 12-04-24 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 13 de abril de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues venga, propiedades. Hemos dicho que las propiedades en este caso van a ser el nombre y el año. Si es solo el año, en realidad no hace falta poner una fecha. 00:00:01
una, vale 00:00:30
si es solo el año, han nacido 00:00:32
en el 2315, pues un número entero 00:00:34
porque quien va a haber nacido en el 00:00:36
3000 millones que es lo máximo 00:00:38
que llega un entero, nadie, pues entonces 00:00:40
con un año 00:00:42
¿qué puedes hacer? comparar si es 00:00:44
antes, si es después, pues un dato 00:00:46
entero te encaja perfectamente 00:00:48
vale, pues venga 00:00:50
quitamos lo de la ñ 00:00:52
por si estamos en otro tipo 00:00:54
de teclados y 00:00:56
no la reconoce 00:00:58
Hacemos un constructor 00:00:59
Con parámetros 00:01:01
Vale, y ahora 00:01:04
Y ahora dice 00:01:08
La deberíamos hacer get y set 00:01:12
Porque las propiedades son privadas 00:01:14
Entonces 00:01:15
Hacemos get y set 00:01:16
Vale 00:01:20
Vale, pues venga 00:01:21
Ahora, dice 00:01:27
Incorporar un método 00:01:29
Crear alumno 00:01:31
Que recibe unos parámetros 00:01:34
Y crea un objeto alumno con esos parámetros 00:01:35
y lo devuelve como valor de retorno. 00:01:38
Vale, pues entonces, el método crearAlumno 00:01:41
devuelve un objeto alumno como valor de retorno. 00:01:44
Este es su nombre y recibe los parámetros necesarios 00:01:50
para crear el objeto, nombre y año. 00:01:53
Vale, pues entonces, este método instancia el objeto 00:02:09
y lo crea. 00:02:13
entonces, este método puede ser simplemente así 00:02:17
¿vale? podría ser simplemente así 00:02:20
entonces, este método 00:02:31
es un método que nos permite crear objetos alumno 00:02:34
cuando no tenemos acceso al constructor 00:02:37
por ejemplo, es decir, aquí el constructor 00:02:40
podría estar puesto con el modificador 00:02:43
de, donde tengo el constructor hecho 00:02:46
donde lo tengo, aquí 00:02:48
el constructor podría ser así 00:02:50
¿Vale? 00:02:57
El constructor podría tener este modificador. 00:02:57
Entonces, al tener este modificador, ¿qué ocurre? 00:02:59
Que nadie puede instanciar objetos alumno con new alumno. 00:03:01
Nadie puede. 00:03:06
Porque el constructor tiene este modificador. 00:03:07
Entonces, ¿cómo permitiríamos en este caso crear objetos alumno? 00:03:09
Pues tendríamos que hacer un método aparte para crearlos. 00:03:14
¿Vale? 00:03:18
Pues no pasa nada, podría uno hacer este método. 00:03:18
Crear alumno. 00:03:22
entonces, este método 00:03:23
ya sí que usa el constructor 00:03:25
lo usa para instanciar un objeto 00:03:27
y él sí que puede 00:03:29
porque el constructor está en la misma clase 00:03:31
entonces 00:03:33
aunque tenga el modificador privado 00:03:35
aunque tenga el modificador privado 00:03:37
desde esta clase se puede usar 00:03:38
todo lo de ella misma, aunque sea privado 00:03:40
entonces 00:03:43
este método sería el que 00:03:45
las clases de fuera utilizarían 00:03:47
porque no pueden instanciar un objeto con el constructor 00:03:48
¿Vale? Entonces 00:03:51
Vamos a hacer un main en paralelo 00:03:53
Para irlo entendiendo 00:03:56
Hacemos un paquete main 00:03:57
Por ejemplo 00:04:02
Y vamos a hacer una clase main 00:04:02
¿Vale? 00:04:05
Pues entonces, por ejemplo 00:04:17
Si uno quisiera 00:04:18
Crear aquí un objeto alumno 00:04:19
Un objeto alumno 00:04:21
Para hacer lo que fuera con él 00:04:23
Pues con unos datos que ha leído por teclado 00:04:25
O como fuera 00:04:31
Nos da lo mismo 00:04:32
Juan que ha nacido en el 2000 00:04:33
pues primero la clase habría que importarla 00:04:36
claro, importamos alumno 00:04:41
pero incluso habiendo importado la clase 00:04:43
el compilador me dice 00:04:46
no puedes instanciar un objeto así 00:04:47
y eso ocurre a menudo con clases que ya están hechas 00:04:50
que usamos nosotros de la librería virtual 00:04:53
que no podemos instanciarlas llamando al constructor 00:04:56
¿por qué? pues porque el constructor está puesto como privado 00:04:59
¿vale? aquí está puesto como privado 00:05:02
luego no podemos crearlas así 00:05:05
entonces, ¿por qué se hace eso así? 00:05:07
¿por qué se hace ese diseño así? 00:05:09
porque nosotros queremos que cuando alguien 00:05:11
cree objetos nuestros 00:05:14
además, pues verificar ciertas cosas 00:05:15
y hacer cosas más complicadas 00:05:18
entonces hacemos un método aparte 00:05:19
un método, que sí ya sí que es público 00:05:21
que sirva para crear el objeto 00:05:23
un método aparte 00:05:26
y ese método ya sí que por dentro llamará al constructor 00:05:27
es un diseño 00:05:30
pues habitual 00:05:32
Que nosotros, cuando usamos clases de otros, nos hayan prohibido instanciar con el constructor y tengamos que instanciar con métodos que llaman internamente al constructor, pero además hacen otras cosas. 00:05:33
Es un patrón de diseño que existe, es un patrón de diseño que existe. 00:05:48
Entonces, en nuestro caso, esto no podríamos hacerlo por el constructor privado, porque para ello nos han dado el método crear alumno. 00:05:52
nos ha dicho, si quieres crear un alumno 00:06:01
hazlo con el método crear alumno 00:06:03
que es este 00:06:05
pero claro, el método crear alumno 00:06:06
es un método de esta clase 00:06:09
entonces los métodos 00:06:11
por lo general 00:06:13
los usamos siempre 00:06:15
los llama siempre 00:06:17
un objeto de esa clase 00:06:19
pero claro, aquí, ¿pero qué objeto? 00:06:20
si no tengo ningún objeto creado, alumno 00:06:23
¿qué objeto va a llamar a crear alumno? 00:06:24
claro, es que aquí es cuando uno se da cuenta y dice 00:06:26
oye, es que este método es estático 00:06:28
este es un método estático 00:06:30
este método no usa 00:06:33
ninguna propiedad de la clase 00:06:35
este método recibe dos parámetros 00:06:37
recibe dos parámetros 00:06:39
y son los únicos que utiliza 00:06:41
aquí dentro, no utiliza nada más que lo que recibe 00:06:43
entonces es un método estático 00:06:45
un método estático 00:06:48
es un método que solo usa 00:06:49
los parámetros que recibe 00:06:50
y además variables locales si las hay 00:06:53
o variables estáticas 00:06:55
de la clase 00:06:57
Pues este cumple esa condición 00:06:58
Solo usa estos parámetros 00:07:01
Los usa para llamar a este constructor 00:07:03
Pero no usa más variables 00:07:05
Con lo cual este método por definición es estático 00:07:06
Entonces uno se da cuenta de eso 00:07:09
Le pone el modificador static 00:07:11
Vamos a ponerle el public también 00:07:13
Si queremos que sea usado desde fuera 00:07:16
Vamos a ponerle el public 00:07:18
Y ahora ya tenemos un método estático estupendo 00:07:19
Para usar cuando queremos crear alumnos 00:07:22
Y ahora ya hacemos esto 00:07:25
alumno.crearAlumno 00:07:27
pasándole pues los datos 00:07:31
que sean, vale 00:07:33
y me faltará 00:07:45
el punto y coma 00:07:46
vale, pues es otro 00:07:48
patrón de diseño en realidad 00:07:51
que cuando yo quiero crear 00:07:52
instancias de una entidad 00:07:55
no puedo hacerlo con el constructor 00:07:57
sino lo tengo que hacer con métodos 00:07:59
de los que me han provisto para ello 00:08:01
y este método pues meterá 00:08:03
dentro las verificaciones, todo lo que quiera 00:08:05
cosas, vale 00:08:07
bueno, pues a ver, seguimos 00:08:09
con el enunciado 00:08:11
este, vale 00:08:13
este enunciado nos dice, nuestra clase 00:08:15
alumno, famosa 00:08:17
tiene el método recrear alumno 00:08:19
y ya nos dice, vale, este método 00:08:21
precisamente, que es el que tiene que incluir 00:08:23
verificaciones, todo lo que tú quieras 00:08:25
verificar 00:08:27
para poder crear un alumno correctamente 00:08:28
pues 00:08:31
dice, oye, cuidado, si el año 00:08:32
pasado, el año que le has dado como 00:08:35
parámetro es negativo 00:08:37
devuelve un null, vale, pues venga 00:08:38
entonces 00:08:41
esto será 00:08:43
el año que me han pasado como 00:08:46
parámetro es menor que cero 00:08:49
entonces el objeto 00:08:50
alumno devuelto es este 00:08:53
vale 00:08:55
y si no, podría poner ahí un else 00:08:57
y si no, return lo otro 00:08:59
pero es que no me hace falta ni el else, obviamente 00:09:00
el else no me hace falta, porque 00:09:02
si yo he hecho el return null 00:09:05
ya ha salido el método 00:09:07
y si no he salido del método es porque he seguido 00:09:08
por aquí y entonces ya devuelvo esto 00:09:11
no me hace falta ni un else 00:09:13
pero vamos, puede poner uno 00:09:14
hace un else y ya está, el efecto es el mismo 00:09:17
el efecto es el mismo 00:09:19
vale, pues entonces 00:09:20
este método, crear alumno 00:09:22
está avisando 00:09:24
de que el alumno no se ha podido 00:09:26
crear porque hay un dato incoherente 00:09:29
que es un año negativo que no existe 00:09:31
está avisando de que hay una información incoherente 00:09:33
y no la ha podido crear mediante el valor de retorno 00:09:39
devolviendo null, está avisando de eso 00:09:40
entonces bueno, habría que documentarlo 00:09:43
con javadoc y todo eso, pero bueno 00:09:44
si devuelve null, es que el alumno 00:09:46
no se ha podido crear por el año negativo 00:09:48
vale, bueno pues entonces 00:09:50
seguimos 00:09:53
ya está 00:09:55
ahora un main que rellena una raíz de objetos 00:09:56
contará 00:10:00
cuantos han nacido en 00:10:02
bueno pues esto 00:10:03
lo sabéis hacer 00:10:05
perfectamente y esto pues si que sería 00:10:08
parte obviamente de la recuperación de 00:10:10
de reas anteriores 00:10:12
pues 00:10:14
hacer aquí un array de objetos 00:10:16
alumno 00:10:18
vamos a hacer un array para que no se nos olviden 00:10:18
los arrays, sería más cómodo hacer 00:10:26
una lista de alumnos pero bueno para que no se nos 00:10:27
olviden los arrays vamos a hacer 00:10:29
un array de alumnos 00:10:31
venga pues 00:10:33
hala, cuatro alumnos 00:10:40
entonces 00:10:45
y ahora recorremos el array 00:10:46
bueno, tú pondrías aquí un escáner 00:10:49
y ya está, leerías la variable y pondrías aquí la variable 00:11:01
vale, vamos de eso nadie tiene duda 00:11:04
le diríamos un numerito, introduzca la cantidad 00:11:08
Leeríamos ese numerito n 00:11:12
Y aquí pondríamos esa variable leída 00:11:14
Alumnos.le 00:11:16
Vale, voy acortando un poco las cosas 00:11:20
Para que nos dé tiempo a hacer más cosillas 00:11:25
Y repasar más cosas 00:11:27
Venga, vamos a crear 00:11:28
En lugar de la cantidad n que hemos leído por teclado 00:11:30
4 y ya está 00:11:33
Vamos a crear 4 alumnos 00:11:34
Que van a ir a ese array 00:11:37
Pues alumnos de i 00:11:38
Va a ser igual a qué? 00:11:41
a alumno.crearalumno 00:11:44
de datos 00:11:47
oficialmente los debería leer por teclado 00:11:49
pero para que no se haga un rollo 00:11:52
luego probar el mail y tener que meter, meter, meter todo el rato 00:11:55
vamos a poner directamente que el nombre de los alumnos 00:11:58
sea nombre 00:12:02
concatenado con la posición que sea 00:12:02
nombre 0, nombre 1, nombre 2 00:12:06
y año vamos a generar un aleatorio 00:12:09
Vamos a generar un aleatorio 00:12:12
Entre el 2000 00:12:14
¿Vale? 00:12:24
Por 2000 00:12:27
Y esto así 00:12:29
Venga, pues años aleatorios entre 0 y 2000 aproximadamente 00:12:32
Y me falta un paréntesis 00:12:36
¿Vale? 00:12:44
Bueno, pues ya tenemos el array de 4 alumnos 00:12:47
Podrían ser n, pues son 4 00:12:50
Ya está 00:12:51
Aquí nos dice 00:12:52
Contar cuántos han nacido 00:13:01
En año bisiesto 00:13:07
Vale 00:13:11
Dice hacerlo creando en la propia clase principal 00:13:12
Un método que te lo haga 00:13:17
Entonces aquí 00:13:18
Contar cuántos han nacido en año bisiesto 00:13:20
Pues bueno, tendríamos que hacer un contador 00:13:22
Como siempre 00:13:24
y ahora ya recorremos otra vez el array 00:13:25
vamos a cambiar, lo vamos a recorrer con un forEach 00:13:29
como se lo vamos a consultar 00:13:35
pues venga, para cada alumno A de ese array 00:13:36
para cada alumno A 00:13:42
aquí habría que ver, si el alumno A ha nacido 00:13:43
en año bisiesto, le contamos 00:13:48
y nos dicen, hazlo con un método adicional 00:13:49
entonces ese método 00:13:52
podríamos llamar nacido bisiesto 00:13:56
¿Vale? 00:13:58
Si ha nacido este alumno 00:14:00
en año bisiesto, entonces 00:14:02
le contamos 00:14:03
¿Vale? 00:14:05
Ahí se queda contado y ya está 00:14:07
y luego se mostraría la cuenta 00:14:09
¿Vale? 00:14:11
Entonces este método es un método 00:14:23
que tiene que devolver un boolean y trabajar 00:14:25
con la propiedad año de este 00:14:27
Bueno, pues vamos a hacer ese método 00:14:28
dentro de la propia clase main 00:14:31
Será este método de aquí 00:14:33
Este método de aquí 00:14:35
Me devuelve un boolean 00:14:37
Recibe un objeto alumno 00:14:39
Y mira a ver si es bisiesto 00:14:41
No es bisiesto 00:14:43
¿Vale? 00:14:45
Entonces, la condición de ser bisiesto no 00:14:46
La teníamos por ahí ya hecha en algún sitio 00:14:49
Entonces, por pura vaguería 00:14:52
Voy a copiarla 00:14:54
Directamente de aquí 00:14:56
Porque 00:14:56
Bisiesto 00:15:01
Era que no fuera múltiplo de 4 00:15:03
Múltiplo de 4 sin serlo de 100 00:15:06
Simultáneamente 00:15:08
Entonces eso ya lo hicimos en 00:15:09
¿En qué clase? 00:15:12
Ah, pero ese no es un paquete 00:15:17
De la librería 00:15:18
Tendríamos que importar el paquete 00:15:19
¿En qué libre? 00:15:21
¿Está en la JRE? 00:15:25
Ah, ¿dónde está? 00:15:26
¿En qué clase está? 00:15:29
Ah, Javatain tiene también para ver si el primer 00:15:34
Mira que ha apañado 00:15:35
Pero la clase 00:15:36
Java también es el paquete 00:15:39
¿Y la clase cómo se llama? 00:15:40
Year 00:15:42
Entonces, year. 00:15:43
Esto 00:15:51
Y ya te devuelve el boolean 00:15:51
Directamente 00:15:54
Es que también dio year con G 00:15:55
Entonces decía, este es que es 00:15:57
Y le ponemos esto de aquí 00:15:59
A.getAño 00:16:02
Vale 00:16:06
Si no, uno planta la condición 00:16:14
que 00:16:17
ya hicimos 00:16:17
programamos nosotros 00:16:21
al principio del curso 00:16:24
que era esta de aquí 00:16:25
es bisiesto, sí 00:16:26
es múltiplo de 4 00:16:31
pero no es simultáneamente 00:16:33
múltiplo de 100 y de 400 00:16:36
era esta condición que planteamos aquí 00:16:38
¿vale? entonces o ponéis esta condición 00:16:40
o llamáis al método 00:16:42
que ya tiene la condición metida dentro 00:16:44
¿vale? da igual 00:16:46
vale, entonces efectivamente 00:16:47
JavaTime, como vimos 00:16:50
es un paquete específico 00:16:52
en cosas relacionadas con fechas 00:16:53
entonces pues puede tener un montón 00:16:55
de utilidades y si uno mira, investiga 00:16:57
pues se puede ahorrar trabajo 00:17:00
JavaUtil tiene cosas relacionadas con 00:17:01
fechas y con más cosas, como Scanner 00:17:04
por ejemplo, pero JavaTime tiene cosas relacionadas 00:17:05
exclusivamente con 00:17:08
operativa de tiempos, de fechas, entonces 00:17:09
pues seguramente tenga dentro cosas 00:17:11
que pueden ser útiles 00:17:13
vale 00:17:15
Bueno, pues ya está contado. Y ahora, ahora incorporamos alguna mejora relacionada con excepciones en este ejercicio. Vale. Bueno, pues entonces, aquí el problema, el problema por lo que esta aplicación es fea es, por lo que esta aplicación es fea es que si uno se pone aquí a meter datos de alumnos y se equivoca y algún alumno lo crea en negativo, lo crea en negativo, 00:17:17
la aplicación 00:17:43
mete ese null 00:17:46
en el array, mete ese null en el array 00:17:47
¿verdad? imaginaos que aquí 00:17:50
en lugar de estar, yo es que lo estoy haciendo 00:17:51
aleatoriamente, entonces van a ser positivos siempre 00:17:54
entonces si ejecutamos esto 00:17:55
si ejecutamos esto de aquí 00:17:57
¿vale? bueno 00:18:02
pues ya está, han coincidido ninguno 00:18:07
ninguno era ambiciesto de los cuatro 00:18:09
aleatorios que ha generado 00:18:10
¿vale? 00:18:12
pero podríamos estar, podría haber 00:18:14
un gestor metiendo datos de los alumnos 00:18:16
entonces ese gestor se equivoca 00:18:18
y le da el menos en algún momento 00:18:21
y mete un año negativo 00:18:23
entonces la aplicación tal y como está hecha 00:18:24
ahora mismo, el desarrollador que está usando 00:18:27
la clase alumno, no la ha hecho 00:18:29
él, la está usando la clase alumno 00:18:31
pues no detecta nada 00:18:33
y lo que ocurre es que 00:18:35
esto devolverá un null 00:18:37
y no pasa nada, ese null se guarda 00:18:38
en el array y ya está, con lo cual 00:18:41
tendremos los alumnos en el array 00:18:43
y en algunos sitios puede haber null 00:18:44
aquellos en los cuales hemos intentado 00:18:47
meter un alumno con edad negativa 00:18:49
como el método 00:18:51
al ver que era negativo 00:18:53
ha devuelto un null 00:18:55
pues ya está, ha devuelto un null 00:18:55
no ha pasado nada y ese null se ha quedado en el array 00:18:59
entonces, hombre 00:19:01
si este método está bien documentado 00:19:02
cuando nosotros estamos usando aquí 00:19:05
el crear alumno 00:19:07
estamos mirando bien la documentación 00:19:09
decimos, ah, cuidado 00:19:11
que aquí me dicen la documentación 00:19:12
Velastegui no está 00:19:15
Es que no viene 00:19:17
No lo coja el teléfono 00:19:21
Ya es que el email de Duca Marino lo va a leer 00:19:26
A ver 00:19:29
¿Velastegui viene a alguna otra clase? 00:19:31
¿Paulo, viene algo? 00:19:35
Pues decirle que se pase por secretaría 00:19:38
Tenéis que decirle que se pase por secretaría 00:19:40
Vale, pero si no lo pueden localizarle 00:19:43
Vale 00:19:44
¿Vale? A vosotros que os hará caso, pues lo decís. 00:19:46
Vale. 00:19:50
Bueno, pues entonces, si el método está bien documentado, 00:19:51
el que lo usa dirá, uy, ojo, que puede haber un null. 00:19:53
Voy a verificarlo con un if. 00:19:56
Y si no es null, pues, y si es null, decirle, 00:19:58
oye, es metiño negativo. 00:20:02
Primero, se complica la aplicación. 00:20:04
Segundo, tú tienes que estar bien atento a la documentación 00:20:05
para ver que esto puede generar un null. 00:20:08
Pero si no lo estás, tú ahora ya metes los alumnos, 00:20:11
te pones a hacer esto y ¿qué te va a salir? 00:20:14
un null pointer exception tremendo aquí 00:20:16
¿verdad? 00:20:18
llegarás ahí y te saldrá un null pointer exception 00:20:20
porque llegas a un alumno 00:20:22
que es null 00:20:24
llegas a un alumno que es null 00:20:25
null.getAño null pointer exception 00:20:28
vale, luego es mucho mejor 00:20:30
que crear alumno 00:20:33
te avise 00:20:34
de que el alumno 00:20:36
de que el año es negativo mediante una excepción 00:20:38
es muchísimo mejor, es una forma de comunicación 00:20:40
muchísimo mejor 00:20:42
y eso es lo que dice 00:20:43
El siguiente apartado 00:20:45
Dice 00:20:47
Oye 00:20:48
Crea una excepción para ese error 00:20:50
Que tú quieres comunicar 00:20:53
Que el año de nacimiento no es válido 00:20:54
Porque es negativo 00:20:56
Crea esa excepción 00:20:57
Y usa esa excepción para que tu método avise 00:20:58
Pues venga, vamos a crear la excepción 00:21:01
Que avise de eso que queremos comunicar 00:21:03
Bueno, pues nosotros aquí 00:21:05
Normalmente en un paquete aparte 00:21:07
Creamos la excepción 00:21:09
una nueva clase 00:21:18
¡ay! ¡ah! ¡qué hijo, eh! 00:21:20
no vería ni el new siquiera 00:21:29
vale, pues entonces, ¿qué queremos comunicar? 00:21:30
año no válido, año nacimiento no válido 00:21:33
si la única 00:21:36
causa de invalidez del año 00:21:41
es que sea negativo, podríamos ser incluso más claros 00:21:42
con el nombre, año nacimiento 00:21:45
negativo, exception 00:21:46
vale, no es que sea 00:21:48
obligatorio acabar los nombres en exception 00:21:51
pero es una pauta 00:21:52
de programación que facilita 00:21:55
que nos entendamos todos 00:21:56
entonces si esto queremos que sea una clase excepción 00:21:58
tiene que heredar 00:22:02
tiene que heredar 00:22:03
de exception o de algo que la inserta 00:22:05
en la jerarquía 00:22:07
pues vamos a hacer la heredera de exception 00:22:08
ahora ya está insertada 00:22:11
en la jerarquía, hereda de exception 00:22:13
vale, pues vamos a hacerle un constructor 00:22:15
porque se hereda todo menos los constructores 00:22:17
ya sabéis, pues vamos a hacerle 00:22:19
un constructor 00:22:21
vamos a hacerle un constructor 00:22:22
y aquí recordad que el constructor 00:22:33
lo hacíamos apoyándonos 00:22:36
en el constructor de la superclase 00:22:38
de exception y la superclase 00:22:40
tiene un constructor al que 00:22:42
tú le pasas un mensajito 00:22:44
un string y ese 00:22:45
string lo usa 00:22:48
para inicializar la variable 00:22:50
de la excepción que tiene la causa del error 00:22:52
¿vale? porque la clase 00:22:54
exception es una clase que tiene ya 00:22:56
variables suyas, que las hereda esta 00:22:58
y una de las que tiene es la variable 00:23:00
message o como se llame 00:23:02
que es la que guarda la causa del error 00:23:04
pues esa variable se inicializa 00:23:06
a través del constructor este de exception 00:23:09
entonces aquí ponemos 00:23:11
la causa que queremos 00:23:14
el año 00:23:14
introducido es 00:23:17
negativo 00:23:20
esta es la causa de error 00:23:21
que queremos que refleje esta excepción 00:23:23
esta es la causa de error 00:23:26
que queremos que refleje 00:23:27
pues nada, ya cuando la instanciemos 00:23:28
esa causa de error 00:23:31
va a ir a la variable 00:23:32
mensaje que guarda el mensaje, la excepción ya está 00:23:35
y ahora ya hay que decidir en qué momento queremos avisar de que eso ha ocurrido 00:23:39
¿en qué momento queremos avisar de que eso ha ocurrido? pues en el método crear alumno 00:23:44
ahí queremos avisar de que eso ha ocurrido, si el año es negativo 00:23:48
entonces nada de devolver null, de devolver null nada 00:23:52
si el año es negativo, lo que hacemos en lugar de devolver un null 00:23:55
como si todo fuera perfecto, nada hubiera pasado, pero simplemente el objeto alumno es null 00:24:00
en lugar de hacer eso, como si no hubiera pasado 00:24:04
decimos, eh, claro que ha pasado algo 00:24:06
ha pasado algo muy grave, que es 00:24:07
que el año es negativo y yo te aviso 00:24:10
lanzando una excepción, que una excepción 00:24:12
es la forma en la que te digo, esto 00:24:14
hay que hacer algo con ello, la aplicación 00:24:16
no debería seguir por este camino 00:24:18
¿cómo se lanza una excepción? ya sabemos 00:24:20
que es throw, y ahora ya instanciamos 00:24:22
el objeto excepción 00:24:24
pues nada, instanciamos el objeto excepción 00:24:25
ala 00:24:28
instanciado 00:24:41
Vamos a importarlo 00:24:43
Vale, pues este método 00:24:46
Ahora ya tiene dos opciones 00:24:51
Que el año sea negativo 00:24:52
Entonces avisa, ha habido una excepción 00:24:53
Y ya para el método 00:24:55
Completamente para 00:24:57
Y el control vuelve al que lo llamó 00:24:59
En este caso el main 00:25:01
Que el año no ha sido negativo 00:25:02
No ha habido un throw 00:25:05
Con lo cual ni se ha lanzado excepción 00:25:06
Ni se ha parado el método 00:25:08
Seguimos por aquí y devolvemos el objeto 00:25:09
Vale, pues entonces ahora 00:25:11
pregunta 00:25:15
¿por qué me sobrescribe 00:25:16
el rojo 00:25:19
el compilador? 00:25:21
no me leáis lo que te avisa el Eclipse 00:25:23
sí, pero está ya importado 00:25:25
está ya 00:25:29
o sea, eso ya me ha dado 00:25:31
un error antes y ese ya lo ha arreglado 00:25:33
este es otro 00:25:35
ya, pero es otra cosa 00:25:36
eso sí, a ver, me dice, oye, vamos a ver 00:25:44
si este método lanza una excepción 00:25:47
si este método lanza una excepción 00:25:49
la cabecera del método 00:25:52
o sea, lanza, es posible 00:25:53
que la lance, es posible 00:25:55
la cabecera del método tiene que avisar 00:25:56
para que el que lo llame 00:25:59
sepa que puede ser lanzada la excepción 00:26:01
sepa que puede 00:26:03
no es que haya que pasársela por parámetro 00:26:04
porque la crea él 00:26:06
pero tiene que avisar la propia cabecera 00:26:07
que puede que la lance 00:26:12
porque el que llama el método 00:26:13
el que llama el método de lo que hay dentro 00:26:15
no tiene ni idea ni tiene por qué saberla 00:26:17
Esa es la encapsulación de la relación entre dos objetos. 00:26:19
El que llama al método de otro, lo único de lo que dispone es de la cabecera. 00:26:22
De lo que devuelve, del nombre, de lo que recibe, de si es estático o no, para saber si lo puede llamar con el nombre de la clase o no. 00:26:29
Y de si puede que lance excepción o no. 00:26:38
Esa es la única información que tiene que tener el que llama al método. 00:26:41
nombre para poder llamarlo 00:26:44
lo que devuelve para recoger 00:26:46
la variable correspondiente 00:26:49
los parámetros que necesita para pasárselos 00:26:50
static 00:26:53
para ver como lo puede llamar 00:26:55
con objeto o con nombre de clase 00:26:57
y throws para saber 00:26:58
si puede que lance excepción o puede que no 00:27:01
eso es lo que el que llama el método tiene que conocer 00:27:03
lo único 00:27:07
eso es lo que se llama una API en general 00:27:07
las siglas API de Application Program Interface 00:27:11
Significan eso, es 00:27:13
¿Cuál es la información que tú tienes 00:27:15
Del código que estás usando? 00:27:18
Eso es lo que significa API 00:27:20
¿Qué es? ¿Tu interfaz de programación cuál es? 00:27:21
Interfaz significa 00:27:25
El punto de comunicación 00:27:26
Entre dos cosas 00:27:28
Eso significa interfaz en realidad 00:27:29
El punto de comunicación entre dos cosas 00:27:31
Entonces API es 00:27:32
Ese punto de comunicación entre dos cosas 00:27:34
El que llama el método y el método 00:27:37
Ese punto de comunicación, ¿qué tiene? 00:27:38
Pues tiene esto, esto es una API 00:27:41
este es el punto de comunicación 00:27:43
entre el que llama al método 00:27:45
y el propio método 00:27:46
bueno, pues nos está diciendo eso 00:27:48
oye, te falta dar esa información 00:27:50
te falta decir 00:27:52
que puede 00:27:54
que este método 00:27:55
llame a este 00:27:59
y ahora ya esta cabecera ya tiene toda la información 00:27:59
que necesita 00:28:03
el que lo llama para trabajar 00:28:05
lo que hace dentro, le da exactamente igual 00:28:06
lo que hace, de hecho es que no lo tiene 00:28:09
por qué conocer, es una información oculta 00:28:10
esto está encapsulado, ya lo tiene todo 00:28:12
vale, pues ya está, entonces a nosotros ahora en nuestro main 00:28:15
una vez que ha cambiado la clase alumno 00:28:20
ahora ya a este main le han cambiado las condiciones del juego 00:28:24
le han cambiado las reglas del juego, se las han cambiado 00:28:27
y esto, que antes ni tenía errores de compilación 00:28:30
ni tenía errores de nada, pues el que está en el repositorio 00:28:34
trabajando en paralelo con el otro, que están subiendo 00:28:38
sincronizados con el repositorio, con github 00:28:40
con el que sea, están sincronizados 00:28:42
a este de repente 00:28:44
cuando se ha sincronizado 00:28:46
con el repositorio 00:28:49
sin haber cambiado nada de su propio código 00:28:50
se le pone esto en rojo 00:28:52
antes lo tenía todo perfecto 00:28:53
lo tenía todo perfecto pero el problema era una caca 00:28:56
porque si metía un año negativo 00:28:58
le iba a salir un null pointer exception 00:29:00
en los de compilación ninguno 00:29:02
pero a la hora de ejecutar la liaba 00:29:03
como el usuario metía uno en negativo 00:29:05
bueno, pues ahora se ha sincronizado con el repositorio 00:29:07
porque está trabajando en equipo 00:29:10
con el del proyecto y de repente 00:29:12
le aparece esto. Esto ya sí 00:29:14
que es una forma mejor de programar 00:29:16
porque ahora ya el que está desarrollando esta parte 00:29:18
del proyecto dice, uy 00:29:20
¿y aquí qué pasa? 00:29:22
Pues aquí pasa lo que me están diciendo. 00:29:24
Te dice, cuidado cuando uses el método. 00:29:26
Cuidado. Porque 00:29:29
puede ser que te salga 00:29:30
esta excepción. Si es 00:29:32
que se ha metido un número negativo. 00:29:34
Cuidado. 00:29:37
Entonces, el que está 00:29:38
trabajando en esta parte del proyecto 00:29:40
tiene que decidir 00:29:42
qué pasa en ese caso 00:29:44
tiene que decidir 00:29:45
¿vale? 00:29:47
entonces 00:29:49
recordad que hay dos opciones 00:29:49
¿qué dos opciones 00:29:51
tenemos aquí 00:29:52
cuando hay una posible 00:29:53
excepción 00:29:54
que puede salir? 00:29:55
¿qué dos alternativas 00:29:57
puedo tomar? 00:29:59
¿capturarla? 00:30:02
efectivamente 00:30:03
puedes decir 00:30:05
ah no 00:30:06
voy a capturarla 00:30:07
hacer un try catch 00:30:08
y decir 00:30:09
inténtalo 00:30:10
si la 00:30:10
si te sale fenomenal 00:30:11
si no 00:30:13
vete al catch 00:30:14
y continúa el programa, va a decir 00:30:14
como hayan metido un negativo 00:30:15
quiero que pare el programa 00:30:18
no quiero que pase nada más 00:30:20
tú ahí tienes que decidir, que quieres que ocurra 00:30:22
si nos vamos a la opción cómoda 00:30:24
que es, uy, si metes un negativo 00:30:26
programa parado, se acabó 00:30:27
avisa, pues entonces haríamos el 00:30:30
throws, vale, esta sería 00:30:32
la opción cómoda 00:30:36
se quita el error de compilación 00:30:38
se quita el error de compilación 00:30:39
vale, este programa 00:30:41
ya estaría terminado, pero como 00:30:44
alguien meta un número negativo 00:30:45
salen las letras rojas 00:30:47
y de hecho 00:30:49
voy a cambiar esto por un scan 00:30:51
para, bueno, nos alargamos mucho 00:30:53
y nos pasan luego las otras 00:30:55
pero vamos, yo creo que 00:30:57
no hace falta para que lo sigáis 00:30:59
entonces si 00:31:01
alguien mete un número negativo 00:31:03
al llegar aquí, ¡pam! 00:31:05
aparecen las letras rojas 00:31:07
y el programa se para, se acabó, no sigue 00:31:09
el programa se ha parado, no sigue 00:31:12
¿qué decimos? 00:31:13
hombre no, tampoco seas tan radical 00:31:15
que no pare el programa solo 00:31:17
porque meta un negativo 00:31:19
avísale, dale una oportunidad 00:31:21
de mejorar, de intentarlo 00:31:23
y que el programa siga 00:31:25
bueno, pues entonces 00:31:27
hacemos un try catch 00:31:29
y ahora ya en el try catch uno hace 00:31:30
el try catch que le dé la gana 00:31:32
vale, yo no quiero propagar 00:31:35
que eso es una caca, es de vagos 00:31:41
y de gente que quiere que sus programas sean 00:31:43
lo menos robustos del mundo, no quiero propagar 00:31:44
quiero hacer un try catch 00:31:46
vale, entonces aquí ya uno decide 00:31:48
aquí ya uno decide 00:31:54
intenta crear el alumno 00:31:57
que lo consigues, fenomenal 00:31:58
que no lo consigues, que quieres que pase 00:32:00
pues aquí decidimos 00:32:02
podríamos meter esto 00:32:04
en un bucle, por ejemplo, de tal forma 00:32:07
que estuviera todo el rato pidiendo años 00:32:08
y salga del bucle 00:32:11
cuando ya se ha metido un positivo 00:32:13
lo que fuera, lo que queramos 00:32:14
por ejemplo, vamos a suponer que lo que 00:32:16
hacemos es, si has metido un negativo 00:32:19
Creamos un alumno que ha nacido en el año cero 00:32:21
Por ejemplo 00:32:23
Entonces podríamos hacer esto, a lo mejor 00:32:24
Lo que el programador 00:32:26
Decida acorde con lo que 00:32:29
Quiere el que va a usar la aplicación 00:32:31
¿Vale? 00:32:33
Nombre más y cero 00:32:51
Ah, que no, es que lo que estoy haciendo con esto es crear alumno 00:32:53
Alumno punto 00:32:58
Crear alumno 00:33:01
Vale, ay, perdón, perdón 00:33:03
¿Eh? 00:33:10
No, no, no, espera, espera, no, no, claro 00:33:12
Claro, o sea, lo que decidas hacer 00:33:14
He puesto esto por poner algo, lo que tú decidas hacer 00:33:26
O crear una lopeza 00:33:28
Es que a ver, lo que he puesto es una tontería 00:33:31
Me estoy dando cuenta ahora 00:33:32
Porque me va a volver a obligar la excepción 00:33:33
O sea, que la decisión que he tomado precisamente es la más estúpida 00:33:35
Que uno podría tomar aquí 00:33:38
Entonces aquí lo natural sería 00:33:39
Decirle 00:33:42
No has podido, el alumno 00:33:43
Esa laña es negativa, vuelve a intentarlo 00:33:48
O sea, volverlo a crear 00:33:50
porque me meto en un bucle infinito 00:33:51
de capturas excepciones, es un poco tonto 00:33:53
entonces 00:33:55
lo que fuera, lo que uno quisiera 00:33:56
¿vale? lo que uno quisiera 00:34:06
entonces hombre, aquí tendría sentido 00:34:08
ahora, si realmente quiero tener creados 00:34:10
todos los alumnos 00:34:12
hacer un do while o simplemente 00:34:13
decrementarla ahí 00:34:17
decrementarla para que se esté en ese alumno insistiendo 00:34:18
insistiendo, insistiendo, por ejemplo 00:34:21
podríamos hacer esto 00:34:22
esto sí que tendría un poquito más de 00:34:24
más de sentido 00:34:28
y es más cómodo que meter este try-catch 00:34:30
en un while, ¿verdad? 00:34:33
intenta crear el alumno 00:34:37
¿qué has podido? genial, se acabó 00:34:38
te vas al siguiente 00:34:40
¿qué no has podido? el año es negativo 00:34:42
e ahí 00:34:43
va uno para atrás 00:34:45
para que te quedes en el mismo sitio 00:34:48
no, no hace falta 00:34:50
con esto ya no hace falta el do while 00:34:54
claro, porque el for 00:34:55
aquí tengo un for 00:34:57
entonces cuando ya he terminado esto 00:34:59
El for incrementa el i 00:35:02
Si yo no tengo decrementado que antes 00:35:04
Se queda en el mismo sitio que estaba 00:35:05
Claro, pero 00:35:07
Es que te lo va a pedir insistentemente 00:35:10
Porque va a estar plantado en ese i todo el rato 00:35:13
Es que el for no va a avanzar 00:35:15
Claro, el for no va a avanzar 00:35:16
Se va a quedar en ese i todo el rato 00:35:18
Claro, se va a quedar atascado en ese i 00:35:19
¿Vale? 00:35:23
Bueno, sería una posibilidad 00:35:24
¿Vale? Por ejemplo, o lo que fuera 00:35:26
¿Vale? Aquí lo que nos importa es 00:35:28
Que esto, el hecho de que hayamos 00:35:31
puesto aquí el 00:35:33
throw y el throws 00:35:35
al que está usando ese software 00:35:37
pues hombre, tiene esa 00:35:40
información directamente y le obligamos 00:35:42
a que decida, que tome una decisión 00:35:44
y ya no se queda el programa a expensas 00:35:46
de los null y del null pointer exception 00:35:48
¿vale? 00:35:50
vale, entonces 00:35:54
para terminar esto 00:35:55
y paramos, para terminar esto 00:35:57
esta excepción 00:36:00
que yo he hecho aquí, esta excepción 00:36:02
hereda directamente de excepción 00:36:04
recordad que eso implica 00:36:06
que es una excepción de las que se llaman 00:36:08
verificadas por código 00:36:10
verificadas en tiempo de compilación 00:36:11
es decir, este de aquí 00:36:13
que ha usado este método 00:36:16
ha tenido que optar 00:36:17
por try, catch o por throws para seguir 00:36:20
si no, no podía seguir 00:36:22
porque tenía ya un error de compilación directamente 00:36:23
¿vale? 00:36:25
¿por qué hemos elegido que esa excepción sea así? 00:36:27
porque nos ha parecido, es evidente, grave 00:36:30
para nuestro programa 00:36:31
nos ha parecido lo suficientemente grave 00:36:33
para obligar al que use el método a decir 00:36:35
oye 00:36:37
eso, esa es la pregunta 00:36:38
entonces si a nosotros nos parece una excepción 00:36:41
que sí, que queremos que se lance si hay un problema 00:36:43
pero no queremos 00:36:45
verificarla en tiempo de compilación 00:36:47
no queremos que en tiempo de compilación sea comprobada 00:36:49
y tratada, sino simplemente 00:36:52
que cuando aparezca sea lanzada y ya está 00:36:53
¿qué cambio haríamos? 00:36:56
pues en lugar de hacer 00:36:58
la heredera de exception, la haríamos heredera 00:36:59
RuntimeException que era una subclase 00:37:02
si la hacemos heredera de esta 00:37:05
se convierte 00:37:07
en una 00:37:10
excepción flojita 00:37:11
como más light, más flojita 00:37:13
entonces el que la está 00:37:15
usando, aunque no hiciéramos el try-catch 00:37:17
aunque no lo hiciéramos 00:37:19
el compilador 00:37:22
no nos daría ningún problema 00:37:31
el programa 00:37:33
el programa parecería igual 00:37:33
pero en tiempo de compilación 00:37:36
a mí no me para 00:37:39
yo puedo programar, pero claro 00:37:39
en tiempo de ejecución me va a salir igual 00:37:42
va a ser lanzada igual y va a funcionar igual 00:37:44
va a parar el código 00:37:46
y va a mostrar las letras 00:37:48
pero en tiempo de compilación no me obliga a mí 00:37:49
a capturarla, es como el null pointer exception 00:37:52
el null pointer exception nos aparece 00:37:54
cuando ha habido ese error 00:37:56
y nosotros hemos podido escribir el código 00:37:58
sin necesidad de hacer un try-cat de null pointer exception 00:38:00
ni de hacer un throw, no lo hemos tenido que hacer 00:38:03
Pero es que si hubiéramos tenido que hacer un throws o un try-catch de todos los posibles null pointer exception, el código se quedaría enorme. Entonces, nosotros podríamos elegir que esta excepción fuera de esas, de las que no está obligada a ser capturada, pero bueno, tiene esa pega que luego el programa se queda más flojo para el tiempo de ejecución. 00:38:05
Porque puede salir y parar el programa 00:38:25
Y ya está 00:38:27
Venga, pues ahora sí que 00:38:28
Sí que paramos aquí un 00:38:31
Un momentito y voy a buscar otro 00:38:33
Otro ejercicio 00:38:35
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
13 de abril de 2024 - 13:52
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 37″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
187.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid