Saltar navegación

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

Clase 5-02-24 - 2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 5 de febrero de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

venga pues a ver 00:00:00
bueno pues entonces 00:00:01
estábamos diciendo que 00:00:04
gracias a que existe la herencia 00:00:06
hacemos un único método 00:00:09
que es realizar la acción 00:00:11
que sea del animal que sea 00:00:13
estupendo 00:00:15
el método ya coge a ese animal 00:00:17
sea el que sea y trata de realizar la acción 00:00:19
y el problema es 00:00:21
que la acción que se hace 00:00:23
ladrar, maullar, nadar 00:00:25
la acción que se hace 00:00:27
depende del tipo de objeto que es 00:00:28
depende de cómo se le hizo el new 00:00:31
de cómo se le instanció 00:00:33
entonces tenemos que poder distinguirlo 00:00:34
pues cómo lo distinguimos 00:00:36
gracias a que existe esta sentencia 00:00:38
vale entonces en nuestro caso 00:00:40
que eso lo tenemos 00:00:42
pues 00:00:43
perro y pez 00:00:45
pues podríamos dejar así el método 00:00:49
y entonces 00:00:53
en ese caso 00:00:58
en ese caso 00:00:58
me falta aquí el A 00:00:58
vale 00:01:01
si esta condición 00:01:02
si esta condición es true 00:01:05
si esta condición es true 00:01:11
es porque A que llegó aquí 00:01:12
A que llegó ahí 00:01:14
cuando se le instanció, se le instanció como pez 00:01:16
entonces si esta condición es true 00:01:18
es porque tenemos la seguridad 00:01:20
de que A se instanció como objeto pez 00:01:22
con lo cual como tenemos la seguridad 00:01:24
de que A se instanció como objeto pez 00:01:26
le podemos hacer un casting 00:01:28
sin miedo a equivocarnos 00:01:30
le hacemos un casting 00:01:33
y ahora ya 00:01:40
esto, como ha recibido un casting 00:01:42
esto ya sí que es un objeto 00:01:45
de tipo pet, porque se han hecho el casting 00:01:47
a pet, eso ya sí es un objeto 00:01:49
de tipo pet, entonces al ser un objeto 00:01:51
de tipo pet, el compilador 00:01:53
nos deja llamar a todos los 00:01:55
métodos de pet 00:01:57
entre ellos, el de nadar 00:01:58
ah, directamente, no nos deja 00:02:02
llamar a nadar, porque a es 00:02:05
animal, esto es un 00:02:07
tema del compilador, pero después de 00:02:09
haberle hecho el casting, el compilador dice 00:02:11
ah, vale, esto ya es pet 00:02:13
lo has convertido a pet, pues te dejo llamar 00:02:15
a los métodos de pet, que es nadar 00:02:17
vale 00:02:19
aquí en realidad 00:02:20
también abrió 00:02:23
un else, porque a 00:02:25
hay tres opciones ahora mismo 00:02:27
en nuestra aplicación, que se instanciara 00:02:28
como pet, entonces entraríamos 00:02:31
aquí, que se instanciara como perro 00:02:33
o que se instanciara como 00:02:35
animal, la clase animal también se puede 00:02:37
instanciar 00:02:39
entonces a podría ser un animal, podría 00:02:39
venir de haber hecho a igual a new animal 00:02:43
podría venir 00:02:45
entonces en ese caso aquí, pues tiene sentido hacer un else 00:02:46
y que queremos hacer, pues 00:02:49
si no tiene acción el animal 00:02:51
cualquiera, no tiene acción, pues podríamos 00:02:53
poner 00:02:55
el animal no tiene 00:02:57
acción establecida, por ejemplo 00:03:07
vale, entonces en único método 00:03:09
ahora ya 00:03:19
el programa pasa al animal que le dé la gana 00:03:21
y ya está 00:03:23
y pasará lo que sea 00:03:25
vale, vamos a probarlo en el mail 00:03:27
porque esto así visto es feo 00:03:29
ahora veremos si lo podemos arreglar o no 00:03:33
hombre es feo, tanto instan en todo es feo 00:03:34
pero bueno, es un método que está ahí 00:03:36
que una vez hecho 00:03:39
ahora ya lo llamamos desde donde nos dé la gana 00:03:40
con toda la comodidad del mundo 00:03:43
con toda 00:03:44
vale, bueno 00:03:45
esto que hemos escrito aquí está claro, ¿no? 00:03:49
lo que significa 00:03:50
vale, no, está claro 00:03:51
que si no hacemos el castro 00:03:54
no podemos llamar a los métodos 00:03:57
de perro ni de pez 00:03:59
solo podemos llamar a los de animal 00:04:00
y después de hacer el casting 00:04:02
ya sí podemos llamar a los específicos 00:04:05
del objeto que sea 00:04:07
bueno, pues ahora nuestro main 00:04:07
de aquí 00:04:10
sí, Josi, no vayas a llegar puntual 00:04:11
nunca 00:04:14
a ver 00:04:15
por ejemplo 00:04:17
aquí, ahora ya 00:04:21
operaciones 00:04:27
realizar acción 00:04:28
aquí estamos ya en el main 00:04:29
al main ya como esté hecha la clase operaciones 00:04:32
es que le da exactamente igual 00:04:34
porque seguramente la hizo 00:04:36
el de dos plantas más arriba 00:04:38
que ni le conozco ni me interesa cómo la hizo 00:04:39
me da igual 00:04:41
pero yo sé que ahora ya puedo llamar a realizar acción 00:04:43
para cualquier animal 00:04:46
sea perro, sea gato 00:04:47
lo que me dé la gana 00:04:48
que quiero que el que realice la acción sea el perro 00:04:50
pues ala 00:04:53
le paso el perro y estupendo 00:04:54
le he pasado un perro 00:04:57
y realizo acción 00:04:58
que ahora quiero que el que realice acción 00:04:59
sea el pez 00:05:01
pues estupendo 00:05:03
le paso el pez 00:05:07
le paso un objeto instanciado como pez 00:05:08
genial 00:05:10
entonces ahora mismo ya es comodísimo 00:05:10
yo tengo un método de realizar acción 00:05:12
y le paso cualquier animal 00:05:15
el que sea 00:05:16
cualquiera 00:05:17
vale 00:05:19
entonces de nuevo 00:05:21
esto facilita el desarrollo 00:05:22
de aplicaciones 00:05:24
yo tengo un único método 00:05:27
que me dice dame el animal que te dé la gana 00:05:29
y yo ya hago lo que sea con ese animal 00:05:31
dame el que te dé la gana 00:05:33
y yo luego tengo un montón de objetos diferentes 00:05:35
tengo peces, gatos, perros 00:05:37
pero a todos los puedo enviar 00:05:39
al mismo método a todos 00:05:41
cuando no teníamos herencia 00:05:43
yo tenía que tratar 00:05:45
cada animal de forma separada 00:05:47
un método para pasarle el perro 00:05:49
otro método para poder pasarle el gato 00:05:51
otro método para poder pasarle el pez 00:05:53
ahora no 00:05:55
ahora un único método al que le paso 00:05:56
animal, venga, ala 00:05:59
el animal que sea 00:06:00
vale, de hecho vamos a instanciar 00:06:01
un animal normal y corriente 00:06:05
que no se anigue 00:06:06
aquí por ejemplo este 00:06:08
vale y vamos a llamar 00:06:11
a realizar la acción del animal 00:06:15
este normal y corriente 00:06:17
que no es ni gato, ni pez, ni nada 00:06:18
ni perro, ni dromedario 00:06:20
este 00:06:23
vale 00:06:26
pues vamos a ejecutar el código 00:06:27
bueno primero 00:06:29
para no liarme voy a comentar 00:06:32
lo de mostrar las iniciales 00:06:34
vale 00:06:36
y efectivamente 00:06:43
este realizó la acción del perro 00:06:44
al método al que se llamó 00:06:47
fue el que está en la clase perro 00:06:49
sin embargo este realizó la acción 00:06:51
del pez 00:06:53
y este nos dijo 00:06:53
no sé, me has pasado un animal 00:06:56
vale 00:06:59
entonces esto nos permite unificar 00:07:00
si se hace uno un buen diseño 00:07:03
de clases, una buena jerarquía 00:07:06
de clases, luego hacer el main 00:07:08
hacer los programas que ya 00:07:10
ejecutan cosas 00:07:12
son muchísimo más sencillos 00:07:13
si uno hace un buen diseño de clases, una buena jerarquía, etc. 00:07:15
es mucho más sencillo 00:07:18
tener un único método, realizar acción al que le paso el animal 00:07:19
que tener 00:07:22
realizar acción del gato, del perro, del no sé qué 00:07:24
vale 00:07:26
pues para esto se inventó 00:07:27
la herencia, para esto se inventó 00:07:29
bueno pues está claro, ¿no? 00:07:31
la motivación y lo que hay de fondo 00:07:35
de esto 00:07:36
está claro, ¿no? 00:07:37
vale, lo que tenemos es que seguir viendo ahora ya detalles 00:07:39
lo que es ya de escritura de código 00:07:42
detalles de pulido 00:07:44
tenemos que seguirlos viendo 00:07:45
pero entendiendo que hay un detrás 00:07:46
para hacer estas cosas 00:07:49
bueno, digo 00:07:51
tenemos una acción en animal 00:07:53
que es comer 00:07:57
porque nos llama a esa acción 00:07:59
no la hemos llamado en operaciones 00:08:02
bueno, a ver, es que también 00:08:05
bueno, porque aquí estamos viendo, podríamos llamar 00:08:07
bueno, porque aquí lo que estamos viendo 00:08:10
es la acción de 00:08:11
ladrar, o sea, estamos haciendo esto 00:08:12
pero a ver, que lo que queremos es que ahora que el animal 00:08:15
coma, tú puedes llamar al método 00:08:17
comer de cualquiera de ellos 00:08:19
¿vale? 00:08:20
vamos a hacer 00:08:23
que el animal A coma 00:08:25
pues puedes llamar a su método comer 00:08:27
porque comer está en la clase animal 00:08:29
¿vale? y también puede 00:08:31
comer este 00:08:34
¿vale? 00:08:34
porque comer 00:08:39
al estar en la clase animal 00:08:41
lo ha heredado 00:08:43
también la clase perro 00:08:45
¿vale? 00:08:47
y también puede comer el otro 00:08:49
¿vale? 00:08:51
si le da la gana 00:08:53
¿vale? porque como comer está 00:08:54
en la clase animal 00:08:58
pues también lo puede llamar 00:09:00
la subclase 00:09:02
pez 00:09:04
cualquiera lo puede llamar porque comer está en la clase animal 00:09:09
¿vale? 00:09:12
la pregunta sería, pero está lo siguiente antes de que cerremos 00:09:13
esto es, y si yo quiero que coman 00:09:16
de forma distinta 00:09:18
claro, pero esto ya es otra cosa, entonces hay que 00:09:19
sobre escribir, ¿vale? 00:09:21
pero vamos a olvidarnos ahora de esto 00:09:23
vamos a seguir con lo que estábamos 00:09:25
¿vale? bueno, pues entonces 00:09:27
ahora lo que estamos haciendo en concreto es 00:09:29
definir unas acciones para cada animal 00:09:31
y ir viendo, pues bueno, esta situación en concreto 00:09:33
cómo resolverla 00:09:35
¿vale? pues entendido esto, vamos a volver 00:09:36
a nuestro método de aquí 00:09:39
a nuestro método 00:09:41
que ya hemos entendido 00:09:43
cómo funciona 00:09:45
¿vale? pues lo hemos 00:09:46
entendido 00:09:49
pero 00:09:50
vamos a cambiarlo para que no sea tan feo 00:09:53
esto está bien 00:09:56
y de hecho vamos a dejarlo así, vamos a incorporarlo en otro método 00:09:57
otra forma de hacer las cosas 00:10:00
otra forma, esto está bien 00:10:01
y lo vais a ver, obviamente, en mil sitios 00:10:03
así funcionan las cosas, y el instansoft a veces 00:10:05
es que no hay tutía, hay que usarlo 00:10:08
porque uno recibe un objeto 00:10:10
que sabe 00:10:12
que pertenece a una superclase 00:10:13
pero necesita además saber 00:10:15
a qué subclase en particular 00:10:18
entonces ahí es el instansoft 00:10:19
no hay otro 00:10:22
¿vale? 00:10:22
bueno, pero vamos a ver otra forma de diseñar esta misma idea 00:10:23
otra manera de diseñar esta misma idea 00:10:26
que estamos diciendo 00:10:27
de un único método 00:10:28
al que yo le paso al animal 00:10:31
y realice la acción 00:10:33
de cualquiera de los animales 00:10:34
independientemente de si es perro, pues otra forma 00:10:37
otra forma de plantearse esto 00:10:39
bueno, pues uno podría preguntar 00:10:41
oye, esto del instansoft 00:10:44
qué feo 00:10:46
ladrar, nadar, qué feo 00:10:47
y si yo en lugar de 00:10:49
diseñarlo así 00:10:51
me hago un método 00:10:53
¿vale? 00:10:55
me hago un método en cada clase 00:10:57
total, que se llame 00:10:59
realizar su acción 00:11:01
y si se llaman igual 00:11:02
pues entonces no tengo por qué distinguir 00:11:04
no podría pensar, no tengo por qué distinguir 00:11:07
si ladrar, nadar 00:11:09
lo que sea 00:11:11
lo que se hace específicamente en cada clase 00:11:12
lo recojo yo en un método 00:11:15
que se llama igual en cada clase 00:11:17
realizar acción 00:11:19
pues entonces uno pensaría, no tengo por qué 00:11:20
distinguir 00:11:23
me da igual el objeto que sea 00:11:24
llamo a realizar acción 00:11:25
y ya ese realizar acción 00:11:27
dentro de cada clase hará lo que sea 00:11:29
¿no? esa podría ser una cosa 00:11:31
que nos plantearíamos 00:11:33
efectivamente 00:11:34
sí, entonces vamos a incorporar aquí 00:11:38
un método, vamos a cambiar el diseño 00:11:39
y decir, venga, vamos a hacernos 00:11:42
realizar acción que se llame igual en todas 00:11:45
en lugar de llamarlo ladrar, nadar 00:11:47
decir, pues para qué complicarnos la vida 00:11:49
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:51
¿para qué? 00:11:52
¿para qué? 00:11:52
¿para qué? 00:11:52
¿para qué? 00:11:52
¿para qué? 00:11:52
¿para qué complicárnosla? 00:11:52
vamos a llamar un método 00:11:57
que sea realizar acción 00:11:58
y que en el caso del perro 00:12:00
sea esta 00:12:02
sea ladrar 00:12:03
vale, estupendo 00:12:05
vale, en el caso del perro 00:12:07
es ladrar 00:12:11
es esto 00:12:12
vale 00:12:15
en el caso del pez 00:12:16
en el caso del pez 00:12:22
es esta 00:12:24
es nadar 00:12:27
uy, me sobra la llave 00:12:28
entonces ya 00:12:36
parecería que uno ha arreglado algo 00:12:40
ha facilitado las cosas 00:12:42
parecería que uno las ha facilitado 00:12:43
porque dice, a ver, si mi problema era en este método 00:12:45
mi problema era 00:12:48
que tenía yo que distinguir 00:12:50
si hablaba de perros o peces 00:12:52
para decidir si llamar a ladrar o nadar 00:12:54
si mi problema era ese 00:12:56
pues hombre, si tengo la opción 00:12:58
voy a llamar al método igual 00:13:00
en todas las clases 00:13:03
aunque haga cosas distintas dentro 00:13:04
voy a llamarlo igual en todas las clases 00:13:06
y como tiene el mismo nombre 00:13:08
yo lo llamo con ese nombre 00:13:10
me da igual que sea perro, que sea gato, que sea no sé qué 00:13:12
vale, tendría sentido 00:13:15
planteárselo así 00:13:17
tendría sentido 00:13:19
y es lo que hemos empezado a hacer 00:13:20
y aquí me falta una llave 00:13:22
esta no es 00:13:26
esta sí 00:13:29
vale 00:13:30
bueno, es lo que hemos empezado a hacer 00:13:31
y tendría todo el sentido del mundo 00:13:33
vale, pues vamos a 00:13:34
para no borrar este método 00:13:35
vamos a hacernos otra versión de este método 00:13:36
realizar acción al que se le pasa un animal 00:13:38
otra versión que tenga en cuenta esto 00:13:40
ahora que hemos hecho 00:13:43
realizar acción 00:13:44
vale 00:13:50
versión 2 00:13:52
otra versión 00:13:54
de realizar acción 00:13:57
teniendo en cuenta ahora ese método que acabamos de hacer 00:13:58
entonces uno tendería a pensar 00:14:00
a ver, me da igual 00:14:02
si ese animal es perro, pez, gato 00:14:04
porque pertenezca a la clase que pertenezca 00:14:07
según el diseño que yo he hecho 00:14:10
hay un método que se llama igual en todas 00:14:12
que es realizar acción 00:14:15
que realiza la acción 00:14:16
con lo cual la llamada que tenemos que hacer 00:14:17
es la misma 00:14:19
sea perro, sea gato, sea no sé qué 00:14:20
sea gato, sea pez 00:14:22
entonces, ¿no? 00:14:23
para eso hemos hecho un método igual en todas las clases 00:14:24
entonces uno diría 00:14:26
pues magnífico 00:14:28
entonces me da igual 00:14:29
ah, me da igual lo que sea 00:14:29
yo sé que sea perro 00:14:31
sea gato, sea lo que sea 00:14:33
tengo mi método 00:14:35
realizar acción en todas ellas 00:14:37
en pez 00:14:39
hará esto 00:14:40
en perro hará esto 00:14:42
en gato hará lo que sea 00:14:44
pero la tengo en todas 00:14:45
para eso lo hemos hecho 00:14:46
¿no? 00:14:48
entonces uno hace 00:14:49
pues venga, lo llamo y tan ricamente 00:14:50
pero no puede 00:14:52
el compilador de nuevo 00:14:54
que es el que 00:14:56
está mirando 00:14:56
que todas las reglas del juego sintáctico 00:14:58
al compilador solo le importan las sintaxis 00:15:01
no le importa la ejecución 00:15:03
le importa que todas las reglas sintácticas 00:15:05
estén cubiertas 00:15:07
pues el compilador que es el que mira 00:15:09
las reglas del juego dice 00:15:12
¿por qué nos dice que no? 00:15:13
si, realizar acción 00:15:22
se llama 00:15:25
en pez se llama 00:15:25
se llama realizar acción 00:15:27
en pez 00:15:32
y en perro se llama 00:15:33
realizar acción 00:15:34
o sea, el método se llama igual en todas 00:15:36
no hombre, no, pero este es 00:15:37
ya, a ver 00:15:40
sí, pero este es el método 00:15:42
a ver, tienes razón 00:15:45
pero este método es el método de la clase operaciones 00:15:46
y este es el de la clase animal 00:15:48
bueno, espera, vamos a cambiarle de nombres 00:15:50
¿qué es el método de la clase operaciones? 00:15:52
para que sea más claro 00:15:52
pero vamos, que están en diferentes clases 00:15:56
da igual que se llaman igual 00:15:58
vamos a cambiarle si quieres 00:15:59
a realizar acción del animal 00:16:02
para que 00:16:04
realizar acción del animal 00:16:06
aquí 00:16:08
ahora este 00:16:10
realizar acción del animal 00:16:12
aquí 00:16:14
y ahora entonces este tiene que llamar 00:16:16
a realizar acción del animal 00:16:20
vale 00:16:22
entonces todas las clases tienen un método 00:16:23
que es realizar acción del animal 00:16:26
la que sea, y cada uno hace lo suyo 00:16:27
entonces me da igual que hace a gato, perro 00:16:29
lo que sea, me da igual 00:16:32
sé que va a tener un método 00:16:33
que se llama realizar acción del animal 00:16:36
al que yo quiero llamar 00:16:38
entonces uno pensaría que 00:16:39
uno tiene que distinguir, le da lo mismo, llama a este 00:16:42
y el compilador que es el que vela por las reglas del juego 00:16:44
sigue diciendo 00:16:46
no puedes 00:16:48
¿por qué no puedes? 00:16:49
claro 00:16:52
vale, esto ya surgió el otro día 00:16:55
porque el compilador 00:16:56
mira esto y dice 00:16:57
ah, ¿de dónde viene? 00:17:00
se va hacia arriba hasta que encuentra la declaración 00:17:02
él sigue unas reglas muy claras 00:17:05
o sea, programar un compilador 00:17:07
es sencillísimo 00:17:08
es cogerte las 00:17:10
1500 reglas sintácticas que tiene 00:17:12
y programarlas 00:17:14
es un ejercicio básico de la carrera 00:17:15
hazme el compilador del lenguaje patatín 00:17:19
porque el compilador 00:17:21
sigue sus reglas sotacayo y rey 00:17:22
el compilador, veo aquí una referencia 00:17:24
empieza a ir linas hacia arriba 00:17:27
hasta que encuentra la declaración 00:17:29
y dice animal 00:17:31
vamos a ver qué hace 00:17:33
a ver si realizar acción está en animal 00:17:35
vamos a ver si está 00:17:37
y en animal no está 00:17:39
y te dice, lo siento, no puedes 00:17:41
vale, entonces 00:17:43
¿cuál es la solución? efectivamente 00:17:45
la única solución posible 00:17:47
la única solución posible 00:17:49
para poder dejar este método así 00:17:51
tan bonito y tan cómodo 00:17:53
sin instance of y sin nada 00:17:55
declarar ese método en la superclase 00:17:58
¿verdad? 00:18:00
estamos en realidad repasando lo del otro día 00:18:02
en una aplicación más pequeñita para no perdernos 00:18:04
entonces 00:18:06
vamos a declarar, realizar acción 00:18:08
del animal aquí 00:18:10
realizar acción del animal 00:18:21
claro, yo la declaro aquí 00:18:27
la declaro aquí 00:18:31
vale, el compilador ya se queda 00:18:33
encantado de la vida, dice genial 00:18:35
¿a qué es? a es una referencia de tipo animal 00:18:37
entonces él se va a animal automáticamente 00:18:39
porque a está declarado como animal 00:18:41
se va a animal 00:18:43
animal tiene realizar acción 00:18:45
va mirando 00:18:47
uy sí, la tiene 00:18:49
y ya está, y se acabó 00:18:51
el compilador ha acabado su tarea, ya no mira más 00:18:53
ya está, dice, has cumplido 00:18:55
las reglas del juego, fenomenal, te dejo seguir 00:18:57
vale, ahora ya, claro, entra nuestra cabeza a pensar 00:19:01
y decimos, vale 00:19:03
me has obligado a declarar 00:19:05
este método para poder llamarlo 00:19:07
pero cuando lo hemos declarado 00:19:09
pues nos surge la 00:19:11
gran pregunta 00:19:13
y es, ¿qué código metemos ahí? 00:19:15
¿estoy en la clase animal? 00:19:17
¿no sé qué hay que hacer? 00:19:19
si hay que nadar, si hay que maullar 00:19:21
si hay que correr, si hay que comer, si hay que nadar 00:19:23
no tengo ni idea 00:19:25
¿qué código metemos ahí? 00:19:27
pues no metemos ninguno 00:19:29
lo dejamos en blanco 00:19:31
vale, no metemos nada 00:19:33
lo dejamos en blanco 00:19:35
claro 00:19:37
entonces, ahora ya cada clase 00:19:39
que hereda 00:19:41
que lo sobrescriba 00:19:43
vale 00:19:45
esa es la famosa sobrescritura 00:19:47
de métodos, la sobrescritura 00:19:49
pues overwrite 00:19:51
cuando lo miráis en manuales 00:19:53
que en ciertas condiciones 00:19:55
que veremos dentro de un poquito 00:19:57
hay que anotarlo, pero eso ya lo veremos más adelante 00:19:59
esa es la sobrescritura 00:20:01
entonces, ahora ya 00:20:03
cada clase que quiera realizar una acción propia 00:20:05
lo sobrescribe 00:20:07
que yo me hago una clase 00:20:09
que no quiero que tenga una realizar acción propia 00:20:11
que no la tenga definida 00:20:13
no la sobrescribo, entonces hereda el blanco 00:20:15
hereda el vacío 00:20:17
y cuando se llame para ese animal un realizar acción 00:20:19
del animal, no hará nada 00:20:21
pero para cualquier otra subclase 00:20:23
que yo quiero que haga algo en concreto 00:20:25
lo sobrescribe 00:20:27
y sobrescribirlo significa 00:20:29
hacer otro método 00:20:31
con la misma cabecera, la misma 00:20:33
idéntica, hacer otro método con la misma 00:20:35
y ya poner el código que a mi me dé la gana 00:20:37
entonces, este método 00:20:39
sobrescribe al de arriba 00:20:41
lo sustituye 00:20:43
directamente, lo sustituye 00:20:45
y el de arriba 00:20:47
ya ha desaparecido 00:20:49
para la clase perro 00:20:51
ya ha desaparecido 00:20:53
y en la clase perro igual 00:20:55
este sobrescribe 00:20:57
al de arriba 00:20:59
y en la clase perro 00:21:01
ya el de arriba 00:21:03
no existe, porque ha quedado sobrescrito 00:21:05
por esto 00:21:07
entonces la superclase 00:21:09
te da una plantilla de cosas 00:21:11
que por ahora están abiertas 00:21:13
y las subclases 00:21:15
las definen 00:21:17
y ahora ya esto ya si que es cómodo 00:21:19
porque yo me despreocupo 00:21:21
y digo, me da igual el animal que sea 00:21:23
me da lo mismo 00:21:25
yo llamo a realizar acción del animal 00:21:27
y ahora ya cuando entramos a ejecutar 00:21:29
que fue con lo que nos quedamos al final 00:21:31
el viernes pasado 00:21:33
cuando entramos a ejecutar 00:21:35
la máquina virtual 00:21:37
ella ya si que se hace preguntas 00:21:39
no es como el compilador 00:21:41
que se limita a mirar el código 00:21:43
a ver si encaja o no encaja 00:21:45
la máquina virtual ya dice 00:21:47
vamos a ver 00:21:49
tiene que llamar a realizar acción 00:21:51
ahora ya estoy ejecutando 00:21:53
no estoy mirando a ver si la sintaxis es correcta 00:21:55
yo soy la máquina virtual, no soy el compilador 00:21:57
y tengo que ejecutar 00:21:59
objeto A 00:22:01
quieres hacer realizar acción 00:22:03
vale, tu objeto A que eres 00:22:05
y tendrá que ver como se instanció 00:22:07
la propia máquina virtual 00:22:09
es la que se hace internamente 00:22:11
la máquina virtual dice 00:22:13
tu A que eres 00:22:15
va mirando a ver el new que se hizo 00:22:17
exacto que eres 00:22:19
y cuando ya mira 00:22:21
ya haya averiguado lo que es 00:22:23
porque esto ya es un objeto que exista 00:22:25
estamos en tiempo de ejecución 00:22:27
ya es un objeto que exista 00:22:29
pues cuando ya sepa ese objeto que ya existe 00:22:31
como se creo 00:22:33
pues se va al método en concreto 00:22:35
se va al método en concreto 00:22:37
entonces por eso aquí 00:22:39
en nuestro main 00:22:41
si hacemos la versión 2 00:22:43
del otro 00:22:47
vale 00:22:49
a ver 00:22:51
realizar acción 00:22:57
versión 2 00:22:59
de A1 00:23:01
realizar acción versión 2 00:23:03
de A1 que hará 00:23:05
pues llamará 00:23:07
a la versión de realizar acción del animal 00:23:09
que hay 00:23:11
en la clase a la que pertenece A1 00:23:13
A1 pertenece a que 00:23:15
a perro 00:23:17
como A1 pertenece a perro 00:23:19
perdón estoy 00:23:21
donde estoy aquí 00:23:23
como A1 pertenece a perro 00:23:25
pues esta llamada 00:23:27
será la de la clase perro 00:23:29
cuando lleguemos 00:23:31
aquí 00:23:33
a la versión 2 00:23:35
la máquina virtual mirará este objeto de que clase es 00:23:37
verá que 00:23:39
este objeto pertenece a la clase pez 00:23:41
como 00:23:43
se instanció como clase pez 00:23:45
llamará al realizar acción 00:23:47
del animal que esté en la clase pez 00:23:49
este de aquí 00:23:51
este de aquí 00:23:55
perdón ponemos aquí la versión 2 00:23:57
este que va a hacer 00:23:59
vamos a ver que hace 00:24:03
este 00:24:05
mirará 00:24:07
de como se instanció 00:24:09
este de aquí A 00:24:11
este se instanció 00:24:13
como animal 00:24:15
se instanció como animal 00:24:17
llamará 00:24:19
a realizar acción del animal 00:24:21
la que hay en la clase animal 00:24:23
que no hace nada 00:24:25
entonces no hará nada 00:24:27
no hará nada 00:24:29
entonces 00:24:31
este me mostrará la acción del 00:24:33
del perro 00:24:35
este me mostrará del gato 00:24:37
y luego no veré nada más 00:24:39
no veremos nada más 00:24:41
vale 00:24:43
y efectivamente eso es lo que ha hecho 00:24:45
y efectivamente eso es lo que ha hecho 00:24:47
esto vale 00:24:49
lo de arriba eran las llamadas a la otra versión 00:24:51
pues es justo lo que ha hecho 00:24:53
vale 00:24:55
entonces 00:24:57
es infinitamente más cómodo 00:24:59
trabajar así 00:25:01
pues entonces 00:25:03
la sobrescritura 00:25:05
y el polimorfismo 00:25:07
son dos términos 00:25:09
que van juntos 00:25:11
que pasa cuando sobrescribimos 00:25:13
métodos 00:25:15
un método que está en la superclase 00:25:17
y lo sobrescribimos 00:25:19
de forma distinta en cada subclase 00:25:21
pues que lo estamos haciendo polimorfo 00:25:23
o lo que es lo mismo 00:25:25
le estamos dando formas distintas 00:25:27
en función de la clase en la que está 00:25:29
lo estamos haciendo polimorfo 00:25:31
le estamos dando formas distintas 00:25:33
entonces 00:25:35
esta llamada de aquí 00:25:37
esta llamada 00:25:39
que parece que es la llamada 00:25:41
un único método 00:25:43
en realidad es 00:25:45
a la del perro si es que A es un perro 00:25:47
o a la del gato 00:25:49
o a la del pez si es que A es un pez 00:25:51
entonces aquí estamos haciendo polimorfismo 00:25:53
porque este método 00:25:55
adopta diferentes formas 00:25:57
y las formas que adopta 00:25:59
dependerá de si A es perro 00:26:01
es gato 00:26:03
es no sé qué 00:26:05
vale 00:26:07
pues a eso se le llama polimorfismo 00:26:09
aquí un método 00:26:11
al que tú le llamas con un nombre único 00:26:13
este nombre 00:26:15
pues o te está haciendo este código 00:26:17
se llama polimorfismo 00:26:19
y cómo se consigue el polimorfismo 00:26:21
se consigue sobreescribiendo métodos 00:26:23
haciendo esto 00:26:25
si yo este método lo sobreescribo aquí 00:26:27
y lo sobreescribo aquí 00:26:29
pues le estoy dando diferentes formas 00:26:31
vale 00:26:33
vale pues esto es 00:26:35
esta es la motivación 00:26:37
y lo que está en la base de la herencia 00:26:39
para esto sirve 00:26:41
no tanto porque al heredar 00:26:43
yo hay un código que directamente 00:26:45
estoy como haciendo un copia y pega y ahorrándomelo 00:26:47
eso en sí mismo no es ninguna motivación 00:26:49
en total copiar y pegar 00:26:51
tampoco se tarda tanto 00:26:53
no es esa la motivación de la herencia 00:26:55
sino esta otra 00:26:57
la comodidad de poder hacer cosas como esta 00:26:59
vale 00:27:01
un único método 00:27:03
al que le cae cualquier clase 00:27:05
cualquier animal cualquier cosa 00:27:07
y hace 00:27:09
lo que toque 00:27:11
si no tuviéramos la herencia 00:27:15
tendríamos que trabajar por separado con los gatos 00:27:17
los perros 00:27:19
y aquí 00:27:21
ala todo junto 00:27:23
en dos líneas de código 00:27:25
vale solamente porque 00:27:27
hay una jerarquía y además hay 00:27:29
sobre escritura de métodos y polimorfismo 00:27:31
pues lo hemos conseguido en eso 00:27:33
y si no hubiera esto las aplicaciones serían 00:27:35
inmanejables 00:27:37
si no hubiera esto 00:27:39
bueno claro claro 00:27:41
vale 00:27:47
lo que nos produce 00:27:49
un poco de ansiedad 00:27:51
es esto de tener que dejar ahí un método vacío 00:27:53
es bastante feo 00:27:55
no parecimos 00:27:59
convencidos de que eso 00:28:01
no sea feo 00:28:03
hombre es feo 00:28:05
es decir jolín yo parece que voy a hacer un método 00:28:07
pero como no tengo ni idea de lo que escribir ahí 00:28:09
porque es que no tiene sentido 00:28:11
porque es un animal genérico y no tiene acción 00:28:13
pues lo dejo vacío 00:28:15
pero lo hemos tenido que poner 00:28:17
porque si no lo poníamos 00:28:19
el compilador aquí 00:28:21
nos decía eh no 00:28:23
no la razón de ponerlo 00:28:25
era porque el compilador nos decía 00:28:27
lo siento 00:28:29
a está declarado 00:28:31
como animal como esta instancia me da igual 00:28:33
porque las instancias se hacen en tiempo 00:28:35
de ejecución cuando el programa arranca 00:28:37
en el compilador no hay nada arrancado 00:28:39
ni tiempo de ejecución ni nada 00:28:41
el compilador dice perdona a 00:28:43
está declarado como animal 00:28:45
pues lo siento mucho tiene que haber 00:28:47
un método de realizar el animal 00:28:49
entonces lo hemos hecho por eso 00:28:51
es que si no no hay tutía es imposible hacer esto 00:28:53
y al hacerlo nos hemos 00:28:55
encontrado que hemos tenido que hacer esta cosa tan fea 00:28:57
de dejarlo así 00:29:01
eh vacío 00:29:03
y hombre esto es feo 00:29:05
vale esto es feo 00:29:07
bueno pero 00:29:11
es que 00:29:13
ocurre que 00:29:15
hay clases en las cuales 00:29:17
el método todavía no se puede definir 00:29:19
porque no tengo la información suficiente 00:29:21
si yo no se que animal es 00:29:23
si yo no se que animal es 00:29:25
no puedo realizar su acción 00:29:27
en ese momento no lo puedo definir 00:29:29
entonces 00:29:31
esto 00:29:33
podría definirse 00:29:35
como que esto es un método abstracto 00:29:37
es un método abstracto 00:29:39
verdad es un método abstracto 00:29:41
no es un método que haga nada concreto 00:29:43
esto ya si 00:29:45
estos son métodos que hacen con que 00:29:47
hacer cosas concretas 00:29:49
esto si 00:29:51
pero este es un método abstracto 00:29:53
vale pues si yo decido 00:29:55
dentro de mi diseño que es abstracto 00:29:57
y quiero que quede reflejado 00:29:59
y quiero que quede reflejado 00:30:01
pues lo que puede hacer 00:30:03
lo que puedo hacer es 00:30:05
no ponerle ni cuerpo 00:30:07
le pongo ahí un punto y coma 00:30:11
y esto lo puedo hacer 00:30:13
termino el método 00:30:15
ni llaves ni nada 00:30:17
termino con punto y coma 00:30:19
con eso que quiero indicar 00:30:21
que este método 00:30:23
es abstracto 00:30:25
vale el siguiente método 00:30:37
es abstracto 00:30:39
porque termina en punto y coma 00:30:43
no tiene cuerpo 00:30:45
el cuerpo de un método es lo que va entre llaves 00:30:47
vale es lo que va entre llaves 00:30:49
ese es el cuerpo de un método 00:30:51
si un método no tiene cuerpo 00:30:53
puede ocurrir 00:30:55
que no tenga 00:30:57
y yo lo termino con punto y coma 00:30:59
entonces lo convierto en abstracto 00:31:01
vale 00:31:03
pero si el método 00:31:07
es abstracto 00:31:09
entonces esto ya tiene implicaciones 00:31:11
entonces ahora yo ya estoy 00:31:13
convirtiendo mi clase 00:31:15
en lo que se llama una clase abstracta 00:31:17
vale 00:31:19
una clase que tiene 00:31:21
un método por definir 00:31:23
vacío que yo no puedo definirlo 00:31:25
porque me falta información 00:31:27
se convierte en una clase abstracta 00:31:29
y eso lo tenemos que avisar 00:31:31
lo tenemos que avisar 00:31:33
poniendo un abstract 00:31:35
ahí 00:31:37
vale 00:31:39
lo tenemos que avisar 00:31:41
poniendo un abstract ahí 00:31:43
y poniendo un abstract 00:31:45
aquí vale 00:31:47
no vale 00:31:49
con que yo lo termine con punto y coma 00:31:51
no vale 00:31:53
con que yo lo termine con punto y coma 00:31:55
valdrá más adelante 00:31:57
cuando 00:31:59
incorporemos otras cosas 00:32:01
pero 00:32:03
ahora mismo no 00:32:05
vale yo entonces 00:32:07
reconectar con el proceso 00:32:09
de funcionamiento 00:32:11
yo he visto que este método 00:32:13
tiene que estar ahí 00:32:15
tiene que estar ahí obligatoriamente 00:32:17
no se lo puedo dar cuerpo 00:32:19
no se lo puedo dar 00:32:21
porque está por definir 00:32:23
ya lo definirán las subclases 00:32:25
ya lo definirán 00:32:27
bueno pues entonces el diseño va a quedar 00:32:29
yo lo puedo dejar como estaba 00:32:31
ya está y no pasa nada 00:32:33
pero el diseño va a quedar más bonito 00:32:35
y como os lo vais a encontrar 00:32:37
ese yo digo pues no 00:32:39
si está en blanco está en blanco 00:32:41
entonces le digo tú eres abstracto 00:32:43
tú eres abstracto porque estás en blanco 00:32:45
y aviso de que es abstracto poniendo esto 00:32:47
aviso 00:32:49
vale 00:32:51
pues entonces desde el momento en que 00:32:53
una clase tiene 00:32:55
aunque sea sólo uno 00:32:57
una clase puede tener mil métodos 00:32:59
y uno sólo de ellos es abstracto 00:33:01
o más de uno 00:33:03
pero desde el momento en que tiene uno al menos 00:33:05
y sólo uno 00:33:07
esa clase se convierte en una clase abstracta 00:33:09
y hay que avisar de ello 00:33:11
poniéndole el astra delante 00:33:13
vale 00:33:15
... 00:33:17
... 00:33:19
... 00:33:21
esta clase es abstracta 00:33:23
porque tiene al menos 00:33:25
puede tener más 00:33:27
un método 00:33:29
abstracto 00:33:31
... 00:33:33
vale 00:33:35
se convierte en abstracta 00:33:37
entonces así queda pues más bonito 00:33:39
... 00:33:41
... 00:33:43
... 00:33:45
... 00:33:47
... 00:33:49
pero bueno esto tiene una pequeña implicación 00:33:51
que puede hacernos daño o puede no hacernos daño 00:33:53
depende de mi aplicación 00:33:55
en concreto 00:33:57
la implicación que tiene 00:33:59
es que de una clase abstracta 00:34:01
no se pueden instanciar objetos 00:34:03
... 00:34:05
... 00:34:07
... 00:34:09
... 00:34:11
... 00:34:13
... 00:34:15
... 00:34:21
... 00:34:23
... 00:34:25
de una clase abstracta no se puede instanciar objetos 00:34:27
... 00:34:29
... 00:34:31
... 00:34:33
no se pueden 00:34:35
la cyclone 00:34:37
y de hecho efectivamente 00:34:39
si nos vamos a nuestro main 00:34:41
Yo tenía aquí un anio-animal. 00:34:43
Antes he podido instanciar un animal sin problemas. 00:34:46
Ahora, el compilador ya me lo ha puesto en rojo. 00:34:49
Me ha dicho, ¿eh? 00:34:52
Animal es abstracta. 00:34:54
Lo siento, no puedes instanciar objetos de la clase abstracta. 00:34:55
No puedes. 00:34:58
Puedes instanciar de la subclase, 00:35:00
pero de la clase abstracta no puedes. 00:35:02
Hombre, entonces uno diría, 00:35:07
jodido, ¿entonces para qué necesito una clase abstracta? 00:35:08
Es que, bueno, es que muchas veces 00:35:10
la clase la quieres simplemente como plantilla. 00:35:13
O sea, como marco de paraguas 00:35:16
para dar un código común que la hereden las demás. 00:35:18
Pero tú no quieres instanciar animales en concreto. 00:35:22
Quieres instanciar perros, gatos, no sé qué, 00:35:26
pero un animal genérico no quieres instanciarlo. 00:35:28
Suele ser lo que ocurre la mayoría de las veces. 00:35:31
Tú tienes tu aplicación con muchos tipos de clientes. 00:35:33
Y como todos ellos comparten parte de sus propiedades y métodos, 00:35:36
las recoges todas por comodidad arriba. 00:35:40
Por comodidad y así también para poder hacerte 00:35:43
una RAI común de todos, etcétera. 00:35:46
Pero objetos cliente en concreto no te vas a instanciar. 00:35:48
Te vas a instanciar cliente, tienda, presencial, patatín. 00:35:51
Suele ser el uso habitual, 00:35:54
que de la superclase no se necesite instancia. 00:35:56
Que esté solamente para dar un marco común para todas 00:35:58
y para poder tratarlas a todas en la misma referencia. 00:36:02
Para poder meterlas a todas en variable cliente. 00:36:06
Entonces, si ese es el caso, 00:36:10
si uno no necesita instanciar objetos de la superclase, 00:36:12
pues estupendo que se abstracta. 00:36:16
Estupendo que lo sea. 00:36:18
Porque el código va a quedar más claro, más bonito. 00:36:20
Y si yo lo termino aquí en un punto y coma 00:36:24
y digo que es abstracto y todo, va a quedar mucho mejor. 00:36:27
Pero claro, en ese caso no podemos instanciar. 00:36:31
Lo voy a... 00:36:35
Vale, esto. 00:36:41
No lo podríamos hacer si es abstracta. 00:36:42
No podríamos hacerlo. 00:36:53
Vale, entonces uno tiene que elegir 00:36:59
cómo diseña su aplicación. 00:37:02
Como veis, a partir de ahora y en el resto del curso, 00:37:07
asumiendo que todas las destrezas de programación las tenemos claras, 00:37:10
sobre todo se trata de entender diseños. 00:37:14
Sobre todo se trata de entender estas herramientas, 00:37:17
de estas potencialidades que nos da el lenguaje, 00:37:20
entenderlas y aplicarlas. 00:37:26
Entonces diríais, bueno, vale, pues me vale para eso exclusivamente, 00:37:33
para dar una especie de paraguas común. 00:37:38
De cosas compartidas y las otras ya lo heredan. 00:37:40
Para eso me vale. 00:37:43
Sí, me vale para eso. 00:37:46
Y además el hecho de hacerle abstracta, 00:37:48
ya me ha metido otra cosa que es muy útil y muy interesante. 00:37:50
Ya con esto paramos, hacemos el descansito. 00:37:55
Vale, y es. 00:38:00
Mi clase es abstracta. 00:38:02
Vale, pues ya ahora voy a... 00:38:04
De repente me ha aparecido otro animal. 00:38:05
En mi aplicación que es Gestión de Animales, 00:38:07
ahora me ha aparecido el ave. 00:38:09
Pues nada, yo meto una nueva clase que también va a heredar de animal. 00:38:18
Hala, me ha aparecido el ave porque ahora quiero trabajar con ellos. 00:38:26
Entonces el ave tendrá, vale, si yo quiero que sea un animal, 00:38:30
pues tendrá que heredar de animal. 00:38:34
De animal. 00:38:37
Entonces, por hacer la heredera de animal, 00:38:42
ya sabemos, ya sabemos que todo lo que haya en animal lo hereda. 00:38:45
Hereda el nombre. 00:38:50
Hereda los métodos. 00:38:52
Los constructores no. 00:38:54
Los constructores no se heredan. 00:38:55
Hay que hacerlos específicamente. 00:38:56
Vale, los constructores no. 00:38:58
Hay que hacerles específico para el ave. 00:38:59
No se heredan. 00:39:01
Vale. 00:39:02
Hay que hacerlos específicamente. 00:39:04
Vale. 00:39:05
Pero es que pasa una cosa más. 00:39:08
Al ser animal abstracta, 00:39:10
todas las herederas de una clase abstracta 00:39:14
están obligadas, obligadas a sobreescribir los métodos abstractos. 00:39:17
Es una obligación que tienen. 00:39:23
Tiene que sobreescribir obligatoriamente 00:39:25
todos los métodos abstractos de la que hereda. 00:39:47
abstractos de la superclase. 00:39:55
Por eso se me ha puesto en rojo. 00:40:06
Y esta obligación es interesante. 00:40:08
Esta obligación te dice, tú has hecho un diseño estupendo. 00:40:10
Me has hecho una clase abstracta animal. 00:40:13
Con un método vacío para que la sobreescriban. 00:40:15
Vale, pues con eso estás generando un compromiso. 00:40:18
Estás diciendo, que me hereda el que quiera. 00:40:22
Pero ojo, el que me herede tiene la obligación y el compromiso 00:40:24
de sobreescribir los métodos que yo he dejado vacíos. 00:40:29
Lo siento. 00:40:32
Los tiene que sobreescribir. 00:40:33
Y eso está bien. 00:40:35
Porque cuando tú haces una clase abstracta, 00:40:37
para que toda la aplicación en conjunto tenga sentido, 00:40:39
tiene sentido que tú digas, oye, tú quieres ser animal. 00:40:42
Perdona, si quieres ser animal, entonces tendrás que realizar acción. 00:40:45
Si no, no lo seas. 00:40:48
Vale, no puede ser que alguien herede de ti 00:40:49
y luego quiera hacer las cosas por libre. 00:40:52
Llamando al método joven en la gana. 00:40:53
Eso genera aplicaciones un poquito incoherentes. 00:40:56
Entonces tiene sentido la idea de, 00:41:00
tú te has hecho una clase cliente. 00:41:02
Vale, muy bien, la clase cliente, 00:41:04
tú le pones un método abstracto, pagar factura. 00:41:07
Entonces, perdona, todos los clientes que hereden de aquí 00:41:10
van a tener que sobreescribir, pagar factura. 00:41:13
Y si no quieres, no heredes de cliente, hereda de otra. 00:41:16
De esta no puedes. 00:41:19
Entonces es una forma de crear una obligación. 00:41:21
Una obligación a las clases que te heredan. 00:41:23
Y eso resta libertades, efectivamente, 00:41:26
resta libertades a la hora de hacer una aplicación. 00:41:29
Porque las libertades suelen conducir a errores de ejecución. 00:41:31
Entonces, cuantas más libertades se cierren 00:41:35
en tiempo de compilación mejor, 00:41:38
pues es lo que nos dice este. 00:41:41
El compilador nos está diciendo, 00:41:43
¿qué quieres heredar de animal? 00:41:44
El compilador se va animal y dice, muy bien, 00:41:46
pero es que animal tiene un método abstracto. 00:41:49
Pues lo siento mucho, 00:41:51
pero tienes que heredarlo. 00:41:52
Antes no pasaba eso. 00:41:54
O sea, cuando no era abstracto, 00:41:56
y yo lo tenía con el cuerpo vacío, así, 00:41:57
lo tenía así, 00:42:01
y entonces esto no era abstracto, 00:42:03
al no estar marcado como abstracto, 00:42:07
no había ninguna obligación de sobreescribirlo. 00:42:10
Tú lo heredabas y lo heredabas vacío. 00:42:13
Lo heredabas vacío. 00:42:16
Entonces, aquí en ave, 00:42:18
¿vale?, 00:42:20
aquí en ave, bueno, 00:42:22
este error me sale por el constructor, 00:42:23
¿vale?, 00:42:24
por el súper, 00:42:25
pero no me sale por eso. 00:42:26
Aquí en ave, 00:42:27
vamos a ponerle un constructor para que se calle 00:42:29
y veamos que el error, 00:42:31
¿vale?, 00:42:33
como nos hemos metido con los constructores todavía, 00:42:34
¿vale?, 00:42:36
aquí en ave se me quita el error. 00:42:37
Se me quita el error y, ¿vale?, 00:42:39
tú heredas de animal, 00:42:41
si te da la gana, 00:42:42
animal no es abstracta, 00:42:43
tiene un método aquí que no tiene cuerpo, 00:42:44
pero no es lo mismo. 00:42:47
Tener un cuerpo sin código, 00:42:48
no es lo mismo que ser abstracto. 00:42:50
No es lo mismo que ser abstracto. 00:42:51
Son dos cosas diferentes. 00:42:52
No es lo mismo. 00:42:53
Entonces, la clase ave hereda esto. 00:42:54
Que lo sobrescribe, genial. 00:42:57
Que no lo sobrescribe, 00:42:59
se queda con su método vacío. 00:43:00
Lo hereda. 00:43:02
Pero si yo he cambiado el diseño, 00:43:03
lo cambio y digo, 00:43:05
no, no, espera. 00:43:06
Lo de un cuerpo vacío es una cosa muy rara. 00:43:07
Lo voy a cambiar a que sea abstracto 00:43:10
y entonces ya mi clase es abstracta. 00:43:16
Vale. 00:43:21
Pues si yo lo cambio a este modelo 00:43:23
y digo, oye, este es un método abstracto 00:43:26
y la clase es abstracta, 00:43:28
automáticamente ave ya se acabó. 00:43:29
Ya casca. 00:43:32
Porque ave ya está en la obligación 00:43:33
de sobreescribir el método abstracto. 00:43:36
No tiene que sobreescribir. 00:43:37
Lo tiene que sobreescribir y ya está. 00:43:39
Pues para eso valen los métodos 00:43:43
y las clases abstractas. 00:43:45
Para generar esa obligación, 00:43:47
para poner esas limitaciones a las herederas 00:43:48
y así forzar una coherencia. 00:43:50
Forzar una coherencia en la aplicación. 00:43:53
Que todos los clientes 00:43:55
tengan que obligatoriamente pagar factura. 00:43:57
Que todos los animales 00:43:59
tengan que obligatoriamente realizar acción. 00:44:01
¿Vale? 00:44:03
Para eso sirve. 00:44:04
Para eso sirven las clases abstractas. 00:44:05
¿Vale? 00:44:07
Venga, ahora sí que vamos a descansar aquí un poquito. 00:44:10
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
5 de febrero de 2024 - 20:19
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
44′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
180.69 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid