Saltar navegación

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

Clase 01-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 3 de marzo de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, bueno pues en esta aplicación que estábamos usando para practicar el modelo de datos, recordad cuando digo el modelo de datos me refiero a las diferentes entidades que gestiona la aplicación, que eso en base de datos son las diferentes tablas, vale, una tabla de una base de datos se va a corresponder con una entidad de mi aplicación, una clase, vale. 00:00:01
Bueno, pues esta aplicación que estábamos usando como ejemplo para ver las listas solamente tenía una clase en el modelo de datos, ya está, solo la clase alumno, con su número de matrícula, su nombre, la edad y las asignaturas que tenía. 00:00:28
Como podía tener muchas asignaturas, cada una caracterizada solo por su nombre, luego cada asignatura es una string por su nombre, pues entonces hacíamos que esta propiedad fuera una lista. 00:00:42
Antes hacíamos que fuera un array, ahora ya no nos hace falta usar un array, usamos una lista que aunque es más ineficiente que el array, es más fácil de programar con ella. 00:00:56
más fácil de programar, esa es su única ventaja 00:01:07
que es más fácil programar 00:01:09
con una lista que programar con un array 00:01:11
es la única ventaja, pero el array siempre va a 00:01:13
funcionar mejor 00:01:15
bueno, pues entonces esta es nuestra entidad 00:01:16
alumno, la única de nuestro modelo 00:01:19
de datos con su constructor 00:01:21
con y sin parámetros 00:01:23
sus get y set para acceder a las 00:01:25
propiedades y además 00:01:27
cuando trabajamos 00:01:30
con colecciones ya, también 00:01:31
dijimos el otro día que entonces ahora ya sí que 00:01:33
empieza a ser importante 00:01:35
que además de caracterizar 00:01:37
nuestra entidad, en nuestro caso alumno 00:01:40
caracterizarla por 00:01:42
matrícula, nombre, edad 00:01:44
y asignaturas, no me hace falta 00:01:46
más, es lo único que mi aplicación 00:01:48
tiene que saber de los alumnos 00:01:50
es decir, cuando el alumno llega 00:01:52
a secretaría a matricularse 00:01:54
tú has hablado con el secretario de secretaría 00:01:55
y le has dicho, oye, que te estoy haciendo la aplicación 00:01:58
¿a ti qué datos te importan? 00:02:00
pues él te habrá dicho 00:02:03
a mi solamente me importa el número de matrícula 00:02:04
el nombre, la edad y el listado de asignaturas 00:02:06
¿solo te importan esos datos? vale 00:02:07
pues esos datos son los que van ahí 00:02:09
eso es lo que se hace en el análisis 00:02:11
y hay que ir haciendo 00:02:13
análisis además un poco más finos 00:02:16
sobre todo ahora que ya estamos usando colecciones 00:02:18
un análisis más fino 00:02:20
sería 00:02:22
de estas propiedades 00:02:22
lo ideal es que 00:02:26
al menos una identifique 00:02:28
de forma única al alumno 00:02:30
o sea una aplicación 00:02:32
en las cuales los objetos no se pueden identificar de forma única 00:02:33
es como una tabla que no tiene clave primaria 00:02:37
eso nunca lo queremos 00:02:40
nunca queremos una tabla sin clave primaria 00:02:43
no queremos registros que no se puedan distinguir unos de otros 00:02:47
porque eso crea confusión en las aplicaciones que los manejan 00:02:50
pues aquí, aunque no es obligado 00:02:53
aquí esto no está, no es como en SQL 00:02:56
en los modelos relacionales 00:02:59
Que ahí está implementada la manera de dar unicidad a los registros. Está implementada mediante el concepto de clave primaria. El sistema gestor de base de datos, como tú intentes insertar un registro con una clave primaria que ya existe, te va a petar y te va a decir, no, aquí tienes un problema de restricción de clave única. 00:03:02
en los sistemas gestores de base a todos está implementado 00:03:23
todo eso, aquí no está 00:03:25
implementado, vale, aquí lo programas 00:03:27
tú y lo decides tú, aquí no hay 00:03:30
nadie que ya te obligue 00:03:31
a que uno de estos sea clave 00:03:33
o que si tú instancias un objeto 00:03:35
con una clave repetida 00:03:37
no hay nadie que te vaya a decir, oye, no instancies 00:03:39
un objeto con este número de matrícula 00:03:41
porque ya hay otro, no 00:03:43
eso no está implementado aquí 00:03:45
ahí ya tienes la libertad de programarlo y hacer lo que quieras 00:03:46
pero claro, es que en eso estamos 00:03:49
en hacer aplicaciones que estén bien 00:03:51
entonces la forma de que estén bien es 00:03:53
planteándonos 00:03:55
qué es lo que identifica 00:03:57
de forma única 00:03:59
a los objetos de las clases 00:04:00
entidad que estamos haciendo 00:04:03
porque si no hay una propiedad 00:04:04
que los identifique de forma única 00:04:07
a lo mejor no mañana, pero dentro 00:04:09
de cinco semanas, cuando vayamos a hacer 00:04:11
una funcionalidad, eso nos va 00:04:13
a pesar y vamos a decir, ostras 00:04:15
cómo se me está complicando esto 00:04:17
está perdiendo el sentido 00:04:19
porque no puede distinguir objetos entre sí 00:04:20
pierde el sentido, en la realidad 00:04:22
todo se puede distinguir 00:04:24
de todo, no hay clones 00:04:26
no existen los clones 00:04:28
pues la idea de esto es gestionar eso 00:04:29
esa realidad, bueno pues entonces 00:04:32
uno después 00:04:34
de hacer ese análisis que estamos hablando 00:04:36
diría, oye, ¿algo de esto identifica de forma única 00:04:38
al alumno? hombre, pues el nombre 00:04:40
claramente no, la edad tampoco, las llanuras tampoco 00:04:42
pero esto sí, afortunadamente 00:04:44
tenemos un campo que se identifique de forma única 00:04:46
porque si no lo tengo 00:04:48
es que algo ha fallado en mi análisis 00:04:50
seguramente tenga que añadir otro 00:04:52
en este caso ya tenemos uno 00:04:55
que identifica de forma única 00:04:56
¿para qué me sirve a mí tener un campo 00:04:57
que identifica de forma única 00:05:00
los objetos de una clase? 00:05:02
me sirve para establecer 00:05:04
el criterio de igualdad 00:05:06
que es importantísimo cuando una aplicación 00:05:08
trabaja con colecciones 00:05:10
¿vale? si yo tengo una propiedad 00:05:11
que caracteriza unívocamente 00:05:15
a los objetos 00:05:16
el criterio de igualdad ya está claro 00:05:17
y es que esa propiedad 00:05:19
y esta propiedad sean iguales 00:05:22
si lo que identifica de forma única 00:05:23
mis alumnos es el número de matrícula 00:05:26
pues dos alumnos 00:05:28
dos objetos alumno con mismo número de matrícula 00:05:30
son el mismo 00:05:32
aunque físicamente estén en direcciones 00:05:33
de memoria distintas, eso nos da igual 00:05:36
lo que nos importa es la interpretación real 00:05:37
de la situación 00:05:39
yo puedo ver dos fotos de una persona 00:05:40
y digo, hombre, esta persona 00:05:43
es la misma 00:05:46
y son dos fotos distintas 00:05:46
pero hay una sola persona, que haya dos fotos 00:05:49
de la misma persona no significa que esa persona exista dos veces en la realidad 00:05:51
no, pero gracias a que su aspecto 00:05:54
que lo identifica de forma única, su aspecto 00:05:57
es igual en esta foto y es igual en esta foto 00:06:00
yo puedo concluir que esa persona es la misma 00:06:02
pues aquí igual, yo tengo un objeto con número de matrícula no sé qué 00:06:04
y otro objeto con número de matrícula no sé qué, el mismo 00:06:09
pues es el mismo objeto 00:06:12
y la aplicación puede asumir a todos los efectos 00:06:13
que es el mismo 00:06:17
¿vale? que es el mismo 00:06:19
entonces que haya una clave, un campo que funcione 00:06:20
como clave primaria, nos permite establecer 00:06:23
el criterio de igualdad que hace 00:06:25
que un objeto sea igual a otro 00:06:27
y poder establecer ese criterio 00:06:29
de igualdad, se traduce 00:06:31
en que yo puedo programar el método 00:06:33
equals, que es un método 00:06:35
que tenemos que acostumbrarnos a tener 00:06:37
programado, porque muchas 00:06:39
otras clases tiran de él 00:06:41
por ejemplo 00:06:43
las clases colección 00:06:45
ArrayList, LinkedList, Haset, todas esas 00:06:46
tiran de él, entonces si yo no lo tengo implementado 00:06:49
ese método correctamente 00:06:51
cuando yo use los métodos de esas clases 00:06:52
add, remove, van a estar 00:06:55
no van a dar error de compilación obviamente 00:06:57
pero luego cuando la aplicación funcione 00:06:59
seguramente funcione de una manera que no es la que yo quiero 00:07:00
y diga, uy, que resultado tan extraño 00:07:03
claro, porque 00:07:06
esas aplicaciones, esas clases 00:07:07
están usando el método equals 00:07:09
si yo no lo he implementado 00:07:11
respondiendo a la realidad 00:07:13
de mi problema, si yo no lo he implementado, van a tirar 00:07:15
del equals de object. Y el equals 00:07:17
de object no tiene ningún sentido. El equals de object te dice 00:07:19
oye, tienes dos fotos de Pepito. 00:07:21
Lo siento, 00:07:25
son dos fotos distintas, hay dos Pepitos. 00:07:25
Eso es lo que te dice el método de object. 00:07:27
El equals de object. 00:07:30
Y eso no tiene ningún sentido en una aplicación. 00:07:31
No tiene ningún sentido. 00:07:34
Yo puedo tener tres fotos de Pepito, pero 00:07:35
es que Pepito solo es uno. 00:07:37
Pues entonces hay que implementar el equals 00:07:39
de la clase Pepito que me diga 00:07:41
oye, 00:07:43
donde tú veas este aspecto, aunque lo veas 00:07:44
en tres fotos distintas, es que solo hay uno 00:07:47
es esta única persona 00:07:49
pues eso es lo que hacemos poniendo el equals 00:07:51
diciendo, oye, perdona 00:07:53
todos los que tengan el mismo número de matrícula 00:07:54
son el mismo 00:07:57
estoy refiriendo al mismo 00:07:58
aunque esté instanciado 27 veces 00:08:00
me refiero al mismo 00:08:03
entonces, dar esta información 00:08:04
es fundamental 00:08:06
para que las clases 00:08:09
que trabajan con nosotros 00:08:11
su funcionamiento tenga sentido 00:08:13
y entre esas clases 00:08:15
repito, pues todas las de colecciones 00:08:17
todas las de colecciones 00:08:19
bueno, pues todas estas cosas son 00:08:20
no es que hagan que una aplicación pete o no pete 00:08:25
si las aplicaciones no petan 00:08:28
tú despliegas una aplicación y funciona, todo funciona 00:08:29
el problema de una aplicación 00:08:31
no es que te dé errores de compilación 00:08:34
se arregla en un pifas 00:08:35
que te dé errores de ejecución 00:08:36
se te va a arreglar un poquito más pero también en un pifas 00:08:38
el problema de una aplicación es que lo que haga 00:08:41
sea útil, tenga sentido 00:08:43
ese es el problema 00:08:44
entonces para que sea útil y tenga sentido 00:08:45
todas estas cosas 00:08:49
tienen que estar claras, ¿vale? 00:08:50
bueno, pues en nuestro caso 00:08:53
en nuestra clase alumno 00:08:54
implementamos el criterio de igualdad en base a la clave 00:08:56
primaria 00:08:59
¿vale? pues ya está 00:08:59
y ahora ya 00:09:02
nos hacíamos 00:09:05
una aplicación como la 00:09:07
el modelo de datos ya está, clase alumno punto pelota 00:09:08
ahora ya podemos hacernos el main 00:09:11
que es la aplicación que gestiona eso 00:09:13
y habíamos decidido estas funcionalidades 00:09:14
bueno pues las vamos a meter 00:09:17
yo no voy a hacer el menú porque es un rollo 00:09:19
simplemente voy a hacer 00:09:21
una clase donde pongo 00:09:23
los métodos que hacen esto y luego ya 00:09:25
el menú del main llamaría 00:09:27
esos métodos y se acabó 00:09:29
venga pues vamos a hacernos 00:09:30
una clase aparte con las operaciones 00:09:33
a las que llamaría el menú 00:09:34
entonces 00:09:37
nuestro proyecto este 00:09:39
era el de jerarquía colecciones 00:09:42
lo vamos a sacar 00:09:44
en un proyecto aparte 00:09:46
porque este es el que habíamos usado para 00:09:48
explicar esto de las listas 00:09:50
el patatín, vamos a hacer un proyecto 00:09:52
aparte, este ejemplito de alumnos 00:09:54
para luego subirlo al aula 00:09:56
virtual, vale, pues ejemplo 00:10:02
alumnos 00:10:04
venga, pues en ejemplo alumnos 00:10:05
me hago mi paquete 00:10:08
modelo, donde solamente va a haber 00:10:10
una clase esta vez. 00:10:12
Vale, mi paquete modelo con las entidades de la aplicación 00:10:19
solo tengo una, la de alumno. 00:10:21
Pues vamos a, la voy a copiar 00:10:23
directamente del otro proyecto. 00:10:25
¡Hala! Ya tenemos 00:10:35
ahí nuestra clase 00:10:36
alumno que ya está hecha. Y ahora 00:10:40
vamos a hacernos un paquete 00:10:42
con la lógica, las operaciones 00:10:44
que van a ser llamadas luego desde donde sea. 00:10:46
Desde un menú, desde una interfaz 00:10:49
gráfica, me da lo mismo. 00:10:50
A ver. 00:10:54
este va a ser 00:10:56
pues lógica, venga, paquete 00:10:58
lógica 00:11:00
y en paquete lógica vamos a 00:11:00
crear una clase 00:11:04
con las operaciones 00:11:06
que vamos a realizar 00:11:07
sobre los datos 00:11:09
¿vale? sobre los datos 00:11:11
y luego tendremos pues un paquete 00:11:13
main donde está la clase principal 00:11:18
con el menú 00:11:20
y todo eso 00:11:23
o la interfaz gráfica, lo que sea 00:11:23
como nos queramos comunicar 00:11:28
Entonces aquí uno tendría su clase main y esta clase main pues ya tendría dos tareas, una recuperar los datos, porque recordad que para una aplicación pueda trabajar con datos, los tiene que tener volcados en variables suyas, un código, un programa solamente puede trabajar con variables que hay aquí, solamente puede trabajar con variables que hay aquí. 00:11:29
entonces 00:12:01
el primer problema del main siempre es 00:12:03
volcar esos datos 00:12:06
y luego ya el menú que llama 00:12:07
las operaciones o el frame de interfaz 00:12:10
gráfica, crearlo para lo que 00:12:12
sea, ya una vez 00:12:14
que tiene los datos, cuando se va a trabajar en variables 00:12:16
pues ya el menú con 00:12:18
las llamadas a los métodos que vamos a hacer en otra clase 00:12:20
y listo, entonces 00:12:22
aquí los datos con los que va 00:12:24
a trabajar la aplicación, ¿cuáles 00:12:26
van a ser? pues los datos van a ser 00:12:28
un montón de alumnos, se supone que esta es la aplicación 00:12:30
de secretaría que trabaja con un montón 00:12:32
de alumnos que van y se están matriculando 00:12:34
vale, pues un montón 00:12:36
de alumnos, sus datos tendrán que estar 00:12:38
volcados aquí en algún sitio 00:12:40
bueno, hasta ahora 00:12:41
los volcábamos en un array 00:12:44
vamos a volcarnos en una lista, ¿no? 00:12:45
porque como en principio no sé cuántos alumnos va a haber 00:12:48
bueno, pues este main va a tener 00:12:50
su lista de alumnos 00:12:52
su lista de objetos alumno 00:12:53
¿vale? 00:12:59
que son los alumnos 00:13:01
con los que va a trabajar 00:13:03
ahora el tema es 00:13:05
aquí importamos 00:13:07
lista y alumno 00:13:09
como veis 00:13:14
yo aquí todavía a la hora de declarar 00:13:17
no me estoy mojando sobre que tipo de lista 00:13:18
cualquier 00:13:21
implementación de list 00:13:23
vale, array list 00:13:24
implementa list, luego vale 00:13:26
linked list 00:13:28
implementa list, luego vale 00:13:30
en el momento de declararlo no me estoy mojando todavía 00:13:32
podría, si quiero 00:13:34
si sé ya qué tipo de lista 00:13:36
quiero que sea alumnos, podría poner aquí 00:13:38
ArrayList o LinkedList, podría, no hay problema 00:13:40
vale, entonces 00:13:42
en un caso real, estos datos 00:13:44
se habrán volcado de una base de datos 00:13:46
claro, los hemos leído con el procedimiento de 00:13:48
acceso a datos 00:13:50
que sea, los hemos leído y ya están 00:13:52
aquí, en nuestro caso no los podemos 00:13:54
volcar ni de una base de datos ni de nada 00:13:56
entonces vamos a crear una lista vacía 00:13:58
y ya está, y la aplicación que vaya insertando 00:14:00
haciendo lo que sea con una lista que inicialmente 00:14:02
está vacía 00:14:04
aquí ya sí que tendríamos que elegir 00:14:05
aquí ya sí que hay que elegir 00:14:08
o ArrayList o LinkedInList 00:14:10
¿vale? 00:14:11
¿qué elegimos? 00:14:13
bueno, pues depende 00:14:15
va a haber muchos alumnos o va a haber pocos 00:14:17
si va a haber muchos, muchos 00:14:20
ArrayList ya empieza a ser un poco pesado 00:14:22
una Array así muy largote 00:14:24
el secretario 00:14:26
que está ahí trabajando con los alumnos 00:14:29
sobre todo, ¿qué hace? 00:14:30
insertar alumnos 00:14:32
eliminarlos 00:14:34
coger alumnos nuevos 00:14:36
o borrarlos, es decir, meter y sacar 00:14:38
en la lista, o sobre todo 00:14:41
estás pidiendo certificados de notas 00:14:43
es decir, consultando 00:14:45
sobre todo, ¿qué hace mayoritariamente su trabajo? 00:14:46
consultas para pedir 00:14:50
certificados, lo que sea, o matricular 00:14:51
y desmatricular alumnos 00:14:53
porque si mayoritariamente matricula y desmatricula 00:14:54
un linked list 00:14:57
que es mucho más 00:14:59
Eficiente para insertar y eliminar 00:15:01
Como ya vimos 00:15:03
Pero si esencialmente lo que hace es consultas 00:15:03
Es lo que más hace, pues un ArrayList 00:15:07
Porque consultar un ArrayList es inmediato 00:15:09
Índice y listo 00:15:10
Bueno, pues a elegir 00:15:12
Vamos a poner un LinkedList 00:15:15
Que cuando se habla de volúmenes 00:15:16
De datos grandes 00:15:19
Suele ser la que por defecto 00:15:19
Más se selecciona 00:15:22
¿Vale? 00:15:24
Pero vamos, que si se trata de 00:15:30
Como hemos dicho ya otras veces 00:15:32
pues uno está trabajando con una chorradita 00:15:34
que sabe que va a haber 10 o 12 elementos 00:15:35
y no va a haber más de 10 o 12 00:15:37
pues un ArrayList y ya está 00:15:38
el ArrayList es mejor, es un Array y listo 00:15:39
bueno 00:15:43
una vez seleccionado 00:15:44
el uso es el mismo, se usan igual 00:15:46
los métodos son iguales, son los métodos de List 00:15:49
son igualitos 00:15:51
me da igual haber seleccionado esta que esta otra 00:15:52
la diferencia es cómo funcionan por dentro 00:15:54
pero cómo funcionan por dentro me da igual 00:15:56
una vez seleccionado 00:15:58
me da igual ArrayList que el LinkedList 00:16:00
lo que yo hago es add, remove, get 00:16:02
es lo que hago 00:16:05
me da igual con esta versión que con otra 00:16:06
esta aporta 00:16:08
métodos adicionales que no tiene ArrayList 00:16:10
aporta 00:16:12
porque esta 00:16:13
la ofrecen también para simular 00:16:14
el funcionamiento de una pila 00:16:18
de una cola, lo mencionamos el otro día 00:16:20
entonces aporta métodos específicos de pilas 00:16:21
que son como push, pop 00:16:24
pero bueno, ya lo mencionamos 00:16:25
en otro momento 00:16:28
ahora primero vamos a hacer esta aplicación 00:16:31
con esto y ya está 00:16:33
bueno pues ya estamos seleccionados 00:16:34
nuestros datos van a estar aquí 00:16:36
y ahora ya, aquí ya estaría el menú 00:16:37
que 00:16:40
con las operaciones que habíamos dicho 00:16:41
que eran 00:16:44
estas de aquí 00:16:45
nuestro, no esto no era 00:16:52
estas eran 00:16:54
nuestras operaciones 00:17:01
vale 00:17:02
pues a ver 00:17:04
el menú llamará 00:17:05
estas operaciones y vamos a hacer los métodos 00:17:08
los métodos que va a usar 00:17:10
entonces aquí 00:17:12
en nuestro este de operaciones 00:17:14
el public sí o sí 00:17:15
obviamente, porque si no, ¿quién lo va a poder usar? 00:17:19
solamente los del paquete 00:17:22
vale, pues el método insertar 00:17:23
alumno 00:17:25
insertar alumno 00:17:26
vale, pues de nuevo 00:17:32
siempre que hacemos un método 00:17:43
tenemos que resolver 00:17:45
aparte del nombre, dos problemas 00:17:47
insertar alumno 00:17:49
¿Qué datos necesita para trabajar? 00:17:51
¿Qué le tengo que pasar por aquí? 00:17:55
¿Qué datos necesita para trabajar? 00:17:57
Claro, dos. 00:18:02
La lista, el alumno que se matricula y el contenedor, 00:18:04
la lista de alumnos a la que va. 00:18:07
¿Vale? 00:18:09
Necesita esos dos datos. 00:18:09
Entonces, la lista de alumnos la tiene aquí el main dentro. 00:18:11
La tiene aquí el main. 00:18:16
Entonces, podemos, esta de aquí. 00:18:18
Entonces, podemos reorganizarlo como lo hicimos ya 00:18:22
clase, podemos reorganizarlo 00:18:25
para que no tengamos 00:18:28
que pasársela por parámetro 00:18:30
todo el rato, no tengamos que 00:18:31
pasársela por parámetro 00:18:33
podemos 00:18:35
poner la lista aquí 00:18:36
como variable estática 00:18:39
aquí están todos 00:18:44
nuestros datos, aquí van a estar nuestros datos 00:18:48
y así no tenemos 00:18:50
que pasársela todo el rato a los 00:18:52
métodos 00:18:54
y el main no tiene ningún problema porque el main 00:18:54
cuando quiera añadir, cuando quiera acceder 00:18:57
a los datos, los tiene aquí 00:19:00
operaciones 00:19:02
por dios 00:19:06
los tiene aquí, si quiere acceder a ellos 00:19:07
es una variable estática de operaciones 00:19:12
los tiene ahí cuando quiera 00:19:14
entonces va a ser más cómodo 00:19:15
que nuestros datos 00:19:19
los guardemos en una variable estática 00:19:20
de esta clase 00:19:22
y así estos métodos 00:19:23
si los hacemos static 00:19:26
directamente pueden 00:19:28
acceder sin ningún problema a nuestros datos 00:19:30
pueden acceder a nuestros datos, sino hay que pasárselos 00:19:32
todo el rato por parámetros del main 00:19:34
que es un rollo 00:19:36
¿vale? entonces 00:19:37
ahora mismo este método 00:19:40
y todos los que están aquí 00:19:43
que haremos aquí abajo, solamente 00:19:44
necesita, en este caso 00:19:46
el alumno insertar 00:19:48
¿vale? 00:19:50
¿me tiene que devolver algo como valor de retorno? 00:19:55
este método 00:19:57
no tiene que devolver nada, la acción es insertar 00:19:58
en la lista de arriba, no tiene que devolver nada 00:20:03
vale, entonces podemos 00:20:05
poner un void y listo 00:20:07
entonces claro, esto 00:20:09
pues queda mucho más bonito, si uno lo documenta 00:20:13
y dice parámetro a 00:20:15
alumno 00:20:17
a insertar, no lo voy a hacer en todos los métodos 00:20:21
pero no perdáis de vista 00:20:23
esto, esto 00:20:24
vale, no devuelve nada 00:20:26
y aquí se pone la explicación 00:20:29
pues que es lo que hace 00:20:31
inserta el 00:20:32
alumno en la 00:20:35
colección 00:20:37
de alumnos. 00:20:40
Lo que sea, lo que fuera. 00:20:43
Ahí se quedaría el método documentado. 00:20:44
Ahora, el código de este método 00:20:49
ahora ya se ha quedado muy chorra, ¿verdad? 00:20:50
¿Cuál sería el código de ese método? 00:20:55
¿Qué escribo ahí? 00:21:04
No sé, ya está aquí. 00:21:12
¿Vale? 00:21:17
Este método se queda en esto. 00:21:18
ya está 00:21:20
no tiene más que hacer 00:21:24
este método 00:21:27
¿eh? 00:21:29
sí, se puede poner directamente en el main 00:21:34
pero estamos separando 00:21:36
en clases 00:21:38
¿vale? estamos separando en clases 00:21:39
que es una buena filosofía de diseño 00:21:41
las clases relacionadas con acceder a los datos 00:21:43
en un lado 00:21:46
la clase relacionada con la vista en otro 00:21:47
¿vale? 00:21:50
cuanto más vayamos separando mejor 00:21:51
vale 00:21:53
bueno pues esto se quedaría así 00:21:55
aquí de todas maneras 00:21:57
hay que irse 00:22:02
hay que irse acostumbrando 00:22:04
quizás ser consciente de ciertas cosas 00:22:08
yo veo 00:22:10
esta línea alumnos.ad 00:22:12
así directamente la veo 00:22:14
y me parece un código 00:22:15
peligroso 00:22:18
¿por qué? 00:22:22
Yo miro este método aisladamente y el objeto alumnos llama a un método. 00:22:27
Esto puede ser un null pointer exception, por supuestísimo. 00:22:34
Entonces, siempre hay que proteger las aplicaciones de null pointer exception. 00:22:38
¿Vale? 00:22:44
Entonces, hombre, esto quedaría más bonito. 00:22:45
Nosotros sabemos que alumnos no va a ser nunca null porque ya le he dado un valor inicial. 00:22:48
pero oye, imagínate 00:22:54
que yo que sé 00:22:56
la colección en algún momento 00:22:56
del software, hay alguien 00:22:59
que la ha puesto a null, pues hombre 00:23:01
yo no sé lo que van a hacer los demás 00:23:04
entonces, cada método 00:23:05
cuanto más protegido 00:23:08
esté frente a error es mejor 00:23:09
entonces hombre, esto queda mucho mejor si es así 00:23:11
si la lista 00:23:13
alumnos es diferente de null 00:23:15
entonces 00:23:17
añado el alumno 00:23:20
Y si no, pues estaría bien crearla, si no la creo y al inserto. 00:23:23
Este método, hombre, es mucho mejor, mucho más bonito. 00:24:07
Aquí que haya un null pointer excepción es imposible, imposible. 00:24:11
Aquí es imposible que lo haya, porque solamente hay dos llamadas aquí, aquí y aquí. 00:24:16
Y en ninguno de los dos casos va a ser null alumnos, en ninguno de los dos. 00:24:21
entonces claro 00:24:24
nosotros en nuestro caso 00:24:27
estamos mirando aquí arriba y decimos 00:24:30
nunca va a ser null pero oye 00:24:32
quien sabe quien puede llamar a ese método 00:24:33
entonces bueno no pasa nada porque 00:24:35
vayamos escribiendo más código 00:24:37
simplemente a efectos de acostumbrarnos 00:24:39
a entender las cosas 00:24:41
vale por insertar alumnos que ya está 00:24:43
inserto uno en la colección 00:24:46
que otra 00:24:48
funcionalidad tenemos 00:24:53
mostrarnos de alumno dado su número 00:24:54
de matrícula 00:24:57
pues 00:24:59
este 00:25:00
método 00:25:03
sería, no lo voy a comentar 00:25:04
pero bueno 00:25:07
public static 00:25:08
vale, mostrar datos de alumno 00:25:10
aquí nos saldría la pregunta 00:25:13
¿directamente los muestro 00:25:15
en el método o lo devuelvo 00:25:17
en un stream? 00:25:19
es mejor devolverlo 00:25:21
porque si yo cambio la, de repente 00:25:22
cambie la interfaz de la aplicación. Ya no quiero usar una 00:25:25
consola. Quiero usar una interfaz gráfica. 00:25:27
Este método ya no me vale 00:25:29
porque me está mostrando por consola. Entonces, mejor 00:25:30
lo devuelvo en un string 00:25:33
y ya mi main en que en cada momento 00:25:34
decida con ese string que quiere 00:25:37
hacer. Si hacerlo en System.NET 00:25:39
para consola, si llevarlo a una interfaz 00:25:41
gráfica, cuanto más se 00:25:43
separen las cosas, mejor. Entonces, 00:25:45
esto, separado de la 00:25:47
vista, separado de la interacción 00:25:49
con el usuario. Como yo meto 00:25:50
aquí System.NET Println, 00:25:53
ah, ya he mezclado, vista y 00:25:54
lógica, no, no, yo aquí hago 00:25:56
la lógica, te devuelvo lo que sea 00:25:58
y la clase que se ocupa de la vista 00:26:00
en nuestro caso el main 00:26:03
que ya decida con ese string, si te lo muestra 00:26:04
por consola, que hace con él, que ya decida 00:26:06
cuanto más desacoplemos 00:26:09
separemos mejor 00:26:10
pues venga, entonces 00:26:11
buena decisión, devolver en un string 00:26:13
los datos del alumno 00:26:16
y listo 00:26:17
esto era mostrar 00:26:19
datos en general, ¿no? 00:26:22
esto era mostrar datos, sí, mostrar datos del alumno dado su número de matrícula, 00:26:24
entonces el parámetro tiene que ser su número de matrícula, no hay otro, 00:26:42
vale, entonces este va a ser el resultado a mostrar, que tendré que ir construyendo como siempre, 00:26:53
Vale, pues a ver 00:27:05
Y esto cuando ya lo tenga hecho 00:27:07
Lo devolveré 00:27:09
Vale, a ver 00:27:10
¿Quiénes habéis hecho este método? 00:27:17
Pero mostrándolo por consola 00:27:23
Bueno, pero 00:27:25
Sea mostrándolo por consola y devolviéndolo como stream 00:27:26
¿Quién lo tiene hecho? 00:27:29
Miguel, ¿tú a tu manera? 00:27:32
¿Alguien más? 00:27:33
¿Nadie más levanta la mano? 00:27:34
Pues venga 00:27:37
Cinco minutos 00:27:38
Para hacerlo. 00:27:41
Sony 33. 00:27:45
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
3 de marzo de 2024 - 19:03
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
27′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
120.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid