Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 23-01-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 23 de enero de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues este método, efectivamente, es hacer un poquito lo de siempre, 00:00:00
pero ahora ya dentro de un método de una clase. 00:00:07
Nosotros tenemos un array y queremos ver si alguno de los elementos del array 00:00:09
cumple una condición, en particular la de que su código sea este, 00:00:17
pero podría ser cualquier otra, cumple. 00:00:21
Pues eso es lo mismo, es saber si algo pasa o no pasa, es lo de siempre. 00:00:23
De partida, asumimos que no pasa. 00:00:26
Y ahora me pongo a recorrerlos todos. 00:00:29
Con que encuentre uno que cumple la condición, 00:00:31
cambio el resultado final y se acabó. 00:00:34
Es lo de siempre. 00:00:37
Pues aquí yo tendré que recorrer el array, 00:00:38
el array está aquí en las propiedades de la clase. 00:00:40
Luego puede acceder directamente, no tenemos ni que pedirlo ni que nada, lógicamente. 00:00:43
Entonces ahora ya recorremos el array, 00:00:48
y en este caso como es para consultar, un for each o un for de índice, 00:00:51
da igual, si uno no es vago escribiendo, siempre va a ser muchísimo mejor 00:00:56
un for de índice porque no hace copias internas de variables, 00:01:01
no hace copias internas, eso que se ahorra, 00:01:05
y no tiene problemas de sincronización si hay varios hilos. 00:01:08
Ese no es nuestro problema ahora, pero podría serlo en otro momento. 00:01:10
Pero a ver, en un ejemplito, pues normal, que tampoco tiene mayores complicaciones, 00:01:15
pues si uno es vago con un for each y ya está y no pasa nada, 00:01:19
no tiene mayor valedad. 00:01:21
Mientras sí, sea menor que pedidos.length, incrementando i, 00:01:24
pues la historia de siempre. 00:01:33
Vamos a ver, el pedido de i cumple la condición, 00:01:35
¿qué condición? La de que su código sea como el que me han dado. 00:01:38
Entonces, pedidos de i, su código y su código lo tengo que coger con el get, 00:01:43
porque es una propiedad privada, con lo cual no puedo acceder directamente a ella, 00:01:49
y como es un string, o no es un string, sí es un string, 00:01:53
como es un string lo tengo que comparar con equals, 00:01:57
todas las cosas que ya no me puedo olvidar a estas alturas. 00:02:00
¿Es igual que el que me han dado? 00:02:03
Pues ya está, ya hemos encontrado un pedido que cumple la condición. 00:02:05
Pues result igual a true. 00:02:08
Y ya está, y ahí me he quedado. 00:02:11
Y aquí es donde hay que evitar la tentación terrible que os vence a muchos 00:02:13
de decir plantar aquí este else y si no result false. 00:02:18
¿Eh Miguel? 00:02:24
Cuidado con esa tentación tremendo, porque esto entonces ya perdería todo el sentido. 00:02:27
Entonces, ¿qué ocurre? Si es el primero lo hemos cambiado a true, 00:02:33
pero si luego el cuarto no es, me lo pone a false otra vez. 00:02:36
El cuarto ya ha perdido el sentido. 00:02:40
Cuando ya se ha hecho true, ya se ha hecho true para siempre. 00:02:42
Entonces, esto fuera. 00:02:46
¿Cómo en el bucle? 00:02:56
¿Al lado del? 00:03:06
Sí. 00:03:08
Ah, vale, vale, vale. 00:03:10
Claro, o sea, sí. 00:03:12
A ver. 00:03:15
Claro, ¿pero para qué? 00:03:17
Sí, vamos a ver. 00:03:20
Una vez, efectivamente, esta sería la estructura básica. 00:03:22
Una vez que ya he encontrado un pedido que lo cumple, lo pongo a true. 00:03:26
Y ya lo que pase con el resto de pedidos ya me da igual. 00:03:29
Lo que desde luego no puedo hacer es que luego me lleve un pedido 00:03:33
tres posiciones después y lo vuelvo a cambiar a false. 00:03:36
Eso es lo que no me puede ocurrir. Eso está claro, ¿no? 00:03:38
Que era la base de esto. 00:03:40
Ahora ya uno se puede poner a, efectivamente, retocar esto y decir, 00:03:42
hombre, una vez que ya he encontrado un pedido que es true, 00:03:45
voy a dejar de recorrer a array, porque ya no me aporta nada. 00:03:49
Entonces, hombre, imaginaos que este array fuera de, yo qué sé, 4.000. 00:03:53
Y ya encontró en el primero que es true. 00:03:57
¿Vamos a hacer 3.999 iteraciones? 00:04:00
Pues, hombre, ¿para qué? 00:04:03
Entonces, podemos, efectivamente, hacer que una vez que ha entrado aquí, 00:04:05
ya este for no se ejecute más, ¿no? 00:04:11
Por ejemplo, primera forma que se os ocurriría, ¿vale? 00:04:15
Para evitar esas iteraciones que ya no aportan nada. 00:04:19
¿Qué podríamos hacer? 00:04:22
Pues lo que ha dicho él, ¿no? 00:04:24
No nos olvidemos que esto es una condición en la que puedo poner lo que a mí me dé la gana. 00:04:26
Entonces, en esta condición yo le puedo poner, 00:04:31
oye, tú ve avanzando mientras no hayas llegado a la posición 00:04:34
y no hayas encontrado 00:04:38
y no hayas encontrado un pedido con ese código. 00:04:46
Por ejemplo. 00:04:49
Entonces, simplemente con esa modificación, este bucle va avanzando. 00:04:51
En cuanto encuentra uno que ya lo cumple, se pone a true. 00:04:55
Con lo cual, esto ya se pondría a false. 00:05:01
Luego, en la siguiente iteración, ya no entra. 00:05:04
Y ya está. 00:05:08
Y te ahorras las 20, 30 iteraciones que te faltan, que ya no las necesitas. 00:05:09
Por ejemplo, ¿no? 00:05:14
¿Vale? 00:05:17
Está claro lo que hemos hecho. 00:05:18
Aprovecharnos. 00:05:20
Una vez que esto ya se ha puesto a true, 00:05:21
aprovecharnos para que esta condición ya se convierta en false 00:05:23
y yo ya no entro más. 00:05:27
¿No? 00:05:30
Así una vez que he encontrado el pedido, 00:05:31
lo que pase con los demás es que me da lo mismo. 00:05:34
Lo que pase con los demás ya me da igual. 00:05:37
Esta podría ser una opción. 00:05:39
Claro, otra. 00:05:43
La que pensaba que me ibas a decir la primera, 00:05:44
que es la que me pone muy nerviosa y muy fea. 00:05:48
Plantado un break en el foro. 00:05:51
Claro, pues sí. 00:05:53
Uno planta un break a tomar por culo. 00:05:55
Claro. 00:05:57
Pero los software, los programas que tienen break, 00:05:58
luego son muy confusos. 00:06:02
Aunque ahora no nos hagamos idea. 00:06:05
Porque los códigos que hacemos son cortitos. 00:06:08
Son muy confusos porque el break es párate. 00:06:10
Y a lo mejor el break está en un foro que dentro tiene 00:06:13
un montón de llamadas a métodos y cosas muy largas. 00:06:17
Entonces tú, cuando haces un vistazo al foro, 00:06:20
desde aquí quieres entender lo que pasa. 00:06:23
Y si tú pones en la condición todo lo relacionado 00:06:26
con cuándo entra y cuándo sale, 00:06:30
va a saber rápidamente lo que hace. 00:06:32
Pero si tú en un break que está ahí oculto 00:06:34
lo obligas a salir, 00:06:36
eso tú no lo ves cuando miras aquí arriba. 00:06:38
No te haces a la idea de que puede ocurrir algo 00:06:41
que lo haga salir. 00:06:43
No te haces a la idea. 00:06:44
Tendrías que empezar a ir a todas las llamadas 00:06:45
que hay dentro hasta que llegues al break. 00:06:47
Entonces, hombre, no es un código muy legible. 00:06:49
Lo ideal es que tú, mirando esta línea, 00:06:53
te puedas hacer una idea de cuándo ese bucle 00:06:55
se ejecuta o no se ejecuta. 00:06:57
Entonces, que esta condición se hace más larga. 00:06:59
No pasa nada, se hace más larga. 00:07:01
Pero tú ya más o menos estarás a la idea de lo que hace. 00:07:03
Porque el break ahí escondido 00:07:05
tiene una acción muy radical 00:07:07
que es romper el bucle 00:07:09
y tú aquí arriba no la estás viendo. 00:07:11
No la estás viendo, que puede ocurrir algo 00:07:13
que no está aquí, puede ocurrir algo 00:07:15
y que se por desaparece. 00:07:17
Entonces, salvo en códigos muy manejables y cortitos, 00:07:19
pues por eso los break están tan mal vistos y con razón. 00:07:22
Pero vamos, que si uno está haciendo 00:07:28
sus propios códigos así patateros 00:07:31
y dice, hombre, pues a mí no me importa. 00:07:34
Jolín, yo pongo aquí un break si me da la gana 00:07:36
por lo tal, por la chorrada que estoy haciendo, 00:07:38
pues hombre, pues lo pone y ya está. 00:07:40
Y esto significa, cuando ya he llegado 00:07:43
a que esto sea true, fue razón. 00:07:46
Se acabó. 00:07:48
Y es lo que significa la sentencia break. 00:07:50
Sale del bucle en el que esté. 00:07:52
Ya no se ejecuta más. 00:07:54
Pero esto es muy feo, no me gusta. 00:07:56
Otra cosa que podríamos hacer, 00:07:58
aparte de poner ahí la variable, 00:08:00
que eso estaría mejor, más bonito, 00:08:02
o el break, 00:08:04
para que este bucle saliera 00:08:06
en el momento en el cual 00:08:10
hemos encontrado ya 00:08:12
un pedido que cumple la condición. 00:08:14
Bueno, pues podemos aprovecharnos 00:08:16
de que es un método 00:08:18
y usar el retorno. 00:08:20
Y hacer esto. 00:08:24
Y fijaos, ala, qué bonito y qué fácil. 00:08:26
Ala. 00:08:32
Esto es un poco radical también, 00:08:34
pero bueno, esto sí que... 00:08:36
Cuando encuentro el pedido 00:08:38
cuyo código coincide, 00:08:40
ya salgo del método directamente. 00:08:42
Ya salgo, porque ya no quiero hacer más. 00:08:44
Ya acabo el método. 00:08:46
Entonces, si salgo del método, 00:08:48
lógicamente salgo del for y salgo de todo. 00:08:50
Y además salgo devolviendo true. 00:08:52
Y entonces, aquí abajo, 00:08:54
pondríamos return false. 00:08:56
Porque si yo llego aquí abajo, 00:09:00
es porque no salí por el return true. 00:09:02
Entonces esta línea me sobraría ya. 00:09:04
Esta línea me sobraría. 00:09:06
O sea, si llego a un pedido 00:09:08
cuyo código es igual, 00:09:10
fuera ya método, me voy de ahí, 00:09:12
return true. 00:09:14
Que no he salido por aquí nunca. 00:09:16
Entonces es que el for ha terminado y llego aquí. 00:09:18
Pues en ese caso return false, 00:09:20
porque no he encontrado ningún pedido. 00:09:22
Sería otra forma de plantearlo. 00:09:24
Pero claro, en métodos en los cuales 00:09:26
lo único que queremos hacer es esto. 00:09:28
No queremos que se hagan más cosas. 00:09:30
Porque el return es que ya sale del método 00:09:32
y sale de todo. 00:09:34
Pero bueno, lo más bonito, en realidad, 00:09:38
lo más... 00:09:40
sería 00:09:42
una variable que yo la voy cambiando 00:09:44
de valor 00:09:46
y luego aquí la devuelvo. 00:09:52
Esto sería, de alguna manera, 00:09:56
lo más ortodoxo, 00:09:58
lo más purista. 00:10:00
Porque aquí, cualquier otro 00:10:02
cambio que yo quiera incorporar, 00:10:04
seguramente sea más fácilmente 00:10:06
incorporable. 00:10:08
Si quiero que este método además haga otras cosas, 00:10:10
pues las puedo poner aquí abajo. 00:10:12
Si tengo el return aquí arriba, pues ya tengo que cambiar el return. 00:10:14
Porque si tenía el return aquí arriba ya, 00:10:16
pues he puesto dos puntos y coma. 00:10:18
Esto sería lo más 00:10:20
purista y ortodoxo. 00:10:22
Y a la hora de incorporar cosas nuevas, 00:10:24
menos cambios voy a tener que hacer. 00:10:26
Pero lo que tenemos que entenderlo todo. 00:10:28
Lógicamente. 00:10:30
Y saber la potencialidad 00:10:32
que tiene cualquier sentencia 00:10:34
y entender todas las construcciones posibles. 00:10:36
Entenderlas. 00:10:38
¿Vale? 00:10:40
Bueno, pues este método ya estaría. 00:10:44
Para que se nos vaya... 00:10:46
Bueno. 00:10:48
Vamos a incorporar ahora ya 00:10:50
en el software, pues que la aplicación 00:10:52
haga esta funcionalidad. 00:10:54
Porque esto no deja de ser la clase. 00:10:56
Aquí todavía tenemos que ponernos en el chip 00:10:58
de que no hay nada ejecutándose. 00:11:00
Esto es la clase que te dice 00:11:02
si algún cliente alguna vez 00:11:04
quiere ver si ha pedido un pedido, 00:11:06
llamará a esto. Pero todavía no hay 00:11:08
ningún cliente pidiendo nada, 00:11:10
ni hay ningún pedido, ni hay nada. 00:11:12
Estamos ahora haciendo la clase solo. 00:11:14
Luego ya se hará 00:11:16
el software que es el que llama 00:11:18
a estas clases, llama a los objetos 00:11:20
y ya hace las cosas. 00:11:22
Y ese es el main, en nuestro caso el main famoso. 00:11:24
Podría ser una interfaz gráfica 00:11:26
también, la que llama a estas cosas 00:11:28
pero como no sabemos hacer 00:11:30
interfaces gráficas, pues haremos un main. 00:11:32
Un main con un menú. 00:11:34
Bueno, pues ese software que estábamos haciendo 00:11:36
era algo como esto. 00:11:38
Habíamos hecho estas 00:11:42
funcionalidades. 00:11:44
Yo aquí en mi ejemplito 00:11:46
no las tengo todas incorporadas 00:11:48
todavía porque esta es la versión de aquí, 00:11:50
no es la de mi portátil, que se me había traído. 00:11:52
Pero bueno, estas las teníamos 00:11:54
todas hechas, yo creo. 00:11:58
Nos faltaba eliminar simplemente. 00:12:00
La llamada al método. 00:12:02
Pero vamos. 00:12:04
Teníamos estas funcionalidades hechas. 00:12:06
Vale, pues ahora esta es nuestro software 00:12:08
cuando solamente 00:12:10
trabajaba con pedidos. 00:12:12
Solamente trabajaba con pedidos. 00:12:14
Ahora nuestro software se ha hecho más grande 00:12:16
y ahora puede 00:12:18
trabajar también con clientes. 00:12:20
Bueno, pues entonces. 00:12:24
La primera pregunta 00:12:26
en relación a un 00:12:28
diseño de software siempre es 00:12:30
¿Cómo vas a trabajar con datos? 00:12:32
¿Los datos dónde están? 00:12:34
¿Dónde están los datos? ¿Cuáles son tus datos y dónde están? 00:12:36
Vale, pues ahora tenemos también 00:12:38
un volumen de datos que van a ser los clientes. 00:12:40
Y eso es lo primero 00:12:42
que hay que resolver. 00:12:44
Vale, si vas a trabajar con clientes, 00:12:46
¿esos clientes dónde están? 00:12:48
Para que yo haga cosas con ellos. 00:12:50
Cuando yo inserte uno nuevo, ¿dónde va a ir a parar? 00:12:52
¿Dónde están? 00:12:54
Esa es la primera pregunta. 00:12:56
Hay que empezar a preguntarse 00:12:58
¿Qué vas a hacer con esos clientes? 00:13:00
Hay que preguntarse dónde van a estar. 00:13:02
La respuesta habitual es 00:13:04
obviamente en una base de datos. 00:13:06
Y entonces la aplicación se conectará 00:13:08
con esa base de datos 00:13:10
para bien meter clientes nuevos 00:13:12
o bien para recoger clientes 00:13:14
y trabajar con ellos. 00:13:16
Pero claro, nosotros no sabemos conectarnos 00:13:18
a una base de datos 00:13:20
para meterle un objeto cliente o recuperarlo. 00:13:22
No sabemos hacer eso. 00:13:24
Nuestros clientes tienen que estar en otro sitio. 00:13:26
Pues por eso los metemos directamente 00:13:28
en una variable de la aplicación. 00:13:30
¿Vale? 00:13:32
En condiciones normales, esa variable se habrá 00:13:34
rellenado con lo que hay en una base de datos. 00:13:36
En nuestro caso, 00:13:38
la rellenamos directamente por consola 00:13:40
porque no sabemos rellenarla en una base de datos. 00:13:42
Y esa variable 00:13:44
para guardar muchos clientes, 00:13:46
pues ahora mismo 00:13:48
es un array. 00:13:50
Pero bueno, podría ser un conjunto, una lista, 00:13:52
un mapa, un diccionario, bueno, millones de cosas. 00:13:54
Podría ser. 00:13:56
¿Vale? Pues 00:13:58
en esta aplicación vamos a 00:14:00
poner 00:14:02
nuestro almacén 00:14:08
de clientes. 00:14:10
Nuestro almacén de clientes. 00:14:12
Entonces claro, el array 00:14:14
es tremendamente 00:14:16
eficiente computacionalmente y es una 00:14:18
estructura básica sobre la que se apoya todo. 00:14:20
Pero 00:14:22
ya sabemos, 00:14:24
por enésima vez hemos dicho, 00:14:26
que su única pega 00:14:28
es que es una estructura 00:14:30
estática, o lo que es lo mismo, 00:14:32
cuando se crea, 00:14:34
se crea con un tamaño determinado 00:14:36
y ese no se mueve. 00:14:38
Esa es la única pega que tiene el array. 00:14:40
Y por esa única pega 00:14:42
es por la que se han hecho clases 00:14:44
por encima que usan 00:14:46
los arrays debajo trucándolos. 00:14:48
Trucándolos como los hemos 00:14:50
trucado nosotros, pues haciendo uno nuevo 00:14:52
con una posición más, sustituyéndolo. 00:14:54
Pues son clases que tienen como propiedad 00:14:56
interna un array suyo y lo trucan. 00:14:58
¿Vale? Bueno, 00:15:00
esas son las colecciones. 00:15:02
Hay varias variantes, varios rollos, ¿vale? 00:15:04
Eso pues ya lo veremos, el tema de colecciones que le gustan 00:15:06
tanto a Alejandro. Y ya veremos cuando 00:15:08
las veamos por dentro, las hagamos nosotros y te siguen gustando 00:15:10
tanto. Dios quiera que sí. 00:15:12
¿Vale? Porque... 00:15:14
Claro hombre, porque es la forma fácil 00:15:17
de usarlas, pero todavía no las hemos visto. 00:15:19
Tenéis que aprender a programar primero. 00:15:21
Tenéis que aprender primero a programar 00:15:24
y luego ya... 00:15:26
Puedes decir lo que quieras. 00:15:28
¿Eh? 00:15:30
Eso es lo bueno, luego todo se sepa. 00:15:33
Vale, pues entonces. 00:15:35
Todo este rollo venía a cuento de que 00:15:37
la única pega que tiene el array es que es una estructura estática. 00:15:39
Entonces tenemos que decidir el volumen, 00:15:41
la capacidad 00:15:43
previamente. 00:15:45
Bueno, pues para no complicarnos 00:15:47
en la vida, venga, esta aplicación 00:15:49
como mucho va a tener, como muchísimo 00:15:51
yo voy a poder registrar 00:15:53
100 clientes, pues ala, 100. 00:15:55
¿Vale? Repito, 00:15:57
esto lo solucionaremos 00:15:59
lo solucionaremos 00:16:01
a corto plazo usando colecciones. 00:16:03
¿Vale? Pero las colecciones 00:16:05
hay que entender muy bien cómo está hecha 00:16:07
cada una por dentro, porque cada una tiene su peculiaridad. 00:16:09
Porque de entender eso 00:16:11
se deriva 00:16:13
que luego tú puedas hacer una selección 00:16:15
correcta de la colección que vas a usar. 00:16:17
No te vale cualquiera para cualquier 00:16:19
aplicación, no te vale cualquiera para cualquiera. 00:16:21
Tienes que hacer una selección correcta. 00:16:23
Vale, pues nada. 00:16:25
Cliente, importamos la clase cliente 00:16:27
porque no nos apetece ponerle 00:16:29
todo el rollito de com, dan uno 00:16:31
entidades que es muy largo, no nos apetece 00:16:33
pues le ponemos el import. 00:16:35
Ya tenemos la clase cliente. 00:16:37
Bueno, pues eso nos permitiría 00:16:39
ya hacer 00:16:41
funcionalidades añadidas con este software. 00:16:43
Pues por ejemplo, 00:16:45
vamos a 00:16:47
hacer 00:16:49
la funcionalidad 00:16:51
8, con lo cual 00:16:53
cambia la 9 de salir 00:16:55
y por tanto 00:16:57
que no se me olvide esto, 00:16:59
cambiarlo a 9, 00:17:01
la de salir, cambiarlo a 9, 00:17:03
pues la funcionalidad 8 00:17:05
que sea 00:17:07
incorporar 00:17:09
pedido 00:17:13
a cliente. 00:17:15
Vale, 00:17:21
incorporar pedido a cliente. 00:17:23
Vale. 00:17:25
Y luego podemos 00:17:27
hacer también la... 00:17:29
A ver, 00:17:31
para no tener que estar viendo el numerito este todo el rato, 00:17:33
voy a poner que la de salir sea 00:17:35
muy bien. 00:17:37
Iba a poner yo la 100, pero es absurdo 00:17:39
poner tres números y ponerte poner uno. 00:17:41
Tienes toda razón, la de salir es la 0. 00:17:43
Y así yo no la cambio nunca más. 00:17:45
La de salir es la 0. 00:17:47
Vale, bien pensado. 00:17:51
Vale, pues la otra que vamos a hacer 00:17:55
va a ser incorporar un pedido a cliente. 00:17:57
Mostrar dirección, 00:18:07
por ejemplo, 00:18:09
bueno cliente, 00:18:11
para que hemos hecho los datos, el nombre y la dirección 00:18:13
para poder enviar la cartita, una carta, 00:18:15
se lo mandamos a un paquete. 00:18:17
Mostrar datos del cliente que ha hecho un pedido. 00:18:19
Vale, entonces esta opción 9 00:18:29
es la que daremos cuando nos ha llegado un pedido 00:18:31
y decimos, a ver, ¿este para quién es? 00:18:33
Se lo voy a meter en una caja y voy a poner aquí 00:18:35
la pegatina con su nombre y dirección. 00:18:37
Pues daremos esa opción. 00:18:39
Vale, vamos a hacer primero la 8, 00:18:41
porque para aprobar la 9 los clientes tienen que tener pedidos. 00:18:43
Bueno, claro, tendremos que poder meter clientes. 00:18:45
Si no metemos clientes, pues 00:18:47
chungo. 00:18:49
Vamos a poner la opción 10. 00:18:51
Esto en una consola ya se queda muy largo. 00:18:55
En una aplicación con interfaz gráfica, 00:18:57
pues bueno, uno puede hacer un despliegue 00:18:59
de opciones y es un poquito más 00:19:01
manejable. 00:19:03
La 10 sería 00:19:05
insertar cliente. 00:19:07
Sería, sí, sí, sí. 00:19:11
Lo que pasa es que como la voy poniendo, 00:19:13
vosotros lo queréis dejar más bonito, pues ya lo vais colocando 00:19:15
como queráis. 00:19:17
Yo como voy ahí 00:19:19
sobre la marcha improvisando. 00:19:21
Vale. 00:19:27
Bueno, pues venga. 00:19:29
Vamos a hacer primero lo de insertar 00:19:31
cliente porque 00:19:33
que sería como la de crear pedido. 00:19:37
Pues igual, pero en este caso clientes. 00:19:39
Entonces, en realidad 00:19:41
es como la de pedido, 00:19:43
pero cambiando por cliente 00:19:45
y usando una variable adicional 00:19:47
porque esta pos, 00:19:49
ahora ya esta pos convendría cambiarla 00:19:51
de nombre y llamarla pos de pedidos 00:19:53
porque ahora tendremos una para indicar la 00:19:55
posición de los clientes, son dos arrays en paralelo. 00:19:57
Entonces vamos a aprovecharnos de 00:19:59
ese concepto que os mencioné 00:20:01
de la refactorización 00:20:03
que es, yo quiero cambiar 00:20:05
un elemento de mi 00:20:07
código fuente de nombre, 00:20:09
pues en lugar de hacerlo yo a mano, 00:20:11
que es un rollo, se me puede escapar alguno, 00:20:13
usamos que el entorno de desarrollo 00:20:15
me hace una refactorización, me ayuda a refactorizar. 00:20:17
Recordad que refactorizar 00:20:19
cambiar el aspecto de mi código 00:20:23
pero sin cambiar nada de la funcionalidad. 00:20:25
Nada, la funcionalidad es la misma. 00:20:27
A lo mejor yo estoy cambiando nombres 00:20:29
de variables, estoy cambiando, 00:20:31
pero no cambio la funcionalidad. Bueno, en este caso 00:20:33
vamos a cambiar el nombre de la variable pos. 00:20:35
Entonces, botón derecho en la variable 00:20:37
en la que queramos refactorizar, botón derecho 00:20:39
os vais a refactor, 00:20:41
rename, que esta arriba 00:20:43
y ahora queremos 00:20:45
que, 00:20:47
a ver, 00:20:49
porque no me, 00:20:51
vamos a ver, 00:20:53
rename, 00:20:55
vale, y ahora ya escribo aquí 00:20:57
el nuevo nombre, ¿verdad? 00:20:59
Y le doy 00:21:01
al enter y el me lo 00:21:03
actualiza todo. 00:21:05
Pues ala, 00:21:09
refactorizo otra vez. 00:21:11
Si, lo que pasa es que 00:21:13
para no cambiarlo de sitio, como lo tengo aquí en la 00:21:15
funcionalidad de pedidos, tendría que acordarme 00:21:17
de cambiarlo de sitio. Entonces voy a 00:21:19
llamarlo, efectivamente, 00:21:21
eh, 00:21:23
me he perdido, 00:21:25
aquí estoy. 00:21:27
A ver, es que 00:21:29
no estaba, 00:21:31
ahora sí. 00:21:33
Vale, pues 00:21:35
venga, pos 00:21:37
pedidos. 00:21:43
Ala, ya está, 00:21:45
más bonita, esta es la posición de pedidos, 00:21:47
todo lo que tenía que ver con pedidos 00:21:49
ya se ha cambiado de nombre. 00:21:51
Estas yo no las tengo llenas, vos las tendréis llenas 00:21:53
del otro día. 00:21:55
Venga, pues ahora necesitamos otra variable 00:21:57
para como indicadora de las posiciones 00:21:59
de los clientes. Un entero 00:22:01
también, 00:22:03
pos clientes, que empieza valiendo 0. 00:22:05
Vale, 00:22:07
y ahora la funcionalidad 00:22:09
de añadir cliente, que 00:22:11
en mi caso es la 10, 00:22:13
es como la de pedido, 00:22:15
igual, pero pidiendo datos 00:22:17
de cliente y 00:22:19
ya está. Voy a copiar el mismo caso 1 00:22:21
y ahora lo modifico 00:22:25
en el caso 10. 00:22:27
En mi caso en el 10. 00:22:29
A ver. 00:22:31
7, 8, 9 y caso 10. 00:22:49
Vale, pues aquí es 00:23:01
donde lo quería yo hacer 00:23:03
y ahora, ¿qué datos hay que pedir? Los del cliente, 00:23:05
que son 3 strings, 00:23:07
nif, nombre y dirección. 00:23:09
Vale, 00:23:11
pues vosotros que tenéis 00:23:13
ya la clase teclado seguramente lo tenéis muy fácil, 00:23:15
yo lo voy a hacer con el escáner, 00:23:17
porque estoy en la versión antigua de esto. 00:23:19
Entonces, 00:23:21
introduzca 00:23:27
nif. 00:23:29
Pues lo leo. 00:23:31
Introduzca 00:23:33
nombre. 00:23:35
Pues lo leo. 00:23:39
E introduzca 00:23:43
dirección. 00:23:45
Pues la leo. 00:23:53
Y ahora ya, en mi array de clientes, 00:23:57
en la 00:23:59
posición que toque, 00:24:01
en la posición 00:24:03
que toque, dejándola 00:24:05
incrementada, por supuesto, 00:24:07
en la que toque dejándola incrementada, 00:24:09
pues 00:24:11
clientes, 00:24:13
en la que toque, meto 00:24:15
ese nuevo cliente 00:24:17
¿qué constructor usamos? 00:24:23
Pues lo ideal sería que en cliente hubiera 00:24:25
un constructor al que yo le doy 00:24:27
los 3 parámetros básicos. 00:24:29
Nombre, dirección y 00:24:31
todavía no lo leo. 00:24:33
Nombre, dirección y nif. 00:24:35
Y el array de clientes, de pedidos, 00:24:37
pasamos de él por ahora porque no hay ningún pedido incorporado. 00:24:39
Entonces, 00:24:41
voy aquí y yo, 00:24:43
que todavía no tengo ni un constructor ni nada, 00:24:45
porque lo acabo de hacer, 00:24:47
pues voy a crear un constructor, 00:24:51
si es que 00:24:53
no lo, igual lo tenéis otros de ayer, 00:24:55
voy a crear un constructor para cliente 00:24:59
con esos 3 datos. 00:25:01
Y entonces cuando cree 00:25:03
mi objeto cliente con este constructor, 00:25:05
pedidos se inicializará a null, que es el valor 00:25:07
por defecto de un array. 00:25:09
Se inicializará a null. 00:25:11
Vale. 00:25:13
Venga, pues nada. 00:25:15
Entonces, llamo yo aquí a cliente 00:25:17
con esos 3 parámetros. 00:25:19
Nif, 00:25:21
nombre 00:25:23
y dirección. 00:25:25
Pues ya está, ya tengo la funcionalidad de 00:25:27
crear, insertar un nuevo cliente 00:25:29
en mi registro de clientes. 00:25:31
Con esos datos básicos y por ahora 00:25:33
sin pedidos. 00:25:35
Bueno, 00:25:39
pues ahora 00:25:45
lo natural sería poder hacerle, 00:25:47
meterle un pedido 00:25:49
a este cliente. 00:25:51
Vale, que sería la funcionalidad 00:25:53
Aquí de nuevo, 00:25:57
como estamos haciendo 00:25:59
el programa escalándolo poco a poco, 00:26:01
primero hicimos la parte de pedidos, luego la de cliente, 00:26:03
se complica un poco 00:26:05
la cosa, claro. 00:26:07
O sea, lo ideal es que cuando uno hace una aplicación, 00:26:09
ya desde el principio, 00:26:11
tenga definidas 00:26:13
todas las necesidades. 00:26:15
Vas a tener clientes, pedidos, 00:26:17
van a tener que hacer esto, para ti, para tal. 00:26:19
Nosotros cuando hicimos esta primera versión de la aplicación, 00:26:21
solamente teníamos definida 00:26:23
la parte de pedidos y le hemos incorporado 00:26:25
ahora después la de clientes. 00:26:27
Vale, pues entonces, 00:26:29
eso ha implicado que tengamos dos arrays. 00:26:31
El array con los pedidos 00:26:33
que van sueltos, los pedidos que se van haciendo. 00:26:35
Y luego, 00:26:37
y luego, 00:26:39
a un cliente, 00:26:41
le tendremos que incorporar 00:26:43
un pedido concreto que ya esté aquí. 00:26:45
Ese es como va a funcionar nuestro software. 00:26:47
Porque ya tenemos previamente 00:26:51
la parte hecha en la cual hacemos un pedido 00:26:53
por libre y lo metemos aquí. 00:26:55
Bueno, pues entonces, 00:26:57
eso significa, vale, 00:26:59
pues entonces, incorporar pedido a cliente, 00:27:01
¿qué tendré yo que pedir? 00:27:03
Pues como siempre, la clave primaria del pedido. 00:27:05
Los pedidos ya están aquí guardados todos. 00:27:07
Los pedidos que se han hecho están ahí. 00:27:09
Se ha hecho un pedido de boli, tenéis aquí. 00:27:11
Pues voy a asociar este pedido al cliente, voy a asociarlo. 00:27:13
Pues entonces, tendremos que pedir, 00:27:15
oye, vale, ¿qué pedido de todos estos 00:27:17
que tienes tú en tu almacén 00:27:19
de pedidos, 00:27:21
¿qué pedido vas a asociar al cliente? 00:27:23
Pues lo que vas a necesitar para identificarlo 00:27:25
será lo que lo identifique de forma única, 00:27:27
que es su clave. 00:27:29
El código, ¿no? 00:27:31
Pues entonces, 00:27:33
en la funcionalidad de incorporar 00:27:35
pedido a cliente, lo primero que habrá 00:27:37
que preguntar es, oye, ¿cuál es el código 00:27:39
del pedido que le quieres pasar al cliente? 00:27:41
¿Cuál es? Eso es lo primero que habrá 00:27:43
que hacer. 00:27:45
Código del pedido. 00:27:49
Código del pedido, 00:27:51
que es string, ¿verdad? 00:27:53
Sí, es string, 00:27:55
afortunadamente queda menos guerra. 00:27:59
Código del pedido, 00:28:01
como ya tenemos una variable 00:28:03
de declarar arriba, la reutilizo 00:28:05
para leer. 00:28:07
Vamos a acabar 00:28:11
este caso 8 00:28:13
y ahora paramos. 00:28:15
Va, ya tengo el código del pedido. 00:28:17
¿Ahora qué hacemos? 00:28:19
Pues tendremos que 00:28:21
saber 00:28:23
a qué cliente incorporarlo. 00:28:25
Bueno, pedimos lo del cliente y paramos 00:28:29
porque se va a hacer quizá un pelín en largo. 00:28:31
Ya tengo el código del pedido. 00:28:33
Ahora será, vale, ¿a qué cliente? 00:28:35
Porque tenemos muchos, ¿a qué cliente? 00:28:37
Pues de nuevo la pregunta es, ¿qué identifica 00:28:39
de forma única a cada cliente? 00:28:41
El nif, ¿no? 00:28:43
Si he hecho bien el diseño, 00:28:45
si he hecho bien el diseño, 00:28:47
alguna de las propiedades debería ser 00:28:49
que el nif no se identifique de forma única, 00:28:51
si lo he hecho bien. 00:28:53
Se supone que el nif 00:28:55
no se identifica 00:28:57
de forma única, se supone. 00:28:59
Pues sería lo siguiente que hay que pedir. 00:29:01
Venga, ya tengo el pedido 00:29:03
que le voy a enseñar al cliente. 00:29:05
Ahora, 00:29:07
nif del cliente. 00:29:11
Pues nada, lo leemos. 00:29:15
Line. 00:29:21
Y como no tenía ninguna variable 00:29:23
nif declarada arriba, 00:29:25
string nif. 00:29:27
Vale, ya tenemos la concentrada. 00:29:31
Y ahora ya efectivamente habría que 00:29:33
localizar el cliente con ese nif 00:29:35
y a través del método de incorporar pedido 00:29:37
pasarle el pedido con ese código. 00:29:39
¿Vale? 00:29:41
Bueno, pues paramos aquí un momentito 00:29:43
y lo 00:29:45
si os aburrís 00:29:47
lo meditáis en estos minutos. 00:29:49
Vale, pues 00:29:51
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
23 de enero de 2024 - 13:42
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
569.89 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid