Saltar navegación

Herencia 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 12 de enero de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, autorizáis la grabación de vuestra voz. 00:00:00
Después de haber visto objetos, clases, constructores y cosas básicas de la programación orientada a objetos, 00:00:07
empezaremos hoy a ver herencia. Rápido repaso para que quede grabado. 00:00:15
Nosotros antes hemos estado en un mundo de programación estructurada. 00:00:22
hemos ignorado las características de orientación a objetos de Java 00:00:27
y hemos trabajado como si fuera un lenguaje de programación viejo, entre comillas. 00:00:36
Entonces, ahí hemos visto la declaración de variables, 00:00:44
hemos visto programar en el sentido de hacer una instrucción tras otra 00:00:47
en una secuencia de instrucciones. 00:00:54
luego hemos empezado a pensar, el flujo de ejecución tiene que estar siempre así, o sea, siempre uno tras otro, o se puede modificar. 00:00:56
Hemos visto lo que son las sentencias de control, que permiten modificar el flujo de ejecución de un programa. 00:01:07
Entonces hemos visto el if, que me permite ejecutar o no un bloque de instrucciones dependiendo de una cierta condición booleana. 00:01:14
Expresión booleana, expresión booleana que ya sois expertos en encontrar valores de verdad en expresiones booleanas complejas con operadores como AND, OR, etc. 00:01:22
Hemos visto también la posibilidad de ejecutar un bloque de sentencias, de instrucciones, más de una vez. 00:01:36
Y hemos visto sus dos variantes principales, que son el for y el while. 00:01:48
El while se utiliza cuando no sé cuántas veces voy a repetir este bloque. 00:01:55
El for se suele utilizar cuando sé cuántas veces voy a repetir este bloque. 00:02:01
También hemos visto, un poquito más tarde, pero como ya ahora lo hemos visto, lo que es la llamada a un método. 00:02:06
Entonces hemos visto que nosotros podemos dar un nombre a un bloque de instrucciones, parametrizarlo con unos parámetros formales y luego llamar este bloque desde otro sitio, desde un main, desde otro método, llamar con el nombre este bloque de instrucciones para que se ejecutan parametrizados con unos determinados parámetros que le pasó en ese momento, o sea los parámetros actuales. 00:02:13
La diferencia entre parámetros formales y parámetros actuales en este momento la sabéis perfectamente, por lo tanto no hace falta volver a explicar. 00:02:42
¿Qué más hemos visto? 00:02:54
Hemos empezado a ver los objetos, ¿vale? 00:02:55
Entonces hemos visto el concepto de clase, 00:02:57
hemos visto que sostancialmente es un molde, 00:03:00
es una forma de definir las características 00:03:02
y las funcionalidades de un objeto que voy a modelizar 00:03:07
para que luego pueda, a partir de este molde, 00:03:10
crear objetos, crear copias 00:03:13
que tienen toda la misma estructura, 00:03:15
tienen todas las mismas características, 00:03:18
las mismas funcionalidades, 00:03:20
pero son copias distintas, son copias que tienen una vida separada una de la otra 00:03:21
y que no se influencian una de la otra. 00:03:28
Si yo creo el objeto A y el objeto B, si hago una modificación o hago hacer algo al objeto A, 00:03:31
el objeto B no se ve modificado. 00:03:36
Además, tanto el objeto A como el objeto B tendrán sus propias características 00:03:38
y por lo tanto será identificado de alguna forma. 00:03:42
Luego, depende de lo que yo quiero hacer. 00:03:45
Yo puedo hacer el objeto persona y modelizarlo de formas completamente distintas dependiendo del sistema en el que estoy. Habrá sistemas en el que requerirá que el concepto de persona tenga unas ciertas características y habrá otros sistemas que esas características a lo mejor no son suficientes y necesitaré más características o necesitaré características distintas. 00:03:47
Entonces, no es que persona se hace así y todo lo que quiere modelizar a una persona lo tiene que hacer así, ¿vale? En un sistema podría ser suficiente saber el nombre y el apellido de la persona, en otro debería ser nombre, apellido y el DNI, en otro el nombre, apellido y el DNI y también dónde vive y cuántos años tiene y quién son sus familiares, no lo sé, ¿vale? 00:04:10
Entonces, la idea es que, en la parte anterior a esta, nosotros hemos aprendido a hacer pequeños 00:04:32
ejercicios en el que se nos daba un problema definiendo en palabras, en castellano, un 00:04:43
objeto y nosotros, a partir de eso, teníamos que crear una, dos, tres clases a veces entrelazadas 00:04:53
entre ellas, ¿vale? Como en el caso 00:05:00
típico de alumno, con sus materias 00:05:02
y la materia tiene una nota, etcétera, etcétera. 00:05:04
Y encontrar 00:05:07
la forma, digamos, de trabajar 00:05:08
con esto. Nosotros 00:05:10
en este momento deberíamos haber aprendido, 00:05:12
deberíamos saber hacer 00:05:15
lo básico. Me dicen, 00:05:16
oye, mira, quiero modelizar un taller 00:05:18
de autos, pues de 00:05:20
coches, pues voy a pensar 00:05:22
cuáles son los elementos, 00:05:25
cuáles son los objetos 00:05:26
que voy a necesitar, 00:05:28
el objeto coche, el objeto mecánico, el objeto factura, el objeto... lo que me haga falta y a 00:05:30
ese punto crear mi sistema. Nosotros podemos hacer sistemas recientes sencillos. Como ayuda para hacer 00:05:39
sistemas no demasiado sencillos, con un cierto nivel de complejidad, han venido los arrays, 00:05:48
que son otro grande tema que hemos visto en la primera 00:05:55
evaluación, los arrays son colecciones 00:05:58
de datos sustancialmente, son en vez 00:06:00
de una variable con dentro un valor 00:06:02
concreto, pues tengo 00:06:04
una variable que 00:06:05
apunta a una colección 00:06:08
de datos de un determinado tipo 00:06:10
y los arrays pueden ser de todo 00:06:12
pueden ser arrays de int, pueden ser arrays de double 00:06:14
pero pueden ser también 00:06:16
arrays de objetos, que es lo que 00:06:18
nos interesa a nosotros, porque nosotros 00:06:20
con programación orientada a objetos, al fin y al cabo 00:06:21
lo que necesitamos 00:06:24
es manejar muchos 00:06:25
objetos. Entonces, cuando yo tengo array, 00:06:27
cuando tengo un coche, 00:06:29
no quiero una variable que tenga dentro 00:06:31
un coche, porque no sé cuántos coches van a 00:06:33
venir a mi taller. Prefiero 00:06:35
tener un array de coches. 00:06:37
Esto 00:06:40
me permite poner ahí dentro 00:06:41
todos los coches que llegan 00:06:43
a mi taller y trabajar 00:06:45
con ellos. Arreglarlos, repararlos, 00:06:47
venderlos, 00:06:49
desguazarlos. 00:06:51
cosas por el estilo, ¿vale? Dependiendo 00:06:52
de lo que tiene que hacer mi sistema. Pero el manejo 00:06:57
de arrays en este momento es fundamental para poder 00:07:00
gestionar este tipo de sistemas un poquito más complejos. Esto se 00:07:05
sustituirá dentro de un rato, después de esta 00:07:08
parte, digamos, teórica de programación orientada a objetos 00:07:12
PRO, veremos las colecciones de datos, 00:07:15
Las colecciones de datos sustituirán los arrays. 00:07:20
Son formas un poquito más sencillas que los arrays. 00:07:24
¿Os acordáis cuando nosotros hicimos una clase estática que permitía darme un array y un nuevo objeto? 00:07:28
Y ese añadía este objeto a ese array y me devolvía un array más grande con ese objeto dentro. 00:07:39
¿Os acordáis? 00:07:46
Repito. 00:07:49
¿Os acordáis que nosotros hicimos unos métodos, que os puedo enseñar? 00:07:50
¿Os acordáis que nosotros hicimos un método que se llamaba gestor array, una clase, gestor array, con métodos, lo diré, estáticos, ¿vale? 00:07:58
Porque nos dependían del objeto, dependían de la clase, no había objeto, nosotros nos creábamos objetos de gestión array, ¿vale? 00:08:12
lo atendré en objetos por algún lado, gestionaré, ¿vale? 00:08:20
Entonces nosotros nos hicimos esta clase que luego íbamos copiando 00:08:31
donde queríamos y le añadíamos cosas, en realidad esta debería haber sido 00:08:39
única en algún lado para que luego si modifico lo modifico allí 00:08:42
y lo uso en todo el lado, pero bueno, donde nosotros creamos este método aquí, 00:08:46
que era un método de, por ejemplo, esto era para string y decía, 00:08:50
ok, quiero añadir 00:08:54
esta string de aquí 00:08:56
a este array, ¿vale? 00:08:58
Entonces tú me pasabas 00:09:00
un string y me pasaba un array, 00:09:02
yo lo que hacía era hacer más grande 00:09:04
el array que me has pasado, 00:09:06
copiar el array 00:09:09
que me has pasado en el nuevo array 00:09:10
y luego añadir al fondo 00:09:12
el elemento que me has pasado 00:09:14
en él, ¿vale? Y te devuelvo 00:09:16
el nuevo array. 00:09:18
¿Sí? 00:09:22
Pues esto 00:09:23
es lo que hará, en un cierto sentido, las colecciones. 00:09:24
Cuando nosotros veremos las colecciones, son clases ya hechas 00:09:29
que en vez de tener que hacerlo yo a mano, 00:09:32
ya me proporciona un método add que me dice, añade un elemento. 00:09:35
Entonces yo tendré una lista de coches 00:09:39
y en vez de estar pensando, oye, ¿cuánto es grande la lista? 00:09:41
¿Cuánto grande la he hecho? ¿La tengo que extender? 00:09:45
Pues no, tendré un método add. 00:09:47
Lo que hago es añadir un nuevo coche y él en automático me lo añade. 00:09:49
Porque por debajo estará haciendo algo parecido a esto. 00:09:53
Dependiendo de cómo estáis o por debajo. 00:09:58
Pero es siempre lo mismo. 00:10:01
Nosotros hemos empezado desde abajo y vamos hacia arriba. 00:10:02
Abajo, arriba, ¿en qué eje? 00:10:06
Estamos aumentando nosotros. 00:10:09
Exacto. El nivel de abstracción. 00:10:13
Nosotros hemos empezado con cosas muy concretas, con operaciones muy concretas. 00:10:15
Y luego vamos escondiéndose estas operaciones en operaciones que llamamos, le damos un nombre, como por ejemplo add, y este me añade un elemento a un array y yo no sé cómo lo hace, pero lo hace, ¿vale? 00:10:19
Lo sé porque lo he estudiado y porque lo he hecho yo, pero en un futuro me darán algunos métodos que yo no sé cómo funcionan y aún así lo uso, esto lo estamos ya haciendo. 00:10:34
El printerln, ¿quién sabe cómo funciona el printerln? 00:10:44
¿Quién, si yo os dijera, vale, printerln no lo podéis utilizar, escribid en pantalla, 00:10:49
¿cuántos de vosotros sabrían programar el printerln? 00:10:55
10. 00:11:00
No sabéis por dónde moveros. 00:11:02
Me costaría a mí programar el printerln. 00:11:06
Yo no lo sé hacer. 00:11:09
Si ahora me siento aquí y digo, programa el printerln, no lo sé hacer. 00:11:10
¿Por qué? Porque uso el que ya me han dado hecho. 00:11:13
vale entonces después de todo esto bla bla bla bla bla de repaso y de inicio vamos a ver el tema 00:11:15
nuevo el tema nuevo pilla como base lo que hemos visto de objetos y clases y añade un nuevo 00:11:26
concepto vale este nuevo concepto es un concepto muy potente no es difícil de entender pero es muy 00:11:35
potente me da me abre a la posibilidad de hacer cosas bastante avanzadas vale es una de las 00:11:41
características base de la programación orientada a objetos todos los lenguajes que sean orientada 00:11:48
a objetos tienen este mecanismo dentro vale Java lo tiene C++ lo tiene Python lo tendrá vale 00:11:54
El concepto es que es una cosa general, nosotros la vemos aplicada a Java, pero no es que es solo de Java. 00:12:06
Es un mecanismo fundamentalmente para la reutilización del software. 00:12:16
Nosotros, cuando hablamos de programación orientada a objetos, ya hablamos de esto, de reutilizar el código. 00:12:21
Era una de las cosas importantes de la programación orientada a objetos. 00:12:29
Yo me creaba el objeto, modelizarlo como persona, y en todos los sistemas que yo creo en un futuro, este código lo podría reutilizar, si me vale ese modelo de persona. 00:12:32
Obviamente, si el modelo de persona tiene que ser distinto, tiene que tener cosas distintas, tenía un problema, tenía que rehacerlo. 00:12:46
Pero aún así, si yo, en mi empresa, que gestiona determinadas cosas, me he creado un modelo de persona, lo más probable es que todos los sistemas de mi empresa, ese modelo de persona le valga, ¿vale? Porque cuando lo he creado, lo he creado según el problema o según los problemas que gestiona mi empresa, ¿sí? 00:12:51
entonces y hacia estas clases y luego esta clase la podía importar o copiar en otros proyectos y 00:13:12
tenerlas allí vale él le utilizaba el código utilizar el código es muy importante de hecho 00:13:20
nosotros estamos reutilizando el código constantemente cuando usamos println estamos 00:13:24
utilizando el código estamos pillando la base de java la estamos importando en nuestro programa y 00:13:29
Ahora mi programa también usa el PrintWriter, el objeto que tiene dentro el println. 00:13:35
Y el escáner, nosotros no hemos creado el escáner, el escáner lo reutilizamos toda la vez que queremos leer de teclado, 00:13:44
pillando una clase que alguien más ha desarrollado, la importo en mi proyecto y la uso. 00:13:52
¿Sí? Ok. 00:13:59
¿Qué pasa 00:14:02
si yo 00:14:03
esta persona que importo, 00:14:06
o sea, esta clase de persona que ya tengo 00:14:08
creado, ha hecho un nuevo sistema? 00:14:10
Quiero utilizar la persona, pero la persona 00:14:12
no es suficiente, 00:14:14
no es... 00:14:16
Me vale, porque es un concepto 00:14:17
básico de persona, me vale, pero 00:14:19
necesito algo más. 00:14:21
Puedo aplicar 00:14:24
esto de la herencia. 00:14:26
Es decir, yo puedo crear una clase que herede de otra clase, una clase que extienda una clase ya existente. 00:14:28
Por ejemplo, si yo tuviera ya hecho la clase persona, la clase persona que tiene un nombre y una edad, y eso me vale, eso es la definición básica de una persona, 00:14:38
y quisiera hacer una escuela, por ejemplo, creo que sí, 00:14:55
pues la persona a sí mismo no me valdría, ¿vale? 00:15:00
Porque dentro de una escuela hay también profesores y hay también estudiantes 00:15:04
y necesitaría algo más. 00:15:08
O sea, la persona sola no tiene notas. 00:15:11
Entonces, ¿cómo hago luego a gestionar las notas de un alumno? 00:15:13
Una persona sola no tiene las materias que imparte. 00:15:17
Por lo tanto, ¿cómo hago en persona a ponerse? 00:15:21
Lo que puede hacer es crear una nueva clase completamente por otro lado, que sea profesor, que tenga dentro nombre, tenga dentro edad, etc. 00:15:23
Pero no estoy reutilizando el código, estoy haciendo otra vez un trabajo que ya he hecho. 00:15:33
Debería reimplementar todo lo que hace una persona, que es tener su nombre, tener su edad, para presentarse, decir cuántos años tiene, respirar, qué sé yo. 00:15:38
y además añadirle todo lo que puede hacer un profesor, o sea, añadirle una materia, 00:15:48
imparte una materia, hora de clase, qué sé yo. Y luego debería ir al estudiante y decir, 00:15:55
ok, vuelve a rehacer todo lo que has hecho de persona, o sea, ponerle el nombre, ponerle la 00:16:02
edad, poner cualquier ser presente, poner que diga otra cosa, y además poner todo lo típico 00:16:07
del estudiante. Esto, dices, pero a ver, lo hago una vez, ya lo tengo solucionado. Pero tened en 00:16:12
cuenta que tiene siempre el problema que si ahora yo me doy cuenta que hay un error en el método de 00:16:19
saludar o que quiero añadir otra cosa que hace todas las personas, tendré que tocar todas las 00:16:24
clases que he creado, como hemos dicho antes. O sea, debería ir al profesor y modificar el saludar. 00:16:31
Debería ir al estudiante, modificar, ir al mecánico, ir al doctor y modificar. 00:16:38
Eso es poco manejable. 00:16:44
Es lo que pasaba en un cierto sentido antes de la orientación a objetos. 00:16:47
Y era razón porque cuando se llegaba a determinados sistemas muy complejos, 00:16:53
pues el sistema se hundía. 00:16:58
Entonces, ¿cómo funciona la herencia? 00:17:01
La herencia funciona que yo me creo persona. 00:17:03
Le pongo todo lo que es una persona. 00:17:05
Y cuando voy a crear profesor, en vez de empezar desde cero, le digo, oye profesor, tú heredas de persona. 00:17:07
Tú eres una persona. Tú extendes la clase persona. 00:17:16
Y todo lo que está en persona, mágicamente, está también en profesor. 00:17:22
Sin necesidad que yo lo descrita. 00:17:26
añado en profesor 00:17:28
solo la parte 00:17:31
extra que caracteriza 00:17:32
el profesor con respecto 00:17:35
a persona 00:17:37
¿se entiende? 00:17:37
ahora cuando hago estudiante o alumno 00:17:40
hago lo mismo, le digo 00:17:43
oye mira, tú eres una persona, tienes todo 00:17:44
lo que tiene una persona, pero además 00:17:47
tienes 00:17:49
tus notas, tienes la posibilidad de estudiar 00:17:50
tienes hacer 00:17:53
un examen, no lo sé 00:17:55
toda la característica propia del estudiante. Entonces ahora lo que es un estudiante no está 00:17:56
definido en una clase sola, está definido en dos clases. Está definido en estudiante con las cosas 00:18:02
particulares del estudiante y luego en persona porque está heredando todo lo que es una persona. 00:18:08
Si ahora me doy cuenta que en persona el método saludar está mal, me voy a la clase persona, 00:18:13
lo modifico en persona 00:18:20
y en automático todas las clases 00:18:22
que heredan de persona 00:18:25
han solucionado este problema. 00:18:26
¿Entiendes? 00:18:31
Útil. 00:18:33
Mucho. 00:18:35
Potente. 00:18:36
¿Vale? 00:18:37
¿Concepto? 00:18:38
Sencillo. 00:18:39
Si tengo ya persona, 00:18:40
¿por qué duplicar mil veces 00:18:41
el concepto de persona? 00:18:43
Pues lo tengo, lo tengo definido 00:18:45
y lo tengo allí para... 00:18:47
Si tengo que especificar más algo, 00:18:49
Pues simplemente lo que hago es crearme una nueva clase que herede de personas. 00:18:52
Oye, y si yo quisiera hacer, no lo sé, un profesor particular, un profesor catedrático, ¿vale? 00:18:57
Que es un profesor, pero que tiene algo más. 00:19:07
¿Qué haría? 00:19:10
O sea, que haría una clase, profesor catedrático, que extende profesor, que hereda profesor. 00:19:18
El profesor hereda a la persona, por lo tanto, esto de aquí está heredando todas estas cosas. 00:19:26
¿Entiendes? 00:19:33
Solo sería necesario ponerle... 00:19:34
Es que profesor, porque profesor hereda a la persona. 00:19:39
Tened en cuenta que, y esto sí es propio de Java, Java puede heredar de una sola clase. 00:19:43
En realidad siempre hereda de dos, o sea, siempre hereda de una y puede heredar de otra. 00:19:52
¿Vale? 00:19:57
Pero no se puede hacer herencia múltiple. 00:19:57
No puedo decir que el profesor hereda de persona y hereda de ser humano. 00:20:00
O uno u otro. 00:20:06
Por eso los profesores no somos seres humanos. 00:20:09
¿Vale? 00:20:12
Una pregunta. 00:20:13
Cuando tú heredas, heredas todas las funciones. 00:20:14
No puedes ser específico. 00:20:17
No, heredas todo. 00:20:20
¿Vale? 00:20:22
Lo que puedes hacer es modificar el funcionamiento de una de las funciones. 00:20:22
Tened en cuenta que la relación que se crea con la herencia es la relación de es un. 00:20:27
O sea, un profesor es una persona. 00:20:37
Entonces, es obvio que tenga que hacer todo lo que te hace una persona. 00:20:40
Porque tú eres una persona. 00:20:43
A partir de allí puedes también hacer algo más. 00:20:46
Pero eres una persona. 00:20:48
Y allá donde se pueda usar una persona, se podrá usar un profesor. 00:20:50
Porque es una persona. 00:20:54
¿Ok? 00:20:57
En algunos lenguajes de programación, como por ejemplo C++, se permite herencia múltiple. 00:20:58
¿No es que la herencia se hereda de uno solo? Pues no. 00:21:05
Hay lenguajes de programación que permiten herencia múltiple, hay lenguajes de programación que no lo permiten. 00:21:09
Aquí veremos que se soluciona parcialmente este problema con el concepto de interfaz, pero todavía no estamos ahí. 00:21:16
¿Vale? Entonces, siempre si heredo, heredo de una cosa sola. En realidad, heredo de dos. ¿Vale? Porque cualquier clase que hayáis hecho vosotros hasta ahora, siempre ha usado este mecanismo. Siempre ha extendido otra clase. 00:21:25
Vosotros no lo sabéis, o mejor, lo sospecháis, pero nunca lo habéis escrito, nunca habéis formalizado que eso existe. 00:21:40
Y la clase que todos los objetos extenden, que heredan de esa clase todos los objetos que habéis creado vosotros es Object. 00:21:49
La clase Object es la clase principal, fundamental. 00:22:04
cualquier clase 00:22:10
que vosotros habéis hecho hasta ahora 00:22:12
siempre ha heredado de esta clase. 00:22:14
De hecho, vosotros podéis utilizar 00:22:17
el toString, ¿os acordáis? 00:22:18
Hemos visto este toString, que 00:22:20
escribí hasta hace... ¿Este toString dónde está 00:22:22
definido? Pues en la clase object. 00:22:24
Porque lo que has creado tú 00:22:26
es un object. Y puede 00:22:28
usar todos los métodos de object. 00:22:30
¿Eh? Lo veremos, ¿eh? 00:22:33
Volvemos a ver. Queda claro por ahora 00:22:34
esto, solo esta transparencia, ¿vale? 00:22:36
permite, la herencia me permite definir una clase 00:22:38
y a partir de esta clase extenderla con nuevas clases 00:22:42
que heredan todas las características y métodos 00:22:45
de la clase, digamos, superclase o clase padre 00:22:50
o clase progenitor o clase por arriba, no lo sé 00:22:54
¿Cuándo 00:22:57
se usa la herencia? ¿Cómo 00:23:01
se usa la herencia cuando nos viene bien vale hay dos formas fundamentales de trabajar con la 00:23:06
herencia lo que es la especialización en la generalización especialización es cuando yo 00:23:14
tengo ya una clase la clase vehículo y quiero crear algo más específico o la clase persona 00:23:19
quiero crear una profesión la clase vehículo y quiero crear un coche la clase fruta y quiero 00:23:28
crear una manzana. 00:23:35
¿Sí? Entonces, yo 00:23:38
tengo ya una clase hecha 00:23:39
que me da las características 00:23:41
típicas 00:23:43
de ese objeto. ¿Vale? 00:23:45
Pero para mí no son 00:23:48
suficientes. Necesito 00:23:49
algo más, porque lo que quiero 00:23:51
modelizar tiene un poquito 00:23:53
más que eso. 00:23:55
¿Sí? Tengo la persona. 00:23:57
A mí me vale toda la característica de persona, 00:23:59
el nombre, el apellido, 00:24:01
el DNI, la dirección, 00:24:03
Pero además quiero que pueda impartir asignaturas 00:24:05
Entonces le tengo que añadir todo esto 00:24:08
Esta sería una especialización 00:24:10
¿Vale? 00:24:13
Escenario, tenemos que desarrollar una nueva clase 00:24:14
Que se parece mucho a una que tenemos 00:24:17
Pero necesita información 00:24:18
Tanto como características como comportamientos 00:24:21
O sea, métodos y atributos adicional 00:24:23
¿Vale? 00:24:26
Por lo tanto, hago una subclase 00:24:27
¿Sí? 00:24:29
Subclase, clase hija o clase derivada 00:24:31
Pues lo mismo 00:24:33
Son formas distintas de decir una clase que hereda de otra. 00:24:34
Creamos una clase derivada y añadimos nuevas funcionalidades sin tener que describir código común. 00:24:40
Lo que hemos hecho antes en el ejemplo. 00:24:45
Tengo persona, entonces digo, oye, mira, quiero hacer un profesor, pues extendo profesor. 00:24:48
Esta es especificación. 00:24:54
Oye, ¿tengo que decir también estudiante? Pues especifico profesor. 00:24:55
La segunda opción es la generalización. 00:25:00
O sea, que yo me doy cuenta que he hecho un programa, he hecho un sistema, y que tengo varias clases, y me doy cuenta que muchas de estas clases tienen algo en común. 00:25:02
Imaginaos una situación parecida a esta donde no está persona. 00:25:13
Yo tengo una escuela donde me ha hecho persona, profesor y estudiante. 00:25:17
Y veo que profesor tiene nombre, apellido, no sé qué, no sé cuánto. 00:25:22
Y estudiante tiene nombre, apellido, no sé qué, no sé cuánto. 00:25:25
Y no lo sé. 00:25:28
El conserje tiene nombre, apellido, no sé qué, no sé cuánto. 00:25:29
Me doy cuenta que hay cosas que se repiten mucho en mis clases. 00:25:32
Entonces puedo decir, vale, espera. 00:25:37
Lo que hago es una reingenierización de mi sistema. 00:25:38
Pillo las partes comunes de las clases que tengo por debajo 00:25:42
y me creo una superclase, ¿vale? 00:25:46
Una clase para arriba que tenga esta parte común de todos. 00:25:49
De esta forma, soluciono el problema que decía antes. 00:25:53
si tengo que hacer una modificación para que 00:25:56
mejore la eficiencia 00:25:58
para que solucione un problema 00:26:00
a una de estas cosas no la tengo que hacer en todas las clases 00:26:01
me la hago solo en la superclase 00:26:05
y las clases que heredan 00:26:06
lo adquieren directamente 00:26:08
¿sí? 00:26:10
entonces, ¿qué escenario? 00:26:12
tengo 00:26:15
coche, tren 00:26:15
bicicleta y 00:26:18
avión, todos son 00:26:20
vehículos, los tengo ya hechos 00:26:22
y me doy cuenta que todos tienen velocidad máxima, todos tienen, no lo sé, kilómetros recorridos. 00:26:24
Vale, entonces estos los saco de todas estas clases y los pongo en una superclase genérica que es vehículo 00:26:32
y haré que todas estas hereden de vehículo. 00:26:39
¿Sí? ¿Se entiende ya? 00:26:43
Tenemos un conjunto numeroso de clases muy similares, con códigos que se repiten 00:26:45
y es difícil de actualizar y mantener porque cada vez que lo mantengo tengo que tocarlo en todas las cosas. 00:26:50
Pues movemos el código que se repite en un único sitio, creando una frase pago. 00:26:54
¿Dudas? 00:27:00
Ejemplo más práctico, ¿vale? 00:27:06
Entonces, imaginaos que yo tenga recurso, aula y ordenador, ¿vale? 00:27:09
Recurso es un recurso genérico, aula es un aula, ordenador es uno de nuestros ordenadores, ¿vale? 00:27:15
En una escuela o lo que sea. 00:27:23
Veo que un recurso en general tiene un nombre, descripción, decir nombre, decir descripción, ¿vale? 00:27:24
Sus atributos y sus métodos. 00:27:30
Y veo que un aula tiene un nombre, una descripción también, tiene una localización, tiene un decir localización, tiene también un decir nombre, un decir descripción, ¿vale? 00:27:32
Sin embargo, el ordenador tiene igualmente un nombre que será un identificador, ¿vale? 00:27:42
La descripción, el sistema operativo que tiene, etcétera, etcétera. 00:27:45
Me doy cuenta que la parte azul se repite, ¿vale? 00:27:49
Es la misma en todos los recursos. 00:27:54
Entonces, en un cierto sentido, a nivel de generalización, digo, vale, esta la saco de aquí 00:27:57
y la pongo en una superclase genérica de curso y hago que desde recurso herede tanto aula como ordenador. 00:28:03
Porque los dos son, en general, recursos de la escuela. 00:28:13
No será un recurso espacial, un recurso más físico, pero los dos son recursos a que la escuela pueda acceder, ¿vale? 00:28:17
Entonces, la parte común se quedará en recurso con su definición de atributos y su definición de métodos. 00:28:24
Aula heredará de recurso, por lo tanto tiene ya estas cosas y además añadirá la parte que era específica del aula. 00:28:32
Ordenador heredará de recurso, por lo tanto tendrá toda la parte azul y además añadirá la parte específica del recurso. 00:28:41
¿Cómo se declararía esta? 00:28:50
cuando yo creo la clase aula 00:28:51
public class aula 00:28:54
extends 00:28:56
recurso 00:28:57
esta es una palabra reservada 00:28:59
extends, que me define que 00:29:01
esta clase extiende 00:29:03
otra clase, que esta clase hereda 00:29:05
de otra clase, que esta es una subclase 00:29:08
de la otra clase 00:29:10
entonces 00:29:10
mientras aquí sería public class recurso 00:29:12
public class aula, public class ordenador 00:29:15
con un código que se repite 00:29:18
Aquí tendría una public class recurso, definición, 00:29:19
y luego tendría public class aula, extend recurso, 00:29:23
extends recurso, y public class ordenador, extends recurso. 00:29:26
Papi. 00:29:33
¿Sí? 00:29:35
Bla, bla, bla, bla, bla. 00:29:36
¿Cómo se dice? 00:29:42
Nombres, ¿vale? 00:29:45
Para entendernos, sinónimos, para entender cuando hablamos de herencia, ¿vale? 00:29:46
Si definimos la clase taxi a partir de la clase vehículo, entonces tenemos vehículos y tenemos taxi que hereda de vehículo, podemos decir las siguientes cosas. 00:29:51
Que taxi hereda las variables y métodos de vehículo. 00:30:03
Esto es correcto. 00:30:07
Taxi extiende vehículo. 00:30:09
Perfecto. 00:30:12
Taxi es subclase de vehículo. 00:30:13
Correcto. 00:30:16
taxi es su clase derivada o clase hija de vida. Se puede decir también que taxi hereda directamente el vehículo, perfecto, ¿vale? 00:30:17
En vez de, al revés, pues vehículo es superclase de taxi, o vehículo es clase base de taxi, ¿vale? 00:30:27
Clase base quiere decir que es la que está para arriba en la jerarquía, ¿vale? O clase padre, clase madre, clase lo que queráis, ¿vale? De taxi. 00:30:37
La herencia realiza, la relación es un, ¿vale? Eso es importante porque eso se olvida. 00:30:47
Una cosa de abajo que hereda algo de arriba, una subclase que hereda de una superclase, 00:30:54
la subclase es una superclase. 00:30:59
Si yo tengo un taxi que hereda de vehículo, el taxi es un vehículo. 00:31:03
Un objeto taxi es también un objeto vehículo. 00:31:07
Si yo tengo un método que recibe como parámetro un objeto vehículo, le puedo pasar un taxi. 00:31:12
Al revés, no. 00:31:20
Vehículo no es un taxi. 00:31:22
Si yo tengo un método que necesita un objeto taxi, no le puedo pasar un vehículo. 00:31:25
¿Lo veis por qué? 00:31:31
Pillamos un método que pilla un objeto vehículo. 00:31:37
Pilla un objeto vehículo y hace algo con ese vehículo. 00:31:41
Pues usará todo lo que viene en un objeto vehículo. 00:31:44
Por ejemplo, podría hacer getMatricula, podría hacer getModelo, que son métodos de vehículo. 00:31:48
Si yo en vez de un vehículo le paso un taxi, el taxi lo tiene getModelo. 00:31:55
Sí, lo tiene getMatricula. 00:32:00
Sí, por lo tanto, pasar un taxi en un sitio donde se usa un vehículo no tiene problema 00:32:02
porque todos los métodos que puedo pedir a un vehículo, el taxi los tendrá. 00:32:08
tendrá algo más 00:32:13
¿sí? 00:32:14
ahora, al revés, si yo tengo un método 00:32:16
que me pilla un taxi 00:32:19
pues quiere decir que este método podría utilizar 00:32:20
por ejemplo set número licencia 00:32:22
¿sí? 00:32:24
pero cuidado, que si yo ahora le paso 00:32:27
un vehículo, vehículo puede hacer set 00:32:28
set 00:32:30
set número licencia 00:32:32
no, porque no lo tiene 00:32:35
entonces, un taxi 00:32:36
es un vehículo, un vehículo no es 00:32:39
un taxi, ¿se entiende? 00:32:41
Un alumno es una persona. 00:32:45
Una persona no es un alumno. 00:32:49
Para sintaxis, ¿vale? 00:32:59
En Java, para indicar que una clase hereda de otra, 00:33:02
se emplea la palabra reservada, extends, ¿vale? 00:33:05
Esto public o sin nada, lo que sea, 00:33:08
clase hija, extends, clase public. 00:33:11
¿Extends sirve para hacer la superclase? 00:33:15
No, la superclase no lo tiene. 00:33:18
En este caso, por ejemplo, la clase padre no tendría nada. 00:33:21
O, si hay varios niveles, yo puedo hacer taxi que estén de vehículo, que estén de objeto. 00:33:25
Claro, pero si es el revés y tienes ya, por ejemplo, taxi y bus, 00:33:35
tú dices que pueden tener cosas en común y ahí crear una superclase. 00:33:40
Si solo tienes taxi y autobús, ¿cuál sería lo que necesitas para crear el vehículo? 00:33:45
O sea, la generalización. 00:33:54
Para hacer la generalización, taxi tendría también todas estas cosas. 00:33:56
Y autobús tendría también todas estas cosas. 00:34:00
Entonces son dos clases separadas que no extienden nada. 00:34:02
Tú lo que harías es crearte una clase nueva que no extiende nada, 00:34:06
vehículo, ponerla allí dentro 00:34:10
la cosa en común de taxi 00:34:13
y autobús, quitándola de taxi y autobús 00:34:15
y a esta punta dirías que taxi 00:34:17
extends vehículo y autobús 00:34:19
extends vehículo. 00:34:21
Igual son que extends. 00:34:23
Eso, que tú 00:34:26
lo hagas por generalización o lo hagas por 00:34:27
especificación, es 00:34:29
lo mismo. 00:34:31
Es dos formas de verlas, es cuando se 00:34:33
usa normalmente. 00:34:35
Son los casos típicos de tú en un 00:34:37
sistema, te das cuenta que antes de un momento 00:34:39
ya tienes una 00:34:41
clase y quieres hacer una especificación 00:34:42
pues ahí usa la asistencia 00:34:45
o que tú te das cuenta 00:34:47
que ya he creado varias clases y todas 00:34:49
tienen una parte en común, entonces dices 00:34:51
vale, hago 00:34:53
pero luego al final se te queda igual 00:34:54
a nivel de código con este 00:34:57
¿sí? 00:34:59
Regulación de clases derivadas, vale, entonces si yo tengo 00:35:02
persona, por ejemplo, esta es public 00:35:05
class persona, vale, porque es 00:35:07
arriba, en realidad aquí estaría 00:35:09
pero no lo ponemos 00:35:11
extends object 00:35:14
¿vale? 00:35:16
por defecto 00:35:17
si tú no lo pones 00:35:18
extends object 00:35:19
¿vale? 00:35:20
entonces luego tengo 00:35:22
empleado 00:35:23
¿vale? 00:35:24
que extens... 00:35:25
bueno, alumno 00:35:25
que extens persona 00:35:26
entonces un alumno 00:35:27
es una persona 00:35:29
¿sí? 00:35:29
luego tengo empleado 00:35:31
que extens persona 00:35:32
y luego tengo profesor 00:35:33
que extens empleado 00:35:35
¿vale? 00:35:36
entonces por ejemplo 00:35:37
aquí le podría poner 00:35:38
cuestiones de sueldo 00:35:39
por ejemplo 00:35:41
de cuánto sueldo tiene, si le pago 00:35:41
el mes o cosas por el estilo, que un alumno 00:35:43
no tiene, pero un profesor sí. 00:35:45
Tened en cuenta que un profesor es un empleado 00:35:47
que es una persona, por lo tanto 00:35:50
el profesor también es una persona. 00:35:51
Todo lo que puede hacer una persona lo puede hacer 00:35:53
un profesor. Y todo lo que puede hacer una persona 00:35:55
lo puede hacer también un alumno. 00:35:57
Todo lo que puede hacer un empleado 00:36:00
el alumno no lo puede hacer. 00:36:02
Pero un profesor sí. 00:36:04
Y una persona tampoco. 00:36:06
¿Está claro? 00:36:10
A partir de aquí 00:36:12
yo me hago toda la estructura 00:36:13
que me da la gana, grande, compleja 00:36:15
cuanto me da la gana, pero ten en cuenta 00:36:17
que aquí hay siempre un nivel extra 00:36:19
que es 00:36:21
todo empieza siempre de 8 00:36:22
entonces, el profesor es un 8 00:36:25
si, porque es un empleado 00:36:29
que es una persona, que es un 8 00:36:31
como decías 00:36:33
que era directamente una subclase 00:36:37
depende de solo 00:36:39
superclase 00:36:40
¿Y cómo puede ser que dependa de los que es lo que habías dicho antes? 00:36:42
No depende de los. 00:36:45
Profesor depende de empleado. 00:36:47
Vale, eso ya. 00:36:49
Pero además de object, dices. 00:36:51
Pero es que tú no estás diciendo que profesor depende de object y de empleado. 00:36:54
Tú estás diciendo que depende de empleado, luego empleado de persona, persona de object. 00:36:59
O sea, tú vas arrastrando. 00:37:04
Pero no estás, o sea, vas escalón por escalón. 00:37:06
Cada vez añades una cosa. 00:37:09
Tú estás heredando y tirándote detrás todo. 00:37:11
O sea, tú cuando creas persona estás traiendo todo lo de objeto. 00:37:15
Y cuando ya creas empleado, estás traiendo todo lo de objeto y además todo lo de persona. 00:37:19
Pero tú estás extendiendo una sola clase. 00:37:26
No podrías extender persona y como empleado y también gestor sueldo. 00:37:30
no puedes 00:37:35
no puedes 00:37:37
heredar de dos clases a la vez 00:37:38
o las metes 00:37:41
en orden, pero por ejemplo 00:37:42
si yo tuviera aquí un gestor sueldo, que no sé 00:37:45
quién es, pero para empleado, para gestor 00:37:47
sueldo, gestor sueldo es una persona 00:37:49
si no es 00:37:51
una persona, no lo puedes poner aquí 00:37:53
entonces ahí tendría un problema 00:37:54
tendría un problema de tener que 00:37:57
heredar de persona y heredar de esta 00:37:59
otra clase, y no puedo 00:38:01
Entonces, hay mecanismo para hacerlo. Sí, hay otras formas de hacerlo. 00:38:03
¿Dudas? ¿Dudas sobre esto? ¿Esto es sintaxis pura, fácil, con el sense? 00:38:10
Entonces, una subclase, que es todo esto, es como si dentro tuviera un objeto de la superclase. 00:38:19
Entonces, la clase alumno, que es todo esto, tiene dentro un objeto persona. 00:38:33
¿Por qué? Porque alumno extiende persona. 00:38:47
Entonces es como si yo aquí dentro me creo una persona y luego a esta persona la extiendo con los datos y las características y los métodos típicos del alumno. 00:38:52
Pero, y de hecho es así como se crea. Cuando yo creo un alumno, antes me creo una persona 00:39:04
y a esta persona le añado todo lo del alumno. Por eso que, al fin y al cabo, si yo en un 00:39:13
método estoy utilizando una persona, puedo tranquilamente utilizar un alumno porque dentro 00:39:19
Tengo todo lo que es una persona. 00:39:25
¿Se entiende? 00:39:29
Pudas. 00:39:31
Pintas. 00:39:33
Si os acordáis, cuando vimos los modificadores, 00:39:39
estuvimos hablando de cuatro tipos de modificadores. 00:39:43
Estaba private, estaba public, estaba protected, estaba packaged. 00:39:46
O nada. 00:39:51
Y protected nosotros decimos, esto no lo entendemos todavía, 00:39:53
tenemos que saber qué es la herencia antes de poder entenderlo. 00:39:57
Esta obra lo sabe, ¿vale? 00:40:01
Cuando yo tengo protected, esto es, no es público, o sea, no es que cualquier clase pueda acceder a él, 00:40:03
pero tampoco es privado, o sea, que sólo esa clase puede acceder a él. 00:40:10
¿Quién puede acceder? 00:40:15
Puede acceder o clases que pertenecen al mismo package, o clases de package distintos, pero que hereden de esta clase. 00:40:16
Entonces, tengo cuatro niveles de privacidad. 00:40:29
private. Solo esta clase 00:40:31
accede a estas variables. 00:40:35
Fuera de esta clase, nadie puede acceder a estas variables. 00:40:36
Para poder acceder a estas variables 00:40:39
utilizaríamos 00:40:40
getReceptor. 00:40:42
Segundo estadio, 00:40:46
que sería package. 00:40:48
Package es 00:40:51
todos los que están dentro 00:40:52
del mismo package pueden acceder. 00:40:54
Si tú estás fuera del package 00:40:56
no puedes acceder a este estado. 00:40:59
tercer nivel 00:41:01
que sería protected 00:41:03
que es, si tú perteneces al mismo 00:41:06
package, puedes acceder 00:41:08
pero además 00:41:10
si tú eres de un package externo 00:41:12
que con package 00:41:14
con el modificador package no podrías 00:41:16
ya acceder, pero resulta que 00:41:18
tú extends esta clase 00:41:20
entonces sí 00:41:22
puedes acceder, o sea que si yo 00:41:24
hago de la clase persona 00:41:26
hago la clase alumno 00:41:28
en un package distinto, ¿vale? Y este es protected desde este package distinto. Si alumno 00:41:30
extensa persona puede acceder al nombre modificado. Y luego está public, que cualquiera puede 00:41:37
atacar o puede acceder como le vaya. Da igual que esté en el mismo package, en packages 00:41:46
distintos, cosas así. Public es peligroso. 00:41:51
El tema del package private y todo lo demás, ¿sería único especialmente para que se puedan 00:41:55
los estos cuatro modificadores son modificadores de visibilidad vale es 00:42:01
sirve para gestionar quién y desde dónde se puede acceder a estas variables directamente 00:42:15
normalmente para que te sirven los métodos más críticos de tu sistema no lo haces accesible 00:42:22
por fuera, desde fuera. 00:42:31
Si tú eres o somos 00:42:33
un empresa, ¿vale? 00:42:35
Desarrollamos el mismo sistema, pero cada uno 00:42:37
se ocupa de un package, 00:42:39
¿vale? A lo mejor hay cosas 00:42:42
que tú dices, vale, que toda la empresa acceda. 00:42:43
O sea, hasta otros grupos de trabajo 00:42:45
pueden acceder a esta variable porque es compartida 00:42:47
entre todos, la usamos entre todos. 00:42:49
Pero puede haber otras cosas que tú dices, 00:42:51
no, esta es una cosa de mi 00:42:53
departamento, del package 00:42:55
que estoy desarrollando yo 00:42:57
y quiero tener control 00:42:59
sobre ella, no quiero que alguien venga afuera 00:43:01
porque yo he asumido un cierto 00:43:03
valor, he asumido ciertas características 00:43:05
que si viene otro desde afuera 00:43:07
y me la cambia como le da la gana, 00:43:09
sin respetar estas reglas, posiblemente 00:43:11
se carga el programa entero. 00:43:13
Entonces, limito la 00:43:15
accesibilidad. 00:43:17
¿A quién la limito? Pues si yo 00:43:19
estoy desarrollando mi clase, 00:43:21
porque dentro del package que somos nosotros, 00:43:23
si yo tengo mi clase, él tiene su clase. 00:43:25
Si yo ya con ellos he hablado, hemos hecho una 00:43:27
cosa así, de que todos tienen que utilizar 00:43:29
mi variable, pero dentro del package 00:43:31
tiene que ser visible, pues le pongo 00:43:33
package. 00:43:35
Si yo estoy, 00:43:37
es una variable que solo depende de mi clase 00:43:39
y que no quiero que otros lo toquen, 00:43:41
pues le pongo private. 00:43:43
Entonces yo estoy seguro que yo puedo hacer lo que me da la gana, 00:43:44
o sea, puedo asumir lo que me da la gana porque soy 00:43:47
solo yo que estoy trabajando sobre eso. 00:43:49
Si él intenta atacarla y cambiarla, 00:43:50
o le he hecho un setter 00:43:53
o un getter, entonces si yo allí he comprobado 00:43:54
que sean datos correctos, 00:43:56
¿vale? O si no, él no puede hacer 00:43:58
hasta si está en mi mismo grupo de trabajo 00:44:00
del mismo package 00:44:03
ahora, si nosotros estamos desarrollando 00:44:04
un package, pero esta cosa aquí 00:44:07
de repente sale otro sistema 00:44:09
que son ellos de allá, que están desarrollando 00:44:11
un package distinto, que pero 00:44:13
quieren utilizar nuestra 00:44:15
clase y necesitan 00:44:16
extenderla 00:44:19
y necesitan atacar esta variable 00:44:21
para cambiarla de alguna forma 00:44:23
pero le pongo protected 00:44:24
que es, nosotros la podemos utilizar 00:44:27
ellos que la extendan la pueden utilizar pero no hay nadie más, la visibilidad o la accesibilidad de esta clase 00:44:29
que en este contexto son sinónimos 00:44:45
Y luego, como puede ser protected, para yo referirme a esa clase de persona, por ejemplo, tendría que referirme también al par que está haciendo 00:44:48
como nosotros hemos importado escáner si escáner dentro tuviera una variable de velocidad de 00:44:59
lectura que si vale que fuera protect y tú cuando importa ese escáner no podrías hacer 00:45:07
de asados pero si tú extiende ese escáner pues entonces si podría comprar esto simplemente para 00:45:14
saber no se nos había quedado allí el tintero de teníamos cuatro posibles modificadores que 00:45:26
era no poner nada, private, protected o public y protected no sabíamos qué era, ¿vale? 00:45:31
Pues aquí hay un ejemplito, persona, con nombre, apellido, nacimiento, public persona 00:45:37
que es el constructor, tiene otro constructor, fijaos que aquí, ¿qué está haciendo con 00:45:45
los constructores? 00:45:52
Pues está sobrecargando, ¿vale? 00:45:54
hay dos métodos 00:45:57
que se llaman iguales, dos constructores 00:46:00
que se llaman iguales, con distintos 00:46:02
parámetros para crear el objeto. 00:46:03
Este de aquí no pilla nada, y por lo tanto 00:46:06
creará un objeto básico. 00:46:08
Este de aquí pilla todos los datos y por lo tanto 00:46:09
asigna los datos concretamente. 00:46:12
¿Vale? Y luego imprime 00:46:14
la cosa. ¿Vale? 00:46:15
Entonces, ahora tenemos la clase alumno 00:46:20
que extiende persona. 00:46:23
¿Vale? 00:46:25
Tiene también 00:46:27
el string grupo 00:46:28
y el horario. Algo más. 00:46:29
¿Sí? Entonces, si yo aquí 00:46:34
a un objeto alumno preguntara 00:46:35
su nombre, ¿lo tendría? 00:46:37
Si yo iba a hacer alumno 00:46:43
x es igual a new 00:46:44
alumno y luego poner 00:46:46
x.nombre, ¿me daría 00:46:48
un error? Aquí no está 00:46:50
declarado nombre. ¿Me daría un error? 00:46:52
No. ¿Por qué? 00:46:54
Porque extende persona 00:46:56
y en persona nombre está definido. 00:46:58
por lo tanto existiría public alumno super acordáis cuando nosotros creábamos aquí de 00:47:00
forma automática un constructor de esta raíz cuál es el último que hemos hecho 00:47:14
¿os acordáis que el constructor me ponía esta cosa? 00:47:20
¿qué es esta cosa? 00:47:28
esto en este contexto aquí, nada más, lo que está haciendo es llamar el constructor de mi superclase 00:47:31
con parámetros ninguno. 00:47:44
Esto me está diciendo, ok, yo soy un alumno. 00:47:51
Como primer paso para crear un alumno, ¿qué tengo que crear? 00:47:54
Para crear un alumno, primer paso que tengo que hacer, 00:48:05
tendré que crear un objeto alumno, usando su constructor. 00:48:09
Primer paso, tendré como alumno que crear una. 00:48:16
Para crear un alumno, como primer paso, tendré que crear una. 00:48:25
Estoy creando objetos, creo clases. 00:48:37
yo soy un objeto, la clase ya está hecha 00:48:39
está allí 00:48:42
voy a crear un objeto alumno 00:48:42
para que un alumno 00:48:46
exista 00:48:48
primero tendré que definirlo 00:48:49
como persona 00:48:52
entonces el primer paso 00:48:53
que hago es crear una persona 00:48:57
y luego a esta persona le añado 00:48:59
lo que es un alumno 00:49:02
pero un alumno no es nada 00:49:03
sin persona, no puedo crear 00:49:05
un alumno sin una persona 00:49:07
¿por qué? 00:49:09
Porque el alumno extiende a la persona. 00:49:10
¿Cómo puedo extender algo si no tengo este algo? 00:49:15
¿Entiendes el concepto? 00:49:18
Entonces, cuando yo tengo un... 00:49:20
Segundo. 00:49:22
Cuando yo tengo un constructor de alumno, 00:49:23
la primera cosa que hace el alumno 00:49:26
es llamar el constructor de la superclase 00:49:28
sin parámetros. 00:49:32
Es decir, 00:49:35
este señor pasó uno para crear un alumno. 00:49:37
Crea una persona. 00:49:46
La persona se creaba, una vez creada la persona, ahora hace otras cosas, que en este caso concreto 00:49:48
es nada, porque estoy creando el alumno más básico de todo, el alumno anónimo. 00:49:57
¿Sí? 00:50:06
¿Había una duda? 00:50:07
Entonces, en automático todas las subclases van creando superclases, que es un superclásico 00:50:08
automático, por eso que... 00:50:17
y automático. 00:50:20
Ahora llegaremos a eso. 00:50:22
Pero sí. O sea, tú, 00:50:24
cuando creas un 00:50:26
constructor, tienes que 00:50:27
asegurarte que has creado 00:50:29
un objeto de la 00:50:32
superclase. 00:50:34
Ah, vale. Por eso, pero nosotros como no lo hemos 00:50:34
visto. No lo habéis visto, pero lo habéis visto. 00:50:36
Ya no lo has visto. O sea, no lo habéis visto, malo está. 00:50:39
Es así. 00:50:41
Ahora llegamos a eso también. 00:50:43
Ahora, otra opción. 00:50:45
Sobrecargo alumno. ¿Vale? 00:50:47
Creo un alumno sabiendo que es una persona, pero no sé sus datos de alumnos. 00:50:49
Paso atrás. 00:50:56
Aquí creo una persona sabiendo sus datos de persona. 00:50:58
Aquí creo una persona sin saber sus datos de persona. 00:51:02
Creo el objeto anónimo. 00:51:06
¿Me entiende? 00:51:09
Yo podría borrar esto. 00:51:10
Y entonces no puedo crear un objeto anónimo. 00:51:13
No puedo crear una persona anónima. 00:51:15
¿Se entiende? 00:51:18
Cada vez que creo una persona, tiene que tener su nombre, apellido y alineación. 00:51:19
Eso lo tengo que poner, porque no hay una opción para ponerlo. 00:51:23
Si en vez lo dejo así, sí hay una opción. 00:51:28
Estoy dando las dos opciones. 00:51:31
Puedes crear una persona cuando sabes todo de ella, 00:51:32
o puedes crear una persona cuando no sabes nada de ella. 00:51:36
Creas esa y luego ya veremos cómo la gestionamos. 00:51:40
Tened en cuenta que ahora yo no tengo la posibilidad de crear una persona 00:51:45
de la que solo sé el nombre. 00:51:48
¿Qué se llama, Stefano? 00:51:52
Ahí persona, le paso Stefano y me crea un objeto. 00:51:53
No hay un constructor persona, solo string nombre. 00:51:59
¿Lo veis o no? 00:52:04
¿Entienden o no? 00:52:05
Aquí yo estoy proporcionando dos formas de crear personas. 00:52:07
O personas de la que no sé nada, o personas de la que sé todo. 00:52:11
Eso no implica que yo aquí podría poner anónimo, anónimo, cero. 00:52:15
¿Sí? 00:52:22
pero o le doy un parámetro 00:52:22
o le doy cero parámetros o le doy tres parámetros 00:52:25
no existe crear una persona 00:52:27
con un parámetro solo 00:52:29
puedo hacerlo, sí, puedo sobrecargar 00:52:30
este, poner public persona 00:52:33
le string nombre, lo que hace es 00:52:35
al nombre le pone nombre y el resto le pone 00:52:37
cero y cero, que sí 00:52:39
null y cero 00:52:40
¿se entiende? 00:52:42
pero ahora mismo tengo solo estos dos metros 00:52:45
bueno 00:52:47
cuando quiero crear el alumno 00:52:48
sin nada, lo que estoy haciendo 00:52:51
es llamar el constructor 00:52:53
de la superclase 00:52:55
con nada. 00:52:57
O sea, que el nombre 00:53:00
de este alumno, ¿cuál será? 00:53:01
Anónimo. 00:53:04
Porque lo que hará es, 00:53:07
vale, para crear el alumno tengo antes 00:53:09
que crear una persona. ¿Cómo creo la persona? 00:53:11
Usando esto. Su nombre es anónimo. 00:53:13
Acabado el constructor de persona, 00:53:15
voy a hacer lo que más 00:53:17
hace la parte de alumno, que es 00:53:19
en este caso, nada. He creado un alumno que tendrá nombre anónimo, apellido nul, año 00:53:21
de nacimiento cero, grupo nul y horario, no sé qué echar, echar vacío. ¿Entendéis? 00:53:28
Un alumno mock, un alumno que no es real. Vale. Segunda opción. Tengo el alumno al 00:53:39
que le doy nombre, apellido, año de nacimiento. O sea, solo los datos que no vienen aquí. 00:53:47
O sea, un alumno del que sé sus datos de persona, pero todavía no sé sus datos de alumno. 00:53:52
¿Lo veis? 00:53:58
Pues entonces aquí llamo alumno, nombre, apellido, al nacimiento. 00:54:00
Lo que hago es llamar el superconstructor, o sea, el constructor de la persona, con nombre, apellido y al nacimiento. 00:54:05
Ahora estoy llamando este constructor, no este. 00:54:15
¿Se entiende? 00:54:23
Por lo tanto, la parte, digamos, núcleo de la persona, la parte persona, que está aquí, ¿vale? 00:54:23
Se creará con su nombre, su apellido y su año de nacimiento. 00:54:35
Y a partir de allí, ¿qué hago? Nada. 00:54:42
¿Vale? Entonces tengo dos formas por ahora de crear un alumno. 00:54:45
El alumno del que no sé nada y el alumno que solo sé sus datos de persona, 00:54:49
pero no los datos propios del alumno. Y luego tengo un tercer constructor que me pilla nombre, 00:54:54
apellido, nacimiento, el grupo y el horario. Entonces, ¿cómo lo creo? Llamando el 00:55:01
superconstructor que me construye la parte de persona con los datos que le he pasado. 00:55:08
Y una vez que ha creado la parte interna, la parte de persona, sigo añadiendo que, 00:55:16
llamando este método que es pon-grupo, que se va a saber qué hace pon-grupo, pues sustancialmente 00:55:26
asigna a grupo, grupo, horario, horario, haciendo una comprobación. 00:55:30
Entonces yo tengo tres modos de crear un alumno. 00:55:34
El alumno del que no sé nada, el alumno del que sólo sé que es una persona y los alumnos 00:55:40
del que sé todo. 00:55:44
¿Verdad? 00:55:45
Y luego tengo el primer grupo, que es un método propio de alumno. 00:55:48
Entonces, ¿qué es este super? 00:55:58
Super es una llamada al super constructor, al constructor de la clase super, ¿vale? 00:55:59
Con los parámetros necesarios para elegir cuáles de los constructores de la clase superior voy a utilizar. 00:56:09
Ahora, vosotros nunca lo habéis puesto. 00:56:18
¿Habéis puesto alguna vez super? No. Pero hemos dicho que vuestra clase hereda el object. 00:56:22
Entonces, cuando vosotros habéis creado la clase animal, habéis creado la clase animal, la clase cafetera. 00:56:31
Cuando vosotros habéis creado la clase cafetera, ¿qué ha hecho para crear una cafetera, para crear un objeto cafetera? ¿Qué se ha hecho? 00:56:39
Primero, crear un objeto object, y luego sobre el objeto object creado se ha creado la cafetera, 00:56:47
porque cafetera hereda de object, pero vosotros no os lo habéis dicho. 00:56:55
¿Por qué? Porque por defecto, si vosotros no ponéis nada, si no se pone nada, 00:57:00
la primera línea de un constructor es esta, que esta línea de aquí se puede quitar 00:57:13
y se llama igualmente 00:57:22
no obstante no esté. 00:57:24
Pero cuidado. 00:57:27
Llama super así. 00:57:28
¿Os acordáis que 00:57:31
cada objeto 00:57:32
tenía un constructor por defecto? 00:57:34
Era el constructor sin parámetros. 00:57:37
Si yo en la clase 00:57:40
superclase 00:57:41
le quito el constructor por defecto 00:57:42
¿vale? 00:57:45
Y luego heredo 00:57:46
y no pongo esta línea aquí 00:57:48
él por defecto llamará 00:57:50
super constructor por defecto 00:57:52
y entonces no funcionará 00:57:55
esto no lo hace 00:57:56
entonces cuidado 00:57:57
esto que se ponga o no se ponga 00:58:00
siempre se ejecutará y es siempre la 00:58:03
primera línea del 00:58:06
constructor, la primera 00:58:08
línea del constructor es una llamada 00:58:09
a la super clase para que construya 00:58:12
la parte digamos el core 00:58:15
el núcleo de mi objeto, luego ya lo 00:58:18
extendo con mis cosas 00:58:20
la primera cosa que hago 00:58:21
es construir un objeto 00:58:24
una vez que tengo un objeto pues le añado las cosas de cafetera 00:58:25
pero no tengo que construir el objeto 00:58:29
si no le he dicho nada, crearé un objeto 00:58:30
sin nada 00:58:32
con el constructor por defecto de orden 00:58:34
si yo creo una persona 00:58:36
si yo creo un alumno por ejemplo 00:58:38
volviendo aquí 00:58:41
cuando yo creo el alumno 00:58:43
el alumno dirá 00:58:47
vale, muy bien, voy a crear 00:58:52
voy a llamar 00:58:54
el constructor de persona, entonces irá a este constructor de aquí. 00:58:56
¿Qué hará aquí el constructor de persona? 00:59:02
¿Cuál es la primera línea del constructor de persona? 00:59:06
Super, paréntesis, paréntesis, hasta si no está escrito. 00:59:13
La primera cosa que hará para construir una persona es irse a Object, 00:59:18
crear un objeto Object, a esto extenderlo con las propiedades de persona, 00:59:23
y a este punto habré hecho la parte gris, y a este punto volveré aquí y la extenderé con la parte que tengo que extenderla aquí abajo. 00:59:27
En este caso aquí, por ejemplo, añadiendole la grupo de horario. 00:59:37
¿Tiene? 00:59:44
¿Duda? 00:59:46
No. 00:59:47
Bueno. 00:59:49
Prueba... 00:59:55
Llego hasta aquí, dos transparencias y luego dejamos el ejercicio, ¿vale? 00:59:56
prueba esta clase prueba vale entonces su main donde crea una persona y un 01:00:00
alumno cuando crea una persona pues new persona pues con sus datos cuando crea 01:00:08
un alumno pues tengo sus datos también vale tened cuenta que a un alumno yo 01:00:15
puedo llamarle pongrupo os acordáis este método de aquí este método de aquí pongrupo 01:00:21
es público. Si tú creas 01:00:31
un objeto que ya sabe 01:00:34
su grupo de horario, él lo hace 01:00:35
directamente allí. Pero tú puedes crear 01:00:38
un objeto sin su grupo de horario 01:00:40
usando este constructor de aquí 01:00:42
y luego después llamar a este 01:00:43
método para asignarlo a un grupo 01:00:46
de un horario. ¿Sí? 01:00:47
Que es lo que se hace aquí. 01:00:49
Se crea un alumno solo con 01:00:51
sus datos de persona 01:00:54
¿Vale? Y después 01:00:55
se hace un grupo. 01:00:57
Ahora, si yo estos dos 01:00:59
lo hubiese puesto aquí al final, 01:01:03
pues habría hecho lo mismo. 01:01:05
¿Sí? Vale. 01:01:08
Y luego llamamos vecino.imprime, 01:01:10
un alumno.imprime, un alumno.imprime 01:01:12
grupo, ¿vale? 01:01:14
Esto de aquí 01:01:15
escribe datos personales, Luisa, 01:01:16
bla, bla, bla, bla, bla. 01:01:19
Este de aquí es imprime, 01:01:21
es un método derivante de persona. 01:01:23
Por lo tanto, escribe lo mismo de persona. 01:01:26
Este es como si fuera una persona. 01:01:27
Y luego, después, imprimo el grupo y me imprime. 01:01:29
¿Podría hacer vecina.imprimeGrupo? 01:01:33
No, porque la vecina no es un alumno. 01:01:36
E imprimeGrupo es solo el alumno. 01:01:41
Sin embargo, imprime es en persona. 01:01:45
Por lo tanto, lo puede llamar tanto el alumno como la persona. 01:01:50
¿Sí o no? 01:01:56
¿Vale? 01:01:59
¿Qué pasaría si el atributo nombre 01:02:00
fuera declarado private. O sea, si yo me meto aquí y este nombre, en vez que protecte, te lo pongo 01:02:04
como private. ¿Quién puede acceder a este nombre? Solo persona. ¿Puede acceder a la clase que 01:02:14
extiende? Me sirve. Ahora, si yo aquí, en vez de poner super nombre bla bla bla bla, podría poner 01:02:26
Dis.nombre es igual a nombre. Dis.apellido es igual a apellido. Dis.años de nacimiento es igual a años de nacimiento. 01:02:50
Lo podría poner. ¿Por qué no? El alumno tiene Dis.nombre. Sí, porque lo hereda. 01:02:58
Pero si yo lo pusiera así y luego pongo nombre privado, ¿lo podría hacer? No. 01:03:13
¿Y con súper lo podría hacer? Sí. Me explico mejor. 01:03:20
Imaginámonos que yo, en alumno, tenga esta cosa aquí. 01:03:25
Me da nombre, apellido y anonacimiento, y hago dispunto nombre, nombre, dispunto apellido, apellido, dispunto anonacimiento, anonacimiento. 01:03:30
¿Lo puedo hacer? Sí, en alumno. 01:03:38
¿Por qué? Porque como heredo, como extendo persona, yo puedo acceder a dispunto nombre. 01:03:41
Es un atributo mío también. 01:03:48
Yo tengo todo lo que tiene la persona. 01:03:50
y la otra opción es lo que hemos hecho aquí con el súper estos dos hacen lo mismo ahora qué pasa 01:03:52
que si yo en persona le pongo private al nombre cuando intento acceder a this punto nombre esto 01:04:01
me dice no puedes es private sólo se puede usar desde persona es verdad que tú eres una persona 01:04:10
Pero no eres la clase persona, eres la clase alumno. 01:04:17
Y esto es accesible solo interno a la clase persona. 01:04:21
Esto no me permitiría crear una persona con el nombre. 01:04:24
Sin embargo, esto, sí. ¿Por qué? 01:04:30
Y el constructor es. 01:04:36
El constructor sí se puede llamar desde fuera. 01:04:38
Hasta si este de aquí es tuyo. 01:04:47
¿Sí? 01:04:50
Por eso, esto contesta la pregunta 01:04:51
que claramente vosotros estaréis haciendo en vuestra cabeza de ¿por qué tengo que llamar 01:04:55
super cuando puedo hacerla así? Esto aquí no funciona porque al intentar acceder al 01:04:59
dis.nombre sale el error el field persona.nombre no es visible porque es privado. Sin embargo, 01:05:07
si haces así, sí funciona porque no accedo directamente al campo privado sino llamo al 01:05:16
constructo de la superclase. ¿Sí? Entonces ahora vamos a hacer un ejercitito, ¿vale? 01:05:20
Que es esto, es decir, tengo una clase dispositivo, tengo una clase móvil y una clase ordenador, 01:05:29
pues lo que quiero hacer es construirme tres clases, aquí hay tres clases, una que será 01:05:38
genérico de un dispositivo, una que será en particular un móvil que es un dispositivo 01:05:45
y uno que está en un ordenador, ¿qué es un dispositivo? 01:05:50
¿Sí? 01:05:54
A lo mejor un pequeño main 01:05:54
para crear un dispositivo, 01:05:56
un ordenador y un móvil 01:05:58
y trabajar un poquito con ellos. 01:06:00
¿Vale? Entonces, 01:06:02
tenéis 10 minutos para hacerlo, 01:06:04
luego recreo y después 01:06:09
de recreo lo rehacemos 01:06:11
juntos. ¿Vale? A ver si os habéis 01:06:13
bloqueado en algún lado 01:06:15
o no lo habéis podido hacer o 01:06:17
sabéis... 01:06:18
¿Vale? 01:06:20
Gracias. 01:06:21
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
12 de enero de 2026 - 11:55
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 06′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
557.56 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid