Saltar navegación

20260116 Herencia_Object - 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 19 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, a ver, entonces, con lo que hemos visto de herencia hasta ahora, ya sabemos que las clases Java de una aplicación 00:00:00
pueden relacionarse con relaciones de herencia construyendo una jerarquía, ¿vale? 00:00:07
La idea no es que en los diseños aparezcan jerarquías complejas, porque ya se pierde un poquito la perspectiva del asunto, 00:00:16
pero sí que haya relaciones de herencia entre clases puntualmente, sí que facilita bastante las cosas. 00:00:24
En cualquier caso, como la herencia en Java como tal es simple, es lo que se llama herencia simple, 00:00:32
¿y qué significa simple? Que cada clase sólo puede heredar de otra, sólo, o sea, esto no existe, esto no se puede dar, 00:00:38
cada clase sólo puede heredar de otra, pues la estructura que tenemos siempre son árboles de este tipo. 00:00:46
Vale, y de hecho tanto es así que si yo tengo una clase cualquiera, una clase cualquiera, si no pongo que herede, por ejemplo, imaginaos que tenéis una aplicación con tres clases que no están relacionadas entre sí, esta es una clase C1, clase C2, clase C3, cliente, producto, pedido, no tienen relaciones de herencia entre sí, ¿vale? 00:00:54
Bueno, pues las clases que no tienen ninguna superclase, que no tienen ninguna, Java supone que por defecto heredan de otra clase que existe, que ahora la abriremos y la veremos, que ya existe, que está hecha, que se llama Objeto. 00:01:18
Entonces, todas las clases 00:01:41
Si no heredan de ninguna 00:01:45
Es decir, si aquí no hay un 00:01:47
Extents de lo que sea 00:01:48
Si no heredan de ninguna, heredan por defecto 00:01:50
De esta clase 00:01:53
Que ya existe, es una clase pequeñita 00:01:54
Que en realidad tiene muy poca cosa dentro 00:01:57
Pero si yo tengo 00:01:58
Estas tres clases en mi aplicación 00:02:00
Las tres 00:02:02
Heredan de object sí o sí 00:02:04
Y luego otra cosa es que además haga más clases 00:02:06
Que hereden de estas 00:02:09
Bueno, pues si las he hecho 00:02:10
ya tengo el arbolito 00:02:13
ya tengo el árbol 00:02:17
siempre, siempre hay un 00:02:18
nodo único raíz de todo 00:02:21
siempre, que es la clase 00:02:23
object, siempre es el nodo 00:02:26
único raíz de cualquier 00:02:27
estructura de clases y todas 00:02:29
aquellas que no tengan un extens 00:02:31
específico, todas las que no lo tengan 00:02:33
heredan de object 00:02:36
entonces object es una clase que se puede 00:02:36
instanciar, lo que pasa es que tiene muy 00:02:40
poco dentro 00:02:41
uno puede hacer un new object 00:02:42
e instanciar 00:02:45
una clase object 00:02:49
esto se puede hacer 00:02:50
entonces estamos instanciando un objeto 00:02:53
de esta clase que ya existe en Java 00:02:55
que está en toda la librería 00:02:56
que nos ofrece la JRE 00:02:59
pero que tipo de objeto es este 00:03:00
es un objeto muy básico 00:03:02
que no tiene espacio 00:03:04
para nada dentro en realidad 00:03:06
pero representa la idea de objeto 00:03:08
esa idea la representa 00:03:10
porque es una referencia 00:03:12
o es una referencia 00:03:14
que me apuntaría a un espacio en memoria 00:03:16
entonces bueno 00:03:18
le da cierta semántica 00:03:20
cierto significado a todo esto 00:03:21
porque cualquier cosa 00:03:23
al heredar de object es como decir 00:03:24
cualquier cosa es un objeto en realidad 00:03:27
¿vale? 00:03:29
entonces ¿de qué nos sirve? 00:03:32
además ¿de qué nos sirve? 00:03:33
que todas las clases hereden de object 00:03:35
bueno porque object 00:03:38
nos ofrece unos métodos 00:03:40
Que ahora los veremos 00:03:41
Que nosotros ya podríamos usarlos tal cual 00:03:43
Si queremos 00:03:45
Es decir, cuando nosotros hacemos una clase nuestra 00:03:46
Clase 1 00:03:49
Sin más 00:03:52
Una clase normal, sin ningún extensa aquí 00:03:53
Sin ninguno 00:03:55
En realidad esta clase ya tiene muchas cosas 00:03:56
Aunque aquí esté vacío, aunque aquí no haya nada 00:03:59
Ya tiene muchas cosas 00:04:01
Porque esto 00:04:03
Implícitamente 00:04:05
Hereda de object 00:04:06
Aunque no esté puesto 00:04:09
implícitamente hereda, aunque no esté puesto 00:04:10
entonces una clase que hagamos 00:04:13
con llavecitas y sin más 00:04:14
ya tiene cosas dentro 00:04:17
aunque nosotros no lo veamos 00:04:18
¿y qué tiene dentro? lo que tiene object 00:04:20
que son algunos métodos 00:04:22
de los cuales el que nos puede sonar ahora 00:04:24
y que más nos importa 00:04:26
es el método toString 00:04:28
ahora lo vemos 00:04:30
entonces 00:04:34
todos los objetos 00:04:36
pueden llamar a toString, aunque no lo hayamos puesto 00:04:38
aquí, ¿por qué? 00:04:41
Porque lo han heredado de object. 00:04:42
Lo que pasa es que la versión del toString heredado 00:04:45
es una versión que te pone nada. 00:04:48
Una cosa muy fea. 00:04:50
Por eso lo que solemos hacer es sobrescribirlo. 00:04:51
El heredado. 00:04:54
¿Vale? 00:04:55
Y como toString algún método más. 00:04:56
Entonces, si lo... 00:05:00
Vemos aquí. 00:05:03
Ahora. 00:05:07
Por ejemplo, 00:05:10
En nuestra clase está 00:05:21
A ver 00:05:23
Voy a abrir herencia ejemplos 00:05:25
Por ejemplo 00:05:28
Teníamos aquí el cliente normal 00:05:29
Cliente yo no he puesto 00:05:31
Que herede de nadie 00:05:35
Entonces no ponerlo 00:05:36
Es equivalente a todos los efectos 00:05:39
Equivalente 00:05:42
A poner esto 00:05:42
¿Vale? 00:05:45
Es decir, cualquier cosa 00:05:49
Hereda de object 00:05:51
Si es que no hereda de ninguna otra 00:05:52
que a su vez heredará de object 00:05:55
si es que no le da ninguna otra 00:05:56
entonces esto está siempre por defecto 00:05:58
no tenemos que ponerlo 00:06:01
está siempre por defecto 00:06:02
entonces al heredar de object 00:06:04
ya esta clase se llena 00:06:05
de las cosas que tiene object 00:06:07
además de las que le hagamos específicamente 00:06:09
¿y qué cosas tiene object? 00:06:12
vamos a buscar esta clase 00:06:14
porque nosotros cuando 00:06:15
hacemos un proyecto 00:06:18
aparte de las clases nuestras 00:06:20
ya hay un montón más de clases hechas 00:06:23
que podemos usar 00:06:25
que son las que están aquí 00:06:26
¿veis? o sea este es mi proyecto 00:06:28
mi proyecto de aquí 00:06:33
el de herencia ejemplos, vale 00:06:36
mi proyecto tendrá 00:06:38
las clases 00:06:40
que yo he hecho 00:06:42
que son estas, estas tres porque las he hecho yo 00:06:43
pero es que además de estas clases 00:06:47
tiene todas las que están 00:06:49
en estos hard 00:06:51
de aquí 00:06:52
En estos paquetes 00:06:54
¿Vale? Esto es como si se hiciera 00:06:58
Un agregar 00:07:01
JAR externo 00:07:03
Como lo hicimos nosotros para la clase teclado 00:07:04
Pues en realidad cuando se crea un proyecto 00:07:06
Es como si se agregaran tropecientos mil 00:07:09
JAR externos 00:07:11
Que están aquí en la máquina virtual 00:07:12
Que están aquí 00:07:14
En la JRE 00:07:15
¿Vale? Es decir, cuando uno tiene 00:07:17
Instalado en su ordenador 00:07:20
La máquina virtual de Java 00:07:22
No hablo del JDK 00:07:24
con el que tú desarrollas, escribes código 00:07:26
y compilas, no hablo de eso 00:07:28
ni de Eclipse, cuando tú tienes 00:07:30
la máquina virtual de Java 00:07:32
que es la que es capaz de ejecutar 00:07:34
código Java, la máquina virtual de Java 00:07:36
además del propio 00:07:38
proceso que se lanza 00:07:40
para ejecutar el código Java, además de eso 00:07:42
tienes un montón de clases 00:07:44
que cualquier aplicación necesita 00:07:46
y que por tanto no las hacemos 00:07:48
nosotros, vale 00:07:50
como la clase System.out que es una clase 00:07:52
que llama al método println 00:07:54
la clase scanner 00:07:56
que cualquier la necesita 00:07:57
o sea, estamos usando 00:07:59
en cualquier aplicación nuestra 00:08:00
usamos un montón de clases 00:08:02
que no hemos hecho 00:08:04
nosotros y todo el mundo 00:08:05
¿vale? 00:08:06
como ejemplo, repito 00:08:08
veamos, scanner 00:08:09
entonces 00:08:10
cuando yo doy mi aplicación 00:08:11
a cualquiera 00:08:13
ese cualquiera lo ejecuta 00:08:14
en su máquina virtual 00:08:16
y le funciona 00:08:17
¿por qué? 00:08:18
porque la máquina virtual 00:08:19
entrega esas clases 00:08:20
que mi aplicación usa 00:08:22
que son comunes 00:08:24
para todo el mundo 00:08:25
Bueno, pues esas clases están aquí 00:08:25
¿Vale? Esas clases 00:08:28
Están aquí, no las he hecho yo 00:08:30
Están aquí metidas en mi ordenador 00:08:32
Y el Eclipse las agrega 00:08:34
Como Hards exactamente 00:08:36
Igual que nosotros agregamos nuestro Hard 00:08:38
Teclado cuando hicimos la prueba 00:08:40
Pues cuando hacemos un proyecto Eclipse 00:08:41
Él automáticamente 00:08:44
Agrega todos estos 00:08:46
Hards que tienen todos estos paquetes 00:08:48
¿Veis? Esto es un Hard 00:08:50
Este botecito de aquí es un Hard 00:08:51
Que tiene todos esos paquetes dentro 00:08:54
Y así tengo para aburrir 00:08:55
Tengo la leche 00:08:58
¿Vale? 00:08:59
Todo esto de aquí 00:09:03
Que cuelga de 00:09:04
Aquí, todos son hard 00:09:08
Todo, todo, que están en mi 00:09:10
Ordenador, y dentro de esos 00:09:12
Hard tengo clases, que son las 00:09:14
Que se supone que usamos todos 00:09:16
Básicas para programar 00:09:17
Que no las tenemos que hacer 00:09:19
Porque ya las da la máquina virtual 00:09:21
¿Vale? 00:09:23
Bueno, pues en todos estos hard 00:09:24
Que dentro tienen un montón de paquetes con clases 00:09:26
Repito, tenemos escáner, tenemos de todo 00:09:28
Entre ellas tenemos la clase 00:09:31
Object, ¿vale? 00:09:33
Por ejemplo, la clase object si la buscamos 00:09:34
A mano, la clase object 00:09:36
Estará 00:09:38
En java lang casi seguro 00:09:40
Aquí, object, ¿vale? 00:09:43
O sea, esta es la clase object 00:09:50
De la que hereda cualquier 00:09:51
Clase que yo no le ponga específicamente 00:09:53
Una super clase 00:09:56
Y ahora esta clase si la abrimos para ver qué es lo que entrega el resto del mundo, pues entrega muy poca cosa, ¿vale? 00:09:56
Entrega un constructor sin parámetros que nos hereda, pero que podemos utilizar nosotros con super sin parámetros, que en realidad explícitamente se asume que se pone, aunque no lo pongamos nosotros. 00:10:06
entrega este método 00:10:20
que ahora mismo nos sería relativamente complicado 00:10:23
entender, en segundo lo entenderemos 00:10:25
¿vale? porque implica 00:10:27
genéricos y demás rollos 00:10:29
entrega este 00:10:30
que este sí que vamos a 00:10:33
explicar por qué es interesante 00:10:35
que esté aquí, porque está relacionado 00:10:37
con los códigos de hash de las 00:10:39
estructuras 00:10:41
el hash set, que es así que las tenemos que ver 00:10:42
claro 00:10:45
¿Qué más métodos entrega? 00:10:45
Lo que es native 00:10:51
¿Eh? 00:10:51
Nativo 00:10:53
Que tira del software de tu equipo 00:10:53
Para generar el código hash 00:10:59
El código nativo en general 00:11:01
Es código que necesita ejecutar 00:11:02
Código máquina de tu sistema operativo 00:11:05
¿Vale? 00:11:08
Que no es independiente de tu sistema operativo 00:11:08
Sería el nativo 00:11:10
El que trae tu sistema operativo 00:11:12
Entonces 00:11:13
Eso significa que tiene que hacer una llamada 00:11:13
a tu sistema operativo 00:11:15
para ejecutar código propio de tu equipo 00:11:17
en este caso para generar ese 00:11:19
hash, ese código de hash 00:11:21
el código 00:11:23
no nativo es el código que está 00:11:26
hecho en un lenguaje de programación que es independiente 00:11:27
de la máquina, que no tiene que llamar a 00:11:29
funciones propias de la máquina 00:11:31
más o menos 00:11:33
¿Para hacer un método de pillar 00:11:34
MIT o así? 00:11:37
¿Utilizaría el MIT? 00:11:38
Si hiciera un método 00:11:41
A ver, es la idea 00:11:42
En este ejemplo que me pones exactamente 00:11:45
No creo, porque lo harías 00:11:47
A través de otra cosa, de un socket 00:11:49
Pero bueno, más o menos es la idea 00:11:51
Quédate con que código nativo 00:11:53
Es lo que está hecho 00:11:55
Específicamente para tu máquina 00:11:57
Y el no nativo 00:11:59
Quédate más o menos con esa idea 00:12:01
Vale 00:12:02
Entonces 00:12:04
¿Qué ofrece? 00:12:06
Bueno, el equals 00:12:09
vamos a clonar 00:12:10
no nos interesa por ahora, estábamos buscando 00:12:15
el toString, este 00:12:18
¿qué ofrece? ofrece un método 00:12:19
toString, eso es lo que 00:12:22
ofrece object, ofrece 00:12:24
un método toString, pero 00:12:26
el método toString lo que te devuelve 00:12:27
es un 00:12:29
getClaseName que os digo ahora 00:12:31
porque este método no lo podemos entender todavía 00:12:34
que te da el nombre de la clase 00:12:35
una arroba y luego 00:12:37
después de la arroba te ofrece 00:12:39
un numerito entero 00:12:42
sacado del código hash 00:12:43
o sea un toString que en realidad 00:12:46
no te da ninguna información sobre el objeto 00:12:48
no te dice nada interesante este toString 00:12:49
entonces yo podría 00:12:52
utilizar este toString directamente 00:12:54
desde cliente si es que no tengo uno específico 00:12:56
aquí por ejemplo en cliente 00:12:58
no tengo ningún 00:13:00
toString, pero yo puedo usar 00:13:02
la llamada toString si me da la gana 00:13:04
porque la ha heredado de object 00:13:06
entonces vamos a hacernos un 00:13:07
main aparte solamente para 00:13:09
pruebas con esta cosita 00:13:12
de object 00:13:14
porque otras clases lo van a necesitar 00:13:14
entonces 00:13:22
alguna versión tiene que tener, ahora volvemos con eso 00:13:22
vale, entonces 00:13:25
me voy a hacer aquí un main2 00:13:27
cualquiera 00:13:32
entonces yo me voy a instanciar aquí 00:13:32
un objeto cliente 00:13:35
un objeto cliente c 00:13:36
igual a new 00:13:42
cliente, vale 00:13:44
Como está en otro paquete, pues tengo que hacer el import 00:13:47
O poner el nombre completo 00:13:49
A elección 00:13:51
Vale, ahora 00:13:53
Cliente, tal y como yo lo he hecho 00:13:54
Este stents como 00:13:57
Lo quito porque que esté y que no esté 00:13:58
Es lo mismo 00:14:01
Esta clase cliente no tiene 00:14:01
Ningún método toString, no lo tiene 00:14:05
Yo no se lo he hecho, no lo tiene 00:14:07
Pero como lo hereda de object 00:14:08
Que object sí que lo tiene 00:14:11
Pues lógicamente c 00:14:12
Puede llamar a toString 00:14:15
Y no pasa nada 00:14:16
Voy a mostrar 00:14:18
Aquí el resultado de tu string 00:14:21
Lo hago en una línea separada 00:14:23
Para que se vea más claro 00:14:25
Y ahora puedo mostrar aquí 00:14:26
Vale, entonces, ¿por qué me hayan dejado 00:14:28
Llamar a un método tu string 00:14:35
Si cliente, cliente 00:14:36
No tiene ese método? 00:14:38
Porque cliente hereda de object 00:14:40
Y object lo tiene 00:14:42
Pero claro, object tiene una versión de tu string 00:14:44
Que 00:14:46
Que lógicamente 00:14:48
No sabe nada del objeto 00:14:50
Tiene una versión de toString muy random 00:14:52
Y además random nunca mejor dicho 00:14:54
Porque el hashCode 00:14:57
Utiliza una semilla aleatoria además 00:14:58
Así que 00:15:01
Entonces si yo ejecuto este main2 00:15:02
Pues me saca esto 00:15:04
Que esto es la salida 00:15:15
Del toString de object 00:15:17
El nombre de la clase 00:15:18
Una arrobita y un número random 00:15:20
Porque eso es lo que tiene el toString de object 00:15:23
el nombre de la clase 00:15:25
una arrobita 00:15:27
y un número aquí random 00:15:28
pues esto es lo que me saca 00:15:30
claro, nosotros 00:15:33
nos gusta este toString 00:15:35
pues no nos gusta, entonces por eso 00:15:36
lo que solemos hacer es 00:15:39
sobreescribirlo en la clase cliente 00:15:40
entonces 00:15:43
nosotros podemos hacer toString 00:15:45
que además este por ser un método 00:15:46
importante nos lo hacía solo el Eclipse 00:15:49
si queremos 00:15:51
y ala, ya tengo el toString 00:15:52
sobrescrito. Y como veis 00:15:57
el Eclipse, como le gusta que 00:16:00
programemos bien, me ha 00:16:02
metido la anotación overwrite 00:16:04
para 00:16:05
permitirme validar que eso es un 00:16:07
método sobrescrito. ¿Qué es 00:16:10
obligatoria la anotación? No es obligatoria 00:16:11
la anotación. La anotación me 00:16:14
vale como aviso de que es un 00:16:16
método sobrescrito de la superclase. 00:16:18
No es obligatoria. 00:16:20
Pero es muy buena práctica 00:16:22
por lo que dijimos el miércoles. 00:16:23
Esto no. 00:16:26
mantener la 00:16:27
anotación 00:16:30
porque así 00:16:32
si yo me equivoco y se me va aquí el dedo 00:16:34
y se me va el dedo 00:16:36
ahí y me equivoco 00:16:38
el que exista la anotación 00:16:39
hace que el compilador diga 00:16:41
cuidado que este método es imposible 00:16:43
que sea sobrescrito porque no existe 00:16:46
arriba, no existe 00:16:48
si yo no tuviera puesta la anotación 00:16:49
traga con todo 00:16:52
ah, que haces un método tu string, jijir 00:16:56
vale, pues toString jiji 00:16:58
pero no queremos hacer un método 00:16:59
toString jiji, sino que queremos sobreescribir 00:17:02
el de arriba 00:17:04
entonces, por eso, si nuestra intención 00:17:04
es sobreescribir 00:17:08
mantengamos la anotación 00:17:09
si nuestra intención es sobreescribir 00:17:11
vale, entonces ahora 00:17:13
respondiendo a tu pregunta 00:17:16
¿y por qué 00:17:20
object te ofrece ya un toString? 00:17:22
¿qué sentido tiene que te ofrezca un toString? 00:17:24
si lo que te ofrece es un código 00:17:26
tan feo que tú lo vas a 00:17:29
tener que sobreescribir 00:17:31
bueno, porque 00:17:32
el método toString es un método 00:17:35
que llaman muchísimas clases 00:17:37
de Java para hacer cosas 00:17:39
por ejemplo, la clase System.out 00:17:43
la clase System.out 00:17:45
cuando le pasamos un objeto 00:17:48
si yo le paso c 00:17:50
yo le paso un objeto 00:17:52
pues este es un ejemplo 00:17:53
en el cual System.out 00:17:56
¿qué hace? 00:17:58
si entráramos en el código de System.out 00:17:59
que este es el método estático 00:18:01
println de la clase System.out 00:18:03
ahora ya podemos entender esto 00:18:06
es la llamada al método println de esta clase 00:18:07
que tiene este nombre raro porque es especial 00:18:10
pero bueno 00:18:11
entonces, si entramos en el código de este método 00:18:12
veremos que lo que hace es 00:18:15
coge esto que hay aquí 00:18:16
si es una variable primitiva la muestra tal cual 00:18:18
si es una variable objeto 00:18:21
llama a tu string 00:18:23
entonces, hombre 00:18:24
vamos a meter un mecanismo 00:18:26
para asegurarnos de que todo el mundo 00:18:29
del mundo mundial 00:18:31
haga la clase que haga, la va a hacer con un 00:18:32
tuestrin, vamos a asegurarnos 00:18:35
porque el tuestrin lo va a llamar 00:18:37
mucha gente, entonces es una 00:18:39
herramienta, es una 00:18:40
forma de asegurarnos de que todo 00:18:42
el mundo va a incluir el tuestrin en sus clases 00:18:45
pues la forma de asegurarnos 00:18:47
de que todo el mundo va a incluir un tuestrin en sus clases 00:18:49
aunque tú no lo pongas 00:18:51
es ponerlo en object y decir, a mí me da igual 00:18:52
cómo programe la gente, sé que cualquier objeto 00:18:55
del mundo, cualquiera va a tener 00:18:57
tu stream. Otra cosa es que lo tenga 00:18:59
con código feo, pero lo va a tener. 00:19:01
¿Vale? 00:19:04
Ok, o sea, es un método 00:19:05
tan usado. 00:19:07
Claro, que ya desde la 00:19:08
superclase lo entregas 00:19:11
para que todos lo tengan en la versión 00:19:12
básica que puede hacer Object, que es nada. 00:19:14
Pero al menos no te va a 00:19:17
dar error 00:19:19
en el desarrollo, porque todo el mundo 00:19:19
tiene ese método. 00:19:23
La idea es acomodar ciertos patrones de diseño que todos 00:19:25
sigamos. 00:19:28
Pues, todos son toString porque lo llamamos todos. 00:19:28
Pues, entonces, en object, ¿vale? 00:19:31
Entonces, si yo no tengo aquí este método, 00:19:40
no tengo el toString en cliente, no lo tengo, 00:19:45
aquí no hay ningún problema. 00:19:49
Este va a seguir llamando al toString. 00:19:51
System.out va a llamar a toString. 00:19:55
Ningún problema porque lo tiene. 00:19:57
Pero me muestra 00:19:58
Pues esta cosa rara 00:20:00
¿Vale? Porque ha llamado al toString de object 00:20:03
Pero si yo sí que tuviera 00:20:05
Un toString sobrescrito en cliente 00:20:07
Ahora este código main 00:20:11
Pues ya me hace algo más bonito 00:20:13
¿Vale? 00:20:16
Claro, en este caso sería un error ya de compilación de partida 00:20:35
Porque te diría 00:20:38
Oye, que cliente no tiene toString 00:20:39
Aquí el compilador no te puede decir eso 00:20:41
porque te dice, a ver, 00:20:43
C es cliente, pero también es object. 00:20:45
Con lo cual, tú no lo tienes, pero está heredado. 00:20:47
O sea, sí que lo tienes en realidad. 00:20:49
Sí que lo tienes, aunque no lo veas. 00:20:51
Y también hay otro método, 00:20:59
es el segundo con el que nos... 00:21:00
El único, segundo y último, 00:21:02
en el que por ahora nos metemos de object, 00:21:04
que es este de aquí que acabamos de ver 00:21:06
que nos ha gustado 00:21:08
porque lo usamos todo el rato en realidad. 00:21:10
Este. 00:21:14
El equals nos suena, 00:21:16
que sí, es un método que estamos usando 00:21:18
a menudo, pero nunca jamás 00:21:20
hemos nosotros programado 00:21:22
un equals 00:21:24
¿vale? claro, no lo hemos programado 00:21:24
porque lo heredamos de object 00:21:28
entonces 00:21:29
a ver, esto es importante 00:21:30
vamos a intentar 00:21:33
ir despacio y entenderlo 00:21:34
¿vale? venga, vamos a ponerlo aquí 00:21:38
bueno, pues 00:21:40
la igualdad de objetos 00:21:46
sigue los mismos criterios 00:21:48
que la igualdad de 00:21:50
Cadenas string 00:21:51
Que ya la vimos en su momento 00:21:53
Porque los string son cadenas 00:21:55
Entonces recordad 00:21:57
Recordáis que nosotros decíamos 00:21:58
Pues yo tengo una cadena 00:22:00
String S1 00:22:03
Igual a hola 00:22:08
¿Vale? 00:22:11
Tengo 00:22:12
String S2 00:22:13
Igual a 00:22:15
Adiós 00:22:17
¿Vale? 00:22:19
Entonces 00:22:20
Ahora si muestro aquí 00:22:21
Igual 00:22:24
Para comparar cadenas 00:22:27
Las comparamos así, ¿verdad? 00:22:31
Las comparamos 00:22:36
S1 igual a S2, perdón 00:22:36
Las comparamos así 00:22:38
Entonces, esto me dará 00:22:41
False, ¿vale? 00:22:43
Ahora 00:22:49
Voy a cambiar a S2 00:22:49
Y le voy a poner a hola 00:22:53
Y ahora, uy, ahora esto me dará true, ¿verdad? 00:22:58
Vale. 00:23:14
Y así es como comparamos cadenas, ¿verdad? 00:23:15
Porque si las comparáramos así, ¿vale? 00:23:20
Es que él usa un buffer, es que estaba buscando un ejemplo en el que hasta 1024 cadenas, 00:23:33
él cuando ve dos cadenas iguales las pone bajo la misma referencia. 00:23:39
Pero eso solo aplica en los casos en los que no lo estás pasando como parámetro. 00:23:43
entonces, vamos a instanciarlas 00:23:46
las cadenas bien para que esto no ocurra 00:23:49
vale 00:23:51
vale, entonces 00:23:53
a ver 00:23:56
vale, entonces 00:24:01
lo que he retocado aquí 00:24:09
lo que he retocado aquí 00:24:11
es la forma real 00:24:13
lo que hace Java en la forma real 00:24:15
en la cual uno instancia un objeto 00:24:17
lo que pasa es que Java nos permite 00:24:20
lógicamente 00:24:21
nos permite 00:24:22
esto 00:24:24
esto de aquí 00:24:26
por comodidad 00:24:31
como los string 00:24:31
los usamos tantísimo 00:24:32
pues java 00:24:33
nos permite 00:24:35
el atajo 00:24:35
de instanciar 00:24:37
un objeto 00:24:38
de la clase string 00:24:39
de instanciarlo 00:24:40
poniendo ahí 00:24:41
lo que sea 00:24:42
con comillas 00:24:42
¿vale? 00:24:43
nos permite este atajo 00:24:44
pero realmente 00:24:45
lo que está haciendo 00:24:46
es instanciar 00:24:47
un objeto 00:24:48
de la clase string 00:24:48
entonces lo que realmente 00:24:49
está haciendo 00:24:51
es esto 00:24:51
entonces yo lo puedo hacer 00:24:52
específicamente 00:24:54
si quiero 00:24:54
lo puedo hacer 00:24:55
específicamente 00:24:56
¿Vale? Con esto estoy instanciando 00:24:56
Un objeto de la clase string 00:24:59
Y al constructor de string 00:25:00
Ya le paso la propiedad 00:25:03
De ese objeto que es esto 00:25:05
Y en mi instanción string con ese valor de 00:25:07
¿Vale? Pero repito 00:25:08
Esto es lo que se abrevia 00:25:11
Si yo hago así 00:25:13
O se abrevia 00:25:14
Si yo hago así ¿Vale? 00:25:16
Por eso normalmente lo hacemos abreviado 00:25:20
No usamos todo esto 00:25:22
Lo que pasa es que yo lo voy a hacer específicamente 00:25:23
Para que se escape de un buffer 00:25:26
Y lo veamos más claro 00:25:29
A ver, dejadme probar un segundito 00:25:30
Vale, ahora ya sé 00:25:35
Vale, entonces 00:25:37
Yo tengo aquí mis dos cadenas 00:25:39
Está claro que aquí me va a dar 00:25:43
S1 equals S2 00:25:46
Falso 00:25:47
Perdón 00:25:48
Vale, tengo estas dos cadenas 00:25:50
Hola y adiós 00:25:53
Me da falso, lógicamente 00:25:55
Ahora, S2 00:25:56
Le asigno hola 00:25:58
Le cambio su valor, le asigno hola 00:26:01
A este objeto S2 que yo tengo aquí instanciado 00:26:02
Le asigno hola 00:26:04
Voy a compararlos ahora, S1 con S2 00:26:05
¿Vale? 00:26:08
Y voy a compararlos de estas dos maneras 00:26:10
De la buena 00:26:12
Con el equals 00:26:13
Y de la mala que uno podría hacer 00:26:15
Si escribe muy rápido 00:26:17
Y mete la pata 00:26:18
Que es S1 es igual a S2 00:26:21
bueno, pues si ejecutamos esto 00:26:24
lógicamente 00:26:27
de la manera buena 00:26:29
me ha salido true, porque aquí 00:26:30
¿qué está comparando? el equals compara 00:26:33
que el contenido que tiene 00:26:35
S1 sea igual que 00:26:37
el contenido que tiene S2 00:26:39
¿pero qué comparamos con esto? 00:26:41
la dirección de memoria 00:26:43
en la que está la cadena S1 es igual 00:26:45
que la dirección de memoria en la que está la cadena S2 00:26:47
no, S1 es un objeto 00:26:49
y S2 es otro objeto 00:26:52
entonces esto es 00:26:54
falso, porque son dos objetos distintos 00:26:57
otra cosa es que su contenido 00:26:59
sea el mismo, su contenido 00:27:01
lo es, porque 00:27:03
lo que mira es el contenido 00:27:05
esto es lo que hemos visto 00:27:07
con string, con lo que hemos 00:27:09
dicho de toda la vida 00:27:11
pues con cualquier otro 00:27:13
objeto sería igual 00:27:15
entonces, vámonos ahora a nuestro cliente 00:27:16
resulta que mi 00:27:20
aplicación 00:27:21
Pues, normalmente a las aplicaciones les ponemos un criterio de igualdad entre entidades, ¿vale? Es decir, una clave primaria. El concepto de clave primaria en las bases de datos es natural porque lo usáis y es imprescindible, no es imprescindible, pero recomendable. 00:27:22
El concepto de clave primaria como tal 00:27:39
En los lenguajes de programación no está 00:27:43
Pero es una idea que yo tengo que poner 00:27:45
Desde fuera, de alguna manera 00:27:47
Por ejemplo, aquí 00:27:49
Sería lo normal asumir 00:27:50
Que dos clientes del mismo NIF 00:27:53
Son el mismo 00:27:55
Tendría sentido, ¿vale? 00:27:56
Por significado real de mi aplicación 00:27:59
Todo por significado, no es que Java 00:28:01
Me obligue 00:28:02
Tendría sentido, ¿vale? 00:28:04
No tendría sentido pensar 00:28:07
que dos clientes con el mismo nombre son el mismo. 00:28:09
No, se pueden llamar igual. 00:28:11
Pero que dos clientes con el mismo 00:28:13
NIF son el mismo, sí. 00:28:15
Lo que pasa es que puede ser que el cliente 00:28:18
a lo mejor se haya registrado 00:28:19
dos veces con nombres 00:28:20
distintos y podría 00:28:23
haber dos objetos con el 00:28:25
mismo NIF y nombres distintos. 00:28:27
Entonces, 00:28:31
hombre, sería interesante que mi aplicación 00:28:31
de alguna manera 00:28:33
fuera capaz de ver si un 00:28:34
objeto es el mismo que el otro, 00:28:37
es igual que el otro, porque si lo es 00:28:39
yo interpreto ya que es una dúplica 00:28:41
ignoro uno o lo que sea 00:28:43
vale, pues entonces 00:28:44
desde el momento en que yo 00:28:46
asumo un criterio 00:28:49
de igualdad 00:28:51
en mis entidades 00:28:52
lo tengo que reflejar de alguna manera 00:28:54
porque si no, ¿cómo sé 00:28:57
si un objeto es igual a otro? 00:28:59
por ejemplo, vamos a hacer aquí en mi main2 00:29:01
vamos a hacer 00:29:03
dos clientes 00:29:05
Igualdad de objetos 00:29:09
Vamos a hacernos aquí dos clientes 00:29:13
Entonces aquí aparece un cliente porque uno se ha registrado 00:29:16
Cliente C1 se ha registrado 00:29:18
Y este cliente C1 se ha registrado 00:29:21
Con el nombre 00:29:26
Se ha registrado, pues con el nombre Luis 00:29:28
Y este cliente C1 se ha registrado 00:29:34
Con el NIF 00:29:40
1, 2, 3, 4 00:29:42
ahora esta aplicación 00:29:46
que es una aplicación distribuida 00:29:49
que se ejecuta en cualquier momento 00:29:51
pues 00:29:53
ha permitido 00:29:54
lo que fuera, pues que haya otro cliente 00:29:57
en la aplicación C2 00:29:59
que resulta que es el mismo 00:30:00
entonces este cliente C2 00:30:02
pues se ha registrado con nombre 00:30:09
Luisito 00:30:11
pues porque 00:30:14
se registró hace muchos años 00:30:16
entonces se llamaba Luisito 00:30:18
pero es Luis 00:30:19
que ha crecido 00:30:21
bueno, pues en la aplicación se puede dar esta situación 00:30:23
se puede dar que yo tenga 00:30:28
dos objetos instanciados 00:30:30
pero a nivel de 00:30:32
interpretación real de lo que está ocurriendo ahí 00:30:35
a nivel de lo que está pasando 00:30:38
se refieren a la misma 00:30:39
persona, a la misma persona 00:30:42
pero son dos objetos distintos, está claro 00:30:43
entonces yo tengo que de alguna manera 00:30:45
pues habilitar 00:30:48
poner la posibilidad de distinguirse 00:30:49
si un objeto se corresponde al mismo cliente que el otro. 00:30:51
Si un objeto y el otro, estas son dúplicas en realidad, 00:30:56
aunque sean objetos distintos. 00:30:59
Tengo que tener alguna manera de decir, 00:31:01
oye, este no será una dúplica, 00:31:02
porque si es una dúplica voy a eliminar uno de los dos, 00:31:04
porque si no voy a tener aquí una raíz de clientes, 00:31:07
cuando a lo mejor cuatro son el mismo, 00:31:09
otros cinco son el mismo, me va a funcionar mal. 00:31:13
Cuando agrego un pedido, ¿a quién se lo agrego? 00:31:15
Si tengo varios NIF juntos. 00:31:17
entonces debería poner de alguna manera 00:31:19
una forma de detectar 00:31:22
si diferentes instancias 00:31:23
son el mismo 00:31:25
la misma persona 00:31:27
son duplicados que no quiero, que me sobran 00:31:28
pues ¿cómo? 00:31:31
pues ahora mismo 00:31:33
tal y como lo tenemos 00:31:34
si mi criterio de igualdad es cliente 00:31:36
tendría que hacerlo 00:31:40
haciendo la propiedad 00:31:41
si c2.getNive 00:31:42
vale, vamos a ponerlo aquí 00:31:46
Ver si los 00:31:49
Dos objetos 00:31:56
Son el mismo 00:31:58
Cliente 00:32:03
Vale 00:32:05
Antes de ponerlo como lo tendríamos que hacer 00:32:07
Lógicamente 00:32:09
Uno 00:32:10
Jamás lo compararía así 00:32:11
Así no los compararía porque esto 00:32:14
Le va a dar 00:32:26
Lógicamente que no son el mismo 00:32:28
Porque ahí compara 00:32:29
Aquí compara la dirección de memoria 00:32:34
De la que cuelga cada objeto 00:32:38
Son dos objetos distintos colgando 00:32:40
Direcciones de memoria distintas 00:32:42
Lo que pasa es que el nif es igual, uno es copia del otro 00:32:44
Pero son dos objetos distintos 00:32:47
Colgando direcciones de memoria distintas 00:32:48
Entonces, si yo 00:32:50
Hago esto, me va a decir que 00:32:52
No son el mismo, ¿verdad? 00:32:54
No son el mismo 00:32:59
Vale, entonces yo podría decir 00:33:00
Oye, voy a hacer el truco 00:33:03
Del string, voy a hacerlo 00:33:05
Con el equals 00:33:07
Vale, entonces yo 00:33:08
Vamos a hacer otro intento 00:33:11
En lugar de comparar así 00:33:12
Vamos a comparar 00:33:14
Que ya tenemos la pista de que con las cadenas 00:33:17
Esto no funciona, pues las direcciones de memoria 00:33:19
Vamos a comparar así 00:33:21
¿Vale? 00:33:26
Y ahora, la pregunta que haríais sería 00:33:30
¿Podemos completar esto 00:33:33
O preferís parar? 00:33:35
¿Eh? ¿Qué habéis dicho? 00:33:37
¿Sigo? 00:33:40
Vale, pues nada 00:33:42
5 minutos, o por ahí 00:33:42
Bueno, siempre digo 5 y luego son 6, pero... 00:33:44
Vale, entonces, primera pregunta que os hacéis. 00:33:47
Decís, pero bueno, ¿cómo que C1.equals? 00:33:50
¿Desde cuándo he hecho yo en mi clase cliente un método 00:33:55
equals? 00:33:59
¿Cómo es que eso puede llamar a un método equals? 00:33:59
Vamos a ver si es que yo tengo en mi clase cliente un método 00:34:02
equals. 00:34:05
No tengo un método equals en ningún sitio. 00:34:06
¿Cómo puede ser que este llame a un método equals? 00:34:08
Claro, pero ya sabemos que cliente hereda de object 00:34:11
y object tiene un método equals, que es este. 00:34:14
Pero este método equals nos vale. 00:34:20
Pues si miramos cómo está hecho, tampoco nos vale. 00:34:22
Porque este método equals lo que hace es el doble igual. 00:34:25
Comparar la dirección de memoria del que llama al método 00:34:28
con la propia dirección de memoria del pasado. 00:34:31
Es decir, hace lo mismo. 00:34:35
Hace el doble igual. 00:34:36
Con lo cual no he ganado nada llamando al equals. 00:34:37
No he ganado nada, porque lo que hace el equals de object es coger la dirección de C1 y hacer doble igual con la de C2. 00:34:40
Esto, coger C1 y hacer doble igual con C2, con lo cual no he ganado nada, llamando al equals de object. 00:34:48
Y de hecho, si lo ejecuto, me va a seguir diciendo que no son el mismo. 00:34:58
Claro, pero es que lo que ocurre es que a mí el equals de object no me interesa. 00:35:02
yo quiero sobreescribir el equals 00:35:06
para que refleje realmente 00:35:09
si el objeto es el mismo o no 00:35:11
entonces nosotros 00:35:13
sobreescribimos el método equals 00:35:15
de object con nuestra condición de igualdad 00:35:17
con la que nos interese a nosotros por aplicación 00:35:19
la que nos dé la gana 00:35:22
entonces, ¿qué hacemos aquí? 00:35:23
vamos a sobreescribir el equals 00:35:25
igual que hemos sobreescrito el toString 00:35:27
vamos a sobreescribir el equals 00:35:28
cliente 00:35:31
equals 00:35:33
cliente C 00:35:35
por ejemplo 00:35:38
y ahora 00:35:39
y que me devuelve 00:35:40
boolean 00:35:44
vale 00:35:45
y voy a poner aquí un override 00:35:47
para asegurarme 00:35:51
a ver si he puesto bien la cabecera 00:35:53
vale 00:35:55
he puesto aquí, perdón 00:35:56
esto, vale 00:35:59
public me devuelve un boolean 00:36:01
el método equal recibe un objeto cliente 00:36:03
entonces 00:36:06
¿qué me va a devolver? pues 00:36:07
dis 00:36:11
el objeto que llama al método 00:36:14
punto nif 00:36:15
resulta que es como es un string 00:36:16
resulta que es igual 00:36:19
esto es un string 00:36:21
¿vale? recordad que los strings se comparan con 00:36:23
equals 00:36:25
es igual que c punto nif 00:36:26
pues entonces 00:36:30
ya retúntru 00:36:31
que mi equals me devuelva true 00:36:32
y si no 00:36:34
Else 00:36:36
Return false 00:36:38
¿Vale? 00:36:40
Entonces 00:36:42
A ver que no he escrito 00:36:43
Bien la cabecera 00:36:50
Object 00:36:52
Y ahora, ¿vale? 00:37:06
Porque la cabecera no estaba idéntica 00:37:08
¿Vale? Ahora he puesto la cabecera 00:37:11
Idéntica para que sea sobrescrito 00:37:12
¿Vale? 00:37:14
He puesto la cabecera 00:37:15
Perdón, idéntica 00:37:17
la cabecera está idéntica 00:37:18
pero lo único 00:37:20
es que ahora me falta hacer el casting 00:37:22
para que la cabecera sea idéntica 00:37:24
el parámetro que paso 00:37:26
lo tengo que poner como si fuera object 00:37:28
para que la cabecera sea idéntica 00:37:29
pero yo sé que el que voy a pasar 00:37:31
es un objeto cliente 00:37:34
cuando lo llame lo sé que es un objeto cliente 00:37:36
luego para poder acceder 00:37:38
a nif, porque esto de nuevo es herencia 00:37:40
el compilador me dice 00:37:42
a ver parámetro c 00:37:44
parámetro c es de clase object 00:37:45
En la clase object 00:37:48
No hay ningún nif que yo sepa 00:37:50
Con lo cual no te dejo 00:37:51
Que hacíamos 00:37:53
Le poníamos el casting a object 00:37:55
¿Verdad? 00:37:57
Perdón, el casting a cliente 00:37:59
Ay, jolines, cliente 00:38:01
Cliente de C 00:38:10
Y ahora 00:38:15
Esto lo paso a 00:38:19
Cliente C 00:38:24
Punto 00:38:25
Ahora, ahora lo 00:38:26
Vale, ya está 00:38:33
Vale, a ver, repasamos por partes. Yo quiero sobreescribir el método equals de object para que realmente me compare, me devuelva true si los objetos son iguales o falsos y no, pero según el criterio de igualdad mío que yo quiera, no según el de dirección de memoria que es el que tiene object. 00:38:39
¿Vale? Ese no me gusta 00:39:02
Quiero que me devuelva true 00:39:04
Si pasa lo que yo quiero 00:39:07
Y false si no 00:39:08
Hasta ahí está claro, ¿no? 00:39:10
Entonces lo sobrescribo 00:39:11
Y sobrescribirlo implica respetar su cabecera tal cual 00:39:13
Vale, ahí se queda sobrescrito 00:39:16
Ahora 00:39:18
¿Cuándo quiero yo que devuelva true? 00:39:19
Cuando el need del objeto que llama el método 00:39:22
Que es this 00:39:25
Sea igual que el need del objeto parámetro 00:39:25
Ahí es cuando quiero que devuelva true 00:39:29
Y false si no 00:39:31
vale, pues si this.nif 00:39:32
es igual 00:39:35
este es el equals de la clase string 00:39:36
es igual que el nif 00:39:38
de este 00:39:41
pero claro, esto es lo mismo de la herencia 00:39:42
que ya hemos visto 00:39:45
como cliente 00:39:46
hereda de object 00:39:49
yo aquí le puedo pasar, le he pasado un cliente 00:39:50
y no pasa nada, porque recordad 00:39:53
que en una superclase 00:39:55
puede caer una instancia de una subclase 00:39:56
entonces c2, lo que yo le paso 00:39:59
aquí es cliente que es subclase 00:40:01
pero él cabe perfectamente 00:40:03
ningún problema 00:40:05
en meterlo en un object 00:40:06
porque object es superclase 00:40:09
luego casa perfectamente 00:40:10
pero claro, el compilador, cuando yo haga c.nir 00:40:12
el compilador me dice 00:40:15
perdona, yo miro como estás 00:40:17
declarado, aunque luego te instancies 00:40:19
como cliente y te pases aquí como cliente 00:40:21
yo miro que estás 00:40:23
declarado como object y aquí en object 00:40:25
que yo sepa no hay ningún nir 00:40:27
¿cómo solucionábamos eso? 00:40:28
hacíamos el casting a la subclase 00:40:31
y ya está 00:40:33
¿vale? es decir, yo sé 00:40:34
que C, cuando este método realmente 00:40:37
se ha invocado desde el main 00:40:40
se ha invocado 00:40:41
sé que le voy a pasar un objeto cliente 00:40:43
que perfectamente 00:40:46
cabe en esta referencia 00:40:47
entonces, me puedo permitir 00:40:49
hacerle un casting 00:40:52
a cliente y ahora 00:40:53
en el casting del compilador 00:40:55
ya si me deja coger las propiedades de cliente 00:40:57
ya si me deja 00:41:00
¿vale? que es lo que habíamos hablado 00:41:01
bueno, pues ya tengo un equals 00:41:03
que se adapta a lo que yo quiero 00:41:05
me devuelve true 00:41:07
si el objeto que llama al método 00:41:08
tiene el mismo need que el objeto parámetro 00:41:10
y false signo, ahora ya tengo el equals 00:41:12
bueno 00:41:15
con lo cual, ahora ya mi main 00:41:15
esto ya sí que va a funcionar 00:41:19
estos dos son objetos distintos 00:41:21
el nombre distinto 00:41:23
luego se registró, puso nombres distintos 00:41:25
pero son el mismo, son una 00:41:27
dúplica 00:41:29
entonces, ahora yo ya 00:41:30
lo voy a ver con esto 00:41:32
cuando yo ejecute esto 00:41:33
ahora efectivamente 00:41:36
me dice la aplicación, los objetos 00:41:39
son el mismo, son lo mismo 00:41:42
es el mismo cliente, porque c1 00:41:43
es igual a c2 00:41:46
porque para que este método sea sobrescrito 00:41:47
tiene que tener la cabecera 00:41:56
tal cual, y la cabecera 00:41:58
en object es esta 00:42:00
vale 00:42:02
claro 00:42:04
¿vale? entonces el equals 00:42:07
de hecho es un método 00:42:13
tan imprescindible 00:42:15
en general, ponerlo en nuestras clases 00:42:17
para dar ese significado 00:42:19
de cuando algo es igual, es una dúplica 00:42:21
de otra cosa, aunque sean objetos distintos 00:42:23
que 00:42:25
como el toString, el eclipse te lo genera 00:42:26
solo si te da la gana 00:42:29
por ejemplo, voy a dejar 00:42:30
este comentado que es nuestra versión 00:42:33
y digo, yo estoy ya 00:42:35
en plan piloto automático 00:42:37
y digo, a ver, cliente 00:42:39
cliente en mi diseño, mi aplicación 00:42:41
me está diciendo que clientes 00:42:44
con NIF iguales son el mismo porque es clave 00:42:45
primaria, pues como NIF es clave 00:42:47
primaria no puede haber dos clientes 00:42:49
con el mismo 00:42:51
NIF, pues me voy a hacer ya un equals 00:42:53
para que la aplicación tenga claro cuando 00:42:55
un objeto es el mismo que el otro, cuando son 00:42:57
dúplicas, aunque sean objetos distintos 00:42:59
pues o lo hago a mano como lo he hecho ahora 00:43:01
o cualquier entorno te permite generarlo 00:43:03
directamente, veis aquí botón derecho 00:43:05
te pone 00:43:07
generar hashcode 00:43:10
en equals 00:43:11
igual que hemos generado 00:43:11
automáticamente 00:43:14
los getter y setter 00:43:14
el toString 00:43:15
pues le marcamos 00:43:16
hashcode en equals 00:43:17
y te dice 00:43:18
¿cuáles son las 00:43:18
propiedades 00:43:22
que definen 00:43:23
que un objeto 00:43:24
sea igual a otro? 00:43:25
en nuestro caso 00:43:25
nif 00:43:26
pues dejamos marcada 00:43:26
nif solamente 00:43:27
podría ser 00:43:28
que yo 00:43:30
que para mí 00:43:31
dos objetos 00:43:31
son iguales 00:43:32
solo 00:43:32
si nif 00:43:33
y nombre 00:43:34
son iguales 00:43:35
los dos 00:43:36
podría ser 00:43:36
eso ya depende del análisis 00:43:37
que yo he hecho de mi aplicación, en este caso 00:43:39
solo depende del nif, marco solo 00:43:41
nif y generar 00:43:43
vale 00:43:45
y él me ha 00:43:46
generado aquí 00:43:51
este equals 00:43:54
y me gea el hashcode 00:43:55
obligatoriamente que lo podemos dejar 00:43:57
pero ahora mismo es que no lo usamos 00:43:59
entonces lo podemos dejar 00:44:01
el hashcode es un paso B 00:44:03
de igualdad cuando usas conjuntos 00:44:05
pero bueno, eso ya lo veremos 00:44:08
Si no usas conjuntos, no lo necesitas. 00:44:09
Vale, entonces nos ha generado un equals 00:44:12
un poquito más completito que el nuestro. 00:44:14
En realidad hacen lo mismo, pero bueno, 00:44:18
como te dice. 00:44:20
A ver, si la dirección de memoria del que llama 00:44:22
es igual que la dirección de memoria, 00:44:24
ahí es evidente que van a ser, 00:44:27
que tiene el mismo nid. 00:44:28
Ahí es evidente. 00:44:29
Pues entonces te devuelve true. 00:44:31
Vale. 00:44:33
¿Qué más hace este equals generado? 00:44:34
Si el objeto que le pasas como parámetro 00:44:36
es nul, es evidente 00:44:38
que es imposible que sea igual que este. 00:44:41
Con lo cual, retúrfalse. 00:44:43
Porque el que llama 00:44:45
al método no podría ser nul. 00:44:46
¿Por qué no puede ser nul? 00:44:48
Porque si... 00:44:52
Claro, si un objeto nul... 00:44:54
Tú llamas c1 punto... 00:44:56
No, es que 00:44:58
no serían iguales. Es que nunca jamás 00:45:00
llegarías ahí. Imagínate que c1 es nul. 00:45:02
Yo ahora hago esto. 00:45:05
c1 es igual a nul. 00:45:06
Y trato de ejecutar este código, que puedo ejecutarlo. 00:45:08
Me sale un null pointer exception, 00:45:14
porque yo no puedo ejecutar desde un, 00:45:16
con lo cual jamás llegaría al equals. 00:45:19
¿Vale? 00:45:22
Entonces, y ya de verdad que terminamos. 00:45:23
Ya, es que son 6 minutos cuánticos. 00:45:28
Entonces, no son lo mismo. 00:45:31
¿Dónde estamos? 00:45:37
En el equals que ha generado, que estaba dónde. 00:45:38
Ah, que no estoy ahí. 00:45:40
Aquí. 00:45:41
vale, entonces este 00:45:41
equals, si los dos 00:45:44
objetos son la misma dirección de memoria 00:45:46
es decir, uno está encima del otro, es evidente 00:45:48
que retunsa, si el segundo 00:45:50
es null, es evidente 00:45:52
que no son iguales, porque el primero no puede ser 00:45:54
null, porque no habríamos llegado ahí 00:45:56
no puede ser null, vale, ahora 00:45:57
esto lo que te dice es 00:46:00
si la clase a la que pertenece 00:46:01
el primero es diferente de la clase 00:46:04
a la que pertenece el segundo 00:46:06
es decir, yo le paso 00:46:07
un cliente y aquí le paso un pedido 00:46:09
que podría porque cabe en object 00:46:12
él ya directamente 00:46:13
te devuelve que es falso, es imposible 00:46:15
que dos objetos sean iguales y son de diferente clase 00:46:17
vale, entonces este es 00:46:19
un método que te devuelve, ya veremos 00:46:21
más adelante, la clase a la que pertenece 00:46:23
si no es la misma clase 00:46:25
directamente retú un falso 00:46:27
y ahora ya, si has pasado todo 00:46:29
el cribado, ahora ya te hace 00:46:31
el casting famoso, te hace el 00:46:33
casting y ahora ya sí te 00:46:35
devuelve, si este 00:46:37
es igual que el otro, te devuelve true 00:46:39
y si no te devuelve false 00:46:41
es decir, hace lo mismo 00:46:42
que el nuestro, pero bueno 00:46:45
te contempla más casos, te contempla si este 00:46:47
es null, que tenemos comparado 00:46:49
luego, este es 00:46:51
otro ejemplo de método sobrescrito de object 00:46:53
que normalmente 00:46:55
lo ponemos para darle un poco de significado 00:46:57
a la aplicación, para darle 00:46:59
significado de que un objeto es igual a otro 00:47:01
y la clase string 00:47:03
tiene su propio método equals que ella 00:47:04
sobrescribe, cuando usamos el 00:47:07
equals de string, no usamos el de object 00:47:09
usamos el que la propia clase 00:47:11
string ha sobrescrito, que mira 00:47:13
a ver si cada carácter es igual que el del otro 00:47:15
¿vale? 00:47:17
si mira, si entramos en la clase 00:47:20
string, que es 00:47:25
esta clase string, pues la clase string 00:47:27
tiene su propio toString sobrescrito 00:47:29
su propio toString 00:47:31
sobrescrito, que a ver si 00:47:37
lo encontramos rápido, esos son los constructores 00:47:39
bueno, aquí no hay un buscar 00:47:41
toString 00:47:51
vale, pero más 00:47:55
¿cómo avanzo aquí? 00:47:59
así aquí 00:48:03
ah, no, perdón 00:48:04
que estaba hablando del equals 00:48:18
perdón, el que quiero localizar es el equals 00:48:19
tiene su propio equals 00:48:22
su propio equals 00:48:23
¿veis? la clase string 00:48:26
que es esta clase 00:48:33
que la acabo de abrir, la clase string 00:48:35
tiene su propio 00:48:37
equals que sobrescribe 00:48:39
de la de object, porque cuando yo 00:48:41
comparo dos strings no quiero comparar con 00:48:43
su dirección de memoria, quiero 00:48:45
comparar si los char que tiene uno dentro 00:48:47
son los char que tiene otro, puesto 00:48:49
de este código que te hace 00:48:51
el equals de tu string 00:48:53
te vale para meterse en el string 00:48:55
para ver si los caracteres son iguales 00:48:57
los del que llama el método 00:48:59
que el string que tú le pases, etc 00:49:00
tiene su propio equals 00:49:03
¿vale? porque el equals 00:49:05
de object no vale para nada, vale para comparar direcciones 00:49:07
de memoria solo 00:49:09
¿vale? 00:49:09
y ahora sí que me callo 00:49:12
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:
1
Fecha:
19 de enero de 2026 - 11:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 18″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
432.57 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid