Saltar navegación

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

Clase 19-02-24 - 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 26 de febrero de 2024 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues con lo que nos hemos despedido antes está claro, ¿no? 00:00:00
Entonces, ¿ves que estas variables de aquí? 00:00:11
Silencio. 00:00:17
En la interfaz... 00:00:20
A ver, callaos. 00:00:21
Y guárdate la comida. 00:00:25
vale, entonces esta variable 00:00:33
que está aquí 00:00:36
bueno, pues 00:00:37
efectivamente la podemos usar como variable 00:00:40
estática 00:00:42
desde cualquier sitio 00:00:43
llamándola simplemente con el nombre de la clase 00:00:45
vale, podríamos haber ubicado ahí 00:00:48
una variable que nos interese 00:00:50
pues para hacer cualquier cosa 00:00:52
yo que sé, vale, entonces podemos llamarla 00:00:54
sin problema 00:00:56
veis, aquí se puede usar esta variable 00:00:57
pues para lo que sea 00:01:05
a ver 00:01:06
Andrés vente aquí al lado 00:01:35
venga 00:01:37
bueno pues las interfaces 00:01:39
muchas veces a veces son 00:01:46
contenedores 00:01:48
de datos 00:01:50
estáticos 00:01:52
que están asociados a lo mejor a un concepto 00:01:53
por ejemplo podría haber una 00:01:56
interfaz math. En este caso hay una 00:01:58
clase math. Vale, pero podría haber una interfaz 00:02:00
math. Tú tampoco puedes comer, ¿eh? 00:02:02
Pues, hombre, 00:02:05
no sé 00:02:07
si es para hablar, sí, pero si no, no se 00:02:08
debe mover la boca en clase. 00:02:10
Venga. 00:02:16
Vale, pues a veces las interfaces 00:02:18
pueden ser contenedores de datos estáticos 00:02:19
que viene bien ubicarlos ahí. 00:02:22
O sea, las variables globales 00:02:24
en Java, como sabéis, no existen. 00:02:25
Tienen que estar siempre en algún sitio. 00:02:28
dentro de una clase tienen que estar siempre 00:02:29
las variables, siempre 00:02:32
no hay variables sueltas 00:02:33
entonces cuando hay una información 00:02:35
que tengo que ubicarla yo en algún sitio 00:02:38
pero no es una información 00:02:40
que caracterice a un objeto en particular 00:02:42
y lo distinga de los demás 00:02:44
sino es una información global 00:02:46
que puedan usar muchos 00:02:47
pues no me queda más remedio que guardarla en variables estáticas 00:02:49
como ya sabemos, porque las variables estáticas 00:02:52
es el sitio para guardar 00:02:54
información que es común 00:02:55
para todos los objetos de una clase 00:02:58
que no depende del objeto 00:03:00
bueno, ahí me vale, porque como Moisés en un ratín va a ir ahí 00:03:02
pues ahí le dejamos el sitio 00:03:04
¿vale? 00:03:05
entonces, por ejemplo 00:03:08
la clase 00:03:10
math esta de Java 00:03:12
es una interfaz 00:03:13
entonces no es 00:03:16
un buen ejemplo, pero 00:03:18
a ver, un momentito 00:03:20
si encontramos en 00:03:22
rápidamente aquí, en el paquete 00:03:24
java lang 00:03:28
aquí en el eclipse las que son interfaces 00:03:30
aparecen con una i delante 00:03:35
en vez de una j 00:03:37
¿veis? 00:03:38
en todas estas aparece una j aquí 00:03:41
eso es que son clases 00:03:42
si fueran interfaces aparecerían con una i 00:03:44
entonces voy a buscar a ver si encontramos 00:03:46
alguna aquí de la librería estándar de java 00:03:49
para que 00:03:51
nada, no son todas clases 00:03:54
sí, lo que pasa es que quería una 00:04:03
que tuviera variables 00:04:10
que tuvieran un sentido para nosotros 00:04:12
pero bueno, da igual 00:04:13
se me ha ido la M 00:04:16
aquí 00:04:35
vale, esta clase, esta de aquí 00:04:37
que es la clase math, que ya la hemos abierto a veces 00:04:51
y usado a veces 00:04:53
vale, pues incorpora esa idea 00:04:54
incorpora la idea de, oye, hay datos 00:04:58
hay datos que 00:05:00
a lo mejor le interesa usar a cualquier aplicación 00:05:02
como el número e 00:05:05
para hacer las exponenciales 00:05:06
como el número pi 00:05:08
como la constante tau 00:05:10
¿vale? entonces 00:05:12
la constante para cambiar 00:05:14
grados a radianes 00:05:16
¿no? la unidad de medida de ángulos 00:05:19
que puede ser grados o radianes 00:05:21
entonces, hay datos 00:05:22
que a lo mejor le puede interesar a cualquier aplicación 00:05:24
donde los ubico, es que tienen que ir dentro 00:05:26
de clases, no pueden ir a otro sitio, tienen que ir dentro de clases 00:05:28
bueno, vale 00:05:31
pues los ubico dentro de clases pero como variables 00:05:32
estáticas, para que quede claro 00:05:34
que no describen a ningún objeto 00:05:36
en particular, no sirven para describir 00:05:38
a ningún objeto 00:05:40
simplemente incorporan datos 00:05:41
que se puede acceder en cualquier momento 00:05:44
sin más que nombre de la clase 00:05:47
punto constante 00:05:49
en cualquier momento, no hace falta que exista ni un objeto 00:05:50
ni nada, esa es la utilidad 00:05:52
de las variables estáticas 00:05:55
meter ahí una información que puede usar cualquiera 00:05:56
porque es interesante 00:05:59
sin más que poner nombre de la clase 00:06:00
punto nombre de propiedad 00:06:03
no tiene que existir ningún objeto 00:06:05
porque es que esas variables 00:06:08
esas propiedades no identifican a objetos 00:06:09
ese es el uso de las variables estáticas 00:06:12
y son imprescindibles de hecho 00:06:14
para reflejar eso 00:06:17
lo que pasa es que claro 00:06:18
como tienen que estar dentro de una clase 00:06:20
pues hombre la idea es que uno decida 00:06:22
ubicarlas en las clases donde 00:06:24
al menos están relacionadas 00:06:26
por concepto, hombre pues las 00:06:28
constantes matemáticas están relacionadas con las 00:06:30
matemáticas, pues vamos a meterlas en una 00:06:32
clase más 00:06:34
vale, entonces esto en particular 00:06:35
no es una interfaz sino que es una clase 00:06:38
porque además nos da métodos 00:06:40
además nos da métodos para hacer cosas 00:06:42
como el seno, el coseno, el random 00:06:44
el no se que, nos da métodos, entonces es una clase 00:06:46
no es una interfaz porque nos da métodos hechos 00:06:48
pero perfectamente una interfaz 00:06:50
podría ser también un contenedor 00:06:52
de variables estáticas 00:06:54
podría serlo también 00:06:56
y sería un uso perfectamente para 00:06:57
o sea, yo tengo un montón de datos 00:07:00
que no identifican un objeto 00:07:02
sino son datos que interesan 00:07:04
a mi aplicación 00:07:06
que están relacionados 00:07:07
con no sé qué proceso de conversión 00:07:10
de algo, pues me hago una interfaz 00:07:12
y meto ahí esas variables 00:07:14
estáticas y ya puedo acceder 00:07:16
a ellas perfectamente con nombre de la 00:07:18
interfaz, nombre de la propiedad 00:07:20
como he accedido aquí en particular a esta 00:07:21
¿vale? 00:07:24
entonces también las interfaces 00:07:27
pueden servirnos en un momento dado 00:07:29
dentro de nuestro diseño para eso, ser contenedores 00:07:30
de variables estáticas que incorporan datos 00:07:33
que son independientes 00:07:34
de los objetos pero me sirven ahí para hacer cosas 00:07:37
¿vale? y 00:07:39
el otro uso 00:07:42
es este que hemos dicho antes de irnos 00:07:43
generar 00:07:46
una especie de plantilla 00:07:48
vacía de comportamiento 00:07:50
cosas que hay que hacer 00:07:51
aquellos objetos 00:07:54
que lo implementen, cosas que hay que hacer 00:07:56
recoger un comportamiento 00:07:58
esa es su 00:07:59
función principal 00:08:00
vale, pues nosotros 00:08:03
podemos incluirlos en nuestro diseño 00:08:06
como lo hemos incluido ahora 00:08:07
como tenemos empleados que pueden ser despedidos 00:08:09
pero no son todos 00:08:12
pues me hago yo una interfaz 00:08:14
y solamente heredan de la interfaz despedible 00:08:15
los que puedan ser despedidos, los otros no, etc 00:08:18
Bueno, pues ya están los 5 planes de su diseño. Pero claro, también nos podemos aprovechar de interfaces que ya están hechas en la librería que nos viene en los proyectos cada vez que creamos uno. 00:08:20
Cada vez que creamos uno 00:08:37
Como ya hemos dicho muchas veces 00:08:39
Nos viene todo esto 00:08:41
Nos vienen todas estas clases 00:08:42
Todas las que están aquí 00:08:47
Y hay tropecientas mil 00:08:49
En cada uno de estos jar 00:08:51
Porque cada uno de esos es un jar 00:08:53
En cada uno de ellos hay tropecientos mil paquetes 00:08:54
Y en cada paquete hay tropecientas mil clases 00:08:57
Y así en todos estos jar 00:09:00
O sea, aquí hay 00:09:02
De todo 00:09:03
¿Vale? De todo 00:09:04
bueno, pues toda esta librería virtual 00:09:06
toda esta librería de la máquina virtual 00:09:11
está ya diseñada 00:09:13
con esta arquitectura de interfaces 00:09:15
de clases abstractas 00:09:17
que yo puedo poco a poco 00:09:19
ir incorporando, ir aprovechándome 00:09:21
de ella, e irla utilizando 00:09:23
por ejemplo, para que lo 00:09:25
entendamos, vamos a hacer 00:09:27
otro proyecto distinto, esto de las interfaces 00:09:31
aparte de un 00:09:33
par de cositas que incorporamos 00:09:35
luego al final para no liar. 00:09:38
Esto está claro, ¿no? Lo que es una interfaz 00:09:40
y qué sentido tiene 00:09:42
incluirlas en nuestro diseño y luego 00:09:43
cómo se usan. Pues se usan 00:09:45
como hemos visto. 00:09:48
Puedes declarar una variable 00:09:50
de tipo interfaz y luego instancias, lo que quieras. 00:09:51
Bueno, pues esto 00:09:55
está claro, vamos a cerrar este proyecto. 00:09:55
Vale, y ahora vamos a hacernos un proyecto nuevo 00:10:01
para poner un ejemplo. Vamos a usar 00:10:03
ahora interfaces que ya están hechas 00:10:05
en mi máquina virtual y vamos a 00:10:06
servirnos de ese mecanismo. De ese mecanismo 00:10:09
que hemos incorporado aquí 00:10:11
y que parece que puede ser útil. 00:10:12
Venga, 00:10:17
pues lo voy a llamar a este 00:10:17
ejemplo comparable. 00:10:18
Comparable. 00:10:23
Vale. 00:10:24
Bueno, pues 00:10:29
vamos a hacer una aplicación 00:10:30
que gestione alumnos. 00:10:32
¿Vale? 00:10:35
Entonces, 00:10:41
si va a gestionar alumnos, bueno, 00:10:41
vale, me valdría cualquier cosa 00:10:42
pero bueno, es lo primero que me va a venir a la cabeza 00:10:45
entonces si va a gestionar 00:10:47
alumnos, pues una entidad alumno 00:10:50
no hay otra, lo de siempre 00:10:52
si mi aplicación gestiona mesas, pues una entidad mesa 00:10:53
si gestiona ventanas, pues una entidad 00:10:56
ventana, pues gestiona 00:10:58
alumnos, pues una entidad alumno 00:11:00
y aquí 00:11:02
pues nada 00:11:06
después de analizar el problema 00:11:08
uno decide 00:11:11
que propiedades son las que le interesan 00:11:12
pues imaginamos que fuera esta 00:11:15
y también nos interesa 00:11:19
la nota 00:11:21
entera, sin decimales 00:11:25
de esta aplicación que genera alumnos 00:11:26
solo nos hace falta saber 00:11:29
NIF, nombre y nota 00:11:31
no queremos saber nada más de los alumnos 00:11:32
porque todas las funcionalidades están relacionadas 00:11:35
con su NIF, su nombre y su nota, solamente 00:11:37
pues entonces son las propiedades que hay que meter 00:11:39
¿vale? no se meten propiedades 00:11:40
que están de más y que sobran, no 00:11:43
solo las propiedades relacionadas 00:11:45
con las tareas que va a hacer la aplicación 00:11:47
vale, pues nada 00:11:49
como de costumbre haríamos 00:11:53
los constructores 00:11:54
Getty Set 00:12:12
pues tres Getty Set 00:12:14
tres pares 00:12:15
vale 00:12:19
pues entonces, ahora 00:12:25
ya está, una aplicación que va a gestionar 00:12:27
solamente alumnos 00:12:30
con esas tres propiedades, luego 00:12:31
no hay que hacer más entidades, es una aplicación muy sencilla 00:12:34
que va a trabajar con alumnos 00:12:36
y les va a poner notas y todo eso 00:12:38
bueno, pues a ver 00:12:40
por ejemplo, ahora hacemos 00:12:42
nuestro main, vale 00:12:44
esta ya es nuestra aplicación que gestiona a los alumnos 00:12:54
entonces 00:12:56
los alumnos 00:12:57
con los que trabaja 00:13:00
¿dónde están? lo de siempre 00:13:02
normalmente estarán en una base de datos 00:13:04
normalmente 00:13:06
pero para trabajar con ellos los tenemos 00:13:07
que volcar 00:13:10
a variables de la aplicación 00:13:11
y cuando ya están en variables de la aplicación 00:13:13
uno ya puede trabajar con ellos 00:13:16
mientras no estén volcados en variables de la aplicación 00:13:17
no se puede trabajar con ellos 00:13:20
la parte de volcar 00:13:21
de la base de datos a variables de la aplicación 00:13:24
no la sabemos hacer, con lo cual vamos a asumir 00:13:25
que ya directamente tengo los alumnos 00:13:28
volcados en variables de mi aplicación 00:13:29
¿dónde? como son muchos 00:13:32
pues por ahora un array 00:13:33
¿dónde vamos a meterlo? 00:13:36
vale, para variar 00:13:38
vamos a incluir otra clase 00:13:39
que va a estar solamente para guardar 00:13:46
los alumnos, para guardar los datos de mi aplicación 00:13:52
que son los alumnos, sería el repositorio de datos 00:13:56
el repositorio, pues venga, vamos a llamarlo así 00:13:59
repositorio 00:14:02
entendiendo repositorio 00:14:04
como algo donde hay datos, eso es un repositorio en general 00:14:07
un repositorio es un sitio donde yo puedo ir a coger datos 00:14:10
eso es un repositorio 00:14:14
bueno, pues vamos a llamar a esta clase repositorio 00:14:17
vale, esto es por meter 00:14:19
yo que sé, diferentes cosas 00:14:23
bueno, pues esta clase, su objetivo va a ser que estén ahí 00:14:24
los datos de la aplicación 00:14:28
los datos de la aplicación con los que va a trabajar hemos dicho que es 00:14:30
unos cuantos alumnos 00:14:34
bueno, pues entonces los datos de la aplicación que van a estar aquí 00:14:36
va a ser 00:14:40
un array de objetos 00:14:40
alumno, ala 00:14:44
inicialmente de nuevo 00:14:49
para lo de siempre 00:14:53
para evitar 00:14:54
los null pointer 00:14:57
exception, vamos a dejarlo 00:14:59
instanciado con tamaño 0 00:15:01
y ya está, y según vayan llegando alumnos 00:15:02
vale 00:15:04
bueno, entonces 00:15:06
siguiente cosa que podemos ir haciendo 00:15:11
para ir dejando esta aplicación un poco más bonita 00:15:13
para irla dejando un poco más bonita 00:15:15
solamente va a haber en toda mi aplicación 00:15:16
solamente va a haber un conjunto de alumnos 00:15:20
que es este, solo va a haber uno 00:15:22
entonces, si solo va a haber uno 00:15:23
pues por ejemplo 00:15:26
puedo añadir un modificador a esta variable 00:15:28
que sea 00:15:31
static 00:15:31
y aquí pegaría y tendría mucho sentido 00:15:34
¿vale? 00:15:36
solamente voy a tener 00:15:41
un array de alumnos en toda mi aplicación 00:15:42
con el que van a trabajar el main 00:15:45
y los que quieran trabajar con ese array de alumnos 00:15:47
no es que vaya a haber 00:15:49
muchos objetos repositorio 00:15:51
y cada repositorio con su array de alumnos 00:15:53
podría ser 00:15:55
pero no es el diseño que estamos planteando 00:15:57
estoy haciendo esto a propósito 00:15:59
porque es uno de los muchos patrones de diseño que hay 00:16:01
este es uno que es el patrón 00:16:03
repositorio que se llama 00:16:05
que es habitual, que es tu aplicación trabaja con datos 00:16:07
ahí están tus datos 00:16:09
esos son, y eso, solo eso, los únicos 00:16:11
y ahora esos datos tienes que meterlos en algún sitio 00:16:13
pues los metes en una clase 00:16:15
cuya única función es 00:16:18
tener ahí los datos dentro 00:16:20
vale, entonces 00:16:21
de esa clase 00:16:23
esos datos 00:16:24
con los que va a trabajar la aplicación son solo esos 00:16:26
están ahí, no es que vaya a haber 00:16:30
varias instancias de esa clase 00:16:32
cada una con sus conjuntos de datos 00:16:34
no, esos son mis únicos datos de la aplicación 00:16:35
pues planto ahí un static y ya está 00:16:37
y al plantar un static 00:16:39
¿qué gano? que puedo acceder 00:16:41
a ellos poniendo 00:16:43
nombre de la clase repositorio.alumnos 00:16:45
es lo que gano 00:16:47
si no pusiera el static 00:16:48
para acceder a ellos tendría que instanciar un objeto 00:16:50
repositorio 00:16:53
y acceder con r.alumnos 00:16:54
¿para qué? 00:16:57
si solamente tengo un array 00:16:59
un único conjunto de alumnos al que quiero 00:17:01
que accedan todas las clases que 00:17:03
intervengan 00:17:05
pues variable estática y se acabó 00:17:07
entonces yo ahora ya desde mi main 00:17:09
desde mi main que quiero 00:17:11
hacer algo con ese 00:17:13
Array de alumnos 00:17:14
Que quiero hacerlo, pues ya está 00:17:16
Accedo así y se acabó 00:17:18
Lo que sea que quiera hacer, ya veremos lo que sea 00:17:19
Yo quería poner aquí, punto 00:17:22
O sea, lo que sea que yo quiera hacer 00:17:23
Pues poniendo repositorio.alumnos 00:17:27
Ya está, ya lo tengo 00:17:33
¿No? 00:17:36
Es lo que he ganado 00:17:38
Poniéndole aquí static 00:17:40
Es lo que he ganado 00:17:41
¿Vale? Si no pongo static 00:17:43
Para acceder a ese array 00:17:45
Tendría que instanciar un objeto 00:17:48
repositorio, ¿verdad? Tendría que 00:17:49
instanciarlo y ahora 00:17:51
ya acceder así. 00:18:00
¿Pero para qué? 00:18:03
¿Para qué? Si solo tengo un conjunto 00:18:04
de alumnos, un array de alumnos 00:18:06
porque así funciona mi aplicación. 00:18:08
Pues le pongo el static delante 00:18:11
y se acabó. Vale. 00:18:12
Bueno, pues esta clase 00:18:17
esta clase es la clase que 00:18:18
tiene exclusivamente como 00:18:20
función guardar ahí 00:18:22
en una variable estática suya los alumnos 00:18:24
con los que mi aplicación trabaja. 00:18:26
Ya está, que van a ser alumnos, se acabó. 00:18:28
Entonces, por comodidad, lo que se suele hacer en esta clase es, hombre, ya de paso, vamos a meterle métodos para las operaciones básicas con un almacén de datos, que es insertar, eliminar, consultar, ¿verdad? 00:18:34
Entonces, vamos a utilizar hacer estos métodos como repaso. 00:18:53
entonces yo podría hacer aquí 00:18:57
un método que fuera 00:19:00
insertar 00:19:02
alumno 00:19:04
al que le paso un objeto alumno 00:19:05
y este método 00:19:08
insertar uno en el array 00:19:14
lo escribo rápidamente o como si queréis hacer 00:19:16
un copia y pega de lo que hemos hecho toda la vida 00:19:18
que es esto 00:19:20
simplemente 00:19:22
aquí se haría lo de siempre 00:19:23
aux 00:19:53
no, aux de i 00:19:56
Igual a 00:20:06
Alumnos de i 00:20:07
Y una vez que ya he copiado 00:20:10
Pongo la adicional 00:20:12
Que la adicional estará en esta posición 00:20:13
Aquí pondría el nuevo 00:20:16
Y ahora ya sobrescribo 00:20:20
Alumnos igual a aux 00:20:23
Vale, pues entonces esta clase que estoy haciendo 00:20:25
Es una clase que está orientada 00:20:30
Simplemente a guardar los alumnos 00:20:32
El almacén 00:20:34
Dentro 00:20:34
Y hacer las operaciones básicas con ese almacén 00:20:36
insertar, recuperar 00:20:39
entonces estamos tratando de reproducir 00:20:41
la idea de la que ya he hablado a veces 00:20:45
de desacoplamiento de código 00:20:47
que es muy importante 00:20:48
no se trata de hacer una única 00:20:50
una aplicación que consista 00:20:53
en una única clase con un barullo 00:20:54
ahí enorme, no 00:20:57
vamos a separar las cosas 00:20:58
esta clase se ocupa 00:21:01
de los datos y del tratamiento de los datos 00:21:03
ya está 00:21:04
y se ocupa de eso 00:21:05
luego habrá otra clase que se ocupe 00:21:07
de otras funcionalidades y cada clase 00:21:10
se ocupa de lo suyo 00:21:12
pues esta se ocupa de los datos 00:21:13
y del tratamiento de esos datos 00:21:15
ya está, vamos a ir tratando 00:21:17
de hacer un código desacoplado 00:21:20
vale, y esta 00:21:21
y esta clase repositorio 00:21:23
pues lo normal sería que tuviera 00:21:26
voy a dejarlos ahora mismo en blanco 00:21:29
para, pues que tendría 00:21:31
que tuviera un método 00:21:33
que fuera eliminar 00:21:35
alumno por 00:21:38
clave primaria, porque así es como se eliminan 00:21:39
entonces alumno, su clave 00:21:42
primaria, pues tendría sentido que fuera el 00:21:43
nif, entonces este método 00:21:45
pues lo podríamos hacer, lo hemos hecho 00:21:52
otras veces, quitar de un array, que es 00:21:53
hacer uno con una posición menos, copiar, pegar 00:21:55
etcétera, también 00:21:57
podríamos hacer el método 00:21:59
consultar alumno 00:22:01
vamos a llamarle, que suele ser 00:22:04
tú le pasas un nif 00:22:11
Y te devuelve el objeto alumno del array 00:22:18
Que tiene ese nif 00:22:21
Este método es muy rápido de hacer 00:22:22
Hacemos un for 00:22:25
Y ahora aquí haríamos 00:22:26
Si alumnos de i 00:22:43
Punto 00:22:49
Get nif 00:22:50
Equals 00:22:52
El nif que me han pasado 00:22:58
Pues ala, ya he encontrado el alumno 00:23:02
Entonces pondría, ala, return 00:23:05
Alumnos de i 00:23:07
¿por qué me lo pone rojo? 00:23:11
¿por qué creéis que el compilador 00:23:28
me da este rojo de ahí? 00:23:33
porque si 00:23:39
no es igual 00:23:40
no devuelve nada 00:23:42
claro, porque el compilador 00:23:43
él simplemente mira que todo encaje 00:23:46
dices, oye, dices que devuelves un alumno 00:23:48
muy bien, si encuentras un alumno 00:23:50
cuyo NIF coincide 00:23:52
sí, efectivamente lo devuelves 00:23:54
pero ¿qué pasa si nunca jamás entras en el NIF? 00:23:56
si nunca jamás entras en el NIF 00:23:58
el for termina, venimos por aquí 00:24:00
y ahí no hay nada que te diga 00:24:02
que devuelves entonces 00:24:05
claro, no pasa nada 00:24:06
pues en ese caso devuelvo un null 00:24:08
¿vale? 00:24:10
uy, perdón, es que he puesto aquí 00:24:13
alumno, lo he cambiado 00:24:14
ahí 00:24:17
así, ¿vale? 00:24:17
ahora ya sí 00:24:21
recorro mi array, si encuentro 00:24:22
un alumno cuyo nif coincide 00:24:25
devuelvo ese alumno 00:24:26
entonces al hacer el return 00:24:28
es que ya salgo del método 00:24:29
he dejado ya el for a la mitad, pero no pasa nada 00:24:32
el nif es clave primaria, solo habrá un alumno 00:24:34
he dejado el for a la mitad 00:24:35
he salido y ya está 00:24:37
que el for termina y nunca jamás 00:24:38
entré en este if, nunca jamás he entrado 00:24:41
el for termina y continúo por aquí 00:24:43
y entonces me dice el compilado 00:24:46
oye, entonces ¿qué devuelves? 00:24:48
un objeto tienes que devolver sí o sí 00:24:49
bueno, pues en este caso 00:24:51
es porque no existía el alumno 00:24:53
pues entonces devuelvo null y ya está 00:24:55
¿vale? 00:24:57
Y también se podría hacer un método modifica alumno, que serían las cuatro tareas básicas que se hacen con los datos. 00:24:59
Insertar uno nuevo, eliminar uno, dado clave primaria, consultar uno, para verlo, dado clave primaria y modificar uno, dado clave primaria, datos nuevos. 00:25:09
son las cuatro tareas que se hacen siempre con los datos 00:25:21
insertar, eliminar, consultar y modificar 00:25:24
y esas cuatro tareas 00:25:30
lo normal es que se incluyan en nuestra aplicación 00:25:33
en la clase que trabaja con los datos 00:25:35
en mi caso esta que he llamado repositorio 00:25:37
¿vale? eso es un patrón habitual de diseño 00:25:40
la clase que trabaja con mis datos 00:25:42
incluye esas cuatro tareas básicas que siempre se hacen 00:25:44
insertar, eliminar, consultar y borrar 00:25:47
entonces eso es tanto así 00:25:48
tanto así que esas cuatro tareas 00:25:51
básicas con los datos reciben un nombre 00:25:53
que es este 00:25:55
esto 00:25:57
en lenguaje 00:25:59
de desarrollo 00:26:02
tiene un significado muy concreto 00:26:04
que si vais, pues os vais apuntando 00:26:06
las cositas para que os vaya ahí todo quedando 00:26:09
eso tiene un significado 00:26:11
muy concreto y en el lenguaje 00:26:13
técnico nuestro 00:26:15
CRUD viene de 00:26:16
crear, leer, modificar y borrar 00:26:18
¿no? 00:26:21
crear e insertar, leer 00:26:22
consultar, update 00:26:24
modificar y delete de borrar 00:26:27
entonces 00:26:29
CRUD significa 00:26:30
las tareas que se hacen con los datos 00:26:32
en informática, que son esas cuatro 00:26:34
entonces a ti, pues cuando tú 00:26:36
vas a hacer una aplicación, te puede decir 00:26:39
tú vas a hacer el CRUD 00:26:41
y no puedes decir, uh, que voy a hacer el CRUD 00:26:42
lo que te están diciendo es 00:26:44
oye, hazme todos los métodos necesarios para trabajar con esos datos. 00:26:46
Y los métodos necesarios son esos cuatro que decimos. 00:26:52
Pues esto es un término muy habitual para decir de forma resumida 00:26:56
las acciones que se hacen con los datos en una aplicación cualquiera. 00:27:01
Bueno, pues esas cuatro acciones en nuestra aplicación estarían aquí. 00:27:07
Insertar que la hemos hecho, eliminar que la podríamos hacer, 00:27:11
consultar que la podríamos hacer 00:27:14
y modificar 00:27:16
pues que podría ser algo así por ejemplo 00:27:17
modifica alumno 00:27:20
pues por ejemplo 00:27:25
le damos un nif 00:27:26
y al alumno con ese nif 00:27:28
le cambiamos su nombre 00:27:30
y su nota por ejemplo 00:27:33
vamos a hacerlo rápidamente porque este 00:27:34
es rápido también 00:27:41
modifica alumno pues sería 00:27:42
parecido a este 00:27:45
y ahora buscamos el alumno 00:27:46
y cuando ya lo hemos encontrado el alumno con ese NIF 00:27:55
el alumno cuyo NIF es este 00:27:58
cuando ya lo hemos encontrado 00:28:01
pues a ese alumno le modificamos con los nuevos datos 00:28:02
su nombre que sea el nombre que me han pasado por parámetro 00:28:05
y su nota que sea la nota que me han pasado por parámetro 00:28:10
vale, este sería el método de modificar 00:28:20
busco dentro de mi conjunto de datos de mi array 00:28:22
el alumno cuyo NIF es el que me han pasado 00:28:26
y cuando lo encuentre le cambio el nombre 00:28:28
y la nota por las que me han pasado 00:28:31
recordad que la clave primaria 00:28:32
no se cambia 00:28:35
porque entonces 00:28:37
no tiene mucho sentido, sería como cambiar el objeto 00:28:37
pero bueno, todas estas son cosas de bases de datos 00:28:41
vale, pues nos hemos hecho aquí 00:28:43
nuestra clase repositorio 00:28:49
que esta va por libre, esta la hace un programador 00:28:51
aparte, uno que ha dicho 00:28:53
oye, tú me haces el club de la base de datos 00:28:55
pues ya está, se ha sentado y ha hecho esto 00:28:57
y lo que haga el resto de los programadores le da igual 00:28:58
pues el resto de los programadores 00:29:01
ahora lo que harán será hacer 00:29:02
la aplicación que seguramente 00:29:04
necesite llamar a estos métodos 00:29:07
para hacer cosas 00:29:08
bueno 00:29:09
este método de aquí, por ejemplo 00:29:13
¿no le pondríais 00:29:17
algo, alguna cosita 00:29:19
aunque solo fuera una, una cosita 00:29:20
a la vista de esto que os estoy enseñando 00:29:22
¿no le pondríais una cosita 00:29:25
más a este método, una palabrita más 00:29:27
para facilitar su uso 00:29:28
static, o sea este método 00:29:30
solo usa variables 00:29:34
estáticas porque de hecho la clase no 00:29:36
tiene otra cosa que no sea variables estáticas 00:29:38
entonces este por definición es un método estático 00:29:40
solo está usando variables estáticas 00:29:42
entonces no es que 00:29:44
sea obligatorio, pero si yo se lo pongo 00:29:46
ahora ya, al 00:29:48
ponérselo, voy a poder 00:29:50
llamarlo mucho más fácilmente, voy a poder 00:29:52
llamarlo así, cuando quiera 00:29:54
yo hacer cosas, lo voy a 00:29:56
poder llamar con el 00:30:02
nombre de la clase sin más 00:30:04
inserta alumno 00:30:05
le paso el alumno que sea y lo inserta 00:30:09
si yo no hubiera puesto el static 00:30:11
porque no me doy cuenta 00:30:13
pues no es que pase nada 00:30:15
pero que es un rollo, ya no puedo llamarlo así 00:30:18
ya es imposible llamarlo así 00:30:20
tendría que instanciar un objeto repositorio 00:30:21
y llamarlo con el objeto, ¿y para qué? 00:30:23
¿para qué voy a instanciar un objeto repositorio 00:30:25
si no lo necesito? 00:30:27
pues le pongo el static 00:30:31
y estupendo 00:30:32
y eso pasaría con el resto 00:30:33
de los métodos 00:30:36
todos tendrían su static delante 00:30:37
vale 00:30:42
a ver, como lo estoy haciendo todo en el mismo paquete 00:30:47
me estoy despreocupando de los public y de todo 00:30:49
pero lo natural sería que estos 00:30:51
métodos estuvieran en el public porque yo los 00:30:54
fuera a usar desde otro paquete, etc 00:30:55
sería lo normal 00:30:57
que todo esto fuera public 00:30:59
porque esta clase está en un paquete 00:31:01
y se va a usar desde clases de otras 00:31:03
si yo no pongo el public lo voy a poder 00:31:05
usar desde 00:31:13
clases de fuera del paquete 00:31:13
¿Vale? Entonces 00:31:16
En cada cosa que hacemos 00:31:19
Yo estoy aprovechando para 00:31:21
Repasarlo todo, o sea, esto que estamos diciendo 00:31:23
Es de hace dos meses 00:31:25
¿Vale? Entonces 00:31:27
Verificad si realmente 00:31:28
Lo vais teniendo claro o no 00:31:31
¿Vale? Bueno, pues ya tengo mi clase 00:31:33
Repositorio 00:31:35
Vale, donde tengo mis datos 00:31:36
Entonces 00:31:39
Ahora 00:31:41
El que hace la aplicación 00:31:44
pues ahora ya se habrá puesto 00:31:46
en contacto con el cliente y dice, oye, yo quiero que mi aplicación 00:31:48
de gestión haga esto, pues inserte 00:31:50
alumnos, me compare 00:31:52
me diga, me busque el alumno 00:31:54
que se llama no sé qué 00:31:56
dados los alumnos, me diga 00:31:56
cuántos aprobados hay, pues lo que sea 00:32:00
entonces uno ya recoge 00:32:02
los requisitos y vamos a hacer 00:32:04
rápidamente, para que quede una aplicación 00:32:06
ya aprovechamos de repaso un poco así 00:32:08
más decente, vamos a hacer pues un 00:32:10
un main 00:32:12
un main 00:32:13
con un menú 00:32:15
para hacer las funcionalidades que hemos decidido hacer 00:32:16
por ejemplo 00:32:19
vamos a hacer un main que sea 00:32:22
insertar alumno 00:32:25
porque inicialmente 00:32:27
nuestro repositorio está vacío 00:32:28
entonces vamos a permitir insertar alumno 00:32:30
aquí se podría poner un montón más 00:32:32
eliminar alumno dado 00:32:35
ni modificar todas 00:32:36
yo voy a poner 00:32:38
insertar alumno 00:32:40
para poder insertar datos y trabajar con ellos 00:32:43
voy a poner 00:32:46
que muestre porcentaje de aprobados 00:32:48
para volver a trabajar 00:32:50
un poco con las sumas otra vez 00:32:55
y voy a poner también 00:32:56
que esta es la que me interesa de cara a las interfaces 00:32:59
que todo esto venía a cuento de las interfaces 00:33:01
voy a poner también una funcionalidad 00:33:03
que sea 00:33:05
ordenar alumnos por nota 00:33:06
porque hay que 00:33:08
darles un premio 00:33:11
y hay que tenerlos ordenaditos 00:33:13
a ver hasta dónde... 00:33:14
O sea, mostrar listado, ordenado por nota. 00:33:18
Y vamos a incorporar una 00:33:25
que sea mostrar listado sin más 00:33:26
para verificar según vayamos insertando 00:33:28
que lo está insertando bien. 00:33:30
Porque si no ponemos ninguna funcionalidad de mostrar 00:33:32
no podemos verificar 00:33:34
si lo está haciendo bien o mal. 00:33:36
Venga, nuestra aplicación tiene sólo 00:33:38
estas funcionalidades. 00:33:40
Puede meter alumnos, puede sacar el porcentaje 00:33:42
de aprobados y puede sacar listados. 00:33:44
¿Ordenados por nota o no? 00:33:46
Ya está. Esto es lo único que le interesa 00:33:48
al que nos pide la aplicación, poder hacer estas cosas 00:33:49
solo le interesa esto, pues estupendo 00:33:51
solo le interesa esto, vamos a hacerlo 00:33:54
¿vale? entonces el que 00:33:55
está haciendo esta aplicación main, como 00:33:58
veis, esta 00:33:59
ni la ha hecho ni le importa 00:34:01
lo único que le importa es 00:34:03
poder llamarla 00:34:05
si la necesita 00:34:07
pero como está hecha por dentro, le da 00:34:09
exactamente igual, la ha hecho otro programador 00:34:11
¿vale? 00:34:13
esto 00:34:17
es la ventaja de que el código 00:34:17
esté diseñado desde el principio 00:34:19
con desacoplamiento 00:34:21
las clases van por libre 00:34:22
bueno, pues venga, nuestro main 00:34:24
le voy a poner 00:34:26
la clase 00:34:30
esa teclado hard que hicimos para 00:34:33
leer por teclado 00:34:35
más rápido 00:34:37
vale, pues venga, la opción del main 00:34:38
recordad que tiene que estar fuera 00:34:51
para que luego 00:34:52
en el while 00:34:55
vamos a poner salir 00:34:55
Uno, dos 00:34:58
Tres 00:35:09
Cuatro 00:35:13
Y le voy a poner cero 00:35:15
Por si alguno añadiera 00:35:17
Funcionalidades 00:35:18
Vale, y hace esto mientras la opción 00:35:19
Sea diferente 00:35:24
De la de salir 00:35:28
Que es la cero 00:35:30
Vale, entonces aquí 00:35:32
Leeremos la opción 00:35:34
Y ahora una vez que hemos leído la opción 00:35:35
Pues el switch case 00:35:43
en el caso de que la opción sea 00:35:44
la opción que sea el numerito 1 00:35:54
vale, pues habría que pedir los datos del alumno 00:35:58
y pasárselo a la clase 00:36:06
al método, afortunadamente como tenemos 00:36:10
esta clase disponible, repositorio 00:36:15
que tiene el método insertalumnos 00:36:19
Y ahora, ¿qué vamos a insertar? 00:36:21
Un nuevo alumno 00:36:25
Lo estoy haciendo todo muy 00:36:26
En lugar de pedir 00:36:31
Introduzca NIF, introduzca nombre, introduzca no sé qué 00:36:34
Voy a poner los scans directamente 00:36:36
Ahí dentro, en el constructor y ya está 00:36:38
Pues le voy a 00:36:40
Decir que lea 00:36:42
El NIF 00:36:44
Le voy a decir que lea 00:36:46
El nombre 00:36:53
Y le voy a decir que lea la nota 00:36:54
¿Vale? 00:36:59
Hombre, para que no quede 00:37:04
Y ya estaría esta función 00:37:05
Bueno, me falta el break 00:37:07
A ver, para que no me quede tan feo 00:37:08
A la hora de ejecutarlo 00:37:13
Voy a ponerle un mensaje 00:37:14
Aunque sea 00:37:16
Introduzca NIF, nombre y nota 00:37:16
Voy a poner así 00:37:18
NIF 00:37:22
Nombre y nota 00:37:23
Entonces 00:37:25
Instalaría el objeto 00:37:28
Con NIF, nombre y nota 00:37:29
Creará un alumno 00:37:31
Y llamará a insertar alumno 00:37:33
De la clase repositorio 00:37:36
que lo insertará en el array correspondiente 00:37:38
como veis 00:37:41
esta es la primera vez 00:37:46
que mi main llama a la clase repositorio 00:37:48
es la primera vez 00:37:50
luego esta variable estática que yo he hecho aquí 00:37:51
esta aparece 00:37:54
esa no existía 00:37:58
porque es una variable asociada a esta clase estática 00:37:59
entonces no aparece hasta la primera vez 00:38:02
que se usa esa clase 00:38:04
¿cuándo es la primera vez que se usa? 00:38:05
pues aquí 00:38:08
en este momento 00:38:08
pues ahí en ese momento 00:38:11
me aparece esa variable estática 00:38:12
y ya se queda ahí para siempre, ya se queda ahí para siempre 00:38:15
porque es la primera vez 00:38:17
que uso esa clase 00:38:19
la primera vez que uso una clase es cuando me aparece todo lo estático 00:38:20
que tenga dentro, pues ahí me 00:38:23
aparece, la primera vez que la uso 00:38:25
me aparece y ya de paso 00:38:27
inserta a esta 00:38:29
y ya esa variable estática se queda ahí 00:38:30
ya para siempre, todo el tiempo que la 00:38:33
aplicación dure, ya se queda ahí siempre 00:38:35
esa variable estática, con mis datos 00:38:37
vale, pues venga, el caso 1 00:38:38
ya está, que es insertar a un alumno 00:38:41
Porcentaje de aprobados 00:38:42
Para hacer algo así 00:38:44
De siempre 00:38:46
Pues porcentaje de aprobados 00:38:48
Tendríamos que sumar los que tienen nota mayor o igual que 5 00:38:50
Y ya está 00:38:52
Entonces eso ya sabemos de toda la vida como hacerlo 00:38:53
Vamos sumando 00:38:56
Y se acabó 00:38:58
Para cada alumno 00:38:59
En mi array 00:39:06
Repositorio 00:39:07
Punto alumnos 00:39:12
veis lo cómodo que es 00:39:13
que mi array esté aquí 00:39:16
en una variable estática 00:39:17
mi array está aquí aparte en una variable estática 00:39:19
todos pueden acceder a él 00:39:21
y de forma tan sencilla 00:39:23
como llamar a la clase y esto 00:39:26
en lugar de tener mi array 00:39:28
ubicado aquí en el main y todo mezclado 00:39:30
tengo mi array de alumnos 00:39:32
ahí aparte en su clase repositorio 00:39:34
en una variable estática 00:39:35
pues ahora aquí simplemente haríamos 00:39:36
a.guernota 00:39:41
mayor 00:39:44
o igual que 5 00:39:48
pues en ese caso 00:39:51
suma 00:39:53
más igual a.guernota 00:39:55
no, ah que estoy contando 00:39:57
perdón, es porcentaje de aprobado, esto es un contador 00:39:59
no es nota media 00:40:01
y nada de eso 00:40:03
con más más 00:40:04
ala 00:40:07
pues estoy contando 00:40:09
mediante un contador 00:40:10
estoy contando todos los que tengan nota mayor o igual que 5. 00:40:13
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
26 de febrero de 2024 - 18:53
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
40′ 25″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
175.65 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid