Saltar navegación

20251202 POO_ClasesMetodos_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 3 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, ¿vienen hasta aquí? Vale, pues por ejemplo, para seguir un poquito con ejemplos, que resulta que mi aplicación no es un instituto con dos alumnos solo, que es muy poquito, sino que tiene mil. 00:00:00
Vale, que resulta que mi aplicación no va a trabajar solo con dos alumnos, sino con mil alumnos, pues no tiene sentido que me haga alumno 1, alumno 2, alumno 3, ¿qué me puedo hacer entonces? 00:00:25
si quiero trabajar con mil 00:00:38
un array 00:00:40
vale 00:00:42
pues 00:00:44
por ejemplo 00:00:45
resulta que mi aplicación va a trabajar 00:00:48
mi instituto tiene mil 00:00:57
pues me hago un array de mil 00:00:58
alumnos, entonces igual que yo 00:01:01
me hacía un array de números enteros 00:01:03
¿cómo me lo hacía? 00:01:05
pues lo hacíamos así ¿verdad? 00:01:06
new int 00:01:09
así me hacía yo un array 00:01:10
para mil números enteros 00:01:15
pues aquí en lugar de mil 00:01:17
números enteros, lo que quiero es 00:01:19
mil variables tipo alumno 00:01:21
pues entonces el int 00:01:23
lo cambio por 00:01:25
alumno, porque ahora mi tipo de dato ha cambiado 00:01:27
ahora ya no es int, ahora es 00:01:29
alumno 00:01:31
vale, ahora es alumno 00:01:32
entender la clase 00:01:37
como la creación de un tipo 00:01:39
de datos propio que me he inventado yo 00:01:41
y es un tipo de datos propio 00:01:43
complejo porque tiene tres partes 00:01:46
pero es un tipo de datos más 00:01:48
del que declaramos variables 00:01:50
si nos da la gana, como aquí 00:01:52
variables que al ser objeto hay que crear 00:01:54
declaro array si me da la gana 00:01:56
¿vale? entonces aquí lo único 00:02:00
ojo, cuidado 00:02:02
con el array 00:02:04
¿por qué? ahora estamos hablando 00:02:05
de objetos 00:02:13
entonces con new alumno 00:02:13
yo me estoy creando mil posiciones 00:02:16
mil posiciones 00:02:19
de variables 00:02:21
de tipo alumno 00:02:23
pero es que ya sabemos lo que es una variable de tipo alumno 00:02:24
en realidad es una dirección de memoria 00:02:26
que te apunta a algún sitio 00:02:28
esto es lo que nos estamos creando 00:02:29
pero los alumnos todavía no están 00:02:32
con esta declaración 00:02:35
con esta declaración 00:02:37
de arriba 00:02:39
yo tengo esta tabla 00:02:39
pero los alumnos todavía no los he creado 00:02:41
Me falta hacer todos los news 00:02:44
Para crear los espacios 00:02:47
¿Vale? Valeria no se come 00:02:49
En clase 00:02:51
Bueno 00:02:52
Pues resto del mundo 00:02:54
No se come en clase 00:02:59
¿Vale? Entonces con esto 00:02:59
He declarado esta parte 00:03:02
Me falta esta de aquí 00:03:04
Pues menos mal que está en un array 00:03:06
Y no tengo que hacer mil news uno tras otro 00:03:08
Menos mal que está en un array 00:03:10
Y no tengo que hacer mil news uno tras otro 00:03:12
Vamos a recorrer el array 00:03:13
vamos a recorrerlo 00:03:15
con un for 00:03:17
de toda la vida de Dios 00:03:20
vale, pues me recorro mi array 00:03:21
como recorro los arrays de siempre 00:03:43
y ahora, números de i 00:03:45
¿ahora qué es números de i? 00:03:47
números de i es una variable 00:03:50
alumno 00:03:51
un objeto alumno 00:03:52
que está declarado, sí, pero que está todavía 00:03:54
sin crear, su espacio está todavía sin crear 00:03:57
entonces, antes 00:03:59
de nada tendré que hacer esto 00:04:01
con todos y cada uno de ellos. 00:04:03
¿Vale? 00:04:06
Antes de nada, con todos y cada uno 00:04:07
de ellos, con números 0, números 1, números 2, 00:04:09
tendré que hacer esto 00:04:12
para crear su espacio. 00:04:12
Igual que aquí, después 00:04:15
de declarar alumno 1, 00:04:17
le he creado el espacio. 00:04:20
Pero aquí solo tenía 1. 00:04:23
Y he creado el espacio para ese. 00:04:25
Pero aquí tengo 1000. 00:04:28
Pues para cada uno de ellos, 00:04:30
Números 0, así hasta número 99 00:04:31
Le creo su espacio 00:04:33
Y ahora ya sí que tengo esos objetos 00:04:34
Para hacer con ellos lo que me dé la gana 00:04:36
Por ejemplo 00:04:38
Vamos a ponerles a todos 00:04:41
Edades aleatorias 00:04:42
Entre 0 y 00:04:44
100, por ejemplo 00:04:47
Pues venga, vamos a recorrer 00:04:48
Nuestro array 00:04:51
¿Alguien ha llamado? 00:04:52
Dime 00:04:57
Vale 00:04:57
Vale, pues por ejemplo 00:05:01
Vamos 00:05:11
Números de i 00:05:13
Es el alumno en posición i 00:05:17
He dicho que a la edad de cada alumno 00:05:20
Es a la que le voy a dar una edad aleatoria 00:05:22
Pues yo que sé 00:05:24
Por 100 00:05:30
Para que me genere entre 0 y 100 00:05:32
Aprox 00:05:36
Casting de int 00:05:36
Pues que te va a generar 0 todo el rato 00:05:40
Porque más random te generan 0, 0,1 00:05:45
0, entre 0 y 1 00:05:48
Entonces al hacerle int 00:05:49
Van a ser 0 siempre 00:05:51
Vale, pues así por ejemplo 00:05:52
He asignado 00:05:54
Edad aleatoria 00:05:56
A todos los alumnos de la RAI 00:06:05
vale, vamos a mostrarlos 00:06:08
si hacemos eso pero en el 00:06:13
fichero de alumno, en donde se crea 00:06:18
la clase, no habrá que poner 00:06:20
esto, ¿no? 00:06:22
vale, no, pero es que la idea de los 00:06:25
métodos que pones aquí son los que trabajan con 00:06:26
un único alumno, ahora cuando 00:06:28
nos metamos en método entenderás, esto no trabaja con 00:06:30
uno en particular, sino que trabaja con todos 00:06:32
pero bueno, sí, se podría hacer un método 00:06:34
que fuera, dame una 00:06:37
daza aleatoria a mí mismo, y luego lo llamo 00:06:38
para todos, vale, ahora lo hacemos, vale, cuando nos 00:06:40
metamos en métodos 00:06:42
vale 00:06:43
con esto asignaría 00:06:44
aleatoria a todos, vale 00:06:48
entonces vamos a mostrarlos 00:06:50
y ya está, pues venga, vamos a mostrarlos 00:06:51
para variar, voy a recorrer 00:06:54
en un for each, porque estoy 00:06:56
consultando, no estoy 00:06:58
pues para cada alumno, ah 00:07:00
en mi array 00:07:02
jolín 00:07:04
le he llamado números, que poco explicativo 00:07:05
voy a cambiarle el nombre de la array 00:07:08
a alumnos 00:07:11
¿eh? 00:07:13
podéis refactorizar o hacerlo con 00:07:23
atajo, como os dé la gana 00:07:25
vale 00:07:26
vale, pues para cada alumno 00:07:27
¿vale? este es el for each de toda la vida 00:07:33
es un bucle 00:07:38
que va recorriendo el array que yo ponga aquí 00:07:40
el array que yo ponga aquí 00:07:42
y este elemento 00:07:44
quedándose con una copia 00:07:47
de todos y cada uno de los elementos del array 00:07:50
claro, este elemento se tiene que 00:07:52
declarar como alumno, porque el array es de alumnos 00:07:54
en cada iteración 00:07:56
A va teniendo cada uno de los elementos 00:08:01
del array, en la primera iteración 00:08:04
A es el primer alumno del array, una copia 00:08:06
en la segunda iteración 00:08:08
A es una copia del segundo elemento del array 00:08:10
luego este for each 00:08:12
no acaba hasta que no has recorrido 00:08:14
todo el array 00:08:16
¿cuándo le di valor a quién? 00:08:17
A es una variable temporal auxiliar 00:08:25
que solo vive, solo tiene vida aquí dentro 00:08:29
de este for y se va rellenando 00:08:32
en cada iteración con cada uno de los alumnos 00:08:34
pero es una variable 00:08:36
que solo vive ahí dentro 00:08:37
cuando el forish termina desaparecido 00:08:39
y sirve para irse quedando con una copia 00:08:41
de cada alumno en las sucesivas iteraciones 00:08:43
ya está 00:08:45
vale, pues entonces, efectivamente 00:08:45
si yo trato de mostrar al alumno a lo bestia 00:08:48
a ver, en lugar de mil 00:08:50
vamos a ponerle menos para que no me salgan ahí 00:08:54
200.000 líneas, vamos a hacer 00:08:56
un array de 10 solamente, no de mil alumnos 00:08:58
de 10 00:09:01
gracias a que 00:09:02
he tirado de len, si no he puesto 00:09:06
tal cual, mil 00:09:08
El cambio de código es inmediato 00:09:09
Me voy aquí, lo cambio y ya está 00:09:11
Vale, pues 00:09:13
Vamos a ejecutar este código 00:09:14
Primero a la parte de arriba 00:09:17
Y luego se pondrá a mostrar todo eso 00:09:19
Vale, entonces 00:09:22
Estos son los 10 alumnos 00:09:31
Efectivamente me está mostrando 00:09:33
Algo muy extraño, ¿qué es esto? 00:09:35
Claro, porque el SISO 00:09:37
Aquí le estamos dando una caja con cosas dentro 00:09:39
No le estás dando 00:09:42
Una única cosa, un string, un int 00:09:43
como le dábamos antes, que él, el stringer 00:09:45
lo sabe mostrar, aquí le damos 00:09:47
una caja con un montón de basurilla 00:09:49
entonces él, ya entendemos 00:09:51
por qué, te hace un aplanamiento 00:09:53
extraño, ya entenderemos por qué 00:09:55
y te dice, me das una caja con un montón 00:09:57
de cosas raras, te muestro 00:09:59
un aplanamiento muy raro y paso 00:10:01
de ti, claro 00:10:03
o le decimos cómo aplanar 00:10:04
que eso todavía no sabemos 00:10:07
o le tendremos que decir que muestre 00:10:08
las propiedades por separado 00:10:11
entonces hombre, aquí 00:10:12
Y pues tiene sentido. 00:10:14
¿Qué quieres mostrar? ¿La edad? 00:10:16
Pues ahora esto ya sí lo vas a ver mostrar. 00:10:21
Porque a.edad será la edad de cada uno de los alumnos. 00:10:23
Por ejemplo. 00:10:30
¿Vale? Pues ahora con esto. 00:10:40
¿Vale? Pues estas son las 10 edades que ha generado. 00:10:51
¿Vale? Este era de un System.out que está arriba. 00:10:56
¿Vale? 00:10:59
Que este System.out es 00:11:00
De donde está 00:11:04
De aquí 00:11:05
¿Vale? 00:11:07
Entonces lo ponemos aquí 00:11:10
Si lo mostramos así 00:11:13
Como tiene 00:11:18
Varios elementos 00:11:21
Nos muestra 00:11:25
Algo raro 00:11:32
Un resumen raro 00:11:34
Ese resumen raro nos vale 00:11:35
Tendríamos que mostrar las propiedades por separado 00:11:37
entonces esto lo voy a poner aquí 00:11:39
entonces nunca 00:11:43
mientras no sepamos 00:11:49
mientras no sepamos 00:11:52
cómo decirle a Java que ese resumen 00:11:54
lo haga a mi gusto 00:11:56
mientras no sepamos, no mostramos un alumno dando el alumno 00:11:57
entero, porque es una caja con cosas 00:12:00
él muestra, yo que sé, le hace así 00:12:01
la caja y muestra lo que sea 00:12:04
mientras no sepamos cómo aplanar la caja 00:12:05
vamos a tener que decirle 00:12:08
que 00:12:10
nos muestra propiedad por propiedad 00:12:10
no, no hemos hecho nada importante 00:12:14
vale 00:12:23
esto sí que lo haríamos 00:12:26
alumno1.nombre 00:12:27
onif 00:12:30
alumno1.nombre 00:12:31
no, es que 00:12:38
los métodos los hemos dejado en blanco todavía 00:12:45
porque estamos por ahora entendiendo cómo funciona 00:12:47
esto y lo que te rondaré morena 00:12:49
porque hemos visto un 0,01% 00:12:51
de todo lo que tenemos que aprender 00:12:54
esto sí nos mostraría cosas con sentido 00:12:55
esto sí, esto no 00:13:01
si ejecutamos esto 00:13:02
esto nos muestra algo raro 00:13:04
porque le he pasado al alumno al completo 00:13:09
y aquí le he pasado propiedad por propiedad 00:13:11
esto ya sí 00:13:13
bueno, pues más o menos la dinámica entendida 00:13:14
¿no? 00:13:17
vale 00:13:19
pero 00:13:19
esta aplicación 00:13:22
solo tiene una entidad 00:13:24
y si tuviera 00:13:27
dos, por ejemplo, ahora vamos a 00:13:30
trabajar con alumnos que tienen 00:13:32
cada uno su matrícula, mi aplicación 00:13:34
va a gestionar, pues que alumno 00:13:36
ha pagado la matrícula, que patatín 00:13:38
patatán, vale, pues entonces 00:13:40
yo me voy con el 00:13:42
cliente y le digo, oye la matrícula 00:13:43
¿cómo se caracteriza 00:13:47
de que va la matrícula? le digo, oye pues la matrícula 00:13:48
tiene un código, tiene 00:13:50
un nombre de 00:13:52
matrícula, pues de dam, dau 00:13:54
y tiene un precio 00:13:56
vale, pues entonces es una 00:13:57
entidad compleja 00:14:00
porque si me dijeran la matrícula 00:14:01
es un precio, ya está, pues la podría declarar 00:14:04
como dabble, porque en un dabble 00:14:06
me cabe el precio, ya está, podría 00:14:08
matrícula, dabble, pero no 00:14:09
la matrícula tiene su nombre, tiene su 00:14:12
precio, tiene su no sé qué, pues tengo que hacerme 00:14:14
una clase matrícula que tenga todo eso 00:14:16
pues venga, vamos a 00:14:18
ampliar la aplicación 00:14:20
ahora con matrícula 00:14:21
a la otra clase más, matrícula 00:14:31
Le quito el public para no liarnos 00:14:32
Matrícula, ¿por qué se va a caracterizar? 00:14:35
Pues se va a caracterizar 00:14:38
Por un código de matrícula 00:14:39
Por ejemplo 00:14:41
Se va a caracterizar por una descripción 00:14:42
Y se va a caracterizar 00:14:46
Por un precio 00:14:50
Una cantidad 00:14:52
Por esas tres cosas 00:14:55
Se va a caracterizar 00:14:59
Vale, entonces podríamos 00:15:00
Instanciar matrículas 00:15:03
ver los precios que tiene, etc. 00:15:04
Pero lógicamente 00:15:07
os vendrá a la cabeza 00:15:08
una pregunta natural 00:15:10
sobre esta aplicación. 00:15:11
¿No os canta algo raro? 00:15:14
Tengo alumno con sus propiedades, 00:15:15
matrícula con las suyas, 00:15:18
una aplicación que gestiona matrículas de alumnos. 00:15:19
¿Qué os suena aquí un poco extraño? 00:15:21
Eso. 00:15:26
Muy bien. 00:15:27
Tengo mis alumnos, tengo las matrículas, 00:15:27
pero esta aplicación gestiona matrículas de alumnos. 00:15:29
O sea, las matrículas solo tienen sentido 00:15:32
si son de un alumno, las matrículas 00:15:34
los alumnos sí pueden estar sueltos por la vida 00:15:35
pero una matrícula es de un alumno 00:15:37
entonces 00:15:40
nos falta algo fundamental en este diseño 00:15:40
que el alumno 00:15:44
tiene su matrícula 00:15:46
luego 00:15:48
esto automáticamente ahora ya 00:15:48
me hace que yo modifique la clase alumno 00:15:51
porque ahora alumno se va a caracterizar 00:15:53
por su NIF 00:15:55
su nombre, su edad 00:16:00
y ahora le aparece 00:16:01
una propiedad nueva 00:16:03
que es su matrícula 00:16:04
y matrícula es otra 00:16:08
propiedad más 00:16:14
lo que pasa es que esta es de un tipo 00:16:15
complejo, es del tipo 00:16:18
matrícula, nif y nombre son 00:16:20
string, porque con un string se queda 00:16:22
completamente caracterizado nif y nombre 00:16:24
el hace su nint, porque con un número se queda 00:16:26
completamente caracterizado edad 00:16:28
pero matrícula no se queda 00:16:29
completamente caracterizado con un 00:16:32
double o con un string, porque matrícula 00:16:34
tiene muchas cosas dentro 00:16:36
entonces me tendré que hacer mi clase matrícula 00:16:37
con todas las cosas que tiene dentro 00:16:41
y ahora ya sí, alumno tendrá dentro de sí 00:16:43
un objeto matrícula suyo 00:16:47
con sus propios datos 00:16:50
luego, las clases, los objetos 00:16:51
tienen dentro otros objetos que los caracterizan 00:17:01
porque si no, el modelo se quedaría muy sencillo 00:17:04
muy simple 00:17:06
y esto no nos tiene que asustar 00:17:07
porque matrícula es otra variable más 00:17:09
es otra variable más, lo que pasa es que es de este tipo de dato 00:17:12
y yo aquí ni hago new ni hago nada 00:17:15
no hay necesidad porque aquí estoy en la clase, estoy en la plantilla 00:17:18
aquí lo que digo es, oye que mi alumno va a tener un nif 00:17:21
mi alumno va a tener un nombre, mi alumno va a tener una edad 00:17:25
y mi alumno va a tener una matrícula, pero todavía no hay nada real 00:17:27
aquí no existe nada todavía, esto es una plantilla 00:17:30
aquí no hay ningún nif, no hay ningún nombre 00:17:33
no hay ninguna edad y no hay ninguna matrícula, no hay nada 00:17:36
por eso ni hago new ni hay nada, solamente hay 00:17:38
unas casillas diciendo 00:17:41
el alumno tiene casilla 00:17:44
nif, casilla nombre, casilla edad, 00:17:46
casilla matrícula. Pero esas casillas 00:17:48
solo se van a 00:17:50
rellenar cuando 00:17:52
el programa se lance y 00:17:54
aparezcan los alumnos. 00:17:55
Bueno, pues para no liar 00:18:00
vamos a hacernos un main2 00:18:01
que 00:18:03
crea ahora matrículas, se las ponga alumnos, 00:18:05
etc. Este main, este 00:18:07
proyecto de ejemplo, como lo subimos 00:18:09
luego, este main lo dejamos así 00:18:11
que es el que trabaja con objetos 00:18:13
normales y corrientes, que no tiene 00:18:15
ni otros objetos dentro, ni nada 00:18:17
a ver 00:18:19
solo uno, la máquina 00:18:25
virtual solo va a tener 00:18:27
solo va a tener en cuenta uno, el otro no se va a arrancar nunca 00:18:28
si tiene dos, o yo me voy a hacer otra clase 00:18:31
main, le voy a decir, arranca ahora este, con lo cual 00:18:33
este otro es como si no existiera, nunca va 00:18:35
a ser arrancado 00:18:37
digamos que en un paquete solo podemos tener 00:18:38
a ver, puedes tener todos los que quieras 00:18:41
Pero, claro, una ejecución solo puede empezar por uno. 00:18:45
Tú eliges por cuál, ¿vale? 00:18:52
Eliges por cuál. 00:18:54
Cada ejecución arranca en un único main, en un único main. 00:18:55
Entonces, voy a hacer otro main que significaría darle otro 00:19:00
punto de arranque a la aplicación, 00:19:02
otro punto de arranque, para elegir si la arranco desde este 00:19:04
o desde este otro, ¿vale? 00:19:06
Entonces, me voy a hacer otra clase con otro método main que 00:19:08
sería otro punto de arranque. 00:19:11
Es como hacer otra aplicación distinta, otra distinta. 00:19:12
Pues venga, me voy a hacer aquí un 00:19:14
main2 00:19:17
No, aquí 00:19:18
con el diseño que yo he hecho 00:19:31
un alumno tiene una única matrícula 00:19:33
si tuviera varias, lo puede hacer 00:19:36
pero entonces tengo que cambiarlo a esto 00:19:37
con el diseño que yo he hecho 00:19:39
un alumno tiene una matrícula, o sea, esto lógicamente 00:19:42
está completamente 00:19:44
ligado al diagrama de la relación 00:19:46
esto sería una relación de uno a uno 00:19:48
un alumno, una matrícula, o de 0 a 1 00:19:50
porque puede haber un alumno sin matrícula 00:19:53
a lo mejor, podría 00:19:55
esta sería de 1 a 1, que yo la quiero 00:19:56
de 1 a muchos, pues es así 00:19:59
bueno, si estás 00:20:01
trabajando con una base de datos, sí, pero ahora mismo 00:20:05
nosotros estamos trabajando con una base de datos 00:20:07
es bueno que 00:20:09
nuestros datos no vienen de una base 00:20:11
de datos, los vamos a ir creando 00:20:13
o sea, es bueno que veáis ese paralelismo 00:20:15
en cuanto al concepto 00:20:17
¿vale? pero ahora mismo nuestros datos 00:20:19
no están en una base de datos, luego no hay ni 00:20:21
de relación, los metemos por teclado 00:20:23
vale 00:20:25
bueno pues entonces 00:20:27
mi otra aplicación 00:20:30
esta es otra aplicación porque es otro main 00:20:32
luego esta es otra 00:20:35
esta es otra porque es otro main 00:20:36
pues venga, vamos a hacernos un alumno 00:20:38
el que yo decida 00:20:41
es que yo no arranco, es que claro, yo cuando arranco una aplicación 00:20:45
arranco un main, le digo este 00:20:48
claro 00:20:49
porque si yo arrancara la aplicación como tal así 00:20:51
le tengo que 00:20:54
decidir en las configuraciones de ejecución 00:20:56
cuál de las dos elegir 00:20:58
¿vale? porque si no él no sabe 00:20:59
por cuál arrancar 00:21:02
¿te va a arrancar por uno o te va a arrancar por otro? 00:21:03
nunca por los dos 00:21:08
vale, pues a ver 00:21:08
mi este de aquí 00:21:11
relax 00:21:13
venga, pues si yo me hago un alumno 00:21:16
Aquí tengo mi alumno 00:21:20
Vale 00:21:27
El alumno ya tiene espacio para sus propiedades 00:21:28
Pues venga, mi alumno 00:21:33
Le vamos a dar 00:21:35
Tiene un NIF 00:21:37
Muy bonito 00:21:39
Y tiene un nombre, muy bonito 00:21:40
Lo podía leer por teclado 00:21:45
Claro, en lugar de dárselo directamente 00:21:52
Esto ya es lo que la aplicación me diga 00:21:55
Tiene su edad 00:21:56
muy bonita también 00:22:00
le voy a dar 00:22:09
una matrícula 00:22:12
entonces alumno.matricula 00:22:13
¿qué necesita? 00:22:15
un objeto matrícula 00:22:18
luego ¿qué pondríais ahí? 00:22:20
muy bien 00:22:23
antes que nada habría que crear 00:22:24
el objeto matrícula para él 00:22:26
antes de nada, antes de empezar a hablar 00:22:27
creamos el objeto matrícula 00:22:29
y ahora ya podemos meternos en la matrícula 00:22:31
para darle los datos 00:22:34
entonces 00:22:35
ahora, que yo quiero 00:22:38
a mi matrícula darle un código 00:22:40
pues sería 00:22:42
alumno.matrícula 00:22:43
y ahora que pondría 00:22:46
.código 00:22:46
y así me puedo ir hasta el infinito 00:22:49
porque si matrícula tuviera dentro otro objeto 00:22:52
seguiría con el punto y punto y punto 00:22:54
y así hasta el infinito 00:22:56
código 00:22:57
ala, pues mi alumno 00:22:59
tiene una matrícula 00:23:01
cuyo código es 43 00:23:04
descripción 00:23:05
pues mi alumno está 00:23:13
matriculado en DAM 00:23:15
mi alumno 00:23:17
cantidad, ¿cuánta cantidad 00:23:24
va a pagar de matrícula? 00:23:31
pues eso 00:23:33
¿vale? entonces es 00:23:34
aplicar el mismo criterio todo el rato 00:23:36
si alumno matrícula es un objeto 00:23:39
porque lo es 00:23:41
pues tendré que crear espacio para él 00:23:43
antes de nada 00:23:45
edad era un número, por eso no he hecho el niño 00:23:46
Porque es un número, le asigno el número y ya está 00:23:49
Nif es un string, trabajo como trabajo 00:23:50
Con los string, asigno el valor y ya está 00:23:53
Pero matrícula es un objeto 00:23:55
Matrícula, pues tengo que crearlo 00:23:57
Antes de nada 00:23:59
Y luego ya, ¿qué le quiero dar propiedades? 00:24:00
Pues se las doy 00:24:03
¿Vale? ¿Qué quiero mostrar 00:24:04
Mi alumno? Pues con esto no haríamos nada 00:24:12
Lógicamente, yo podría mostrar 00:24:14
Lo que me diera a mí la gana 00:24:16
¿Vale? Aquí ya podríamos mostrar lo que quisiéramos 00:24:17
Pues alumno 00:24:30
Su matrícula 00:24:32
Por su código, lo que yo quisiera 00:24:34
O la cantidad, lo que vas a pagar 00:24:36
No, lo acabamos de hacer hace un ratito 00:24:39
Y acabo de explicar por qué no funciona 00:24:45
¿En qué estabas pensando? 00:24:47
Pero ¿qué vas a correr con un for each? 00:24:51
Aquí no hay ningún array 00:24:52
No puedes recorrer nada con un for each 00:24:53
¿Vale? 00:24:55
Entonces voy a ejecutar este main 00:25:05
Aquí, ligado con lo que me preguntabais antes 00:25:06
Efectivamente 00:25:10
Yo hago varios mains 00:25:11
pues para poder practicar diferentes cosas 00:25:13
sin mezclar el código 00:25:17
y que luego quede más claro. 00:25:18
Claro, si entendemos este proyecto 00:25:19
como una aplicación completa, 00:25:21
yo no puedo arrancar esta aplicación sin más 00:25:24
porque la máquina virtual se volvería loca. 00:25:26
Me diría, pero escúchame, 00:25:29
dime el punto de arranque, 00:25:31
dime el punto de arranque cuál es. 00:25:33
Entonces, si lo puedo configurar aquí 00:25:35
en configuraciones de arranque, 00:25:36
en run configuratios, 00:25:38
pero ahora no nos vamos a meter en eso. 00:25:40
que yo quiero ejecutar este 00:25:41
pues aquí botón derecho run este 00:25:43
ya está, que quiero ejecutar este 00:25:45
pues aquí botón derecho run este y ya está 00:25:47
y ese se convierte automáticamente en el punto de arranque 00:25:49
pues venga 00:25:52
vamos a ejecutar el 2 00:25:53
vale, pues este apagado 00:25:55
76, bueno pues 00:25:59
esta dinámica de crear clases 00:26:10
con sus propiedades 00:26:12
y acceder a ellas 00:26:14
con el operador 00:26:16
punto, para darles valor 00:26:18
o para recuperarlo, para mostrarlo, 00:26:20
está cogida. 00:26:24
Ya sabemos cómo crear una clase, 00:26:26
cómo darle, asignarle propiedades 00:26:29
y luego cómo instanciar objetos de esa clase 00:26:32
y dar valor a sus propiedades. 00:26:35
Y con esas propiedades yo luego opero 00:26:38
como cualquier otra variable. 00:26:40
Opero y hago lo que me dé la gana, 00:26:42
como cualquier otra. 00:26:43
O lo meto en un array, lo que quiera. 00:26:45
Los métodos hemos dicho que son 00:26:55
trozos de código 00:26:56
que un objeto alumno puede ejecutar 00:26:58
entonces esos trozos de código 00:27:01
se supone que son 00:27:03
cosas que a ti te interesa 00:27:04
que a ti te interesa hacer con los alumnos 00:27:07
o sea, tú has estudiado 00:27:09
bien tu aplicación, te has entrevistado 00:27:11
con el cliente, has mirado mil cosas 00:27:13
y ya tienes claro que es lo que 00:27:14
tu aplicación necesita hacer 00:27:17
pues ponerle a un alumno 00:27:18
si ha pagado la matrícula o no la ha pagado 00:27:21
cambiarle el nombre 00:27:23
porque se ha cambiado de nombre 00:27:24
pues decirme si es mayor de edad o no 00:27:26
hay cosas que a lo mejor tu aplicación 00:27:29
va a querer hacer con los alumnos 00:27:31
por ejemplo 00:27:33
una muy fácil, pues a lo mejor 00:27:34
el tipo de secretaría 00:27:39
que me ha pedido la aplicación me ha dicho 00:27:42
oye perdona, yo necesito saber 00:27:43
de un alumno si es mayor de edad o no 00:27:45
porque en función de eso 00:27:47
hago unas cosas o hago otras, entonces tu aplicación 00:27:48
tiene que tener una funcionalidad 00:27:51
para decirme si un alumno 00:27:54
es mayor de edad o no, la tiene que tener porque 00:27:55
yo voy a invocar a esa funcionalidad 00:27:57
para obtener respuesta. 00:27:59
Vale, pues entonces, 00:28:02
automáticamente, nosotros ya como programadores decimos 00:28:03
vale, pues para cada alumno 00:28:05
me va a interesar saber 00:28:07
si es mayor de edad. 00:28:09
Requisito. Pues entonces, 00:28:11
en la clase alumno, me voy 00:28:13
a, porque esta operativa 00:28:15
tiene que ver con alumnos, porque 00:28:17
si el alumno es mayor de edad, 00:28:19
pues en la clase alumno, que es su sitio, 00:28:22
me voy a meter un trozo de código 00:28:23
que me diga 00:28:27
si un alumno es mayor de edad o no 00:28:28
me lo voy a meter en la clase alumno 00:28:30
porque repito, esta operativa, esta funcionalidad 00:28:32
está relacionada con alumnos 00:28:34
que me dice el de secretaría 00:28:36
oye, también necesito saber si una matrícula está pagada o no 00:28:38
por ejemplo 00:28:41
o si el precio supera 00:28:41
el precio establecido 00:28:44
pues de, uy, esto que me estás pidiendo tiene que ver con matrículas 00:28:45
pues este trozo de código te lo voy a meter en matrícula 00:28:48
pero estamos con lo de ser mayor de edad 00:28:51
Vale, pues entonces, ahora ya vamos a programar un código que me diga si un alumno es mayor de edad o no. 00:28:53
Un método. 00:29:04
¿Dónde lo meto eso? 00:29:06
En alumno, porque yo he decidido que es ahí su sitio, porque tiene que ver con alumnos. 00:29:07
Pues ahora vamos a hacer método que devuelve true o false en función de si el alumno es mayor de edad o no. 00:29:12
vale 00:29:27
pues entonces 00:29:43
esto de aquí es un poco lo más complicado 00:29:45
de entender y lo más complicado de explicar 00:29:48
ahora haciendo 00:29:50
este método, primero hay que 00:29:52
darle un nombre, el método 00:29:54
es el trozo de código que voy a hacer aquí 00:29:56
un trocito de código relacionado con esto 00:29:57
a ese trozo de código vamos a darle 00:29:59
un nombre, para luego tenerlo identificado 00:30:02
y poder llamarlo desde otros sitios 00:30:04
pues por ejemplo, un nombre explicativo 00:30:05
mayor 00:30:10
de edad. Así. 00:30:10
Por ejemplo. 00:30:14
Al método 00:30:16
le doy, elijo 00:30:18
un nombrecito, por ahora estoy eligiendo el nombre. 00:30:20
Elijo un nombre lo más 00:30:22
explicativo posible, un nombre lo más 00:30:24
explicativo 00:30:26
y que empiece por minúscula 00:30:26
también como convenio. 00:30:30
Igual que las propiedades, por minúscula 00:30:32
como convenio. No es obligatorio, 00:30:34
no lo es, pero luego queda 00:30:36
más claro el código, hacedme caso. 00:30:38
vale 00:30:40
entonces a este método que me faltan 00:30:41
a mí ahora me faltan mil cosas todavía 00:30:43
por ponerle esto ahora mismo 00:30:46
he elegido el nombre 00:30:48
lo único que he hecho es elegir el nombre, no he hecho nada más 00:30:50
me faltan todavía mil cosas 00:30:52
por hacer, lo único que he hecho 00:30:54
es elegir el nombre del método 00:30:56
vale 00:30:57
a este método ¿quién lo va a llamar? 00:30:58
pues a los métodos de una clase 00:31:03
los llaman los objetos 00:31:05
de la clase 00:31:08
el método se declara aquí 00:31:09
pero luego el que lo llama 00:31:12
el que lo invoca, el que lo ejecuta 00:31:14
es un objeto de la clase 00:31:16
es decir, este método 00:31:17
cuando ya esté hecho, que está sin hacer 00:31:20
¿quién lo va a ejecutar? 00:31:22
no se va a ejecutar aquí, aquí está simplemente 00:31:24
escrito para ver lo que hace 00:31:26
pero ahí no se ejecuta 00:31:27
¿quién va a ejecutar este método? pues yo en mi main 00:31:29
¿vale? 00:31:32
me voy aquí a este main 00:31:34
por ejemplo, al main2 de la matrícula 00:31:35
Y vamos a ver, pues por ejemplo, quiero ver si el alumno, este que me acabo de crear, el único, es mayor de edad. 00:31:40
Pues entonces, este alumno, el objeto alumno, este, es el que llamará al método, este. 00:31:52
Luego los métodos no se llaman así por las buenas de la nada, los llama siempre un objeto perteneciente a la clase donde está el método. 00:32:02
Entonces, ¿cómo lo va a llamar? 00:32:14
alumno.nombreDelMétodo 00:32:18
y unos paréntesis que le explicaremos por qué. 00:32:23
Luego, igual que a las propiedades las llama 00:32:31
.nombreDeLaPropiedad para dar un valor, 00:32:33
al método lo va a llamar .también 00:32:37
nombreDelMétodo. 00:32:40
Pero es fundamental entender, 00:32:42
y aquí está la clave de todo, 00:32:44
que a ese método que yo voy a hacer, 00:32:45
que está sin hacer, 00:32:47
el que le llamas siempre es un objeto. 00:32:49
No aparece de la nada. 00:32:51
No es que llamemos a es mayor de edad y ya está. 00:32:53
No, lo llama siempre un objeto. 00:32:55
Y entonces, este método va a trabajar con este objeto. 00:32:59
Con este, no con otro, con este. 00:33:03
Entonces, ahora, cuando yo programe este objeto, 00:33:06
aquí, perdón, este método, 00:33:09
es mayor de edad. 00:33:11
Ahora ya voy a empezar a programarlo. 00:33:12
vale, pues en estas interrogaciones 00:33:14
que yo he puesto aquí delante 00:33:16
¿qué es lo que pongo? 00:33:17
si ese método 00:33:21
me va a devolver 00:33:22
algo como valor de vuelta 00:33:24
o no 00:33:26
puede que no me devuelva nada, puede que sí 00:33:27
todo esto lo iremos entendiendo 00:33:30
en este caso, este método 00:33:31
¿qué me va a devolver? 00:33:33
me tiene que devolver o true o false 00:33:36
con lo cual lo que me va a devolver es un boolean 00:33:38
pues ¿qué pongo yo aquí? 00:33:41
el tipo de dato del valor de vuelta 00:33:42
vale, pues este método 00:33:46
me va a devolver 00:33:48
un boolean 00:33:50
vale, luego el método 00:33:52
luego el nombre 00:33:54
y ahora, ¿qué pongo después? 00:33:55
unos paréntesis 00:33:58
unos paréntesis 00:33:59
y una llave 00:34:04
que se cierra y se abre 00:34:06
entonces 00:34:08
dentro de estas llaves va el código del método 00:34:17
estos paréntesis 00:34:20
ahora mismo los dejo vacíos 00:34:23
ya los usaremos 00:34:24
en el siguiente método 00:34:26
ahora mismo los dejo vacíos 00:34:28
vale, pues ahora pienso 00:34:30
elegido ya, el valor que va a devolver 00:34:32
un true o un false 00:34:34
el nombre del método 00:34:35
paréntesis vacíos, pero hay que ponerlos obligatorios 00:34:37
paréntesis vacíos 00:34:40
y ahora, a este método, ¿quién lo va a llamar? 00:34:41
lo va a llamar este 00:34:44
¿veis? 00:34:46
el objeto alumno va a llamar 00:34:47
con el punto al método es mayor de edad, poniendo su paréntesis también. 00:34:49
Bueno, pues ahora me pongo a hacer el código. 00:34:54
¿Qué hace este código? 00:34:56
Pues tendrá que ir a dónde? 00:34:58
A la edad del alumno. 00:35:00
La edad tiene acceso directo porque está aquí arriba. 00:35:03
Es decir, todo el código que yo haga aquí, 00:35:07
el código que hagamos aquí, 00:35:10
tiene acceso directamente, sin necesidad de redeclararlo de nuevo ni de nada, 00:35:13
a todas las propiedades 00:35:26
del objeto que lo llama 00:35:38
fijaos, a este objeto 00:35:39
perdón, a este método 00:35:43
del objeto 00:35:45
que lo llama 00:35:47
a este método, repito 00:35:48
lo está llamando este 00:35:55
este lo está llamando 00:35:57
luego cuando yo aquí ponga 00:35:59
por ejemplo esto 00:36:02
if edad 00:36:04
mayor que 18 00:36:06
return true 00:36:08
else 00:36:11
retun false, que este código ya 00:36:12
lo sabemos hacer. 00:36:15
Del retun ahora, un momento, olvidaos. 00:36:19
Vale, cuando yo ponga aquí edad, 00:36:21
estoy poniendo edad directamente 00:36:24
sin declarar ni nada. ¿Por qué? 00:36:25
Porque edad está aquí arriba. 00:36:27
Es la edad del alumno. 00:36:29
Entonces, este método tiene acceso 00:36:31
directamente a las propiedades 00:36:33
del alumno que lo está llamando. 00:36:35
Que están declaradas aquí arriba. 00:36:38
Que están declaradas 00:36:40
aquí arriba. 00:36:41
Entonces, yo con esto estoy diciendo, 00:36:43
si la edad del alumno que te llama, 00:36:45
luego aquí el que está llamando es alumno, 00:36:50
luego es mayor de edad, 00:36:54
en esta llamada estará trabajando con la edad de este. 00:36:56
Si la edad del alumno que te llama es mayor que 18, 00:37:01
haz esto. 00:37:04
Ahora vemos lo que es haz esto. 00:37:05
Si no, haz esto otro. 00:37:06
Sí, porque si no es mayor de edad, 00:37:15
tienes que devolver false. 00:37:17
Pero vamos a quitar por ahora el boolean para no liarnos. 00:37:18
Vamos a hacer que el método 00:37:21
muestre por pantalla si es mayor de edad o no. 00:37:22
Que muestre. 00:37:25
Para ir más despacio. 00:37:29
Por pantalla. 00:37:31
Si el alumno es mayor de edad o no. 00:37:36
Pues entonces voy a quitar el retun. 00:37:39
Y voy a poner 00:37:41
es mayor de edad. 00:37:42
Olvidaos del retun 00:37:57
que he puesto hasta ahora. 00:37:58
Lo incorporamos después. 00:37:59
Vale, ahora este método es más fácil de entender. 00:38:01
este método, si la edad 00:38:04
que no tengo que declararla, es que tiene acceso 00:38:06
directo, está aquí arriba, ¿y de quién es 00:38:08
esa edad? ¿Qué edad va a tener en cuenta? 00:38:10
La del que lo llame. 00:38:12
La del que lo llame, si lo llama alumno, será la edad de este. 00:38:14
Si lo llama otro, será la edad de otro. 00:38:16
Pues si 00:38:19
la edad es mayor 00:38:19
o igual que 18, el método 00:38:22
hará esto, mostrar esto por consola, si no hará 00:38:24
esto otro. Entonces, 00:38:26
como este método 00:38:28
no me devuelve a mí nada, 00:38:29
no me entrega nada, se limita a mostrar por consola 00:38:32
en ese caso 00:38:34
se pone aquí void 00:38:36
porque el método no me está 00:38:37
entregando nada de vuelta, se limita 00:38:54
a mostrar por consola 00:38:56
vale, pero bueno 00:38:57
con esto ahora volvemos cuando veamos el retune 00:39:00
y eso lo entenderemos mejor 00:39:02
no me devuelve ningún 00:39:04
valor, que podría 00:39:09
devolverlo, vale 00:39:11
vale 00:39:13
pues entonces 00:39:15
¿está entendido esto que es lo más 00:39:16
importante? yo aquí declaro 00:39:20
un método al cual le pongo 00:39:22
un nombre, paréntesis 00:39:24
obligatorios, entre llaves 00:39:25
lo que hay que hacer 00:39:28
si el método no me 00:39:29
entrega nada de vuelta, que ya entenderemos 00:39:31
después que significa entregarte algo de vuelta 00:39:33
si el método no me entrega nada de vuelta 00:39:35
voy, ya está 00:39:38
y ahora, este método 00:39:39
va a hacer cosas dentro 00:39:41
lo que a mí me dé la gana 00:39:43
y va a acceder 00:39:44
si quiere y lo necesita 00:39:47
si necesita va a acceder a esto de arriba 00:39:48
El BOI significa 00:39:51
este método no le entrega 00:39:59
al programa que lo llama 00:40:02
ningún valor 00:40:03
solamente muestra porque yo aquí he puesto 00:40:04
muestra, pero podría ni mostrar siquiera 00:40:07
No, tú aquí puedes 00:40:09
hacer lo que quieras 00:40:13
Sí, pues yo aquí puedo 00:40:14
Hacerle un escáner, puedo hacer lo que me dé la gana 00:40:17
Lo único es que al tener void, este método 00:40:18
No me entrega nada 00:40:20
De vuelta 00:40:22
Vale, es decir, pero bueno, eso ahora 00:40:23
Lo entenderemos mejor, cuando ahora mismo, olvidaos de eso 00:40:40
¿Vale? Ahora lo que me importa 00:40:42
Es que entendáis que 00:40:44
lo que yo pongo aquí 00:40:45
accede directamente 00:40:47
a estas variables 00:40:48
y ahora ya 00:40:49
dependiendo 00:40:50
de qué objeto lo llame 00:40:51
las variables que usa 00:40:52
son unas u otras 00:40:56
vamos a crear otro alumno 00:40:57
por ejemplo 00:41:00
este alumno de aquí 00:41:00
¿qué edad le hemos puesto? 00:41:01
uy, este va a ser mayor de edad 00:41:03
pero yo no me entiendo 87 00:41:04
si yo ejecuto este main 00:41:05
si yo ejecuto este main 00:41:07
el alumno es mayor de edad 00:41:12
porque tenía 700 y pico años 00:41:14
87, vamos a hacernos otro alumno, otro alumno distinto, alumno 2, igual a new alumno, vale, ahora a este alumno 2 le vamos a poner una edad igual a 12, por ejemplo, 00:41:17
Ahora yo hago alumno2.edad 00:41:37
Perdón, alumno2.llamoalmetodo 00:41:43
¿Qué me va a mostrar esto? 00:41:48
Pues que va a hacer 00:41:56
Es mayor de edad, se va a ejecutar 00:41:56
Pero se va a ejecutar con los datos de alumno2 00:41:59
Con los datos de alumno2 porque es el que lo llama 00:42:01
Es el que lo llama 00:42:04
Y alumno2 tiene 12 00:42:05
Pues entonces se va a ejecutar, es mayor de edad 00:42:07
Pero se va a ejecutar, es mayor de edad 00:42:10
y ahora edad será la edad del objeto alumno 2. 00:42:12
Luego el método hace el código que hay aquí, 00:42:20
pero lo que cambia es el valor de las variables. 00:42:24
El valor de las variables usadas que están declaradas aquí arriba, 00:42:26
el valor va a ser el del objeto, que lo llama alumno, 00:42:30
pues las variables que usa es mayor de edad serán las que tiene alumno, 00:42:34
que lo llama alumno 2, 00:42:38
pues las variables que usa es las de alumno 2 00:42:39
entonces si yo ejecuto esto 00:42:42
el primero me dirá es mayor de edad 00:42:45
y el segundo me va a decir no es mayor de edad 00:42:47
esta es la primera ejecución 00:42:51
era mayor de edad 00:42:53
porque el alumno este era mayor de edad 00:42:59
esta es la segunda ejecución 00:43:02
esta es esta de abajo 00:43:05
alumno 2 tenía 12 00:43:06
luego es mayor de edad toma esta propiedad 00:43:08
bueno, pues esto entendido seguro 00:43:12
yo aquí declaro lo que va a hacer 00:43:23
pero aquí no se ejecuta nada todavía 00:43:25
aquí no se ejecuta nada 00:43:27
la ejecución se hace ahora ya 00:43:28
cuando existe un objeto 00:43:31
cuando ya existe, porque es un objeto 00:43:32
el que tiene que llamar al método 00:43:35
el método no se lanza así por las buenas, el solo 00:43:37
no, al método 00:43:39
lo llama un objeto de esta clase 00:43:41
y no de otra, de esta 00:43:43
de la clase alumna, no le puede llamar 00:43:45
un objeto de otra clase, le llama un objeto de esta 00:43:47
Y un objeto de la clase alumno es el que lo llama y entonces ahora ya sí se ejecuta, pero se ejecuta poniendo aquí sus propios datos. 00:43:49
En esta ejecución es mayor de edad, vuelca los datos de alumno para ejecutarse y en esta ejecución es mayor de edad, vuelca los datos de alumno 2 para ejecutarse. 00:44:00
¿Vale? Pues venga, vamos a parar. 00:44:11
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:
1
Fecha:
3 de diciembre de 2025 - 12:22
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 16″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
251.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid