Saltar navegación

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

2 visualizaciones

Más información Transcripción

Descargar la transcripción

o sea, Juanito es la instancia 00:00:00
claro, Juanito, el que tiene nombre Juanito 00:00:01
y no sé qué, es la instancia 00:00:04
instancias de una clase 00:00:06
puede haber mil 00:00:09
dos mil, tres mil, es que hagan falta 00:00:10
clases solo hay una, la que tú has escrito 00:00:12
en tiempo de desarrollo 00:00:14
entonces cuando la aplicación 00:00:15
que ya se está ejecutando 00:00:21
crea un ejemplo 00:00:22
concreto de mi clase 00:00:25
se llama que instancia 00:00:27
la clase, porque crea una instancia 00:00:29
Entonces se dice, vamos a instanciar la clase alumno. 00:00:31
¿Qué significa instanciar la clase alumno? 00:00:34
Crear un ejemplo concreto. 00:00:37
Puedes instanciar la clase alumno 00:00:39
tantas veces como quieras 00:00:41
y por cada una de esas veces te crea un objeto. 00:00:42
Bueno, pues esta es la idea 00:00:45
del funcionamiento de una aplicación orientada a objetos. 00:00:46
Ahora diréis, vale, 00:00:50
esta aplicación orientada a objetos 00:00:52
hace que aparezcan objetos. 00:00:53
Vale, muy bien, 00:00:57
pero la aplicación son objetos que aparecen 00:00:57
aparecen y están ahí cruzados de brazos 00:00:59
no, las aplicaciones hacen cosas 00:01:01
lógicamente, tienen que hacer cosas 00:01:03
claro, pues dentro 00:01:05
de cada clase 00:01:08
además de las propiedades 00:01:09
que me importan 00:01:12
de los objetos 00:01:14
en particular, dentro de cada 00:01:16
clase, yo tengo un espacio 00:01:18
para declarar una cosa que se 00:01:20
llaman métodos 00:01:22
y cada clase tiene su espacio 00:01:23
para declarar 00:01:28
programar una cosa que se llama métodos 00:01:30
¿y qué son los métodos? 00:01:32
trozos de código 00:01:36
esos son los métodos 00:01:37
trocitos de código que reciben un nombre 00:01:39
ahora cuando ya hagamos una clase 00:01:41
en particular, ya lo vamos poniendo 00:01:43
en los comentarios 00:01:46
ahora es para que tengáis una idea general 00:01:47
de de qué va esto 00:01:49
vale, pues los métodos son 00:01:50
trocitos de código con un nombre 00:01:53
y cada clase 00:01:55
puede tener un montón de ellos 00:01:57
Pues ahí en los métodos es donde programamos ya las cosas que se hacen 00:01:59
Las que se hacen se programan ahí, en los métodos 00:02:04
Entonces, la aplicación ejecutándose, ¿qué va a ser? 00:02:07
Va a ser objetos que se han creado 00:02:12
Y que esos objetos llaman a estos métodos 00:02:15
Que son los que hacen las cosas 00:02:20
A estos trozos de código que yo he puesto aquí 00:02:22
¿Quién los lanza para que se puedan ejecutar? 00:02:26
los lanzan los objetos de cada clase 00:02:30
a estos trozos de código 00:02:33
los lanzan los objetos alumno 00:02:35
cuando quieren y se interesa 00:02:37
y a los métodos de esta clase 00:02:38
los códigos que yo he puesto aquí 00:02:41
los llaman, los lanzan 00:02:43
los ejecutan los objetos matrícula 00:02:45
que yo he instanciado aquí 00:02:47
entonces yo decido 00:02:49
donde coloco esos trozos 00:02:51
de código, decido donde coloco 00:02:53
en función del diseño que me parezca 00:02:55
más coherente y que tiene más sentido 00:02:57
porque habrá cosas que se hacen en la aplicación 00:02:59
que tienen que ver con los alumnos. 00:03:02
Pues esas cosas que tienen que ver con los alumnos 00:03:05
las meteré aquí dentro 00:03:07
y así queda más organizadito mi código. 00:03:09
Sin embargo, habrá cosas que tenga que hacer mi aplicación 00:03:11
que tienen que ver con las matrículas, 00:03:14
como hacer cosas con el precio. 00:03:16
Pues esas operaciones las meteré aquí 00:03:18
porque tienen que ver con la matrícula. 00:03:20
Entonces yo voy colocando lo que hace la aplicación, 00:03:22
lo voy colocando en métodos 00:03:25
que va metido en las entidades relacionadas 00:03:27
con lo que hace ese método. 00:03:32
Si hace cosas con los alumnos, pues aquí, 00:03:35
como darle de baja, como cambiarle el nombre. 00:03:37
Si hace cosas con matrícula, pues aquí. 00:03:40
Luego una aplicación orientada a objetos ejecutándose 00:03:44
es un montón de objetos que aparecen 00:03:47
y están ahí, que aparecen y se han creado 00:03:50
y ahora esos objetos llamando a estos códigos para ejecutarse. 00:03:53
Eso es una aplicación orientada a objetos. 00:03:58
Objetos que hago aparecer, que responden a estas clases, a estas plantillas, 00:04:01
y esos objetos van llamando a estos métodos. 00:04:08
Ese es el funcionamiento de una aplicación orientada a objetos. 00:04:11
Una aplicación orientada a objetos admite tantos diseños como clases me dé a mí la gana. 00:04:14
Una misma aplicación que a mí me han pedido que gestione cosas, 00:04:20
la puedo diseñar de formas muy distintas. 00:04:23
distintas, porque a lo mejor en un diseño 00:04:25
decido que estas entidades son 00:04:27
las que me gustan y hago los métodos así 00:04:29
en otro diseño decido estas otras 00:04:31
entidades y hago los métodos de otra manera 00:04:33
habrá diseños mejores y peores 00:04:35
¿cuáles son los mejores? 00:04:37
los que hacen que la aplicación sea 00:04:39
clara, elegible, que tú la veas y la entiendas 00:04:41
que si tienes que retocar algo 00:04:43
no tengas que retocar en mil sitios 00:04:45
eso hará que la aplicación sea buena 00:04:46
que te va a funcionar a lo mejor igual que otra 00:04:49
con otro diseño distinto 00:04:50
pero si una aplicación tiene un diseño 00:04:52
que cualquier modificación implica 00:04:55
que tienes que tocar mil clases 00:04:57
etcétera, pues que diseño más malo 00:04:59
aunque te funcione 00:05:01
¿vale? 00:05:02
luego, recopilando 00:05:05
no hay una única forma de hacer una aplicación 00:05:07
dentro de objetos, admite 00:05:09
todas las que a ti te dé la gana en función 00:05:11
del diseño de clases que tú quieras hacer 00:05:13
las clases que tú decidas 00:05:15
en función a eso, te haces los métodos 00:05:16
en consonancia y creas los objetos 00:05:19
como vaya tocando 00:05:21
cada diseño, pues bueno 00:05:22
funcionará de una manera 00:05:25
funcionará de otra, harán lo mismo entre ellos 00:05:28
pero a la hora de retocarlos es donde pueden 00:05:30
medir las diferencias 00:05:31
puede que retocar uno para 00:05:33
incorporar una funcionalidad sea más complicado 00:05:35
que retocar otro, pues entonces ahí ya 00:05:38
falla 00:05:40
ventaja enorme de la programación orientada a objetos 00:05:41
o ventajas, ¿por qué programamos 00:05:47
así? 00:05:49
primero, porque es 00:05:51
algo absolutamente natural, surge de forma 00:05:53
natural, si mi aplicación gestiona entidades 00:05:55
pues hombre, vamos 00:05:57
a hacer la foto de las entidades, vamos a hacer 00:05:59
la foto y voy a organizar los códigos 00:06:01
así, entonces es 00:06:03
muchísimo más claro, tiene 00:06:05
mucho más sentido, es natural, que no me voy 00:06:07
a hacer un chorizo enorme 00:06:09
y me voy a poner a hacer 200.000 líneas 00:06:10
en un main, en un main 00:06:13
que hemos hecho hasta ahora 200.000 líneas, pues hombre 00:06:15
eso es una locura, no 00:06:17
voy a hacer primero una foto de mi alumno y 00:06:18
matrícula, luego el código 00:06:20
de las matrículas lo meto aquí 00:06:23
pues es mucho más organizado 00:06:25
más limpio, más bonito, clases separadas 00:06:26
esa es la principal ventaja 00:06:29
que está separado en clases 00:06:31
no hay un único main con todo el chorizo 00:06:33
está separado por clases 00:06:34
y es mucho más claro 00:06:36
y el segundo 00:06:37
mucho más importante incluso 00:06:40
la reutilización 00:06:42
ese es el básico 00:06:45
el que ha hecho que esto 00:06:47
sea una herramienta poderosa 00:06:49
la reutilización 00:06:50
una vez que tienes hecha una clase matrícula 00:06:52
con sus propiedades 00:06:55
y los métodos 00:06:57
eso se convierte 00:06:58
en un fichero ahí autónomo 00:07:00
que tú puedes reutilizar 00:07:03
en un montón de aplicaciones distintas 00:07:04
en las que vayas a trabajar con matrículas 00:07:07
ahora te haces otra aplicación, versión B 00:07:08
que trabaja con matrículas, pero ahora es para mi cole 00:07:11
no es para el instituto 00:07:13
ah, pues me cojo esta clase 00:07:14
tal cual, porque está estupenda 00:07:17
y la reutilizo tal cual en mi otra 00:07:18
aplicación, tal cual, porque ahora 00:07:21
mi aplicación está hecha con retazos 00:07:23
pues esos retazos 00:07:25
que son las clases, algunos 00:07:27
de ellos igual me interesan tal cual 00:07:29
en otra aplicación, pues cojo el retazo 00:07:31
y lo utilizo como retazo para 00:07:32
esa otra aplicación, eso es 00:07:35
lo fundamental, la reutilización del código 00:07:37
la reutilización de las clases, al organizarlo 00:07:39
de esta manera 00:07:41
por eso programamos así 00:07:41
por la claridad, ahora de separar el código 00:07:44
en partes, y la reutilización 00:07:47
Utilización. Son las dos razones 00:07:49
fundamentales. 00:07:51
Bueno, pues dicho esto, 00:07:54
vamos a programar una clase 00:07:55
para ver cómo podemos luego, desde un programa 00:07:56
en ejecución, instanciar objetos 00:07:59
y llamar a métodos 00:08:00
que hagan cosas. 00:08:03
¿Vale? 00:08:05
Pues venga. 00:08:06
A ver. 00:08:16
Pero bueno, es un tema mío. 00:08:48
Tú llámalo como te dé la gana. 00:08:49
Venga, pues vamos a hacernos un pequeño proyecto para declarar una clase e instanciarla y utilizarla. 00:08:51
Pues venga, un proyecto de Java, que en mi caso se va a llamar Programación orientada a objetos, ejemplo, ejemplos. 00:09:02
Vamos a hacer un pequeño paquete para meter las entidades. 00:09:21
Vamos a llamar a este paquete entidades, por ejemplo. 00:10:01
Vamos a meter aquí las clases. 00:10:04
Ahora ya cuando sepamos clases, 00:10:06
ya vamos a entender un poco más qué sentido tienen los paquetes 00:10:09
y ya nos vamos a meter con ellos. 00:10:11
Hasta ahora los hemos creado para meter cosas en ellos, 00:10:12
pero no sabíamos ni lo que eran ni nada. 00:10:15
Ahora ya sé que vamos a poder entenderlo un poquito después. 00:10:18
Pues me voy a crear un paquete, se llama entidades, 00:10:22
porque yo he decidido que mi aplicación va a trabajar con alumnos. 00:10:24
Entonces, como mi aplicación va a trabajar con alumnos, 00:10:29
pues identifico una entidad alumno. 00:10:31
¡Hala! 00:10:34
Pues venga, me hago nueva clase. 00:10:35
Una nueva clase. 00:10:41
Porque programar una entidad es programar una clase. 00:10:43
Pues nueva clase. 00:10:46
¿A esta clase cómo la voy a llamar? 00:10:49
A alumno. 00:10:51
No, vale. 00:10:56
Vale, pues voy a quitarle el public, 00:11:03
porque ahora mismo todavía no sabemos lo que significa. 00:11:06
Ahora ya dentro de poco sí podremos saberlo. 00:11:10
Bueno, pues esto es lo primero que se hace para declarar una clase. 00:11:12
ya lo habíamos hecho antes 00:11:15
porque teníamos que hacer una clase sí o sí 00:11:17
para hacer el programa de ejecución, ahora volvemos con eso 00:11:19
pero ahora nos olvidamos de nuestro 00:11:21
main, de lo que hemos hecho hasta ahora nos olvidamos 00:11:23
bueno pues 00:11:25
esta va a ser mi clase alumno 00:11:27
mi plantilla, tiene la palabra 00:11:29
reservada a class 00:11:31
y luego después el nombre 00:11:33
que yo le doy a la clase o entidad 00:11:35
que debería ser un nombre como siempre 00:11:37
lo más explicativo posible 00:11:39
y por convenio 00:11:41
aunque no obligatorio 00:11:43
que la primera 00:11:45
empiece en mayúscula 00:11:47
el nombre de la clase 00:11:48
¿vale? porque así lo distinguimos 00:11:50
de los nombres de las propiedades 00:11:57
ahora lo decimos que por convenio 00:11:58
idealmente en minúscula y los métodos 00:12:00
bueno, pues esta es mi clase alumno 00:12:02
ahora empiezo a hacer la plantilla 00:12:04
la plantilla va a tener dos partes 00:12:06
las propiedades o atributos 00:12:08
como lo queráis llamar 00:12:11
de esa entidad 00:12:12
¿vale? pongo las tres palabras 00:12:13
que se suelen usar, sobre todo 00:12:24
atributos, propiedades, campos 00:12:26
¿vale? 00:12:28
variables, incluso a veces hasta se le llaman 00:12:30
las variables de la clase, voy a ponerlo también 00:12:32
a veces también se les llama variables 00:12:34
vale, pues ahora 00:12:36
me toca poner 00:12:41
que atributos 00:12:43
caracterizan a esta entidad 00:12:44
¿vale? esto es lo mismo que hacéis en base de datos 00:12:46
bueno 00:12:49
pues a mi alumno, venga, pues mi alumno 00:12:51
se va a caracterizar 00:12:53
por su NIF 00:12:54
y su nombre, hemos dicho 00:12:56
venga 00:12:59
pues entonces tendrá dos propiedades 00:13:00
NIF y nombre, pero claro 00:13:04
¿cómo las programo? 00:13:06
¿cómo los declaro? pues cada propiedad 00:13:08
es una variable 00:13:11
de las de toda la vida que ya conocemos 00:13:13
entonces tengo que decidir su tipo de datos 00:13:14
pues NIF 00:13:16
le pega un string, ¿verdad? 00:13:18
pues como a NIF le pega un string 00:13:20
lo declaro 00:13:22
así 00:13:26
se declara como una propiedad 00:13:27
como una variable, perdón 00:13:32
como una variable 00:13:34
eliges su tipo de dato 00:13:34
eliges su tipo de dato 00:13:37
y le eliges un nombre 00:13:39
entonces, nombre también sería 00:13:41
un string 00:13:44
pues la puedo poner aquí después si quiero 00:13:45
o la podría poner abajo 00:13:47
me da igual, aquí estoy declarando 00:13:50
variables 00:13:52
estamos declarando variables 00:13:53
igual que les declaramos, voy a poner una de otro tipo 00:13:55
para que haya más variedad 00:13:57
pues el alumno tiene una edad 00:13:59
por ejemplo 00:14:01
bueno, pues cada 00:14:02
atributo, propiedad o campo 00:14:05
se corresponde con una declaración de variable 00:14:07
como las que hemos declarado siempre 00:14:09
con una declaración de variable 00:14:11
con los tipos de datos que conocemos 00:14:12
y elegimos el nombre que nos dé la gana 00:14:15
lo mismo, nombre 00:14:18
lo más explicativo posible respecto a la 00:14:19
propiedad a la que se refiere 00:14:22
un nombre bien elegido 00:14:24
y también por convenio 00:14:26
pues que empiece en minúscula 00:14:28
porque así ya empiezo a distinguir 00:14:30
cuando me refiero a nombres de clases 00:14:33
a cuando me refiero a nombres de propiedades 00:14:34
¿vale? 00:14:37
por convenio empieza en minúscula 00:14:39
bueno 00:14:40
quiero que mi alumno se caracterice por más cosas 00:14:42
o a la aplicación solo le hace falta 00:14:44
porque solo trabaja con su NIF nombre y edad 00:14:46
pues solo le hace falta NIF nombre y edad 00:14:48
así se queda 00:14:50
no hay que ponerle más propiedades 00:14:52
vale, ahora podríamos incluir aquí 00:14:54
pero vamos antes a instanciar un objeto 00:14:57
lo que hemos llamado métodos 00:14:58
sería la segunda parte 00:15:01
que va dentro de la clase 00:15:04
¿y qué son los métodos? 00:15:06
los métodos son 00:15:08
códigos 00:15:09
que los objetos 00:15:11
alumno 00:15:14
creados en tiempo de ejecución 00:15:15
ahora lo veremos 00:15:19
pueden llamar 00:15:22
esos son los métodos 00:15:26
códigos que un objeto 00:15:31
alumno que se haya creado puede llamarlo 00:15:34
para que se ejecute, yo ahí 00:15:36
declaro lo que va a hacer 00:15:37
pero por ahora es un propósito, es una declaración 00:15:39
de intenciones, no se hace nada 00:15:42
esto no se va a ejecutar hasta que no 00:15:43
aparezca un objeto alumno que lo ejecute 00:15:46
ahora mismo vamos a dejar la clase así 00:15:48
el alumno no puede hacer nada todavía 00:15:50
bueno, pues vamos a dejarla ahora así 00:15:51
Vale, pues mi aplicación ahora mismo consta de mi clase alumno, porque solamente trabaja con alumnos, y ahora ya voy a hacer yo una aplicación que haga cosas. 00:15:54
Pues mi aplicación tiene que tener, ahora sí, una clase especial porque tiene dentro el método main, el que ya conocemos. 00:16:04
Y ese método main es el punto de arranque de la aplicación donde empiezan a pasar las cosas. 00:16:15
nosotros hasta ahora era la única que teníamos 00:16:20
una clase con el método main 00:16:24
porque no había entidades, no había nada 00:16:25
ahora tendremos la clase con el método main 00:16:27
que es el punto de arranque 00:16:30
y esa clase con el método main 00:16:31
es la que irá llamando a las otras que hemos hecho 00:16:33
pues vamos a hacer esa clase 00:16:35
esa que ya conocemos, ya hemos hecho siempre 00:16:37
vamos a hacer esa clase 00:16:39
pues la voy a llamar main 00:16:43
porque es la clase que tiene el método main 00:16:45
la puedo llamar como me dé la gana 00:16:47
pero bueno, si la llamo main 00:16:49
dejo muy claro que es 00:16:50
la clase punto de arranque 00:16:52
la que tiene el main 00:16:54
claro, ahora mismo sí 00:16:55
porque como todavía no entendemos de paquetes, ahora mismo 00:17:00
sí la vamos a crear ahí 00:17:02
todas juntas en el mismo 00:17:03
vale, entonces esta clase ya no suena 00:17:05
incluso le voy a 00:17:08
quitar el public 00:17:10
para no meter nada raro 00:17:11
esta como veis es otra clase 00:17:14
más, también empieza por class 00:17:16
tiene el nombre que ahí me dé la gana darle 00:17:18
empezando con mayúscula 00:17:20
y él tiene unas llaves, una que se abre y otra que se cierra 00:17:21
es otra clase más, igual que alumno 00:17:24
lo que pasa es que main le pasa una cosa 00:17:25
y es que tiene esto 00:17:28
que es lo que se llama el método main 00:17:30
y este método main 00:17:33
volvemos a decir ahora 00:17:40
como ya dijimos al principio 00:17:41
que es un método especial 00:17:42
porque a este método 00:17:46
es al que llama 00:17:47
la máquina virtual cuando la aplicación arranca 00:17:49
cuando la aplicación arranca 00:17:52
la aplicación puede que tenga mil clases 00:17:53
o dos mil, pero la máquina virtual 00:17:56
a la que va a ir es a esta 00:17:58
y el método que va a arrancar es este 00:18:02
entonces este método 00:18:04
es el 00:18:07
punto de arranque 00:18:10
de la aplicación 00:18:12
de esta aplicación 00:18:17
que tiene muchas clases 00:18:19
y por eso yo tengo 00:18:20
que respetar la cabecera 00:18:23
no tocarla porque la máquina virtual 00:18:24
va a buscar un método como este 00:18:27
tal cual, con esa cabecera 00:18:29
bueno, pues entonces la aplicación cuando arranque 00:18:30
vendrá aquí 00:18:33
no irá aquí, no, esto no irá 00:18:33
a ningún sitio de aquí, ni irá a nada 00:18:37
la aplicación cuando arranque va a venir aquí 00:18:38
vale, pues la aplicación 00:18:41
ahora que es lo que hace 00:18:43
lo que hemos dicho antes, la aplicación ahora ya se pone a crear 00:18:44
objetos y hacer cosas 00:18:47
pues venga, vamos a crear 00:18:48
o instanciar, como queramos llamarlo 00:18:51
instanciar un objeto alumno. 00:18:53
Vamos a instanciar un alumno. 00:19:00
¿Vale? 00:19:03
Ahora ya tenemos que crear un ejemplo concreto 00:19:03
de esta plantilla. 00:19:07
Un ejemplo concreto de esta plantilla. 00:19:10
Vamos a crear. 00:19:12
Vale. 00:19:14
Pues esto es importante. 00:19:15
Y esto es lo más, una de las cosas más importantes de entender. 00:19:17
Bueno, pues mi objeto alumno, 00:19:20
que es un caso concreto, 00:19:23
Es un dato, que es mi alumno 00:19:25
con sus datos. Pues mi objeto 00:19:27
alumno es otra variable más, 00:19:29
es otra variable más. 00:19:31
Cuando yo declaraba, por ejemplo, 00:19:33
mi aplicación tiene que trabajar con un número, 00:19:35
pues yo hacía esto, inNúmero. 00:19:37
Y a número, pues a lo mejor 00:19:40
le daba, pues yo que sé, 00:19:41
12, lo que fuera, y hacía cosas 00:19:43
con número. Con esto, ¿qué estaba haciendo? 00:19:45
Hacer aparecer 00:19:48
un número. Hacer aparecer 00:19:49
un número, era lo que estaba haciendo. 00:19:51
Hago aparecer un número. 00:19:53
pues lo que vamos a hacer ahora 00:19:54
cuando instaciamos el objeto es lo mismo 00:19:56
ahora lo que vamos a hacer aparecer es 00:19:59
un dato también, pero lo que vamos a hacer aparecer es 00:20:01
un alumno, aquí hacíamos aparecer 00:20:03
un número declarando 00:20:06
poniendo tipo, nombre de la variable 00:20:07
y luego le daba un valor 00:20:09
si quería, si no se lo daba 00:20:11
después, pues aquí vamos a 00:20:13
hacer lo mismo, vamos a hacer aparecer 00:20:15
un alumno, que es un dato 00:20:17
luego 00:20:19
esto también va a ser una declaración 00:20:21
de variable 00:20:24
lo que pasa es que ahora 00:20:24
el tipo de dato 00:20:26
es este 00:20:28
el de la clase 00:20:29
luego al hacer una clase 00:20:31
es como si yo me hubiera inventado 00:20:33
un tipo de dato nuevo 00:20:36
me he inventado un tipo de dato 00:20:38
alumno, del cual yo quiero 00:20:40
crear, del cual yo quiero crear 00:20:42
yo puedo crear variables 00:20:44
por ejemplo, a1 00:20:45
por ejemplo 00:20:48
pues ya está 00:20:48
esta, he hecho la primera parte 00:20:51
esta es una declaración de variable 00:20:54
más 00:20:56
a1 es una variable 00:20:57
el nombre que ahí me ha dado la gana de dar 00:20:59
voy a poner alumno1 para que quede más claro el nombre 00:21:01
vale 00:21:04
alumno1 es una variable 00:21:08
yo lo he llamado alumno1 00:21:11
igual que número 00:21:13
es un número, un número en concreto 00:21:15
pues alumno1 es un objeto alumno 00:21:17
una variable alumno 00:21:21
pero claro, cuando declaro una variable 00:21:23
siempre tengo que poner el tipo de dato al que 00:21:25
pertenece, esta variable 00:21:27
tiene un número entero 00:21:29
pues por eso pongo int 00:21:31
pero es que esta tiene un objeto 00:21:32
alumno, pues por eso pongo 00:21:35
alumno, el nombre de la clase 00:21:37
entonces esta es 00:21:39
una variable primitiva 00:21:41
porque es de un tipo de dato primitivo 00:21:43
y esta es una variable objeto 00:21:45
porque su tipo de dato es 00:21:47
alumno 00:21:49
bueno pues con esto la he declarado 00:21:50
Entonces, con esto he hecho la mitad del trabajo solo, ¿vale? Con esto lo único que he hecho es, he hecho aparecer en memoria un espacio para guardar el objeto alumno, no, para guardar la dirección de memoria que apunte a un espacio para ahora. 00:21:53
Y así guardar los datos de un alumno, que en mi caso tiene tres campos, 00:22:27
NIF, nombre y edad. 00:22:34
Entonces, con esto he declarado una variable que se llama alumno1, 00:22:39
que está pensada para contener la dirección de memoria de un objeto cuando exista, 00:22:45
pero todavía no existe. 00:22:51
Ahora mismo, con esto de aquí, yo estoy creando un objeto alumno que apunta a null, que es null por ahora. 00:22:52
Ahora mismo, esto es lo que he hecho con esta primera sentencia. 00:23:12
He creado una variable pensada para contener la dirección de los datos de un alumno en concreto. 00:23:16
De hecho, si nos planteáramos hacer esto ahora, si nos planteáramos hacer esto, si nos planteáramos hacer esto, alumno 1, ¿vale? Pues me dice, la variable alumno 1, perdona, todavía no tiene nada. 00:23:23
me lo está diciendo ahí en bajito 00:24:01
cuidado que la variable alumno1 00:24:03
no tiene nada 00:24:05
vale, entonces con esto 00:24:06
simplemente he declarado 00:24:09
una variable pensada para apuntar 00:24:10
a un objeto alumno concreto 00:24:13
ahora ya 00:24:14
¿cómo lo creo? 00:24:16
pues de esta manera 00:24:19
new 00:24:20
el nombre de la clase 00:24:21
y paréntesis vacíos 00:24:24
vale 00:24:26
ahora ya sí 00:24:28
Con esto, ahora ya sí que sí, con esta primera parte, he creado esto, alumno1, la variable alumno1, que apunta por ahora a nada y ahora con new, new te hace aparecer el espacio en memoria para guardar los datos de un objeto alumno. 00:24:30
El objeto alumno, ¿cuántos campos tiene? 00:25:13
Tres. 00:25:17
Pues entonces te abre un espacio para tres. 00:25:18
Dos string, 00:25:20
need, nombre y un int. 00:25:21
El new te abre espacio 00:25:24
para los datos de un alumno en concreto. 00:25:26
Vale, pues ahora ya he creado esto. 00:25:30
Vale. 00:25:34
Ahora ya que la estructura interna en memoria sea esta, 00:25:36
ya empieza, ahora ya me empieza a importar menos. 00:25:41
Es importante que lo entienda, claro, 00:25:44
porque si yo no hago el new, esto se queda 00:25:46
apuntando a null, no puedo usarlo 00:25:48
cuando he hecho el new 00:25:50
ya se queda esto de aquí, y ahora ya 00:25:52
lo que nos importa es el objeto, que es esto 00:25:54
bueno, pues 00:25:56
ahora con este objeto, ahora mismo este objeto 00:25:58
he creado el espacio 00:26:00
pero no tiene nada todavía 00:26:02
dentro, no tiene nada 00:26:04
ahora la pregunta sería, ¿cómo le doy yo 00:26:06
valor a las propiedades? 00:26:08
¿cómo se las doy? 00:26:10
porque aquí, número 00:26:12
solo tiene espacio para el valor numérico. 00:26:13
Pues ya está, 12. 00:26:16
Aquí está muy claro. 00:26:17
Pero alumno 1, 00:26:19
¿cómo le doy valores a alumno 1? 00:26:20
Porque alumno 1 tiene tres partes. 00:26:22
Alumno 1 es su NIF, su nombre o su edad. 00:26:24
¿Cómo accedo a cada apartado? 00:26:28
Porque alumno 1 es un dato complejo. 00:26:29
Alumno 1 tiene tres partes. 00:26:33
Es un dato complejo. 00:26:35
No es como número que solo tiene una, el número. 00:26:35
Alumno 1 tiene su parte NIF, 00:26:38
su parte nombre y su parte edad. 00:26:40
¿Cómo accedo a cada parte? 00:26:42
Bueno, pues de forma muy sencilla 00:26:44
Con el operador punto y ya está 00:26:46
Ahora lo 00:26:48
Vale, entonces 00:26:51
Esto lo podemos interpretar como que 00:26:56
Alumno1 00:26:59
Es una variable 00:27:02
Compleja 00:27:04
Con tres partes en realidad 00:27:05
Con tres campos, si lo queréis ver 00:27:07
Tiene tres campos 00:27:09
El nombre 00:27:17
El nif, el nombre 00:27:18
y la edad son los tres campos 00:27:26
que yo he puesto aquí, el nif, el nombre 00:27:29
y la edad, son estos tres 00:27:31
pues alumno1 es una variable 00:27:32
objeto compleja con esos tres apartaditos 00:27:35
pues venga, vamos a 00:27:37
alumno1, vamos a darle 00:27:38
un nif 00:27:41
alumno1, ¿cómo accedemos 00:27:41
a su parte nif, a su apartado nif? 00:27:45
pues con .nif 00:27:47
alumno1.nif 00:27:48
es el campo 00:27:51
nif del alumno1 00:27:53
pues alumno1.nif 00:27:54
pues ya está 00:27:57
el nif que a mí me dé la gana 00:27:58
vale 00:28:02
entonces el operador punto 00:28:02
es el que me lleva a cada una 00:28:05
de las propiedades o campos 00:28:07
del objeto alumno1 00:28:09
vale 00:28:11
que ahora quiero 00:28:13
ponerle un nombre 00:28:18
pues alumno1.nombre 00:28:19
vale, este me lleva al apartadito 00:28:21
o campo nombre del objeto alumno1 00:28:27
que es complejo porque tiene tres partes 00:28:29
alumno1.edad 00:28:31
es un int 00:28:38
porque el campo edad era int 00:28:40
pues aquí le tengo que asignar un tipo compatible 00:28:42
bueno, pues así accedo a los tres apartaditos 00:28:44
del objeto alumno1 00:28:52
entonces el nombre de la clase 00:28:55
solo ha aparecido aquí para declararlo 00:29:00
para decir, oye, que es de tipo alumno 00:29:04
y luego ya, ese es el nombre de la variable 00:29:06
que puede haber tantas variables 00:29:09
alumno como uno quiera 00:29:11
que queremos otro alumno 00:29:12
pues me puedo hacer otro alumno 00:29:19
vamos a instanciar 00:29:21
otro alumno más 00:29:28
bueno, pues otra variable más 00:29:36
alumno a dos 00:29:38
igual a new alumno 00:29:41
ala, ya tengo 00:29:43
otro alumno más 00:29:47
tengo dos instancias 00:29:50
dos ejemplos 00:29:52
dos alumnos concretos 00:29:53
que pertenecen a la misma plantilla 00:29:56
a la misma plantilla 00:29:58
alumno2 00:30:00
pues tendrá su propio conjunto de propiedades 00:30:02
el que a mí me dé la gana poner 00:30:04
alumno2.nif 00:30:05
pues tendrá lo que a mí 00:30:08
me dé la gana poner 00:30:10
pues tendrá lo que 00:30:11
a mí me dé la gana 00:30:19
y así puede haber 00:30:20
mil objetos alumno distintos. 00:30:31
Puede haber mil objetos alumnos distintos. 00:30:35
Todos 00:30:38
pertenecen al mismo tipo, que es al tipo 00:30:39
alumno, a la clase que yo he declarado. 00:30:42
Y cada uno tiene 00:30:46
su propio conjunto de propiedades. 00:30:47
¿Vale? 00:30:50
Ahora, pues 00:30:52
por ejemplo, 00:30:53
pues yo que sé, 00:30:56
vamos a hacer tonterías 00:31:00
para practicar un poco. 00:31:02
Claro, porque el alumno tiene tres cosas 00:31:03
Tendrás que decir, ¿qué muestro? 00:31:09
Tú puedes hacer un siso de alumno2.nif 00:31:11
alumno2.nombre 00:31:14
¿Vale? 00:31:15
Entonces, por ejemplo 00:31:16
Yo quiero ver 00:31:19
qué alumno de los dos es mayor 00:31:20
Por ejemplo 00:31:23
¿Qué alumno es mayor? 00:31:24
Pues, ¿qué haría? 00:31:34
Pues haría 00:31:36
Si alumno1.edad 00:31:37
es mayor que alumno2.edad 00:31:40
mayor el primero, si es lo contrario 00:31:45
mayor el segundo, iguales 00:32:01
Bueno, pues mi aplicación está haciendo cosas con alumnos 00:32:27
y los alumnos están recogidos en sus 00:32:33
correspondientes variables, pues por ejemplo 00:32:37
asignar al primer alumno 00:32:41
el nombre del segundo 00:32:46
porque se ha copiado 00:32:48
de nombre y se quiere llamar igual 00:32:51
asignamos 00:32:52
al primer alumno 00:32:56
el nombre del segundo 00:32:58
porque eso es lo que queremos que haga nuestra aplicación 00:33:04
por lo que sea 00:33:06
pues alumno1 00:33:07
punto nombre 00:33:10
igual 00:33:12
alumno2 00:33:14
punto nombre 00:33:16
vale 00:33:18
y así podríamos estar hasta el infinito 00:33:21
Pues haciendo cosas con los alumnos 00:33:23
Con sus datos 00:33:25
Ahora 00:33:27
¿Un for que recorra las propiedades? 00:33:29
Si tienes una RAI de alumnos, sí 00:33:42
Claro 00:33:46
Si tienes una RAI de alumnos, sí 00:33:46
Por ejemplo, seguimos 00:33:48
Ahora, dos alumnos no me valen 00:33:51
¿Vale? 00:33:54
Entonces, antes de 00:33:57
seguir 00:33:59
esta aplicación por supuesto 00:34:00
se podría haber diseñado de otra manera 00:34:03
esta aplicación que tiene que 00:34:05
hacer esto, pues de hecho, en lugar de diseñarla 00:34:07
con clases, me hago yo 00:34:09
un montón de variables sueltas 00:34:11
nombre alumno 1, nif alumno 1 00:34:12
edad alumno 1, nombre alumno 2 00:34:15
y mi aplicación trabaja con eso 00:34:17
pero me queda un mail con muchas 00:34:19
variables, más largo, más complicado de entender 00:34:21
que me va a funcionar y me va a hacer lo mismo 00:34:23
sí, pero ahora tengo yo que retocar 00:34:25
esa aplicación y tengo un lío con estas variables. 00:34:27
Sin embargo, si la he diseñado así, digo, ojo, 00:34:29
como yo estoy trabajando con 00:34:32
alumnos que todos ellos comparten 00:34:33
que tienen tres campos, me voy 00:34:35
a hacer mi clase alumno. Y ahora 00:34:37
cada alumno 00:34:39
que sea una instancia de eso y tenga 00:34:40
dentro sus tres propiedades. 00:34:43
Esto es mucho más claro, 00:34:46
mucho más bonito que hacer la 00:34:47
aplicación de esta manera. 00:34:49
Hacerla, oye, pues, nombre 00:34:51
alumno1, 00:34:53
nombre alumno2, 00:34:57
sería una locura 00:34:59
que de repente los alumnos 00:35:00
la aplicación escala 00:35:02
y ahora quiero que contabilice 00:35:04
también, pues yo que sé 00:35:07
yo que sé, el nombre 00:35:09
de los padres de los alumnos 00:35:12
pues yo me vengo aquí 00:35:14
y lo meto ahí dentro, punto pelota 00:35:15
pero con el 00:35:18
otro diseño me tendría que hacer 00:35:20
un montón de propiedades 00:35:22
tantas como alumnos tengas, una locura 00:35:24
no tiene sentido 00:35:26
entonces el diseño con clases 00:35:27
lógicamente facilita la creación de programas 00:35:30
que manejan instancias y cosas 00:35:32
bueno 00:35:34
vamos a parar aquí antes de seguir 00:35:36
con lo que vamos a seguir 00:35:38
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:
2
Fecha:
3 de diciembre de 2025 - 12:16
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
810.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid