Saltar navegación

Herencia 3 - 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 5 de febrero de 2024 por Stefano C.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos grabando, por lo tanto si habláis me estáis dando la autorización a que se os grabe, ¿vale? 00:00:00
Entonces, la última vez estuvimos hablando un poco de herencia, ¿vale? 00:00:09
La herencia es un mecanismo que es propio de la programación orientada a objetos, o sea que cuando hay programación orientada a objetos hay herencia. 00:00:14
Todos los lenguajes que trabajan con esto pues incluyen la herencia, que sirve sustancialmente para organizar mejor el código y para reutilizar código en distintos proyectos o en el mismo proyecto, ¿vale? 00:00:24
Sale de dos ideas que son la misma pero vistas desde dos perspectivas distintas, que son una es tengo una clase ya hecha y la quiero especializar, 00:00:39
o sea quiero añadir algo más a esta cosa. 00:00:52
Pero digamos que el esquema principal de esta clase me vale, que por lo tanto la quiero reutilizar, entonces estaremos en un nivel de espacialización. 00:00:54
Tengo la clase vehículo, que me modeliza un cualquier vehículo y ahora necesito trabajar con coches. 00:01:04
Entonces especializo la clase vehículo con algo más que solo los coches tienen. 00:01:09
Todos los vehículos tendrán lo que está en vehículo, pero coche tiene algo más que tienen solo los coches. 00:01:16
Y bicicleta otra cosa distinta de coche. 00:01:21
Tiene solo la bicicleta y avión tiene algo, etcétera, etcétera, ¿sí? 00:01:24
La otra opción es a nivel de generalización, o sea si tengo muchas clases en mi proyecto que veo que tienen una parte compartida, 00:01:31
tienen métodos que son la misma implementación y que se repiten en varias clases, a un cierto momento puedo decir, 00:01:40
oye mira, toda esta parte común la saco de las clases pequeñas y la pongo en una clase, 00:01:45
la saco de las clases pequeñas y la pongo en una clase, la saco de las clases pequeñas y la pongo en una clase, 00:01:53
la saco de las clases pequeñas y la pongo en una clase, 00:01:54
que será una superclase, y esta superclase luego se heredará en todas las clases anteriores. 00:01:54
De esta forma centralizo en una única clase todos estos métodos que antes, o variables que antes se repetían en muchos sitios. 00:02:00
De esta forma si lo hago mañana, tengo que mejorarlo, tengo que cambiar, tengo que modificar, encuentro un error, 00:02:08
pues tengo una sola clase que modificar y no copiar esta modifica en 37 clases distintas, ¿vale? 00:02:14
Son muy parecidas las dos cosas. 00:02:21
Pero vistas desde dos perspectivas distintas, ¿sí? 00:02:24
Entonces este era un ejemplo en el que aquí había tres clases donde la parte en azul se repetía en las tres clases, 00:02:27
pues entonces la idea es utilizar la clase recursos como superclase, heredarla en aula y ordenador, 00:02:36
y aula y ordenador solo especifican lo que es propio de aula y de ordenador, ¿vale? 00:02:43
Para hacer esto está la palabra extends, ¿vale? 00:02:49
Una palabra reservada. 00:02:52
Una palabra reservada. 00:02:53
Que permite extender recurso con una nueva clase. 00:02:54
Bla, bla, bla, modificadores, ¿vale? 00:02:58
Entonces esto por ejemplo para declarar una estructura como esta, donde está persona, empleado, alumno y profesor, 00:03:04
pues la clase persona es esta de aquí, no tiene nada, la clase alumno extende persona, la clase empleado extende persona, 00:03:14
la clase profesor extende empleado, ¿vale? 00:03:24
Entonces, acordaos que esta relación, esta relación de herencia es una relación de es, ¿vale? 00:03:28
Es decir que un alumno es una persona, un profesor es un empleado, un empleado es una persona, un profesor es una persona. 00:03:38
Es decir que donde yo necesite un objeto superclase, 00:03:48
puedo poner un objeto subclase, ¿si? 00:03:54
Si yo tengo un método que pilla un empleado, puedo utilizar un objeto empleado o puedo utilizar un objeto profesor, 00:04:00
porque profesor es un empleado, tiene todo lo que necesita un empleado. 00:04:07
Este método dentro utilizará variables y cosas propias de empleado, que seguramente profesor tiene, 00:04:11
que muy probablemente profesor tiene, ¿si? 00:04:18
¿Dudas? 00:04:22
Sigo, ¿vale? 00:04:24
Esta es un poquito la idea interna del, de la subclase donde está la parte que hereda y la parte nueva, ¿vale? 00:04:25
Tened en cuenta que no son dos objetos, es siempre un solo objeto, ¿vale? 00:04:34
Este objeto está con una parte anterior que representa prácticamente un objeto de tipo persona, 00:04:38
exteso con la parte que es propia de alumno, ¿si? 00:04:44
La idea es que si yo ahora uso un método que en vez de pedir un objeto alumno, 00:04:49
pide un objeto persona, yo aquí de todas formas tengo toda la información de una persona, 00:04:53
entonces lo puedo usar tranquilamente, no tengo problemas. 00:05:00
Al revés, no, allá donde va una persona no puedo utilizar un alumno, 00:05:03
porque un alumno, perdón, allá donde va un alumno no puedo utilizar una persona. 00:05:07
Si yo tengo un método que quiere un alumno y que entonces puede utilizar estos parámetros aquí abajo, 00:05:12
y tú me pasas una persona, o sea, solo esto, 00:05:18
pues solo esto no tiene estos parámetros, entonces no se puede usar. 00:05:21
Bla, bla, bla. 00:05:26
Hemos visto el constructor super, ¿vale? 00:05:28
Constructor super hace referencia al constructor de la superclase, 00:05:32
y es que cuando, ahora, hoy lo veremos con más detalle, 00:05:35
pero cuando yo creo un objeto de una subclase, 00:05:39
la primera línea del constructor de la subclase tiene que ser una llamada super. 00:05:42
O sea, construye un objeto de la clase super, 00:05:46
y a partir de allí lo extendes con las cosas nuevas. 00:05:50
Si no lo pongo, si no pongo ninguna llamada super, 00:05:55
se asume que por defecto se llame un super así, sin parámetros. 00:05:59
Y eso implica que si el padre, si la superclase no tiene el constructor sin parámetros, 00:06:03
esto me dará error. 00:06:10
Entonces el super es el paso para que entiende el ordenador de coger, 00:06:13
si tengo una superclase y una subclase, 00:06:17
cuando yo ponga el super, le estoy dando a entender al ordenador 00:06:19
que coja lo de la superclase y lo ponga en la subclase. 00:06:24
Eso se lo estás diciendo aquí. 00:06:28
O sea, la relación entre alumno y persona se lo estás diciendo 00:06:31
cuando dices que alumno extende persona, ¿vale? 00:06:36
El super es la llamada al constructor de arriba. 00:06:39
Si tú tienes alumno y persona, para crear un alumno, 00:06:44
tendrás antes que crear una persona. 00:06:48
Y sobre esta persona extender, ¿vale? 00:06:51
Esta llamada a decir, oye, mira, antes de crear un alumno, 00:06:54
crea una persona, es este super. 00:06:57
¿Sí? 00:06:59
Entonces, tú puedes no usarlo. 00:07:01
Yo puedo quitar todos los constructores aquí 00:07:03
y se me quedaría solo el constructor por defecto. 00:07:08
No he usado super por ningún lado. 00:07:10
Por defecto él sabe que como esto extende persona, 00:07:12
cuando tú me crearás un alumno sin parámetros, 00:07:16
voy a llamar super sin parámetros, crearé una persona sin parámetros 00:07:19
y una vez que tengo esta persona, pues la extenderé con alumno. 00:07:23
¿Sí? 00:07:27
Si en vez lo quieres usar explícitamente, 00:07:28
tiene que ser la primera línea de un constructor 00:07:30
y puedes llamar super sin parámetros o super con parámetros. 00:07:34
Esto llamará el constructor de la superclase que corresponde a esos parámetros. 00:07:38
¿Sí? 00:07:43
Vale. 00:07:44
Vale. 00:07:45
Esto es todo el repaso, ¿eh? 00:07:47
Prueba, vimos esta cosa aquí que es reciente interesante 00:07:49
sobre los conceptos de los modificadores. 00:07:56
¿Vale? 00:08:02
Si no, nosotros antes persona era protete, protete, protete, 00:08:03
o public, me da igual. 00:08:07
En el momento en que pongo privado nombre, ¿vale? 00:08:09
Este nombre solo es accesible desde dentro persona. 00:08:13
Tampoco, hasta si al alumno extende persona, 00:08:17
alumno no puede acceder a esta variable. 00:08:23
¿Sí? 00:08:26
Porque cuando es privado es solo de la clase, 00:08:28
solo interna esta clase. 00:08:32
Para poderlo acceder desde una clase que hereda, 00:08:34
lo debería poner protete. 00:08:36
¿Vale? 00:08:38
Os recuerdo que hay cuatro niveles de visibilidad, 00:08:39
de accesibilidad, que son public, 00:08:41
que pueden acceder quien quiera. 00:08:44
Package, que pueden acceder todas las clases 00:08:47
que pertenecen al mismo package, al mismo paquete. 00:08:52
Protected, que pueden acceder todas las del mismo paquete 00:08:55
y todas las clases que hereden de esta clase, 00:09:01
aún si no están en el paquete. 00:09:05
¿Vale? 00:09:08
Y finalmente private. 00:09:09
Que es solo esta clase puede hacer. 00:09:10
Entonces, si pongo private aquí, 00:09:13
no puedo hacer una cosa así. 00:09:15
Esto no funcionaría. 00:09:18
Este es un constructor de alumno, 00:09:22
que pilla nombre, apellido, nacimiento. 00:09:24
Apellido y nacimiento que no están declarados en alumno, 00:09:27
están declarados en persona. 00:09:31
Pero son accesibles sin problemas. 00:09:33
Pero esto dis.nombre no podría hacerlo. 00:09:35
Porque dis.nombre no es accesible. 00:09:38
Porque dis.nombre es accesible solo desde dentro de persona. 00:09:39
Y aquí no estoy en persona, estoy en alumno. 00:09:44
¿Sí? 00:09:47
Esto no quita que pueda hacer esta cosa de aquí. 00:09:49
Llamar el constructor de persona que yo extendo 00:09:56
con nombre, apellido y nacimiento funcionaría 00:10:02
porque en este caso no soy yo que modifico el dis.nombre. 00:10:05
Es un método que pertenece a persona. 00:10:09
El que está tocando, está cambiando el nombre. 00:10:13
Entonces esto funcionaría. 00:10:17
Esto se entiende porque no funciona. 00:10:24
No puedo acceder al nombre. 00:10:26
Dis.nombre es privado. 00:10:28
Es propio de persona. 00:10:30
Si persona puede hacer lo que le da la gana, 00:10:32
todos los métodos de persona pueden toquetear esto, 00:10:34
fuera de la clase persona, 00:10:37
como estoy aquí porque estoy en la clase alumno, 00:10:38
pues no puedo tocar esto. 00:10:40
Por lo tanto esto, al haber puesto nombre privado, 00:10:42
se me bloquea. 00:10:45
O cuidado que si pongo nombre protected ya lo puedo hacer. 00:10:46
Sin ningún problema. 00:10:49
Pero ahora es privado. 00:10:50
No puedo. 00:10:51
Entonces, ¿cómo podría crear un objeto persona entre comillas 00:10:52
para luego crear el objeto alumno? 00:10:56
O una cosa de ese estilo. 00:10:58
Creo un alumno que tiene nombre, apellido y nacimiento. 00:11:00
¿Cómo sé que mi nombre es ese de allí? 00:11:03
Desde alumno no lo puedo modificar. 00:11:06
Pues entonces, llamo el constructor de la superclase. 00:11:09
Llamar al constructor de la superclase está diciendo 00:11:13
que voy a utilizar para modificar este nombre, 00:11:16
no la clase alumno, sino algo propio de la clase persona. 00:11:19
Yo entro en la clase persona, en el constructor de la clase persona, 00:11:24
y le paso estos tres parámetros, 00:11:29
y será el constructor de la clase persona, 00:11:31
si os acordáis que era así. 00:11:33
Este constructor de aquí, 00:11:36
aquí dentro yo estoy usando este constructor pasándole nombre, 00:11:43
y él hace dis.nombres igual a nombre. 00:11:47
Está haciendo lo mismo que hemos visto al otro lado, 00:11:50
pero al otro lado lo estaba haciendo desde alumno. 00:11:52
Y aquí lo estoy haciendo desde dentro persona. 00:11:55
Y por lo tanto sí tiene acceso a este de aquí, 00:11:57
hasta si esto fuera privado. 00:12:01
¿Sí? 00:12:03
Vale. 00:12:06
Este es el ejercicio que hicimos la última vez. 00:12:08
¿Vale? 00:12:11
Te creamos un dispositivo, luego un móvil, un ordenador, 00:12:12
y lo extendimos y hicimos alguna prueba con ellas. 00:12:14
¿Vale? 00:12:18
Y desde aquí es cosa nueva. 00:12:19
Entonces, la idea de la herencia, 00:12:24
este mecanismo que estamos viendo ahora, 00:12:28
crea una jerarquía. 00:12:31
¿Vale? 00:12:34
Es decir, que persona, 00:12:35
o persona tiene dentro empleado alumno, 00:12:38
empleado tiene dentro profesor, 00:12:41
alumno tiene dentro qué sé yo, otra cosa, 00:12:43
pues se va creando una jerarquía 00:12:46
en el que como nodo principal, como nodo inicial, 00:12:49
está el que está más arriba, 00:12:53
y desde allí cuelgan los hijos creando un árbol. 00:12:55
¿Vale? 00:12:59
Y una jerarquía que va especificando cuanto más abajo, 00:13:00
más eso hay específico, 00:13:03
más estoy extendiendo lo que está arriba. 00:13:05
Antes tengo un concepto más general, 00:13:08
lo extiendo con cosas más particulares, 00:13:10
lo extiendo con cosas más particulares, etc. 00:13:12
¿Vale? 00:13:14
Teniendo en cuenta que una clase en Java puede 00:13:18
o heredar específicamente de otra clase, 00:13:21
que es lo que estamos viendo ahora, 00:13:23
extends persona, ¿vale? 00:13:25
Si no le digo nada, 00:13:27
todas las clases que habéis hecho vosotros desde el día uno, 00:13:29
¿vale? 00:13:32
Esto es un public class algo, 00:13:33
en automático, por defecto, 00:13:35
hereda desde la clase object. 00:13:37
¿Vale? 00:13:41
Existe una clase especial object, 00:13:42
definida en el núcleo de Java, 00:13:46
o sea que existe allí y que define un objeto en general, 00:13:48
y todas las clases que vosotros creáis, 00:13:51
por defecto, heredan de object. 00:13:54
O sea que object es la raíz de este árbol de herencia. 00:13:56
Siempre. 00:14:01
Todos los objetos, todas las clases que haréis en Java. 00:14:02
Lo que puedo hacer es que yo puedo crear, 00:14:05
qué sé yo, alumno, ¿vale? 00:14:08
Y alumno hereda de persona, 00:14:10
pero persona, como no le he dicho que extiende nada, 00:14:12
por defecto extiende object. 00:14:14
¿Habéis usado alguna vez 00:14:18
system.out.println 00:14:20
y habéis puesto un objeto allí? 00:14:23
¿Qué os sale? 00:14:26
Os sale el tipo, 00:14:30
arroba, dirección de memoria. 00:14:32
¿Y por qué? 00:14:34
System.out.println que pilla como parámetro. 00:14:39
¿Qué es system.out? 00:14:46
Es un print stream. 00:14:51
Vamos a ver en la API 00:14:54
qué es un print stream. 00:14:57
Print stream, bla bla bla, cosas guay, tiene un metodito. 00:15:00
Que es println. 00:15:06
¿Sí? 00:15:09
Es el que usáis vosotros. 00:15:10
¿Sí? 00:15:12
¿Qué pilla como parámetro el println? 00:15:14
Puede pillar nada, un booleano, un char, un array de char, 00:15:18
puede pillar un float, puede pillar un int, puede pillar un long, 00:15:23
puede pillar un object. 00:15:26
Puede pillar un string. 00:15:28
Vosotros normalmente usáis esto. 00:15:31
Ahora, ¿cuándo se pilla un object? 00:15:34
¿Vosotros habéis pasado nunca un object? 00:15:37
No. 00:15:40
¿Vosotros habéis pasado lo que vosotros habéis creado? 00:15:42
¿Habéis creado coche? 00:15:44
¿Habéis pasado coche? 00:15:46
¿Cómo se me explica? 00:15:48
Nunca habéis hecho vosotros un cast explicit object. 00:15:50
Hasta hoy vosotros ni siquiera sabíais que existía un object. 00:15:52
¿Y por qué entonces esto funciona? 00:15:55
Porque hereda. 00:15:57
Porque hereda. 00:15:59
Y cualquier cosa que hayáis creado vosotros, 00:16:00
vuestra clase, vuestro coche, vuestro animal, 00:16:03
heredaba de object. 00:16:07
Es un object. 00:16:09
¿Sí? 00:16:11
Y por lo tanto se puede poner aquí. 00:16:12
¿Y qué hará este señor de aquí? 00:16:14
Pues este señor de aquí transforma, 00:16:16
como lo que quiere hacer es imprimir en pantalla algo textual, 00:16:20
y tú me estás dando un objeto. 00:16:25
Un objeto no se puede imprimir, 00:16:26
porque un objeto es una serie de unos y ceros. 00:16:28
Pues en la clase object, 00:16:30
está un señor, 00:16:33
que es... 00:16:35
¿Dónde está? 00:16:37
El toString. 00:16:39
Este metodito de aquí, 00:16:41
lo que hace es traducir el objeto 00:16:43
en una representación string del objeto mismo. 00:16:47
¿Vale? 00:16:52
El defecto es mi tipo arroba la posición de memoria, 00:16:54
más o menos no es la posición de memoria, 00:16:57
pero algo parecido. 00:16:58
¿Sí? 00:17:00
Lo que quiero decir con esto, 00:17:01
es que si vosotros no implementáis nada, 00:17:02
y creáis la clase gato, 00:17:07
la clase gato hereda de object, 00:17:10
y entonces importa este método de aquí. 00:17:13
Tiene este método de aquí. 00:17:17
Y cuando vosotros hacéis . 00:17:19
System.out.println, 00:17:21
de un objeto de tipo gato, 00:17:23
como el objeto de tipo gato, 00:17:25
no tiene un toString propio, 00:17:27
sino usa el toString de object, 00:17:29
o sale gato arroba numerito. 00:17:32
¿Se entiende? 00:17:36
Ahora, ¿qué pasa cuando yo, 00:17:38
dentro de gato, 00:17:40
sobreescribo este método? 00:17:42
Y me creo un toString dentro de la clase gato. 00:17:44
Que cuando uso el .println, 00:17:48
el me va a intentar usar esto, 00:17:52
pero se da cuenta que mi objeto 00:17:55
es un objecto y tiene esto. 00:17:58
Pero más específicamente es un gato, 00:18:00
y tiene el toString de gato. 00:18:03
Entonces me usa el toString más específico. 00:18:05
Y entonces me sale lo que yo le he dicho. 00:18:09
Esta cosa de aquí, 00:18:12
la veremos más adelante. 00:18:14
¿Por qué está funcionando así? 00:18:16
Pero es como funciona ya. 00:18:18
Esto ya lo hemos experimentado. 00:18:20
No sabemos por qué, 00:18:22
todavía no lo sabemos, 00:18:24
pero lo podemos medianamente intuir. 00:18:26
Pero todo esto está basado en la herencia, 00:18:29
en la sobreescriptura de métodos. 00:18:32
Cuidado que no es la sobrecarga de métodos, 00:18:35
es sobreescriptura, que ahora lo veremos. 00:18:38
Fijaos también que object por sí mismo 00:18:42
tiene varios métodos. 00:18:45
Estos métodos, 00:18:50
por ejemplo, 00:18:52
white, 00:18:53
notify all, 00:18:54
etcétera, 00:18:55
etcétera, 00:18:56
los veréis en segundo o en tercero 00:18:57
en DAM, 00:19:00
en programación de procesos y servicios. 00:19:02
Pues allí se ve que son estas cosas. 00:19:11
En segundo de DAO no lo sé, 00:19:13
si por algún lado veis algo de este tipo. 00:19:15
Y otras cosillas, 00:19:17
pues las veremos. 00:19:19
Equals, 00:19:20
igual se os suena de algo. 00:19:21
Fijaos que está definido a nivel de objeto, 00:19:23
de object. 00:19:26
Luego cada objeto pues sobreescribirá esto, 00:19:28
lo haremos, 00:19:30
antes o después. 00:19:31
Vale, 00:19:33
entonces sigo. 00:19:35
Entonces, 00:19:37
aquí tenemos esta herencia. 00:19:39
Acordaos que cualquier objeto que vosotros creáis, 00:19:41
pues tiene los métodos de object, 00:19:43
más todos los que están en su cadena, 00:19:45
digamos, 00:19:48
de las clases superiores. 00:19:49
El alumno tiene todo lo que está en alumno, 00:19:51
todo lo que está en persona, 00:19:53
y todo lo que está en object. 00:19:54
¿Sí? 00:19:56
Venga. 00:19:58
Constructores y herencias, 00:20:00
más o menos de esto hemos hablado. 00:20:01
Cuando creo un objeto, 00:20:03
primero se crea la parte base, 00:20:05
y luego se crea la parte derivada. 00:20:08
Es el discurso de cuando creo un alumno, 00:20:10
antes creo una persona, 00:20:12
y luego después creo la extensión de esta persona, 00:20:15
que es el alumno. 00:20:18
¿Correcto? 00:20:20
¿Hago algo más antes? 00:20:23
En realidad, 00:20:33
primero creo un objeto, 00:20:34
luego lo extendo con las cosas de persona, 00:20:36
y luego lo extendo con las cosas de alumno. 00:20:39
Por el mismo principio. 00:20:42
¿Vale? 00:20:44
Como persona hereda de objeto, 00:20:45
lo que estoy creando al fin y al cabo 00:20:47
como primera parte, 00:20:49
como parte base, 00:20:50
es el objeto-object. 00:20:51
A él le añado lo que es persona, 00:20:53
con sus métodos, sus atributos, etc. 00:20:57
Y a eso le añado lo que es el alumno. 00:20:59
Y al final creo un objeto solo, 00:21:02
es como si fueran tres partes. 00:21:04
Cuidado que el objeto es único, 00:21:06
no he creado tres objetos. 00:21:08
He creado un objeto, 00:21:09
y luego lo he extendido 00:21:11
con las características de los otros objetos. 00:21:13
¿Sí? 00:21:15
Entonces, 00:21:16
si la clase base de objeto hereda a su vez, 00:21:18
pues en el paso uno se aplica la misma cosa, 00:21:21
pero hasta llegar a object. 00:21:24
¿Vale? 00:21:26
En el sentido de, 00:21:27
pillamos alumno que hereda a la persona. 00:21:28
¿Cómo se crea esto? 00:21:30
Pues el paso uno sería 00:21:31
que se crea la parte correspondiente a persona. 00:21:32
Porque alumno hereda de persona. 00:21:35
Pero, ¿y cómo se crea esto? 00:21:37
Pues esto se crea 00:21:39
reaplicando estos dos pasos a persona. 00:21:40
O sea, 00:21:43
que se crea la parte correspondiente a persona, 00:21:44
correspondiente a object, 00:21:46
porque persona hereda de object. 00:21:47
Entonces aquí he creado object. 00:21:49
Luego, 00:21:51
se añaden los elementos de personas, 00:21:52
y después he acabado el punto uno de alumno, 00:21:55
y entonces paso al punto dos de alumno, 00:21:58
que es, 00:22:01
añado la parte específica de alumno. 00:22:02
¿Se entiende? 00:22:06
Esta cosa de aquí, 00:22:07
es el super, 00:22:09
en un cierto sentido. 00:22:11
¿No puede ser que la publica alumnos 00:22:13
estén obviosos directamente? 00:22:15
Sí, pero no te sirve de nada. 00:22:18
Porque si no lo pones en automático, 00:22:20
estén desobviosos. 00:22:22
Si tú pones public class alumno, 00:22:25
estás haciendo public class alumno, 00:22:27
estén desobviosos. 00:22:29
Pero luego no es una persona. 00:22:31
Te ha saltado persona. 00:22:33
No tiene nombre ese alumno. 00:22:35
Pero si es que, 00:22:37
directamente hereda de objeto, 00:22:39
ya lo tengo declarado. 00:22:42
Pero objeto no tiene nombre. 00:22:44
Y tampoco alumno tiene nombre. 00:22:47
Claro, pero por ejemplo, 00:22:50
el profesor, 00:22:52
puedo poner public class profesor, 00:22:54
que estén personas directamente. 00:22:56
Claro. 00:22:58
Por ejemplo, empleado. 00:22:59
¿Por qué no? 00:23:00
Sí, pero probablemente empleado 00:23:01
tendrá algo más que no tiene persona. 00:23:03
Ahora, si te fijas en el escritorio 00:23:05
que te hicimos nosotros, 00:23:07
era aquí, ¿dónde está? 00:23:09
Esto. 00:23:14
Tú puedes decir que personas 00:23:15
prende directamente persona, 00:23:17
pero no tiene sueldo luego. 00:23:19
El profesor luego no tiene sueldo. 00:23:21
Porque el sueldo está en empleado. 00:23:23
Tú puedes hacer lo que quieras, 00:23:27
depende de cómo lo modelizas. 00:23:29
Si tú no te interesa esta cosa aquí, 00:23:31
puedes hacer que el profesor sea directamente una persona. 00:23:33
Aquí, pero la idea es de estructurar 00:23:35
de tal forma que todas las personas 00:23:37
tengan un nombre. 00:23:39
Entonces, tanto alumno como empleado 00:23:41
como profesor tendrán un nombre. 00:23:43
Pero alumno luego tiene las notas, 00:23:45
pero no tiene ni materias que imparte 00:23:47
ni un sueldo. 00:23:49
Sin embargo, todos los empleados sí tienen un sueldo. 00:23:51
Y esto incluirá, además de los profesores, 00:23:53
los conserjes, los profesionales 00:23:55
de la limpieza, qué sé yo. 00:23:57
Y en particular está el profesor. 00:23:59
El profesor que tendrá 00:24:01
una lista 00:24:03
de materias que imparte, 00:24:05
tendrá un sueldo porque le viene 00:24:07
de empleado y tendrá un nombre 00:24:09
porque le viene de persona. 00:24:11
Pero no tendrá una lista de notas. 00:24:13
¿Entiendes? 00:24:15
Vale. 00:24:19
Entonces, este es el procedimiento. 00:24:21
Esta primera parte, la 1, 00:24:23
sería, sustancialmente, el hacer un 00:24:25
súper, que se hace siempre. 00:24:27
Si vosotros no lo ponéis, 00:24:29
se hace un súper, 00:24:31
una llamada al constructor de la 00:24:33
superclase, lo que crea 00:24:35
la parte base de la clase sin 00:24:37
parámetros. 00:24:39
Se llama el constructor por defecto. 00:24:41
Es por esa razón que si vosotros 00:24:43
el constructor por defecto de una clase 00:24:45
os lo habéis cargado porque habéis creado 00:24:47
otro constructor con otros parámetros 00:24:49
y luego heredáis esa clase 00:24:51
sin poner un súper 00:24:53
explícitamente, pues os va a dar un error. 00:24:55
Lo hemos hecho la última vez. 00:24:57
Lo volveremos a hacer para 00:24:59
que veáis ese error. Son esos errores 00:25:01
de dónde viene si está todo escrito bien. 00:25:03
Pues no, falta algo. 00:25:05
¿Sí? 00:25:07
Vale. 00:25:09
Constructores y herencias. En el constructor 00:25:11
de la clase derivada se realiza siempre 00:25:13
una llamada al constructor de la clase base. 00:25:15
Esta es la primera acción del 00:25:17
constructor y 00:25:19
hay dos posibilidades. Indicarlo explícitamente, 00:25:21
entonces llama el súper sin nada, 00:25:23
o indicarlo explícitamente, entonces 00:25:25
tiene que estar obligatoriamente la primera línea. 00:25:27
No se puede hacer, hago algo 00:25:29
y luego súper. 00:25:31
La idea es que si vas a utilizar 00:25:33
súper, tiene que ser la primera línea de un 00:25:35
constructor. 00:25:37
¿Sí? Si no, 00:25:39
ya se ha hecho. 00:25:41
Si yo lo pongo 00:25:43
algo antes, pues él en automático 00:25:45
me ha hecho una llamada súper vacía 00:25:47
arriba. Entonces estás 00:25:49
llamando otra vez a otro constructor 00:25:51
y eso no se puede hacer. 00:25:53
Si no se indica explícitamente, 00:25:57
ya va a insertar totalmente la llamada súper. 00:25:59
O sea, aquí 00:26:01
habría una llamada súper 00:26:03
de este tipo, hasta 00:26:05
si yo no la he escrito. 00:26:07
¿Sí? 00:26:09
Si lo indico explícitamente, 00:26:13
en vez, la primera línea 00:26:15
es súper con el constructor 00:26:17
que yo quiero, que puede ser también súper sin nada. 00:26:19
No hace falta, porque 00:26:21
si quiero llamar súper sin nada, pues entonces 00:26:23
puedo no ponerlo directamente, lo hace él 00:26:25
de forma automática, pero si quiero ser explícito 00:26:27
puedo poner súper sin 00:26:29
parámetro. 00:26:31
¿Sí? 00:26:33
Persona. 00:26:35
Si no ponías 00:26:37
nada, te ponía el nombre que era anónimo. 00:26:39
Entonces, en el ejemplo anterior 00:26:41
... 00:26:43
Antes te haría un nombre anónimo 00:26:47
y luego le añadirías 00:26:49
el número que era anónimo. 00:26:51
Al crearte esto de aquí 00:26:53
habría puesto en el nombre 00:26:55
anónimo y luego al ejecutar 00:26:57
esto, cambia nombre 00:26:59
a esta cosa aquí. 00:27:01
Ahora, como ya lo 00:27:03
hace el otro, 00:27:05
esto está mal, 00:27:07
entre comillas, porque si le pasas nombre 00:27:09
pues probablemente aquí habrías 00:27:11
tenido que llamar esto. 00:27:13
¿Sí? Esto es más correcto 00:27:15
probablemente, porque si le pasas los mismos 00:27:17
parámetros que luego sirven al constructor 00:27:19
de arriba, pues esto es más elegante 00:27:21
que el otro. 00:27:23
Hay situaciones en las que 00:27:25
a lo mejor el constructor de alumno 00:27:27
no tiene algo que Persona sí tiene, 00:27:29
entonces tú ya creas 00:27:31
un objeto Persona, se te llenará lo que tenga 00:27:33
que ser hasta por defecto y lo 00:27:35
utilizarás de aquí. 00:27:37
... 00:27:39
... 00:27:41
... 00:27:43
... 00:27:45
... 00:27:47
... 00:27:49
... 00:27:51
... 00:27:53
... 00:27:55
... 00:27:57
... 00:27:59
... 00:28:01
... 00:28:03
... 00:28:05
... 00:28:07
... 00:28:09
... 00:28:11
... 00:28:13
... 00:28:15
... 00:28:17
... 00:28:19
... 00:28:21
... 00:28:23
... 00:28:25
... 00:28:27
... 00:28:29
... 00:28:31
... 00:28:33
el overriding 00:28:35
¿vale? que veremos 00:28:36
después porque 00:28:38
en 5 minutos no me da tiempo 00:28:40
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
5
Fecha:
5 de febrero de 2024 - 13:34
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 45″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
89.65 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid