Saltar navegación

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

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

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, de que conviene no desconectar nunca y perder nunca de vista lo que está pasando debajo, 00:00:00
claro, lo que ocurre debajo. 00:00:07
Porque en muchas situaciones, pues no es que tengamos que tenerlo siempre presente, 00:00:08
pues ya si hacemos otra OJ y las cosas tiran y ya está. 00:00:12
Pero hay situaciones en las cuales las cosas no van como creemos que van 00:00:15
y lo vamos a acotar, vamos a encontrar la solución si entendemos lo que hay debajo, si no, no. 00:00:19
Entonces, todo esto venía a cuento de que esta línea, no penséis que está duplicando el objeto, 00:00:25
que no pasaría nada. 00:00:31
Pero hombre, sería una pérdida de memoria tonta, no está duplicando el objeto. 00:00:33
¿Aquí qué está pasando? 00:00:36
Nosotros tenemos, nos vamos al pain este estupendo. 00:00:37
Nosotros tenemos nuestro array de pedidos, 00:00:41
Joder, vaya mierda, a ver. 00:00:46
Este. 00:00:49
Tenemos nuestro array de pedidos, 00:00:51
pues los pedidos que sean. 00:00:54
Este es el array y cada uno de estos es un pedido, ¿vale? 00:00:56
Y ahora, ¿cada uno de estos qué es? 00:01:03
Del array, es un objeto pedido. 00:01:05
Luego, cada uno de estos, en realidad, ya sabemos que lo que realmente es, 00:01:08
es una dirección de memoria hacia el verdadero objeto pedido, 00:01:12
que tiene a su vez sus propiedades, las que sean. 00:01:17
Eso es lo que sabemos que hay, ¿verdad? 00:01:20
En cada posición del array, pedidos de i, pedidos de i, 00:01:23
en realidad es una dirección de memoria del verdadero objeto pedido con sus datos. 00:01:27
Ese es cada pedidos de i, ¿verdad? 00:01:32
Eso lo tenemos claro. 00:01:35
Cada pedidos de i es eso. 00:01:43
Cada pedidos de i es una dirección de memoria a donde sea. 00:01:45
Vale. 00:01:52
Bueno. 00:01:54
Esto es nuestra aplicación que ya se está ejecutando. 00:01:56
Cuando hay una aplicación en ejecución, cuando hay un main, ya hay cosas en memoria, ya hay cosas. 00:01:58
Pues es una de las que hay. 00:02:02
¿Qué más cosas hay en memoria de esta aplicación que estamos ejecutando? 00:02:04
Pues un array de clientes. 00:02:07
¿Vale? 00:02:09
Pues claro, tenemos nuestro array de clientes, que es este de aquí. 00:02:10
Nuestro array de clientes, pues con un montón de clientes. 00:02:16
En realidad, cada posición del array, cada clientes de i, 00:02:22
ya sabemos que es una dirección de memoria a donde ahora ya sí que está el cliente. 00:02:26
¿Vale? 00:02:33
Y el cliente, a su vez, tiene dentro su nombre, su nif. 00:02:36
Su nif, su nombre, su dirección. 00:02:46
Y el cliente, a su vez, tiene dentro un array. 00:02:49
Un array ya sabemos lo que es. 00:02:52
Es otro objeto. 00:02:54
Luego el cliente, a su vez, tiene una dirección donde está el array. 00:02:56
Y aquí están los pedidos del cliente. 00:03:02
¿Vale? 00:03:10
O sea, los pedidos del cliente son estos. 00:03:11
Estos son los pedidos del cliente, en realidad. 00:03:15
¿Vale? 00:03:19
Esta es la estructura que tenemos, ¿verdad? 00:03:20
El array de clientes. 00:03:22
Cada cliente, cada posición del array es una dirección de memoria a un cliente. 00:03:24
Cada cliente que tiene nombre, nif, dirección y a su vez un array. 00:03:28
Un array ya sabemos lo que es. 00:03:32
Un array en realidad es un objeto. 00:03:34
Luego un array es la dirección de memoria hacia el array. 00:03:36
Y ya el array tiene dentro los pedidos. 00:03:39
Que a su vez, como es un array de pedidos, pues cada uno de estos es la dirección de memoria, 00:03:42
ahora ya sí, de un pedido. 00:03:47
Cada uno de estos. 00:03:50
¿Vale? 00:03:51
Este ya es el pedido. 00:03:52
Este ya es el pedido. 00:03:55
Y claro, si quisiéramos seguir dibujando, que no vamos a hacerlo más, 00:03:57
a su vez una propiedad del pedido es un array de ítems. 00:04:01
Luego a su vez uno de estos es la dirección de memoria al array de ítems, 00:04:04
que son las direcciones de los ítems, y ahí ya se acaba el árbol. 00:04:08
Ahí ya no hay más. 00:04:10
Porque los ítems ya no tienen dentro objetos. 00:04:11
Tienen ya propiedades sencillas. 00:04:13
Esto es lo que hay. 00:04:15
¿Vale? 00:04:16
Entonces, ¿nosotros qué hacemos cuando le asignamos un pedido a un cliente? 00:04:17
Pues lo que hacemos es, a la dirección donde tiene, perdón, a la dirección esta, 00:04:21
al array este, al array este le incorporamos una dirección más, 00:04:31
que sea la dirección de uno de estos pedidos. 00:04:36
No es que estemos haciendo aparecer un pedido copia de este, 00:04:39
y ese pedido lo metamos en este array. 00:04:45
No, lo que estamos haciendo es, 00:04:48
hemos localizado el pedido, 00:04:50
imaginaos que es este, lo hemos localizado. 00:04:52
Vale, lo hemos localizado y a una variable auxiliar que está por aquí, 00:04:54
que es la que se llama pedidosincorporar, 00:04:58
a esta variable auxiliar, que es la que hemos llamado pedidoincorporar, 00:05:01
mediante esta sentencia, pedidoincorporar, igual pedidos de i, 00:05:08
que esta es la sentencia clave, 00:05:12
me di esta sentencia, en esta no estamos haciendo ninguna copia de este pedido, 00:05:14
no estamos haciendo ninguna copia, 00:05:19
lo que estamos es, a este dándole esta dirección de memoria, 00:05:21
luego a este le estamos haciendo que apunte también a ese pedido, 00:05:25
pero el pedido que existe es solo uno, 00:05:30
a este también va a apuntar ahí. 00:05:33
Vale, esto es lo que estamos haciendo con esta sentencia, 00:05:37
con esta, 00:05:40
con esta sentencia estamos haciendo que esto apunte también aquí, 00:05:41
vale, no estamos creando otro, un pedido copia idéntico a este, 00:05:46
no estamos creando un pedido copia idéntico a este, no, 00:05:51
estamos creándole otra referencia que la estamos guardando aquí 00:05:54
y ahora ya cuando localicemos el cliente, 00:05:58
pues en su array de pedidos, 00:06:01
¿qué hacemos? 00:06:03
Pues en su array de pedidos estaremos añadiendo, que es este, 00:06:04
en su array de pedidos estaremos añadiendo una posición más, 00:06:08
una posición más a la que le damos la dirección de pedido a incorporar, 00:06:12
luego se queda apuntando ahí. 00:06:17
Este pedido nuevo se va aquí. 00:06:28
Estos son los dos enlaces que estamos haciendo, 00:06:34
vale, intentad seguirme, 00:06:36
ya sé que es un rollo pero es importante, 00:06:38
vale, o sea con esta sentencia que es la clave, 00:06:41
esta de aquí, 00:06:45
hacemos esto, 00:06:48
a esta variable le damos como dirección esta misma, 00:06:49
luego se queda apuntando al pedido, al pedido que hay 00:06:53
y ahora localizamos cliente, 00:06:56
cuando lo hemos encontrado nos vamos a su array de pedidos 00:06:58
y a su array de pedidos le añadimos esto, 00:07:02
luego al añadirle esto que es una dirección de memoria, 00:07:06
lo que le estamos añadiendo es que apunte aquí, 00:07:08
eso es lo que estamos haciendo, 00:07:12
no es que estemos creando un objeto pedido, 00:07:14
copia de este para él, 00:07:16
no, simplemente al array de pedidos de este cliente 00:07:17
le metemos una posición más que empieza a apuntar a ese pedido, 00:07:20
no estamos creando nada nuevo, 00:07:24
simplemente hacemos esto. 00:07:26
Cuando hacemos esta sentencia de aquí, 00:07:28
cuando hacemos esta, 00:07:30
la de incorporar pedido cuando la hagamos ahí abajo, 00:07:32
dentro del método que ahora está vacía, 00:07:35
pues lo que estamos haciendo simplemente es 00:07:37
a este array de pedidos del cliente de ahí 00:07:40
que acabamos de encontrar, 00:07:42
a este array le añadiremos una posición 00:07:43
y le meteremos este 00:07:46
y al meterle este a la posición añadida, 00:07:48
¿qué estamos haciendo? 00:07:51
Pues ponerle esta dirección 00:07:52
y al ponerle esta dirección le hacemos que apunte aquí, 00:07:54
¿vale? 00:07:56
Eso es lo que está pasando por dentro. 00:07:57
Entonces conviene entenderlo bien, 00:07:59
porque hay veces que en función de las cosas que uno haga 00:08:00
en realidad no está haciendo esto, 00:08:03
sino que está haciendo una copia, 00:08:05
luego modifica esto 00:08:07
y no se modifica la copia, claro, 00:08:08
y la aplicación no funcione, 00:08:10
pero si yo he guardado 00:08:11
y no se me guardan los datos, 00:08:13
¿qué está ocurriendo? 00:08:15
No está ocurriendo nada, 00:08:16
simplemente que a lo mejor no estás entendiendo 00:08:17
esto que estás haciendo de fondo, 00:08:19
estás trabajando con una copia, 00:08:20
estás modificando esto 00:08:22
y entonces la copia no. 00:08:24
Bueno, por este tipo de cosas que ocurren en las aplicaciones 00:08:25
conviene entender bien exactamente 00:08:28
qué se hace cuando se hacen asignaciones de objetos, 00:08:31
porque no olvidéis, 00:08:34
un objeto es una dirección de memoria. 00:08:35
Bueno, más o menos, 00:08:39
el dibujito este más o menos 00:08:41
lo que trae por debajo. 00:08:43
Bueno, pues entonces, 00:08:48
nuestra funcionalidad de incorporar pedido a cliente 00:08:50
es esta, 00:08:53
localizamos el pedido, 00:08:55
lo dejamos apuntado por este 00:08:56
y una vez que lo hemos localizado, 00:08:58
llamamos a este método. 00:08:59
Este método está sin hacer, 00:09:01
pero al que está haciendo esta parte del software 00:09:02
le da exactamente igual, 00:09:04
él hace su trabajo estupendamente 00:09:05
y sigue y ya el otro cuando vuelve de su baja, 00:09:07
pues ya está, 00:09:10
ya completará esto. 00:09:11
Meter el pedido en el array de pedidos del cliente. 00:09:15
¿Vale? 00:09:20
Entonces, 00:09:21
el tío que estaba de baja, 00:09:22
este método, 00:09:24
este método no lo ha hecho, 00:09:27
bueno, ya lo hará, 00:09:29
pero nosotros podemos hacer nuestro software perfectamente 00:09:30
y cuando él lo rellene, 00:09:34
pues ya está, 00:09:35
nosotros no tendremos que tocar nada. 00:09:36
Lo que pasa es que si entonces ahora queremos ya ejecutarlo, 00:09:38
pues hombre, 00:09:41
conviene que ya tengamos esa parte hecha, 00:09:42
porque si no incorporar pedido no va a hacer nada, 00:09:43
todo está vacío. 00:09:45
¿Vale? 00:09:47
Pues para probarlo vamos a, 00:09:48
ala, ya nos incorporamos de la baja 00:09:49
y vamos a hacer este método. 00:09:50
Bueno, pues incorporar pedidos 00:09:53
es como el de incorporar ítem, 00:09:55
mal ítem del pedido, 00:09:57
es lo mismo, 00:09:58
es la misma historia de siempre. 00:09:59
Cogemos este array, 00:10:01
si es nul, 00:10:03
creo una primera posición y la pongo 00:10:04
y si no es nul, 00:10:05
creo una adicional con una más, 00:10:06
copio y pego. 00:10:07
Lo de siempre. 00:10:08
Esto ya es que se puede escribir rapidísimamente 00:10:10
porque es la historia de toda la vida. 00:10:14
¿Vale? 00:10:17
Entonces, 00:10:18
esto sería, 00:10:19
si es el primer pedido 00:10:20
o lo que es lo mismo, 00:10:22
si pedido es igual a nul, 00:10:23
porque es el primero, 00:10:24
pues entonces me creo mi primer array de pedidos 00:10:25
con una posición una, 00:10:29
única, 00:10:32
y pongo en esa única posición 00:10:35
que es pedidos de cero, 00:10:38
pongo el pedido P. 00:10:40
¿Vale? 00:10:42
Y ya he terminado, 00:10:43
no tengo más que hacer, 00:10:44
con lo cual me voy del método, 00:10:45
retún, punto, pelota, 00:10:46
se acabó. 00:10:47
¿Vale? 00:10:48
Que pedidos no es igual a nul, 00:10:50
ya tiene pedidos. 00:10:52
Entonces, 00:10:53
el if no se ejecuta, 00:10:54
luego vengo por aquí, 00:10:55
no hay un retún, 00:10:56
vengo por aquí, 00:10:57
y en ese caso lo de siempre, 00:10:58
pues habrá que hacer una raya auxiliar 00:10:59
de pedidos 00:11:02
con una posición más 00:11:04
que la que tiene el viejo, 00:11:06
una posición más que la que tiene el viejo, 00:11:09
y la que tiene el viejo es pedidos.length 00:11:13
más uno, 00:11:17
y ahora ya copiamos el viejo en el nuevo, 00:11:24
así sea menor que pedidos.length 00:11:32
incrementando i, 00:11:36
copiamos el viejo en el nuevo, 00:11:39
que es aux de i 00:11:41
igual a pedidos de i, 00:11:44
y una vez que hemos copiado el viejo en el nuevo, 00:11:48
en la posición que nos falta, 00:11:50
que es aux de aux.length menos uno, 00:11:52
que es la última de aux, 00:11:56
pues en esta ponemos el nuevo, 00:11:57
y ahora ya no se nos olvide terminar 00:12:00
sustituyendo el viejo por el nuevo. 00:12:02
Pues ya está, 00:12:06
el rollo de siempre, 00:12:07
ahí plantamos. 00:12:08
¿Vale? 00:12:10
Venga, pues ya está. 00:12:14
Lo que importa aquí es que ya tenemos 00:12:17
este método resuelto, 00:12:19
que nos mete un nuevo pedido en el array. 00:12:20
Ya lo tenemos, ¿vale? 00:12:22
Bueno, pues ahora a ver si tenemos ya 00:12:28
todo lo que necesitamos para poder probar 00:12:30
al menos las funciones básicas de este main. 00:12:32
Este main nos permite, 00:12:35
como yo tengo la versión más antigua, 00:12:36
nos permite crear un pedido, ¿verdad? 00:12:38
Porque yo la tenía ya hecha aquí, 00:12:39
¿sí? Permite crear un pedido. 00:12:41
Permite añadir un ítem a pedido, 00:12:45
porque lo tenía ya aquí hecho en el caso dos, 00:12:48
a través del método addItem, 00:12:51
que lo tengo aquí hecho. 00:12:55
¿Vale? 00:12:59
Y el resto de las funciones, 00:13:05
ya yo no las tengo hechas, 00:13:06
vosotros sí. 00:13:07
Vamos a crear un cliente, 00:13:10
que lo tenemos en la 10. 00:13:11
Incorporar pedido a cliente. 00:13:14
Con eso, hombre, ya veremos 00:13:17
si da errores de ejecución o no. 00:13:18
Si da null point exception o no los da. 00:13:19
Si hemos hecho cosas raras, 00:13:21
dará null point exception. 00:13:22
Pero no vamos a poder ver si lo ha hecho bien, 00:13:23
porque no tenemos mostrar los datos de un cliente. 00:13:26
Sería interesante hacer esa funcionalidad rápidamente, 00:13:32
que nos muestre datos de un cliente, 00:13:35
para ver si le incorpora el pedido correctamente. 00:13:37
Vamos a ponerla en la 11. 00:13:40
La 9, mostrar datos del cliente que ha hecho un pedido. 00:13:43
Tienes razón, vale, vale. 00:13:48
Vamos a... 00:13:50
Sí, pero yo quería una funcionalidad 00:13:54
que les daba un cliente mostrar todos los pedidos que ha hecho. 00:13:55
A ver si es verdad que ha incorporado 00:13:58
los pedidos que le estamos diciendo. 00:13:59
Mostrar pedidos de un cliente. 00:14:02
Vamos a hacer la 11. 00:14:03
Mostrar pedidos de un cliente. 00:14:05
Vamos a mostrar pedidos de un cliente cualquiera. 00:14:08
Dado su NIF, claro. 00:14:12
Pues este será el caso 11. 00:14:14
Vale, pues habrá que pedir primero el NIF del cliente. 00:14:21
Introduzca NIF. 00:14:28
Introduzca NIF, vale. 00:14:29
Lo localizamos en el array. 00:14:30
Y sea menor que clientes... 00:14:35
No, clientes len... 00:14:38
No, posclientes, claro. 00:14:39
Y sea menor... 00:14:42
Incrementando. 00:14:49
Y lo localizamos al cliente, como siempre. 00:14:50
Y aquí algo he escrito mal, esto. 00:14:52
Y ahora sí, clientes de I. 00:14:56
Su NIF es igual al NIF de búsqueda. 00:15:00
Ahora ya es clientes de I, 00:15:09
aquel del que le quiero mostrar los datos. 00:15:11
Entonces yo podría ahora ponerme aquí 00:15:13
y hacer un montón de System Outprint LN, 00:15:14
un FOR para recoger sus pedidos y mostrarlos. 00:15:17
Un código muy largo, 00:15:20
solo para mostrar los datos de un cliente. 00:15:22
Entonces aquí sí que me pide el cuerpo, 00:15:24
mira, haz un método. 00:15:27
Mostrar datos cliente, 00:15:29
que pongas en la clase cliente, 00:15:30
y que cuando un cliente lo llame, 00:15:32
te haga todo el chorizo de mostrar para ti y para tal. 00:15:33
Vale. 00:15:36
Entonces si somos vagos, 00:15:38
y yo creo que nos estamos haciendo demasiado vagos 00:15:39
con esto de lo que la Eclipse ayuda, 00:15:41
pues uno hace, venga. 00:15:44
Ojalá yo tuviera un método que se llama 00:15:46
mostrar datos cliente. 00:15:51
Ojalá lo tuviera, 00:15:54
un método que se llamara así. 00:15:56
Y cuando yo lo llamara, 00:15:59
mostrar datos, 00:16:01
me mostrara todos los datos del cliente este, 00:16:02
que lo llama. 00:16:05
Ojalá lo tuviera. 00:16:06
Y entonces pues pongo ahí el punto de la llamada, 00:16:08
pues aspirando que alguien me lo haga, 00:16:10
porque estaría muy bien. 00:16:12
Ahora mismo no lo tengo, 00:16:14
y por eso me lo pone en rojo. 00:16:15
Me dice, 00:16:16
no tienes ningún método para mostrar los clientes. 00:16:17
Vale. 00:16:20
Pero el Eclipse, 00:16:22
que es estúpido e imbécil, 00:16:24
pero a veces es capaz de hacer algo del trabajo sucio, 00:16:26
pues en la línea roja me dice, 00:16:31
venga, 00:16:33
que tú quieres un método mostrar datos, 00:16:35
venga, 00:16:37
créalo. 00:16:38
Pinchamos ahí, 00:16:41
crear. 00:16:42
Repito lo mismo que le he dicho a ellos, 00:16:43
cuidado con las sugerencias que da el compilador aquí, 00:16:45
porque el 99% no nos interesa porque están fatal. 00:16:50
Nosotros cuando pinchamos ahí, 00:16:54
es porque ya sabemos qué queremos hacer. 00:16:56
Ya sabemos qué queremos hacer. 00:16:58
Y buscamos saber si nos lo ofrece. 00:17:00
Pero no a ver qué nos ofrece y yo elijo. 00:17:02
Porque lo que nos ofrece a mayoría de los casos 00:17:04
no tiene ningún sentido. 00:17:06
Pero yo aquí sé lo que quiero hacer. 00:17:08
Es crear un método como este. 00:17:10
Venga, voy a ver si me lo ofrece. 00:17:12
Anda, venga. 00:17:14
Pues entonces yo le digo, 00:17:16
ah, pues sí, quiero. 00:17:17
Le dais doble click 00:17:18
y ya él se va a la clase cliente 00:17:19
y te hace el método con los parámetros de entrada 00:17:22
que en este caso son cero. 00:17:25
Voy y te dice, 00:17:27
pues ya está, ya te lo he hecho. 00:17:28
Claro, lo hacía lógicamente, 00:17:30
le metes todo el código normal. 00:17:31
Vale, pero ya sabemos qué es. 00:17:32
En la clase cliente, 00:17:35
que es donde estamos, 00:17:36
donde lo ha hecho, 00:17:37
mostrar esto, 00:17:38
ya está, mostrarlo. 00:17:39
Pues venga, 00:17:41
vamos a mostrar ahí. 00:17:42
Aquí ya nos hacemos nuestro system out así 00:17:46
muy rápidos y muy feos 00:17:49
para no perder mucho tiempo. 00:17:52
Vamos a poner solamente el nombre del cliente, 00:17:55
no nif ni nada, 00:17:58
solo por ser rápidos. 00:17:59
Si lo hiciéramos bien, 00:18:03
venga, nombre del cliente es este. 00:18:04
Y ahora vamos a mostrar los pedidos que ha hecho 00:18:08
para comprobar que efectivamente 00:18:11
los pedidos se han incorporado, etc. 00:18:12
Para mostrar los pedidos, 00:18:15
pues tendremos que hacer un for. 00:18:16
De nuevo vamos a ser vagos, 00:18:18
como vamos a consultar. 00:18:19
Vamos a hacer un for each. 00:18:21
Voy a recorrer el array de pedidos 00:18:24
que tengo aquí arriba. 00:18:25
Este array. 00:18:27
Me voy a hacer aquí un for each 00:18:29
y ahora ya voy a mostrar. 00:18:31
Vale, le voy a poner un tabulador 00:18:39
para que me quede tabulado 00:18:43
los pedidos del nombre del cliente. 00:18:44
Vale, esto es un tabulador 00:18:46
porque es carácter de escape. 00:18:48
Es un tabulador, 00:18:50
un carácter especial del teclado. 00:18:51
Y venga, después del tabulador 00:18:53
pues vamos a poner 00:18:55
descripción pedido. 00:18:57
Descripción del pedido. 00:19:01
Y ahora esto lo tendremos que concatenar 00:19:07
con p.getDescripción. 00:19:09
Vale. 00:19:16
Y así podríamos mostrar 00:19:18
el resto de propiedades 00:19:20
de cada pedido p del array. 00:19:21
Descripción y podríamos meternos 00:19:24
a mostrar los ítems. 00:19:26
Pero bueno, vale, no nos alargamos. 00:19:28
Lo ideal es que uno haga aquí un método 00:19:31
que te muestre todo, claro. 00:19:32
Descripción del pedido, código. 00:19:34
Se ponga a recorrer los ítems de p. 00:19:36
Que p recordad que tiene 00:19:39
un array de ítems 00:19:41
que está aquí. 00:19:43
Aquí, perdón. 00:19:47
Está ahí. 00:19:49
Entonces para que este método 00:19:51
de mostrar datos del cliente 00:19:53
sea completo, 00:19:55
podríamos mostrar ahí de todo. 00:19:56
Como yo solamente voy a verificar 00:19:58
que funciona, 00:20:00
voy a mostrar solamente 00:20:01
para cada cliente su nombre 00:20:02
y las descripciones 00:20:05
de todos los pedidos que ha hecho. 00:20:06
Pero incorporad vosotros más cosas 00:20:08
para cada pedido también, 00:20:11
un for que recorra los ítems 00:20:13
para ver que está todo bien. 00:20:14
Vale, ya tengo a mostrar datos. 00:20:17
Bueno, pues ahora mi main 00:20:19
ya vamos a probarlo. 00:20:21
Vamos a probarlo a ver si puedo 00:20:22
insertar pedido, insertar cliente, 00:20:23
asociar pedido a cliente 00:20:25
y luego cuando muestre 00:20:27
datos del cliente 00:20:28
a ver si es verdad que lo tiene, 00:20:29
lo tiene todo. 00:20:30
Vamos a ver. 00:20:32
Porque estamos probando 00:20:35
muchas cosas de golpe 00:20:36
y alguna pues habremos escrito mal. 00:20:37
Pues venga. 00:20:41
Venga, vamos a crear un pedido 00:20:45
lo primero de todo. 00:20:46
Venga, me acaban de... 00:20:50
Bueno, yo ya empiezo con los 00:20:51
scan necklines in 00:20:53
porque no tengo la clase teclado 00:20:55
que es muy bonita. 00:20:57
Entonces me falta a mí 00:20:59
un neckline después de algún sitio. 00:21:00
Me falta aquí. 00:21:06
Esto ya lo tenía arreglado 00:21:10
en la versión del portátil 00:21:11
pero en esta no. 00:21:13
Me falta aquí un neckline. 00:21:15
¿Dónde más me falta? 00:21:17
Me va a faltar aquí. 00:21:20
Después de haber leído esto. 00:21:22
scan.neckline 00:21:24
también me va a faltar. 00:21:27
¿Ves? Por esto es bueno 00:21:28
que os acostumbréis a usar la clase 00:21:29
importándola como hard, 00:21:31
la clase que hicimos ayer 00:21:32
porque va a ser todo mucho más fácil. 00:21:35
Vale, y ya no me van a faltar más 00:21:39
porque no tengo más cosas hechas. 00:21:40
Creo. 00:21:42
Venga, pues volvemos. 00:21:43
Siguiente prueba. 00:21:45
Que la primera prueba no la hemos pasado. 00:21:47
A ver la siguiente. 00:21:50
Creamos pedido. 00:21:51
Vale, ya se para en código. 00:21:53
Menos mal. 00:21:54
Venga, pedido de código 1. 00:21:55
Descripción del pedido. 00:21:58
Como siempre, casi no se nos olvida. 00:22:00
Bolis. 00:22:02
Pedido 1. 00:22:03
Que tiene bolis. 00:22:05
El otro día ya probamos 00:22:10
lo de añadir ítems a un pedido. 00:22:11
Vimos que funcionaba. 00:22:13
No le voy a añadir ningún ítem. 00:22:14
Un pedido de bolis sin ítem. 00:22:15
Ya está. 00:22:17
Pero vamos, ya sabemos que funciona 00:22:19
añadir ítems. 00:22:20
Vale, venga. 00:22:21
Vamos a meter un cliente. 00:22:22
Ya tenemos un pedido. 00:22:23
Vamos a meter un cliente. 00:22:24
Cliente era la opción 10. 00:22:25
Introduzca NIF del cliente. 00:22:30
Pues 1, 2, 3, 4. 00:22:32
Introduzca nombre del cliente. 00:22:34
Repito. 00:22:37
Introduzca dirección. 00:22:38
Vive en Madrid. 00:22:40
Bueno, en principio ya se ha creado el cliente. 00:22:42
De NIF 1, 2, 3, 4. 00:22:44
Vale, vamos a mostrar ahora mismo sus datos. 00:22:48
Ahora mismo no va a tener pedidos. 00:22:51
Vamos a ver qué nos muestra. 00:22:52
Mostrar pedidos de un cliente. 00:22:54
11. 00:22:58
La opción 11. 00:22:59
Introduzca NIF de qué cliente quieres mostrar datos. 00:23:01
Queremos mostrar datos del cliente 1, 2, 3, 4. 00:23:04
Único que tenemos. 00:23:06
Único que tenemos. 00:23:07
1, 2, 3, 4. 00:23:08
Vale, pues nos muestra el nombre. 00:23:10
Y aquí nos dice. 00:23:12
Esto casi lo podemos ver. 00:23:15
Null pointer exception. 00:23:16
Cuando muestras los pedidos de un cliente 00:23:18
que todavía no tiene ninguno. 00:23:21
Era de espera. 00:23:26
Pero es típico. 00:23:27
Uno va a hacer la primera prueba. 00:23:28
Le sale esto. 00:23:29
Primero. 00:23:30
Con estas cosas recordad que esto no se trata de. 00:23:31
¿Cuál es el pedido? 00:23:34
¿Me ha fallado? 00:23:35
No. 00:23:36
Esto es obviamente la clave de todo. 00:23:37
Y esto hay que saber entenderlo y destriparlo. 00:23:42
Vale. 00:23:45
Primero. 00:23:46
Esta es la clave. 00:23:47
Null pointer exception. 00:23:48
Ya sabemos lo que significa. 00:23:49
Un objeto que es nulo. 00:23:50
En algún sitio. 00:23:52
Ese objeto que es nulo. 00:23:53
Está intentando llamar a métodos, a propiedades. 00:23:55
Y es nulo. 00:23:57
Si es nulo es imposible. 00:23:58
Null pointer exception. 00:23:59
Ya sabemos que esa es la causa. 00:24:01
Ahora lo siguiente. 00:24:03
¿Y dónde? 00:24:04
¿En qué momento ha pasado eso? 00:24:05
¿En qué momento ha pasado que yo haya hecho eso? 00:24:06
Pues vamos bajando. 00:24:08
Hasta que llegamos a la primera línea. 00:24:09
Que nos aparece un código que hemos hecho nosotros. 00:24:12
Porque aquí arriba podría haber clases internas de la máquina virtual. 00:24:15
Y aquí. 00:24:19
Ah, cliente. 00:24:20
Esta la he hecho yo. 00:24:21
Esta es mía. 00:24:22
Cliente. 00:24:23
Ha sido cuando llamábamos a datos. 00:24:24
Voy a pinchar ahí. 00:24:25
Voy a pinchar ahí y a ver dónde ha estado el problema. 00:24:26
Pinchamos ahí. 00:24:27
Anda. 00:24:29
Claro. 00:24:31
¿Qué pasa? 00:24:33
For each. 00:24:35
¿Por qué os digo a veces? 00:24:36
Uy, el for each cuidadín. 00:24:38
Que a veces es problemático. 00:24:39
Cuidado con él. 00:24:41
Vale. 00:24:43
Con un for de índice. 00:24:44
Aquí no habría sido null pointer exception. 00:24:45
¿Por qué? 00:24:47
Porque el for de índice sería. 00:24:48
Ah, bueno. 00:24:50
Perdón. 00:24:51
Sí que habría salido. 00:24:52
Vale. 00:24:53
A ver. 00:24:54
El for each. 00:24:55
¿Qué está haciendo? 00:24:56
Pedidos. 00:24:57
Pedidos es null. 00:24:58
Uno podría pensar. 00:24:59
Como es null, no entra. 00:25:00
No entra. 00:25:02
No, no es verdad. 00:25:03
Es que el for each, antes de eso, 00:25:04
trata de sacar propiedades de pedidos. 00:25:06
¿Cómo? 00:25:07
¿Cuál es tu longitud? 00:25:08
¿Cuál es tu longitud para empezar a recorrerlo? 00:25:09
Pues cuando se haga el pedidos.len, 00:25:11
ahí es donde le viene el null pointer exception. 00:25:13
Entonces, aquí nosotros, físicamente, 00:25:16
no nos parece estar viendo que estemos llamando 00:25:18
a ninguna propiedad de pedidos. 00:25:21
No la estamos viendo. 00:25:23
Pero el for each por dentro lo hace. 00:25:24
El for each hace. 00:25:26
A ver, pedidos. 00:25:27
Hay que recorrer pedidos. 00:25:28
Muy bien. 00:25:29
Voy a hacer yo por dentro un pedidos.len. 00:25:30
A ver cuál es la dirección. 00:25:32
La longitud. 00:25:33
Pues cuando haga el pedidos.len, 00:25:34
le sale el null pointer exception. 00:25:36
Ese es el problema. 00:25:38
Que lo hubiéramos hecho con un for int. 00:25:40
Con un for de índice. 00:25:42
En realidad nos habría salido también un problema. 00:25:45
En este caso. 00:25:47
Porque habríamos hecho esto. 00:25:48
Desde int igual a cero. 00:25:50
Mientras i sea menor que pedidos.len. 00:25:52
Y más más habríamos hecho esto. 00:25:58
Descripción esto. 00:26:01
Aquí también nos habría salido 00:26:11
un null pointer exception. 00:26:12
Porque pedidos es null. 00:26:13
Porque no ha hecho ningún pedido. 00:26:14
Al hacer punto de cualquier cosa que sea null. 00:26:16
Null pointer exception. 00:26:18
Pero al menos aquí. 00:26:20
Cuando le damos para arreglarlo. 00:26:21
Es que lo vemos rápido. 00:26:23
Decimos. 00:26:24
Justo. 00:26:25
Aquí está. 00:26:26
Aquí. 00:26:27
Parece misterioso. 00:26:28
Decimos. 00:26:29
¿En qué momento estamos llamando 00:26:30
a propiedades de pedidos? 00:26:31
En ningún momento. 00:26:32
Pero claro. 00:26:33
Está haciendo el for each por dentro. 00:26:34
Es más misterioso. 00:26:35
O sea. 00:26:36
El for each por dentro hace un montón de cosas. 00:26:37
Hace copias de la raya. 00:26:38
Hace de todo. 00:26:39
Entonces por eso tiene peligro. 00:26:40
¿Vale? 00:26:41
Hay que entender bien. 00:26:42
Cómo funciona. 00:26:43
Bueno. 00:26:46
Pues entonces. 00:26:47
Bien por esta opción. 00:26:48
Bien por esta. 00:26:49
Nos dan un pointer exception. 00:26:50
Que entendemos por qué. 00:26:51
Tiene todo el sentido del mundo. 00:26:52
¿Vale? 00:26:53
¿Cuál es el problema? 00:26:54
Que cuando el cliente no tiene todavía 00:26:55
ningún pedido. 00:26:56
No tiene todavía ninguno. 00:26:57
En ese caso. 00:26:58
No queremos recorrerlo. 00:26:59
Bueno. 00:27:01
Pues es tan fácil como meter esto en un. 00:27:02
Y el pedido es distinto de null. 00:27:03
Y solucionado. 00:27:05
Y ya está. 00:27:06
¿No? 00:27:07
Y tan fácil. 00:27:08
Bueno. 00:27:10
Entonces. 00:27:11
Voy a. 00:27:12
Dejar esto aquí. 00:27:13
Y entonces. 00:27:14
Si pedidos. 00:27:15
Es distinto de null. 00:27:16
Y solo en ese caso. 00:27:17
Entonces. 00:27:18
Ahora ya sí recorre. 00:27:19
Y si no. 00:27:20
Es que el cliente no tiene ningún pedido. 00:27:21
No tiene ninguno. 00:27:22
Todavía no hay nada que recorrer. 00:27:23
Vale. 00:27:24
Pues entonces. 00:27:25
Aquí me debe faltar. 00:27:26
O sobrar una llave. 00:27:27
O me debe. 00:27:28
Aparar. 00:27:29
¿Vale? 00:27:30
Aparar. 00:27:31
Aparar. 00:27:32
Aparar. 00:27:33
Aparar. 00:27:34
Aparar. 00:27:35
Aparar. 00:27:36
Aparar. 00:27:37
Aparar. 00:27:38
Aparar. 00:27:39
A pedidos de i. 00:27:40
Porque lo he cambiado al. 00:27:41
Pedidos. 00:27:42
Pedidos de i. 00:27:43
Vale. 00:27:44
Ala. 00:27:45
Vale. 00:27:46
Pues volvemos a pasar la prueba. 00:27:47
Vámonos al main otra vez. 00:27:48
Venga. 00:27:49
Siguiente. 00:27:50
Primero. 00:27:51
Creamos un pedido. 00:27:52
¿Vale? 00:27:53
¿Vale? 00:27:54
¿Vale? 00:27:55
¿Vale? 00:27:56
¿Vale? 00:27:57
¿Vale? 00:27:58
¿Vale? 00:27:59
¿Vale? 00:28:00
¿Vale? 00:28:01
¿Vale? 00:28:02
¿Vale? 00:28:03
¿Vale? 00:28:04
¿Vale? 00:28:05
¿Vale? 00:28:06
¿Vale? 00:28:07
¿Vale? 00:28:08
Segundo. 00:28:09
Bueno, ¿qué tal puedo hacer? 00:28:10
Código 1 de descripción. 00:28:12
Pedido de boli sin ítem y sin nada. 00:28:14
Eso ya probamos, que podríamos añadir. 00:28:16
Vamos a insertar un cliente. 00:28:19
Venga, un If, un 2, 3, 4. 00:28:20
Nombre. 00:28:25
Pepito. 00:28:27
Dirección. 00:28:28
Pues vive en Madrid. 00:28:29
Ahí está, el cliente registrado. 00:28:31
Todavía no tiene ningún pedido hecho. 00:28:32
Ahora resulta, oye este pedido que hemos hecho. 00:28:34
Vamos a poner solo este cliente. 00:28:37
Pues venga, para eso tenemos el método. 00:28:39
Incorporar pedido a cliente. 00:28:41
Venga. 00:28:44
Ah, bueno, primero íbamos a mostrar los datos del cliente, 00:28:44
para ver que no tiene pedidos. 00:28:48
Vamos a mostrar primero los datos del cliente. 00:28:49
Opción 11, a ver si esta vez no falla. 00:28:51
¿De qué cliente quieres mostrar pedidos? 00:28:55
De un 2, 3, 4. 00:28:57
Pues me dice, nombre del cliente, Pepito. 00:29:00
Efectivamente. 00:29:03
¿Vale? 00:29:05
Esto de opción incorrecta, es porque me falta un next line, 00:29:05
se queda con el salto de línea, se cree que ese es la opción, 00:29:08
etcétera. 00:29:11
Entonces, me falta un next line. 00:29:11
Pero no me ha mostrado pedidos, efectivamente. 00:29:13
Pero a mí me falta un next line por algún lado. 00:29:15
Porque esto, cuando ya la aplicación se hace muy gorda, 00:29:20
con entrada y salida, es hacerlo con escáner y next line es 00:29:22
una locura. 00:29:25
A ver. 00:29:35
En algún sitio tengo ya aquí un next line de más, 00:29:39
que luego cuando lo leen. 00:29:44
Vale, bueno. 00:29:51
Vale, tengo que encontrar el next line que tengo, 00:29:53
modificarlo para que no se quede en el buffer y no lo coja la 00:29:56
opción del menú. 00:30:01
Pero bueno, eso. 00:30:02
Vale, vamos ahora a la opción y ya nos vamos a ver si nos sale 00:30:03
error o no. 00:30:07
Ahora vamos a ponerle un pedido a ese cliente. 00:30:08
Venga, código del pedido a ponerle al cliente. 00:30:12
Código del pedido. 00:30:14
Pues el 1, el único pedido que tenemos. 00:30:16
El pedido 1. 00:30:19
Pedido 1, venga. 00:30:21
1, vale. 00:30:25
Nib del cliente al que le vamos a poner ese pedido. 00:30:26
El único nib que tenemos, 1, 2, 3 y 4. 00:30:29
No sabemos si se lo ha metido o no. 00:30:34
No sabemos. 00:30:36
Vamos a mostrar datos de ese cliente. 00:30:37
Pedidos, a ver si ahora me aparece. 00:30:39
Los muestro, introduzcan nib. 00:30:41
1, 2, 3, 4. 00:30:42
Vale. 00:30:45
Nombre cliente pedido y aquí está. 00:30:46
Nombre cliente Pepito y aquí está su único pedido. 00:30:49
Pues sí, lo ha incorporado. 00:30:52
Y esto es lo del next line que se ha quedado ahí, pero bueno. 00:30:53
Vale, pues lo que hemos hecho parece que funciona. 00:30:56
Bueno, pocas pruebas, pero bueno. 00:30:58
Venga, vamos a parar aquí. 00:31:02
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
23 de enero de 2024 - 13:45
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
592.35 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid