Saltar navegación

20250318 Planteam_AppPedidos_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 21 de marzo de 2025 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos a realizar una interfaz gráfica para gestionar pedidos, para variar y ya está. 00:00:00
Vale, entonces, vamos a tunearlo también un poco para que sea un poquito más completo. 00:00:08
Primero, importante en una aplicación, antes de empezar a ver qué tiene que hacer mi aplicación, 00:00:15
antes de empezar con 00:00:24
¿qué tiene que hacer? 00:00:26
¿qué tiene que hacer? recordad que forma 00:00:29
parte de la fase de análisis 00:00:31
¿no? de un proyecto 00:00:33
¿sí o no? ¿conocéis los ciclos? 00:00:34
el ciclo de vida 00:00:37
el desarrollo del software ¿verdad? ¿lo conocéis? 00:00:38
vale, y la fase de análisis 00:00:41
es ¿qué 00:00:43
tiene que hacer esto? 00:00:44
¿qué tiene que hacer? 00:00:46
¿qué tiene que hacer? entonces tú te juntas con 00:00:48
el cliente y le dices 00:00:50
A ver, ¿tú qué quieres? 00:00:52
Él te cuenta un rollo en uno que no entiendes nada 00:00:54
Entonces te sigues entrevistando con él, con Macatín 00:00:57
Y al final sacas un listado 00:00:59
De funcionalidades pequeñitas 00:01:01
Que son las que tiene que hacer 00:01:03
¿Vale? 00:01:04
No, las más importantes no 00:01:07
Todas y cada una de las que tiene que hacer 00:01:08
El desglose de lo que tiene que hacer una por una 00:01:10
¿Vale? 00:01:13
Pero, eso es una cosa 00:01:15
No pongas cara de 00:01:17
Estás ahí tocando la nariz 00:01:18
Porque es así 00:01:20
Pero eso es una cosa 00:01:21
Lo que tiene que hacer la aplicación 00:01:23
Que es importante que la tengamos clara 00:01:25
Pero nunca nos olvidemos 00:01:27
De otra parte importantísima 00:01:29
Que es, ¿qué datos maneja mi aplicación? 00:01:31
¿Y dónde están? 00:01:34
¿Qué datos maneja? Voy a caracterizarlos 00:01:35
Voy a describirlos, ¿y dónde se van a guardar? 00:01:37
Entonces esa parte es importantísima 00:01:40
Caracterizar los datos 00:01:42
Con los que va a trabajar mi aplicación 00:01:43
Porque si no tenemos clarísimos 00:01:44
Los datos con los que va a trabajar y su estructura 00:01:47
Es imposible 00:01:49
que podamos enunciar claramente 00:01:51
qué tiene que hacer, es imposible 00:01:53
que podamos tener un enunciado claro de 00:01:55
tiene que hacer esto con no sé qué 00:01:56
si ese no sé qué no está 00:01:59
perfectamente caracterizado 00:02:01
vale, pues aquí 00:02:02
¿con qué datos va a trabajar nuestra aplicación? 00:02:04
pues pedidos, vale 00:02:07
¿y qué tienen los pedidos? 00:02:09
pues los pedidos 00:02:12
se caracterizan por un código 00:02:13
único 00:02:15
y un tipo 00:02:16
una descripción 00:02:18
y un precio, vale, lo de la variable tipo numerado 00:02:20
olvidadlo porque no hemos visto variables tipo numerado 00:02:23
¿vale? pero a cambio 00:02:26
lo que vamos a meterle es 00:02:28
los pedidos en lugar de tener solamente 00:02:31
código, descripción y precio 00:02:35
que tengan un listado de productos 00:02:37
¿vale? vamos a cambiar esto de numerado 00:02:40
por tipo 00:02:43
descripción y el precio lo cambiamos 00:02:48
por listado de productos, vale, y ahora sí, cada producto tendrá su nombre, unidades 00:02:51
y precio por unidad, bueno, ahora sí están caracterizados los datos, los datos son pedidos, 00:03:09
Cada pedido tiene 00:03:20
Código único 00:03:22
Lo de tipo 00:03:23
Tipo nos sobra, ¿verdad? 00:03:25
Pasamos del tipo 00:03:28
Vale 00:03:29
Código único, descripción de ese pedido 00:03:31
Y listado de productos 00:03:34
Y cada producto, nombre de ese producto 00:03:35
Unidades del producto y precio por unidad 00:03:38
Y podríamos completarlo 00:03:40
Poniendo el cliente que ha hecho el pedido 00:03:42
Etcétera, pero bueno, vamos a dejarlo aquí 00:03:44
El código único es del map solo, ¿no? 00:03:46
No, es que esa es otra pregunta 00:03:48
Que es donde voy a guardar los datos 00:03:49
Donde los voy a guardar y como 00:03:52
Vale 00:03:54
Entonces el pedido se va a caracterizar por un código 00:03:55
Se tiene que caracterizar 00:03:58
Otra cosa es, vale, ahora como guardo esos datos 00:03:59
Que es que ya nos está diciendo aquí como hacerlo 00:04:01
Nos lo está ordenando 00:04:04
Vale, pero nosotros antes 00:04:06
Hemos hablado con el cliente 00:04:08
Y le hemos dicho, a ver, de este pedido 00:04:10
A ti que datos te interesan 00:04:12
Pues cada pedido va a tener un código 00:04:13
Tiene que tener un código único 00:04:14
cada pedido para que yo lo pueda localizar rápidamente 00:04:16
para que no confundir pedidos con otros 00:04:19
vale, pues venga, cada código un pedido 00:04:21
tú vas ahí apuntando con 00:04:22
tus apuntes 00:04:24
¿qué más quieres que tenga el pedido? hombre, pues 00:04:26
una descripción para que cuando yo lo localice ese pedido 00:04:28
pues de dónde ha salido, si es 00:04:31
urgente, si no es urgente, lo que sea 00:04:33
y también los productos para que yo tenga 00:04:34
que servirlo, pues para saber lo que tengo que ir a buscar 00:04:37
al almacén, vale 00:04:39
versión reducida, porque lo ideal sería 00:04:40
tener un cliente, para saber a quién enviárselos 00:04:42
porque si no, no sabes a quién enviárselos 00:04:45
pero bueno, lo dejamos así 00:04:47
vale, entonces ya tenemos claro y ya vamos a apuntar 00:04:48
nuestro blog de notas, vale, tus pedidos 00:04:51
necesitan esto, y ahora ya 00:04:53
tú ya te vas 00:04:55
y te haces la siguiente pregunta 00:04:56
que es, ¿dónde voy a guardar esto? 00:04:59
lo normal es que 00:05:02
lo guardáramos en una base de datos 00:05:03
tabla productos, tabla pedidos 00:05:04
¿vale? cada producto 00:05:07
clave ajena a un pedido, ¿verdad? 00:05:09
cada producto pertenece 00:05:12
a un pedido, pues clave ajena, algo así 00:05:13
en nuestro caso no podemos 00:05:15
hacer esa parte porque 00:05:17
aunque sabemos, sabéis diseñar 00:05:18
una base de datos 00:05:21
no sabemos acceder a ella desde una aplicación 00:05:22
luego esa solución por ahora 00:05:26
no nos vale, bueno pues vamos a 00:05:27
guardarlos localmente 00:05:29
menuda birria porque va a tener 00:05:31
que estar la aplicación arrancada siempre 00:05:33
como se vaya a la luz todos los pedidos 00:05:35
el historial de pedidos se ha ido fuera 00:05:37
pero bueno 00:05:39
si no se va a la luz pues no funciona 00:05:40
la aplicación bien 00:05:43
pues donde los guardamos 00:05:44
localmente hemos dicho 00:05:47
una variable de la aplicación 00:05:48
¿cómo? pues hombre 00:05:49
el tío me ha venido a decir que el código 00:05:52
es lo que le va a ser a él útil 00:05:54
para localizar un pedido rápidamente 00:05:56
ver la descripción que tiene 00:05:58
sus unidades 00:06:00
pues hombre, maravilloso si yo uso 00:06:01
un map, porque el map precisamente 00:06:04
lo que me ofrece es 00:06:06
la rapidez en localizar algo 00:06:08
por clave 00:06:10
si yo lo meto todo en un set 00:06:11
pues para localizarte o quitar a Aries 00:06:14
un rollete 00:06:16
no hace falta 00:06:17
tú ya lo diseñas 00:06:21
si quieres que la tengas, si no la tengas 00:06:22
pero el pedido 00:06:24
queda identificado por su código 00:06:26
otra cosa es que no esté en la clase pedido 00:06:28
pero conceptualmente 00:06:30
el pedido tiene su código 00:06:32
luego tú ya decides cómo colocas esos datos 00:06:33
como lo planteabas al principio me sonaba más 00:06:36
a que el pedido lo iba a tener 00:06:38
como D1 00:06:39
claro, yo no estaba hablando 00:06:40
de clase pedido, estaba hablando 00:06:44
del pedido real de la persona 00:06:46
del pedido real de la persona, no estaba pensando 00:06:47
ya, no estaba pensando todavía en cómo hacer la clase 00:06:49
pedido, aun así 00:06:52
lo natural es 00:06:53
si un pedido se caracteriza por su código 00:06:56
independientemente de que yo lo meta en un map 00:06:57
que también le ponga la propiedad código 00:06:59
que también, ¿no? porque lo caracteriza 00:07:01
aunque esa propiedad va a estar 00:07:04
también en el 00:07:06
en la clave del map, pero 00:07:07
en cualquier caso, si yo utilizo ese pedido 00:07:09
fuera del contexto del map 00:07:12
pues está bien que tenga su propia 00:07:13
ID dentro 00:07:15
caracterizándola, que sirva para 00:07:17
equals, que sirva para cosas 00:07:19
claro 00:07:21
claro, depende de las funcionalidades 00:07:22
que quieras hacer, depende de, pero siempre 00:07:25
va a ser más escalable 00:07:27
esta aplicación, más, vas a poder 00:07:29
añadir funcionalidades más fácilmente 00:07:31
si pedido tiene dentro su ID 00:07:33
porque te va a facilitar la vida 00:07:35
si no, si se va a quedar ahí y todo lo que 00:07:37
haces, lo haces con el map, pues da igual 00:07:39
porque ya está el ID en 00:07:41
vale, bueno pues entonces 00:07:43
los datos van a estar en un map 00:07:45
más o menos con estos requisitos 00:07:47
y ahora ya 00:07:49
que funcionalidades tenemos que hacer 00:07:51
pues bueno, quiero insertar un pedido 00:07:54
nuevo, quiero consultarlo 00:07:56
por código, quiero modificarlo 00:07:58
y añadiremos algunas, pues gestionar 00:08:00
los precios, gestionar búsquedas 00:08:01
lo que sea 00:08:04
y además con una interfaz gráfica, entonces tendremos que 00:08:04
decidir pues cuantos paneles hacemos 00:08:07
para que tenga cositas, pero lo primero son 00:08:09
los datos. Entonces vamos a arrancar el dentro de ejercicios, interfaces gráficas, que esto 00:08:11
yo creo que, no sé ni dónde estaba esto, pero esto es, a ver, ¿cómo se llamaba este 00:08:28
proyecto? Ejercicios, clase, interfaces gráficas, vale. ¿Qué habíamos hecho? El arcao y el 00:08:54
ejercicio 2. Pues venga, vamos a poner, en lugar de un proyecto nuevo, lo meto en un 00:08:59
paquete, todas las clases hay 00:09:04
a mogollón, muy feo, pero bueno, así 00:09:06
para subirlo a la virtual es más fácil. 00:09:08
Diez. 00:09:10
Vale, de nuevo todo esto que estamos haciendo 00:09:19
es con el objetivo de repasar 00:09:21
una y otra vez lo de siempre. 00:09:23
Lo de que algunos ya sabréis y os aburriréis muchísimo, 00:09:25
pero hay que acostumbrarse al aburrimiento 00:09:27
también. Y los que no, 00:09:29
pues que lo utilicen como 00:09:31
repaso de lo mismo 00:09:33
y una y otra vez. Gestión de clases, 00:09:35
de métodos, de colecciones. 00:09:37
Claro, claro, una aplicación con interfaz gráfica 00:09:41
Para gestionar todos esos pedidos 00:09:44
Pues venga, nuestros datos 00:09:45
Nuestros datos los vamos a poner en una clase 00:09:47
Aparte 00:09:50
Nuestros datos van a estar aquí 00:09:51
Accesibles 00:09:58
Por todos los métodos de la aplicación 00:09:59
Metidos en un HashMap 00:10:02
Por ejemplo, donde 00:10:05
Si el código es entero 00:10:07
Pues será integer 00:10:09
Y la clave será el objeto pedido 00:10:10
vale, pues ya tenemos importados 00:10:13
estos dos y la clase pedido 00:10:41
pues hay que hacerla 00:10:44
pues venga 00:10:45
vamos a hacer la clase pedido 00:10:50
y la clase pedido 00:10:53
como los pedidos se caracterizan por un código 00:11:00
vamos a ponérselo, otra cosa es que luego 00:11:03
a lo mejor no lo usemos porque como ya está 00:11:05
duplicado en la clave del map pues igual 00:11:06
no nos hace falta pero nos podría hacer 00:11:08
Descripción y listita de productos. 00:11:11
Pues nada, habrá que importarlo todo. 00:11:52
Producto, vale, bueno, vamos a crear producto lo primero para que me ofrezca luego el import. 00:11:54
Producto 00:12:06
Pues le hace falta 00:12:09
Y producto era solamente el nombre 00:12:10
Las unidades 00:12:13
Y el precio 00:12:23
Y aquí ya sí que podemos hacer 00:12:32
Los constructores 00:12:37
No, ¿cuántos de este producto? 00:12:39
Cuatro bolis, cinco gomas 00:12:53
Ocho rotus 00:12:54
Get it set 00:12:55
Vale 00:13:12
hay clave primaria en esta clase 00:13:15
si no la hay, que diseño más 00:13:18
peligroso 00:13:20
si, podemos entender que hay clave 00:13:22
primaria que es el nombre 00:13:24
pues vamos a ponerle un jasco de equals 00:13:25
por si las moscas 00:13:28
y efectivamente como pedido 00:13:32
va a trabajar con una lista 00:13:41
si nosotros dentro de los productos 00:13:42
quisiéramos añadir un 00:13:44
ver si un producto está en esta 00:13:46
lista, pues gracias 00:13:49
sea ese jasco de equals, podríamos hacerlo 00:13:51
con el contains. Sin ese 00:13:52
jasco de equals, el contains 00:13:55
dentro de producto no nos valdría. 00:13:57
Entonces, si una 00:13:59
funcionalidad fuera, mira 00:14:00
a ver en qué pedidos hay 00:14:03
bolis para comunicar al 00:14:04
cliente que los bolis se nos han acabado. 00:14:07
Pues ahí tendríamos que recoger los 00:14:09
pedidos, hacer un contains de productos. 00:14:10
Ese contains solo va 00:14:13
a funcionar si producto tiene jasco de equals. 00:14:15
Ahora sí 00:14:20
que podemos importar 00:14:20
esto. 00:14:22
Vale. 00:14:33
Un constructor 00:14:34
de pedido. 00:14:35
Tiene las tres propiedades, 00:14:43
constructores, 00:14:44
getter setter 00:14:47
y el 00:14:48
jasco de equals por nombre. 00:14:50
Ah, no, el jasco de equals lo he hecho por los tres. 00:14:51
no, lo he hecho por nombre 00:14:53
es que como 00:14:56
aquí me 00:15:00
no, no, no, lo he hecho por los tres 00:15:01
lo he hecho por los tres 00:15:04
claro, veía que yo mucho 00:15:06
claro, por los tres no tiene 00:15:07
sentido 00:15:10
jascode 00:15:10
equals solo por nombre 00:15:16
dime 00:15:18
la clase para los datos de la aplicación 00:15:23
que los datos van a ser un map 00:15:30
de pedidos 00:15:33
indexados 00:15:34
por su clave 00:15:37
por su código 00:15:38
aquí van a estar los datos guardados 00:15:40
se supone que se habrán volcado 00:15:45
de una base de datos 00:15:46
pero en muchos 00:15:47
supone 00:15:51
en muchos 00:15:51
supone 00:15:55
no porque 00:15:55
Normalmente cuando 00:16:02
Claro, cuando una entidad tiene alguna propiedad 00:16:04
Que son colecciones 00:16:06
Pues tú la instancias primero con sus datos básicos 00:16:07
Y se supone que luego esos datos los vas rellenando 00:16:11
Con el tiempo 00:16:13
La puedes poner, pero entonces cuando lo instancias 00:16:13
Pues si le pones null 00:16:16
Ya te has cargado este new de aquí 00:16:18
Entonces 00:16:20
Constructor normal 8 00:16:20
Y gettyset de todos 00:16:28
vale 00:16:32
y también puedo avanzar 00:16:39
no sé si lo voy a necesitar o no 00:16:41
pero tenemos clarísimo 00:16:43
que el código identifica de forma única 00:16:45
el pedido 00:16:47
pues desde luego no me va a poner 00:16:48
ningún problema el añadir el jasco 00:16:51
de equal, lo más que puede ocurrir es que sobre 00:16:53
pero molestar no va a molestar 00:16:55
y ayudar igual si que ayuda 00:16:57
si yo tengo que hacer 00:17:00
iteraciones sobre pedidos, etc 00:17:02
Pues mis datos ya están caracterizados 00:17:04
Voy a tener un montón de pedidos 00:17:09
Entonces en esta clase de datos 00:17:10
Lo normal es que uno ya incluya 00:17:17
Métodos para hacer las operaciones básicas 00:17:19
De acceso a estos datos 00:17:22
Que es insertar un pedido nuevo 00:17:23
Buscar recuperar pedido 00:17:26
Etcétera 00:17:30
¿Vale? 00:17:31
En este caso es que 00:17:33
Es decir, aquí 00:17:34
haríamos los famosos métodos 00:17:36
que os mencionaba ayer 00:17:39
CRUD 00:17:40
estos, vale 00:17:41
pues insertar uno, pues hombre 00:17:55
vale 00:17:57
pues aquí 00:18:15
tenemos que pensar 00:18:16
ahora ya si que tenemos que pensar un poquito en el funcionamiento de la aplicación 00:18:18
que es 00:18:21
a mi el 00:18:23
cliente que me ha pedido esta aplicación 00:18:25
lógicamente 00:18:27
me habrá dicho el que se va a sentar a usarla 00:18:29
esta gestión, ¿qué datos te va a dar del pedido? 00:18:31
Entonces, te va a dar 00:18:34
del pedido, oye, pues me acaban 00:18:35
de hacer un pedido urgente 00:18:37
para no sé dónde 00:18:39
con bolis 00:18:42
tres que cuestan cinco pesetas 00:18:45
y con ordenadores 00:18:47
ocho que cuestan doce pesetas. 00:18:49
¿Vale? 00:18:53
Entonces, esos son los datos que el tío va a meter. 00:18:53
Él no te va a decir 00:18:56
el código. No vas a tener 00:18:57
ayer secretario tuyo pensando 00:18:59
en el código, espérate voy a mirar los códigos 00:19:01
que ya estaban metidos, no te va a meter el código 00:19:03
todo eso lo gestiona la aplicación 00:19:05
vale, pues el problema llega 00:19:07
aquí, cuando tú quieres meter un pedido 00:19:09
nuevo, este código 00:19:11
de donde ha salido 00:19:13
claro, entonces la propia aplicación 00:19:14
lo tiene que generar, tiene que 00:19:17
garantizar que va a ser único para todos 00:19:19
los pedidos, único 00:19:21
bueno, pues eso nos es fácil de programar 00:19:22
podemos hacer aquí una variable estática 00:19:25
global que incrementamos 00:19:27
cada vez que insertamos un pedido nuevo, por ejemplo 00:19:29
podemos llamarlo 00:19:31
secuencia 00:19:44
para códigos 00:19:45
inicialmente 00:19:48
pues uno, por ejemplo 00:19:49
entero 00:19:51
vale, pues cada vez que se inserta un pedido 00:19:52
el pedido nos habrá llegado 00:20:00
nos ha llegado 00:20:02
con ese código sin 00:20:04
setear, vale, con ese código 00:20:06
está sin setear, pues venga 00:20:08
vamos a ponerle al pedido 00:20:10
setCódigo 00:20:12
esta secuencia 00:20:13
y ahora además lo metemos en el map 00:20:15
pedidos.put 00:20:18
con esta secuencia misma 00:20:21
estoy duplicando la información 00:20:23
pero bueno 00:20:26
sí, sí 00:20:26
que no pasa nada porque esté dentro también 00:20:29
me refiero que estoy poniendo el código en dos sitios 00:20:31
pero ya hemos dicho que eso tiene su utilidad 00:20:33
y aquí pongo el pedido p 00:20:35
secuencia 00:20:37
code 00:20:44
vale 00:20:44
esta es la versión más chuchurría 00:20:49
para hacer este insert 00:20:53
más chuchurría porque no me da 00:20:55
ningún tipo de 00:20:57
al que llama a insert pedido 00:20:58
y quien va a llamar a insert pedido 00:21:01
a insert pedido lo va a llamar un listener de nuestra 00:21:02
interfaz, un listener va a llamar 00:21:05
a insert pedido después de haber recogido los datos 00:21:07
y ese listener 00:21:09
no va a recibir ninguna realimentación 00:21:11
si dejamos el método así, menuda caca 00:21:13
no va a saber ese listener 00:21:15
si poner en la interfaz de nuevo 00:21:17
pedido insertado 00:21:19
no ha podido insertar pedido 00:21:20
no va a recibir ninguna realimentación 00:21:22
entonces, que este método 00:21:24
nos dé alguna realimentación 00:21:27
bueno, antes que nada, la secuencia 00:21:28
tendremos que dejarla incrementada 00:21:31
porque es que si no, vamos a estar repitiendo 00:21:32
y en vez de, claro, y ahora ya 00:21:35
la secuencia hay que dejarla incrementada, eso para empezar 00:21:39
y ahora ya tenemos que pensar 00:21:41
la realimentación que le damos 00:21:42
a la interfaz gráfica que me ha llamado 00:21:45
para saber si se ha insertado correctamente 00:21:47
o no, a través de un boolean 00:21:49
que me devuelva true o false, pues la más cómoda 00:21:51
porque como este tiene este 00:21:53
inactivo, el pobre, sin uso, void 00:21:55
pues la más cómoda es con un boolean 00:21:57
si este 00:21:58
dato 00:22:01
si este valor de retorno no fuera 00:22:02
void, porque la aplicación me tiene que devolver algo 00:22:05
mi manera de avisar 00:22:07
de que algo raro ha pasado, ¿cuál sería? 00:22:09
si se ha metido o no 00:22:12
con un drop 00:22:13
con una, lanzando 00:22:14
una excepción, tendría que crearme 00:22:17
una excepción y lanzarla desde aquí 00:22:20
y esa sería la manera que 00:22:21
el listener se enteraría de que algo raro 00:22:23
ha pasado, ¿vale? 00:22:25
porque no se puede enterar por el valor 00:22:28
de retorno, bueno, a menos que el método 00:22:29
si te devuelve nul es que no ha funcionado 00:22:31
y tú lo puedes sacar a partir de ahí 00:22:33
pero lo que quiero decir es que 00:22:35
tenemos dos maneras de avisar 00:22:37
desde luego jamás lo haríamos con un 00:22:39
sys o system.out ha fallado 00:22:41
porque aquí no hay consola por ningún lado 00:22:43
esto es una interfaz gráfica 00:22:45
o bien avisamos con el boolean porque el método no devuelve nada 00:22:46
o bien nos creamos una excepción 00:22:50
con ese mensaje y le hacemos aquí el flow 00:22:51
vale, pues aquí 00:22:53
¿qué puede fallar? 00:22:55
¿puede fallar algo en este put? 00:22:56
a ver, podría fallar que ya existiera 00:22:58
el pedido y por tanto el put 00:23:01
no funciona, porque cuando no funciona 00:23:03
el put más que no funciona 00:23:05
cuando no hace la inserción 00:23:07
cuando ya existe algo con una clave 00:23:08
pero no puede pasar 00:23:11
porque la secuencia se aumenta, con lo cual aquí 00:23:13
no se me ocurre nada que pueda 00:23:15
fallar, salvo que 00:23:17
pedido sea null, que algo haya fallado 00:23:19
en la aplicación 00:23:21
pues es que hasta eso 00:23:22
conviene verificarlo, porque nunca sabemos 00:23:24
a quién se le va a ocurrir a llamar insert pedido 00:23:27
a lo mejor este map lo ha puesto 00:23:29
a null, entonces hasta eso 00:23:31
conviene verificarlo 00:23:33
y decir, oye, si donde yo 00:23:35
tengo que meter los datos es nul 00:23:37
pues retún 00:23:39
false, bueno, o podríamos 00:23:43
depende de 00:23:45
como sea el resto de mi aplicación 00:23:46
pues 00:23:50
podríamos crear un map nuevo 00:23:51
eso claro, tendría yo que 00:23:53
juntarme con todo el equipo y decidir 00:23:55
cómo hacemos, pero bueno, vamos a optar 00:23:57
por esta opción, si algo ha pasado 00:23:59
y alguien ha eliminado el map 00:24:01
yo quiero que insert no se inserte 00:24:03
no quiero que genere uno nuevo 00:24:05
vale, tendría que 00:24:07
sentarme con los demás a decidir que quiero 00:24:09
si el mapa ha desaparecido 00:24:11
si quiero crear uno nuevo e insertarlo 00:24:13
y ya está, y quedarme callado 00:24:15
o quiero avisar de que, oye, este mapa ha desaparecido 00:24:16
bueno, vamos a dejarlo así 00:24:19
vale, pues lo que puede fallar aquí 00:24:20
a mí no se me ocurre otra cosa 00:24:22
en este código 00:24:24
que 00:24:26
no se me ocurre otra cosa 00:24:27
que aquí haya un null pointer exception 00:24:31
bueno, a ver, si nos ponemos muy muy muy exquisitos 00:24:34
también podría fallar esta cosa 00:24:37
si le pasamos un pedido null 00:24:39
porque aquí también saldría un null pointer exception 00:24:41
si nos ponemos ya el colmo 00:24:43
de hacer el método más robusto del universo 00:24:45
que no pare la aplicación 00:24:47
porque imaginaos que alguien llama a este método 00:24:48
pasándole un null 00:24:51
si alguien llama a este método 00:24:52
mal, que las cosas se llaman 00:24:55
mal a veces si le llama un null 00:24:57
aquí va a salir un pedazo 00:24:59
null pointer exception 00:25:01
parece una tontería, pero el usuario se le ha roto 00:25:02
la aplicación, ni interfaz gráfica 00:25:05
ni leches, pum, todo ha desaparecido 00:25:07
entonces, hombre, si la aplicación 00:25:09
está bien hecha, está todo bien coordinado 00:25:11
la interfaz gráfica no tiene la opción 00:25:13
de pasarle un DUN 00:25:15
bueno, hombre, claro que tiene 00:25:16
o sea, es que no es 00:25:19
la interfaz gráfica, eres tú en el list 00:25:21
en el que decides lo que pasas 00:25:23
entonces, bueno, esto ya sí que es 00:25:24
¿alguien está llamando por aquí? 00:25:26
sí, perdono 00:25:28
Ah, vale, que es cambio de clase 00:25:29
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
21 de marzo de 2025 - 10:54
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
25′ 34″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
110.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid