Saltar navegación

20241212 POO-Clases-Ejer_3 - 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 diciembre de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues 00:00:01
Eliminar persona 00:00:03
Sería 00:00:05
Lo mismo 00:00:10
Un boi porque el efecto del método 00:00:15
Se queda registrado aquí 00:00:18
Se queda registrado ahí 00:00:20
Ya está 00:00:22
Eliminar persona 00:00:22
Necesita este método 00:00:28
Que se le pase algo como parámetro 00:00:33
Necesita que se le pase algo como parámetro 00:00:35
¿Eh? 00:00:37
¿Sí o no? 00:00:40
¿Cómo que no? 00:00:41
Habrá que pasarle 00:00:46
Aquí entra 00:00:47
El concepto de 00:00:49
No nos olvidemos 00:00:50
De ligar esto con las bases de datos 00:00:53
Sí 00:00:55
Porque las aplicaciones trabajan con 00:00:56
Datos que normalmente están en bases de datos 00:00:59
Entonces aquí entra el concepto 00:01:01
Clave primaria 00:01:04
¿Os suena eso? 00:01:05
Claro, ¿qué es clave primaria? 00:01:07
Ese campo de una tabla 00:01:09
que identifica de forma unívoca a cada registro. 00:01:11
Pues en los objetos pasa igual. 00:01:15
Si uno ha hecho un buen diseño de clases, 00:01:18
alguno de los campos de la clase 00:01:20
tiene que servir para identificar de forma única a cada objeto. 00:01:22
De forma que si tú quieres eliminar a un objeto del array, 00:01:27
le pasas esa propiedad 00:01:31
y buscas el que tenga esa propiedad. 00:01:33
Entonces, aquí nuestra persona, si esta clase está bien diseñada, 00:01:37
alguno de estos campos debería servir para identificar de forma única a cada persona. 00:01:44
Porque si no hay un campo que identifique de forma única a cada persona, 00:01:52
luego esa aplicación seguro que va a tener efectos secundarios muy raros. 00:01:56
Porque si hay objetos que pueden tener el mismo conjunto de propiedades, 00:01:59
los mismos valores en sus propiedades, 00:02:05
¿Qué aplicación tan extraña? 00:02:07
¿Cómo puedo saber yo que son personas distintas 00:02:09
si se llaman igual a direcciones y variedad en la misma? 00:02:11
¿Cómo lo puedo saber a través de la dirección de memoria? 00:02:14
La dirección de memoria es absolutamente transparente para el usuario. 00:02:16
No pinta nada. 00:02:19
Las aplicaciones tienen un significado real. 00:02:20
Entonces, una clase estará bien pensada 00:02:23
si alguna de las propiedades, al menos una, 00:02:26
identifica de forma única los objetos. 00:02:30
De forma que si mi aplicación tiene varias personas, 00:02:32
pueda distinguir unas de otras. 00:02:35
Bueno, pues aquí el campo que le pega como clave primaria es el campo nombre, ¿verdad? 00:02:37
Esto no implica ningún tipo de codificación, no es que se ponga aquí nada para indicar que es clave primaria, no. 00:02:45
Es un tema de diseño, uno lo tiene que tener en mente. 00:02:51
Vale, pues entonces, si hemos decidido nosotros, porque lo hemos decidido, porque lo hemos hablado y lo hemos acordado, 00:02:54
que el campo nombre identifique de forma única 00:03:01
la persona 00:03:04
pues entonces mi método 00:03:05
eliminar persona que tiene sentido que reciba 00:03:07
el nombre de la persona a eliminar 00:03:10
lo que viene siendo la clave primaria 00:03:12
es que ya va en el pack 00:03:14
tú dices, elimíname la persona que se llame Pepito 00:03:19
pues te eliminará el objeto entero 00:03:22
cuyo nombre es Pepito 00:03:23
y con eso te eliminará todo 00:03:24
claro, porque nombre 00:03:26
es que esto no está bien diseñado. 00:03:32
Lo ideal sería que hubiera una cuarta propiedad 00:03:34
que fuera eso, el NIP, porque eso ya sí 00:03:36
que lo iba a identificar de forma única. 00:03:38
Pero como no lo tenemos, 00:03:41
asumimos que el nombre es lo que 00:03:42
identifica de forma única al... 00:03:44
Vale, pues ahora este método... 00:03:46
Nombre. Vale, pues 00:03:48
este método, ¿qué tendrá que hacer? Lo de siempre. 00:03:50
Una raya auxiliar 00:03:52
con una posición menos. 00:03:53
A ver, estamos dando por sentado 00:04:00
que la persona existe. 00:04:01
si no, bueno, devolvemos el mismo que había 00:04:03
y ya está, o sea, no lo tocamos y se acabó 00:04:06
entonces 00:04:08
este 00:04:10
va a tener como longitud 00:04:11
contactos o dis.contactos 00:04:15
me da igual, .length 00:04:17
menos uno, vale 00:04:19
entonces de nuevo estamos 00:04:21
asumiendo que solo hay una persona que se 00:04:23
llama así, pero claro 00:04:25
la aplicación tiene que tener una coherencia, un diseño 00:04:27
entonces si alguien lo ha diseñado así 00:04:30
es porque 00:04:32
en su contexto, hablando con el cliente 00:04:33
que le ha pedido la aplicación, le ha dicho, sí, sí, 00:04:35
no va a haber personajes que se llamen igual. 00:04:38
Porque si el que le ha 00:04:40
contado las necesidades que tiene 00:04:41
de su aplicación, le ha dicho, puede haber 00:04:43
personajes que se llaman igual. Entonces, tú, 00:04:45
como buen diseñador, habrás dicho, ah, pues voy 00:04:47
a meter un campo adicional. 00:04:49
Y de NIV lo que sea. Que lo identifique 00:04:51
de forma, porque si no, la aplicación lo va a ser un pitote. 00:04:53
Si todas las personas se pueden llamar igual, 00:04:56
misma dirección. Bueno, 00:04:58
en nuestro caso, como partimos 00:04:59
de la base, porque ya lo hemos hablado y acordado 00:05:02
que cada persona tiene 00:05:04
nombre único, 00:05:05
pues eliminar la 00:05:08
persona de este nombre será quitar 00:05:10
una posición solo, que será quitar una. 00:05:11
Por eso el auxiliar tiene 00:05:14
solo menos una, la que quitamos. 00:05:16
Tiene solo menos una. Y ahora ya 00:05:17
lo de siempre, esto ya es automático, 00:05:20
lo que hacemos siempre. 00:05:22
Esta va a ser la posición donde vayamos 00:05:24
copiando del viejo en el nuevo, 00:05:26
saltándonos 00:05:28
el que hay que eliminar, pues se acabó. 00:05:29
ahora ya recorremos 00:05:32
el array contactos 00:05:34
mientras 00:05:37
i sea menor que 00:05:40
contactos 00:05:43
punto length incrementando 00:05:45
i, pues que tenemos que hacer 00:05:47
aquí, si la 00:05:49
persona del array 00:05:50
original contactos no es la que tengo que 00:05:52
eliminar, aux a la posición 00:05:54
que toque 00:05:56
si contactos 00:05:57
de i 00:06:00
Punto get nombre 00:06:01
Con el get, no puedo hacer a la propia 00:06:04
Directamente con punto nombre 00:06:06
Punto equals, porque es un string 00:06:08
Los strings se comparan con equals 00:06:10
No con doble igual 00:06:12
Nombre 00:06:13
Pues si esto no es así 00:06:16
O sea, un no delante 00:06:20
Y aquí 00:06:22
Me sobra, me falta algo 00:06:30
Pues si la persona 00:06:36
De posición y 00:06:38
su nombre no es el que me han pasado 00:06:39
copiarla en aux 00:06:42
pero en la posición que toque 00:06:44
y dejarla incrementada 00:06:45
inicialmente tocará la 0 00:06:47
pero vale, entonces 00:06:49
esto lo estamos haciendo 00:06:51
todo el rato 00:06:53
si copiarais en i 00:06:55
directamente 00:06:58
estaríais dejando una en medio sin rellenar 00:06:59
esto mismo lo hicisteis en el examen 00:07:02
y lo hacemos ya automáticamente 00:07:04
entonces esto, copiar una raíz en otro 00:07:06
saltándote posiciones 00:07:08
no copiando posición por 00:07:09
posición clavada 00:07:12
sino saltándote posiciones 00:07:13
pues tenemos que hacerlo así 00:07:15
y es el índice del primer array 00:07:18
y pos el del segundo 00:07:22
avanzo el del segundo 00:07:24
solo cuando copio 00:07:26
¿vale? 00:07:28
y aquí 00:07:29
aux pos 00:07:31
más más igual a contactos 00:07:35
Ahí, claro, obviamente 00:07:37
Vale, pues esto 00:07:38
Claro, no hagáis aquí 00:07:44
Lo de pongo un i, porque estáis repitiendo 00:07:47
El error de siempre 00:07:49
Que hemos hecho mil veces 00:07:50
Vale, pues el arrao y auxiliar 00:07:52
Ya tiene 00:07:57
El arrao y auxiliar 00:08:03
Es el que tenemos que devolver 00:08:05
Vale 00:08:06
Si es distinto 00:08:11
Es una condición 00:08:14
A ver, si el nombre que me han pasado 00:08:24
No es igual al nombre de la posición 00:08:27
Pues cópialo 00:08:31
O sea, la condición es 00:08:33
Es un no delante 00:08:36
No igual 00:08:37
Esta es la condición de 00:08:38
Nombre de contactos de Y es igual a nombre 00:08:40
Pero tú quieres no ser igual 00:08:44
Pues tienes que ponerle un no delante 00:08:46
Es el operador not, ¿vale? 00:08:47
Vale 00:08:51
Aquí lo único es que podemos 00:08:52
Prever ya una situación fea 00:08:54
Que puede ocurrir 00:08:56
¿Qué ocurre si no hay en el array? 00:08:57
A ver, pregunta 00:09:00
Muy interesante 00:09:01
Para que me hagáis caso 00:09:03
Tiene que haber un menos uno 00:09:05
No, pregunto, espera 00:09:07
Pregunta 00:09:09
¿Qué ocurre si no hay ninguna persona 00:09:10
con ese nombre, yo le doy a eliminar 00:09:13
persona, mi libreta 00:09:16
Pepito, y en libreta 00:09:17
no existe Pepito 00:09:20
¿qué ocurriría? 00:09:21
¿qué tipo de error saldría? 00:09:24
claro, saldría 00:09:26
rain de sauronbaos porque este 00:09:28
post incrementaría 00:09:30
y se saldría del menos uno 00:09:31
llegaría a la siguiente 00:09:33
¿vale? porque nunca hemos 00:09:35
nunca hemos 00:09:37
o sea, estamos todo el rato 00:09:40
entrando aquí, porque esto nunca se da 00:09:42
estamos todo el rato entrando, todo el rato entrando 00:09:44
estos irían que me entrando 00:09:46
y trataríamos de escribir 00:09:47
en la siguiente a la última 00:09:50
reservada, en la siguiente a la última 00:09:52
entonces saldría una write in desbound exception 00:09:54
luego de alguna manera 00:09:56
hombre, tenemos que proteger 00:09:58
de que el usuario me meta un nombre 00:10:00
que no existe 00:10:02
¿vale? 00:10:02
claro, pues entonces 00:10:05
bueno, o le damos una hostia directamente 00:10:07
pero, claro 00:10:10
Claro, podemos regularlo de muchas maneras 00:10:12
Pero haciéndolo a través de POS 00:10:14
Efectivamente, y detectando 00:10:17
Si POS ha llegado a la última 00:10:18
Pues ya está, por ejemplo, podemos hacer aquí 00:10:20
Yo que sé 00:10:22
Si la posición 00:10:23
Después de hacer el incremento 00:10:26
Se ha quedado ya 00:10:28
Resulta que es igual ya 00:10:29
Que con tantos punto Lens 00:10:32
Menos uno 00:10:35
¿Vale? 00:10:37
Bueno, lo que pasa es que hemos llegado ya 00:10:43
Hemos guardado ya en la última 00:10:44
Eso significaría 00:10:47
Que hemos llegado al final sin haber encontrado 00:10:49
Que hemos llegado al final sin haber encontrado 00:10:52
Entonces aquí podemos 00:10:53
Encontrado 00:10:55
Igual a true 00:11:02
Y aquí le ponemos 00:11:04
Pues lo siento pero 00:11:07
Encontrado 00:11:08
Bueno, la verdad es que esto está muy mal programado 00:11:09
Sería mucho más fácil 00:11:13
Al revés, poner el encontrado 00:11:14
Aquí, bueno, pero bueno 00:11:17
Podéis cambiar este código para que quede más bonito 00:11:18
Y ahora ya aquí simplemente 00:11:22
Si no lo hemos encontrado 00:11:27
Pues le decimos 00:11:30
Pues no existe la persona de ese nombre 00:11:33
Y vamos a hacerle un else 00:11:37
Ya que estamos 00:11:47
Que sea persona eliminada 00:11:48
Hombre, ya que estamos teniendo la aplicación amigable 00:11:51
Pues en el de agregar persona 00:12:12
Estaría bien hacer un system out 00:12:14
Persona agregada 00:12:16
Porque si no, no sabemos ni lo que ha hecho ni nada 00:12:17
Vale 00:12:19
Vale 00:12:37
Y a ver, gente despierta 00:12:39
¿Qué me falta en este método? 00:12:41
Para terminarlo 00:12:43
Eso 00:12:44
Mira, parecías dormida 00:12:48
Y no 00:12:52
Parte de tu cerebro estaba despierto 00:12:56
Vale, contactos igual a aux 00:13:00
¿Funcionará esto? 00:13:04
Pues Dios lo quiera 00:13:06
Vamos a ver 00:13:07
Caso 3 00:13:08
Contactos igual a aux 00:13:10
Vale, pues aquí lo único que hay que pedirle 00:13:20
Para la opción 3 es pedirle el nombre 00:13:25
Y ya está 00:13:27
Le pedimos el nombre 00:13:28
Y ahora llamamos a la libreta 00:13:36
Punto 00:13:39
Eliminar persona 00:13:41
Y ya directamente le pasamos el 00:13:43
Nombre leído con el next line 00:13:45
Y así ni hago variable ni hago nada 00:13:47
Aunque bueno 00:13:49
Esto hace un poco 00:13:52
Más confuso el código 00:13:56
No poner una variable aparte lo hace más confuso 00:13:57
Pero bueno como es un código cortito 00:14:00
Y nos entendemos 00:14:02
Y pongo la opción que no la había puesto 00:14:03
Eliminar 00:14:12
Persona 00:14:22
Vamos a ver 00:14:33
Vamos a agregar a una 00:14:34
Venga 00:14:35
Persona agregada 00:14:37
Efectivamente aquí está 00:14:42
Vamos a agregar a otra más 00:14:43
Vamos a ver si esta también está 00:14:46
Si ahora tenemos dos 00:14:52
Vale 00:14:53
Vamos a eliminar a la primera de ellas 00:14:55
La persona no existe en la libreta 00:14:58
¿Vale? 00:15:04
Se borra 00:15:05
Con lo cual algo hemos hecho mal en el live 00:15:08
Es porque estamos volviendo al auxiliar 00:15:11
Y el auxiliar se copió hasta la mitad 00:15:12
O sea, copió hasta el último 00:15:13
Ah, claro, que solo tengo que devolver el aux en el 00:15:15
Vale, vale, vale 00:15:17
Muy bien, muy bien, estás muy despierta 00:15:18
Claro, claro, o sea, contactos.aux 00:15:20
Control 00:15:23
X, lo tengo que meter 00:15:25
Solo aquí 00:15:27
Solo cuando la persona está eliminada 00:15:28
Claro, vale 00:15:31
Muy bien 00:15:35
No, a ver 00:15:36
No ha sido un error de no poner las llaves 00:15:41
Es que no me da, que no, que lo he hecho mal 00:15:43
Podría decir, ah, no han sido las llaves 00:15:45
No, es que lo he hecho mal 00:15:51
Hay que reconocer los errores 00:15:52
Vale 00:15:56
Vale, persona agregada 00:15:59
Agregamos otra 00:16:06
Vale 00:16:10
Eliminamos la primera 00:16:17
De ellas 00:16:19
A ver, vamos a ver 00:16:20
Tres 00:16:26
Digo dos 00:16:27
vale, no, pues ahora lo que ha fallado es 00:16:30
eliminar, la persona no existe, no la he encontrado 00:16:32
por nombre, luego tenemos otro error aquí 00:16:35
muy interesante 00:16:36
no he buscado 00:16:37
nos viene genial, venga, a ver 00:16:39
¿dónde está ese error? 00:16:42
vamos a ver, introduzca 00:16:45
nombre, lo leemos aquí 00:16:46
libreta de direcciones 00:16:48
eliminar persona 00:16:53
vale 00:16:56
Bueno, no, pero da igual 00:16:57
Porque 00:17:06
No, porque da lo mismo 00:17:06
Este for se va a hacer 00:17:09
Y es solo en la última iteración 00:17:10
En la última iteración 00:17:14
Es cuando ya entra aquí 00:17:16
Y en esa es la última ya 00:17:18
Porque ya será cuando contactos de i 00:17:20
Cuando 00:17:22
Y pos es igual a 00:17:24
Pos se queda incrementada 00:17:27
Vale 00:17:29
Contactos igual a 00:17:30
A ver qué falla aquí 00:17:36
Venga, a ver 00:17:37
¿Quién lo encuentra? 00:17:37
Trofe 00:17:38
Antes cuando tenía fuera 00:17:39
El contacto 00:17:41
Y fue igual a 00:17:41
Sí, me salía 00:17:42
Y ahora cuando le estoy poniendo 00:17:43
Me sale 00:17:45
No sé si 00:17:45
Bueno, pero 00:17:46
Dependería del caso de prueba 00:17:49
Pero a ver 00:17:51
Aquí solamente 00:17:51
Este 00:17:52
Array 00:17:53
Solo es válido 00:17:54
Cuando has eliminado 00:17:55
Una persona 00:17:56
Si la persona no existe 00:17:56
No tienes que tocar al array 00:17:58
No tienes que tocar 00:17:59
O sea que no es cuestión 00:18:00
De prueba y error 00:18:01
Sino hacerlo bien 00:18:01
Entonces 00:18:03
A ver 00:18:04
Aquí los boolean, los hemos puesto al revés 00:18:08
O algo, vamos a ver 00:18:11
A ver si esta condición está bien 00:18:12
¿No? ¿Está bien? 00:18:16
A ver si esta condición está 00:18:18
Sí 00:18:19
Yo creo que puede que el problema esté aquí 00:18:20
No, ¿no? Porque 00:18:26
Hemos 00:18:27
Pues lo dejamos incrementado 00:18:29
Ah, no, no, no, espera 00:18:33
Es que pues se queda incrementado 00:18:35
Entonces sería aquí, sería la siguiente, ¿verdad? 00:18:37
O sea que cuando hemos copiado la última 00:18:42
POS se queda incrementado 00:18:44
Entonces POS ya se queda con contactos 00:18:45
Vale, vale, vale, claro, es que nos falta a veces menos uno 00:18:47
Vale 00:18:49
Vamos a ver a probarlo 00:18:50
Introduzca nombre 00:18:52
Vale 00:18:56
Agregamos otro 00:18:58
Ahora 00:19:01
Vamos a eliminar a la personita 00:19:05
Esta de aquí, persona eliminada 00:19:08
Que no está 00:19:10
Casos de prueba raros 00:19:11
Cuando como consecuencia de eliminar 00:19:13
Me he quedado sin nadie en el array 00:19:15
Porque pueden salir 00:19:17
Siempre hay que hacer los casos de prueba límite 00:19:18
Vamos a eliminar 00:19:21
Para dejarlo vacío 00:19:24
Eliminar persona 00:19:25
Venga 00:19:26
Introducimos nombre 00:19:27
Persona eliminada 00:19:29
Y aquí no hay nadie 00:19:32
Vamos ahora a agregar 00:19:33
Porque a lo mejor he dejado el array null y no 00:19:34
Que no lo habré dejado null 00:19:37
Porque la hora deja cero, pero siempre hay que hacer casos de prueba 00:19:40
Por si acaso 00:19:43
Parece que sí 00:19:44
Entonces, bueno, más o menos 00:19:51
Con los casos de prueba a límites que hemos probado 00:19:53
Está todo 00:19:55
Ah, no, eso no lo he probado 00:19:57
Venga, vamos a eliminar 00:20:00
Esta 00:20:03
Ah, mira, qué bien 00:20:05
Qué caso de prueba también puesto 00:20:06
Muy bien, muy bien, muy bien 00:20:09
Claro 00:20:11
claro, efectivamente 00:20:12
muy bien, estáis 00:20:15
muy listos y muy despiertos 00:20:17
y estoy muy muy muy orgullosa de vosotros 00:20:19
yo por eso no la estaba terminando de hacer, estaba mirando 00:20:21
claro, estoy muy orgullosa, efectivamente 00:20:23
claro, es que aquí habrá que 00:20:25
poner un ant, claro, es decir 00:20:28
cuando ya POSA queda incrementado 00:20:29
claro, el ant de cosas 00:20:32
el ant de cosas 00:20:33
muy bien 00:20:34
vale, claro 00:20:36
vale, entonces 00:20:39
sí, a ver, uno se va aquí 00:20:41
cuando le sale el error, aquí lo natural es que uno 00:20:43
hace, uy, ¿qué pasa? te vas 00:20:45
aquí y tal cual te dices, coño 00:20:47
claro 00:20:49
pero es muy importante 00:20:49
a ver, cuando 00:20:52
uno ve esto y ya lo ve clarísimo, está claro 00:20:55
pero si no, es fundamental 00:20:56
que se vaya uno 00:20:58
a la primera línea de tu código 00:21:00
y ya aquí lo ves 00:21:02
rápidamente lo ves, entonces, ah, efectivamente 00:21:04
lo he dejado incrementado, con lo cual 00:21:07
En la siguiente iteración 00:21:09
Aquí me sale un pedazo a Reinders Bound 00:21:11
Entonces no quiero entrar 00:21:12
Si encontrado 00:21:14
Es igual a falso 00:21:17
Si no encontrado 00:21:18
¿Vale? 00:21:21
Mientras no lo hayas encontrado 00:21:25
Sigue 00:21:27
No, no, no, no 00:21:28
Mientras encontrado sea truco 00:21:29
No, a ver, cuando encontrado 00:21:32
Sí, a ver, cuando encontrado sea falso 00:21:33
Ya no quieres entrar 00:21:37
Entonces, y encontrado 00:21:37
Entonces, cuando encontrado sea falso 00:21:40
Ya no entras 00:21:42
Eso, vale 00:21:43
Venga 00:21:45
Ay, de verdad, qué cansancio me producís 00:21:51
Teníamos que haber parado 00:21:54
No, que está muy bien, me parece fenomenal 00:21:57
Que estéis tan avispados 00:21:58
Vale, vamos a eliminar 00:21:59
A... 00:22:02
¿O? 00:22:03
No, el mismo 00:22:06
Algo no hemos cambiado bien 00:22:07
Aquí tienes que entrar 00:22:10
Mientras 00:22:12
Igualmente 00:22:13
Se aumenta el post más más 00:22:14
No, pero a ver, yo aquí 00:22:18
En cuanto encontrado es igual a falso 00:22:19
Ya no quiero 00:22:22
Pero el post ya vale 00:22:23
O sea, es que ya no llega 00:22:25
Nunca llega a ser falso 00:22:28
Porque ya iba a ser menor 00:22:29
Vale, o sea, es que ya no 00:22:31
O sea, que no va a entrar nunca 00:22:33
Aquí cuando hayamos pasado el post 00:22:34
Vale, entonces, esto lo que hay que hacer es ponerlo antes y ponerle el menos uno. 00:22:37
Entonces, a ver, si postcontactos.led, si ya me he pasado, entonces, con llaves para que no nos estresemos. 00:22:45
Así. 00:23:01
Y si no, vale, ya estaría. 00:23:02
Espera, espera, espera. 00:23:11
Espera. 00:23:12
Ya estaría. 00:23:14
Vamos a ver. 00:23:15
Si pos ya sea contactos, la última posición de la raíz será contactos.led-1. 00:23:16
Entonces, si pos es contactos.led-1. 00:23:24
Aquí sí que va el menos uno. 00:23:28
Vale. 00:23:29
Entonces, si la posición ya es la siguiente a la última de aux, no lo he encontrado y no tengo que. 00:23:30
y si no lo es, pues entonces 00:23:39
sigo copiando. Aquí es donde ya me 00:23:41
salgo. Cuando pos igual a 00:23:43
contactos led menos uno. 00:23:45
Porque 00:23:48
la array aus tiene este tamaño 00:23:48
con lo cual la posición menos uno 00:23:51
es ya la primera no válida. 00:23:53
Es ya la primera no válida. 00:23:55
Entonces si pos ha llegado a ser la primera 00:23:57
no válida, si hemos llegado a este punto 00:23:59
de ser la primera no válida 00:24:01
es porque no la hemos encontrado. 00:24:03
Y no hay que guardar nada. 00:24:05
Y si no ha llegado a ser la primera 00:24:07
no válida, pues sigue, tú sigue 00:24:09
¿qué? 00:24:11
a mí me da un error de 00:24:13
que tiene documento negativo 00:24:15
bueno, a ver, vamos a 00:24:17
y ahora ya 00:24:19
este 00:24:21
en el foro yo creo que no hace falta ponerlo porque si hemos llegado 00:24:22
a esta situación es porque 00:24:25
ya el foro ya va a terminar 00:24:27
¿no? 00:24:28
el foro ya va a terminar igualmente 00:24:30
o sea, si hemos llegado a que post 00:24:32
valga esto 00:24:39
encontrado igual false 00:24:40
y eso significa que 00:24:44
si mi duda es 00:24:47
que ya no hace falta 00:24:51
que yo creo que ya no hace falta ponerlo aquí porque no entraría 00:24:52
en una siguiente, no, entraría en una más 00:24:57
si porque si van a la par 00:24:58
si entraría una más 00:25:02
entonces 00:25:04
claro, sí, es que hay que ponerlo 00:25:05
porque si no te entra una más 00:25:11
y entonces 00:25:12
pero POS no se ha incrementado, entonces no hace falta 00:25:13
yo creo que no hace falta porque 00:25:17
si ya has llegado a la última, no se incrementa 00:25:17
con lo cual, podrías entrar una más 00:25:20
podrías entrar una más y no molestaría 00:25:23
porque 00:25:25
POS seguiría siendo esto, o sea, haríamos 00:25:26
dos veces este if, es una pérdida de tiempo 00:25:28
pero bueno, a ver 00:25:30
bueno, está ya arreglado 00:25:32
no, que cuando ya hemos llegado a la última 00:25:38
aunque este for entre otra más 00:25:41
el post no se ha quedado incrementado 00:25:43
entonces, no, en realidad no para 00:25:45
porque entras una más 00:25:47
claro, pero vuelve a hacer 00:25:49
otra vez esto, porque el post se ha quedado en su sitio 00:25:51
vuelve a hacerlo otra vez 00:25:53
va a entrar una vez más 00:25:54
eso, nanosegundos 00:25:56
vale, pues entonces 00:26:00
todo este epifostio era 00:26:01
para 00:26:03
que si el nombre no existe 00:26:04
pos no crezca más allá 00:26:07
del tamaño que puede crecer 00:26:10
porque cuando ha llegado aquí 00:26:12
eso significa 00:26:14
que ya se ha rellenado completo y esa 00:26:16
posición ya no se puede rellenar 00:26:18
espera, vamos a ejecutar a ver si esta versión 00:26:19
está bien, yo creo que sí, ¿no? 00:26:24
vamos a ver, vamos a probar 00:26:26
vale, pues 00:26:28
venga, agregamos 00:26:31
una, vale 00:26:36
el caso de prueba que había fallado 00:26:40
que es el que estábamos arreglando 00:26:42
es cuando metemos una que no existe 00:26:44
la persona no existe 00:26:46
vale, vamos a ver 00:26:48
si sigue estando la otra, no se la ha 00:26:50
cargado, efectivamente 00:26:52
¿algún otro caso de prueba que se os ocurra 00:26:53
que podamos no haber contemplado? 00:26:56
se pone el 00:26:59
el que? 00:27:00
que elimine a Pepe 00:27:05
que elimine a Pepe 00:27:07
A ver 00:27:09
Elimino a Pepito 00:27:14
Pepe 00:27:18
Persona eliminada, mostrar información 00:27:21
No sabemos 00:27:24
A ver, también me gusta el error 00:27:35
De que si no hay nadie en la libreta 00:27:36
Quieres eliminar a alguien 00:27:38
Muy bien, pues eso hay que arreglarlo también 00:27:40
¿Vas a ser un tester? 00:27:45
¿Vas a ser? ¡Claro! 00:27:47
Mira, ¿tú sabes lo que cobran los testers? 00:27:49
Vas a ser de un equipo de pruebas 00:27:51
maravilloso, que cobran un huevo 00:27:53
El equipo de testing 00:27:55
que es el que pasa las pruebas de las aplicaciones 00:27:56
porque uno siempre se cree 00:27:59
que su aplicación está estupenda 00:28:01
y siempre va a tener errores, siempre 00:28:02
Entonces, el equipo de testing es el que tiene que tener 00:28:04
la clarividencia 00:28:06
De decir, mira, seguro que se lo has contemplado 00:28:08
¿Vale? 00:28:12
Vale, vamos a ver aquí 00:28:16
Nuestro tester 00:28:18
¿Qué ha hecho? 00:28:20
Pepe 00:28:23
Que vive aquí 00:28:23
Y que tiene 23 00:28:26
¿Vale? ¿Qué caso de prueba es el que no va a funcionar? 00:28:27
Ahora le elimino 00:28:31
A este, para que se quede vacía 00:28:32
Bueno, hay uno, pero lo quito 00:28:34
Vale 00:28:36
quito a Pepe, ahora 00:28:37
no hay nadie 00:28:39
ahora trato de eliminar, claro 00:28:41
vale, sí, pero este va a ser más fácil de arreglar 00:28:44
vale, entonces ahora 00:28:46
claro, esto se trata de distinguir 00:28:48
simplemente, vale, este es más fácil 00:28:50
de arreglar, claro 00:28:52
este es más fácil de arreglar, este es 00:28:53
a ver, métete en el fregado de eliminar 00:28:56
solo si personas 00:28:58
punto 00:29:00
contactos punto lens es mayor 00:29:01
que cero, si no, no 00:29:04
Entonces, este es más fácil de arreglar que es 00:29:06
Oye, cuidado 00:29:08
Si no tienes a nadie en el array 00:29:09
No te pongas aquí a recorrerlo 00:29:11
Porque si no, efectivamente te va a dar aquí 00:29:13
Un contactos.length null pointer exception 00:29:15
Bueno, aquí no, porque no es null 00:29:18
Te va a dar aquí 00:29:20
Cuando trates de acceder a la posición 0 00:29:21
Entonces, si 00:29:24
Contactos.length 00:29:25
No, esto no 00:29:31
Si contactos 00:29:33
Punto length 00:29:36
Es igual a cero 00:29:38
Entonces 00:29:40
¿Qué queremos hacer en ese caso? 00:29:42
Pues decimos 00:29:44
La libreta está vacía 00:29:46
Aquí podríamos meter esto en un else 00:29:49
Todo lo demás 00:29:57
Pero es que vamos a tener que empezar a formatear a la derecha 00:29:58
Y queda horrible y muy feo 00:30:01
¿Para qué? 00:30:03
¿Para qué sirve este maravilloso retun? 00:30:04
Este maravilloso retun 00:30:08
Ya lo hemos mencionado con funciones 00:30:09
te sale del método en el que estés 00:30:10
como este tiene void 00:30:12
no hay que devolver nada 00:30:15
si no tuviera void, tuviera un int, tuviera lo que fuera 00:30:16
pues tendría que devolver lo que fuera 00:30:19
pero como es void, no devuelvo nada 00:30:20
entonces 00:30:22
ahora ya vamos a eliminar una persona 00:30:27
libreta vacía, ya está 00:30:29
venga, más 00:30:31
¿qué más pegas tienes que ponerle? 00:30:32
vale 00:30:43
bueno, pues muy bonita 00:30:43
nos ha permitido sacar un montón 00:30:47
de cosas y este método de eliminar 00:30:49
nos ha tocado programar en él 00:30:51
que es lo que se hace todo el rato 00:30:53
uno hace una aplicación y lo que acaba haciendo 00:30:55
es programar, lo que acaba haciendo son 00:30:57
wildships, es lo que acaba haciendo 00:30:59
y es lo que hemos hecho aquí, que nos hemos encontrado errores 00:31:00
hemos tenido que arreglar, entonces por eso es por lo que 00:31:03
uno tiene que tener muy claras las bases 00:31:05
de la programación, clarísimas 00:31:07
y con el hábito pues ir encontrando los errores 00:31:09
lo que sea, dígame 00:31:11
vaya por dios 00:31:12
a ver 00:31:14
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:
13 de diciembre de 2024 - 18:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
131.47 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid