Saltar navegación

20250225 CorreccionExSegunda_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 26 de febrero de 2025 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga 00:00:00
Pues nada, los magos y las magas 00:00:01
Yo es que soy muy mágica 00:00:04
Venga 00:00:08
Lo hacemos todo entre los dos 00:00:10
No tengas la mínima duda 00:00:15
Nos compenetramos a la perfección 00:00:16
Ya te lo digo 00:00:20
Venga, a ver, el mago elemental 00:00:21
Vale, aquí 00:00:24
Teniendo en cuenta que esto 00:00:34
hacer estas clases 00:00:36
es facilísimo porque es hacer unas clases 00:00:39
unas propiedades y unos métodos, con lo cual 00:00:41
de alguna manera lo que se espera 00:00:42
es que seáis capaces de extraer 00:00:44
meta información 00:00:47
meta información 00:00:49
sí, que es 00:00:51
algo más de lo que se dice 00:00:52
es decir, tomar decisiones 00:00:54
son clases abstractas, son interfaces 00:00:56
eso es lo que se evalúa 00:00:58
porque hacer una clase con propiedad tal y tal 00:01:00
eso no se puede 00:01:03
evaluar, eso es un cero 00:01:04
porque es que te lo hace el eclipse. 00:01:06
Lo que tenemos que evaluar es que sepáis capaces 00:01:07
de extraer información extra, entre líneas, entre comillas, 00:01:09
de una situación. 00:01:14
Por ejemplo, en este caso, el mago elemental, este de aquí, 00:01:15
la forma de lanzar el hechizo depende del mago que sea. 00:01:20
Conclusión, ¿cómo lanza un hechizo el mago? 00:01:24
No lo sabemos. 00:01:27
Conclusión, clase abstracta. 00:01:28
¿Vale? 00:01:30
Primera cosa que se evalúa. 00:01:31
¿clase abstracta o interfaz? 00:01:33
hombre, pues clase abstracta 00:01:37
porque tiene una propiedad nombre, luego no puede ser 00:01:38
interfaz, luego aquí no hay tutía 00:01:40
mago elemental, es una clase 00:01:42
abstracta si yo hago un diseño 00:01:44
acorde con la lectura 00:01:46
que me están ofreciendo 00:01:48
de la situación 00:01:50
pues ya está 00:01:51
esto era 00:01:52
aprendizable 00:01:54
sí, vale 00:01:58
esto 00:02:00
tú dijiste que por convención se sabían llamar 00:02:00
sí, sí, sí, sí 00:02:03
sí, tienes razón 00:02:05
vale, entonces, bueno, paso de los get y los set 00:02:07
porque eso da igual 00:02:10
ahora mismo 00:02:11
y como es mucho que vamos a ir rápido 00:02:13
tiene una propiedad string nombre 00:02:14
y aquí podéis poner constructores 00:02:16
lo que os dé la gana, eso pues bueno 00:02:20
podemos más o menos 00:02:21
pero lo importante era darse cuenta 00:02:22
de que es una clase abstracta y no interfaz 00:02:25
porque tiene propiedad 00:02:27
y que el método lanzar hechizo 00:02:28
no puede tener un código 00:02:30
pues ya está 00:02:32
y es que ver subclases abajo 00:02:34
es que estaba ya completamente ofrecido 00:02:36
que eso tenía que ser una clase abstracta 00:02:39
es que solo nos faltaba decir 00:02:40
hacer una clase abstracta mago elemental 00:02:42
pues venga 00:02:44
a ver 00:02:47
Cristian 00:03:01
¿cómo se escribe hechizo? 00:03:03
y la primera de ellas 00:03:06
¿cuál es? 00:03:10
vale 00:03:13
¿por qué no te diste cuenta de eso en el examen? 00:03:13
¿tú te crees que yo puedo encontrarme 00:03:19
un examen así e irme a la cama 00:03:21
tranquila? 00:03:23
me echaste 00:03:34
me echaste, vamos 00:03:35
vale, pues esta clase 00:03:35
con tener esto ya era suficiente 00:03:38
que ponéis constructores, Getty Set 00:03:39
para nombre, pues muy bien, lo ponéis 00:03:42
sí, pero 00:03:43
en defensa del jefe 00:03:49
él puede decidir largarte cuando le dé la gana 00:03:52
y estáis en el punto 00:03:54
de mira, porque es que 00:03:56
se os odia mucho en general a vuestra 00:03:58
generación 00:04:00
no lo sé, no lo sé, porque 00:04:00
no lo sé, no es 00:04:03
entonces, en cuanto os vean 00:04:04
coger el teléfono para ir tenéis un mensaje 00:04:08
ya estáis dando la excusa para decir 00:04:09
otro que vive pegado a su teléfono, a la calle 00:04:11
se vayan a la mierda 00:04:14
sí, pero 00:04:15
los que se van a la mierda son los que te van a pagar 00:04:17
así que mejor que no se vayan a la mierda 00:04:19
venga, entonces 00:04:21
el fuego y el aire 00:04:23
pues es que no tienen nada que 00:04:26
que hacer 00:04:27
vale, entonces como el mago fuego 00:04:38
es el mago elemental 00:04:45
tiene que implementar el método 00:04:46
y este método dice aquí 00:04:49
que ahora ya este sí que tiene cuerpo 00:04:51
pero para eso necesita la propiedad adicional 00:04:52
pues ya está 00:04:54
el fuego superficie y el aire velocidad 00:04:56
pues ya ves tú que complicación 00:04:59
el fuego superficie 00:05:01
con lo cual este pues ya está 00:05:04
Todo esto 00:05:17
Y con esto ya era suficiente 00:05:26
Que luego además 00:05:30
Lo rizáis bien, ponéis get set 00:05:32
Ponéis modificadores de acceso 00:05:34
Pues muy bien, muy bonito 00:05:36
Vale, se supone que eso ya lo tenéis interiorizado 00:05:38
Pero 00:05:41
Con esto, esto es lo que evaluamos 00:05:41
Ya ves tú que tontería 00:05:44
El mago aire pues lo mismo 00:05:45
El mago aire sin embargo 00:05:46
Pues tenía la velocidad del viento 00:05:58
Y al heredar del mago elemental, pues tiene que implementar su método. 00:05:59
Empujo o soplo a esta velocidad. 00:06:24
hala, tres clases hechas 00:06:28
vale 00:06:35
ahora, ¿qué más hay? 00:06:36
este tiene capacidad de estudiar 00:06:41
no tiene propiedades 00:06:43
ni tiene nada, solo tiene comportamiento 00:06:45
entonces 00:06:47
aquí, pues el 00:06:49
punto evaluable es 00:06:51
decidir, darse cuenta 00:06:53
de que esto se queda mejor representado 00:06:55
en una interfaz, que es lo que solo tiene 00:06:57
comportamiento, una interfaz 00:06:59
¿vale? entonces alguien puede comportarse 00:07:01
como un aprendiz 00:07:03
¿vale? pero sin embargo, alguien 00:07:04
no solo se comporta como un mago elemental 00:07:07
sino que es un mago elemental 00:07:09
porque tiene nombre, por eso 00:07:11
es una clase abstracta 00:07:13
pues venga, el aprendiz es una interfaz 00:07:14
y ya está, ¿y qué comportamiento ofrece? 00:07:17
pues el de estudiar 00:07:19
¿cuál? no sabemos, aquí ya decimos que no sabemos 00:07:20
cuál es, por eso es una interfaz 00:07:23
pues hacemos 00:07:24
la interfaz 00:07:28
aprendizable 00:07:31
aprendizable, aprendible 00:07:36
voy a estudiar 00:07:41
a veces son amenas 00:07:47
si la verdad es que a veces si ponéis alguna chorrada 00:07:51
pues algo me entretengo 00:07:54
si que no es tu caso 00:07:55
es que lo recuerdo y no es tu caso 00:08:00
¿qué dices? 00:08:04
ni de coña, obviamente no 00:08:07
pues porque no 00:08:10
porque los 3 RAs también tienen parte 00:08:11
de lo anterior, que tienes que decir una colección 00:08:13
tienes que decir, hombre a ver 00:08:16
si con hacer esto apruebas 3 RAs que es casi 00:08:17
la mitad del curso, ¿para qué estamos 00:08:19
aquí nosotros? si es que esto se 00:08:22
aprenden 00:08:23
vale 00:08:24
aprendiz a estudiar 00:08:26
Y ahora, ¿qué más tenemos? 00:08:30
Pues tenemos el mago estudiante 00:08:33
y el mago estudiante puede estudiar 00:08:35
y además es elemental, pues entonces ya no lo están 00:08:37
diciendo, pues hereda e implementa. 00:08:39
Entonces, si alguno había 00:08:41
hecho esto como clase abstracta, 00:08:43
ya esa información se lo hace cambiar a interfaz 00:08:45
porque tú no puedes heredar de dos 00:08:47
clases a la vez, entonces una tiene que ser interfaz. 00:08:49
La primera no puede ser porque tiene 00:08:52
un nombre, pues tiene que ser esta. 00:08:53
Entonces, por cualquier parte que abordaras 00:08:55
llegabas a esto. 00:08:57
Entonces 00:08:58
El mago 00:09:01
Elemental 00:09:09
Este de aquí 00:09:11
Uy, perdón, no, el mago elemental no, mago estudiante 00:09:12
Mago estudiante 00:09:15
Vale 00:09:19
El mago estudiante es elemental 00:09:20
Y aparte 00:09:23
Es aprendiz 00:09:28
Implement 00:09:30
Implementes 00:09:31
Entonces, al tener las dos 00:09:34
cosas, pues tiene que implementar 00:09:42
los dos métodos. 00:09:45
¿Cómo los implementa? Pues como 00:09:46
me dice aquí. Ya está. 00:09:48
¡Hala! Rapidito. 00:10:08
Poniendo cualquier cosa. Vale. 00:10:09
Y las clases ya están. 00:10:11
Y ahora ya 00:10:14
un main con 00:10:17
tres magos. Con esto 00:10:18
de aquí. Pues este 00:10:20
main. 00:10:27
¡Ay! 00:10:33
Ya no sé ni escribirlo. 00:10:57
Vale. 00:10:59
Vale, pues ya está 00:11:04
Hacemos tres magos, una Rai 00:11:06
De tres magos elementales 00:11:08
Que alguno me dijo, una Rai, pero si yo no estudio a Rai 00:11:10
Por Dios, pues eso es lo que no puede ocurrir 00:11:12
Que de un examen a otro 00:11:15
Se subieron las cosas 00:11:16
Estaba claro que tú no ibas a ser de esos 00:11:17
Porque en cuanto viste la opción 00:11:20
De ver una Rai, dijiste, por fin se han acordado de mí 00:11:23
Elemental 00:11:25
Soy así, soy así 00:11:27
Me dicen que por dentro de todo 00:11:29
Pues viene a todo Rai 00:11:30
Ala, tres magos elementales 00:11:31
Pues nada 00:11:44
El mago cero 00:11:45
Tenemos 00:11:49
Un estudiante, un aire y un fuego 00:11:54
Aquí como no tengo ni constructora ni nada 00:11:57
Le voy a dejar 00:12:05
No, no le puedo dejar sin nombre 00:12:07
magos 0 00:12:08
punto 00:12:15
a ver, lo estoy haciendo horrible todo 00:12:16
por la rapidez que decíamos, no estoy poniendo 00:12:18
ni, no, porque es que 00:12:21
ni siquiera lo tengo como protete, venga 00:12:23
vamos a hacer un constructor 00:12:24
vale 00:12:25
ya es que 00:12:28
me ha dicho rápido, rápido, pues yo voy rápido 00:12:31
vale, entonces 00:12:33
hacemos en mago elemental 00:12:34
un constructor rápidamente 00:12:36
Que no se tarda nada 00:12:39
Con el nombre 00:12:41
Y ahora 00:12:44
Los otros pues se han quedado 00:12:49
Ahora ya rojitos 00:12:51
Hacemos un constructor 00:12:53
Para cada uno de ellos 00:12:57
Este ya tiene 00:12:59
El mago fuego ya lo tiene 00:13:05
El mago aire también 00:13:07
Y el mago estudiante 00:13:11
necesita 00:13:20
un constructor también 00:13:22
vale 00:13:25
ya tenemos constructores en los tres 00:13:27
y así esto se queda 00:13:30
ahora más sencillo 00:13:33
en el main 00:13:35
el mago estudiante no sé cómo se va a llamar 00:13:35
pero lo llamamos bla 00:13:38
el mago aire 00:13:39
se llama me da igual 00:13:55
y empuja 00:13:57
Y este me da igual como se llame 00:14:01
Y quema 87 00:14:20
Y ahora 00:14:21
Tienen que hacer cosas 00:14:24
Entonces claro, uno podría uno por uno 00:14:25
Hacer el casting para que hagan las cosas 00:14:28
Pero ya especificamos que eso no valía 00:14:30
Había que recorrer 00:14:32
Ya especificamos que eso no valía 00:14:33
Entonces hay que recorrer 00:14:35
Pues cada 00:14:37
Para cada mago elemental 00:14:38
En mi array de magos 00:14:41
Hay que ver 00:14:43
Vamos a ver 00:14:45
¿Eres estudiante? 00:14:46
Pues primero estudias 00:14:48
Pues eso es lo que habrá que ver 00:14:49
¿Cómo vemos si es estudiante? 00:14:51
Oye tú 00:14:53
¿Eres estudiante? 00:14:53
Pues si eres estudiante 00:15:01
En ese caso te puedo hacer el casting 00:15:02
Amago estudiante 00:15:05
Porque eres estudiante 00:15:07
Y te hago el casting 00:15:09
Y después de hacerte el casting 00:15:13
Pues ya no habrá problema 00:15:14
En que estudies 00:15:15
y ahora ya 00:15:17
seas estudiante o no lo seas 00:15:24
en el resto de los casos 00:15:26
pues ya está, este era el main 00:15:27
bueno, sobre esta 00:15:30
ejercicio nadie tiene dudas 00:15:42
vale, voy a ir 00:15:43
copiando 00:15:59
las clases del otro 00:16:01
a ver, de todas maneras que lo voy a subir 00:16:03
la solución a la virtual 00:16:43
tampoco os obsesionéis con copiarlo 00:16:44
porque vamos a intentar ir fluidos 00:16:46
porque ahora en el otro de más 00:16:49
que vamos a completar el código 00:16:52
venga, pues a ver 00:16:53
vale, pues a ver 00:17:01
el otro ejercicio 00:17:12
partía ya de 00:17:13
estas clases 00:17:16
una partícula con carga, masa y posición 00:17:18
no tiene puesto ni igual 00:17:24
ni tiene nada 00:17:30
con la idea de que uno lo incorpore 00:17:30
en la medida en que lo necesite 00:17:32
el punto 00:17:33
dos coordenadas 00:17:36
lo mismo, no tiene 00:17:41
equals ni nada, la espera de que si es 00:17:42
necesario lo pongamos 00:17:45
y el main 00:17:46
entonces aquí todo el tiempo que se pierde, como no había 00:17:47
mucho tiempo, porque solo había dos horas 00:17:52
cortas, como siempre hay mucho tiempo escribiendo 00:17:54
los escáner, patatín, pues por eso 00:17:56
lo dimos todo hecho 00:17:59
para que tuvierais solo que completarle 00:18:00
imprescindible, vale 00:18:02
pues este main simplemente 00:18:04
la idea era que llamara al ejecutar 00:18:06
que es el que ya hace las cosas 00:18:08
y el ejecutar mostraba 00:18:10
un menú, sin más 00:18:12
y había que hacer estos cuatro métodos 00:18:14
entonces 00:18:16
de los cuales estaban 00:18:19
hechos la parte de leer por teclado 00:18:24
¿vale? y luego el main que teníamos aquí 00:18:25
que es llamar a ejecutar, si lo quería uno probar 00:18:28
llamaba a ejecutar y se acabó 00:18:30
entonces, uno se echa un vistazo a esto 00:18:31
y si miramos el enunciado 00:18:35
pues lo primero que nos dice es 00:18:40
¿vale? 00:18:41
hay un sistema donde interactúan 00:18:43
partículas elementales 00:18:46
entonces, claro que es lo primero 00:18:47
que nos falta de este ejercicio 00:18:50
los datos, donde meto los datos 00:18:51
recordad que esto se trata 00:18:53
no solo de hacer algoritmos 00:18:55
programa que haga no se que 00:18:58
sino de, de alguna manera 00:18:59
pues extraer información 00:19:01
en general, dentro de 00:19:03
la práctica del desarrollo, que es 00:19:05
hombre, si voy a modelar partículas 00:19:07
y yo a las partículas 00:19:09
añado una a la colección de partículas 00:19:11
pues hombre, ¿dónde pongo yo 00:19:14
mis datos? pues en una colección 00:19:16
¿me cuadra eso con lo que me dice? 00:19:17
sí, sí, sí, porque yo tendré una colección 00:19:20
de partículas a la que añado, busco dentro 00:19:22
de esa colección, elimino 00:19:24
pues parece que una única colección 00:19:25
es el único dato que necesito 00:19:27
una colección de partículas 00:19:30
bueno, pues aquí os lo poníamos 00:19:31
fácil porque la podíais elegir 00:19:34
que fuera una lista, un conjunto, la que 00:19:35
quisierais 00:19:38
vale, pues bueno 00:19:38
la que casi todos habéis elegido 00:19:41
es una lista 00:19:44
pero no era necesario 00:19:44
¿vale? una lista 00:19:48
podía ser un conjunto, podía ser cualquiera 00:19:49
pero pusiste arriba, importaste arriba la raíz 00:19:51
y dijimos, ya que está importado 00:19:53
ya, es que eso fue un fallo 00:19:56
porque las pruebas 00:19:59
pues las hicimos poniendo una lista cualquiera 00:20:00
para ver que el programa entero 00:20:02
tenía sentido 00:20:04
claro, pero entonces 00:20:05
no, pero bien, si no pasa nada 00:20:07
o sea, el que puso un list, pues un list 00:20:10
no hemos quitado puntos por eso 00:20:11
no, lo único que decía era que 00:20:13
en este ejercicio no es necesario 00:20:15
los métodos que hay no necesitan 00:20:17
claro 00:20:19
aquí la pregunta sería 00:20:20
¿esta aplicación 00:20:23
permite 00:20:26
tiene sentido que permita duplicados? 00:20:27
pues hombre 00:20:31
aquí tuvimos, Estefano, una larga discusión 00:20:31
porque él al principio 00:20:33
dijo vamos a poner un sistema de colisión 00:20:35
de partículas y dije yo a ver 00:20:38
si es de colisión de partículas 00:20:39
puede haber partículas con la misma carga 00:20:41
la misma masa en el mismo 00:20:44
punto, en el mismo 00:20:45
con lo cual automáticamente 00:20:47
tiene que ser un sistema en el cual 00:20:49
la colección tenga que admitir 00:20:51
objetos con las propiedades iguales 00:20:53
duplicados, entonces ahí ya la cosa 00:20:55
se puede poner más útil 00:20:57
y Estefano dijo vamos a quitarlo de colisión 00:20:59
bueno pero como no va a ir listo 00:21:01
sí, pero bueno 00:21:02
para que no pareciera que complicábamos la cosa 00:21:05
entonces dijimos, mira, quitamos lo de colisión 00:21:07
y porque 00:21:09
y entonces ya 00:21:11
automáticamente ya esto cobraba sentido 00:21:12
porque la partícula más cercana 00:21:14
claro 00:21:16
entonces al poner aquí 00:21:21
la más cercana ya automáticamente 00:21:23
asumíamos que en cada posición sólo puede haber 00:21:25
una partícula, con lo cual 00:21:27
el equals en caso de necesitarlo debería ser 00:21:29
por posición, porque puede haber varias 00:21:31
partículas con la misma masa o con la misma carga 00:21:33
pero no en la misma posición 00:21:35
¿vale? entonces del enunciado entero 00:21:37
se deducía 00:21:39
que había un equals por posición 00:21:41
eso por un lado y que no hacía falta 00:21:43
una lista ¿vale? que luego 00:21:45
era imprescindible que estuviera el equals 00:21:47
pues depende, depende de si 00:21:49
borrabais por... depende 00:21:51
¿vale? pero lo que es la 00:21:53
situación tenía sentido 00:21:55
así, con un equals por posición 00:21:57
¿sí? 00:21:59
pero luego no lo usabas 00:22:01
vale, pues entonces 00:22:03
el problema de hacerlo por todo es que si luego usas un remove 00:22:08
tienes que pasarle las tres propiedades 00:22:11
idénticas, no te basta con que le pases solo una 00:22:13
si hubieras hecho ese uso, pero no lo has hecho 00:22:15
vale, pues entonces 00:22:16
lo primero que nos damos cuenta 00:22:19
aquí es que hay que añadir 00:22:21
la colección en algún lado 00:22:22
¿dónde? pues hombre, donde os dé la gana añadirla 00:22:24
aquí 00:22:27
agregar partícula a la colección 00:22:28
si la 00:22:31
si la colección la poníais aquí dentro 00:22:32
de ejecutar, pues entonces luego teníais que pasársela 00:22:34
como parámetro, ¿verdad? 00:22:37
donde quisierais ponerla 00:22:38
si la ponemos aquí como static 00:22:40
pues entonces ya la puede usar cualquier método 00:22:42
pero hay que cambiarle el modificador a static 00:22:45
entonces eso es lo que 00:22:47
cada uno quisiera, ¿vale? 00:22:49
siempre y cuando fuera una opción con sentido 00:22:51
entonces 00:22:52
por ejemplo, si yo 00:22:54
declaro mi 00:22:56
este de colección de partículas 00:22:58
lo declaro aquí 00:23:04
como solo hay una colección 00:23:05
en todo el ejercicio, pues aquí va a ser 00:23:11
más cómodo 00:23:13
public static list 00:23:14
partícula 00:23:17
partículas 00:23:22
vale, podríamos ya 00:23:23
declararlo aquí mismo si queremos 00:23:28
vale 00:23:30
bueno pues aquí están mis partículas 00:23:36
y ahora ya si nos vamos a los métodos 00:23:39
agregar partícula 00:23:41
pues hombre 00:23:44
agregar partícula 00:23:45
ya ves tú 00:23:48
que tiene que hacer 00:23:49
agregar partícula 00:23:53
agregar partícula 00:23:54
tiene que instanciar 00:23:56
el objeto partícula 00:23:59
tiene ya las propiedades 00:24:01
pues tiene que instanciarlo 00:24:02
y había un constructor 00:24:04
con los tres parámetros, si no lo hay 00:24:14
pues se lo crea uno y ya está 00:24:16
hay un constructor 00:24:18
con los tres parámetros 00:24:21
masa y posición 00:24:23
pues entonces le añadimos aquí 00:24:25
la carga 00:24:27
la masa y la posición 00:24:31
que será un nuevo objeto punto 00:24:35
con 00:24:38
x e y 00:24:42
y ahora se lo añadimos a 00:24:43
es que de hecho 00:24:48
ni siquiera tendríamos que 00:24:50
partículas.add 00:24:52
vale 00:24:56
pues ya está 00:25:09
aquí lo único es que uno puede rizar el rizo 00:25:13
pero no era tampoco lo que mirábamos 00:25:16
que es, oye y si me meten una partícula 00:25:18
que ya existe 00:25:21
o lo que es lo mismo 00:25:24
que está en la misma posición que otra 00:25:25
podríamos verificarlo 00:25:26
a ver si hay alguna partícula ya que esté 00:25:29
en esa posición o no 00:25:31
si hubiéramos hecho un hash set con el jasco de equals 00:25:32
de posición no haría falta 00:25:35
verificarlo, entonces esa sería la opción 00:25:37
mejor, que hubierais seleccionado 00:25:39
una colección hash set 00:25:41
y un equals 00:25:43
por posición, porque 00:25:44
os hubierais dado cuenta de que 00:25:46
no tiene sentido que haya dos partículas en la misma posición 00:25:48
porque de hecho ya el método de distancia 00:25:50
me lo está dando a entender 00:25:52
entonces, si os dais cuenta de eso 00:25:54
hacéis un jasco de equals por posición 00:25:57
y aquí al añadir os despreocupáis 00:25:59
de si va a meter en la colección 2 00:26:02
con la misma posición 00:26:03
si habéis hecho una lista sin más 00:26:04
va a meter la partícula sí o sí 00:26:06
aunque tenga la misma posición 00:26:09
con lo cual luego va a haber un problema 00:26:10
cuando encontréis la más cercana 00:26:12
eliminará solo una 00:26:14
eso pues bueno, la aplicación no está 00:26:16
correctamente hecha en realidad 00:26:18
porque te elimina una pero te dejaría otra 00:26:20
¿realmente quieres que haya dos en la misma posición? 00:26:22
pues entonces tu error ya venía de aquí 00:26:25
de haber hecho el add sin verificar 00:26:26
claro, entonces aquí 00:26:28
lo ideal sería 00:26:30
si tú lo has hecho en una lista, hacer un contains 00:26:32
y decir, oye, si no la contienes 00:26:34
añádelo, eso sería lo guay 00:26:37
pero claro, para hacer un contains 00:26:39
necesitas el equals por posición 00:26:41
entonces 00:26:43
lo mejor de todo es, si uno ya ha llegado 00:26:44
a la conclusión de que en este ejercicio 00:26:47
la posición es lo importante 00:26:49
ya se hace su equals 00:26:51
y si se hace su hascode también, porque nunca sobra 00:26:52
Si luego cambias a un set, claro, entonces te haces ya de siempre tu jasco de equals por posición y ya lo tienes. 00:26:55
Ah, vale, me dice que punto no, me está implementando el equals, vale, porque estoy tirando de, claro, en punto, aquí sí que sí, dos puntos son el mismo si las dos coordenadas son iguales. 00:27:08
entonces aquí en punto 00:27:19
podríamos hacernos nuestro 00:27:21
jasco de equals 00:27:24
por las dos coordenadas 00:27:26
vale 00:27:27
y ya tengo mi punto con su jasco de equals 00:27:29
mi partícula con su jasco de equals 00:27:31
y ahora ya aquí 00:27:33
en el momento de añadir podría hacer 00:27:35
oye si no contiene 00:27:37
si me colisión partículas 00:27:39
no contiene 00:27:41
a la partícula que acabo de crear 00:27:44
vamos a ponerla 00:27:46
parte para que se vea mejor 00:27:48
pues si no 00:27:50
contiene a p 00:28:04
si no la contiene 00:28:05
entonces añade 00:28:08
la a y dices partícula agregada 00:28:11
y si no pues le dices 00:28:12
ya existe 00:28:29
una partícula en esa posición 00:28:31
y como esto no es un sistema 00:28:32
de colisión pues no se puede 00:28:41
bueno pues esto sería lo bonito 00:28:42
la forma buena de hacer las cosas 00:28:48
si yo echo un list verificarlo con 00:28:50
contains porque contains 00:28:52
recordad que tira del equals 00:28:54
en la lista 00:28:56
o si he hecho un set con el hascode 00:28:57
de equals, ya está 00:29:00
no hace falta que verifique si lo contiene o no 00:29:01
porque ya sé que no lo voy a añadir, esa sería la forma 00:29:03
bonita 00:29:05
que habéis hecho un list, lo habéis añadido 00:29:07
y punto pelota, es decir una línea de código 00:29:09
lo hemos contado también 00:29:11
como si estuviera bien hecho 00:29:12
completo 00:29:16
con lo cual este método no tenía más historia 00:29:16
buscar por rango de masa 00:29:19
pues aquí lo tenemos más fácil todavía 00:29:21
hacemos un for y la partícula 00:29:23
que 00:29:25
cumple esa propiedad se añade aquí 00:29:26
cuidadín 00:29:29
claro, habría que guardarlo en la lista 00:29:30
cuidadín, lógicamente habéis instanciado 00:29:34
aquí la lista 00:29:37
pero bueno, vamos a 00:29:38
guardarlas en la lista que está 00:29:41
arriba y devolverlo, pues ya está 00:29:43
vamos a recorrer 00:29:45
cada partícula 00:29:49
vale, pues 00:30:00
vamos a ver si cumple esa propiedad 00:30:01
Pues si p 00:30:03
Aquí no había get ni set ni había nada 00:30:06
No había get ni set ni nada 00:30:08
Entonces vamos a ponerlo 00:30:13
Vale, si la masa es 00:30:15
Si la masa es mayor o igual 00:30:26
Que la mínima 00:30:31
Y siendo mayor o igual que la mínima 00:30:34
Es menor o igual 00:30:38
Que la máxima 00:30:45
¿Qué hago yo? 00:30:52
no se llama maxMasa, ¿verdad? 00:30:53
He borrado algo, ¿verdad? 00:31:03
Sí, aquí he borrado el 00:31:05
este. Pues ya está. 00:31:06
Se añade a la lista y se acabó. 00:31:17
Lista.add 00:31:23
p. Vale. 00:31:24
Aquí tenemos el riesgo 00:31:27
de añadir una que ya 00:31:29
existe en la posición. 00:31:30
Pues no, porque estas son partículas 00:31:34
que ya estaban en la 00:31:36
colección. Se supone que no estaban en la misma 00:31:38
posición. Bueno, pues 00:31:39
Ya está, este método ya está. 00:31:42
Cuidadín, claro. 00:31:44
Vamos a instanciar la colección, 00:31:46
si no en la primera añadida va a ser un new pointer exception. 00:31:47
Cuidado que a nadie se le olvide instanciarla, lógicamente. 00:31:51
Pues este método ya estaba, muy fácil también. 00:32:03
Vale, eliminar por posición. 00:32:06
Aquí es hacer un mínimo. 00:32:09
Aquella que cumpla que una propiedad, 00:32:12
que es la propiedad distancia, sea mínima. 00:32:14
y esa propiedad distancia 00:32:16
la podemos sacar de este método que ya estaba hecho 00:32:18
entonces no hace falta que nos compliquemos 00:32:20
entonces aquí hay que hacer 00:32:21
un mínimo 00:32:24
dentro de todas las partículas para encontrar 00:32:26
una 00:32:28
que es la que vamos a eliminar 00:32:29
luego tenemos una partícula objetivo 00:32:31
la partícula a eliminar, que es esta 00:32:33
¿vale? 00:32:36
esta es la partícula a eliminar 00:32:41
entonces 00:32:43
esta partícula 00:32:45
la partícula a eliminar 00:32:48
puede ser como tenemos una lista 00:32:50
puede ser la primera de la colección 00:32:52
vale 00:32:53
y ahora ya comprobamos 00:32:55
todas ellas a ver si alguna tiene 00:32:58
como distancia menor que la distancia 00:33:00
que tiene esta 00:33:02
entonces esta puede ser 00:33:03
partículas.get 00:33:05
vale 00:33:09
esto es hacer un mínimo 00:33:10
que es de la primera evaluación como veis 00:33:11
igual que preguntamos ahora cosas 00:33:14
de la primera evaluación todo el rato pues en la tercera también 00:33:16
de colecciones de hash map 00:33:18
aquí no ha caído nada, pero caerá en otros 00:33:20
exámenes, los map 00:33:22
¿vale? 00:33:24
vale, pues esta es la partícula eliminada 00:33:26
pues porque como se vio con tan poco 00:33:27
tiempo de antelación, pues para que no 00:33:34
pusierais ahí mi... 00:33:36
te hubiera gustado 00:33:38
venga, pues vamos a recorrer todo 00:33:40
para cada partícula 00:33:44
P en partículas 00:33:46
vamos a ir una por una 00:33:47
a ver si encontramos alguna 00:33:50
cuya distancia a este punto 00:33:52
sea menor que esta 00:33:55
que es la primera que hemos cogido 00:33:57
puede ser una cualquiera 00:33:59
puede ser una cualquiera 00:34:00
pues venga, aquí ya hacemos 00:34:01
si, y como calculo yo 00:34:04
la distancia entre 00:34:07
esta partícula y el punto 00:34:08
pues la podría hacer 00:34:11
o tengo el método, pues tengo un método 00:34:12
si la distancia 00:34:14
calcular distancia 00:34:16
entre 00:34:20
la posición de mi partícula P 00:34:25
que la saco con get punto 00:34:28
cuando me haga mi get 00:34:30
set de 00:34:32
ya lo tengo, ¿no? 00:34:35
get set de 00:34:38
ah, es que es posición 00:34:39
vale 00:34:39
sí, eso 00:34:40
vale 00:34:43
get posición 00:34:44
y en la posición que me han dado 00:34:47
vale 00:34:50
si la distancia de esta partícula P 00:34:50
es menor 00:34:53
que la que es mínima 00:34:55
hasta ese momento 00:34:58
es menor que 00:34:59
que con un zoom tan grande 00:35:01
es todo muy complicado 00:35:04
es menor que 00:35:05
no, que calcular distancia 00:35:06
eliminar 00:35:10
punto get 00:35:19
posición 00:35:21
Posición 00:35:22
Si es menor, ala, tengo nueva partícula 00:35:24
Mínima 00:35:27
Eliminar igual a p 00:35:28
Y ya está 00:35:30
Bueno, ya está 00:35:33
Ya he encontrado la partícula eliminar 00:35:35
Vale, pues ya está 00:35:36
Es un for para hacer el mínimo 00:35:38
Cojo cualquiera de la colección 00:35:39
Cualquiera, he cogido la primera 00:35:42
Y ahora me pongo a recorrer toda la colección 00:35:44
Voy una por una 00:35:46
Sí, se puede hacer de muchas maneras, pero bueno, podemos coger una cualquiera, ya recorremos toda la colección, para cada una de ellas, cumple que es menor que la otra en la propiedad que sea, en este caso es en la distancia, silencio, esta partícula P, cumple que su distancia es menor que la que es mínima hasta ese momento, pues sí, cumple que es menor, pues tengo nuevo mínimo, y así todo el rato. 00:35:47
cuando ya mi for ha terminado 00:36:14
que ha terminado en este punto 00:36:16
ya puedo eliminarla de la colección 00:36:17
partículas 00:36:20
para eso tengo un remove 00:36:22
¿vale? 00:36:24
pero insisto 00:36:27
este remove que va a hacer 00:36:28
va a eliminar 00:36:30
la primera partícula 00:36:32
que encuentre igual a esta 00:36:34
igual 00:36:37
según su método equals 00:36:38
¿vale? 00:36:40
claro, en este caso 00:36:42
perdón, eliminar 00:36:43
¿qué hago yo? eliminar 00:36:45
vale 00:36:47
igual a esta 00:36:48
¿vale? igual su método 00:36:51
igual, pero es que eliminar 00:36:53
es directamente una copia de p 00:36:54
que está en la colección, es directamente 00:36:57
una copia, luego ya va a tener su posición 00:36:59
el equals de la posición lo va a tener 00:37:01
entonces con esto ya lo tengo 00:37:02
si yo no hubiera puesto 00:37:04
un equals 00:37:11
en partícula 00:37:14
cuidado porque esto 00:37:16
falla 00:37:19
porque esto es un for each 00:37:20
con lo cual esto es un for each 00:37:22
con lo cual esto es una copia 00:37:24
de la partícula real, está en otra 00:37:27
dirección de memoria 00:37:29
su contenido es el mismo 00:37:30
masa, carga eléctrica y posición 00:37:32
idéntica, su contenido es el mismo 00:37:35
pero P tiene una dirección de memoria 00:37:37
y la partícula real tiene otra 00:37:39
¿vale? 00:37:41
con lo cual en eliminar 00:37:42
yo estoy poniendo la dirección 00:37:44
de la copia 00:37:47
¿vale? su contenido es el mismo 00:37:48
su contenido es el mismo 00:37:50
pero la dirección no es la dirección de la partícula real 00:37:52
es otra dirección 00:37:54
aunque el contenido es el mismo 00:37:56
luego si yo aquí no he puesto un equals 00:37:57
en partícula 00:38:00
él va a usar el equals de object 00:38:01
y el equals de object va por dirección 00:38:03
con lo cual no va a borrar la partícula original 00:38:06
no la va a borrar 00:38:08
porque su dirección no es la dirección de esta 00:38:09
¿vale? 00:38:11
estos son los detalles en los que no perdáis 00:38:14
efectivamente, porque luego las aplicaciones 00:38:16
simplemente no funcionan 00:38:19
y hay veces que aplicaciones muy gordas 00:38:21
muy grandes, de mil cosas 00:38:23
no funcionan por cosas como estas 00:38:25
simplemente por cosas como estas, nada más 00:38:27
y uno se va a mirar a otra parte, se va a mirar 00:38:29
a los datos, se va a la base de datos, se va a mirar no sé qué 00:38:31
cuando es esto, ¿vale? 00:38:33
bueno, pues ya está 00:38:37
calcular por posiciones, hacer un mínimo 00:38:38
y partícula de mayor masa, pues hacer un máximo 00:38:43
pues venga, mostrar la partícula 00:38:45
con mayor masa, pues ya está 00:38:49
cogemos como una 00:38:50
partícula de mayor masa 00:38:53
pues cualquiera de ellas 00:38:55
la primera de todas 00:38:56
como es una lista 00:38:59
pues tengo la suerte de que puedo coger 00:39:01
la que me dé la gana, si fuera un set 00:39:04
no puedo coger una cualquiera, no es tan fácil 00:39:05
tengo que iterar siempre 00:39:07
y ahora ya me hago el máximo 00:39:08
pues para cada 00:39:11
partícula 00:39:14
P en partículas, ahora ya, esta partícula, su masa es mayor que esta primera, que la que tenga la mayor masa hasta ese momento, inicialmente la primera de todas, pues sí, es mayor, pues tengo una nueva partícula de mayor masa. 00:39:15
hala, ya está 00:39:38
sa igual a 00:39:39
y como aquí lo único que tengo que hacer es mostrar 00:39:48
no eliminar ni nada 00:39:51
el equals aquí en realidad me da igual 00:39:53
el equals me da igual 00:39:55
aquí lo único que tengo que hacer es mostrar 00:39:56
sí, pero ya lo tenía 00:39:58
tenía un twistring 00:40:02
en partícula, y si no se pone y ya está 00:40:03
ahí tiene un twistring 00:40:05
vale 00:40:08
y si no se pone y listo, y de nuevo no es pelo 00:40:08
que tengo que mostrar, sino mayor 00:40:12
más 00:40:13
vale, pues este era 00:40:14
el cuarto método, hacer un máximo 00:40:18
entonces eso tiene que estar claro 00:40:21
hacer un mínimo, saber 00:40:22
usar métodos, llamar a un método 00:40:25
desde otro lado 00:40:27
todos los matices de colecciones con los 00:40:28
IQUA, los HASCO, los métodos 00:40:31
que se usan, todo eso 00:40:33
y ya está, y eso es lo que tenía que 00:40:35
estar claro en este ejercicio, por eso 00:40:37
este ejercicio tenía peso en el resto de las RAs 00:40:38
porque incorporaba varias cosas 00:40:41
Aquí algunos 00:40:43
Me mostrabais no la partícula 00:40:46
Sino la mayor masa 00:40:49
Sin más 00:40:50
Entonces eso tampoco 00:40:51
Eso no es lo que se pide 00:40:54
Hay que hacer lo que se pide 00:40:57
Otra cosa es que al final damos puntos por casi cualquier cosa 00:40:58
Pero 00:41:02
No se puede dar todo lógicamente 00:41:03
Vale 00:41:06
Y este ya está 00:41:11
Y aquí no sé 00:41:13
Ah es que me falta un paréntesis 00:41:14
tercer ejercicio 00:41:16
más corto y rápido 00:41:21
imposible 00:41:24
y de hecho este de aquí como veis 00:41:24
es escribir cuatro líneas 00:41:29
en cada método 00:41:31
la más cercana 00:41:32
la más cercana es la que más tenía 00:41:35
claro, la más cercana 00:41:38
es la que más tenía 00:41:40
pero bueno, era hacer el mínimo 00:41:41
y darse cuenta de que tienes que usar ese método 00:41:43
pero nada más 00:41:45
y de añadir ya digo 00:41:46
lo de distinguir si ya está o no está 00:41:48
pues ya dijimos que eso ni lo contábamos 00:41:51
ni lo habíamos tenido en cuenta 00:41:53
vale, entonces el tercer ejercicio 00:41:54
una plantita 00:41:59
o varias 00:42:10
pues nada, una planta con nombre 00:42:12
y altura 00:42:15
hacer esta clase 00:42:16
ya por hacer la clase que no tenía nada 00:42:18
ya dábamos algo 00:42:21
si encima lo hacías bien implementando 00:42:22
comparable y todo eso ya 00:42:24
el colmo 00:42:26
venga 00:42:27
clase planta 00:42:29
bueno pues no sé cómo se llaman 00:42:31
las propiedades o cómo pero nos da igual 00:42:46
y si era dave lo era en la altura 00:42:48
pero me da igual también 00:42:50
altura 00:42:52
venga vamos a poner 00:42:54
un constructor 00:42:56
vale 00:42:57
solo por hacer esto ya dábamos algo 00:43:12
y esto no es lo que había que hacer 00:43:14
claro, pero 00:43:16
haz una planta con dos propiedades 00:43:18
planta, dos propiedades 00:43:21
vale, ahora 00:43:22
una aplicación 00:43:24
con tres 00:43:27
y mostrarlo por orden ascendente 00:43:28
solicitados al usuario 00:43:31
porque si no sois capaces de dárselos a Capone 00:43:33
y luego mostrarlo por orden ascendente según lo habéis 00:43:35
pues venga 00:43:37
el main, ya está 00:43:39
una colección 00:43:40
pues que colección 00:44:02
como vamos a implementar por orden 00:44:04
aquí la opción natural es 00:44:06
jolines lo único que yo voy a necesitar 00:44:08
va a ser un listado ordenado 00:44:10
de la colección 00:44:12
es mi único requisito 00:44:14
un listado ordenado 00:44:15
pues si tu único requisito es un listado ordenado 00:44:16
para eso está el triset 00:44:19
que directamente cuando tu iteras 00:44:20
te itera siempre de forma ordenada 00:44:23
¿según qué criterio? el que tú elijas 00:44:25
pues es justo lo que se adapta a lo que nos han dicho 00:44:28
una aplicación cuya única funcionalidad es un listado ordenado 00:44:31
pues ya está, si yo quiero un listado ordenado 00:44:34
vamos a hacer que planta 00:44:37
implemente comparable 00:44:39
de planta y ahora 00:44:47
¿qué orden es el que nos gusta? 00:44:50
si implementa comparable pues tiene que 00:44:53
implementar el método y ahora 00:44:56
¿qué orden es el que me interesa a mí? 00:44:59
pues orden ascendente 00:45:02
de menor a mayor 00:45:03
con lo cual el compare tú tiene que estar 00:45:04
en función de la altura 00:45:07
es decir, si la planta 00:45:08
dis que llama al método 00:45:11
su altura es menor 00:45:12
que esta planta o, me tiene que devolver 00:45:15
negativo, si la altura 00:45:17
de la que llama compare tú es la misma 00:45:19
que o, me tiene que devolver cero 00:45:21
y si la altura de la que llama compare tú 00:45:22
es mayor que o, me tiene que devolver positivo 00:45:25
con lo cual, hombre, la forma fácil de hacer esto es 00:45:27
return altura 00:45:30
menos o punto 00:45:32
altura 00:45:34
y ya está, como lo he puesto como dable 00:45:34
pues voy a tener que hacer un casting 00:45:38
entero, pero no pasa nada 00:45:40
¿vale? aquí lo único 00:45:41
hay un detalle 00:45:55
que aquí fallaría 00:45:57
en esta solución y tendríamos que optar por otra 00:46:00
que es, como yo he puesto 00:46:02
como la altura dable, si tengo una planta 00:46:04
que mide 1,3 00:46:06
y otro que mide 1,2 00:46:08
claro, me van a salir que son iguales 00:46:10
con lo cual cuando yo las añada 00:46:13
en el triset no la va a añadir 00:46:15
entonces las plantas 00:46:16
cuya diferencia es en decimales 00:46:18
esta aplicación no las consideraría 00:46:20
con lo cual usar un 00:46:23
dabble es un poco estúpido 00:46:24
porque va a considerar como iguales 00:46:26
si, yo he puesto 00:46:29
dabble porque no quería, me daba pereza 00:46:31
me había denunciado 00:46:32
altura máxima en metros 00:46:33
a ver, no lo dice, uno podría haber elegido 00:46:36
dabel y entonces esta opción no sería buena 00:46:39
pero a ver, daba igual, si lo hacía 00:46:40
no teníamos en cuenta eso 00:46:42
pero lo que me importa es que entendáis 00:46:44
que el método compare tú 00:46:46
te tiene que volver un entero, con lo cual si yo me baso 00:46:48
en esto, sin más 00:46:50
no va a distinguir plantas que se diferencian 00:46:52
solo en decimales 00:46:55
cuando yo haga el add 00:46:56
les va a parecer igual, no las va a añadir 00:46:58
en el add, entonces si me importa 00:47:01
esa situación, pues no me valdría 00:47:03
un tríceps. Tendría que hacer 00:47:05
una lista y luego 00:47:07
ordenar con sort. Eso ya sí. 00:47:08
Bueno, no tampoco. Tendría que hacer un comparator. 00:47:11
Bueno. En fin. 00:47:13
Estarían las mismas y luego en el 00:47:15
sort tiro de este. Estarían las mismas. 00:47:16
Pero a ver, 00:47:19
lo que quiero decir es que esto no nos importa ahora. 00:47:20
De hecho, nos importa 00:47:23
tampoco que en la solución 00:47:24
que vamos a subir, para no volvernos locos, 00:47:26
vamos a poner que es entero y se acabó la altura. 00:47:28
Y así no hay ningún 00:47:31
problema. Plantas con la misma 00:47:32
altura son la misma. 00:47:34
Entonces, yo no puedo meter dos plantas 00:47:38
con la misma altura en el 00:47:40
tríset. 00:47:42
¿Y aquí qué pasa? 00:47:47
Ah, claro, que al cambiar el 00:47:48
int e int 00:47:49
y sigue habiendo algo rojo aquí. 00:47:54
Y ahora ya sí. 00:48:04
Pues ya está. Hacemos un tríset 00:48:05
y apañao. 00:48:07
Uy. 00:48:17
ala, se piden los datos por teclado 00:48:17
el escáner, etc 00:48:34
pero bueno, da igual 00:48:36
vale 00:48:38
repito, se pedirían por teclado 00:49:00
en realidad, pero vamos, aquí para comprobar 00:49:03
simplemente que esto funciona 00:49:05
las pongo 00:49:07
así se acabó 00:49:09
y 6, por ejemplo 00:49:16
vamos a poner 00:49:18
y voy a poner un toString 00:49:19
en planta, un toString para cuando lo muestre 00:49:21
y ahora ya como es un triset 00:49:24
ya sabemos que cualquier 00:49:34
iteración que hagamos los va a mostrar 00:49:35
por el orden del compareTo 00:49:38
pues ya está 00:49:39
y ya está el ejercicio 00:49:41
a falta de que esto se lee por teclado en realidad 00:49:51
pero bueno 00:49:53
vale, pues aquí están ordenadas 00:49:54
4, 6 y 7 00:49:58
Pues igual 00:49:59
Vale, pues completo 00:50:04
Que uno se hace una lista 00:50:06
Y luego ordena 00:50:09
El comparado lo tiene que hacer igualmente 00:50:10
Por lo que hemos visto nosotros 00:50:12
El comparado lo tiene que hacer igualmente 00:50:14
Los pequeños flecos que se nos han quedado colgando 00:50:15
Del comparado y todo no sé qué 00:50:19
Ya los vamos incorporando en diferentes aplicaciones 00:50:20
Que vayamos haciendo 00:50:23
Bueno, pues examen completo 00:50:24
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:
7
Fecha:
26 de febrero de 2025 - 12:55
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
50′ 33″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
252.38 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid