Saltar navegación

20260126 InterfacesEjemplo_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 27 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues el modelo está en dos versiones, 00:00:00
con una clase intermedia y otra que no. 00:00:07
Ahora, la aplicación ahora tiene una serie de funcionalidades 00:00:09
que tiene que dar, que son todo esto. 00:00:14
Tiene que poder registrar envíos, listar envíos, 00:00:18
dar el coste total de todos ellos, 00:00:21
dar el coste total que se ha gastado en seguros, 00:00:23
actualizar el estado de los envíos, que sean. 00:00:25
bueno pues tiene un montón de funcionalidades 00:00:29
esto es lo que se supone 00:00:31
que la persona 00:00:33
que está sentada con el ordenador 00:00:35
trabajando con los envíos 00:00:36
tiene que poder hacerlo, pues estas 00:00:38
estas mismas, vale 00:00:41
entonces 00:00:43
esto 00:00:44
lo vamos a recoger todo en una 00:00:46
clase 00:00:49
donde estén todos los métodos para hacer esto 00:00:49
vale, que serán llamados 00:00:53
ahora ya si de la aplicación principal 00:00:55
interfaz gráfica, mail, lo que sea 00:00:57
que sea lo siguiente a hacer 00:00:59
bueno, pues esto es lo que se supone 00:01:00
que se ha recopilado como las 5 00:01:03
cosas que la persona que se siente a ordenador 00:01:05
tiene que poder hacer con esos envíos 00:01:07
meter uno nuevo 00:01:09
mirar todos los que hay 00:01:10
calcular 00:01:13
el coste de todos ellos 00:01:14
calcular el coste de todos los seguros 00:01:17
y actualizar 00:01:19
el estado de cualquiera de ellos 00:01:21
bueno, esas 5 cosas 00:01:23
vale, pero claro 00:01:24
la pregunta natural 00:01:26
que nos tendríamos que haber hecho muchísimo 00:01:28
antes, muchísimo antes 00:01:30
incluso de empezar a enunciar 00:01:32
lo que el operador 00:01:34
tiene que poder hacer 00:01:37
nuestros datos de trabajo 00:01:39
¿cuáles son? pues nuestros datos de trabajo 00:01:42
son los envíos 00:01:44
esos envíos, un montón de envíos, son los datos 00:01:46
de trabajo, ¿dónde van a estar? 00:01:48
si son un montón de envíos 00:01:51
Hasta ahora mismo 00:01:52
Y esperemos que por poco tiempo 00:01:54
Solamente pueden vivir en un array 00:01:56
No pueden vivir en otro sitio 00:01:58
Hasta ahora mismo 00:01:59
¿Vale? Pues ese array 00:02:00
¿Dónde lo vamos a colocar? 00:02:02
Pues en lugar de colocarlo siempre en el main 00:02:04
Para que esté ahí siempre metido en el main 00:02:07
Vamos a colocarlo en una clase suya 00:02:09
Para él 00:02:11
Una clase suya donde viva ese array 00:02:12
Y así vamos separando un poco 00:02:15
Pues venga, nos hacemos otro paquete 00:02:18
Por ejemplo, paquete 00:02:21
Repositorio, por eso de que aquí están 00:02:25
Los datos 00:02:28
Ahí están los datos 00:02:28
Y ahora 00:02:35
Repositorio envíos 00:02:42
Por ejemplo 00:02:46
Repositorio envíos 00:02:46
Y aquí van a estar nuestros envíos 00:02:50
Colocados ahí, bien centralizados 00:02:55
Para que sea un main 00:02:57
Sea una interfaz gráfica, sea quien sea 00:02:59
Tire de ellos 00:03:01
Pues venga, public 00:03:02
Como nuestra colección de envíos 00:03:04
O array de envíos es única 00:03:07
En toda la aplicación, es única 00:03:09
Pues static desde el principio nos facilitamos 00:03:10
Su acceso 00:03:13
Y vamos a no tentar a la suerte 00:03:13
De los null pointer exception 00:03:24
Haciendo esto 00:03:25
Vale, entonces 00:03:28
Como tengo 00:03:34
Dos modelos 00:03:36
Yo voy a tirar del modelo 00:03:37
Dos, todo el, vale 00:03:40
Voy a hacerlo con el dos, no sé como lo habéis hecho vosotros 00:03:42
Y ya está 00:03:44
O sea, con la versión 00:03:45
Con la intermedia 00:03:47
Con la clase intermedia 00:03:49
Con el envío rastreable 00:03:50
Vale 00:03:53
Entonces voy a tirar 00:03:55
Vale, pues bueno 00:03:57
Aquí van mis datos 00:04:01
Entonces, lo normal 00:04:02
Lo normal 00:04:05
Esto como que simula un poquito 00:04:07
Pero simula un poco de lejos todavía 00:04:09
Simula un poco de lejos 00:04:11
Un patrón de acceso a datos típico 00:04:13
pero todavía está simulado un poco de lejos 00:04:15
así de andar por casa 00:04:17
lo normal es que si esta clase 00:04:18
tiene una caja con cosas 00:04:21
pues esta clase 00:04:23
te ofrezca como sacar y meter 00:04:25
cosas en ella 00:04:27
es lo normal, que te lo ofrezca 00:04:28
yo tengo mi caja y hombre no te voy a dar 00:04:31
la caja es mi clase 00:04:33
mi objeto repositorio envío 00:04:35
pues hombre no te voy a dar mi caja hermética 00:04:37
te doy una caja y además 00:04:39
te doy la opción de que la abras y saques algo 00:04:41
o la opción de que 00:04:43
metas algo, o incluso la opción 00:04:45
de que mires 00:04:47
lo que hay, o la opción 00:04:49
de que algo de lo que hay 00:04:51
lo cambies, tengo una caja 00:04:53
pues hombre, que menos que ofrecerte 00:04:55
que accedas a ella 00:04:57
y luego ya la aplicación 00:04:58
que use eso como le dé 00:05:01
la gana, pero al menos 00:05:03
el acceso básico a la caja, vamos a 00:05:05
dárselo desde aquí 00:05:07
sería como simular un patrón 00:05:08
más o menos de diseño, un poco así de acceso 00:05:11
a datos un poco chapucero, pero bueno, ya como que empezamos a ver un poquito 00:05:13
de qué van las cosas. Pues aquí aislamos, 00:05:17
separamos en una clase nuestra cajita con la opción de meter y sacar 00:05:21
cosas en ella. Lo dejamos ahí aisladito. Caja para meter y sacar cosas. 00:05:25
Esa caja con posibilidad de meter y sacar, ya que la use quien sea y como sea. 00:05:29
Bueno, vamos a hacer el método de 00:05:34
recuperar envío. Vale. Entonces, 00:05:36
recuperar 00:05:41
envío, pues por ejemplo 00:05:46
y vamos a ver 00:05:48
envío tiene que tener 00:05:57
una clave, algo que lo identifica 00:05:58
porque si no, menos mal 00:06:01
tenemos una propiedad que tiene toda la pinta de que es 00:06:03
única, que es código, menos mal 00:06:05
si no este diseño habría estado 00:06:07
muy feo 00:06:09
en los diseños, los objetos 00:06:10
tienen que tener algo que los identifique de forma única 00:06:13
porque si no, menos mal 00:06:15
hay un código, venga pues entonces 00:06:17
En repositorio envío 00:06:19
Recupera mi envío por código 00:06:21
Que el código es entero 00:06:25
O es string, como es el código 00:06:27
Es entero, vale 00:06:29
Pues int código 00:06:31
Pues que método tan bonito 00:06:33
Si yo lo hago 00:06:36
Ya sé que cualquiera puede coger 00:06:38
Un envío de la caja 00:06:41
Llamando a este método 00:06:42
Y ya está, que menos, ¿no? 00:06:44
Que menos que ofrecer un método 00:06:47
Que te permita recuperar un envío de la caja 00:06:48
Pues bueno 00:06:51
Hacer este método 00:06:55
Es muy fácil 00:06:56
Vamos a recorrer la colección 00:06:59
Si e.código 00:07:01
Es igual 00:07:15
Es un entero 00:07:18
Es igual a código 00:07:19
Ya lo tengo 00:07:22
Return 00:07:23
¿Qué le falta a este método? 00:07:28
¿Por qué sale aquí rojo? 00:07:41
Tienes que retornar 00:07:42
claro, creo que más que 00:07:43
retornar, tendría que devolver 00:07:47
claro 00:07:48
si este 00:07:50
es que si empezamos retornando llegamos a tal 00:07:54
así 00:07:57
este for 00:07:58
podría ocurrir que jamás se encuentre 00:08:00
un envío dentro 00:08:03
con ese código, entonces 00:08:04
el for termina, esto sigue 00:08:06
por aquí y el completador 00:08:09
te dice, ¿y ahora qué hago? 00:08:11
yo no me voy de aquí, si no me das a alguien para devolver 00:08:12
De ahí no me puedo ir, estoy ahí encerrado 00:08:15
Bueno, pues ahora que abre 00:08:17
Hay que ponerse de acuerdo 00:08:19
Y decir, a ver que devolvemos 00:08:20
Si no 00:08:22
Si no existe el envío, lo normal es devolver un objeto null 00:08:23
Peligrosísimo 00:08:27
Los null dan mucho miedo 00:08:30
Vale, yo devuelvo un null 00:08:32
Y luego la clase que sea que me llame 00:08:35
Se hace directamente un 00:08:38
Fine envío by código 3 punto no sé qué 00:08:40
Punto 00:08:42
Null pointer exception 00:08:43
si he puesto el código mal 00:08:45
pero bueno, estas cosas 00:08:46
esto, pues luego tiene una solución 00:08:49
que es envolverlo en otra clase, etc 00:08:50
pero bueno 00:08:53
vamos aparcando esas cosas 00:08:53
para el futuro 00:08:57
vale, bueno pues ya está 00:08:57
este método ya está 00:09:01
menos mal 00:09:01
menos mal 00:09:04
que he hecho esta inicialización 00:09:05
y así esto 00:09:08
nunca me va a dar este for 00:09:10
nunca va a petar, nunca va a explotar 00:09:12
porque incluso 00:09:14
cuando el array no tenga nada 00:09:16
el array no tenga nada 00:09:18
y llamemos a find 00:09:20
envío by código con un array vacío 00:09:22
que podría ocurrir con un array vacío 00:09:24
este for 00:09:26
que hace internamente entrar en el 00:09:28
array 00:09:30
como el array tendrá cero posiciones 00:09:31
entra y se va 00:09:34
pero no ha explotado, ha entrado, tienes 00:09:36
cero, me voy, pero si 00:09:38
esto no estuviera 00:09:40
esto sería un null 00:09:41
entonces el for este cuando entra 00:09:43
el array como es un null, pum, le sale 00:09:45
null pointer exception 00:09:47
entonces esta inicialización 00:09:48
viene muy bien 00:09:51
para que nunca nunca jamás 00:09:52
este array de envío sea null 00:09:55
ni siquiera cuando no tiene nada 00:09:57
ni siquiera cuando no tiene nada 00:09:59
porque si fuera null, repito 00:10:00
este for me daría null pointer exception al entrar 00:10:03
vale, pues recuperar 00:10:05
envío por código ya está, ya me han dado ese 00:10:07
método en la cajita y ya está 00:10:09
¿Qué otra cosa nos interesa hacer 00:10:10
Con esta caja? 00:10:14
Meter algo 00:10:16
Estas son las operaciones de 00:10:17
Consultar, insertar, recuperar 00:10:19
Y modificar 00:10:22
Las cuatro cosas básicas que se pueden hacer con unos datos 00:10:23
¿Verdad? 00:10:26
Cuando tenéis un conjunto de datos 00:10:28
Hay cuatro acciones que se pueden hacer con ellos 00:10:29
Punto, pelota, nada más 00:10:32
Recuperar 00:10:33
Por clave 00:10:35
Eliminar 00:10:36
por clave, insertar 00:10:38
uno nuevo y modificar 00:10:41
uno que ya está 00:10:43
son las cuatro acciones que se pueden hacer con los datos 00:10:44
y esto es tan así 00:10:47
que esto tiene un nombre 00:10:48
que se llama así 00:10:50
¿vale? cuando uno hace 00:10:53
un cruz, hazme el cruz de esto 00:10:56
pues ¿qué haces? los cuatro 00:10:59
métodos que te hacen las únicas 00:11:01
cuatro cosas que se pueden hacer con 00:11:03
datos, que son 00:11:04
insertar 00:11:05
créate, consultar o recuperar, real, actualizar y borrar, ¿vale? 00:11:07
Luego este es el acrónimo estándar que se usa continuamente cuando hablamos de trabajar con datos, 00:11:24
porque son las cuatro cosas que se pueden hacer, crear, consultar, modificar y borrar. 00:11:32
Pues eso justo 00:11:38
Lo estamos incorporando 00:11:39
A nuestra clase repositorio 00:11:42
Las cuatro cosas que se van a poder hacer con esos datos 00:11:43
No se puede hacer más 00:11:46
Luego ya combinando esas acciones 00:11:46
Cada aplicación que haga lo que le dé la gana 00:11:49
Pero combinando esas acciones 00:11:52
Pero esas son las cuatro básicas 00:11:53
Las cuatro únicas 00:11:55
Bueno, pues vamos, hemos hecho la de 00:11:56
Consultar 00:11:59
La R, hemos hecho la R 00:12:01
Es la de Farina que se echó 00:12:03
Sí 00:12:04
¿Vale? Entonces 00:12:05
Lo podemos incluso poner aquí 00:12:09
Hacemos 00:12:12
Las funciones 00:12:17
Crud 00:12:19
Que serían pues eso 00:12:22
Create 00:12:24
Reagudate 00:12:27
Y delete 00:12:31
Esto es lo que se puede hacer con datos 00:12:35
Nada más 00:12:39
Esta en particular sería la de 00:12:40
Leer 00:12:43
Vale, vamos a hacer ahora la de insertar un dato nuevo 00:12:44
No se llaman por 00:12:48
No es como un estándar 00:12:55
Llamarle create 00:13:00
Envío 00:13:01
Como lo de create insert 00:13:02
No es como un estándar 00:13:04
Sí, insert 00:13:05
Más bien, el nombre del método te refieres 00:13:08
Sí, sí 00:13:10
Insert 00:13:12
Vale 00:13:13
A ver que 00:13:15
Vale, pues este de aquí 00:13:23
Insert 00:13:39
Envío 00:13:42
Necesita un objeto envío entero 00:13:43
Insert 00:13:47
El sotaka o jirrey de siempre 00:13:51
Hacemos el array grande 00:13:53
New envío 00:13:55
Con el tamaño que tiene 00:14:05
Envíos 00:14:06
Más uno 00:14:08
copiamos el viejo en el nuevo 00:14:12
que sería aux de i 00:14:21
igual a envíos de i 00:14:35
y ahora ya la nueva posición se va a la última 00:14:42
posición de aux, que es aux.length-1 00:14:47
esta es la última posición de aux, a esta le ponemos 00:14:52
el envío nuevo, y ahora ya aux es el 00:14:55
definitivo tiene lo viejo 00:14:59
más el adicional que hemos 00:15:01
copiado en la posición adicional 00:15:03
con lo cual tenemos que sobre escribir 00:15:05
envíos 00:15:07
igual a aux 00:15:10
vale 00:15:22
esto es lo de siempre que luego con colecciones 00:15:32
es inmediato con colecciones 00:15:42
haces un add y ya 00:15:45
pero claro diréis uy que fácil con colecciones 00:15:47
el problema de las colecciones es que es muy fácil 00:15:49
porque con un método haces todo 00:15:52
El problema son los efectos secundarios 00:15:53
Si no las has diseñado bien 00:15:55
Porque puede no estarte funcionando como crees 00:15:56
Vale, esto ya lo habéis 00:15:59
Otro segundo 00:16:02
¿Vale? 00:16:04
Vale, y aquí un momentito 00:16:28
A ver 00:16:30
Lo que cambia, lo que pasa es que 00:16:56
Hay una cosa que me tiene 00:16:59
Un segundito 00:17:01
Sí 00:17:04
Pero los métodos estáticos, porque cuando tú haces una propiedad estática, además dices que solo hay una, solo hay un envío, sí, ya está, no va a haber más. 00:17:05
Claro, aunque tú instanciaras muchos de estos objetos, solo hay uno. 00:17:12
Y no solo eso, sino que este objeto puede vivir independientemente de que exista un objeto de esta clase, no lo necesita para nada. 00:17:16
Pero los métodos, entonces, estáticos... 00:17:24
Los métodos estáticos son métodos que pueden ser llamados sin que exista ningún objeto previo. 00:17:28
Vale. 00:17:34
Esa es la diferencia 00:17:34
Un método que no es estático 00:17:35
Necesita la existencia de un objeto de esa clase 00:17:37
Para ser llamado 00:17:40
Aunque no use los métodos del objeto 00:17:41
Lo necesita para ser llamado 00:17:43
Un método estático 00:17:45
Puede ser llamado sin que exista ningún objeto 00:17:46
De la clase 00:17:50
Y lo llamas con el nombre de la clase 00:17:50
Sin más 00:17:54
Pero claro, para que el compilador te lo permita 00:17:54
Tienes que identificarlo con el static delante 00:17:57
Tienes que identificarlo con el static delante 00:18:00
Claro, si yo no lo he 00:18:01
Identifico con el static delante, tengo que hacer un 00:18:04
NewRepositorioEnvíos 00:18:06
Que no me va a valer para nada, salvo 00:18:07
Para llamar a este 00:18:10
Pero si le pongo el static delante ya ni me hace 00:18:11
Falta hacer el newRepositorioEnvíos 00:18:14
¿Vale? 00:18:16
Entonces el método de insertar envío ya lo tenemos 00:18:18
Borrar 00:18:20
Pues el método de borrar 00:18:23
Se le pasa 00:18:29
Un código 00:18:31
Es borrar por clave primaria 00:18:39
Y tendrá que borrar 00:18:42
el elemento con ese código 00:18:44
este es un poquito el más complicado 00:18:46
el más lioso 00:18:48
porque aquí se trata de 00:18:49
copiar 00:18:52
y pegar, hacer uno 00:18:54
con una posición menos 00:18:56
y copiar y pegar en el otro 00:18:58
saltándome ese código 00:19:00
y además convendría detectar si el código 00:19:02
no está, pues no hacer nada 00:19:04
entonces aquí tendríamos que hacer 00:19:06
una raya auxiliar 00:19:08
con una posición menos 00:19:09
porque estamos borrando por clave primaria 00:19:12
solo borro uno como mucho, que será un new envío, envíos.leds menos uno. 00:19:14
Y ahora vamos a recorrer, menor que envíos.leds, incrementando y, 00:19:30
llevamos dos índices por separado, porque el índice de envíos y el índice de aux 00:19:44
No es el mismo porque en algún momento 00:19:50
El índice de envíos 00:19:52
Aumentará y el de aux no 00:19:54
Porque no habremos copiado 00:19:56
Entonces necesitamos otra 00:19:58
Este es el índice de aux 00:19:59
Y este es el índice de envíos 00:20:08
Y ahora 00:20:09
El índice de envíos va aumentando siempre 00:20:11
Entonces aquí que hacemos 00:20:13
Aux 00:20:15
De j 00:20:17
Perdón si el código es diferente 00:20:19
Claro, si 00:20:21
En envíos de i resulta que su código es distinto del que tengo que borrar, distinto del código a borrar, pues entonces aux de j igual a envíos de i. 00:20:22
y j lo dejo incrementado 00:20:50
para que la siguiente copia 00:20:54
se haga en el siguiente 00:20:55
e i no hace falta porque ya está aquí 00:20:57
y ya está 00:20:59
entonces esta parte del código 00:21:03
este for lo entendéis 00:21:10
si no 00:21:12
aquí tenemos envíos 00:21:15
que tiene por ejemplo 00:21:19
cuatro posiciones 00:21:22
vamos a suponer que envíos tiene 4 ahora mismo 00:21:24
y aus que en este caso tendría 3 00:21:26
porque aus se declara 00:21:29
con una posición menos 00:21:31
entonces i 00:21:33
va avanzando 00:21:34
por envíos y j 00:21:37
va avanzando por aus 00:21:38
entonces vamos copiando i igual a 0 00:21:40
su código es el mismo, no, no es 00:21:43
distinto, copiado en j igual a 0 00:21:45
y j se incrementa también 00:21:47
j se incrementa, el i también 00:21:49
porque está aquí, i igual a 1 00:21:51
¿su código es el mismo? 00:21:53
no, no es el mismo, pues no se copia 00:21:55
pero el i se incrementa 00:21:58
pero el j no, el j se queda aquí esperando 00:22:00
todavía, el j se queda aquí esperando 00:22:01
el j solo se incrementa cuando se copia en el 00:22:03
el i siempre 00:22:05
igual a 2, ¿el código es distinto? 00:22:06
si es distinto, pues lo copio 00:22:10
y j se incrementa 00:22:11
aquí 00:22:13
igual a 3, ¿el código es distinto? 00:22:14
sí, pues 00:22:17
se copia y j se incrementa 00:22:18
ya habríamos terminado 00:22:21
¿Vale? Este es este for sin más 00:22:22
Entonces 00:22:26
Una vez que hemos terminado este for 00:22:33
En aux se han copiado todos 00:22:36
Salvo el que coincida en código 00:22:38
Pero hombre, convendría distinguir 00:22:40
Oye, ¿qué ha pasado? 00:22:43
¿Qué pasa? 00:22:45
Si no hay código 00:22:49
Claro, si no hay código 00:22:53
Este for va a tener un problema, ¿verdad? 00:23:01
¿Qué problema va a tener? 00:23:03
va a tener un problema que es 00:23:05
que cuando toque copiar el último 00:23:10
o sea 00:23:12
al acceder a esta 00:23:13
posición va a decir uy que esta posición 00:23:16
no existe 00:23:18
entonces en algún momento 00:23:18
deberíamos distinguir aquí 00:23:22
este for cuando va a terminar 00:23:23
este for tiene que terminar 00:23:25
¿cuándo tiene que terminar 00:23:27
este for? 00:23:31
¿Pero cómo no va a haber código? 00:23:32
Porque te lo dan mal. 00:23:34
Podría, te pueden dar un código mal, tú le das a delete y no se ha borrado. 00:23:36
Entonces, ¿cómo incorporaríais la opción de que este for no dé null, 00:23:40
pues no dé a rain, desvaun, excepción? 00:23:46
Con un team que te busque primero en el for el índice que quieres eliminar. 00:23:49
O sea, el control de un índice se convierte en el índice, 00:23:55
por ejemplo, el índice lo puedes inicializar en menos uno 00:23:57
y si después de terminar el primer foro 00:23:59
en el que busca el código y sigue el menos uno 00:24:01
es que el código no se ha encontrado y por lo tanto no existe 00:24:03
y no se hace nada 00:24:05
yo me complicaría menos la vida 00:24:06
no lo sé 00:24:15
haciendo aquí 00:24:15
si J ha terminado 00:24:17
marcarlo con un fin 00:24:21
y salir 00:24:22
y luego fuera a comprobar 00:24:23
si ahí le ha dado tiempo 00:24:25
a llegar al final o no 00:24:29
no lo sé 00:24:30
sobre la marcha 00:24:32
pero sobre la marcha igual 00:24:35
se os ocurre algo más fácil a vosotros 00:24:36
no, que igual visto lo tuyo escrito 00:24:39
igual lo tuyo es más sencillo 00:24:41
¿vale? 00:24:43
no sé, yo aquí 00:24:45
yo qué sé, haría 00:24:47
Y si luego, si terminas al final 00:25:01
Sigue siendo menos uno 00:25:04
Vale, vale, vale 00:25:06
Mejor así 00:25:08
O sea, tienes un menos uno 00:25:11
Y si no se encuentra 00:25:13
Sigue siendo menos uno 00:25:16
Como una R y con posición menos uno 00:25:18
Entiendo lo que dices 00:25:19
¿Eso es lo que dices? 00:25:20
Bueno, allí me vas a explicar 00:25:23
Como chavismo 00:25:25
Vale, bueno 00:25:25
Yo aquí 00:25:29
Yo aquí, que es una opción 00:25:31
No digo que sea mejor ni peor que 00:25:33
Yo aquí he marcado 00:25:35
Que el bucle salga 00:25:37
Cuando este array esté completo 00:25:39
Entonces con eso, sí o sí 00:25:41
Nos ahorramos el array index 00:25:43
Va a una excepción, ¿verdad? 00:25:45
Porque cuando ya este 00:25:47
Se ha rellenado del todo 00:25:48
Salimos 00:25:50
Ahora afuera, simplemente 00:25:51
Tenemos que distinguir 00:25:55
si el código se encontró 00:25:57
o no se encontró 00:25:59
¿y ahora cómo lo podemos distinguir 00:26:01
aquí? 00:26:05
si fin sigue siendo 00:26:08
si fin es false es que se ha encontrado 00:26:10
bueno no, porque se podría haber encontrado 00:26:12
claro, es que fin 00:26:15
va a salir siempre así 00:26:17
la diferencia es si llegó 00:26:20
al final o no llegó al final 00:26:22
si es true significa que llegó al final y no hay código 00:26:23
a ver, si este va a llegar 00:26:26
siempre al final 00:26:30
el problema es si va a llegar al final 00:26:31
antes de que envíos se haya recorrido 00:26:33
entero o no 00:26:36
es decir, tenemos dos posibilidades 00:26:37
esto, esto, vale 00:26:42
este es 00:26:49
envíos y este es outs 00:26:51
entonces 00:26:53
posibilidad en el que el código se encontró 00:26:55
este se ha copiado 00:26:57
este se ha copiado 00:26:59
este no se ha copiado pero ha avanzado 00:27:01
y este se ha copiado 00:27:03
y ha acabado siendo 00:27:04
la longitud de envíos 00:27:06
¿verdad? envíos.len 00:27:08
posibilidad 2 00:27:10
el envío no está 00:27:13
¿vale? 00:27:14
está rápida 00:27:19
posibilidad 2 00:27:21
este se ha copiado 00:27:23
este se ha copiado 00:27:24
este se ha copiado 00:27:26
el bucle finalizó 00:27:28
porque el bucle finaliza en cuanto 00:27:30
j ya ha llegado al final, el bucle finalizó 00:27:33
y este se ha quedado sin copiar 00:27:35
luego en la posibilidad 00:27:37
dos y 00:27:39
se ha quedado una posición antes 00:27:40
en envíos.led 00:27:42
menos un 00:27:43
luego la forma de distinguir 00:27:45
si hemos salido del bucle 00:27:48
habiendo copiado o no habiendo copiado 00:27:50
sería como se ha quedado 00:27:52
valiendo y 00:27:54
¿vale? 00:27:56
¿vale? 00:28:04
es una posibilidad 00:28:05
Pero que problema tenemos 00:28:05
Que i es local al bucle 00:28:08
Claro 00:28:11
Que i es local al bucle 00:28:14
Entonces 00:28:16
A ver lo más fácil es guardarlo en una variable 00:28:18
Y ya está 00:28:29
Fin es igual a true 00:28:30
Vale 00:28:37
Es igual a 00:28:39
true 00:28:44
y podemos hacerlo aquí para 00:28:45
y es igual 00:28:56
a la última de las posiciones 00:28:58
que sería envíos 00:29:01
punto 00:29:03
led 00:29:06
bueno 00:29:08
es que es muchísimo más fácil 00:29:10
de forma de complicarlo tan tonta 00:29:12
de verdad es mucho más fácil marcarlo con la variable 00:29:14
si se encontró, ¿no? que tontería 00:29:17
alce 00:29:18
claro 00:29:22
Lo que hemos hecho de toda la vida 00:29:23
Encontrado igual a false 00:29:26
Y aquí marcarlo con true 00:29:29
Y ya está 00:29:30
Que forma más tonta de complicarnos 00:29:31
Con variables que no significaban nada 00:29:35
Así muchísimo mejor 00:29:36
Ahora ya nada 00:29:38
Si lo he encontrado 00:29:43
Claro 00:29:44
Si lo hemos encontrado entonces fenomenal 00:29:45
Ahora ya envíos 00:29:50
Igual a aux 00:29:52
Y si no lo hemos encontrado 00:29:53
En BIOS no se toca 00:29:56
No se ha borrado nada 00:29:57
¿Vale? 00:29:59
Es decir 00:30:03
Hacemos uno con una posición menos 00:30:03
Copiamos el uno en el otro 00:30:05
Saltándonos el borrado 00:30:08
Marcando si lo hemos borrado 00:30:10
Y salimos 00:30:11
Salimos de aquí 00:30:13
Entonces esta condición 00:30:17
Para que este código 00:30:20
Esto no quede aquí tan feo 00:30:21
esto lo natural sería meterlo aquí 00:30:23
mientras j 00:30:25
sea diferente 00:30:27
y aquí no meto este if tan feo 00:30:28
esto sería mientras 00:30:31
sea menor 00:30:35
que aux 00:30:36
punto len 00:30:38
menor que aux punto len 00:30:40
y aquí quito este if 00:30:44
y ya esto tiene mucho más sentido 00:30:45
y bueno es que 00:30:47
cuando esta sea 00:30:57
FALSE 00:30:59
Esta va a ser TRUE siempre 00:31:00
Entonces voy a entrar en la segunda 00:31:03
Pero sí, lo dices porque te ahorras una evaluación 00:31:04
No, error no 00:31:07
La duda es 00:31:19
Esta sobra en realidad 00:31:22
Esta sobra 00:31:26
Porque va a salir por esta antes siempre 00:31:29
¿Verdad? 00:31:32
Pero entonces ahí la variable FIN 00:31:33
Ya no vale para nada 00:31:37
La variable FIN ya no sirve para nada 00:31:37
no, porque la variable fin la he puesto 00:31:40
para coger ese valor, entonces si lo pongo aquí 00:31:42
ya no la necesito, entonces la puedo borrar de aquí 00:31:44
vale 00:31:46
entonces yo creo 00:31:48
que esto ahora 00:31:54
creo que aquí no pinta nada 00:31:55
esta 00:31:57
cláusula, porque 00:31:58
esta cláusula 00:32:01
va a ser siempre true 00:32:03
si la otra lo es, si la otra lo es 00:32:06
esa lo va a ser sí o sí 00:32:08
con lo cual esa ahí no pinta nada 00:32:09
Yo creo que esto así estaría bien 00:32:11
Creo que esto estaría bien 00:32:14
Recorremos el bucle 00:32:19
Mientras no nos hayamos salido 00:32:21
Del array más pequeñito 00:32:23
Y ahora vamos copiando 00:32:25
Saltándonos, vamos copiando 00:32:28
Marcamos si lo encontramos o no 00:32:30
Y ahora ya sí que esto de aquí 00:32:32
Creo que esta es la mejor versión posible 00:32:35
Creo que se va a saltar una posición 00:32:37
No, es que es la J 00:32:45
Con la que estoy 00:32:54
Envíos 00:32:55
Porque Aux tiene menos 1 00:33:05
Si el Bios tiene 5 00:33:07
Y Aux 00:33:08
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:
1
Fecha:
27 de enero de 2026 - 12:42
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 10″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
122.22 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid