Saltar navegación

20250124 Interfaces_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 26 de enero de 2025 por Raquel G.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues con lo que estábamos, ¿verdad? Era con la herencia, ¿vale? 00:00:01
Entonces, realmente yo creo que todos estamos ya en el punto en el cual entendemos por qué esto tiene sentido y tiene razón de ser, ¿no? 00:00:12
Que no es un invento que se pone en otras cosas. ¿Verdad que sí? 00:00:19
No. Hola. 00:00:24
David, tú por ejemplo, ¿qué has atendido? ¿Podrías decirme una razón por la que la herencia tenga sentido? 00:00:27
Bueno, pues inténtalo 00:00:35
porque tendrás que dar charlas 00:00:38
y debe ser con tu trabajo 00:00:40
No me lo podías explicar tú, Juan 00:00:42
No, porque la hered... 00:00:48
Una, reutilizar código 00:00:52
¿Vale? 00:00:56
Efectivamente, porque tú heredas de una clase 00:00:58
y al heredar de ella o extender 00:01:00
todo lo que tenía esa clase 00:01:02
está ya en ti 00:01:04
Entonces, eso es una ventaja para el tiempo de desarrollo, ¿vale? 00:01:05
Para hacer métodos más fáciles, 00:01:11
tipo poner métodos en todas las partes de las herencias, 00:01:13
y luego meter verazas y todo eso. 00:01:18
Bueno, esencialmente, sobre todo, la ventaja de la herencia es el polimorfismo. 00:01:20
Es decir, yo tengo... 00:01:25
Le he dicho 200.000 veces. 00:01:28
Le he dicho 200.000 veces. 00:01:30
Entonces, esencialmente, la herencia es una herramienta para describir mejor la realidad que vamos a gestionar, ¿verdad? 00:01:35
Porque nuestra aplicación va a gestionar una serie de conceptos y entidades. 00:01:50
Entonces, si hacemos un diseño que los represente correctamente con sus clases, propiedades y métodos, 00:01:55
luego ya la aplicación, lo que para nosotros ahora mismo es el main solamente, 00:02:01
La aplicación va a ser mucho más sencilla de hacer, más fácil de mantener, de escalar, aumentar funcionalidades, etc. 00:02:05
Entonces, la herramienta esencialmente es un diseño para representar mejor la realidad. 00:02:13
¿Y por qué la representa mejor? 00:02:17
Porque en la realidad muchos conceptos distintos comparten una raíz común, ¿no? 00:02:19
Comparten cosas, ¿vale? 00:02:25
Un gato y un perro, pues los dos son animales. 00:02:27
Entonces, en lugar de hacer un gato y un perro por separado, hacemos una clase animal. 00:02:29
Un gato cree de esta y un perro cree de esta, pues estaremos reutilizando todo lo de animal y además estaremos particularizando. 00:02:33
Entonces, al particularizar, lo que hacemos es, todos los animales comen, pero el perro come diferente del gato. 00:02:41
Entonces, al particularizar, yo particularizo el método comer en gato y el método comer en perro. 00:02:49
¿Vale? Pero luego mi aplicación le da exactamente igual que cada clase heredera o cada subclase tenga su propia versión. A la aplicación le da igual. La aplicación, gracias a que hay una raíz común, sabe que yo puedo tener 37 animales que si todos heredan de mi raíz común animal, todos van a comer. 00:02:57
y la aplicación llamará a comer 00:03:18
y la aplicación será 00:03:20
completamente transparente 00:03:22
que luego en realidad 00:03:24
cada uno de los animales o subclases 00:03:25
lo hace a su manera 00:03:28
será completamente transparente 00:03:29
la aplicación sabe que llamará 00:03:32
al método de la superclase 00:03:33
y ya sabe que la máquina virtual 00:03:35
hará el trabajo sucio 00:03:37
es decir, vale, estás llamando al método de la superclase 00:03:38
pero yo tengo que ver 00:03:42
el objeto concreto, cuál es su propia versión 00:03:44
entonces la máquina virtual hace el trabajo sucio 00:03:46
de irse a la clase 00:03:49
concreta del objeto que ha llamado 00:03:51
al método de la superclase a ver si tiene 00:03:52
una versión suya propia 00:03:54
entonces todo ese trabajo sucio que hace la máquina virtual 00:03:56
se lo quita el desarrollador 00:03:59
porque si no el desarrollador 00:04:01
tendría que especificar en el código 00:04:02
no, estoy llamando a la versión 00:04:04
de comer de gato, a la versión de comer de perro 00:04:06
no, el desarrollador dice yo llamo a comer de la de arriba 00:04:08
de la de arriba y la máquina virtual 00:04:10
que se preocupe el objeto 00:04:12
en concreto que versión 00:04:14
propia tiene, ese es el 00:04:16
polimorfismo y eso en realidad es lo que 00:04:18
le da a esto 00:04:20
la fuerza de que nos dé 00:04:21
aplicaciones más 00:04:24
más manejables 00:04:25
y que no sean unos 00:04:28
códigos que luego a la hora de mantenerlos 00:04:30
hay una cantidad de clases que tenemos que 00:04:32
retocar por todos lados 00:04:34
vale, pero la herencia tal y como la hemos visto 00:04:36
pues tiene una pequeña 00:04:38
pega, que la herencia 00:04:40
Java es simple 00:04:42
es decir, que la herencia sea simple 00:04:44
significa que de una superclase 00:04:55
bueno, mejor dicho, que lo estoy explicando 00:04:58
que una clase 00:05:04
solo puede heredar de otra 00:05:06
el extens que acompaña a la subclase 00:05:10
el extens este de aquí 00:05:14
que acompaña a la subclase 00:05:18
solo puede tener una 00:05:20
es decir, una clase 00:05:21
solo puede tener un padre 00:05:24
solo, y ya está 00:05:25
el que le paga que eres tú 00:05:26
y el real, el biológico 00:05:30
pues aquí en Java, solo una clase 00:05:31
solo puede tener un padre 00:05:34
¿vale? 00:05:35
esto, de nuevo 00:05:38
es una limitación 00:05:39
porque a lo mejor habrá situaciones de la realidad 00:05:41
que queremos modelar 00:05:44
que yo soy a la vez una cosa 00:05:45
y soy a la vez otra 00:05:47
entonces querría heredar de las dos 00:05:48
y diríamos, vale, pues esas dos cosas que eres 00:05:51
ponlas juntas en una clase 00:05:55
pero es que entonces a lo mejor ya se pierde el sentido 00:05:56
porque estoy mezclando dos clases que no son 00:05:59
entonces, podría haber situaciones que no se pudieran representar bien 00:06:02
solamente con una estructura así 00:06:06
esta es la estructura de Java 00:06:08
de clases, uno puede hacer aquí un árbol hasta el infinito 00:06:13
un árbol hasta el infinito 00:06:16
pero al final cada una 00:06:18
solo puede dar de una, luego el árbol 00:06:20
hasta el infinito siempre va a ser 00:06:22
así, donde la clase de arriba 00:06:24
que esto es verdad que no lo he 00:06:27
dicho hasta ahora, donde la clase 00:06:28
de arriba es una clase que 00:06:30
ya existe 00:06:32
que es la clase object 00:06:33
entonces hay una clase en Java que ya existe 00:06:36
que ya está hecha, como la clase string, como la clase scanner 00:06:38
como las dos mil millones de clases 00:06:40
que está en la JRE 00:06:42
que es la clase object 00:06:43
la clase de object no tiene dentro 00:06:45
prácticamente nada 00:06:48
la podemos mirar ahora, no tiene dentro prácticamente nada 00:06:49
y cuando uno hace 00:06:51
cualquier clase 00:06:54
cualquiera 00:06:56
tiene dos opciones 00:06:57
o la deja en blanco 00:07:02
el extens y ya está, ya hace su clase 00:07:03
o hereda de algo 00:07:06
y entonces ya se mete en la jerarquía 00:07:08
heredando lo que sea 00:07:10
bueno, pues si nosotros aquí no ponemos nada 00:07:11
lo dejamos en blanco completamente 00:07:14
y no ponemos nada 00:07:16
por defecto 00:07:17
es como si hubiéramos puesto esto 00:07:19
¿vale? 00:07:22
luego, si no hay nada 00:07:28
en realidad tenemos esto 00:07:29
¿eso qué significa? 00:07:31
que cuando nosotros hacemos una clase 00:07:33
en realidad 00:07:34
esa clase ya tiene algunas cositas dentro 00:07:36
muy pocas, aunque nosotros no las veamos 00:07:39
muy poquitas, que son las de odio 00:07:41
y de hecho 00:07:43
ya lo hemos usado a veces incluso sin saberlo 00:07:45
porque nosotros 00:07:47
Hacíamos a lo mejor 00:07:49
A ver 00:07:50
Me mejor en el eclipse 00:07:51
Vale 00:08:00
¿Qué os pasa? 00:08:27
Lo meto aquí en ejemplo 00:08:30
Herencia 00:08:31
Vale, ¿se ve bien con la luz atrás? 00:08:32
Porque no se ve una caca, ¿no? 00:08:39
Ah, que está todavía arrancando 00:08:41
Está como nosotros 00:08:42
Que no acaba todavía de despertarse 00:08:45
He dicho nosotros, no he dicho vosotros. 00:08:46
Bueno, por ejemplo, voy a reutilizar este ejemplo herencia de cliente, cliente online, cliente tienda. 00:08:53
Pues nosotros la primera clase que hicimos en esta aplicación era la clase cliente y esta clase no heredaba de ninguna. 00:09:08
luego ya sí, cliente online hereda de esta 00:09:16
con lo cual tenía todo lo de cliente, sobre escribía métodos si interesaba 00:09:21
si no, no, cliente tienda también heredaba de cliente 00:09:25
luego tenía todo lo de cliente, sobre escribía métodos si le interesaba o no 00:09:28
y ya está, y con esto ya hicimos una aplicación con diferentes clientes 00:09:33
que hacían diferentes cosas, vale, esta en concreto, esta en particular 00:09:37
no hereda de nadie, con lo cual en realidad esto es como si hubiéramos puesto 00:09:41
esto. Luego, poner esto y no poner nada es la misma cosa. Entonces, efectivamente, Java 00:09:45
tiene una jerarquía de clases que es un arbolito, siempre, porque cualquier clase que yo haga, 00:09:58
cualquier clase que hagamos, si yo no pongo nada, va a heredar de esta, que es object 00:10:06
de aquí, vale 00:10:19
de la clase object hereda cualquiera 00:10:28
que yo hago más clases que no heredan de ninguna 00:10:30
pues todas heredan de object 00:10:32
todas heredan de object 00:10:34
vale 00:10:35
ahora, que hago 00:10:39
en alguna clase un stance de alguna otra 00:10:46
bueno, pues entonces se heredará de la que sea 00:10:49
que luego hago otra que en lugar 00:10:51
de heredar de object directamente hereda 00:10:54
de otra, pues bueno, esa estará metida ahí 00:10:56
donde sea, entonces 00:10:58
java 00:11:01
cualquier aplicación 00:11:04
es un arbolito de clases 00:11:06
donde la de object es la de arriba 00:11:08
si no hay herencia pues todas las demás 00:11:09
están todas abajo 00:11:12
que además estoy haciendo 00:11:13
extens de alguna de las que ya hay 00:11:16
pues estaría haciendo un nivel inferior 00:11:17
todo es un árbol así 00:11:19
entonces esto 00:11:20
a veces puede representar algunas situaciones 00:11:23
pero hay veces 00:11:26
que no lo representa 00:11:27
porque hay veces que alguna de estas clases de aquí 00:11:28
pues efectivamente tiene todo lo de esta 00:11:31
y todo lo de sus abuelos y bisabuelos 00:11:34
pero a lo mejor también querría 00:11:36
yo que tuviera lo de esta 00:11:38
y que heredara el comportamiento 00:11:39
heredara de las dos 00:11:42
pues en Java no se puede, solo puedes 00:11:43
heredar de alguna 00:11:46
entonces hay un parche 00:11:47
pero es un parche fundamental 00:11:50
para 00:11:52
salvar esto 00:11:54
salvar esta restricción 00:11:57
que son las interfaces 00:11:58
¿Vale? Son las interfaces 00:12:00
Es una cosa muy sencilla 00:12:01
Que vamos a ver simplemente ahora 00:12:03
Que es lo que tiene de fondo 00:12:05
Pero antes de eso vamos a ver un pelín y más 00:12:07
Ya que hemos sacado esto de la clase object 00:12:09
Que es la raíz de la jerarquía siempre 00:12:11
De cualquier conjunto de clases en Java 00:12:13
Vamos a ver por curiosidad que tiene 00:12:15
Esta clase object 00:12:17
Entonces recordad, esto estar o no estar 00:12:18
Es lo mismo, vale, vamos a ver que tiene object 00:12:21
Bueno, es que object hasta que la abre 00:12:23
Este 00:12:31
Uf, se está mil horas 00:12:32
Debería haberla buscado a mano 00:12:35
Igual si la busco a mano 00:12:42
Porque está en 00:12:50
Avalanche 00:12:51
Así es más rápido 00:12:51
Vale, esta es la clase object 00:13:03
Esta sí que no hereda de nadie 00:13:05
Que ya está dada 00:13:07
Y todo eso, y no tiene nada 00:13:09
Tiene un constructor 00:13:11
Sin parámetros 00:13:12
Vale, luego cuando una clase 00:13:14
cualquiera que hacemos que no era de nadie 00:13:17
nos pone automáticamente 00:13:19
el eclipse, un super sin parámetros 00:13:21
está llamando a este, que no hace nada 00:13:23
bueno, por eso decíamos cuando nos aparecía 00:13:24
loquito y ya está, porque es que no hace nada 00:13:27
claro, el super siempre es 00:13:29
constructor de la superclase 00:13:31
cuando la superclase es 00:13:33
object, pues 00:13:35
poner el super y no ponerlo es lo mismo, porque es que no me está 00:13:37
haciendo nada el constructor de la superclase 00:13:39
¿vale? 00:13:41
¿y qué tiene? pues tiene algunos 00:13:43
métodos muy chorras que hasta ahora 00:13:45
algunos los hemos usado 00:13:47
sin saber exactamente que hacían 00:13:50
getClass 00:13:52
te devuelve el nombre de la clase 00:13:54
al que pertenece ese objeto 00:13:56
este te genera 00:13:57
un código hash para ese objeto 00:14:00
que todavía no lo necesitamos pero lo necesitaremos 00:14:02
más adelante 00:14:04
y sí que hemos usado uno 00:14:04
este, ¿verdad? 00:14:07
este método lo hemos usado para objetos 00:14:09
a veces, ¿vale? 00:14:11
el método id 00:14:13
pues este método 00:14:14
Está heredado de object 00:14:16
Entonces, por ejemplo 00:14:18
Mi cliente que hereda de object 00:14:20
Da igual que yo lo ponga o no, porque hereda de object 00:14:22
Si yo 00:14:24
Ahora en mi main 00:14:26
En mi main de pruebas, este de aquí cualquiera 00:14:27
Pues tengo mi objeto cliente 00:14:34
Que es c 00:14:40
Vale, vamos a hacer un específico 00:14:40
Cliente 00:14:45
Vale, pues este objeto cliente 00:14:46
Tiene un método equals 00:14:57
Al que puede llamar 00:14:59
Vale 00:15:00
tiene un método equals al que puede llamar 00:15:02
y a este método equals al que puede 00:15:04
llamar, este método ¿cuál será? 00:15:07
en cliente no está declarado 00:15:09
entonces este método equals 00:15:11
será el que hereda automáticamente de 00:15:13
object y el que hereda de object 00:15:15
es este, el que hereda 00:15:17
de object se le puede pasar cualquier 00:15:18
objeto, el que a mí me dé la gana 00:15:20
cualquiera y me devuelve 00:15:22
un true, ¿y qué hace este equals? 00:15:24
es un equals muy básico 00:15:26
compara si la 00:15:28
dirección de memoria del objeto 00:15:31
que yo paso, es idéntica 00:15:32
a la dirección de memoria del objeto 00:15:35
que lo llamo. 00:15:37
Ya alguna vez lo hemos mencionado. 00:15:38
Si yo hago un equals entre un 00:15:41
objeto y otro objeto, 00:15:42
lo que hace el equals, 00:15:45
a menos que yo lo tenga sobrescrito en la 00:15:47
clase cliente, claro, a menos que lo tenga 00:15:48
sobrescrito. Si yo no lo tengo sobrescrito, 00:15:50
el equals, 00:15:53
la versión que usa es la heredada. 00:15:54
¿La heredada de quién? Pues de 00:15:57
object, porque cliente 00:15:58
heredada de object la heredada y la versión heredada de equals que hace pues si no se va 00:16:00
a igual a lo que hace es ver si son exactamente iguales exactamente iguales esta dirección de 00:16:07
memoria y la dirección de memoria del objeto es decir si un objeto y otro en memoria ram son el 00:16:13
mismo están uno encima del otro no sé su contenido es igual porque yo puedo tener un objeto en esta 00:16:19
dirección de memoria otro objeto en esta dirección de memoria tenerlas los mismos valores en las 00:16:24
propiedades, pero este 00:16:29
equals me daría false 00:16:31
porque uno y otro no están 00:16:32
en la misma dirección de memoria 00:16:35
bueno, pues el método equals de object 00:16:37
lo que te ofrece es eso 00:16:39
que es muy sencillo, te dice 00:16:41
oye, yo te digo que son iguales 00:16:43
si uno y otro están en la misma dirección 00:16:45
si tú quieres que la igualdad 00:16:46
sea por otras cosas 00:16:49
sea dos objetos son iguales 00:16:50
si el nombre es el mismo 00:16:53
que eso tiene más sentido, dos clientes en mi aplicación 00:16:54
son iguales 00:16:57
Si su nombre es igual 00:16:59
Eso tiene mucho más sentido 00:17:00
Este sentido no es un sentido real 00:17:02
Yo puedo tener en mi aplicación 00:17:05
Dos personas 00:17:08
Con el mismo DNI 00:17:09
Porque una la he cargado de la base de datos 00:17:11
En un momento 00:17:14
Y otra la he cargado después de otra base de datos 00:17:15
Tengo dos objetos distintos 00:17:18
Pero el DNI es igual 00:17:20
Entonces si yo llamo a este equals 00:17:22
Para ver si uno es otro 00:17:25
Me va a decir no, no, son dos personas distintas 00:17:26
la aplicación funcionaría mal 00:17:28
porque aunque esté cargada en objetos distintos 00:17:30
se refiere a la misma 00:17:32
se refiere a la misma persona, mismo DNI 00:17:34
aunque estén objetos diferentes 00:17:36
luego, en casos así 00:17:37
cuando yo ya estoy haciendo la aplicación bien, la estoy diseñando 00:17:40
bien, tendría que ver, oye, ojo 00:17:42
que el método equals 00:17:44
que heredo de object es que no me interesa 00:17:45
porque cuando yo quiera ver 00:17:48
si un cliente es igual que otro cliente 00:17:50
me va a decir false 00:17:52
aunque tenga el mismo DNI, me va a decir false 00:17:54
entonces esta versión no me interesa 00:17:56
vale, pues por eso, ¿qué hacemos a veces? 00:17:57
en la clase 00:18:01
que le dé de object, sobreescribir 00:18:02
este método 00:18:04
sobreescribir el equals 00:18:04
este de aquí, sobreescribir este 00:18:07
¿vale? 00:18:09
entonces aquí en mi aplicación, si yo quiero 00:18:11
incluir que 00:18:14
cuando tenga dos objetos 00:18:15
que vete a saber de dónde han salido 00:18:17
de dónde se han leído, de dónde se han pasado 00:18:19
si son el mismo DNI, entonces quiero 00:18:21
que la aplicación entienda que es el mismo cliente 00:18:23
porque son el mismo DNI y el mismo cliente 00:18:25
Aunque esté cargado en varios objetos distintos 00:18:27
Pues si quiero que entienda eso 00:18:29
Tengo que sobreescribir el método equals 00:18:31
¿Vale? 00:18:34
Pues sobreescribo el método equals 00:18:35
Que tiene exactamente esta cabecera 00:18:37
Sobreescribo el método equals 00:18:39
¿Veis? Me aparece aquí el verdecito 00:18:45
Y aquí ya digo 00:18:46
Oye, ¿qué quiero yo? 00:18:48
¿Cuándo quiero que me devuelva true? 00:18:51
¿Y cuándo quiero que me devuelva false? 00:18:52
¿Quiero que me devuelva true? 00:18:53
Si los dos de ne son iguales 00:18:55
Y quiero que me devuelva false si no 00:18:56
pues entonces yo aquí ya podría poner 00:18:58
return 00:19:01
dis.dni 00:19:02
igual a 00:19:04
bueno el objeto obj 00:19:06
tendría que hacer un casting 00:19:08
a cliente 00:19:11
porque yo aquí puedo mandar 00:19:12
un objeto genérico 00:19:15
pero se supone que yo quiero comparar cuando un objeto 00:19:16
sea igual a otro, luego le pasaría un cliente 00:19:19
como aquí le paso un cliente 00:19:20
este cliente de aquí 00:19:23
para ver si este es igual que este 00:19:24
Vale, entonces, me hago el casting a cliente de este objeto y ahora ya devuelvo esta igualdad, vj.dn. 00:19:27
vale, entonces 00:19:57
esto es un string y esto es un string 00:20:00
vj, no, perdón 00:20:02
esto es un string 00:20:05
que es el dni del objeto en el que estoy 00:20:09
que llama al método 00:20:11
y este es otro string, que es el dni del pasado 00:20:12
como parámetro, que lo he hecho el casting 00:20:15
para poder hacer la propia dni, porque si no hago el casting 00:20:17
no puedo hacer la propia dni 00:20:19
vale, de nuevo string 00:20:20
son objetos 00:20:23
esto ya sí que de toda la vida hacemos 00:20:24
cuando quiero ver si un string es igual que otro 00:20:26
llamamos a equals 00:20:29
y ahora ya podemos entender 00:20:30
porque en la clase string llamamos a equals 00:20:32
sino el doble igual 00:20:34
porque cuando yo quiero comparar dos cadenas 00:20:35
quiero comparar si tienen el mismo texto 00:20:38
quiero comparar si una cadena es 00:20:40
hola Pepito y hola Pepito 00:20:42
pero no quiero, me da igual 00:20:44
que estén en la misma posición de memoria 00:20:46
o que estén en distinta, me da igual 00:20:48
lo que yo quiero es comparar si 00:20:50
aquí pone hola Pepito y aquí pone hola Pepito 00:20:52
Entonces, la clase string 00:20:54
Como hereda de object 00:20:56
La clase string 00:20:58
Ha implementado su propia versión de equals 00:21:00
¿Vale? 00:21:03
Entonces, la clase string 00:21:04
Si uno la abriera por aquí 00:21:05
La clase string 00:21:08
Que está aquí abajo 00:21:17
¿Vale? Hereda de object 00:21:18
Como todas las clases del mundo 00:21:22
¿Vale? Y aparte implementa cosas 00:21:24
Pero eso ahora lo entenderemos 00:21:27
Hereda de object como todas las del mundo 00:21:28
No tiene ningún stance de nadie, pues hereda de object 00:21:30
vale, y entonces 00:21:32
su equals sería 00:21:34
el feo, el equals de 00:21:36
string sería el que te dice que 00:21:38
este string está en la misma posición de memoria 00:21:40
que el otro, el mismo, no encima de otro 00:21:43
no es el string que queremos 00:21:44
no es el equals que queremos, el equals de string 00:21:46
es, oye, quiero saber si este texto 00:21:49
es igual que este texto 00:21:51
me da igual que estén en posiciones de memoria distintas 00:21:52
pues por eso la clase string 00:21:54
tiene su propia versión de 00:21:56
equals, que estará por ahí 00:21:58
que es esta 00:22:01
¿Vale? 00:22:09
¿Ves? Sobrescribe 00:22:11
Sobrescribe 00:22:13
el equals de object 00:22:14
y lo sobrescribe diciendo 00:22:17
oye, no, yo quiero ver si todos 00:22:19
los caracteres, bueno, se hace 00:22:21
todas estas cosas raras 00:22:23
si el objeto que me pasas aquí 00:22:24
es un string 00:22:27
pues entonces haces todo esto 00:22:28
patatín, patatán y ya 00:22:30
es una versión propia suya 00:22:32
para la clase string 00:22:34
la versión suya de stream 00:22:35
vale, pues entonces 00:22:36
estábamos ahora haciéndonos nuestra 00:22:39
versión propia de equals 00:22:41
para cliente, para no tener la heredera de 00:22:43
object, bueno pues nuestra versión 00:22:45
es, oye devuélveme true 00:22:47
si el dni 00:22:49
del objeto que llama al método 00:22:51
es igual que 00:22:53
el parámetro 00:22:55
ya tengo mi versión de equals, luego otro ejemplo 00:22:56
más de por qué necesitamos 00:22:59
la herencia 00:23:01
vale, entonces el método equals 00:23:01
este es el método más usado 00:23:05
y más polimórfico del mundo, cuando tú llamas 00:23:07
a equals de un string, estás llamando a la versión de 00:23:09
la clase string, cuando llamas a 00:23:11
equals de cliente, estás llamando a este, cuando llamas 00:23:13
a equals de no sé qué 00:23:15
pero si no hubiera un equals 00:23:16
propio, pues estaríamos llamando 00:23:19
al equals este, de object 00:23:21
que compara direcciones de memoria sin más 00:23:22
entonces aquí en nuestro main de pruebas 00:23:24
¿vale? en nuestro main de pruebas 00:23:27
por ejemplo, vamos a poner 00:23:33
aquí el DNI de este cliente 00:23:34
te estás durmiendo, ¿verdad? 00:23:37
no, no, me estoy durmiendo 00:23:39
sí, te estás durmiendo 00:23:40
¿estás qué? 00:23:42
se me está quemando el cerebro 00:23:45
vale, por ejemplo 00:23:46
íbamos a comparar este cliente 00:23:52
con el DNI1, con este C 00:23:54
que estaba aquí arriba 00:23:55
que este C 00:23:57
o lo habíamos puesto a null, vamos a ponerle 00:23:58
no, el mismo 00:24:01
para ver que, vale, entonces 00:24:04
este c 00:24:06
es un objeto que está por ahí 00:24:08
con sus propiedades 00:24:10
¿vale? y este otro 00:24:11
cli es otro objeto que está por ahí con sus propiedades 00:24:14
pero los dos tienen el mismo dna 00:24:16
luego cuando yo 00:24:18
mire a ver si uno es igual que otro porque lo 00:24:20
necesita para, porque mi aplicación 00:24:22
quiere hacer la comprobación que sea lo que sea 00:24:24
porque quiero ver si hay duplicados para 00:24:26
quitar uno, si no estar, vale 00:24:28
para lo que sea, si quiere ver que uno es igual que otro 00:24:30
pues hará esto, y como tenemos 00:24:32
sobrescrito equals, pues 00:24:34
ahora aquí nos dice true. 00:24:36
Son iguales. ¿Vale? 00:24:38
Pero si no hubiéramos sobrescrito 00:24:40
el método equals aquí, 00:24:42
si no lo hubiéramos sobrescrito, 00:24:44
porque no nos hubiéramos acordado 00:24:46
de sobrescribirlo 00:24:51
y nuestra aplicación va a necesitar a veces 00:24:53
ver si un cliente es igual a otro. 00:24:55
O sea, si la aplicación no lo necesita, no es grave. 00:24:57
Pero si mi aplicación va a necesitar a veces 00:24:59
ver si un cliente es igual a otro y a mí se me ha olvidado 00:25:01
sobrescribir mi propia versión 00:25:03
de equals, la buena, 00:25:05
la que yo decida por DNI, por nombre, si se me ha olvidado, 00:25:07
ahora mi aplicación va a funcionar igual, pero me dice, no, no son iguales. 00:25:10
Vale, y yo sigo procediendo, sigo haciendo cosas sobre un supuesto falso. 00:25:15
Porque este cliente y este sí que son, son iguales. 00:25:19
Pero sin haber sobrescrito el equals me dice que son distintos, me dice falso, 00:25:23
porque este es un objeto en una dirección de memoria 00:25:27
y este es otro en otra dirección de memoria. 00:25:30
¿Está claro? 00:25:36
Vale, pues ahora entonces, gracias a la herencia, entendemos un poco más el equals de dónde sale y la importancia de sobrescribirlo en nuestras clases si vamos a necesitar ver si un objeto es igual a otro según un criterio propio. 00:25:37
Vale, string ya lo tiene sobrescrito, por eso lo usamos siempre sin más, etc. 00:25:50
Vale, todo esto venía a cuenta del object, que aunque nosotros no lo veamos y no lo sepamos, cualquier clase hereda de object y tiene todo lo de object. 00:25:55
Y si hereda de otra, también lo va a tener, porque recordad que el árbol este de herencia, si esta hereda de esta, tiene todo lo de esta. 00:26:06
Ahora, esta de aquí hereda de esta, pues tiene todo lo de esta, que a su vez tenía todo lo de la de arriba. 00:26:13
Luego cada uno tiene todo lo de su padre, abuelo, bisabuelo, etcétera, etcétera. 00:26:18
Bueno, pues todo esto venía a cuento de la clase object, que es la base de toda la jerarquía de clases, 00:26:23
que se nos quedaba 00:26:30
corto, porque puede haber clases 00:26:33
que interese 00:26:35
que adopten 00:26:37
funcionalidades de dos clases 00:26:38
distintas 00:26:43
y yo no puedo fusionarlas 00:26:43
porque por ejemplo, hay situaciones en las que sí 00:26:46
uno podría 00:26:50
a ver, que se nos ocurre 00:26:52
vale, pues imaginaos 00:26:55
un zoológico 00:26:57
en el tiempo de los robots 00:27:00
dentro de 300 años 00:27:02
entonces, claro, los robots 00:27:03
dominan el mundo y tienen su zoológico 00:27:06
donde tenemos humanos y animales 00:27:07
o sea, animales en general 00:27:10
¿vale? 00:27:11
entonces 00:27:13
los humanos y los animales no humanos 00:27:13
pues en principio 00:27:18
tienen características distintas 00:27:20
podría decir 00:27:24
entonces 00:27:25
se podría hacer 00:27:26
una clase, humanos 00:27:28
hay, pues yo que sé 00:27:30
humanos 00:27:32
no lo sé, españoles 00:27:33
franceses, alemanes, entonces para eso es una clase 00:27:36
se puede hacer una super clase 00:27:38
humano general, con todo lo que tenga 00:27:40
humano, y luego ya cada uno pues 00:27:42
mujeres, hombres, lo que sea 00:27:44
con animales igual 00:27:45
gatos, perros, caballos, una super clase 00:27:47
animal, pero a su vez 00:27:50
si dejamos la jerarquía 00:27:51
por separado pues habrá cosas 00:27:54
que comparten los dos 00:27:56
los humanos y los animales 00:27:58
pues todos tienen 00:27:59
todos comen y todos cagan 00:28:00
bueno vale pues comer 00:28:06
vale pues entonces 00:28:08
ahí 00:28:09
se podría solucionar haciendo una 00:28:11
super clase de estas dos por separadas 00:28:14
de humano y de animal 00:28:16
pues se hace una super clase que es 00:28:17
miembro del zoo por ejemplo 00:28:20
entonces se pueden solucionar 00:28:21
pero claro 00:28:23
y todos hacen todo lo que haya en miembro del zoo 00:28:24
pero podría haber situaciones que no sean fáciles 00:28:28
de solucionar así, por ejemplo 00:28:30
los robots 00:28:31
como son peores personajes 00:28:33
que nosotros, pues también meten 00:28:36
en su propio zoológico a robots 00:28:38
por ejemplo 00:28:40
entonces el zoológico de los robots del futuro 00:28:41
tiene robots 00:28:44
humanos y animales 00:28:46
¿vale? a ver que no me pierda 00:28:48
Entonces, esto es para que entiendas una situación, como puede haber tantas, en las cuales necesitas herencia múltiple, ¿vale? 00:28:51
Entonces, ¿qué ocurre aquí? Que los humanos y los robots hablan, los animales no. 00:29:01
¿Tú no sabes que los animales hablan también, no? 00:29:09
No, los del zoológico y los robots no hablan. 00:29:13
¿Los zoológicos? 00:29:15
No, esos no hablan. 00:29:16
Yo te juro que te pongo hasta los robots, sí. 00:29:17
bueno pero le ponemos directamente la parte de animalitos dóciles vale entonces qué ocurre que 00:29:19
ahí pone hacer la jerarquía con una superclase miembro del zoo pues hombre no se adapta porque 00:29:31
el método hablar vale el método de hablar pues solamente lo tienen los humanos y los robots pero 00:29:39
Sin embargo, no queremos que lo tengan los animales, 00:29:47
pero si hay cosas que tienen compartida. 00:29:50
Entonces, a lo mejor podríamos hacer una superclase 00:29:52
habladores, con todas las cosas relacionadas con hablar, 00:29:54
porque se trata de forma distinta. 00:29:59
Entonces, humanos y robots queremos que hereden de 00:30:01
habladores, pero animales no queremos que hereden de 00:30:03
habladores, porque todo relacionado con habladores es 00:30:05
mucho y no queremos que lo hereden porque es meter ahí un 00:30:07
montón de cosas que podemos luego a lo mejor usarlas por no 00:30:09
ser cuidadosos y la hemos cagado con la aplicación. 00:30:13
Entonces, esto se le dan de animal, sin más. 00:30:17
Pero a su vez queremos que todos hereden de la superclase 00:30:21
que tiene todo relacionado con comer, con cagar, etc. 00:30:23
Entonces, ¿cómo resolvemos eso? 00:30:26
Pues se queda muy complicado. 00:30:28
Entonces, ¿cómo lo resolveríamos? 00:30:30
Pues hacemos una superclase, que eso ahora lo vemos después, 00:30:31
por ejemplo, pensada en todo lo que comparten todos 00:30:35
de cara a su descripción. 00:30:41
Propiedades que todos comparten, etc. 00:30:42
Y luego ya, si alguna de esas entidades que hay abajo tienen características diferenciadas, las metemos en una interfaz, lo que se llama una interfaz, y ahora de esas subclases, las que tengan esa característica diferencial, que además, en nuestro caso, que sería hablar, todo lo de animales, pero además hablar, pues esas que implementen esta interfaz que acabo de hacer. 00:30:44
Entonces, tendría animales que heredan de, perdón, sí, gatos, perros, no sé qué, que heredan de animal, ¿vale? Luego, además, tendría humanos que heredan de animal, ¿vale? Robot no puede heredar de animal, ¿vale? Y luego tendría robot y humano que implementa habladores, ¿vale? 00:31:11
Entonces puedo flexibilizar muchísimo mi jerarquía gracias a esto de las interfaces. 00:31:33
Y decido, vale, tú le das de aquí, pero además implementas esto, 00:31:40
con lo cual tienes esto de aquí, pero te comportas de esta manera, 00:31:43
que el otro no se puede comportar así, el animal no puede hablar, 00:31:45
luego no puedo implementar esto, pero tú sí tienes lo suyo, 00:31:48
luego le das de su superclase. 00:31:51
Bueno, más o menos. 00:31:53
Yo a ti lo dibujo como si fuese un arbolito porque... 00:31:55
Sí, pero no se nota, ¿no? O sí se nota. 00:31:59
Sí, se nota un poco que me estoy perdiendo, ¿no? 00:32:03
Por eso, si quieres, dibújalo ahí con palitos y cuadraditos. 00:32:05
Sí, más que dibujarlo, vamos a poner un ejemplo ahora de cómo son las interfaces, 00:32:09
cómo se, bueno, ahora o después, cómo se programa una interfaz, 00:32:14
cómo se implementa una interfaz y cómo se usa. 00:32:18
Ya está, un ejemplito. 00:32:21
Y luego ya, sobre todo a nosotros, lo que nos importa sobre todo, 00:32:23
es que este concepto 00:32:28
de interfaces, clases y clases abstractas 00:32:32
que ya vimos el otro día 00:32:35
es sobre el que se diseña todo 00:32:35
entonces nosotros a partir de ahora 00:32:38
¿qué vamos a usar? 00:32:39
vamos a usar un montón de paquetes 00:32:41
por ejemplo, todo el que gestiona las excepciones 00:32:43
todo el que gestiona las colecciones 00:32:46
todo el que gestiona las interfaces gráficas 00:32:49
vamos a usarlo 00:32:51
pues todos esos paquetes están todos 00:32:52
metidos en una jerarquía 00:32:54
de interfaces y clases abstractas y clases 00:32:56
normales. Ahí es un sumo bollón. 00:32:58
Entonces tenemos que entender 00:33:00
cómo se usa un montón de 00:33:01
clases que tienen jerarquías entre ellas. 00:33:04
Nos interesa eso más 00:33:07
que hacer la parte 00:33:08
de diseño, que es tengo una situación 00:33:10
que diseño me 00:33:12
queda bien, que no sé qué, más que eso. 00:33:14
Sobre todo lo que nos interesa es entender 00:33:16
cómo poder usar un montón de clases 00:33:18
que están relacionadas de esa manera, como las 00:33:20
excepciones, colecciones, etc. 00:33:22
¿Entendido? 00:33:25
Pues hala, idos a comer que es lo que más os gusta hacer 00:33:26
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
17
Fecha:
26 de enero de 2025 - 19:24
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
384.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid