Saltar navegación

20250206 Ejer1_Colecciones_2 - Contenido educativo

Ajuste de pantalla

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

Subido el 6 de febrero de 2025 por Raquel G.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

venga vamos a seguir con lo que nos faltaba pero bueno ahora ya sí que se 00:00:00
hace siempre lo mismo todo el rato mostrar porcentaje de aprobados de un 00:00:09
profesor bueno pues nada vamos a hacer el método 00:00:13
mostrar porcentaje de aprobados en lugar de mostrarlo por consola vamos a hacer 00:00:20
que lo devuelva como valor de retorno así la aplicación que decida si lo 00:00:24
muestra, lo lleva a una interfaz gráfica, lo que le dé la gana. Porcentaje de aprobados, 00:00:29
¿de quién? De un profe, nos han dicho. Pues entonces ese será nuestro dato, el NIF del 00:00:39
profesor. ¿Dónde están nuestros datos? Nuestros datos están en una cajita de profesores, 00:00:46
¿qué hay que pasar? Pues este muy fácil. De nuevo tendremos que localizar al profe, 00:00:53
Vamos a hacer una suma acumulativa, vamos a localizar al profesor, pues ya está. 00:01:08
Vamos a recorrer con un for each nuestra caja. 00:01:14
Un rollo, si esto fuera un diccionario, un mapa, pues sería más fácil, 00:01:22
pero como no lo es, pues vamos en nuestra cajita dato por dato. 00:01:26
Profesores, y ahora, si el profesor en el que estamos, su NIF es igual al NIF del profesor objetivo, 00:01:31
ahora ya es cuando empezamos la suma acumulativa, para calcular el porcentaje. 00:01:45
vamos a contar los aprobados 00:01:54
y ahora ya pues ya está 00:01:59
lo de siempre, vamos a recorrer la lista 00:02:06
entonces para variar 00:02:08
un poco, para variar, vamos a recorrer 00:02:10
la lista con 00:02:11
en lugar de con un for each, con un for de índice 00:02:12
porque la lista 00:02:15
getAlumnos es un 00:02:16
list, entonces 00:02:18
vamos a recorrer para variar con un 00:02:21
for de índice 00:02:23
a menor que 00:02:24
p.getalumnos.size 00:02:27
vale, pues vamos a recorrer esta lista 00:02:32
si p.getalumnos.geti 00:02:38
el alumno en la posición i 00:02:45
resulta que su nota 00:02:47
es mayor o igual que 5 00:02:49
pues ala, el alumno está aprobado 00:02:54
lo contamos 00:02:57
como siempre hemos hecho, ya está 00:02:58
cuando este fuera terminado 00:03:02
ya tenemos el porcentaje de aprobados 00:03:03
que podremos devolver así a lo bestia 00:03:06
con este 00:03:08
retun 00:03:10
que será 00:03:12
pues 00:03:16
cont por 00:03:17
100 00:03:19
entre 00:03:22
peguetalumnos 00:03:24
.6, vale, pues ya está 00:03:28
ese es el porcentaje de alumnos aprobados del total 00:03:40
entonces de nuevo, podríamos no haber salido por aquí 00:03:43
del método, podríamos no haber salido por aquí 00:03:48
porque nunca hubiéramos entrado en este if 00:03:51
nunca hubiéramos entrado aquí, con lo cual si nunca hubiéramos entrado en este if 00:03:56
porque el profesor no existe, pues no tendríamos la cuenta 00:04:00
Entonces aquí tenemos que decidir qué devolvemos en este caso. 00:04:04
Bueno, pues ala, podríamos hacer devolver cero. 00:04:08
Esto se queda un poco confuso en realidad, porque cuando el método devuelva cero, ¿qué significa? 00:04:11
¿Que el profesor tiene cero aprobados o que no hemos encontrado al profesor? 00:04:18
Se queda un poquito confuso, entonces lo mejor sería devolver, por ejemplo, menos uno, 00:04:25
porque menos uno no es un porcentaje válido. 00:04:32
Entonces ahora ya este método devuelve menos uno si no hemos encontrado al profesor y si lo hemos encontrado devuelve su porcentaje de aprobados, que podría ser cero. 00:04:34
Entonces esto siempre en un caso real, pues lo documentaríamos, claro, y diríamos, oye, avisaríamos menos uno si no existe el profe. 00:04:43
y así el que luego usa nuestro método 00:04:56
pues ya se le va a desplegar esta ayuda 00:04:59
y dice, ah, vale, si me devuelves menos uno 00:05:02
es que el profesor no existe 00:05:04
entonces ya puedo avisar, no existe el profesor 00:05:06
vale, pues nada, porcentaje de aprobados 00:05:08
listo, si no me equivoco 00:05:13
damos un alumno 00:05:14
dime los nombres de los profes que lo tienen 00:05:18
pues venga 00:05:21
un método, vamos a hacer una cosa 00:05:22
que los nombres de los profes que lo tienen, pues lo vamos a meter 00:05:26
en una lista. Aquí va a ir la lista de los nombres 00:05:30
de todos los profesores que lo tienen. Pues ya está. 00:05:34
Profesores de un alumno. 00:05:40
En lugar de los NIFs, los nombres. 00:05:43
Un poquito lo estamos haciendo para practicar, mezclar cosas distintas. 00:05:46
Entonces, imaginaos que hubiera dos profesores 00:05:51
diferentes, distinto NIF 00:05:54
pero el mismo nombre, los dos se llaman 00:05:56
Álvaro López 00:05:59
pues entonces 00:06:00
si yo en este list 00:06:02
me aparecerá dos veces Álvaro López 00:06:04
¿vale? 00:06:07
profesores de alumno, ¿de qué alumno? 00:06:12
pues de este 00:06:15
¿dónde está mi cajita de datos? 00:06:16
se la tengo que pasar 00:06:21
porque es local a mi main 00:06:22
Aquí la tenemos, mi cajita de datos 00:06:24
Y otra vez lo mismo, un rollo 00:06:38
Tenemos que iterar para encontrar al profesor 00:06:44
Si los profesores estuvieran en lugar de en un conjunto, en una lista 00:06:47
Podríamos hacer todo el rato esto que hemos hecho aquí 00:06:53
Sacar la posición con indexOf 00:06:56
Y una vez que tenemos la posición, recuperarlo con el get 00:06:59
sacaríamos con index of la posición del profesor 00:07:02
con ese nif 00:07:07
y ya lo recuperaríamos con get 00:07:08
pero como es un conjunto 00:07:16
lo que pasa es que 00:07:18
aquí no es recuperar un profesor por nif suyo 00:07:19
aquí pueden ser muchos profesores 00:07:30
luego aquí sí que tenemos que iterar, sí o sí, tenemos que iterar, e ir metiendo en la lista todos aquellos que contengan este alumno, pues ya está, pues esto ahora ya sí que iteramos, para todos los profesores de mi caja, ¿cuál va a ser mi resultado?, mi resultado va a ser una lista de string, de nombres de profesores, 00:07:32
vale, esta lista, venga, para variarla 00:08:00
voy a instanciar como ArrayList 00:08:03
como se supone que van a ser poquitos nombres 00:08:04
un Array siempre es 00:08:06
un poquito más 00:08:08
eficiente, salvo si los datos 00:08:10
son muy grandes 00:08:13
crea teclas ArrayList 00:08:13
esto sí 00:08:17
vale, pues ahora ya sí 00:08:20
iteramos por cada profe 00:08:22
y ahora simplemente habrá que ver 00:08:25
oye, tú profe, P, ¿contienes en tu lista 00:08:26
de alumnos 1 con este nif? Pues ala, tu nombre a la lista. Pues ya está, esto ya hemos visto 00:08:29
el contains. Vamos a ver, alumnos de este profep. Alumnos de este profep contienen un 00:08:36
alumno igual a este, un alumno igual a este que tiene nif alumno. Me da lo mismo el nombre 00:08:44
que ponga aquí, me da igual la nota que ponga aquí 00:08:56
¿eh? oye, colección de alumnos de profe 00:08:59
¿contiene a uno igual a este? esto me da igual 00:09:04
porque insisto, el contains va a mirar el criterio 00:09:08
de igualdad que está en equals y ese solo tira de alumno 00:09:12
pues sí, oye, y lo contiene, hay un alumno con ese nombre ahí 00:09:16
pues ala, entonces, a mi lista nombres vamos a añadirle 00:09:20
el nombre del profe 00:09:25
y punto pelota. 00:09:27
Ya está. 00:09:32
Cuando este fuera terminado 00:09:34
devolvemos el resultado. 00:09:35
Puede estar vacío 00:09:39
si no hubiera ningún profe que contenga al alumno. 00:09:40
Puede estar vacío. 00:09:42
Pero no nulo. Siempre mejor devolver nulos 00:09:43
peligrosos por los null pointer exception. 00:09:45
No es nulo. 00:09:49
Lo peor que me puede ocurrir 00:09:49
es devolver una lista vacía. 00:09:52
¡Hala! Pues este 00:09:55
muy fácil. 00:09:55
Nib de un profe, vamos a ordenar alfabéticamente a los alumnos, venga, dado el Nib de un profe, mostrar un listado alfabético de los alumnos, esto está así, pues venga, un método estático, vale, 00:09:57
vamos a hacer una cosa vamos a hacer que me devuelva una lista de alumnos que van a ser 00:10:24
los alumnos de ese profe ordenados alfabéticamente por nombre listado ordenado de quien pues listado 00:10:34
ordenado de un profesor vale y de dónde saco yo los datos para trabajar saco los datos para 00:10:47
trabajar de esto, para trabajar de esto, vale, bueno, pues entonces, vale, vamos a localizar 00:10:58
al profe, de nuevo, sí o sí, tenemos que localizar al profe con ese need, y como esto 00:11:21
es un map, como esto no es un mapa, no puedo localizar por clave, como es una lista, no 00:11:27
puedo sacar la posición con el index 00:11:32
of, pues no hay tutía 00:11:35
a recorrer 00:11:36
la caja 00:11:38
vamos a encontrar 00:11:39
el profesor 00:11:42
que estoy buscando, que es aquel 00:11:44
cuyo nif sea igual a este 00:11:46
sea igual 00:11:49
a este que me han dado 00:11:53
una vez que lo he 00:11:54
encontrado, resulta que yo aquí ya tengo 00:11:56
esta lista suya 00:11:59
¿vale? esto es una 00:12:00
lista la lista de sus alumnos bueno pues entonces la lista ya sabemos que tiene un montón de métodos 00:12:03
muy bonitos y muy interesantes que nos permiten hacer un montón de cosas y todo estupendo vale 00:12:09
pues en particular tiene un método short tiene un método short que ya hemos mencionado con la 00:12:16
clase a raíz la clase a raíz tenía un método estático short que ya usamos pero bueno ahora 00:12:25
esto es otra cosa porque esto es un método no estático de la clase list vale pues list tiene 00:12:30
un método ordenar que ordena esta lista es decir los mueve de sitio los mueve de sitio para que 00:12:38
estén ordenados pero qué significa estar ordenados pues no lo sé depende de cómo ordenó yo los 00:12:46
alumnos por orden alfabético de ni por altura por orden alfabético de nombre por nota como los 00:12:55
ordeno? Pues habrá 00:13:01
que decírselo a sort cómo los ordeno 00:13:03
porque si no se lo digo 00:13:05
pues él no va a saber cómo ordenar. 00:13:06
El compilador se ha quedado muy tranquilo 00:13:09
pero cuando luego ejecutemos esto 00:13:11
si yo no le he dicho cómo ordenar los 00:13:13
alumnos, me va a decir 00:13:15
eh, alumnos 00:13:16
incomparables, no puedo comparar uno con otros. 00:13:18
Vale, 00:13:22
pues entonces, ¿cómo indico 00:13:23
yo cómo 00:13:25
ordenar los alumnos? ¿Cómo 00:13:26
indico yo el criterio de ordenación? 00:13:29
Bueno, pues entonces alumno, si yo quiero que los alumnos sean ordenables, se puedan ordenar entre sí, 00:13:31
la clase alumno tiene que adquirir el comportamiento de ser comparable, de ser ordenables, de ser comparables unos a otros. 00:13:39
¿Cómo se adquieren los comportamientos? 00:13:46
Implementando las interfaces que los reflejan. 00:13:49
Pues tenemos una interfaz comparable, que ya hemos mencionado alguna vez, 00:13:53
que es una interfaz 00:13:56
que quien la implementa 00:13:58
se convierte en objeto 00:14:00
capaz de ser ordenado con sus iguales 00:14:02
de ser menor que, mayor que 00:14:05
con sus iguales 00:14:07
claro, implementando el método correspondiente 00:14:08
de la interfaz, si implementamos una interfaz 00:14:11
hay que dar cuerpo a sus métodos 00:14:12
pues habrá que dar cuerpo a ese método 00:14:14
vale, entonces 00:14:15
comparable es una clase genérica 00:14:18
yo la puedo 00:14:21
poner así sin más 00:14:23
Pero entonces estaría diciendo con esto que un alumno puede ordenarse y compararse con un objeto de cualquier otra clase 00:14:25
Un alumno puede compararse para ser ordenado con un profesor, con una mesa, con un gato 00:14:33
No es el uso 00:14:39
Normalmente cuando yo ordeno, o ordeno solo alumnos entre sí, o ordeno solo profesores, o ordeno solo gatos 00:14:40
entonces 00:14:48
vamos a especificarle a la clase 00:14:50
genérica comparable 00:14:52
tú 00:14:53
que alumno 00:14:55
es una clase que va a ser capaz 00:14:58
de ser comparable pero 00:15:00
solo con sus iguales 00:15:02
con otros de la clase alumno 00:15:04
solo con otros de la clase alumno 00:15:06
no comparable con cualquier 00:15:08
otra cosa, solo 00:15:10
comparable con objetos de la clase alumno 00:15:12
vale 00:15:14
Ya hemos parametrizado la interfaz comparable 00:15:15
Estamos obligados a dar código al método que está sin implementar 00:15:19
Y aquí en este método yo ya decido mi criterio de ordenación 00:15:25
Entre el alumno que llama el método y el alumno pasado por parámetro 00:15:30
¿Alfabético de nombre? 00:15:33
Pues no sé, ¿qué me han dicho aquí? 00:15:36
Alfabético de nombre, sí, sobreentiendo que alfabético de nombre 00:15:39
vale, pues recordad que este método 00:15:42
tiene que devolver 00:15:44
menos uno o negativo 00:15:45
si el que llama al método va antes 00:15:47
que el pasado por parámetro 00:15:49
cero, si son el mismo 00:15:51
y uno 00:15:53
si el que llama al método 00:15:55
va después que el pasado por parámetro 00:15:58
ir antes o después 00:16:00
aquí es en función de la propiedad 00:16:03
nombre 00:16:05
y comparar alfabéticamente 00:16:06
dos string 00:16:08
sabemos que lo podemos hacer 00:16:09
es decir, este string 00:16:11
dis.nombre 00:16:12
por ser un string 00:16:14
tiene entre muchos métodos 00:16:17
uno que se llama compareTo 00:16:19
que si yo le paso otro string 00:16:22
como este 00:16:25
pues compareTo es un método de la clase string 00:16:27
que me devuelve menos uno 00:16:30
si este nombre está alfabéticamente antes que este 00:16:32
cero si este es el mismo que este 00:16:36
y más 1 si este está alfabéticamente después que este. 00:16:39
Pues es justo lo que yo quiero hacer en este compareto. 00:16:44
Bueno, pues entonces voy a devolver directamente esto. 00:16:46
Y ya tengo el código que quería. 00:16:51
Un código que me devuelve menos 1 si el objeto alumno dis que llama al método 00:16:53
está alfabéticamente por nombre antes que este. 00:16:58
0 si alfabéticamente por nombre están junticos. 00:17:02
y más uno si este objeto dis está alfabéticamente por nombre 00:17:06
después que este objeto justo, ya tengo lo que quería 00:17:11
pues entonces, como alumno ya implementa la interfaz 00:17:15
comparable para ser comparado con sus iguales alumno 00:17:20
este método cuando yo lo ejecute, el sort 00:17:23
va a saber cómo ordenar, y qué va a hacer, recolocar esta colección 00:17:27
recolocarla enterita, y ahora va a dejar a los alumnos del profesor 00:17:31
alfabéticamente colocados 00:17:36
los va a dejar ya colocados alfabéticamente 00:17:37
si yo no quisiera que tocara 00:17:40
la colección de alumnos 00:17:43
y simplemente me devolviera otra 00:17:46
ordenada alfabéticamente 00:17:49
podría copiar esta colección en una 00:17:50
y ordenar esa 00:17:52
y ya está, pero bueno, me da igual 00:17:53
lo voy a dejar así 00:17:55
para que la propia colección de alumnos del profesor 00:17:56
ya se quede ordenada 00:17:59
tampoco pasa nada, porque se quede ordenada 00:18:00
vale, pues una vez que 00:18:02
Hemos terminado 00:18:04
Ya yo devuelvo 00:18:06
La colección ordenada 00:18:09
¿Vale? 00:18:12
Ah, perdón, que tengo que 00:18:16
Hacerlo aquí porque estoy dentro del for each 00:18:19
Claro 00:18:24
Vale 00:18:24
Retune 00:18:28
P.getAlumns 00:18:31
Vale 00:18:34
Entonces repito, con este método 00:18:35
No solo estamos devolviendo 00:18:37
una colección de alumnos ordenados alfabéticamente del profe 00:18:39
sino que además estamos ya alterando la propia colección de alumnos del profe 00:18:43
y la estamos ya dejando ordenada. Repito, si no quisiéramos alterar 00:18:47
esta colección de alumnos, sino simplemente devolver una 00:18:51
con eso a unos ordenados, pues nos haríamos una copia y devolveríamos la copia 00:18:54
o sea, nos haríamos una copia, ordenaríamos la copia y devolveríamos la copia 00:18:58
pero bueno, depende de lo que queramos hacer. Vale, ¿qué ocurre 00:19:02
si yo he llegado a este punto 00:19:07
sin salir por este retún, que no encontré 00:19:09
al profesor 00:19:11
si no encontré al profesor, pues bueno 00:19:11
tiene sentido que me devuelva yo un null 00:19:15
a lo mejor, y que este método 00:19:16
pues yo puedo hacer 00:19:19
yo aviso 00:19:20
claro, para que el que lo usa 00:19:23
sepa cómo usarlo, null 00:19:24
si no existe el profe, por ejemplo 00:19:26
así el que 00:19:29
lo use, ya sabe 00:19:31
que cuando esto devuelva null 00:19:32
es que el profesor no existe, luego no tiene 00:19:35
sentido 00:19:36
devolver un listado ordenado porque no existe 00:19:37
vale 00:19:41
más métodos 00:19:43
eliminar alumno de un profe 00:19:48
vale, hasta ahora hemos añadido y consultado 00:19:50
pero no hemos eliminado elementos 00:19:52
de una colección 00:19:54
y si se tiene que poder 00:19:55
obviamente una colección es 00:19:59
algo para guardar datos 00:20:00
tenerlos ahí guardaditos 00:20:02
con orden o sin orden 00:20:03
depende de lo que nos interese 00:20:05
y consultarlos 00:20:07
de vez en cuando, para ver, ah, este profe 00:20:10
que estaba aquí con Niftal, ¿qué alumnos tiene? 00:20:12
ah, pues para hacer consultas sobre lo que hay ahí 00:20:14
pero también tenemos que poder eliminar cosas 00:20:15
de ellos, de las cajas, obviamente 00:20:17
tenemos que poder eliminar cosas 00:20:19
bueno 00:20:20
vale, bueno, antes de pasar a ese método, que no he 00:20:22
incidido en ello, este 00:20:25
método sort de ordenar 00:20:27
tiene sentido y existe 00:20:29
solo en las listas, obviamente 00:20:31
porque las listas 00:20:33
son las colecciones 00:20:34
que tienen un orden 00:20:37
¿vale? que tienen 00:20:39
cada elemento en una 00:20:40
posición 00:20:43
entonces tiene sentido 00:20:43
una acción en la que yo los cambie de posición 00:20:46
como lo que hace 00:20:49
short, short los cambia de posición 00:20:50
para mostrármelos con otro 00:20:52
orden, en un conjunto 00:20:55
en un set, el método 00:20:56
short no tiene sentido 00:20:58
porque están todos a mogollón 00:21:00
¿vale? están todos a mogollón 00:21:02
Otra cosa es que 00:21:04
Cuando yo itero por un set 00:21:07
Itere con algún tipo de orden o no 00:21:10
Pero eso ya tiene que ver con el preset 00:21:13
Que todavía no hemos mencionado 00:21:15
Pero en un conjunto 00:21:16
Lo que tenemos que ver ahora a priori 00:21:19
Es que está todo ahí a mogollón metido 00:21:21
Entonces no tiene sentido 00:21:23
Ahora los voy a ordenar por color de ojo 00:21:24
Pero que vas a ordenar si están todos ahí a mogollón 00:21:26
No hay ninguna posición en la que ponerlos 00:21:28
Venga 00:21:30
Pues estábamos diciendo que nos faltaba eliminar un alumno de un profe. 00:21:32
Eliminar un alumno de un profe, ya que estamos en plan valor boolean de control para ver si algo existe o no. 00:21:40
Pues lo ponemos. 00:21:46
Eliminar alumno. 00:21:49
¿De quién? Pues de un dato. 00:21:52
Profesor. 00:21:59
¿Qué alumno vamos a eliminar de ese profesor? 00:22:00
Pues este. 00:22:07
¿Dónde están mis datos? 00:22:10
Qué suerte, todavía estaba en el portapapeles. 00:22:12
Aquí está mi cajita de datos. 00:22:17
Bueno, pues estamos en las mismas una y otra vez. 00:22:19
Vamos a tener que recorrer mi lista de profesores hasta encontrar el profesor objetivo. 00:22:22
Y estamos en las mismas. 00:22:34
si este es mi profesor objetivo 00:22:39
si este es mi profesor 00:22:42
objetivo 00:22:51
el cual 00:22:51
tiene como propiedad nif una 00:22:54
igual a esta 00:22:56
pues entonces ahora resulta que tendrá una lista de alumnos 00:22:57
vacía o no 00:23:01
pero bueno tendrá una lista de alumnos 00:23:03
y yo de esta lista quiero 00:23:04
eliminar un alumno 00:23:06
igual a este 00:23:08
un alumno igual a este 00:23:10
hombre pues magnífico 00:23:12
Porque mi clase list, collection en general, tiene un método estupendo que es remove, ¿vale? 00:23:14
Y remove, ¿qué hace? 00:23:23
Tú le pasas un objeto y remove te borra. 00:23:25
Ahora, la primera instancia que ha encontrado en esta lista igual a ese objeto. 00:23:29
La primera que ha encontrado. 00:23:37
si hubiera más iguales a ese objeto 00:23:38
que podría verlo, porque esto es una lista 00:23:42
luego podría ver varios alumnos con ese nif 00:23:44
te borra solo la primera 00:23:47
si yo vuelvo a hacer otro remove 00:23:50
te borra la primera que encuentra 00:23:52
que sería la segunda que quedó de antes 00:23:55
luego importante, cada remove 00:23:57
te borra solo una instancia igual a esta 00:24:00
que es la primera que encuentra 00:24:03
si hay más instancias iguales a esta las deja 00:24:05
habría que hacer sucesivo remove, podríamos meterlo en un while 00:24:09
y este remove aparte te devuelve true o false 00:24:13
en función de si ha hecho una eliminación efectiva o no la ha hecho 00:24:17
porque no ha encontrado nada igual, bueno por lo pronto vamos a pasarle 00:24:21
un objeto igual que queremos borrar, pues newAlumno 00:24:24
newAlumno y el nombre es que nos da lo mismo 00:24:29
y la nota nos da lo mismo, porque el remove te borra un alumno igual a este de aquí 00:24:33
y la igualdad la va a mirar exclusivamente en función de esta propiedad. 00:24:41
Luego me da igual lo que ponga aquí, ¿vale? 00:24:48
Pero eso sí, al remove hay que pasarle un objeto alumno. 00:24:51
Venga, pues ya está. 00:24:55
Entonces este remove, además de hacer la eliminación, 00:24:57
Si es que encuentra alguno con un if igual a ese, te devuelve true si realmente hizo la eliminación o false si no. 00:25:00
Pues vamos a aprovechar ese valor para ponernos el retorno. 00:25:08
Y ya está. 00:25:11
¿Qué ocurre si hemos llegado a este punto? 00:25:13
Si hemos llegado a este punto es porque en ningún momento hemos encontrado un profesor con ese if. 00:25:17
Luego, si no hemos encontrado un profesor con ese if, o directamente que no hay profesores, luego no ha entrado nunca aquí, 00:25:21
Pues no ha borrado nada, está claro 00:25:26
Porque no hay ni profesor ni nada 00:25:29
O puede haber encontrado 00:25:31
Bueno, no, sí, si ha encontrado profesor 00:25:33
Y no tiene alumno, este ya sale por falso 00:25:35
Vale, si no ha encontrado al profesor 00:25:37
O es que ni hay profesores 00:25:39
Hemos llegado a este punto 00:25:41
Tenemos que seguir devolviendo algo 00:25:42
Pues en este caso devolveremos falso 00:25:45
Porque no hemos encontrado nada 00:25:47
Vale 00:25:49
Pues estas serían 00:25:53
Todas las funcionalidades del ejercicio 00:25:55
Ahora, deberíais vosotros probarlas en un main, ¿vale? 00:25:58
Probar en un main, a ver, insertar alumnos con un menú, poner nota a un alumno, etc. 00:26:04
Para verificar que realmente están bien, porque puedo haberme equivocado en alguna cosa, 00:26:10
que es la alguna excepción, para verificar que realmente están bien. 00:26:15
Entender bien todo esto, claro. 00:26:19
Y continuar haciendo ejercicios, ¿vale? 00:26:21
Todo esto lo podéis hacer 00:26:25
Todo esto lo podéis hacer 00:26:28
Esto es hacerse una propia 00:26:31
Una propia 00:26:32
Vale 00:26:33
Esto también 00:26:34
Ah no, esto ya es un map 00:26:37
Esto tiene map 00:26:38
Y bueno, aquí hay 00:26:43
Y esto 00:26:44
Tiene excepciones 00:26:47
Pero este de aquí 00:26:49
Por ejemplo, este de aquí 00:26:54
Hacedlo sí o sí 00:26:55
¿Vale? Que es similar 00:26:56
similar o más fácil que el que hemos hecho 00:26:58
¿vale? porque tiene solamente una clase 00:27:02
¿vale? una clase que tiene un conjunto de objetos 00:27:04
entonces lo ideal sería hacer este ejercicio 00:27:09
de tal manera, una versión en la cual 00:27:13
los discos que tiene la discoteca sean una lista 00:27:16
y otra versión en la que los discos que tenga la discoteca sean un conjunto 00:27:19
¿vale? y ver si hay algunas diferencias 00:27:23
que podamos aplicar entre una versión y otra. 00:27:28
Vale, pues venga, lo dejamos aquí. 00:27:32
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:
17
Fecha:
6 de febrero de 2025 - 11:57
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
120.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid