Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 05-03-24 - 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 6 de marzo de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, a ver 00:00:00
como estoy usando los paquetes 00:00:02
para distinguir los ejercicios entre sí 00:00:04
pues no voy a hacer 00:00:06
paquetes para entidades, lógica 00:00:08
etcétera, como es lo que se hace 00:00:10
en una situación habitual 00:00:12
pero bueno, a nosotros eso ya 00:00:13
como lo tenemos clarísimo, no tenemos que hacerlo 00:00:16
todo el rato para demostrarlo 00:00:18
pues nada, ejercicio 3 00:00:20
habréis hecho la clase 00:00:22
profesor, que la clase 00:00:24
profesor habréis 00:00:29
no tiene nada más que 00:00:31
el NIF y el nombre 00:00:35
y la lista, claro 00:00:39
la lista de alumnos 00:00:42
aquí siempre se nos va a plantear la duda 00:00:59
de esta propiedad alumnos 00:01:09
la dejo ya inicializada a una lista vacía 00:01:12
bueno, normalmente es recomendable 00:01:15
por lo de siempre 00:01:18
para que 00:01:19
alumnos no sea null nunca 00:01:21
porque si tenemos objetos que no son null 00:01:23
mejor 00:01:26
para que no nos den null pointer exception 00:01:27
si alguien los maneja mal 00:01:29
descuidadamente y no los instancia antes 00:01:31
entonces como estamos poniendo siempre 00:01:34
linked list 00:01:36
porque yo le tengo 00:01:37
un poco más cariño que a write list 00:01:40
pues como siempre ponemos linked list 00:01:41
vamos a variar, vamos a poner a write list 00:01:43
el uso es el mismo 00:01:45
salvo unos cuantos matices 00:01:47
que al final de esto 00:01:50
podemos comentar para dejarlo completo 00:01:52
pero el uso es el mismo 00:01:55
insertar, recuperar en una posición 00:01:56
con el get, lo de siempre 00:02:00
pues venga 00:02:01
entonces los alumnos 00:02:03
la clase alumno 00:02:05
pues la clase alumno 00:02:09
que propiedades le habréis puesto 00:02:11
pues a ver, vamos a cerrar esto 00:02:12
la clase alumno le habréis puesto 00:02:14
ni fin hombre, ya está, un ejercicio sencillo 00:02:18
para practicar esto simplemente 00:02:21
que todos deberíais haber hecho ayer por la tarde 00:02:23
entonces el alumno ya no depende de nadie 00:02:27
pues le habréis puesto el constructor 00:02:41
los get y set 00:02:42
entonces aquí ya nos podemos adelantar y avanzar 00:02:48
como estamos caracterizando a una entidad 00:03:00
que es un alumno, lo estamos caracterizando 00:03:02
vamos a caracterizarlo del todo 00:03:04
entonces ya hemos caracterizado 00:03:06
sus propiedades 00:03:08
lo que lo identifica, el NIF y el nombre 00:03:10
el siguiente paso 00:03:12
¿vale? y algo de eso 00:03:14
lo identifica de forma única 00:03:16
¿vale? una cosa es la 00:03:17
información 00:03:20
la información es NIF y nombre 00:03:21
y luego otra cosa es la 00:03:24
metainformación 00:03:26
concepto que también 00:03:27
tenéis que conocer, metainformación 00:03:30
¿metainformación qué significa? 00:03:31
información 00:03:35
sobre la información, es decir, la información es NIF y nombre, 00:03:35
la información del alumno, y la meta información es cómo interpreto 00:03:40
yo esos datos, es información sobre la información, bueno pues 00:03:44
como parte de la meta información sería, oye NIF resulta 00:03:47
que yo sé, porque sé lo que es un NIF en la vida real, sé que 00:03:51
cada uno tiene un NIF único, lo sé, el nombre no, 00:03:56
lo del nombre lo repetimos, pero el NIF no, 00:04:01
entonces 00:04:03
estos atributos 00:04:04
además podemos extraer de ellos 00:04:06
que este va a ser único para los alumnos 00:04:09
eso automáticamente 00:04:11
nos permite decir 00:04:13
pues voy a hacer aquí un equals 00:04:14
para que a todos los efectos 00:04:16
de cara al resto del universo 00:04:18
a todos los efectos 00:04:20
dos alumnos con el mismo NIF sean iguales 00:04:22
entonces si incorporamos el equals 00:04:24
incorporamos esa 00:04:26
caracterización añadida de igualdad 00:04:28
y eso le va a ser muy útil a cualquiera 00:04:30
que trabaje con alumnos 00:04:32
porque si necesita en algún momento 00:04:34
distinguir si dos objetos son iguales 00:04:36
ya va a poder, si no ponemos un equals 00:04:38
no va a poder, entonces no se trata 00:04:40
solo de 00:04:42
decidir que propiedades 00:04:43
caracterizan a cada alumno, sino incorporar 00:04:46
toda la información que es útil para trabajar 00:04:48
con ellos, pues aquí es útil 00:04:50
incorporar mediante un equals 00:04:52
que dos alumnos con el mismo 00:04:54
nif son iguales 00:04:56
¿vale? siempre y cuando 00:04:57
pueda concluirlo 00:05:00
que en este caso está claro 00:05:01
bueno, pues entonces esto quedaría mucho más bonito 00:05:04
si uno se hace 00:05:06
un equals 00:05:08
basado en if 00:05:10
el hashCode fuera 00:05:11
no nos gusta por ahora 00:05:15
¿vale? 00:05:17
¿que vamos a mostrar datos de alumnos 00:05:20
en algún momento? pues también 00:05:22
es una buena costumbre poner un toString 00:05:24
como aparece en casi todas las clases 00:05:26
un toString que si alguien llama un 00:05:28
system.println o cualquier cosa 00:05:30
en lugar de ponerle el toString de equals 00:05:31
que es una arroba extraña 00:05:34
pues pone lo que uno quiera 00:05:35
bueno, pues buena costumbre 00:05:37
poner un toString con el aspecto que a uno le dé la gana 00:05:39
el que nos ofrece Eclipse 00:05:42
es este 00:05:46
¿nos gusta este? pues sí, no hombre ya está 00:05:47
¿no nos gusta? pues lo cambiamos 00:05:50
ah, el alumno está 00:05:52
y profesor ya tiene las propiedades 00:05:54
importamos list 00:05:57
array list 00:05:58
estamos repitiendo lo mismo 00:05:59
una, una y otra vez 00:06:02
así que si no os queda después de esto 00:06:04
tenéis un problema de fósforo 00:06:06
vale 00:06:09
a ver 00:06:11
ya tenemos las propiedades 00:06:12
pues lo de siempre, un constructor 00:06:15
aquí 00:06:17
meter en el constructor 00:06:19
la colección 00:06:22
pues quizá lo mismo que he dicho otras veces 00:06:24
pues a lo mejor es poco práctico 00:06:27
porque lo natural es que cuando uno 00:06:29
da de alta a un profesor porque ha llegado al instituto 00:06:31
da de alta a un profesor, da de alta al profesor 00:06:33
con su nifo y su nombre y los alumnos 00:06:35
irán llegando, entonces en el momento 00:06:37
de instanciar el profesor que se hace con el 00:06:39
constructor, pues ahí una situación 00:06:41
habitual es que solo tenga 00:06:43
en ese momento nif y nombre, entonces 00:06:45
tiene sentido hacer un constructor con nif y nombre 00:06:47
pero de nuevo todas estas cosas 00:06:48
se hacen después 00:06:51
de haber hecho toda esa fase de análisis en las que 00:06:53
se ha entendido 00:06:55
cuál es la situación real en la que se va a trabajar 00:06:56
entonces pues se va a trabajar una secretaría 00:06:58
Un profe llega que le acaba de mandar la consejería 00:07:01
Venga, que te doy de alta 00:07:03
Ya está, te doy de alta con nifinombre 00:07:04
Pues un constructor con nifinombre 00:07:07
Luego, como siempre he dicho 00:07:08
No es que haya la forma buena 00:07:21
Y la forma mala de hacer las cosas 00:07:23
Hay la forma 00:07:25
Que resuelve una situación 00:07:27
Y la forma que 00:07:29
No la resuelve un poquito peor 00:07:30
Ya está, no hay ni buena ni mala 00:07:33
Si no hay situaciones distintas 00:07:35
Vale, faltarían aquí los get y set 00:07:36
de todas las propiedades 00:07:42
y aquí podríamos hacer ya 00:07:45
la siguiente visita 00:07:48
de nuevo aquí 00:07:50
hay clave primaria 00:07:52
y hay algo que yo puedo interpretar como clave primaria 00:07:54
hombre pues sí, está claro que 00:07:56
los profesores van a tener todos diferentes 00:07:58
NIF o NIE o lo que sea 00:08:00
bueno, si hay algo que puedo identificar como 00:08:01
clave primaria a todos los efectos 00:08:04
de mi aplicación 00:08:06
pues ala 00:08:07
pongo un equals 00:08:09
con el nif 00:08:11
y mucho más bonito 00:08:18
y ya si lo quiero dejar 00:08:19
estupendísimo 00:08:22
pues pongo un toString 00:08:23
en el toString 00:08:26
meter la lista 00:08:30
no tiene mucho sentido 00:08:32
en el toString de profesor 00:08:34
pues lo natural es meter 00:08:38
nif, nombre y ya está 00:08:39
porque de hecho si metemos la lista 00:08:40
¿qué me hace el toString 00:08:43
este de Eclipse? 00:08:45
me muestra 00:08:48
NIF, nombre, alumnos 00:08:49
y luego aquí directamente la referencia 00:08:52
a la lista, con lo cual este 00:08:54
a su vez llamará al toString de lista 00:08:56
que me ha mostrado una patata 00:08:58
entonces este toString no nos vale 00:09:00
este toString va a 00:09:02
mostrar una patata muy fea 00:09:04
o me meto yo ahí en un for para mostrar los alumnos 00:09:06
que ya sería un toString muy complicado 00:09:08
o va, paso de ellos 00:09:10
directamente, como acostumbramos a hacer 00:09:12
vale 00:09:14
ya está, ya tengo un toString 00:09:15
de profesor, y ya 00:09:21
tenéis las dos clases, profesor 00:09:27
alumno, y ahora insertar profesor 00:09:29
add 00:09:31
que lo hacéis, vale 00:09:32
ahora, nuestro 00:09:34
main, este ejercicio dice que 00:09:37
en el main, es donde están los 00:09:39
datos, y los datos es el conjunto de profesores 00:09:41
vamos a hacer un main 00:09:43
ahí 00:09:45
no he puesto esto 00:09:53
ah, la dice, el main 00:09:55
el propio main, hace el volcado 00:10:08
de los datos, de la base de datos y los lleva 00:10:10
a la variable que sea 00:10:12
entonces todos los profes tienen que ir 00:10:14
a una variable para poder 00:10:16
manejarlo, pues ¿a cuál? ¿a una array? 00:10:18
¿a una lista? ¿un set? pues a una lista 00:10:20
pues sale a todos los profesores 00:10:22
con los que vamos a trabajar 00:10:24
ahí estarán 00:10:25
profesores 00:10:28
la implementación de lista que a uno 00:10:29
le dé la gana, aunque ya sabéis que hay 00:10:34
unos criterios 00:10:36
linked list mejor 00:10:37
para inserciones y 00:10:39
borrados 00:10:41
y peor para consultas y ArrayList 00:10:42
justo al revés 00:10:46
vale, pues entonces si uno 00:10:47
hace aquí, hacemos rápidamente el main 00:11:01
para que sea bueno, como si fuera un ejercicio 00:11:03
real 00:11:05
de examen o algo así, aunque va a ser más 00:11:07
difícil 00:11:09
voy a poner lo del teclado 00:11:10
para que sea más cómodo 00:11:15
añadimos esto 00:11:17
Vale, pues entonces aquí tenemos la opción, y ahora ya sí, insertar profesor, una de las opciones del menú, la otra era dado nombre de alumno, dado NIF, perdón, porque es lo que lo identifica, profes que dan clase a ese alumno, 00:11:28
Porque hay que avisarles de que se ha puesto enfermo o lo que sea. 00:12:18
Pues entonces, profes de un alumno dado NIF. 00:12:24
Esta sería la opción 2. 00:12:35
Y la 3. 00:12:39
Y la 3 sería listado alfabético de alumnos de un profe. 00:12:46
Aquí ya hay que hacer cosas de orden. 00:12:52
Alfabético de alumnos. 00:13:04
Vale. 00:13:07
Y ahora aquí leeríamos la opción y ahora ya el rollo de siempre. 00:13:07
En el caso de que la opción sea la primera, pues aquí ya sabemos que habrá que leer todos los datos del profesor. 00:13:29
Esto es un rollo, para lo cual aquí sería más bonito hacer un método auxiliar, llamar a ese método recoger datos, por ejemplo, para que no nos quede ahí un case con un montón de líneas. 00:13:42
Y luego una vez que hemos leído los datos de profesor 00:13:53
Pues habría que instanciarlo y añadirlo 00:13:58
A la lista de profesores 00:13:59
Aquí tendríamos, ¿no? 00:14:01
Un profesor P al que le leemos los datos 00:14:10
Y este pues ya lo añadiríamos 00:14:12
A la lista y ya está 00:14:19
Vale 00:14:20
Y ahora, la que nos interesa 00:14:32
Opción 2 00:14:34
Dado un NIF 00:14:35
Todos los de alumno, todos los profes que lo tienen 00:14:37
Entonces vamos a hacer aquí 00:14:41
La petición del dato del NIF 00:14:43
vale, pues el nif es un string 00:14:45
lo leeríamos con el mecanismo 00:14:56
de lectura que os guste 00:15:03
y ahora ya 00:15:04
habrá que hacer todo el código 00:15:06
correspondiente para buscar en la lista de 00:15:08
profesores, que profesor tiene ese 00:15:10
alumno, incorporarlo 00:15:12
al resultado, mostrarlo por consola, lo que sea 00:15:15
entonces aquí, en lugar de hacer 00:15:17
todo eso ahí, vamos a llamar a un método 00:15:20
que lo haga 00:15:22
vamos a cambiar la estructura 00:15:27
en vez de meterlo en un método de operaciones 00:15:28
pues un método auxiliar dentro del mismo main 00:15:30
vale, entonces si yo tengo 00:15:32
este método 00:15:41
en lugar de ponerlo aquí, repito, simplemente 00:15:41
lo hago llamando a un método 00:15:44
que está en la misma clase 00:15:46
pero vamos, voy a poner el código 00:15:48
dentro de ese método 00:15:50
entonces este método 00:15:51
este método será este 00:15:53
¿veis? 00:15:56
un método auxiliar 00:15:58
que va a coger el nif 00:15:59
y va a recorrer 00:16:02
esta lista de profesores 00:16:04
vale 00:16:07
y edu 00:16:07
este es el final del switch 00:16:12
por ahora 00:16:15
y aquí faltaría 00:16:16
el while, mientras 00:16:23
la opción sea diferente 00:16:24
de la de salir, que vamos a ponerle la de salir 00:16:27
la 0 00:16:29
vale, pues a ver, venga, observad 00:16:32
entonces esta estructura 00:16:48
otra vez, este es mi main 00:16:50
y dentro de mi main está la lista 00:16:52
de profesores con la que voy a trabajar 00:16:54
a la que luego voy a insertar aquí 00:16:55
la que voy a recorrer, aquí está mi lista de profesores 00:16:57
vale, la opción 2 00:17:00
que es la primera que estoy haciendo, pido el 00:17:02
nif y ahora voy a pasárselo 00:17:04
a un método 00:17:06
para que haga 00:17:06
todo lo que tenga que hacer y ya ese método 00:17:10
tenga los system out dentro para mostrar 00:17:12
lo recorro en un método 00:17:14
entonces este método 00:17:16
de nuevo ves que no lo estoy llamando 00:17:18
asociado a ningún objeto lo cual 00:17:20
no se puede 00:17:22
ya sabéis que a los métodos 00:17:25
y a las variables los llaman los objetos 00:17:28
salvo en el caso de ser 00:17:30
estáticos que entonces 00:17:32
lo que los llaman son las clases 00:17:34
y de oye método estático o variable 00:17:36
estática de esta clase 00:17:38
pero aquí no lo he llamado asociado a nada 00:17:39
¿por qué? 00:17:42
no lo he llamado asociado a nada 00:17:45
porque este método está 00:17:46
en la misma clase 00:17:47
Entonces como está en la misma clase 00:17:49
Esto es como 00:17:51
Si yo no lo asocio a nada 00:17:53
Por defecto es la clase en la que estoy 00:17:54
Es como si estuviera haciendo esto 00:17:57
¿Vale? 00:17:59
¿Vale? 00:18:03
Estamos repasando como siempre 00:18:05
Mostrar profes es un método estático 00:18:07
Mostrar profes es un método estático 00:18:10
De mi clase main 00:18:12
Es un método estático de mi clase main 00:18:13
Entonces como es un método estático 00:18:15
De mi clase main 00:18:17
Yo lo llamo con el nombre de la clase 00:18:18
pero 00:18:20
como en este caso 00:18:22
main es la misma clase en la que estoy 00:18:24
main es en la que estoy, no es otra 00:18:26
es en la que estoy 00:18:28
este main es opcional 00:18:29
en este caso 00:18:32
¿vale? porque en este caso la clase 00:18:33
que llama el método es la misma 00:18:36
en la que estoy 00:18:40
si yo llamara un método estático de otra clase 00:18:41
ahí sí que tengo que poner el nombre de la clase sí o sí 00:18:44
pero si estoy llamando un método 00:18:46
estático de la misma clase en la que estoy, sería opcional, ¿vale? 00:18:48
Lo digo porque siempre que aparece un método suelto parece que no lo llama nadie y siempre 00:18:52
lo llama alguien. Un objeto, si es que no es 00:18:56
estático, o una clase si es que es estático, ¿vale? Bueno, eso por 00:19:00
un lado. Siguiente cosa. Ahora 00:19:04
yo ya podría ponerme aquí a navegar por los profesores. Yo aquí lo que tengo que hacer 00:19:10
es navegar por los profesores, cada profesor, si tiene un alumno con 00:19:14
este nif, mostrarlo 00:19:18
bueno, pues podría ya ponerme 00:19:20
aquí a hacer eso, me falta 00:19:22
algo, no, por ejemplo 00:19:27
vamos a ponernos a navegar por la lista de profesores 00:19:32
para ver si ese profesor 00:19:34
contiene al alumno 00:19:37
y si lo contiene lo muestro 00:19:39
pues navegar la lista de profesores 00:19:40
es una lista 00:19:43
¿cómo recorro una lista? 00:19:44
un for de índice 00:19:47
con el get, un for each, un iterador 00:19:49
vamos a poner 00:19:51
un for de índice que es lo más habitual para las listas 00:19:53
porque tienen posición 00:19:55
los iteradores son más para conjuntos 00:19:57
y sea menor que 00:19:59
¿cómo se llama la lista? 00:20:02
se llama profesores 00:20:04
profesores.size 00:20:06
incrementando 00:20:10
y pues aquí tendríamos que hacer 00:20:14
aquí tendríamos que hacer 00:20:16
Si profesores tiene al alumno I, habría que ver cómo es eso de tiene al alumno I. 00:20:22
Pues muestro profesores, vale. 00:20:27
Pero se me ha puesto en rojillo, ¿verdad? 00:20:30
¿Por qué se me ha puesto en rojillo esto? 00:20:35
Sin que lo miréis en la manita. 00:20:40
Eh, Diego, no es por eso. 00:20:45
este método es el que yo he hecho 00:20:54
para recorrer la lista de profesores 00:21:01
que tengo aquí arriba 00:21:02
esta, para recorrerla 00:21:04
y para cada profesor 00:21:07
pues mirar si tiene alumno con este NIF, etc. 00:21:08
pero antes de arrancar a hacerlo ya me pone 00:21:10
eso que no, ¿por qué? 00:21:12
si yo pongo aquí 00:21:16
la manilla, ¿qué 00:21:17
error me va a dar? 00:21:18
bueno 00:21:24
No, estar está, lo que pasa es que no tiene, inicializada está, o sea que no está inicializada no, ¿qué otra cosa me va a decir? Sin ponerla vosotros, no me va a decir que no sea public, aparte es que el modificador public yo no puedo ponerlo aquí, el modificador public se pone en las propiedades de las clases, esto no es una propiedad de una clase, es una variable del método, es distinto una propiedad de clase, 00:21:24
que se pone aquí, que una propiedad 00:21:57
de método, que es una propiedad 00:21:59
no, una variable local de un método 00:22:01
venga, ¿qué error me va a decir ahí en rojo? 00:22:02
va por ahí, sí 00:22:15
pero exactamente ¿qué me va a decir? 00:22:16
me va a decir 00:22:25
is not visible 00:22:26
no me va a decir 00:22:29
oye, o no visible 00:22:31
perdón, que no la conozco 00:22:34
me va a decir, ¿quién es profesores? 00:22:35
no la conozco, eso es lo que me va a decir 00:22:38
¿Veis? Me dice 00:22:43
cannot, no puede ser resuelta. 00:22:44
No la conozco, no puede ser resuelta. 00:22:47
Eso es lo que va a decir, ¿no? 00:22:50
Desconocida, variable desconocida. 00:22:51
Claro, y tan desconocida 00:22:53
porque tenemos dos 00:22:55
métodos. Main es un método 00:22:56
que acaba y termina aquí. 00:22:58
Este es otro 00:23:01
que acaba y termina aquí. Las variables 00:23:02
locales de un método 00:23:04
no son visibles para otro método. 00:23:06
Una variable local de un método 00:23:08
tiene visibilidad solo 00:23:10
en ese bloque, no tiene visibilidad 00:23:12
afuera, entonces 00:23:14
mi variable profesor es, yo la he declarado 00:23:16
aquí dentro del main 00:23:19
que es el que hace las cosas, trabaja 00:23:19
y ahí está, no pasa nada, puede estar ahí 00:23:22
perfectamente, porque va a estar ahí 00:23:24
toda la vida del main, toda la vida del programa 00:23:27
porque el main va a estar ahí 00:23:29
pero todo lo que yo 00:23:30
haga fuera del main, es imposible 00:23:33
que tenga acceso a esta variable 00:23:35
porque es local 00:23:36
¿vale? entonces 00:23:37
era de esperar que esos me pusieran rojillo 00:23:40
y me dijeran no conozco profesores 00:23:43
vale, bueno 00:23:45
pues soluciones 00:23:47
primera solución que se os ocurre 00:23:48
decirle no la conoces 00:23:51
te la paso por parámetro 00:23:55
tranquilo, no pasa nada, te la paso por parámetro 00:23:57
entonces este método 00:23:59
mostrar profesores 00:24:01
que reciba el NIF 00:24:02
y la lista de profes con la que trabajar 00:24:05
llamémosle profesores 00:24:07
lista como... ¡Uy, profe! 00:24:16
¿Vale? Dice, no puedes acceder 00:24:20
a ella porque es local al 00:24:22
método main, con lo cual desde 00:24:24
fuera de main no puedes. 00:24:25
Te la paso por parámetro. 00:24:28
¿Vale? Entonces, ahora 00:24:30
cuando llamemos el método, 00:24:32
habrá que pasarle la lista con la 00:24:34
que queremos trabajar. 00:24:36
¿Vale? 00:24:39
Esta es una solución. 00:24:41
Y otra, si es que 00:24:49
podemos, otra sería sacarla 00:24:50
de aquí, ¿no? O sea, si el problema es que es local a main 00:24:53
y por tanto fuera de main no puedo, pues hombre 00:24:56
si la saco como variable de clase, si la saco como variable de clase 00:25:00
y la pongo aquí, esta, si la saco 00:25:05
fuera, ya pueden acceder a ella cualquier método 00:25:09
de la clase main, ¿no? Es el otro, es decir, la saco 00:25:13
fuera. Vale, sacarla fuera así tal cual, hacer un copia y pega 00:25:17
de esto aquí, pum, copio 00:25:23
corto más bien, corto y pego 00:25:24
eso tal cual 00:25:27
corto y pego sería una solución 00:25:28
no, porque no, que más habría que poner 00:25:30
o no, razonadlo 00:25:33
ya, pero que no es un tema de que no me acuerdo 00:25:39
porque me falla la memoria 00:25:44
sino es 00:25:46
que lo razonéis 00:25:48
que esto no lo habréis aprendido de memoria, que lo habréis entendido 00:25:50
Entonces si yo hago un corta y pega 00:25:52
Y saco esto fuera 00:25:56
El problema está resuelto, puedo trabajar ya dentro 00:25:56
De los métodos con la variable profesores 00:25:59
Tanto de este como del otro 00:26:02
Vamos a hacer un corta y pega 00:26:03
Hago un corta 00:26:09
Y pega 00:26:12
Ya, pero no me vale que me digáis las cosas como conejos 00:26:15
A ver, entonces, y voy a poner la situación en la que estaba 00:26:19
En la que ya no se lo paso como parámetro 00:26:21
Ya no se lo paso 00:26:23
vale, ya no se lo paso como parámetro 00:26:25
no se lo paso 00:26:31
¿por qué? porque la he sacado 00:26:33
fuera, ahora es una variable de clase 00:26:35
ahora es una variable de clase 00:26:37
todos los 00:26:39
métodos de la clase 00:26:41
tienen visibilidad de esa variable, todos 00:26:42
una variable de clase, ¿no? todos 00:26:45
pero aún así 00:26:46
cuando yo intento acceder a 00:26:47
profesores aquí, me sigue poniendo en rojo 00:26:51
entonces sin poner ahí la manita 00:26:53
¿qué error me está diciendo ahora ahí? 00:26:55
me sigue dando un error, sí o sí 00:26:57
desde luego ya no va a ser 00:26:58
profesores cannot be resolved 00:27:01
ya no va a ser 00:27:02
porque profesores claro que puede ser resuelta 00:27:03
tienes perfectamente acceso a ello 00:27:05
es una variable de la clase 00:27:07
pues que error nos va a dar ahí 00:27:08
claro me va a decir 00:27:12
no puedes referenciar a una variable 00:27:16
no estática dentro de un método estático 00:27:18
eso era el concepto de estático 00:27:21
verdad 00:27:23
que es justo lo que me dice 00:27:23
oye 00:27:25
no puedes referenciar a una variable estática 00:27:26
a una variable no estática 00:27:30
en un contexto estático 00:27:33
claro, si esto es un método 00:27:35
estático, entonces uno podría 00:27:38
decir, ah, estupendo 00:27:40
no pasa nada 00:27:42
le quito el static 00:27:43
genial 00:27:45
le quito el static, ningún problema 00:27:48
este método ya puede acceder a profesores 00:27:50
perfectamente 00:27:52
pero ahora en qué le ha cagado 00:27:53
ahora ya sí que le ha cagado y ha roto la aplicación del todo 00:27:56
¿no? 00:27:58
le he quitado el static 00:28:00
para que ya pueda acceder a la variable de clase 00:28:01
no estática que yo he pegado 00:28:04
arriba, y ahora me dice 00:28:06
vale, este se ha quedado tranquilo, pero 00:28:08
arriba ha explotado todo 00:28:10
¿por qué ha explotado? 00:28:11
porque no puedo llamar desde main 00:28:17
que es estático, no puedo llamar a un método que no sea 00:28:19
estático, ¿vale? ahora el que ha saltado 00:28:22
es este, main es un 00:28:24
método estático y esto sí que no lo puedo 00:28:25
cambiar sí o sí, esto no lo puedo cambiar 00:28:27
porque el main tiene que estar en la cabecera 00:28:30
luego todo 00:28:31
lo que llame este método que esté fuera 00:28:33
sea propiedad 00:28:36
o sea otro método, todo tiene que ser estático 00:28:37
obligatoriamente, entonces si yo le he 00:28:40
quitado el estático a mostrar profesores 00:28:42
a mostrar profes 00:28:44
si se lo he quitado 00:28:46
de ahí ya no puedo llamarlo 00:28:47
con lo cual, quitar 00:28:48
este static no ha sido solución 00:28:53
quitar el static no ha sido solución 00:28:55
entonces que puedo hacer para arreglar 00:28:58
esto y que pueda acceder 00:29:00
a profesores 00:29:02
sin necesitar pasársela. 00:29:02
¿Qué cambio puedo hacer? 00:29:07
Ya el último cambio, ya el definitivo. 00:29:11
¿Vale? O sea, estamos otra vez 00:29:14
que método 00:29:16
estático no puedes acceder a una variable 00:29:17
de clase que no sea estática. 00:29:19
No, es muy sencillo. 00:29:27
Hagamos la lista estática, pero ¿qué más me das? 00:29:29
Si solo hay una... 00:29:31
Y esta es la solución, natural. 00:29:33
O sea, yo solamente tengo una lista de profesores. 00:29:38
Pues ya está. 00:29:41
Esta, que sea static. 00:29:43
Y entonces pueden acceder todos los métodos. 00:29:45
Y no tengo que pasarlo por parámetro. 00:29:48
Aunque podríamos haber optado por la primera solución que dijimos. 00:29:50
Pásaselo por parámetro. 00:29:52
Si es que yo no puedo sacarlo del main. 00:29:54
Si yo no puedo sacarlo del main, 00:29:56
porque la tengo que tener aquí, 00:29:59
no puedo sacarla del main. 00:30:00
entonces la única solución es 00:30:01
pasársela por parámetros 00:30:04
la primera que habíamos dicho, pasársela por aquí 00:30:05
no hay solución, pero si la puedo sacar 00:30:07
del main, mejor, no tengo que 00:30:10
pasar por parámetro todo el rato 00:30:12
pero entonces pongamos la estática que no pasa 00:30:13
nada, porque sea estática 00:30:16
de hecho va en su naturaleza, solo hay una lista 00:30:17
de profesores 00:30:20
¿vale? 00:30:20
bueno, pues entonces ahora ya podríamos 00:30:25
recorrer este 00:30:27
cacharro de profesores para hacer las cosas 00:30:28
¿Vale? 00:30:31
Venga, vamos a parar un par de minutillos 00:30:32
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
6 de marzo de 2024 - 12:22
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
30′ 38″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
153.53 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid