Saltar navegación

20260223 ExAbril24 - 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 3 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues aquí primero la clase apunte económico abstracta con tres propiedades, dos métodos, uno de los cuales no hace falta que sea abstracto y otro sí. 00:00:01
Bueno, pues aquí seguimos las pautas y os habrá quedado pues algo como esto, la clase abstracta con sus tres propiedades, un constructor, las clases abstractas pueden tener constructores aunque no se instancien nunca, claro. 00:00:12
Los get y los set 00:00:27
Que heredarán las subclases 00:00:30
Y ejercicio actual 00:00:32
Pues bueno, hay que coger 00:00:36
Del código 00:00:38
Los cuatro primeros dígitos 00:00:39
Que son el año 00:00:42
Y ya está, entonces como el código es un entero 00:00:42
Lo primero habrá que pasarlo a string 00:00:46
Para poder coger los cuatro primeros dígitos 00:00:48
¿Vale? 00:00:51
Bueno, pues esta es la forma más cómoda 00:00:52
De pasar a string 00:00:54
Ahora, ¿cómo cogemos los cuatro primeros dígitos? 00:00:55
Pues hombre, si desplegáis en los métodos de string 00:01:00
Rápidamente encontráis su string 00:01:02
O si no lo podéis hacer a mano 00:01:04
Concatenando charad0, macharad1, macharad2 00:01:06
¿Vale? 00:01:09
Siempre podríais hacer esto a mano 00:01:10
Así un poco a lo más cutre, ¿no? 00:01:12
Es decir, primero nos cogemos 00:01:14
El año, que es el código en string 00:01:17
Que sería 00:01:21
Esto, por ejemplo 00:01:22
Y ahora, pues siempre 00:01:27
Podríais hacer 00:01:31
Y así 00:01:32
Concatenado uno 00:01:45
Tras otro 00:01:47
Lo cual sería un rollo 00:01:48
Un poco feo y muy poco 00:01:51
Profesional, pero bueno 00:01:53
Así os estaríais quedando 00:01:55
Entendéis lo que estoy haciendo 00:01:59
Os estaríais quedando con los cuatro 00:02:00
Primeros caracteres 00:02:03
Y luego ya tendríais que pasarlo a string 00:02:04
O sea, esto sería una cosa muy fea 00:02:07
Pero bueno, puestos a hacer cosas feas 00:02:09
Pues ya 00:02:11
Charac3 00:02:12
Charac3 00:02:20
Esto sería los cuatro primeros dígitos 00:02:23
En string 00:02:29
Y ahora tendríamos que convertirlos a entero, claro 00:02:30
Para convertir a entero 00:02:32
Ya sabemos que tenemos el parseInt 00:02:36
Entonces, hombre 00:02:38
En caso de 00:02:41
Necesidad, que no se nos ocurra 00:02:42
cotillear los métodos de string 00:02:44
que no, pues bueno, siempre podemos hacer esto 00:02:46
¿no? 00:02:48
siempre podríamos hacer esto de aquí arriba 00:02:50
pero bueno, un poco feo es 00:02:51
un poco feo es, lo dejamos aquí comentado 00:02:53
siempre sería mejor 00:02:56
me quedo con los cuatro primeros 00:02:58
dígitos del substring, pues si uno 00:03:00
mira la ayuda, empieza 00:03:02
en la posición que tú le digas 00:03:04
y coge tantos caracteres 00:03:06
a partir de ahí como tú le digas después 00:03:08
empieza en la cero y coge cuatro 00:03:10
vale, y ahora 00:03:12
esa subcadena 00:03:14
que son los cuatro primeros dígitos 00:03:16
pues la tenemos que cambiar a entero, claro 00:03:18
pero para eso ya conocemos este método 00:03:20
vale, pues get ejercicio 00:03:22
actual, este puede 00:03:25
estar en la clase abstracta porque en todos 00:03:27
los apuntes económicos funciona igual 00:03:28
pues así lo dejamos 00:03:30
vale, y ahora 00:03:32
el método de escribir es el que se queda como 00:03:34
abstracto porque cada apunte económico 00:03:36
tiene su propia descripción 00:03:39
se supone 00:03:40
bueno 00:03:41
entonces el hashCode 00:03:43
e equals lo he puesto 00:03:45
luego a posteriori 00:03:47
cuando ya he hecho gestión económica 00:03:50
al ver que es un hashSet 00:03:51
pero bueno, ahora mismo como que lo ignoramos 00:03:53
vale, pues tenemos aquí las propiedades 00:03:55
constructor, getSet 00:03:58
y los dos métodos, uno de los cuales es 00:04:00
abstracto 00:04:02
está por definir, lo cual 00:04:04
hace la clase abstracta, vale 00:04:06
subclases, la factura 00:04:07
la factura que añade 00:04:10
dos propiedades 00:04:12
¿qué son esas dos? 00:04:14
¿vale? pues entonces 00:04:16
aquí es que esto 00:04:18
es así, vale 00:04:21
bueno, pues un constructor 00:04:23
un constructor normalmente basado 00:04:26
en el superconstructor 00:04:28
en el constructor de la superclase 00:04:30
como siempre, pues este 00:04:32
constructor recibe los cinco parámetros 00:04:34
de la factura, los cinco parámetros 00:04:36
y con esos cinco 00:04:38
Actualiza las propiedades 00:04:39
¿Vale? Aquí 00:04:41
Pues podríamos poner protected 00:04:42
A lo mejor para 00:04:45
Facilitar el acceso 00:04:48
A estos campos 00:04:51
En la subclase 00:04:52
¿Vale? Así en cualquier subclase 00:04:54
Pues podemos acceder 00:05:01
Pues venga 00:05:03
Vale 00:05:04
Y ahora al heredar tiene que implementar 00:05:07
Describir, pues ya está 00:05:10
Lo que fuera, da igual 00:05:12
Lo que fuera 00:05:13
Venga, gestión empresarial 00:05:15
Pues lo mismo 00:05:17
Hereda 00:05:18
Dos propiedades, ponía string 00:05:20
Pero bueno, pues como es una fecha 00:05:23
Podríamos poner local date 00:05:25
Constructor 00:05:27
Basado en el super constructor, como siempre 00:05:29
Get y set 00:05:31
Y el sobrescrito 00:05:33
Este obligatorio 00:05:35
De hacerlo, claro 00:05:37
Pues lo que fuera, lo que pidiera el examen 00:05:38
Que sería mostrar un mensajito con toda la descripción 00:05:41
El emisor, el no sé qué, lo que fuera 00:05:43
Mostrar los datos, vamos, en definitiva 00:05:46
Como si fuera un toString 00:05:48
El describir sería como si fuera un toString 00:05:49
Vale, y ahora ya 00:05:52
Esta clase tiene el main 00:05:53
Tiene los datos, lo tiene todo 00:05:56
Pues venga 00:05:58
Los datos de la aplicación 00:06:00
Son todo el conjunto de apuntes económicos 00:06:02
Pues son estos 00:06:05
Los ponemos aquí, fuera del main 00:06:06
Para que puedan acceder a los datos 00:06:08
Todos los métodos del main 00:06:12
porque me han dicho aquí que el main 00:06:13
que es este, gestión económica 00:06:16
implementa el main y tiene los métodos 00:06:18
que hacen cosas 00:06:19
pues entonces para facilitar 00:06:20
que los métodos puedan acceder 00:06:23
a todas esas cosas que se hace 00:06:25
pues ese conjunto 00:06:27
fuera del main 00:06:29
vale, pues aquí está 00:06:30
este es mi set de apuntes 00:06:33
entonces ahora ya sí 00:06:37
cuando 00:06:39
veo que los apuntes económicos 00:06:40
van a estar metidos en un hash set 00:06:43
para que ciertos métodos del hashSet 00:06:45
como contains, equals, todo eso 00:06:49
funcionen correctamente 00:06:51
el remove para que funcionen correctamente 00:06:52
pues necesitamos que haya 00:06:55
un hashCode equals o lo que es lo mismo 00:06:57
que haya un criterio de igualdad 00:06:59
para el hashSet dentro 00:07:01
de la clase a la que pertenece 00:07:03
entonces aquí la confusión 00:07:04
es que tengo tres clases 00:07:07
¿dónde pongo el hashCode equals? 00:07:09
claro, entonces 00:07:13
si la igualdad de todos es por código, el código está en la superclase 00:07:14
entonces no hay problema, yo lo pongo en la superclase por código 00:07:19
y ya vale los de abajo, si la igualdad 00:07:23
de las clases de abajo fuera por otros parámetros suyos propios 00:07:26
pues luego tendría que sobreescribir abajo el jasco de equals, pero aquí no hace falta 00:07:30
entonces en apunto económico, pues aquí es donde pondríamos jasco de equals 00:07:34
por código 00:07:39
entonces mirad que aquí el equals 00:07:41
aquí, esto es un caso 00:07:45
un poco raro, lo que pasa es que claro, este ejercicio 00:07:49
no estaba pensado para hacerse con un hash set 00:07:51
sino con un hash map que como funciona 00:07:53
de forma distinta, al transformarlo 00:07:55
a un hash set, se queda una situación 00:07:57
un poco rara, vale 00:07:59
porque si yo digo 00:08:01
la igualdad es por códigos, vale 00:08:03
entonces tengo una factura 00:08:05
y una gestión empresarial 00:08:06
con el mismo código 00:08:09
son la misma 00:08:11
en realidad no deberían ser la misma 00:08:12
porque una es un gasto empresarial 00:08:15
y otra es una factura 00:08:18
entonces 00:08:19
eso 00:08:21
se contempla aquí 00:08:23
recordad que el equals que te da 00:08:25
el equals que te da 00:08:28
el eclipse 00:08:29
te dice ya directamente 00:08:31
si la clase a la que pertenece este objeto 00:08:32
no es la clase a la que pertenece 00:08:35
el que tú le pasas 00:08:37
Doy por sentado que son distintos 00:08:38
Doy por sentado que son distintos 00:08:41
Aunque tuvieran el mismo código 00:08:43
Entonces habría que ver 00:08:45
En esta situación queremos que sea así 00:08:48
Tengo una factura con código 3 00:08:49
Y un gasto empresarial con código 3 00:08:52
Asumo que son la misma 00:08:54
Pues hombre, no deberían ser la misma 00:08:56
Vale, lo que quiero decir es que 00:08:58
Al haber cambiado este ejercicio 00:09:00
De Hashmat a Hashet 00:09:02
Se queda una cosa un poco rara 00:09:03
Pero bueno 00:09:05
Pues ya está 00:09:06
Tenemos hascode equal 00:09:09
Se hereda tal cual en las otras dos 00:09:10
Igualdad por código y ya está 00:09:13
Y ya está 00:09:14
Y con eso acabamos 00:09:16
La primera clase 00:09:18
Perdón 00:09:20
El tema de los datos 00:09:24
Aquí 00:09:26
Estábamos aquí 00:09:27
Un set, un haset de estos 00:09:29
Vale, ahora 00:09:31
¿Qué métodos tiene mi aplicación? 00:09:33
Métodos que yo he puesto aquí 00:09:35
que luego ya la idea es llamarlos 00:09:36
desde el main para probar 00:09:38
crear apunte 00:09:40
pues nada, crear apunte 00:09:42
aquí es un rollo 00:09:44
porque hay que decir, ¿qué quiere? factura y gestión 00:09:46
económico, en función de eso un switch case 00:09:48
o un if else 00:09:50
y en función del que quiera pedir ya los datos 00:09:52
y ya está 00:09:54
y instancia el objeto 00:09:56
y una vez instancia el objeto añadirlo 00:09:58
con un add, o sea este no 00:10:00
tiene ninguna dificultad salvo el 00:10:02
rollo de pedir todos los datos 00:10:04
Salvo el rollo de pedirlos y además distinguir, preguntarle primero, ¿es factura, gestión empresarial? En función de eso te pido unos datos u otros. Pero la única cosa que tenía es que la aplicación se tiene que asegurar de que el código es único, ¿vale? 00:10:06
Y entonces, para que el código sea único, ¿cuál es la mejor estrategia? El código normalmente, los códigos, las claves primarias de los datos, y esto en bases de datos funciona igual, las claves primarias no suelen ser datos que se le pidan al usuario, porque trasladar al usuario la responsabilidad de la unicidad es un poco, 00:10:24
y si tengo mil datos y me dices 00:10:50
dame la clave, jolín, hasta que 00:10:52
acierte con uno que no exista 00:10:54
entonces no se debería trasladar 00:10:55
al que mete los datos 00:10:57
del nuevo objeto 00:11:00
la responsabilidad de dar un código único 00:11:01
porque podría haber otros 30.000 00:11:04
por eso la mayoría de las 00:11:05
tablas 00:11:07
en bases de datos pues tienen una clave 00:11:09
primaria que es autoincrement 00:11:11
¿no? porque 00:11:13
así se genera ya solita 00:11:15
y tenemos la seguridad, la garantía de que 00:11:17
hay una clave primaria que es imprescindible 00:11:20
en un diseño relacional 00:11:22
aquí no hay un autoincrement 00:11:23
no hay algo que Java 00:11:26
te diga, vale, usa un tipo 00:11:27
de dato autoincrement y yo me aseguro 00:11:30
de que se se incrementa, no, pero lo podemos 00:11:32
simular nosotros 00:11:33
vale, pues yo aquí es lo que haría 00:11:34
entonces, cada vez 00:11:37
que creemos un nuevo apunte 00:11:40
yo no le pido ese dato al usuario 00:11:41
no se lo pido 00:11:44
sino le asigno 00:11:45
uno a partir 00:11:48
De un valor que tenga esta variable 00:11:49
Inicialmente cero 00:11:52
Que podría ser el primer código 00:11:53
Cuando se lo asigne al primer apunte 00:11:55
Me aseguro de dejarlo incrementado 00:11:57
Me aseguro de dejarlo incrementado 00:12:00
¿Vale? 00:12:02
Pero 00:12:04
¿Este es el código 00:12:05
Primero es la fecha y después ya? 00:12:07
Claro, pero sí, pero luego lo concatenarías 00:12:09
Claro, lo concatenarías al año 00:12:12
¿Vale? 00:12:14
Entonces 00:12:17
pero esto es para generar ese serial 00:12:17
de alguna manera 00:12:20
entonces la forma más cómoda es simular 00:12:21
el autoincrement de una base 00:12:24
de datos 00:12:26
entonces el crear apunte 00:12:26
pues es pedir los datos 00:12:30
el año 00:12:31
el año y 00:12:33
luego generar esto 00:12:36
que generarlo es coger 00:12:37
el valor que tenga esta variable estática 00:12:41
ahí global, estática 00:12:44
y dejarla incrementada 00:12:48
¿vale? dejarla incrementada 00:12:49
y ya está 00:12:51
el año 00:12:52
o bien se podría pedir 00:12:56
o bien incluso se podría sacar 00:12:57
pero bueno, eso es una cosa que no os pedí 00:12:59
en el examen no se pedía 00:13:01
lógicamente por el manejo del local date 00:13:04
y de todo eso 00:13:06
pues se podría sacar el año actual de la clase local date 00:13:06
que tiene un montón de métodos para hacer cosas 00:13:10
entre ellas el año en el que estás 00:13:11
pues podrías tú sacar de la clase local date 00:13:13
el año 00:13:15
el año en el que estás actualmente 00:13:16
y concatenarlo a este código 00:13:19
y ya está, o si no se le pregunta 00:13:21
al usuario y se acabó 00:13:23
¿vale? pero sobre todo lo que me importa es 00:13:24
la idea 00:13:27
de que los códigos únicos 00:13:29
no son responsabilidad 00:13:31
normalmente del que introduce los datos 00:13:32
sino de la propia aplicación 00:13:35
¿vale? y esta es la forma 00:13:36
más sencilla de asegurarse un código 00:13:39
único, ¿entendido? 00:13:41
¿no? vale 00:13:43
Buscar apunte 00:13:46
Pues esto es lo más sencillo 00:13:48
Y teras 00:13:52
Y como tenemos la suerte 00:13:54
De que el código 00:13:56
Pertenece a la superclase 00:13:58
Pertenece a la superclase 00:14:01
Pues no necesito 00:14:03
Distinguir si es una factura 00:14:05
Si es una factura 00:14:07
No necesito 00:14:08
Este es el polimorfismo puro 00:14:09
Todos los apuntes económicos 00:14:11
Sean gestiones, sean facturas 00:14:14
Sean gastos empresariales 00:14:15
Sean facturas, tienen getcode 00:14:17
Lo llamo, si es igual al código que me han dado 00:14:19
Ya tengo el objeto 00:14:21
Si he salido de aquí 00:14:22
Si he salido de este for 00:14:25
Lo he completado, es porque nunca salí por aquí 00:14:26
¿Verdad? Nunca salí por aquí 00:14:29
Eso significa 00:14:31
Que no aparece 00:14:33
Ese código, pues entonces devuelvo null 00:14:36
Devuelvo null y se acabó 00:14:38
Vale, aquí lo único 00:14:40
Que, pero ya digo 00:14:44
es que este ejercicio no estaba pensado para hacer con 00:14:46
haset, si 00:14:48
queréis usar el contains 00:14:49
para ver si 00:14:51
existe alguno con 00:14:53
este, si existe alguno, pues aquí 00:14:56
no es tan sencillo, porque 00:14:58
aquí uno haría, si apuntes 00:15:00
punto contains 00:15:02
y aquí 00:15:04
como usábamos esto, pues como 00:15:06
la igualdad es por código 00:15:08
aquí poníamos un objeto 00:15:09
con ese código 00:15:12
y el resto de propiedades nos daban igual 00:15:14
porque el contains va a mirar la igualdad 00:15:16
basada en el código solo 00:15:19
pero yo aquí no puedo instanciar un apunte económico 00:15:21
no puedo instanciarlo 00:15:24
entonces el contains aquí no sería tan fácil 00:15:26
tendría que poner 00:15:30
si contiene una new factura con este código 00:15:32
o si contiene 00:15:37
es decir, no sería tan fácil 00:15:40
factura, por ejemplo, con el código code 00:15:42
y el resto de propiedades de factura que son double int, no, double string, int y string. 00:15:48
Pues por ejemplo, 0, 0, 0, 0 o new gasto empresarial con lo que tenga gasto empresarial 00:16:00
Que la que nos importa es 00:16:32
El código y luego tiene 00:16:34
Double string 00:16:36
Y todo, puedo ponerlo ahí 00:16:37
Vale, entendéis lo que digo 00:16:40
Que aquí el contains 00:16:48
Se complica 00:16:50
Porque la aplicación 00:16:51
Perdón 00:16:54
El set de apuntes tiene dos tipos de objetos 00:16:55
Puede tener facturas 00:16:58
Puede tener gastos empresariales 00:17:00
Ahí perfectamente entremezclados 00:17:02
Porque como todos son apuntes económicos 00:17:04
Y el set es de apunte económico 00:17:05
Puede tener de todo 00:17:07
Entonces cuando yo quiero ver si apuntes contiene algo 00:17:08
Siempre hacemos 00:17:12
Si contiene un objeto como este 00:17:13
Y ahí ya nos hacíamos new la clase que fuera 00:17:15
Con los datos que fueran 00:17:18
Pero aquí 00:17:20
No puedo hacer un si contiene un new 00:17:21
Apunto económico con ese código 00:17:23
No puedo porque no puedo instanciar apunto económico 00:17:25
Porque es una clase abstracta 00:17:27
Pero podríamos hacer esto 00:17:29
Si contiene una factura con este código 00:17:30
Porque el resto de propiedades me dan igual 00:17:33
Porque no se miran en el equals 00:17:35
o contiene 00:17:36
un gasto empresarial con ese código 00:17:39
pues entonces podría 00:17:41
concluir que sí 00:17:43
que 00:17:44
contiene un apunte económico con ese código 00:17:45
¿vale? 00:17:49
si quisiéramos usar el contains 00:17:50
me refiero, para lo que fuera 00:17:52
entonces 00:17:54
por ejemplo 00:17:56
para dejarlo aquí puesto 00:17:59
voy a hacer al contrario, si no contiene 00:18:01
que devuelva null 00:18:05
y entonces 00:18:07
sería el negado del or sería si no contiene una factura con ese código y tampoco contiene una con 00:18:09
ese reto nulo y ahora ya si no me pasó aquí por ejemplo vale pero bueno que esto es un poco lío 00:18:19
por tener dos sub clases dentro de la super clase lo dejo aquí comentado vale siguiente método 00:18:36
importe total de las facturas, esto como lo haríais, como lo habéis hecho, importe total de las facturas hay que recorrer la colección de apuntes y solo, solamente sumar a la suma las que sean facturas, entonces esto pues habréis hecho algo así, 00:18:49
Aquí con una variable suma inicialmente igual a 0 00:19:14
Y ahora aquí solamente si A resulta que es una factura 00:19:30
Solamente en el caso de que A sea una factura 00:19:39
Pues entonces en ese caso habrá que sumar su importe 00:19:43
¿Vale? Y entonces 00:19:49
Porque factura es una propiedad 00:19:52
Solo, perdón 00:19:55
Ah, importe es de 00:19:56
Apunte, con lo cual no hace falta 00:20:01
Ni hacer el casting ni nada 00:20:03
Porque ya tiene GetImporte 00:20:04
¿Vale? 00:20:07
Si importe solo fuera de factura 00:20:11
Solo, pues habría que hacer aquí 00:20:13
Un casting, claro, pero no es el caso 00:20:15
Y ahora 00:20:17
RetunSuma y ya está 00:20:19
Algo así 00:20:21
¿Vale? 00:20:22
Vale, pues entonces os pongo yo ahora 00:20:24
Por ejemplo este método 00:20:26
Porque quedaría algo aquí más 00:20:27
Importar facturas 00:20:30
¿Ya está? 00:20:33
¿Qué? 00:20:38
Bueno, luego ya tiene el main 00:20:42
El main que es para probarlo 00:20:43
¿Vale? 00:20:45
Que es llamar a estos y ya está 00:20:46
El main, vale 00:20:47
Pero lo que me interesa ahora 00:20:48
Pues imaginaos 00:20:51
Imaginad que ahora añadimos 00:20:52
un método que fuera este listado de todos los gastos empresariales por orden 00:20:53
devuelve un listado de gastos empresariales por orden de importe, por orden descendente, 00:21:03
es decir, el más caro primero 00:21:21
descendente 00:21:23
de importe 00:21:26
vale, pues venga, si hubiera que hacer 00:21:27
este método, ¿qué es lo que haríais? 00:21:32
primero 00:21:37
pensamos, hay que ordenar 00:21:38
hay que ordenar 00:21:39
pues como no sabemos 00:21:40
ordenar nosotros, porque no hemos implementado 00:21:44
la ordenación nosotros 00:21:46
ya sabemos que tenemos un sort, que es como ordenamos 00:21:47
con un sort, vale 00:21:50
pero lo primero que pensamos es 00:21:51
vale, el método sort 00:21:53
me funcionan las listas 00:21:55
y en los Arrays, claro 00:21:57
me funcionan las listas 00:21:58
entonces yo necesito una lista 00:22:00
de gastos empresariales 00:22:03
¿tengo una lista de gastos empresariales 00:22:04
que pueda ordenar, sea algún 00:22:07
criterio? 00:22:09
no, tenemos un conjunto de apuntes 00:22:11
pues entonces 00:22:13
lo ideal sería, vamos a crearnos 00:22:15
una lista de gastos empresariales 00:22:16
y cuando ya tenga eso, eso ya 00:22:19
lo puedo ordenar 00:22:21
¿vale? entonces, primero 00:22:22
me piden que ordene no sé qué 00:22:24
vale, para ordenarlo 00:22:27
tengo que tener una lista, si no, no puedo ordenar 00:22:29
nada, o en un array 00:22:31
pero una lista es más fácil de crear 00:22:32
bueno, pues voy a 00:22:35
crearme esa lista, esa lista 00:22:37
de donde me saco los datos para 00:22:38
ella, pues tendrán que ser 00:22:41
todos los gastos empresariales 00:22:43
los apuntes, bueno pues 00:22:45
entonces nos vamos a hacer esa lista 00:22:49
lo primero de todo, una lista 00:22:50
De gasto empresarial 00:22:56
Vale 00:22:59
Esto mismo por ejemplo 00:23:00
Ahora vamos a construirla 00:23:17
Pues para construirla lo más fácil es 00:23:18
Pues venga 00:23:21
Vamos a sacarlos de aquí 00:23:23
Económico 00:23:25
Apuntes 00:23:27
Y ahora 00:23:34
Si A 00:23:38
Resulta que es 00:23:39
Un objeto 00:23:42
Gasto 00:23:44
empresarial 00:23:46
pues si lo es 00:23:48
se va a mi lista 00:23:51
gastos.ad 00:23:53
ese objeto 00:23:56
¿por qué me da este rojo? 00:23:57
¿por qué me da error de compilación? 00:24:10
ahí 00:24:14
me da error de compilación 00:24:14
porque a esta lista 00:24:20
al estar parametrizada 00:24:21
a esta lista solo le puedo meter 00:24:22
gastos empresariales o subclases 00:24:24
y estoy intentando 00:24:27
meterle algo que está declarado 00:24:28
como apunte económico, claro 00:24:30
pero no pasa nada porque yo sé que se 00:24:32
instanció como gasto 00:24:34
empresarial, entonces al haberse 00:24:36
instanciado como gasto empresarial no hay ningún 00:24:38
problema en que le 00:24:40
haga esto 00:24:42
porque ya he verificado antes 00:24:43
empresarial 00:24:46
ahora, vale 00:24:53
ya está, y ahora ya es cuando 00:24:56
uno ya se puede plantear ordenar 00:24:58
¿Vale? Porque esta lista, al ser una lista, pues tendrá un método sort, ¿vale? Y este método sort ya sabemos cómo funciona. 00:24:59
¿Los gastos empresariales tienen un criterio de ordenación definido? No lo tienen, aquí no hay ningún implements comparable. 00:25:16
Tenemos dos opciones 00:25:25
O aquí un implements comparable 00:25:28
Porque ese es su orden natural 00:25:30
Para toda la aplicación 00:25:32
O hacer un comparator 00:25:33
¿Vale? Entonces 00:25:35
¿Qué decido? 00:25:38
Depende, primero tengo que tener acceso 00:25:40
A esta clase 00:25:42
Para poder plantearme y poner aquí 00:25:43
El implements comparable 00:25:46
Y luego cuando lo haga 00:25:47
Tengo que pensar 00:25:49
Que voy a estar alterando al resto del universo 00:25:51
Que esté usando esta clase 00:25:53
porque automáticamente la estoy poniendo 00:25:55
en un orden natural, orden descendente 00:25:57
importes 00:26:00
y el resto del universo 00:26:02
que use esa clase, cuando ordene 00:26:05
cuando haga cosas, cuando haga un triset 00:26:07
pues de repente va a tener ese orden 00:26:09
establecido 00:26:11
entonces eso 00:26:12
es peligroso de hacer 00:26:14
en un contexto real es peligroso, aunque aquí no 00:26:16
funcione, vamos a suponer que lo 00:26:19
hacemos aquí, pues esto se quedaría 00:26:21
Implements comparable 00:26:23
De gasto económico 00:26:26
Vale, entonces al implementar 00:26:30
Lo bajo aquí abajo 00:26:35
Al implementar el comparable de gasto económico 00:26:37
Pues necesito 00:26:41
El gasto empresarial, perdón 00:26:44
Perdón, perdón, perdón 00:26:47
Empresarial 00:26:49
Ahora sí, vale 00:26:53
Ahora entonces ya necesito 00:26:54
Esto 00:26:57
Gasto 00:26:59
Empresarial 00:27:01
Empresarial 00:27:02
Empresarial 00:27:05
Vale 00:27:06
Entonces descendente de importe 00:27:08
Pues descendente de importe 00:27:11
Sería 00:27:13
Que o.get 00:27:14
Importe 00:27:16
menos 00:27:18
dis.get 00:27:25
importe, ¿verdad? 00:27:28
Porque si esta cantidad 00:27:30
ahora le hacemos el casting 00:27:33
entero, porque 00:27:39
los importes son double, porque si esta cantidad 00:27:41
es negativa 00:27:43
significa que 00:27:44
el importe 00:27:47
de el parámetro 00:27:49
más pequeño 00:27:53
luego va 00:27:54
eso significa 00:27:56
que efectivamente 00:27:58
si esta cantidad es negativa estoy diciendo 00:28:00
que el que llama this va el primero 00:28:02
y debería ir el primero 00:28:05
sí, porque su cantidad 00:28:07
es mayor que esta de aquí 00:28:09
es mayor 00:28:11
luego ese sería el orden descendente 00:28:11
da negativo cuando el que llama 00:28:14
el que llama 00:28:17
tiene más cantidad que el parámetro 00:28:18
vale 00:28:21
Lo que pasa es que como los importes son double 00:28:23
Esto me va a dar en double 00:28:24
Pero a mí lo que me importa es el signo de la 00:28:26
De la operación 00:28:29
Es lo que me importa, el signo de la operación 00:28:30
Pues le hago un casting y ya está 00:28:33
¿Vale? Me importa el signo, si es negativo 00:28:34
Positivo o cero 00:28:37
Bueno, pues esto sería un criterio de orden 00:28:38
Que hemos plantado ahí 00:28:44
Que es el descendente de gastos 00:28:45
Vale 00:28:48
Entonces ahora esto se ordenaría 00:28:55
Y ahora vamos a hacer el listado 00:29:01
Y ahora aquí ya, para cada gasto empresarial de mi lista, pues listado más igual g.describir, que para eso tenemos un describir. 00:29:03
Ah, bueno, que describir no te lo devolvía, te lo imprimía, te devolvía un void. 00:29:42
Pues entonces lo dejamos así, le ponemos un toString y ya está. 00:29:46
¿Vale? 00:29:52
Va concatenando y lo devuelve. 00:29:54
Entonces haría falta un toString en gasto empresarial 00:30:02
para que al concatenar uno con otro, uno con otro, 00:30:05
más el salto de línea, claro, 00:30:08
pues no nos quede muy feo el listado. 00:30:12
Vale, vamos a ponerle un gasto empresarial aquí a este. 00:30:18
O sea, un toString, perdón. 00:30:23
Vale, ya está. 00:30:29
A ver, ¿dónde estamos? 00:30:35
Aquí. 00:30:37
Vale. 00:30:39
el compare to de comparable 00:30:39
o el compare de comparator 00:30:42
porque son la misma idea 00:30:44
trabaja siempre 00:30:45
con dos elementos 00:30:48
que son el que llama al método 00:30:49
que es dis 00:30:51
y este que es o en este caso 00:30:52
entonces 00:30:55
te tiene que devolver 00:30:56
negativo si el dis 00:30:58
va antes 00:31:01
que este 00:31:03
cero si son 00:31:04
claro claro porque es el criterio 00:31:06
con el que todos lo tienen en cuenta, ¿vale? 00:31:09
0 si está en la misma posición 00:31:12
y positivo si el dis está después. 00:31:13
Vale, pues nosotros lo que queremos es 00:31:18
que cuando este esté antes, el dis esté antes, 00:31:19
es porque su valor es mayor, 00:31:24
porque queremos el orden descendente, ¿no? 00:31:25
Pues su valor es mayor. 00:31:27
Pues si nos hacemos esta resta, 00:31:28
cuando el dis, su valor sea mayor, 00:31:30
esta resta me va a dar negativo. 00:31:33
Y cuando su valor sea menor, 00:31:36
esta resta me va a dar positivo 00:31:37
que es justo lo que queremos 00:31:40
pues ya está, si lo quisiéramos 00:31:41
en orden al revés, orden 00:31:44
ascendente en vez de descendente 00:31:45
cambiaríamos 00:31:48
los elementos de la resta 00:31:50
lo que pasa es que esta resta 00:31:52
me da en double, porque son números double 00:31:54
pero a mí lo que me importa es el signo de lo que me devuelve 00:31:56
pues lo hago un casting a int y ya está 00:31:58
y cuando sea en el mismo 00:32:00
importe, luego está en la misma posición 00:32:02
pues me da 00:32:04
me dará cero 00:32:05
nunca usaríamos este comparable 00:32:06
este compare tú 00:32:10
para un triset 00:32:12
porque el triset entonces dos gastos 00:32:13
del mismo importe le parecerían 00:32:17
que son el mismo 00:32:19
porque el triset este es su criterio de igualdad 00:32:19
el del compare tú 00:32:23
y no tiene sentido que dos gastos empresariales 00:32:24
solo por tener el mismo importe 00:32:27
fueran el mismo 00:32:28
entonces si usáramos un triset para meter gastos empresariales 00:32:29
tendríamos que hacerle a él 00:32:32
un comparator por nombre 00:32:34
por código 00:32:36
que quiera un triset 00:32:37
me preguntas ahora 00:32:41
a 10 horas del examen 00:32:43
pues otra implementación 00:32:44
de set 00:32:47
está en la grabación que pone triset 00:32:47
lo tienes todo 00:32:50
vale 00:32:51
vale 00:32:51
entonces 00:32:55
y si nosotros ahora 00:32:59
añadieramos aquí 00:33:01
listado de gastos empresariales 00:33:02
pues por ejemplo 00:33:04
ahora, este mismo 00:33:06
listado de gastos empresariales lo quiero 00:33:08
pero por fecha, pues aquí 00:33:10
de nuevo, aquí tendríamos un problema 00:33:25
porque, espérate, otra vez estoy en las 00:33:26
mismas, quiero un listado 00:33:29
de gastos empresariales, vale, ese lo consigo 00:33:31
muy rápido 00:33:33
lo consigo aquí 00:33:33
muy rápido, ya tengo el listado 00:33:38
ahora voy a ordenarlo 00:33:40
pero ahora mi orden 00:33:42
mi orden ya está 00:33:44
establecido, el orden natural yo ya lo he fijado 00:33:50
aquí y he fijado que fuera por 00:33:52
importe, como entonces 00:33:54
como hago ahora para ordenar 00:33:56
por otro criterio distinto 00:33:58
que no sea el natural que yo he puesto 00:34:01
aquí, pues ya 00:34:02
sabemos como, en lugar de decirle 00:34:04
null, dame mi 00:34:07
criterio de ordenación, uno 00:34:08
en concreto para esta ordenación 00:34:10
uno en concreto, pues 00:34:12
tendremos que hacernos un criterio de ordenación 00:34:14
un comparator en 00:34:16
particular para este sort 00:34:18
que le aplique a él solamente 00:34:20
Porque ya sabemos que si le pasamos null 00:34:22
Entonces este sort va a tirar del que haya en la clase 00:34:25
Va a tirar de este 00:34:29
Entonces yo no le puedo pasar null 00:34:30
Porque no quiero que tire del de la clase 00:34:33
Quiero que tire de un criterio distinto que es por fechas 00:34:36
Pues tendremos que pasarle un criterio 00:34:39
Me tendré que hacer, que está sin hacer 00:34:44
Este, pues necesito un criterio 00:34:47
Comparator fechas, como yo lo quiera llamar 00:34:51
Pues venga 00:34:54
Vamos a hacerlo 00:34:56
Pues sería esta clase 00:34:56
Pues yo me la haría 00:35:04
Public class comparator de fechas 00:35:06
Vale 00:35:09
Para que sea 00:35:10
Vale 00:35:13
Aquí ya 00:35:14
Para que sea un comparador 00:35:15
Para que sea un criterio de comparación 00:35:18
Tiene que implementar 00:35:20
Implements 00:35:21
Tiene que implementar 00:35:23
comparador 00:35:25
quiero que sea yo un comparador 00:35:27
entre objetos cualesquiera 00:35:30
o solo entre gastos empresariales 00:35:32
solo entre gastos empresariales 00:35:34
pues venga 00:35:36
empresarial 00:35:37
parametrizalo ahí 00:35:39
y ahora ya 00:35:40
al ser esto una clase 00:35:43
que implemente esto de aquí 00:35:46
necesita sobre escribir los 00:35:47
métodos, no hay otra 00:35:50
que método es 00:35:51
Pues este 00:35:54
Este 00:36:04
Me da un criterio de ordenación 00:36:07
Entre estos dos parámetros 00:36:10
Entre este y este otro 00:36:11
Entonces ahora tenemos que pensar aquí 00:36:13
¿Cómo hacemos para que devuelva negativo 00:36:15
Si la fecha de este 00:36:17
Es antes que la de este otro 00:36:20
Cero, bueno pues menos mal que 00:36:21
Local date 00:36:24
Tiene métodos para ver si una fecha 00:36:26
Es antes que otra 00:36:28
Vamos a ver, pues si el gasto empresarial 1 está, tendrá aquí un get date, claro, get fecha, get fecha, si la fecha del gasto empresarial 1 está después que la fecha del gasto empresarial 2, 00:36:29
Si está después 00:36:53
Entonces aquí me interesa devolver positivo 00:36:55
¿Verdad? 00:36:58
Perdón 00:37:01
Si este está después de este 00:37:02
Me interesa devolver positivo 00:37:06
Pues 1 00:37:08
El 6 00:37:09
Si en lugar de después está antes 00:37:13
Tendrá un is before 00:37:23
Imagino lo tiene 00:37:27
Pues si está antes entonces devuelve menos 1 00:37:28
Porque tiene que devolver negativo 00:37:31
Si el primero está antes que el segundo 00:37:32
retun-1 00:37:35
y si no está antes ni después 00:37:37
es la misma fecha 00:37:40
en ese caso pues ahora ya sí 00:37:41
vale, bueno pues 00:37:43
este es un criterio de ordenación ahí suelto 00:37:55
para quien lo quiera usar 00:37:57
no va asociado a la clase 00:37:59
es por si 00:38:01
lo queremos usar en algún momento 00:38:03
bueno pues este criterio de ordenación que está por aquí 00:38:04
suelto, ahora ya sí 00:38:07
que lo vamos a usar aquí 00:38:09
Y ahora ya pues nos hacemos nuestro listado 00:38:11
Otra vez como aquí 00:38:15
Y aquí sigo teniendo un error rojo 00:38:16
Que no sé 00:38:34
Ah, por este context que tenía yo puesto aquí 00:38:35
Suelto 00:38:38
Vale, venga, vamos a añadir 00:38:39
Otro método, por ejemplo 00:38:47
Vamos a eliminar 00:38:48
Todos los 00:38:50
Todas las facturas de un emisor 00:38:52
Todas las de un emisor fuera 00:39:00
Elimina 00:39:02
Facturas 00:39:11
De un emisor 00:39:13
Que aquí se le pase 00:39:18
Pues aquí cuidado 00:39:19
Vamos a eliminar de un set 00:39:23
Entonces recordad 00:39:25
Que uno no se plantea hacer esto 00:39:27
Para cada 00:39:30
Vámonos a los apuntes económicos 00:39:33
Apunte 00:39:36
Económico 00:39:37
De apuntes 00:39:42
De la tentación 00:39:44
Que uno tendría 00:39:45
Pues si este apunte resulta que es una factura 00:39:46
Y además de ser una factura 00:39:55
Y además de ser una factura 00:40:00
Resulta que su emisor 00:40:04
Factura A 00:40:06
Resulta que su emisor es igual a este que me han dado 00:40:12
Resulta que es igual a este que me han dado 00:40:24
pues un juego tendría tentaciones 00:40:30
aquí de hacer, pues oye tú 00:40:32
de apuntes 00:40:34
punto remove 00:40:36
esa factura, vale 00:40:38
y esto es lo que hemos dicho que es muy mal 00:40:42
bueno aquí antes de eso 00:40:44
fijaos que aquí gracias al doble 00:40:47
AND 00:40:49
este casting 00:40:50
no va a tener ningún problema 00:40:52
porque este doble AND 00:40:55
solo entra aquí 00:40:57
en la segunda cláusula si esta es true 00:40:59
Si es false esta ni se evalúa 00:41:01
Si es false ni se evalúa 00:41:04
Pero 00:41:05
Si es true 00:41:07
Si que se evalúa 00:41:08
Y en ese caso al ser true 00:41:10
Este casting tiene sentido 00:41:13
Porque factura es la clase de A 00:41:14
Pero bueno a lo que íbamos 00:41:17
Esto recordad que es lo que no podíamos 00:41:19
Estamos recorriendo la colección for remove 00:41:20
A su vez otra vez va a recorrerlo 00:41:23
Entonces 00:41:25
Esto no fatal ya lo sabemos 00:41:26
Vale 00:41:29
Ya hemos visto en ejemplo 00:41:31
Como 00:41:34
Como nos da 00:41:35
Concurrent modification exception etc 00:41:41
Vale entonces aquí que hacemos 00:41:43
Bueno pues el método remove ya sabemos 00:41:45
Que puede borrar pero borra por igualdad 00:41:49
Pero claro aquí no hay que borrar 00:41:51
Por 00:41:53
Igualdad de objeto 00:41:54
Sino todos aquellos que su emisor sea 00:41:56
Igual que este 00:41:59
Y ese no es 00:42:01
El criterio de igualdad del hasco 00:42:03
de equals, el criterio de igualdad 00:42:05
del jasco de equals es por código 00:42:07
entonces aquí yo no puedo usar 00:42:09
el remove 00:42:11
y pasarle un objeto con un emisor 00:42:12
igual a este, porque el remove 00:42:15
te borra por igualdad 00:42:17
de jasco de equals 00:42:19
luego aquí como 00:42:20
lo haríamos entonces 00:42:22
que usaríamos 00:42:24
para eliminar de un set 00:42:27
por un criterio que no fuera el de 00:42:30
clave primaria 00:42:33
por un criterio que no es el de jasco de equals 00:42:34
¿qué usaríamos? 00:42:37
no nos queda más remedio que usar 00:42:41
¿qué? el 00:42:42
el iterador, no nos queda más remedio que usar el iterador 00:42:43
para borrar 00:42:47
por un criterio, bueno 00:42:48
y las lambdas que no las conocemos 00:42:49
para borrar por un criterio que no sea 00:42:52
clave primaria 00:42:56
repito, esto no lo podemos hacer 00:42:57
nos va a fallar, nos va a dar 00:43:00
concurrent modification exception por acceder 00:43:02
por un lado por el for y luego por el remove 00:43:04
que a su vez tiene dentro un for 00:43:06
¿Vale? 00:43:07
Y si yo pongo un remove suelto 00:43:09
A punto remove algo 00:43:11
El remove suelto 00:43:13
Lo que yo le pase aquí 00:43:15
El remove va a buscar algo que sea 00:43:17
Igualito a este 00:43:19
Igualito a este 00:43:20
Y la igualdad es por código 00:43:22
No es por emisor 00:43:25
Luego este remove suelto aquí no pinta nada 00:43:26
Este remove solo me vale para borrar 00:43:29
Por clave primaria 00:43:32
En este caso por código 00:43:34
Nunca me borraría por emisor 00:43:35
Nunca me borraría por emisor 00:43:37
Luego esto nada 00:43:38
Vale, entonces tenemos que hacer un iterador 00:43:39
Que ya sabemos 00:43:42
Apuntes 00:43:43
Y ahora ya 00:43:48
Pues ya usamos el iterador 00:43:58
Como ya sabemos usarlo 00:44:00
Mientras tengamos 00:44:01
Un siguiente 00:44:06
En mi iterador 00:44:07
Pues vamos a guardar el elemento en el que estemos 00:44:08
Que es, vamos a dejarlo claro 00:44:14
Apunte 00:44:16
económico 00:44:18
y punto 00:44:20
next, vale, estamos aquí parados 00:44:22
vale, que 00:44:24
teníamos que hacer aquí, borrar 00:44:26
solo si es factura 00:44:28
iterator de 00:44:29
vale 00:44:35
esto a punto de 00:44:39
económico, es que se me había 00:44:41
dado 00:44:44
parametrizar, vale 00:44:44
ahora, si a 00:44:47
resulta que 00:44:50
es una instancia de factura, solo en el caso de que sea una instancia de factura, y si 00:44:54
además de ser una instancia de factura, si además de serlo, resulta que esta condición 00:45:02
de aquí, que ahora ya sí que podemos moverla, y si además de eso resulta que su emisor 00:45:09
es igual que este emisor 00:45:26
que me han dado 00:45:28
pues entonces en ese caso 00:45:29
ahora ya 00:45:31
id.remove 00:45:33
¿vale? así si podemos 00:45:36
borrar todas las facturas 00:45:39
de un emisor 00:45:42
así si 00:45:42
¿vale? ya se quedarían borradas 00:45:44
¿vale? 00:45:47
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:
3 de marzo de 2026 - 17:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
190.88 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid