Saltar navegación

20251215 AppClientesPedidos_2 - 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 15 de diciembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

registrar cliente era una funcionalidad básica 00:00:00
que ya hemos hecho 00:00:03
vamos a hacer una, que menos 00:00:03
puedo 00:00:06
vale 00:00:11
pues que menos que ponerle una funcionalidad 00:00:20
que sea 00:00:25
ver el listado de clientes 00:00:26
para así 00:00:28
poder comprobar si se ha registrado correctamente 00:00:28
o no 00:00:32
que menos, poder tener un listado de clientes 00:00:32
pues venga, vamos a hacer la opción 2, listado de clientes 00:00:37
la opción 2 no hay que pedirle nada al usuario 00:00:41
simplemente hay que recorrer este array para mostrarlo 00:00:45
entonces en principio uno podría hacer esto, verdad 00:00:50
y ahora, parte buena y bonita y estupenda 00:00:52
de haber hecho el toStream, yo quiero mostrar el cliente 00:01:05
con lo que nosotros hemos dicho hasta ahora, 00:01:09
cliente tiene tres cosas dentro. 00:01:14
NIF, nombre, pedidos. 00:01:17
Entonces, realmente mostrarle al cliente sería 00:01:20
que meto en el system out. 00:01:22
Meto NIF, meto nombre, recorro el array 00:01:24
y meto los pedidos. 00:01:27
¿Qué meto? 00:01:31
¿Tendría que hacerte system out? 00:01:34
Pero claro 00:01:36
¿Qué ocurre? 00:01:38
¿Qué pasa? 00:01:41
¿Qué pasa si yo le paso 00:01:42
¿Eh? 00:01:45
Sí, pero 00:01:49
¿Por qué te has dado cuenta 00:01:50
Tan rápido? 00:01:53
Quería que se vea en la ejecución 00:01:54
¿Vale? Efectivamente, efectivamente 00:01:56
Lo he puesto así a propósito porque así no lo haríamos 00:01:58
¿Vale? Pero bueno, olvidaos de esta línea por ahora 00:02:00
Olvidaos de esta línea 00:02:03
Por ahora 00:02:05
Vamos a esta 00:02:05
¿Vale? Olvidaos de esta línea por ahora 00:02:07
Vamos a esta 00:02:09
Ahora mismo 00:02:11
Ahora vámonos al system out por ahora 00:02:12
La opción 2 00:02:14
Mostrar el listado de clientes 00:02:17
Que se supone que está en el array 00:02:19
Vale 00:02:21
Vámonos a mostrar el cliente 00:02:22
Cliente es una caja 00:02:27
Con varias cosas dentro 00:02:29
Entonces al system out 00:02:31
Yo no le paso 00:02:33
la caja, ¿qué le pasas? 00:02:35
le pasas el nombre, le pasas, pero claro 00:02:37
ahora es donde sabemos 00:02:39
oye, ¿qué pasa? que C 00:02:41
tenía un método maravilloso 00:02:43
cliente, que era tu string 00:02:45
que me lo convierte a una cadena 00:02:46
pues, magnífico 00:02:49
llamo a tu string y le paso esa cadena 00:02:51
pero es que todavía 00:02:53
más apañado 00:02:55
si yo le paso un objeto 00:02:56
al system out, le paso un objeto 00:02:58
sin más, sin este tu string 00:03:01
le paso el objeto 00:03:03
el system out este 00:03:04
al ver que no es stream 00:03:06
él ya automáticamente llama a tu stream 00:03:07
porque asume que tú tienes ese método 00:03:10
de ahí la importancia 00:03:12
de hacer el método tu stream 00:03:15
porque quienes nos usen, sean los que sean 00:03:16
por ejemplo el SISO este 00:03:18
quienes nos usen, van a asumir 00:03:20
que lo tenemos y si lo necesitan 00:03:22
lo van a llamar 00:03:25
pues el SISO lo necesita 00:03:26
porque el SISO solo es capaz de mostrar cadenas 00:03:28
solo, entonces si yo le paso 00:03:30
algo que no sea una cadena 00:03:32
él, ah, no pasa nada, te llamo al toString 00:03:33
y da por asumido 00:03:36
que lo tenemos 00:03:38
entonces 00:03:40
hace falta que le pase el toString 00:03:41
no hace falta 00:03:45
que se lo pase 00:03:45
porque el System.out.println cuando ve 00:03:49
que le pasó algo que no es cadena 00:03:52
él ya llama al toString 00:03:54
solito, da por sentado que lo tenemos 00:03:56
¿vale? 00:03:58
con lo cual, esa es la importancia 00:04:00
de tener ese método 00:04:02
y no solamente el System.out 00:04:03
va a llamar alto stream, cualquier otro método 00:04:05
que haya por ahí, que nos use 00:04:08
y necesite que seamos cadena 00:04:09
lo va a llamar, va a dar por hecho 00:04:11
que lo tenemos 00:04:13
vale, lo vamos a poner 00:04:15
aquí como comentario 00:04:18
entonces me podríais decir 00:04:18
oye, pero y si yo no he hecho 00:04:36
alto stream, porque no es obligatorio 00:04:38
si yo no lo he hecho 00:04:40
¿qué pasa? 00:04:41
si yo no lo he hecho 00:04:44
el compilador sin ningún problema 00:04:45
pero a la hora de ejecutarle 00:04:48
el toString que se va a llamar 00:04:50
es un toString por defecto 00:04:52
que muestra unas cosas muy raras 00:04:54
entonces el toString por defecto 00:04:56
si yo no hago un toString 00:04:59
hay uno por defecto 00:05:00
pero que muestra unas cosas muy raras 00:05:02
entonces el por defecto no lo queremos 00:05:04
por eso hacemos uno específico bonito 00:05:06
¿vale? 00:05:08
hacemos uno específico bonito para no usar 00:05:10
para que no use el por defecto 00:05:12
la clase que sea 00:05:14
Entonces lo ponemos aquí 00:05:16
Si no hubiéramos hecho un toString 00:05:22
Si no hubiéramos 00:05:24
Hecho un toString 00:05:28
Nosotros 00:05:32
Si no lo hubiéramos hecho 00:05:33
Se llamaría a uno por defecto 00:05:36
Pero este por defecto 00:05:41
Muestra unas cosas muy raras 00:05:46
Y no nos interesa 00:05:47
Por eso hacemos uno y listo 00:05:48
Vale, y ahora ya sí 00:05:52
Vamos a lo que habéis apuntado 00:05:53
El forEach 00:05:56
aquí es muy mala elección 00:05:57
porque el for each ya sabemos que te recorre 00:05:58
la raya entero de principio a fin 00:06:01
entero, no puedes parar antes 00:06:03
y nosotros no queremos 00:06:05
recorrer la raya entero 00:06:07
queremos recorrer 00:06:09
solo hasta la posición 00:06:11
que esté rellena 00:06:13
porque la raíz son 100, yo lo he instanciado como 100 00:06:14
con lo cual este for each 00:06:17
de aquí 00:06:19
se va a ejecutar 100 veces 00:06:20
si solo tengo uno, me va a mostrar 00:06:23
99 nul 00:06:25
Entonces yo aquí 00:06:26
El for each es una elección muy mala 00:06:28
Vamos a hacer un for de índice 00:06:30
Y digo yo 00:06:32
¿Dónde me quedo? 00:06:34
Pues empezando por la 0 00:06:38
Mientras 00:06:40
Y sea menor que qué 00:06:42
¿Qué pondríamos? 00:06:44
Esta, que es la que me dice 00:06:51
¿Cuántos realmente tengo rellenos? 00:06:53
Esta variable 00:06:58
es la que me dice cuantos tengo rellenos 00:06:59
cuando la siguiente posición libre es 0 00:07:01
es porque no tengo ninguno 00:07:05
no hay lista de clientes 00:07:06
cuando es 1 00:07:09
cuando la siguiente a rellenar es 1 00:07:11
es porque tengo un cliente 00:07:14
el de la 0 00:07:16
cuando la siguiente posición a rellenar es la 2 00:07:16
es porque tengo dos clientes 00:07:19
el 0 y el 1 00:07:21
luego siguiente posición libre me sirve 00:07:21
como contador de posiciones 00:07:25
que están rellenas 00:07:27
Esta variable nos sirve 00:07:28
Porque lo es, realmente lo es 00:07:35
Como contador 00:07:37
De posiciones que se han rellenado 00:07:38
Realmente 00:07:42
Vale, pues 00:07:43
Por el hecho 00:07:56
De que el array 00:07:58
Necesita fijar una posición al principio 00:08:01
Hemos tenido que usar esta variable 00:08:03
Adicional, no nos queda otra 00:08:05
Vale 00:08:07
Aquí tengo un error de compilación por ahí 00:08:09
Que aquí lógicamente 00:08:11
no es c, sino que es clientes 00:08:14
de id 00:08:16
y este va a llamar alto string 00:08:17
vale, aquí ya podríamos hacer 00:08:20
deberíamos hacer la primera prueba 00:08:26
a ver si al menos la funcionalidad 00:08:28
de registrar clientes la hace correctamente 00:08:30
aunque aquí 00:08:32
voy a tener el problema de que después 00:08:34
del next ir al hacer next line 00:08:36
se va, entonces 00:08:38
necesito aquí esto 00:08:40
porque si no se queda el salto de línea 00:08:42
que va a coger el salto de línea con el nif 00:08:47
No me va a dejar meter el NIF, etc 00:08:49
Vale 00:08:51
Pues probad a hacer la primera 00:08:57
Prueba 00:08:58
Venga, registrar 00:09:00
Vamos a mostrar el listado de clientes 00:09:04
Antes de nada, nada, el listado de clientes no me muestra nada 00:09:07
No me muestra nada, no tengo clientes 00:09:10
Vamos a registrar uno 00:09:12
Nombre 00:09:13
1111 00:09:15
NIF 1111 00:09:16
Nombre 00:09:18
Nombre 1 00:09:20
Cliente registrado, suponemos 00:09:22
Vamos a ver ahora el listado 00:09:25
Aquí algo hemos hecho mal 00:09:27
Dispedidos is null 00:09:30
Vale 00:09:34
En la clase cliente 00:09:35
He puesto el atributo 00:09:50
¿Cuál? 00:09:51
Sí, a todos 00:09:53
Vale, entonces ahora 00:09:54
Vamos a ver, ahora vamos a 00:09:56
desentrañar una traza de error, que es una 00:09:58
de nuestras tareas más importantes, la que 00:10:00
vamos a hacer, vais a 00:10:02
hacer todo el rato, uy 00:10:04
porque me ha salido error, yo no 00:10:06
tenía en mente que aquí fallara algo, aparentemente 00:10:08
lo hemos hecho todo bien, importantísimo 00:10:10
vamos a ver que nos dice 00:10:13
null pointer exception 00:10:14
error básico 00:10:16
que significa null pointer exception 00:10:18
significa que yo estoy 00:10:20
tratando de entrar en un objeto 00:10:22
que es null, que pasa 00:10:24
continuamente, intentar entrar en un objeto 00:10:26
que es null, vale, hay un objeto 00:10:28
ahí que estoy haciendo, ese objeto 00:10:30
punto algo, ese es el problema, ¿no? del null pointer 00:10:32
exception, yo a un objeto le hago 00:10:34
punto lo que sea 00:10:36
y si ese objeto es null 00:10:38
el punto lo que sea me va a decir null pointer 00:10:39
exception, vale, vamos a ver 00:10:42
que más detalles me da 00:10:44
me dice, no puedo 00:10:45
leer, this pedidos 00:10:47
is null 00:10:50
vale, efectivamente 00:10:51
el cliente tiene 00:10:53
un array de pedidos null 00:10:56
pero yo he accedido a pedidos en algún momento 00:10:57
debe ser que sí 00:11:00
vamos a ver 00:11:02
claro, vamos a ver 00:11:03
en la traza donde me lleva, pues nosotros 00:11:05
bajamos hasta aquí, hasta llegar 00:11:08
a la primera clase que es nuestra 00:11:10
que en este caso es esta, cliente Java 00:11:11
pues justo, cuando 00:11:13
el system out ha llamado al toString 00:11:16
ha intentado hacer un 00:11:18
pedidos.length 00:11:20
y pedidos es null 00:11:22
luego aquí ha salido el error 00:11:23
entonces este toString 00:11:26
no está bien, porque si el objeto 00:11:27
pedidos es null 00:11:30
aquí va a salir null pointer exception 00:11:31
entonces aquí 00:11:34
pues tendríamos que tocarlo 00:11:36
para que el número de pedidos 00:11:38
pues 00:11:40
depende, ¿con qué lo vamos a concatenar? 00:11:41
depende, si es 0 con 0, o sea si pedidos 00:11:43
es null, le vamos a poner aquí 00:11:46
directamente un ternario 00:11:48
si pedidos 00:11:49
es igual a null 00:11:51
entonces concaténamelo 00:11:53
Con cero 00:11:56
Y si no, concatenamelo 00:11:57
Con 00:12:00
Pedidos.length 00:12:01
Vale 00:12:04
No me deja concatenar directamente con el ternario 00:12:06
Ahí 00:12:08
Pero si lo pongo todo en paréntesis 00:12:08
Ya igual sí 00:12:12
A ver, sí, vale 00:12:13
Vale 00:12:16
Pues he cambiado el pedidos.length 00:12:18
Que lo tenía así a capón 00:12:20
Lo he cambiado por esto 00:12:22
que es jugar con el ternario 00:12:24
que sabemos hacerlo 00:12:27
lo he cambiado, hoy es null 00:12:28
entonces plántame 0 00:12:30
si es null no me hagas pedidos.led 00:12:32
número de pedido 0 00:12:34
y si no es null 00:12:37
entonces ya sí que plántame pedidos.led 00:12:38
ahora ya 00:12:40
ese null pointer exception 00:12:42
vale, entonces aquí lo que 00:12:44
concatenamos, con lo que concatenamos 00:12:50
que está entre estos paréntesis 00:12:52
lo que concatenamos, pues depende 00:12:54
concateno con esto o concateno con esto 00:12:56
dependiendo de esa condición 00:12:58
vale, concateno con esto 00:13:00
o con esto, ahí está metidito dentro de la 00:13:02
concatenación, o con esto 00:13:04
o con esto, depende 00:13:07
vale, entonces se usa mucho este 00:13:08
este operador 00:13:12
ternario, porque yo tengo que usar 00:13:15
un valor y a veces ese valor 00:13:16
o uso una versión o uso otra en función 00:13:18
de una condición, no pasa nada 00:13:20
lo pongo así, vale, vamos a 00:13:23
volver a ejecutar el main 00:13:25
este. Registramos 00:13:26
cliente. 00:13:33
Nombre 1. 00:13:36
Vale, registrado. Listado de clientes. 00:13:37
Ahora ya sí. 00:13:40
Cliente, nombre 1, 00:13:42
número de pedidos 0. 00:13:43
El tuestrín ha quedado un poco feo porque se ha quedado muy 00:13:45
concatenado el nombre con número de pedidos. 00:13:47
Luego le vamos a poner aquí 00:13:50
el espacio. 00:13:51
Número pedidos. 00:13:53
Antes de cerrar esta versión, vamos a 00:13:57
insertar otro para hacer una prueba un poco más 00:14:00
completa. Vamos a registrar otro cliente más. 00:14:02
Dos con nombre 00:14:04
Dos 00:14:06
Listado de clientes, pues aquí están los dos 00:14:07
Ambos con número de pedidos 00:14:12
Cero 00:14:14
Salir 00:14:15
Bueno, pues vale 00:14:17
La primera parte, lo que hemos hecho funciona 00:14:26
Como veis está bien 00:14:31
Haciendo pruebas 00:14:32
De forma progresiva 00:14:33
Para no acumular errores 00:14:36
Aquí ya hemos depurado un primer error 00:14:39
Que se nos había escapado 00:14:41
el del toString 00:14:42
entonces si vamos incorporando, hacemos un programa así 00:14:43
y pasamos las pruebas cuando ya lo tenemos 00:14:46
todo, pues salen ahí 00:14:48
un montón de errores que va a ser mucho más complicado 00:14:50
de depurar, vale, esta parte ya está 00:14:52
venga, vamos a hacer 00:14:54
siguiente funcionalidad 00:14:56
que sería evidente que va a necesitar 00:14:58
esta persona, que es 00:15:00
agregar un pedido a un cliente 00:15:01
pues vamos a la opción 00:15:05
Pedido a un cliente, él ha venido a la tienda o lo ha hecho por internet o por lo que sea 00:15:18
Y a mí me toca a ese cliente meterle el pedido en su lista de pedidos 00:15:30
Me toca eso, agregar pedido a cliente 00:15:35
Pues venga, caso 3 00:15:38
A ver, ¿qué datos va a necesitar? 00:15:40
Los datos del pedido 00:15:51
Los datos del pedido que son la descripción y el precio 00:15:53
¿por qué? porque el código 00:16:02
no lo da el que compra 00:16:05
cuando vos compráis algo 00:16:07
quiero esto y no sé qué 00:16:09
vale, y voy a pagar esto, esos datos son 00:16:11
vuestros, pero el código 00:16:13
se supone que 00:16:16
es un dato interno que le genera la aplicación 00:16:17
para luego tener ubicados los pedidos 00:16:19
o lo que sea 00:16:21
entonces pues vamos a hacerlo así 00:16:22
entonces 00:16:24
vamos a generar códigos 00:16:26
únicos para los pedidos 00:16:29
Una variable interna de la aplicación 00:16:31
Que genera códigos únicos 00:16:35
Los datos que vienen de fuera realmente 00:16:36
Son la descripción y el precio 00:16:38
Son los que vienen de fuera 00:16:40
El código no debería venir de fuera 00:16:41
Porque el que lo mete 00:16:44
No sabe si ese código ya existió o no 00:16:45
A lo mejor mete uno que ya está usado 00:16:48
Y los códigos deberían ser únicos por definición 00:16:50
Como las claves primarias de las tablas 00:16:52
Entonces vamos a hacerlo bien 00:16:55
Que la información de fuera 00:16:57
Sea solo, descripción y precio 00:16:59
Pues vamos a pedir la información de fuera 00:17:01
Venga 00:17:04
Descripción de lo que quieres 00:17:08
Descripción del pedido 00:17:10
Descripción 00:17:12
Next line 00:17:21
El precio 00:17:32
Vale, el precio 00:17:33
Pues bueno 00:17:51
Vale, ya tenemos 00:17:51
Dos datos para instanciar el pedido 00:18:04
Pero al pedido hay que ponerle 00:18:05
Un código 00:18:08
Pues vamos a generar el código internamente para que sea único 00:18:08
Bueno, pues esto se nos ocurriría hacerlo de mil maneras 00:18:13
Vamos a usar una variable que empieza siendo cero 00:18:30
Usamos esa variable como código y la dejamos incrementada, por ejemplo, y ya está 00:18:33
Y así la aplicación se asegura de que los códigos de los pedidos son únicos 00:18:37
Pues venga, vamos a usar una variable cualquiera 00:18:42
Por aquí 00:18:45
Inicialmente es 0 00:18:54
Y ahora 00:18:59
Ahora ya me voy a crear el pedido 00:19:01
Pues mi pedido va a ser 00:19:03
Pedido va a ser igual 00:19:05
A new 00:19:10
Pedido con los tres datos 00:19:11
Descripción 00:19:13
No sé en qué orden iban en el constructor 00:19:15
En el constructor iban en orden 00:19:17
Código, descripción y precio 00:19:20
Pues vamos a pasarlo en ese orden 00:19:22
Lógicamente 00:19:24
Código 00:19:25
Código, como lo he llamado, código pet directamente 00:19:27
Código 00:19:34
Descripción 00:19:36
Y precio 00:19:37
Tengo que importar pedido o usar 00:19:39
Su nombre completo, ejer22.model 00:19:44
Hombre, usar el nombre 00:19:47
Completo, un rollo 00:19:48
Casi mejor 00:19:49
Hago el import 00:19:52
Arriba, deger22modelpedido 00:19:54
Vale, tengo el pedido creado 00:19:57
Pero ojo, código de pedido 00:20:01
Se tiene que quedar incrementado 00:20:03
Para que el siguiente pedido que hagamos 00:20:05
Tenga código único 00:20:07
Bueno, pues incrementémoslo aquí mismo 00:20:08
Y ya está, y así no usamos una línea adicional 00:20:11
¿Vale? Código de pedido 00:20:13
Se queda incrementado 00:20:17
Para que el siguiente código 00:20:18
Sea distinto 00:20:20
Y ahora, ¿qué nos toca? 00:20:21
Pues nos toca 00:20:26
a qué cliente es el que tiene este pedido. 00:20:27
Porque habrá que meter este pedido 00:20:33
en el array de pedidos del cliente. 00:20:34
Luego, la siguiente información que necesitamos. 00:20:38
¿Qué cliente es? 00:20:40
¿Qué identificaría de forma única al cliente? 00:20:43
El NIF. 00:20:47
Entonces, eso es lo que tenemos que pedir. 00:20:48
¿Cuál es el NIF? 00:20:49
Si la aplicación... 00:20:51
No estamos verificando, 00:20:52
cada vez que se registra un cliente, 00:20:53
No estamos verificando que el NIF no esté repetido, 00:20:55
pues para no complicar la aplicación. 00:20:58
Pero, hombre, se debería verificar. 00:21:00
Cuando vendimos un NIF, 00:21:03
deberíamos hacer una búsqueda en el array 00:21:04
para ver si ya existe. 00:21:05
Y si ya existe, decir el NIF ya está registrado. 00:21:07
Por ahora, emitimos esa parte. 00:21:10
Asumimos que el NIF es único, 00:21:11
que debería ser único en el array de clientes. 00:21:13
Luego, es lo único que tenemos que pedir. 00:21:15
El NIF, para identificar al cliente. 00:21:18
NIF del cliente. 00:21:25
Pues venga. 00:21:27
NIF del cliente 00:21:28
Y ahora 00:21:33
Pues que tenemos que hacer 00:21:43
Recorrer el array de clientes 00:21:45
Cuando encontremos el cliente 00:21:48
Con este NIF 00:21:50
Agregarle a su array 00:21:51
Este pedido 00:21:54
En el caso 3, tenemos el pedido y el precio. 00:22:17
¿Qué caso 3? ¿En la T? 00:22:32
Sí, en el caso 3. 00:22:35
¿Mostrar clientes con más pedidos a dónde han llegado por el producto o por las descompras pedidas? 00:22:37
Gracias. 00:22:42
Seguimos 00:23:12
Si yo lo tengo aquí también 00:23:27
Y para algunas cosas de sprint 00:23:31
Pues a veces lo uso porque lo integra muy rápido 00:23:34
Pero 00:23:37
Venga, a ver, vamos a completarlo 00:23:37
Vale 00:23:44
¿Dónde estamos? 00:23:46
Lo de los escáneres, ahora revisamos 00:23:48
Porque efectivamente algún escáner 00:23:50
Ahí nos va a dar la murga 00:23:52
Ahora, vamos a recorrer 00:23:54
El array de clientes hasta encontrar 00:23:57
El bueno 00:23:58
Un for each, de nuevo no 00:23:59
Un for de índice porque tenemos que quedarnos 00:24:04
En el 00:24:06
Siguiente 00:24:07
Posición libre 00:24:09
¿Vale? Ahora ya 00:24:12
clientes 00:24:18
de i 00:24:22
punto get 00:24:24
nif 00:24:26
es igual, con un equals 00:24:28
no con doble igual 00:24:30
porque estamos hablando de string 00:24:32
es igual a mi nif de búsqueda 00:24:34
a mi nif de búsqueda 00:24:37
aquí es donde tengo que agregar 00:24:38
pedido 00:24:41
p a client 00:24:44
claro, aquí podría hacer 00:24:48
todo el código correspondiente 00:24:54
pero esto ya empezaría a hacerse un caso 3 00:24:55
un poco largo y feo 00:24:59
ya de hecho bastante largo es 00:25:01
hombre, ya que tengo la clase cliente 00:25:02
y agregar pedido a cliente 00:25:06
es algo que se hace en el cliente para el cliente 00:25:08
es algo que sufre la acción de agregar pedido 00:25:12
la recibe el cliente, como él es el que recibe la acción 00:25:15
que menos que hacerle un método en la clase cliente 00:25:18
que sea agregar pedido 00:25:21
entonces todas las funcionalidades 00:25:22
que modifiquen 00:25:25
actúen, tengan su efecto 00:25:27
sobre objetos de una clase 00:25:29
pues metámoslas en 00:25:31
métodos de esa clase 00:25:33
de su sitio, porque si nos ponemos a hacerlo 00:25:34
aquí todo, al final esta 00:25:37
pronunciación de cada objeto se ha quedado muy descafeinada 00:25:39
descafeinada, ¿vale? pues repito 00:25:41
agregar un pedido 00:25:43
P a un cliente 00:25:45
es algo que afecta al objeto cliente 00:25:47
es algo que le va a modificar 00:25:49
va a modificar su array de pedidos 00:25:50
pues hombre, hagamos un método en la clase cliente que lo haga 00:25:52
y desde aquí llamamos al método 00:25:56
es decir, si tuviéramos 00:25:58
un método maravilloso 00:26:02
que si lo llama un objeto cliente 00:26:05
pasándole yo mi pedido 00:26:07
se lo agregara, si yo tuviera este método estupendo 00:26:12
fijaos que fácil 00:26:16
ojalá yo tuviera un método al que puede llamar 00:26:18
un objeto cliente, en este caso 00:26:22
clientes de i, porque clientes 00:26:24
de i es un objeto cliente, 00:26:26
a este método le pasara 00:26:28
yo el pedido nuevo 00:26:30
y este método ya, cogiera el pedido, 00:26:31
lo metía en el array, 00:26:34
estaría estupendo, ¿verdad? 00:26:36
Ojalá lo tuviera. 00:26:38
Porque entonces ya mi código estaría terminado. 00:26:40
Pondría, 00:26:44
¿vale? 00:26:45
Vale, pues vamos a hacer este método. 00:26:48
Vamos a hacer este método que me sería tan útil. 00:26:50
¿Este método dónde va? A la clase cliente, porque lo va a llamar un objeto cliente, a la clase cliente, pues vámonos a hacer en la clase cliente un método public para poder ser llamado desde fuera, no hace falta que me devuelva nada, porque el efecto lo sufre ya el array de arriba, este array es el que sufre el efecto, 00:26:52
el método se llama agregar 00:27:14
pedido y que va a recibir 00:27:20
un objeto pedido 00:27:23
eso es lo que va a recibir 00:27:25
un objeto pedido 00:27:27
este p de aquí 00:27:28
pues entonces 00:27:29
aquí tendré que poner 00:27:31
esto 00:27:34
dime 00:27:35
en la opción 1 00:27:37
si pero por eso 00:27:39
he dicho que vamos a hacer una aplicación 00:27:43
la vamos a hacer entera a nuestra manera 00:27:44
saliéndonos del ejercicio, ¿vale? 00:27:46
Olvídate de denunciado. 00:27:49
Porque así le vamos a dar un poco más de sentido. 00:27:51
Vamos a ir metiendo cosas. Vamos a hacer una aplicación de clientes 00:27:52
pedido como más general con más cosas. 00:27:55
Y así la podemos usar 00:27:57
para aprender más cositas. 00:27:58
Vale, pues estupendo 00:28:03
que tengamos este método. Bueno, hay que 00:28:04
hacer el código. No se lo hemos hecho, claro. 00:28:06
Que yo le paso un objeto pedido 00:28:08
y me lo mete en el array de este objeto. 00:28:10
Estupendo. 00:28:14
Ese método 00:28:16
estará aquí colocado. 00:28:16
Estará ahí 00:28:18
¿Vale? 00:28:19
Ahí 00:28:23
¿Vale? Pues que tiene que hacer este 00:28:23
Este no es tan sencillo 00:28:25
Porque este array 00:28:27
¿Qué tendré que hacer? 00:28:30
Romperlo 00:28:34
Y hacer un auxiliar con una posición más 00:28:34
Meter el pedido 00:28:36
Y sustituir uno por otro 00:28:38
Lo que hicimos en el pasado 00:28:39
Cuando queríamos simular un array que se hiciera grande 00:28:40
Para coger un valor nuevo 00:28:43
Lo que hicimos en el pasado 00:28:45
Pues eso lo metemos aquí en este método 00:28:47
Que bien que va a ir aquí escondido 00:28:49
Y el main le va a dar igual 00:28:51
El main va a hacer agregar pedido 00:28:54
Y le va a dar igual 00:28:56
Que bien que va a ir escondido aquí 00:28:56
Pues venga 00:28:58
Vamos a hacer una array auxiliar 00:29:00
De pedidos 00:29:02
Una array auxiliar de pedidos 00:29:09
Esto ya lo hicimos cuando hicimos arrays 00:29:13
Que sea un nuevo array 00:29:14
De pedido 00:29:17
Con una posición más 00:29:18
Que el que tiene el actual 00:29:22
Pedidos.length 00:29:24
Más 1 00:29:26
Pedido 00:29:27
Esto, vale 00:29:32
En la radio auxiliar 00:29:35
Copiamos el viejo 00:29:36
Que es el de aquí arriba 00:29:38
En el nuevo 00:29:41
Y sustituimos 00:29:42
Pues venga, vamos a copiar 00:29:43
Pues copiamos 00:29:46
aux de i 00:30:00
Igual a 00:30:01
Pedidos de i 00:30:04
vale 00:30:06
y ahora 00:30:08
la posición extra 00:30:10
es la que se ha quedado libre 00:30:12
pues en la posición extra va P 00:30:14
pues la posición esta 00:30:16
es la última del aus 00:30:18
que es esta 00:30:20
esta es la posición extra 00:30:21
que es la última 00:30:25
pues en la posición extra va el P 00:30:26
el nuevo 00:30:30
y ahora ya sustituimos 00:30:30
la propiedad pedidos 00:30:36
la dejamos pisada 00:30:37
por la nueva 00:30:38
Por el nuevo array, por aux 00:30:41
Sí 00:30:42
Dime 00:30:43
Pedidos 00:31:08
¿Qué variable es? 00:31:10
Pedidos, la propiedad pedidos 00:31:12
Del objeto cliente en el que estamos 00:31:14
Sus pedidos actuales 00:31:16
Vale, no me hacéis ningún comentario 00:31:18
Sobre este código 00:31:21
Algo que os suena que pueda fallar 00:31:22
Cuando le metamos 00:31:24
El primero de todos 00:31:29
Porque cuando le metamos el primero 00:31:30
Pedidos es null 00:31:33
Entonces cuando le metamos el primero 00:31:35
En ese momento pedidos es null 00:31:38
Luego al hacer aquí pedidos.led null pointer exception 00:31:39
Vamos a arreglar esto de forma fácil 00:31:42
Si pedidos 00:31:44
Igual a null 00:31:47
Entonces 00:31:48
Si pedidos es igual a null 00:31:50
Habrá que hacer pedidos con una posición 00:31:53
Pedidos 00:31:55
Le creamos el espacio 00:31:58
new pedido 00:31:59
de una posición solo 00:32:01
el nuevo que vamos a meter 00:32:04
y pedidos de 0 00:32:05
igual a p 00:32:08
y si no 00:32:09
ya hacemos todo lo demás 00:32:12
un arreglito rápido para eso 00:32:14
si, si, si, ahora lo dejo 00:32:16
todo puesto 00:32:18
un momentito 00:32:20
¿por qué? 00:32:22
el auxiliar 00:32:29
como tiene uno de más, el pedido si 00:32:30
va a llegar en la última 00:32:32
y te va a dar error en internet 00:32:34
no, porque el for está solo en pedidos.led 00:32:36
no en aux.led 00:32:38
ah, cierto 00:32:39
porque ese array 00:32:41
tiene ya su tamaño fijo 00:32:51
ese array ya no te vale 00:32:52
tienes que hacer uno nuevo 00:32:53
ese no se le puede crear una posición adicional 00:32:56
ese es una caja de 7 00:32:59
y va a tener siempre 7 00:33:00
si tú quieres meter una octava botella 00:33:02
tienes que comprarte 00:33:04
una caja de 8 00:33:06
y tirar la de 7 00:33:07
porque en esa de 7 no puedes poner 00:33:09
una posición más, no se puede 00:33:11
el auxiliar tiene una posición más 00:33:13
que pedidos 00:33:19
a pedidos 00:33:20
recorro hasta donde tiene 00:33:23
aux tiene una más 00:33:24
en la extra pongo p 00:33:26
y ahora a pedidos lo pisoteo por el nuevo array 00:33:28
pero sigue teniendo la misma longitud 00:33:31
no, tiene una más 00:33:33
pedidos contundentes más 1 00:33:35
Ya, pero es que Pedidos ya se ha ido a la basura 00:33:37
Pedidos ya se ha quedado sin referencia 00:33:39
Ya se desaparecerá 00:33:41
Es decir, lo que hemos hecho es lo siguiente 00:33:42
Ah, vale, vale 00:33:45
Claro, lo que hemos hecho es 00:33:46
Por si alguien no lo entiende, esto es lo que vimos con Arrays 00:33:54
Yo tengo mi 00:33:56
Array, por ejemplo 00:33:58
Imaginaos de tres posiciones 00:34:02
Y quiero meter un cuarto 00:34:03
Este cuarto ahí, imposible 00:34:05
Pues entonces, este es Pedidos 00:34:07
me hago aux 00:34:10
que tiene 4 00:34:12
una más 00:34:14
vale, con este for de aquí 00:34:16
copio esto en esto, copio esto 00:34:18
en esto, copio esto en esto 00:34:20
¿qué hago con el nuevo? el nuevo aquí 00:34:21
vale, ahora este array 00:34:24
p, este es el array p 00:34:26
y este es el array aux, que apunta aquí 00:34:29
pues ahora ¿qué estoy haciendo con esta sentencia? 00:34:31
estoy haciendo que 00:34:34
pedidos p, deje 00:34:35
de apuntar al viejo 00:34:37
deje de apuntar al viejo y empiece a apuntar a este 00:34:39
es lo que estoy haciendo con esta sentencia 00:34:42
hacer que la referencia pedidos 00:34:44
deje de apuntar a este array que ya no lo quiero 00:34:47
y empiece a apuntar a este 00:34:49
luego ahora pedidos se ha convertido en una referencia al bueno 00:34:51
y ya está, y ya se queda 00:34:56
pedidos con el bueno 00:34:59
y este que le ha pasado 00:35:00
este no es que haya desaparecido, ese sigue ahí en memoria 00:35:02
pero se ha quedado sin nadie que lo apunte 00:35:06
ahí ya no hay nadie que le esté apuntando 00:35:08
porque el único que le apuntaba, que era este 00:35:10
ha pasado a apuntar a este otro 00:35:12
entonces si nadie le mira 00:35:14
desaparece 00:35:17
el recolector de basura, que es un proceso 00:35:18
que aparece cada cierto tiempo en background 00:35:20
va eliminando 00:35:22
todo lo que se ha quedado 00:35:24
sin nadie que le apunte 00:35:27
este, el único 00:35:28
que le apuntaba era este, que empezó 00:35:31
a apuntar a este otro 00:35:32
este se ha quedado ahí sin nadie que le apunta 00:35:33
pues entonces, ala 00:35:36
Ese, el recolector de basura 00:35:38
Lo tira a la basura 00:35:41
Para hacer dos milisegundos 00:35:42
Y ahora ya, ¿qué se me ha quedado? 00:35:43
Se me ha quedado este array ya bueno 00:35:46
Con pedidos apuntándole 00:35:47
Y aux también le está apuntando 00:35:49
Pero no pasa nada 00:35:52
Porque aux, como es una variable local 00:35:53
Va a desaparecer 00:35:55
¿Y dónde le hemos dado el tamaño? 00:35:56
Aquí 00:36:00
Ah, dices al original 00:36:01
Tendrá el que tenga 00:36:03
En el main 00:36:05
La primera vez que insertemos un pedido 00:36:06
la primera vez entrará por aquí porque es nul 00:36:09
pues aquí le daremos su primer tamaño que es 1 00:36:12
¿vale? 00:36:14
o sea, con el primer pedido que insertemos 00:36:16
con el primer pedido entraremos por aquí 00:36:18
por el nul, porque será nul 00:36:20
con el primero, y aquí le daremos 00:36:22
su primer tamaño que es 1 00:36:24
pero ya las siguientes veces 00:36:25
irá creciendo a 2, y luego a 3 00:36:28
y luego a 4 00:36:30
claro, habría 00:36:31
habido otra posibilidad, pero ya sería como 00:36:38
ocupar demasiada memoria, que es 00:36:40
crear para todos los clientes 00:36:42
una array de pedidos de 50 00:36:44
asumiendo que nunca va a tener 00:36:46
más de 50, pero habría sido 00:36:48
muy rollo, porque dentro de la clase cliente 00:36:50
habría que haber puesto una variable 00:36:53
adicional que dijera hasta cuántos 00:36:55
pedidos hay, entonces ya 00:36:57
vale, entonces 00:36:59
ahora ya este método 00:37:04
tiene toda esta complejidad 00:37:06
que es un rollo, pero el main le viene 00:37:08
fenomenal, el main llama a agregar 00:37:10
pedido y se acabó, dime 00:37:12
Y ahora podemos poner 00:37:14
Pues eso, este método tiene aquí 00:37:17
Es un rollo de método 00:37:21
Pero ahí se queda escondido 00:37:22
Ahora el main llama a agregar pedido 00:37:24
Y ya sabe, no sabe cómo lo hace 00:37:27
Y le da igual 00:37:29
Sabe que este pedido se mete a la raíz de clientes 00:37:31
Y ahora ya podemos completar aquí 00:37:34
Pedido agregado 00:37:37
Y listo 00:37:39
¿Vale? 00:37:55
Uy, me he puesto esto 00:37:56
Vale, pedido agregado y ya está 00:37:59
Vale, todo esto tiene miles de mejoras 00:38:03
Aunque nos vamos ya así 00:38:09
Pues que si encuentra el cliente 00:38:10
Yo querría 00:38:13
Dejar, abandonar el array 00:38:14
Y no seguirlo recorriendo 00:38:16
Pues un boolean que se ha encontrado 00:38:18
Y aquí añade el boolean 00:38:19
Luego un montón de arreglos, ¿vale? 00:38:20
Venga, paramos aquí 00:38:22
Vale 00:38:26
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:
4
Fecha:
15 de diciembre de 2025 - 17:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
389.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid