Saltar navegación

20251216 AppClientesPedidos_4_incluye_static - 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 16 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues aquí dejé planteado ayer que hicierais vosotros, por ejemplo, estas dos funcionalidades, la 5 y la 6, que son farragosas, no son especialmente cómodas tampoco. 00:00:01
¿Las habéis hecho? Uno las ha hecho, el empollón de la clase. Es una broma, hombre, que está muy bien. 00:00:16
Vale, has hecho las dos 00:00:27
Vale, fenomenal 00:00:29
¿Nadie más se ha puesto con ellas? 00:00:31
Ay, muy mal, muy mal 00:00:35
Uf, pero tú no eres el que los ibas a hacer en los 10 minutos 00:00:37
Que tenías de cambio de clase 00:00:43
Hombre, pero ¿quién nos saca 3 minutos para hacer esto? 00:00:44
Bueno 00:00:51
Pues vamos a hacer 00:00:54
Mostrar cliente con más pedidos 00:00:55
Recordad que en esta aplicación 00:00:59
Todos los clientes están aquí 00:01:01
En este array 00:01:04
Con lo cual como máximo 00:01:05
Podemos tener 100 00:01:08
Porque el array no tiene espacio para más de 100 00:01:09
Pero no habrá 100 00:01:11
En un momento dado 00:01:13
Habrá tantos como me diga este contador 00:01:15
Inicialmente 0 00:01:17
Pero recordad que cada vez que insertábamos un cliente 00:01:19
Pues el contador se incrementa, ¿vale? Entonces, con esto insertamos cliente, con esto mostramos todos los clientes, con esto agregábamos pedido a un cliente nuevo a través del método correspondiente, 00:01:22
Con este mostrábamos la factura de un cliente con un NIF 00:01:41
Llamando al método correspondiente 00:01:49
Todos estos eran métodos que hacíamos aquí 00:01:52
En la clase Cliente 00:01:55
Hacíamos el método AgregarPedido 00:01:57
Que cogía un pedido nuevo y lo agregaba al array 00:02:00
Hacíamos el método MostrarFactura 00:02:04
Con los datos del cliente que está arriba, etc. 00:02:08
Vale, pues a ver, ¿cómo nos plantearíamos la siguiente funcionalidad que nos queda aquí? Venga, caso 5. El cliente que más pedidos tiene. Sería casi más interesante, ¿tú has hecho el que más pedidos tiene o el que más dinero se ha gastado? El que más pedidos, ¿no? 00:02:11
vale, porque 00:02:36
sería interesante 00:02:39
una vez que hayamos hecho este 00:02:43
pues que hagáis 00:02:45
este otro también 00:02:46
5, 6, 7 00:02:48
el que más se ha gastado, porque uno a lo mejor 00:02:51
ha hecho 20 pedidos de un euro cada uno 00:02:55
y otro ha hecho un pedido de 00:02:57
200.000 euros, entonces casi 00:02:58
que nos gusta más el cliente 00:03:01
que más se ha gastado 00:03:03
pero vamos a hacer el que yo os pedí, el primero 00:03:04
venga, caso 5 00:03:12
vale, pues en el caso 5 se trata 00:03:13
de hacer el máximo 00:03:28
de algo, entonces ya 00:03:30
automáticamente nos ponemos en el chip del algoritmo 00:03:32
del máximo que ya lo tenemos en la cabeza 00:03:34
igual que tenemos el de contar, igual que tenemos 00:03:36
el de sumar o multiplicar 00:03:38
de forma acumulativa o concatenar de forma 00:03:40
acumulativa, pues ya tenemos muchos 00:03:42
algoritmos ya metidos en la cabeza 00:03:44
para resolver tareas concretas 00:03:45
que se hacen todo el rato en programación 00:03:48
como contar, sumar, ver si 00:03:50
algo pasa o no pasa 00:03:52
con el boolean y el contraejemplo 00:03:53
o máximo y mínimo, son las cuatro ideas 00:03:55
básicas, sobre las cuales se monta un poco 00:03:57
todo. Vale, pues el máximo 00:03:59
ya sabemos cómo funciona, el máximo siempre 00:04:01
se hace sobre un conjunto de cosas 00:04:03
entonces cuando hay que hacer el máximo de algo 00:04:05
lo primero que pensamos es 00:04:07
¿el máximo de qué conjunto de cosas? 00:04:09
Pues el cliente que más 00:04:12
pedidos tiene, pues sobre el conjunto 00:04:13
de clientes. ¿Tengo yo alguna 00:04:15
estructura que tenga mis clientes? Sí 00:04:17
¡Qué suerte! Tengo directamente 00:04:19
una estructura con mis clientes que es el array 00:04:21
luego el algoritmo de máximo 00:04:23
lo único 00:04:25
que tiene que hacer es 00:04:27
recorrer este array 00:04:29
para sobre él 00:04:31
ir encontrando que cliente 00:04:32
supera al anterior 00:04:36
en el 00:04:37
criterio por el que 00:04:38
estamos maximizando que en este caso 00:04:41
es el número de pedidos 00:04:43
el algoritmo de máximo siempre es el mismo 00:04:45
yo tengo un conjunto de cosas de la que quiero 00:04:47
encontrar el que más algo 00:04:49
o el que menos algo 00:04:51
pues 00:04:52
asumo, cojo uno de ellos 00:04:54
y asumo que ese 00:04:57
es el que más algo 00:04:59
y ahora empiezo a recorrer los demás 00:05:01
uno por uno 00:05:03
con cada uno de ellos, si ese ha superado 00:05:04
al que hasta ese momento era el que más 00:05:08
pues tengo nuevo 00:05:10
máximo, y ese es el algoritmo que hemos usado siempre 00:05:11
pues vamos a 00:05:14
aplicarlo aquí 00:05:15
entonces aquí tenemos 00:05:17
Tenemos una opción 00:05:19
Que es programarlo aquí todo entero directamente 00:05:23
Entonces el algoritmo de máximo parte 00:05:26
Venga, máximo inicial 00:05:29
El máximo inicial es el primero de los clientes 00:05:32
Clientes de cero 00:05:38
Este es el máximo inicialmente 00:05:40
Ahora voy a recorrer los demás 00:05:44
A ver si alguno supera ese máximo 00:05:46
y actualizo 00:05:50
el que es el máximo 00:05:50
en el criterio que sea, que en este caso es en el 00:05:56
número de pedidos que tiene 00:05:57
Max es un objeto cliente 00:05:59
claro 00:06:05
es un cliente máximo, es un objeto cliente 00:06:07
vale, pues desde 00:06:10
empezando por el segundo 00:06:11
cliente ya 00:06:13
mientras si sea menor que 00:06:14
este de aquí, lógicamente, que son todos 00:06:16
los clientes que tenemos 00:06:21
Recordad que esta variable 00:06:22
Es la que me está contabilizando 00:06:24
En toda la aplicación 00:06:26
Los clientes que tengo 00:06:28
Esta variable es la que me lo está contabilizando 00:06:29
¿Vale? No puedo poner clientes.length 00:06:32
Porque si pongo 00:06:35
Clientes.length 00:06:36
Me iría a 100 00:06:38
Y hay un montón que son null 00:06:40
Entonces 00:06:42
Como todos los recorridos 00:06:44
Al igual que hicimos ayer 00:06:45
Esos recorridos llegarán 00:06:47
Hasta el último 00:06:49
cliente libre, ¿vale? Pues, ¿qué tenemos que hacer dentro del algoritmo de máximo? Pues, ver si cliente de i supera al que es máximo 00:06:53
hasta ese momento, ¿vale? Si queréis, a lo mejor es más fácil de entender si a esta variable la llamamos cliente max, por ejemplo, ¿vale? 00:07:07
Pues si cliente sí supera a cliente max, actualizamos cliente sí. 00:07:20
Esta es la idea general del algoritmo, la idea general. 00:07:28
Ahora hay que aplicarla para nuestro caso concreto, 00:07:31
porque para cada caso, superar el actual al máximo, 00:07:34
en cada caso implicará una cosa. 00:07:39
Que el tamaño de su nombre sea mayor, que no sé qué, 00:07:42
en cada caso implicará una cosa u otra. 00:07:45
¿Aquí qué implica superar este objeto cliente a este otro? 00:07:47
Pues que la longitud de su array de pedidos sea mayor 00:07:51
Eso implica superar 00:07:56
Porque el criterio de ser mayor que, menor que 00:07:58
Es en la longitud del array de pedidos 00:08:02
¿Vale? Pues vamos a hacer eso 00:08:05
Si clientes de i 00:08:07
Cogemos sus pedidos 00:08:12
Clientes de i 00:08:15
Cogemos sus pedidos 00:08:16
Este es el array de pedidos 00:08:22
Pues su longitud, que la puedo sacar con length, resulta que es mayor que el número de pedidos del que es máximo hasta ese momento, que es este, get, ay, es que lo he llamado así, clientemax.getpedidos.length, 00:08:25
Pues si es mayor 00:08:55
Tengo un nuevo máximo 00:08:57
Que es clientes de i 00:08:59
Sí, lo que pasa es que entonces 00:09:00
Solamente te quedarías 00:09:12
Si actualizas esa variable 00:09:14
Con el número de pedidos máximo 00:09:15
Pero la información de que cliente lo ha tenido 00:09:17
Tendrías que llevarla en paralelo 00:09:20
En una variable en paralelo 00:09:21
Si llevamos el objeto entero 00:09:23
Mejor, ahora lo vamos a hacer abajo 00:09:25
¿Vale? 00:09:28
Entonces 00:09:29
si el cliente 00:09:30
actual y supera 00:09:34
al máximo en ese momento 00:09:36
el número de pedidos 00:09:38
pues actualizo 00:09:40
y ya está, ya he acabado el algoritmo 00:09:41
cuando este for ha terminado 00:09:50
que ha terminado aquí 00:09:54
tengo la seguridad 00:09:56
de que en cliente max 00:09:58
va a estar el cliente dentro 00:10:00
del array 00:10:02
cuyo tamaño del array de pedidos sea el más grande 00:10:03
es el algoritmo de máximo de toda la vida 00:10:06
lo que decía ella 00:10:08
por ejemplo, vamos a quedarnos en lugar de 00:10:13
maximizar 00:10:16
voy a suponer que comentamos esto un momentín 00:10:17
vamos a poner 00:10:22
una variable máximo, que el máximo inicial 00:10:24
sea 0 00:10:30
y ahora voy cliente por cliente 00:10:32
el que supere a la variable máximo 00:10:35
Actualiza el máximo 00:10:39
Vale, pues entonces 00:10:41
Esto de igual a 0 00:10:42
Mientras i sea menor que 00:10:46
Siguiente 00:10:48
Posición libre 00:10:51
Incrementando i 00:10:52
Cada vez 00:10:55
Pues sí 00:10:55
Este cliente es de i 00:10:57
Su array pedidos 00:11:01
Pues el tamaño de su array pedidos 00:11:05
Uy, perdón 00:11:08
El tamaño de su array pedidos 00:11:09
Resulta que es mayor 00:11:16
que es mayor 00:11:18
que el máximo hasta ese momento 00:11:21
tengo nueva 00:11:22
variable máxima 00:11:25
que sería esta 00:11:27
tengo nueva variable máxima 00:11:28
que sería esta, vale, pero con esto 00:11:33
cuando el bucle termina 00:11:36
lo único que tenemos es 00:11:38
el número de pedidos máximo 00:11:40
que se ha hecho, pero no sabemos que cliente 00:11:42
lo ha hecho 00:11:44
y si tuvieras max igual a i 00:11:44
podrías tener la posición 00:11:46
Claro. Bueno, max igual a i, no, otra variable que guardará la posición, porque esta ya tiene un uso, que es el número máximo de pedidos. No puedes sustituirla por la posición en la que está. Esta ya tiene un uso que no puedes tocar. 00:11:48
Entonces, como cuando acabe este form no queremos solo el número máximo de pedidos que se ha pedido, sino también qué cliente lo ha hecho, pues tenemos que llevar en paralelo esa información. 00:12:02
La podemos llevar por la posición, por ejemplo, también o llevar una instancia y pues tú puedes hacer cliente c igual a null, vacío, para que se actualice con el primero que supere a cero. 00:12:11
con el primero que supere a cero 00:12:38
inicialmente cliente está sin inicializar 00:12:40
como es un objeto 00:12:43
hay que inicializarlo 00:12:44
a null, vale 00:12:46
vale, lo que pasa es que luego 00:12:48
se va a quedar pisado por otra cosa, pero te es 00:12:56
más cómodo ponerlo a null directamente 00:12:58
que inicializarlo a un valor ficticio 00:13:00
que luego se va a ver pisado 00:13:02
vale, entonces aquí pues tendríamos que 00:13:03
hacer c igual a 00:13:06
clientes de i 00:13:07
o hacer lo que dices tú, me llevo 00:13:09
una variable con la posición 00:13:12
inicialmente cualquiera, me da igual 00:13:13
cero o la que sea 00:13:16
y aquí actualizo 00:13:18
la posición ahí 00:13:20
¿vale? me llevo una variable 00:13:21
posición con cualquier 00:13:24
valor y 00:13:26
si el cliente supera 00:13:30
pues la posición donde está 00:13:32
igual ahí 00:13:34
¿vale? me da igual llevar en paralelo esta variable 00:13:34
que llevar esta ¿vale? 00:13:38
y aquí ya tendría toda la información, pero 00:13:40
nos ahorramos 00:13:42
variables 00:13:45
si lo hacemos como arriba 00:13:45
si lo hacemos como arriba, arrastramos ya el cliente entero 00:13:48
entonces voy a dejar 00:13:51
esto es lo que voy a dejar comentado 00:13:53
y voy a dejar 00:13:54
el de arriba 00:13:57
¿vale? entonces 00:13:57
hombre, el de arriba mejor, yo estoy 00:14:04
maximizando, siempre que podamos hacerlo así 00:14:06
yo estoy maximizando 00:14:08
un conjunto de clientes 00:14:10
un conjunto de pedidos, un conjunto de ordenadores 00:14:12
un conjunto de lo que sea, de objetos 00:14:15
pues trabajo con el objeto directamente 00:14:16
este es el objeto máximo 00:14:18
hasta ese momento, el cero 00:14:20
voy por los demás, si supera el máximo 00:14:22
tengo nuevo máximo y ya está 00:14:25
¿vale? 00:14:26
si cliente es de i 00:14:29
su número de pedidos es mayor 00:14:30
que el que tenía más hasta ese momento 00:14:32
iniciándolo con el primero 00:14:35
tengo nuevo cliente máximo y ya está 00:14:37
cuando el bucle ha terminado 00:14:39
ya tenemos en el objeto 00:14:41
cliente máximo todos los datos 00:14:42
del cliente 00:14:44
y ahora podríamos 00:14:46
poner el cliente 00:14:51
con 00:14:55
más pedidos 00:14:57
y lo podemos concatenar sin miedo 00:15:00
con cliente max 00:15:02
porque la clase cliente 00:15:04
tiene un toString 00:15:07
tiene un toString 00:15:08
entonces al tener un toString 00:15:11
el método system.out 00:15:17
a la hora de concatenar 00:15:19
no le queda más remedio que convertirlo a stream 00:15:21
el método system.out tiene que 00:15:23
convertirlo a stream para concatenar 00:15:25
¿cómo convierte a stream? 00:15:27
llamando al toStream, que no tenemos 00:15:29
toStream hecho, hace una patata 00:15:31
como tenemos hecho un 00:15:34
toStream, pues mostrará aquí lo que 00:15:35
hayamos hecho nosotros, vale 00:15:37
¿tienes el poder de verificar 00:15:51
el poder de luz? 00:15:57
ah, tienes toda la razón 00:16:00
claro, porque 00:16:01
si no verificamos, porque el cliente puede no 00:16:02
tener pedido, entonces si no los tiene 00:16:05
en ese caso no quiero considerarlo 00:16:06
quiero que la condición sea falsa, efectivamente 00:16:08
puede haber clientes sin pedidos 00:16:11
entonces me saldría un pedazo null pointer 00:16:13
exception, de hecho 00:16:15
si uno no se da cuenta 00:16:16
según lo ve, se va a dar cuenta en cuanto 00:16:18
haga un par de pruebas, en cuanto le salga un null 00:16:21
pointer exception va a decir, ah claro 00:16:23
yo estoy recorriendo todos los 00:16:25
clientes, puede que haya clientes 00:16:27
que no tengan pedidos, cuidado 00:16:29
porque en esta condición entonces tengo que 00:16:31
añadir, si clientes 00:16:33
.get 00:16:35
clientes de i 00:16:36
si clientes de i 00:16:40
.get 00:16:42
pedidos 00:16:45
es diferente de null 00:16:46
y si además de ser 00:16:48
diferente de null 00:16:53
y si además de ser diferente de null 00:16:54
clientes de i 00:16:57
.get pedidos 00:16:59
.len supera 00:17:00
entonces esta condición if tiene que ser más compleja 00:17:02
tiene que tener, si es diferente de null 00:17:05
y además de ser diferente de null 00:17:06
supera su tamaño, la del máximo 00:17:09
hasta ese momento 00:17:11
vale, efectivamente, si no ponemos esto 00:17:12
pues nos va a salir un null pointer exception 00:17:15
seguro, en algún momento 00:17:17
este es otro ejemplo 00:17:19
de la diferencia grande entre 00:17:24
poner un solo ampersand o dos 00:17:26
vale 00:17:28
si ponemos dos ampersand 00:17:30
acordaos, de que en cuanto 00:17:33
esta sea falsa 00:17:36
la de abajo ya ni la mira 00:17:37
entonces, si entramos a un cliente 00:17:39
con pedidos null 00:17:42
esta ya ni la mira, el and es falso y se acabó 00:17:43
pero si ponemos solo una ampersand 00:17:46
cuando lleguemos 00:17:49
a un cliente con pedidos null 00:17:51
esta va a dar false, pero aún así 00:17:52
va a entrar aquí, con lo cual nos va a seguir 00:17:55
saltando el null pointer exception 00:17:57
entonces hay un montón de casos 00:17:58
en que lógicamente, aunque la tabla 00:18:00
de verdad sea la misma 00:18:02
el false, false, true, true, sea la misma 00:18:04
con un ampersand que dos 00:18:06
la diferencia entre que se ejecute lo segundo 00:18:07
no es enorme 00:18:10
¿Vale? Aquí con un solo ampersand 00:18:11
Nos va a salir un null pointer de excepción 00:18:14
Todo el rato 00:18:16
Y solamente podemos arreglarlo 00:18:16
Con el doble ampersand 00:18:19
¿Vale? Pues este máximo 00:18:20
Estaría entendido 00:18:29
Entonces, si hiciéramos el otro 00:18:30
Maximizar ahora 00:18:32
Pero por el que más se ha gastado 00:18:34
Pues sería prácticamente lo mismo 00:18:36
Pero cambiando solo la condición de máximo 00:18:38
Este sería 00:18:41
A ver si, porque 00:18:45
No sé si tengo cerrado 00:18:47
sí, este es el del case 00:18:49
caso 00:18:51
6, ¿verdad? 00:18:56
caso 6, este era 00:19:01
maximizar 00:19:03
pero ahora 00:19:04
por el cliente que más 00:19:06
se ha gastado 00:19:09
luego el criterio no es 00:19:10
el tamaño del array 00:19:12
sino la suma de todos los elementos 00:19:14
vale, pues 00:19:17
gran parte 00:19:19
del código lo vamos a reutilizar 00:19:21
pues nos hacemos un copia y pega 00:19:22
Aquí tengo un 00:19:24
Un error en el punto y coma 00:19:29
Porque algo no he debido cerrar 00:19:34
O yo que sé qué 00:19:36
Sí, me falta 00:19:37
Alguna llave en algún sitio 00:19:39
A ver 00:19:42
Este cierra ahí 00:19:47
Y este, ¿qué le pasa? 00:19:49
No sé qué le pasa a este 00:20:07
Este es este 00:20:08
Hay alguna llave que tengo 00:20:15
¿Cómo es hacer el máximo? 00:20:19
vamos a copiar y pegar este código 00:20:23
el único que cambiamos 00:20:25
es el criterio por el que 00:20:26
supera un cliente al máximo 00:20:29
pues todo esto 00:20:31
lo podemos 00:20:33
copiar y pegar 00:20:35
porque arrancamos 00:20:36
igual, el cliente 00:20:44
que más se ha gastado 00:20:46
clientes de 0, recorremos 00:20:47
los demás, si clientes 00:20:50
de i supera cliente máximo 00:20:53
vale, aquí lo que 00:20:54
pasa es que esta 00:20:56
condición es la que cambia 00:20:58
¿vale? lo único que cambia 00:21:00
del código de arriba es que esta 00:21:02
condición de aquí que tengo marcada es la que cambia 00:21:04
antes, el cliente 00:21:07
actual cliente sí, superaba 00:21:08
al máximo si el tamaño de su 00:21:10
array era mayor que el tamaño del array 00:21:12
de este, pero ahora no 00:21:14
ahora este cliente va a superar al máximo 00:21:16
si la suma de precios 00:21:18
de todos los pedidos que tiene 00:21:20
es mayor que la suma de precios 00:21:22
de todos los pedidos que tiene este otro 00:21:24
con lo cual, aquí ya se complica 00:21:26
porque esa suma 00:21:28
no la podemos hacer aquí en la condición a la vez 00:21:30
tendríamos que hacerla 00:21:33
antes 00:21:35
pero claro, este case empieza ya a hacerse 00:21:35
muy grato, ahora en cuando pensamos 00:21:39
oye, que bien me vendría 00:21:41
que bien me vendría 00:21:43
tener un método 00:21:45
que si lo llamo un cliente 00:21:47
me devolviera por ejemplo 00:21:48
gasto total 00:21:50
porque si yo tuviera un método 00:21:53
que me devolviera gasto total 00:21:56
lo llamo 00:21:58
y ya tengo esto hecho 00:21:59
repito, si yo tengo 00:22:03
un método en la clase cliente 00:22:09
que para el objeto que lo llame 00:22:11
me devuelve lo que se ha gastado 00:22:13
en pedidos, maravilloso 00:22:15
mi máximo ya estaría 00:22:17
máximo inicial el primero 00:22:18
recorro los demás 00:22:21
si él tiene pedidos 00:22:22
nul y el gasto total 00:22:25
de ese cliente es mayor que el gasto 00:22:26
total del cliente máximo, hasta ese momento 00:22:29
tengo un nuevo cliente máximo, y ya está 00:22:31
y aquí ya diría 00:22:33
el cliente que más ha gastado 00:22:34
quien sea 00:22:39
vale, pero claro, me vendría muy bien 00:22:40
ese método 00:22:47
si no, tengo que hacer la suma acumulativa 00:22:48
aquí en este mismo código 00:22:52
antes de la comparación 00:22:53
la suma acumulativa para clientes de ahí 00:22:54
la suma acumulativa para cliente max 00:22:57
un rollo 00:22:59
entonces, si tengo este método, fenomenal 00:23:00
vale, pues entonces 00:23:03
mi código parte de que ese método 00:23:07
existe, yo ya al que esté haciendo cliente 00:23:09
le digo, incorpora este método 00:23:11
y ese es un problema del que hace la clase 00:23:12
cliente, el que hace la clase 00:23:15
cliente, ahora incorporará 00:23:17
un método que para un cliente 00:23:19
en particular, te devuelve 00:23:21
la suma de todo 00:23:23
lo que se ha gastado, vale 00:23:25
pues hemos derivado 00:23:31
el problema desde el main, lo hemos derivado 00:23:33
la clase cliente. ¿Puedo abrir 00:23:35
la clase cliente? Pues venga, 00:23:46
vamos a hacer el método en la clase cliente. 00:23:51
¡Hala! Otro método 00:23:57
más. Pues un método 00:23:58
public, porque lo estoy usando desde otro 00:24:00
paquete. ¿Qué me va 00:24:02
a devolver? Una suma de precios. 00:24:04
Luego este método me devuelve double. 00:24:06
¿Cómo hemos dicho que 00:24:09
se tiene que llamar? Gasto total. 00:24:10
¿Recibe algún 00:24:14
parámetro? No. Este método solamente 00:24:14
trabaja con la lista de pedidos. 00:24:16
No recibe nada. Pues ¡hala! 00:24:18
ahora ya a este método le toca 00:24:20
trabajar con este 00:24:24
array de pedidos de aquí arriba 00:24:26
para 00:24:27
hacer una suma acumulativa 00:24:29
la suma acumulativa 00:24:32
sabemos hacerlo, estamos usando todo el 00:24:34
rato los patrones básicos 00:24:36
algorítmicos que conocemos 00:24:37
entonces bueno, antes que nada 00:24:40
si pedidos fuera null 00:24:42
ni entro en el array 00:24:43
porque es que me va a salir un pedazo null point 00:24:45
de excepción, entonces si los 00:24:47
pedidos del usuario es null, pues se ha 00:24:49
gastado cero, return cero 00:24:51
¿vale? 00:24:53
entonces cuando el método alcanza 00:24:59
return, ahí ya ha terminado 00:25:01
¿vale? o sea el return 00:25:02
no solo manda el 00:25:05
valor hacia afuera, sino que también 00:25:07
para el método 00:25:09
aquí el método termina 00:25:10
claro, claro 00:25:14
lo de abajo sería 00:25:21
si no se ha dado 00:25:23
la condición de lift 00:25:25
vale, entonces el return implica 00:25:26
devuelve valor 00:25:29
y además método se acabó, sales de ahí 00:25:30
y te vas al programa principal 00:25:33
vale, pero que ocurre si pedidos es diferente 00:25:34
de null, si pedidos es diferente 00:25:37
de null, como no alcanzamos el return 00:25:39
el método sigue hacia abajo 00:25:41
porque no ha entrado en el return, el método sigue 00:25:43
vale, pues en este caso ahora ya si que 00:25:45
queremos hacer la suma 00:25:47
y ahora la suma, pues esto ya es 00:25:48
muy fácil para nosotros 00:25:54
esto si que lo podemos hacer con un 00:25:55
for each, porque el array de pedidos 00:25:58
tiene tantos 00:26:00
el tamaño es exactamente 00:26:01
el de los pedidos, porque el agregar pedido 00:26:03
lo hemos hecho agrandando el array, etc 00:26:05
y ahora aquí ya suma 00:26:07
más igual 00:26:11
p.getPrecio 00:26:13
ala 00:26:15
ya tengo la suma acumulativa 00:26:17
una vez que la tengo, para afuera 00:26:19
y se acabó este método 00:26:21
vale, si pedidos es null 00:26:25
cero, te has gastado cero y se acabó 00:26:38
que no es null, no entra aquí 00:26:41
luego sigue, suma acumulativa 00:26:45
recorre los pedidos 00:26:47
del usuario y va 00:26:48
sumando el precio 00:26:51
de ese pedido 00:26:52
a la variable suma acumulativa, cuando el for 00:26:53
ha terminado, devolvemos 00:26:57
la suma hacia afuera 00:26:58
vale, pues ese método ya lo ha hecho alguien en cliente 00:26:59
y yo lo uso desde mi mail 00:27:09
ya me despreocupo de 00:27:11
dime 00:27:12
claro 00:27:14
lo que pasa es que en este caso 00:27:19
porque tal y como hemos hecho agregar pedido 00:27:22
lo hemos hecho de tal manera que el array 00:27:24
pedidos de arriba 00:27:26
tiene siempre exactamente 00:27:27
tantas posiciones como pedidos 00:27:30
porque agregar pedido lo hemos hecho que 00:27:31
va agrandando una posición 00:27:33
entonces en este caso el for 00:27:35
queremos que lo recorra entero de principio a fin 00:27:38
con lo cual puedo usar el for each 00:27:39
solo porque es más rápido de escribir 00:27:42
no porque aporte ninguna otra ventaja 00:27:44
porque es más rápido de escribir 00:27:45
porque el único problema 00:27:47
que tiene el for es que va de principio 00:27:50
a fin obligatoriamente, no es como el de índice 00:27:52
que yo lo paro cuando quiera, pues como en este 00:27:54
caso quiero ir de principio a fin, porque 00:27:56
es más fácil y cómodo de escribir, pues lo 00:27:57
he hecho así, pero claro, lo puedes hacer con un for 00:27:59
con i, por índice igual a cero 00:28:01
¿vale? como si lo haces con 00:28:03
un for normal, es exactamente igual, unido 00:28:11
y cambias esto, igual a cero 00:28:13
mientras i sea menor que 00:28:15
pedidos.length 00:28:17
incrementando i 00:28:19
Claro, pedidos 00:28:21
Cuando se llegue a este método 00:28:26
Pedidos ya existirá 00:28:28
Porque ya hay un objeto creado 00:28:29
¿Vale? 00:28:30
Suma más igual 00:28:34
Pedidos de i 00:28:35
Punto 00:28:38
El de arriba y el de abajo 00:28:39
Pues hacen lo mismo 00:28:42
El for de arriba y el for de abajo 00:28:43
Hacen exactamente igual 00:28:46
Este lo hace con una variable 00:28:47
Temporal que se queda con la 00:28:50
copia 00:28:52
pero el resultado es el mismo 00:28:53
vale 00:28:56
vale 00:28:57
pues entonces gracias a que está este método 00:29:02
ahora ya el main 00:29:04
tira de él 00:29:06
para el máximo 00:29:07
vale pues vamos a aprovechar 00:29:09
método este que calcula 00:29:37
el gasto total 00:29:39
este método que tenemos aquí 00:29:40
por ejemplo este 00:29:43
para incorporar otro concepto 00:29:45
que es el concepto 00:29:48
de variables 00:29:50
y métodos estáticos 00:29:51
¿vale? es sencillo 00:29:57
no hay que estresarse 00:30:00
¿cuál? el main 00:30:00
el main es el mismo 00:30:07
de arriba 00:30:10
pero lo único que hace es 00:30:11
comparar si el gasto total del cliente 00:30:13
en posición i es mayor 00:30:16
que el gasto total del máximo 00:30:17
hasta ese momento 00:30:20
ahora el criterio para hacer el máximo 00:30:20
es el gasto del cliente 00:30:26
no el tamaño de su array 00:30:28
vale, o sea son 00:30:30
el caso 5 y 6 son iguales 00:30:33
solo cambia esta condición 00:30:36
tamaño del array o gasto total 00:30:37
vale, pues vamos a 00:30:40
aprovechar 00:30:45
este método por ejemplo de aquí 00:30:46
gasto total para 00:30:48
incorporar otro concepto 00:30:50
como hemos dicho, el de las 00:30:53
variables y los métodos estáticos 00:30:54
que silencio 00:30:56
Que creo que esta última semana de Navidad 00:31:06
Normalmente solo estamos aquí en el instituto 00:31:10
Los de informática 00:31:12
Que sois los únicos pringados 00:31:13
Que trabajáis a todas horas 00:31:18
Hasta el último minuto 00:31:20
Cosa que está fenomenal 00:31:22
Que la vida os devolverá 00:31:25
Y yo que quería 00:31:26
Yo quería esto 00:31:31
Vale 00:31:32
Vale, pues a ver 00:31:44
Sabemos ya como funciona este tema 00:31:49
De los objetos 00:31:51
tenemos 00:31:52
yo aquí tengo 00:31:54
por ejemplo mi clase cliente 00:32:00
mi clase cliente que dice 00:32:03
que tiene nif y nombre 00:32:05
por ejemplo, nif nombre 00:32:07
o lo que sea 00:32:09
voy a ponerle dos propiedades solo 00:32:09
mi clase cliente que tiene nif y 00:32:12
nombre, entonces yo a partir de aquí 00:32:15
puedo ya instanciar 00:32:16
¿vale? 00:32:19
puedo ya instanciar 00:32:20
todos los objetos que quiera 00:32:23
¿vale? 00:32:30
ya sabemos cómo funciona esto 00:32:32
C1, C2, C3 00:32:33
y ya sabemos que cada objeto 00:32:35
tiene su propio NIF 00:32:38
su propio nombre 00:32:40
su propio NIF, su propio nombre 00:32:41
su propio NIF, su propio nombre 00:32:42
¿vale? porque NIF y nombre son propiedades 00:32:44
de la clase 00:32:46
lo cual significa que cada objeto 00:32:47
que se instancie de esta clase 00:32:51
que puede ser uno, pueden ser 00:32:53
200.000 millones, cada uno 00:32:54
de ellos tiene un valor concreto 00:32:56
para sus propiedades, porque es un ejemplo 00:32:58
concreto. Cada objeto 00:33:00
es un ejemplo concreto de cliente, 00:33:02
siendo esta, pues, la plantilla. 00:33:05
¿Vale? 00:33:07
Vale, entonces, esto representa 00:33:09
bastante la realidad. En la realidad, 00:33:10
pues, tenemos objetos 00:33:12
concretos de las ideas 00:33:14
platónicas, ¿verdad? 00:33:17
Si habéis estudiado filosofía de Kuhn, pues, tenemos 00:33:18
instancias concretas. Vale, 00:33:20
pero hay cosas 00:33:22
de la realidad 00:33:24
que nos gustaría también recoger 00:33:26
y representar aquí de alguna manera 00:33:28
en nuestro modelo de datos, en nuestra aplicación. 00:33:30
Y es la idea 00:33:33
de que puede haber información 00:33:34
que es común 00:33:36
para todos los objetos de una clase. 00:33:38
La misma, compartida. 00:33:41
Y que si cambia para uno, 00:33:43
cambia para otro, porque todos la comparten. 00:33:45
Entonces, esa idea 00:33:48
también se da en la realidad, ¿no? 00:33:48
Por ejemplo, vosotros sois todos 00:33:51
ejemplos concretos de la clase 00:33:53
alumno, os podéis 00:33:55
caracterizar por vuestro NIF 00:33:57
por vuestro nombre, pero 00:33:58
también os podéis caracterizar por el aula 00:34:01
por la que dais clase, porque ese dato 00:34:02
por lo que sea le interesa a la aplicación, el aula 00:34:04
donde dais clase, pero ¿qué ocurre? 00:34:06
que como sois todos alumnos de Damu 00:34:09
no vais todos juntitos, pues 00:34:10
la clase es la misma para todos, entonces 00:34:13
yo puedo tener mil instancias 00:34:15
de cada uno de vosotros, cada uno con el 00:34:17
carterito aquí de 00:34:19
Pepito, NIF1, en 00:34:20
aula de alguno, pero el apartado 00:34:23
aula es que es el mismo para todos 00:34:24
porque vais todos a la misma 00:34:26
clase, entonces 00:34:29
si uno de vosotros cambia su nombre 00:34:30
lo cambia solo en su tarjetita 00:34:32
estupendo, pero si de repente cambia 00:34:34
el aula, hay que ir a la tarjetita 00:34:36
de todos y de cada uno de ellos 00:34:38
es un rollo, que la información que compartís 00:34:40
todos, esté duplicada 00:34:43
es un rollo, entonces 00:34:44
podríamos decir, saquemos 00:34:46
la de propiedades de la clase 00:34:48
que esa esté en otro sitio 00:34:50
¿pero qué otro sitio? es que no hay otro sitio 00:34:52
en Java todo está en clases 00:34:54
todo tiene que estar ubicado en una clase 00:34:57
¿en qué otro sitio? el concepto de 00:34:58
variable global suelta con un dato global 00:35:00
ese afortunadamente no existe 00:35:03
en Java, porque las variables globales son 00:35:04
unos generadores enormes 00:35:06
de errores y efectos secundarios extraños 00:35:08
entonces en algún sitio tiene que estar 00:35:11
ese dato 00:35:13
vale, pues para eso se han 00:35:13
inventado las variables 00:35:16
o propiedades static 00:35:18
¿vale? entonces, imaginaos 00:35:21
que yo ahora, al dato 00:35:24
aula a la que voy 00:35:26
aula a la que voy 00:35:27
¿como el aula? bueno, en este caso 00:35:29
he puesto un cliente 00:35:31
pero bueno, podría ser un alumno 00:35:34
así seguimos el ejemplo 00:35:35
¿vale? 00:35:38
entonces 00:35:40
si esto es un alumno 00:35:40
vale 00:35:43
pues entonces 00:35:47
Aula a la que va el alumno 00:35:48
El aula tiene que estar recogida en algún sitio 00:35:52
Como está relacionada 00:35:54
Con el concepto de alumno 00:35:56
Está relacionada 00:35:58
Su sitio debería ser la clase alumno 00:35:58
Porque en alguna clase tiene que estar 00:36:01
Es el aula de los alumnos 00:36:03
Pues tendré que ponerla en la clase alumno 00:36:05
No la voy a poner en una clase por ahí 00:36:07
Que no pinta nada 00:36:09
Pues tendré que ponerla aquí, aula 00:36:10
Vale, desde el momento en que yo pongo aquí la propiedad 00:36:12
Ya sabemos que automáticamente 00:36:15
eso implica lo que no queremos, que les aparece a todos 00:36:17
las instancias, les aparece a todos 00:36:21
la casillita para el aula, pero menudo 00:36:24
rollo porque en todas es el mismo 00:36:29
entonces si cambia uno de aula, cambian todos, tengo que ir uno por uno 00:36:31
menudo rollo, entonces, ¿qué ocurre si yo 00:36:37
dándome cuenta de que eso es así y de que esa es la situación que quiero representar 00:36:41
información común para todos, si cambian uno 00:36:45
cambian todos 00:36:47
¿qué pasa si yo pongo 00:36:48
delante de esa propiedad 00:36:53
el modificador static? 00:36:55
otro modificador 00:36:58
más que puedo poner 00:36:59
además del private, entonces ya tendría 00:37:00
pues el private, static, ya tendría 00:37:03
dos uno detrás del otro, que no pasa nada 00:37:05
se pueden poner muchos modificadores 00:37:06
¿qué pasa si yo pongo el static? 00:37:09
delante de una propiedad 00:37:13
pues si pongo el static delante de la propiedad 00:37:14
automáticamente todas estas réplicas 00:37:17
se funden 00:37:20
en una 00:37:21
y ahora ya 00:37:22
tendríamos cada 00:37:25
objeto tiene su conjunto 00:37:27
de propiedades propias 00:37:30
las suyas y luego hay ahí 00:37:31
en memoria una caja 00:37:33
compartida por todos que es 00:37:34
única para todos 00:37:37
¿cómo accedemos a esa caja? 00:37:38
pues perfectamente accedemos 00:37:43
como accedemos a cualquier propiedad 00:37:45
de una clase a través de un objeto 00:37:47
es decir, si yo hago 00:37:49
c1.aula 00:37:51
accedo a este 00:37:52
hueco 00:37:55
pero claro, si hago c2.aula 00:37:55
también, porque es una caja compartida 00:37:59
y si hago c3.aula 00:38:01
también 00:38:03
me da igual cuantos objetos 00:38:04
tenga, si hago 00:38:07
c27.aula accedo aquí 00:38:08
entonces si yo hago c1.aula 00:38:11
igual a 7 00:38:13
pues aquí se pone el 7 00:38:14
y si ahora accedo a c3.aula 00:38:16
pues veré que está el 7 00:38:19
porque es lo mismo 00:38:20
c1.aula es lo mismo que c3.aula 00:38:22
igual que c21.aula 00:38:24
todos me llevan 00:38:26
a la misma cajita 00:38:27
tanto es así 00:38:30
que por comodidad 00:38:34
aunque podemos acceder a las variables 00:38:36
static así 00:38:39
con el nombre de un objeto cualquiera 00:38:40
pues como realmente da igual 00:38:42
el objeto con el que accedas 00:38:44
da exactamente igual, porque accedas 00:38:46
por C1, C2, C3, vas a ir 00:38:48
a la misma caja 00:38:50
a las variables static se les permite 00:38:51
acceder y se suele hacer y es recomendable 00:38:54
con el nombre de la clase 00:38:56
sin más, entonces si yo 00:38:58
pongo alumno 00:39:00
nombre de la clase, que es el nombre 00:39:02
de la clase, no de ningún objeto 00:39:04
el de la clase, este 00:39:06
alumno.aula 00:39:07
con esto estoy accediendo 00:39:10
a este espacio compartido, ¿vale? 00:39:15
No necesito usar ningún objeto. 00:39:18
Con el nombre de la clase punto aula 00:39:22
accedo al objeto compartido, ¿vale? 00:39:24
De hecho, es que ni es necesario 00:39:27
que existan objetos para que exista 00:39:34
este objeto compartido, es que ni hace falta, ¿vale? 00:39:37
Decimos esto y paramos. 00:39:43
Es decir, si una clase tiene una, dos o tres 00:39:45
las que sean variables estáticas 00:39:48
en este caso tiene una 00:39:50
eso es lo que se llama 00:39:52
el contexto estático de la clase 00:39:54
que es la cantidad de variables estáticas que tiene 00:39:56
esta tendría solo una 00:39:58
su contexto estático sería uno 00:40:00
eso 00:40:02
no existe, ese espacio en memoria 00:40:03
no existe, igual que no existe este 00:40:06
ni existe este hasta que no aparece un objeto 00:40:08
vale, pues ¿cuándo es la primera vez 00:40:10
que aparece ese espacio en memoria? 00:40:12
la primera vez que lo llamamos 00:40:14
y hacemos referencia a él 00:40:16
es decir, si yo hago alumno.aula 00:40:17
igual a 7 00:40:20
sin haber creado 00:40:22
ningún objeto antes, sin haber creado ninguno 00:40:24
sin haber hecho ni un new alumno 00:40:26
ni alumno, ni alumno 00:40:28
la primera vez que yo desde mi main 00:40:29
hago referencia a esta variable estática 00:40:31
con el nombre de la clase, la primera vez 00:40:34
paz, ahí aparece 00:40:36
memoria, luego 00:40:38
las variables estáticas pueden estar 00:40:40
ahí en memoria 00:40:42
antes de que aparezcan los objetos 00:40:43
No hay necesidad de que aparezcan los objetos. Aparecen la primera vez que hacemos referencia a ellos. Luego es una forma que tenemos de guardar información al margen de la existencia de objetos, al margen de la existencia. 00:40:46
lo que pasa es que esa información tiene que estar asociada a una clase 00:41:06
porque tiene que estar declarada dentro de una clase 00:41:10
entonces la solemos meter en la clase cuyo significado tiene relación 00:41:12
claro, no hacemos un diseño metiendo ahí una variable 00:41:16
porque quiero que no pega nada con alumno 00:41:19
hay que meter variables aquí 00:41:21
aunque para existir no necesitan que existan los objetos 00:41:25
pues que su significado tenga que ver 00:41:30
que la foto que yo tengo ahí con mis clases 00:41:32
pues que represente un poco que tenga sentido 00:41:34
¿vale? bueno, ¿entendido? 00:41:36
¿eso solo funcionaría para 00:41:43
si tienes solo el aula de dao? 00:41:45
es que claro 00:41:53
si esa información 00:41:54
no es común para todos los objetos 00:41:56
entonces no puede ser una variable estática 00:41:57
entonces si puede haber alumnos en dao 1 00:42:00
y alumnos en dao 1 00:42:01
ya no puedes poner una variable estática 00:42:03
esto es solo cuando tú has concluido 00:42:05
después de analizar tu problema 00:42:08
que ese dato es común 00:42:09
para todos los objetos 00:42:12
que se creen, da igual cuántos se creen 00:42:14
común para todos ellos 00:42:16
hombre, pues para un montón 00:42:17
de cosas, para, se usa muchísimo 00:42:20
más que las variables 00:42:22
ahora, sus 00:42:23
consecuencias naturales, que son los métodos 00:42:25
estáticos 00:42:28
pues para guardar valores constantes 00:42:28
por ejemplo, pues 00:42:32
si se hace una aplicación, pues pi 00:42:33
se está guardado con una variable estática 00:42:35
es una información común, que está en la clase 00:42:37
más, ahí está 00:42:40
¿vale? entonces por ejemplo 00:42:42
aquí 00:42:44
claro, claro 00:42:46
claro, porque las variables estáticas 00:43:00
el constructor 00:43:02
usaría las variables propias 00:43:04
las variables estáticas tienen 00:43:06
otro significado 00:43:07
otro significado que no es caracterizar al objeto 00:43:09
sino caracterizar el 00:43:12
contexto en el que se mueven 00:43:14
no a él propiamente dicho 00:43:15
entonces cuando tú invocas a un constructor 00:43:17
estás construyendo un objeto concreto 00:43:19
y ahí tiene sentido 00:43:22
que le des lo que le 00:43:23
caracteriza a él de forma única 00:43:24
lo que va en las variables estáticas 00:43:27
es como información de contexto 00:43:29
que tú inicializas por libre y con el nombre de la clase 00:43:31
y ya está 00:43:34
harías el constructor con if y nombre 00:43:35
y las variables estáticas no tienen get y set 00:43:39
por ejemplo, se ponen como public 00:43:41
normalmente 00:43:43
y tú accedes con el nombre de la clase sin más 00:43:44
por ejemplo, y ya paramos 00:43:47
Hemos usado a veces la clase math 00:43:49
Que math es una clase, un objeto 00:43:52
Así alegremente 00:43:53
¿Por qué? Porque la clase math 00:43:55
Fijaos todas las cosas 00:43:57
Que nos... 00:44:00
Vale, pues hemos usado a veces 00:44:10
Para hacer cosas 00:44:12
La clase math, ¿no? 00:44:13
Que lo he escrito aquí para... 00:44:14
Bueno, no sé dónde lo he escrito, pero da igual 00:44:19
Vale, a veces hemos usado 00:44:20
La clase math para hacer cosas 00:44:26
Math es una clase, no es un objeto 00:44:29
Y pese a ser una clase 00:44:31
si le damos al punto 00:44:33
me ofrece cosas 00:44:35
por ejemplo como pi 00:44:36
¿por qué? 00:44:38
porque pi es una propiedad 00:44:40
estática de la clase 00:44:43
math, con lo cual no necesito 00:44:45
un objeto de la clase math 00:44:47
para usarlo 00:44:49
no necesito instanciar un new math 00:44:49
no hace falta, con la clase 00:44:52
como pi es estática 00:44:55
entonces 00:44:56
¿veis? esta es mi clase math 00:44:57
mi clase math 00:45:00
esta de aquí, ¿vale? 00:45:02
que está aquí, con todos sus 00:45:05
esta clase 00:45:08
la clase math 00:45:09
es una clase que no se puede instanciar 00:45:14
no tiene constructor 00:45:17
nada, no se puede instanciar, por eso tiene el private 00:45:18
delante, ¿por qué? porque esta clase 00:45:21
solamente vale para dar 00:45:23
contenido estático, para cosas útiles 00:45:24
por ejemplo, e 00:45:27
¿veis? es una variable static 00:45:28
y double también 00:45:31
public para poder 00:45:32
accederla desde cualquier sitio 00:45:34
este es un método 00:45:36
pues pi es una variable estática 00:45:45
de la clase math 00:45:48
entonces yo puedo usar esa variable 00:45:48
sin que exista ningún objeto de la clase math 00:45:51
que ya le da este valor 00:45:54
entonces las variables 00:45:57
estáticas tienen 00:46:00
muchos usos a la hora de describir 00:46:02
una situación pero también 00:46:03
es para guardar 00:46:06
dentro de una clase recoger información 00:46:08
constantes 00:46:10
que van a usar otras clases 00:46:12
pues lo recojo, lo dejo ahí recogidito 00:46:13
por ejemplo, esto es un ejemplo 00:46:15
¿vale? un ejemplo 00:46:17
el final ya veremos lo que significa 00:46:19
pero estos dos modificadores 00:46:21
pues los entendemos 00:46:23
¿vale? entonces yo aquí 00:46:24
puedo usar mathP 00:46:26
pues para lo que quiera, para multiplicarlo 00:46:28
por algo, para lo que quiera 00:46:31
¿vale? 00:46:33
Bueno, venga, ahora sí que vamos a parar aquí 00:46:35
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
16 de diciembre de 2025 - 14:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 42″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
775.47 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid