Saltar navegación

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

Clase 6-02-24 - 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 8 de febrero de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

ayer habíamos terminado diciendo 00:00:00
que 00:00:03
en Java siempre hay una jerarquía 00:00:04
una jerarquía de herencia 00:00:07
aunque nosotros no la hagamos específicamente 00:00:09
aquí en este ejercicio 00:00:11
si habíamos hecho una jerarquía específica 00:00:13
que era animal 00:00:15
y de animal heredan ave, perro 00:00:16
y pez 00:00:19
pero aunque no hagamos ninguna jerarquía 00:00:19
siempre hay una implícita 00:00:25
porque existe una clase object 00:00:26
una clase object que nos la aporta 00:00:29
la máquina virtual 00:00:31
junto con otras mil 00:00:32
string, scanner, buffer, 00:00:34
reader, bla bla bla 00:00:37
pues existe una clase object 00:00:38
con muy poquitas cosas 00:00:41
de la que todas las clases 00:00:42
heredan si es que 00:00:45
no especificamos que hereden de alguna otra 00:00:47
entonces este sería 00:00:49
el caso de animal 00:00:51
esta clase no hereda de ninguna 00:00:51
pero no es 00:00:54
la parte alta de la jerarquía 00:00:57
no, porque no heredar de ninguna 00:01:01
significa que en realidad 00:01:02
es como si hiciéramos esto 00:01:04
como si heredara de object 00:01:06
vale 00:01:09
entonces no heredar de 00:01:10
no poner nada 00:01:11
es lo mismo que poner esto 00:01:13
entonces todas las clases 00:01:15
todas las clases que hagamos 00:01:17
heredan 00:01:18
de verdad que rabia lo de no tener rotulador 00:01:19
porque 00:01:22
a ver si me compro uno una vez 00:01:23
vale 00:01:25
entonces todas las clases que hagamos 00:01:27
todas las clases en realidad 00:01:27
todas heredan de esta 00:01:28
todas 00:01:41
si no se pone nada 00:01:42
entonces en nuestro ejemplo pues teníamos animal 00:01:45
que 00:01:47
hereda de object 00:01:57
animal hereda de object 00:01:59
porque al no haber puesto 00:02:01
que hereda de ninguna 00:02:03
es como haber puesto esto 00:02:05
hereda de object 00:02:06
entonces ya sabemos lo que significa heredar 00:02:07
heredar significa 00:02:09
que todo lo que haya en object 00:02:11
es como si estuviera aquí también escrito 00:02:13
tanto propiedades como métodos 00:02:15
todo 00:02:17
exceptuando los constructores 00:02:18
los constructores hay que hacerlos específicamente 00:02:20
y ya vimos ayer como 00:02:23
la forma habitual de hacer un proyecto es hacer una propiedad y hacer un objeto 00:02:25
la forma habitual de hacer un constructor en una subclase 00:02:26
suele ser apoyándose 00:02:28
en constructores 00:02:30
que ya hay hechos en la superior 00:02:32
llamándolos con super etcétera 00:02:34
vale entonces animal vale dar todo lo de object que es muy poca cosa 00:02:36
y luego además nosotros 00:02:38
en nuestra aplicación habíamos hecho 00:02:40
pues una clase 00:02:42
ave, perro 00:02:44
de todo y 00:02:46
pues esa clase ave 00:02:56
heredaba de animal 00:02:58
y también teníamos 00:03:04
la clase perro 00:03:20
hereda de animal y así todas 00:03:22
entonces 00:03:24
niveles de jerarquía 00:03:26
puede haber 00:03:28
hasta el infinito 00:03:30
lo que pasa es que hombre 00:03:32
la idea es que cuando uno hace un diseño de clases 00:03:34
sirva para ayudar 00:03:36
para representar la situación 00:03:38
que quiere gestionar y para hacer una especie 00:03:40
pues de pintura 00:03:42
de foto de ella que sea útil 00:03:44
entonces si una jerarquía ya es demasiado grande 00:03:46
seguramente ese diseño que hemos hecho 00:03:48
pues ya empieza a ser confuso 00:03:50
porque que pasa en una jerarquía? ave 00:03:52
ave va a tener 00:03:54
lo que hemos escrito en ella específicamente 00:03:56
eso está claro pero además ave va a tener 00:03:58
aunque nosotros no lo veamos va a tener todo lo que hay en animal 00:04:00
salvo los constructores 00:04:02
pero es que además 00:04:04
ave va a tener todo lo que hay en object 00:04:06
porque lo hereda a través de animal 00:04:08
lo hereda entonces ave va a tener 00:04:10
todo lo que hay en animal excepto constructores 00:04:12
y todo lo que hay en object excepto constructores 00:04:14
entonces si la jerarquía ya empezamos 00:04:16
a hacerla demasiado grande y hacemos clases 00:04:18
que hereden y a su vez que hereden 00:04:20
el lío de clases que se nos queda 00:04:22
pues es muy confuso porque llega un momento 00:04:24
en que ya no sabemos lo que hay dentro de esta clase 00:04:26
tiene tantas cosas que podemos perder 00:04:28
un poquito el control 00:04:30
entonces como todas las herramientas 00:04:32
como todas 00:04:34
hay que usarlas de manera que ayude 00:04:36
que hagan aplicaciones claras 00:04:38
que representen lo que queremos 00:04:40
entonces en la realidad rara vez 00:04:42
hay situaciones que exijan una jerarquía 00:04:44
demasiado profunda 00:04:46
rara vez vale 00:04:48
lo normal es que con dos niveles ya 00:04:50
representen todo lo que queremos 00:04:52
porque más allá de dos niveles se va a complicar 00:04:54
entonces 00:04:56
no olvidemos que todas las clases 00:04:58
de Java heredan de object 00:05:00
todas las que hagamos 00:05:02
si es que no ponemos nada y luego además 00:05:04
de cada una de esas clases 00:05:06
si queremos pues pueden heredar otras 00:05:08
y así vamos haciendo un arbolito 00:05:10
de clases 00:05:12
que 00:05:14
como ya hemos dicho otras veces 00:05:16
se queda un poco pobre 00:05:18
porque 00:05:20
las clases solo pueden heredar de una 00:05:22
solo puede heredar de una 00:05:24
a lo mejor aquí podría haber 00:05:26
otra clase que fuera mamífero 00:05:28
otra clase que fuera mamífero 00:05:30
porque esta aplicación nuestra 00:05:32
pues trabaja con conceptos relacionados con animales 00:05:34
con conceptos relacionados con mamíferos 00:05:36
con lo que sea 00:05:38
bueno en este caso parece que mamífero podría heredar de animal 00:05:40
pero bueno imaginaos que tenemos aquí una clase mamífero 00:05:42
que 00:05:44
va por libre 00:05:46
entonces a lo mejor tendría sentido hacer 00:05:48
que perro 00:05:50
cogiera todo lo de animal 00:05:52
que perro cogiera todo lo de mamífero 00:05:54
porque tiene 00:05:56
la doble personalidad 00:05:58
pues no se puede hay que elegir 00:06:00
o heredo de uno o heredo de otro 00:06:02
entonces eso 00:06:04
nos resta posibilidades 00:06:06
para diseñar nuestras clases 00:06:08
sería más bonito 00:06:10
que una clase pudiera 00:06:12
cogerlo de varias a través de la herencia 00:06:14
pues no puede 00:06:16
entonces como no puede y efectivamente 00:06:18
eso es una limitación un poco fea 00:06:20
un poco fea porque no tiene sentido en la vida real 00:06:22
uno puede tener doble personalidad 00:06:24
y triple y lo que quiera 00:06:26
pues como es una limitación un poco fea 00:06:28
pues entonces se hace 00:06:30
otra cosa más que es lo siguiente 00:06:32
que veremos vale 00:06:34
que son las interfaces y su implementación 00:06:36
pero eso es lo siguiente que veremos 00:06:38
son la misma idea que la herencia 00:06:40
pero incluye unos pequeños matices nada más 00:06:42
bueno pues entonces 00:06:44
como todas heredan de object 00:06:46
que es lo que nos quedamos diciendo ayer 00:06:48
todas tienen cosas ahí 00:06:50
que no estamos viendo 00:06:52
y en particular 00:06:54
hay dos métodos 00:06:56
que toda clase tiene 00:06:58
por el hecho de heredar de object 00:07:00
que sí que son muy útiles 00:07:02
y que se usan continuamente 00:07:04
y que no los hemos programado nosotros 00:07:06
los estamos usando sin haberlos programado 00:07:08
y los está heredando de object 00:07:10
vale vamos a ver eso 00:07:12
y ya dejaríamos medio cerrado 00:07:14
lo de la herencia 00:07:16
vale 00:07:18
bueno pues entonces 00:07:20
vamos a hacernos otra clase 00:07:22
para no volver a 00:07:24
tocar esta ya 00:07:26
habíamos dejado que esta era abstracta 00:07:28
porque tenía un método 00:07:30
que habíamos decidido que fuera abstracto 00:07:32
porque este método 00:07:34
realizar acción del animal 00:07:36
no podíamos definirlo en este punto 00:07:38
en la clase animal no podíamos definirlo 00:07:40
realizar acción del animal 00:07:42
que acción depende 00:07:44
que acción realiza el animal no lo sé 00:07:46
entonces como aquí habíamos decidido 00:07:48
que este método 00:07:50
no podíamos todavía definirlo 00:07:52
entonces pegaba 00:07:54
quedaba más bonito si lo hacíamos abstracto 00:07:56
en lugar de dejarle un cuerpo vacío 00:07:58
y entonces la clase se convertía en abstracta 00:08:00
y ya veíamos las implicaciones que teníamos 00:08:02
que todo lo que heredara de una clase abstracta 00:08:04
estaba obligada 00:08:06
a darle cuerpo a este método 00:08:08
entonces vamos a hacer otra clase 00:08:10
para ver estos métodos que os digo de object 00:08:12
y así no retocamos por enésima vez esta 00:08:14
bueno 00:08:16
pues vamos a hacernos otro animalillo 00:08:18
por ahí 00:08:20
otra clase 00:08:22
no pero que no herede de animal 00:08:24
otra clase cualquiera 00:08:28
clase cuidador yo que sé 00:08:32
por poner algo 00:08:34
vale 00:08:38
cuidador no hereda de animal 00:08:40
un cuidador en la mayoría de los casos 00:08:42
no es un animal 00:08:44
entonces es otra entidad 00:08:46
de mi aplicación esta de animales 00:08:48
de zoológico de lo que sea 00:08:50
es otra entidad cualquiera que hago aparte 00:08:52
vale 00:08:54
esta no la hago heredar de ninguna 00:08:56
no la hago heredar de ninguna 00:08:58
si no la hago heredar de ninguna 00:09:00
significa 00:09:02
que entonces 00:09:04
tiene una herencia implícita 00:09:06
que es de la clase object 00:09:08
vale que es de la clase object 00:09:10
y la clase object 00:09:12
para tenerla aquí al ladito abierta 00:09:14
pues vamos a 00:09:20
a ver 00:09:22
recordad que 00:09:30
aquí la JRE 00:09:32
tiene tropecientos mil paquetes 00:09:34
con tropecientos mil 00:09:36
clases pero tropecientos 00:09:38
por ejemplo tiene aquí en el paquete 00:09:44
java lang en este 00:09:46
tiene tropecientas mil cosas 00:09:48
aquí 00:09:50
bueno pues yo en particular 00:09:52
lógicamente las que tiene 00:09:56
la máquina virtual son las compiladas 00:09:58
las punto clas 00:10:00
porque son las que la máquina virtual 00:10:02
necesita 00:10:04
a ver Moisés te traigo otra vez con Adrián 00:10:06
o traigo 00:10:08
a María me da lo mismo 00:10:10
digo yo 00:10:12
vale aquí está el punto clas 00:10:14
porque el punto clas es la que la máquina virtual 00:10:16
necesita obviamente 00:10:18
pero están 00:10:20
incorporados el Eclipse me incorpora 00:10:22
los fuentes para que yo me facilite 00:10:24
el desarrollo me lo facilite 00:10:26
entonces si yo pincho aquí 00:10:28
no es que se me abra el punto clas porque el punto clas 00:10:30
estaría en un idioma que yo no entiendo 00:10:32
no se me abre el punto clas que es el compilado 00:10:34
lo que hace el Eclipse es buscar 00:10:36
el código fuente que generó ese clas 00:10:38
y me abre ese código fuente 00:10:40
vale pero realmente los ficheros 00:10:42
que están en la máquina virtual que son los que tienen que estar 00:10:44
porque son los que necesita 00:10:46
luego para la ejecución 00:10:48
son los clas obviamente pero bueno 00:10:50
el Eclipse afortunadamente 00:10:52
las últimas versiones desde hace ya tiempo 00:10:54
me incorporan el fuente 00:10:56
entonces si pincháis en cualquiera de ellas 00:10:58
se van a buscar el fuente y te lo abren 00:11:00
entonces en particular 00:11:02
esta 00:11:04
vale vamos a 00:11:06
abrir object 00:11:10
vale 00:11:12
entonces repito 00:11:16
aunque aquí ponga object punto clas 00:11:18
esto no es 00:11:20
object punto clas 00:11:22
object punto clas es un código ya compilado 00:11:24
el bytecode de toda la vida que decíamos 00:11:26
un código que no podíamos nunca jamás 00:11:28
ver en un fichero de texto 00:11:30
nunca jamás podríamos porque no es código fuente 00:11:32
pero ese 00:11:34
punto clas se corresponde 00:11:36
con este código fuente 00:11:38
que está aquí 00:11:40
y en este código fuente hay un montón de cosas 00:11:42
que está heredando 00:11:44
la aplicación 00:11:46
por ejemplo 00:11:48
hay un constructor vacío 00:11:50
hay un constructor vacío 00:11:52
entonces cuando nosotros en cuidador 00:11:54
imaginaos que generamos un constructor 00:11:56
sin parámetros 00:11:58
con el Eclipse 00:12:00
que hacíamos esto 00:12:02
genero un constructor 00:12:04
entonces como no tiene campos 00:12:08
no me deja 00:12:10
no tengo opción de 00:12:12
generarlo de otra manera 00:12:14
si así 00:12:16
vale 00:12:18
cuando generamos el constructor 00:12:20
nosotros directamente con el Eclipse 00:12:22
recordáis que nos aparecía siempre esto 00:12:24
en la primera línea y yo decía 00:12:26
esto que este o no este 00:12:28
es que da exactamente igual 00:12:30
ahora ya entendemos que da exactamente igual 00:12:32
porque que hace esta llamada 00:12:34
llama al constructor de la clase padre 00:12:36
el constructor de la clase 00:12:38
padre cual es 00:12:40
es decir llama al constructor 00:12:42
sin parámetros de la clase padre 00:12:44
que es este 00:12:46
y este constructor que hace nada vacío 00:12:48
por eso ese super 00:12:50
que nos ponía 00:12:52
entre que este y no este nada 00:12:54
no hace absolutamente nada 00:12:56
vale y por eso lo quitábamos 00:12:58
bueno 00:13:00
pues entonces 00:13:02
la clase object tiene ese constructor 00:13:04
que no hace nada 00:13:06
y tiene otras cosas de las cuales dos 00:13:08
si que nos interesan 00:13:10
bueno pues vamos a 00:13:12
a verlo 00:13:14
vamos a ponerle propiedades al cuidador 00:13:16
para poder hacer algo 00:13:18
a ver le ponemos 00:13:20
que el cuidador va a tener 00:13:22
un código 00:13:24
y va a tener un nombre 00:13:30
para no perder 00:13:34
mucho tiempo en propiedades 00:13:36
va a tener 00:13:40
un código y un nombre 00:13:42
entonces en condiciones normales pues siempre hacemos 00:13:44
en las entidades siempre hacemos 00:13:46
constructor con y sin parámetros 00:13:48
y luego getter y setter 00:13:50
vale pues es lo que 00:13:52
vamos a hacer aquí 00:13:54
constructor 00:13:56
con parámetros 00:14:00
y get y set 00:14:04
pues nada 00:14:16
esta es mi entidad normal y corriente 00:14:18
propiedades, constructor 00:14:20
y get y setter 00:14:22
no hereda de nadie 00:14:24
osea no he puesto ningún extens 00:14:26
luego hereda de hoy 00:14:28
vale vamos ahora en un main a hacer cosas con cuidadores 00:14:30
en un main a hacer cosas con cuidadores 00:14:32
pues venga 00:14:38
nos vamos a 00:14:40
a nuestro main 00:14:44
en el que hacíamos las pruebas estas 00:14:50
con los animales 00:14:52
hicimos todas las pruebas 00:14:54
para verle el polimorfismo como funcionaba 00:14:56
etc etc 00:14:58
y para que nos servía 00:15:00
vale 00:15:02
vamos a añadir este main 00:15:06
algunas cositas 00:15:08
con el cuidador 00:15:10
le voy a poner aquí 00:15:12
para 00:15:14
indicar que ya estamos 00:15:16
vale vamos a hacer algunas cositas con el cuidador bueno pues vamos a 00:15:18
crear dos cuidadores 00:15:20
por ejemplo dos cuidadores 00:15:22
distintos 00:15:24
un cuidador c1 00:15:28
que sea un cuidador de código 1 00:15:32
y nombre 00:15:34
pues este 00:15:36
ala 00:15:38
ya tenemos un cuidador creado 00:15:40
y ahora vamos a hacer otro 00:15:46
vale tenemos dos cuidadores 00:15:50
con estos cuidadores yo ahora 00:16:08
no puedo hacer nada en realidad 00:16:10
ahora mismo no puedo hacer nada con ellos 00:16:12
porque la clase cuidador 00:16:14
es que no tiene nada 00:16:16
no le he puesto ningún método como para que haga cosas 00:16:18
pues añadirle no se que 00:16:20
asignarle animales 00:16:22
no tiene nada este cuidador no tiene nada 00:16:24
vale 00:16:26
pero por el hecho de 00:16:28
heredar de object 00:16:30
tiene métodos de la clase object que puede usar 00:16:32
y que de hecho usamos 00:16:34
continuamente y que tenemos que entender 00:16:36
muy bien como están funcionando 00:16:38
porque los usamos continuamente 00:16:40
y me refiero en particular a equals 00:16:42
y a toString 00:16:44
vale a equals y a toString 00:16:46
vale vamos con el primer 00:16:48
de ellos 00:16:50
nos vamos a nuestro main 00:16:52
y vamos a poner aquí 00:16:56
la clase cuidador 00:17:00
hereda 00:17:02
el método 00:17:04
toString 00:17:08
de la clase object 00:17:10
lo hereda 00:17:14
yo no tengo ningún toString metido aquí en cuidador 00:17:16
no tengo ninguno 00:17:18
pero sin embargo 00:17:20
pero sin embargo 00:17:22
yo si que puedo aquí 00:17:24
hacer que el objeto 00:17:26
llame al método toString 00:17:30
puedo perfectamente 00:17:32
c1 está llamando al método toString 00:17:34
pero este método 00:17:36
yo no lo he hecho en la clase cuidador 00:17:38
no lo he hecho 00:17:40
pero lo puede llamar porque toString es un método 00:17:42
que está en object 00:17:44
todos los métodos y propiedades salvo constructores 00:17:46
de una superclase 00:17:48
se heredan en la subclase 00:17:50
bueno pues toString es tan obvio 00:17:52
ahora la pregunta sería 00:17:54
y para que me sirve ese método 00:17:56
tiene sentido que yo lo use alguna vez 00:17:58
hombre pues si 00:18:00
pues es un método que si que se usa 00:18:02
a menudo 00:18:04
para que hemos convenido todos 00:18:06
para que convenimos todos 00:18:08
los que 00:18:10
el programa manejaba 00:18:12
para que se use 00:18:14
bueno pues para dar información sobre él 00:18:16
esa es la idea de este método 00:18:18
dar información sobre este objeto 00:18:20
recordad que c1 00:18:22
en realidad es una dirección de memoria 00:18:24
eso es lo que es 00:18:26
es una dirección de memoria 00:18:28
que apunta a un espacio donde ya están las propiedades de c1 00:18:30
en este caso código y nombre 00:18:32
entonces 00:18:34
si yo quiero información sobre ese objeto 00:18:36
pues podría yo construirla 00:18:38
accediendo a c1 punto código 00:18:40
c1 punto nombre 00:18:42
y mostrarlo todo 00:18:44
vale 00:18:46
podríamos hacer eso 00:18:48
pero se ha llegado 00:18:50
de alguna manera al convenio 00:18:52
que este método toString 00:18:54
lo que haga sea 00:18:56
devolver un string 00:18:58
con información sobre el objeto al que 00:19:00
apunta c1 00:19:02
es el convenio al que se llega 00:19:04
que este método sea 00:19:06
el que devuelve un string 00:19:08
con valor de retorno, devuelve un string 00:19:10
con información sobre ese objeto 00:19:12
entonces como devuelve con valor de retorno 00:19:14
un string 00:19:16
de hecho si nos vamos aquí a ver el toString 00:19:18
efectivamente devuelve un string 00:19:20
ese es el toString de object 00:19:22
el que estamos heredando 00:19:24
esto ahora no lo diréis 00:19:26
el toString de object como devuelve un string 00:19:28
pues hombre si quiero yo ver 00:19:30
el efecto 00:19:32
de la llamada 00:19:34
pues hombre 00:19:36
voy a pasárselo a un system.out para mostrarlo 00:19:38
sino no lo voy a poder mostrar 00:19:40
vale pues para eso se conviene 00:19:46
para eso se ha convenido que se use toString 00:19:52
para que devuelva un string 00:19:54
con información de c1 00:19:56
pero claro yo aquí 00:19:58
no es sobre escrito 00:20:00
el método toString en cuidador 00:20:02
no lo es sobre escrito 00:20:04
entonces está tirando del que está en object 00:20:06
está tirando del que está en object 00:20:08
no lo es sobre escrito 00:20:10
y el método que está en object 00:20:12
es un método genérico 00:20:14
que lo que te muestra es una basurilla 00:20:16
el método toString de object 00:20:18
te devuelve 00:20:20
el nombre de la clase 00:20:22
porque getClash te da el nombre de la clase 00:20:24
todo esto 00:20:26
el nombre de la clase 00:20:28
un arroba 00:20:30
y luego un código 00:20:32
un código hash 00:20:34
que ya veremos cuando veamos conjuntos 00:20:36
y tablas hash 00:20:38
que es un código hash 00:20:40
es un código 00:20:42
asociado 00:20:44
si, pero que normalmente tiene un uso 00:20:46
que es tratar de 00:20:48
me sale clasterizar 00:20:50
pero no 00:20:52
se usa para encriptar 00:20:54
es uno de los usos de los códigos hash 00:20:56
pero en general es cuando tienes una diversidad 00:20:58
de objetos muy grande 00:21:00
y los quieres identificar fácilmente 00:21:02
pues les asocias efectivamente un identificador 00:21:04
y ese identificador es el código hash 00:21:06
pero claro 00:21:08
si la idea de ese código hash 00:21:10
es que 00:21:12
te reduzca 00:21:14
la variabilidad de toda esa bolsa de cosas 00:21:16
entonces hay varios objetos 00:21:18
que te pueden llegar al mismo código hash 00:21:20
bueno, ya volveremos sobre ello 00:21:22
pero si, en resumen 00:21:24
el código hash es normalmente una forma sencilla 00:21:26
de identificar a cualquier cosa 00:21:28
en nuestro caso a un objeto 00:21:30
pero puede ser a cualquier cosa 00:21:32
es una forma sencilla de identificar a cualquier cosa 00:21:34
que luego tiene muchos usos 00:21:36
lo tiene en encriptación 00:21:38
lo tiene en almacenamiento 00:21:40
lo tiene en muchas partes 00:21:42
pero en general es un número para identificar una cosa 00:21:44
y luego en función de como lo generes 00:21:46
las reglas de generación 00:21:48
que pueden ser muchas 00:21:50
lo puedes usar para unas cosas o para otras 00:21:52
pero por definición es 00:21:54
un numerito para identificar una cosa 00:21:56
bueno, pues a lo que vamos 00:21:58
el toString este 00:22:00
de object dice, pues yo que sé 00:22:02
yo aquí que hago, un object 00:22:04
pues te doy el nombre de la clase 00:22:06
un arroba y te doy un identificador 00:22:08
un identificador que genero 00:22:10
según una regla 00:22:12
que ahora tiene muy básica 00:22:14
porque es que ni siquiera la tenemos 00:22:16
una regla que tiene muy básica 00:22:18
¿eso nos vale para algo? 00:22:20
pues vaya descripción del objeto más fea 00:22:22
o sea si esa nos gusta 00:22:24
pues venga vamos a ver efectivamente que nos sale 00:22:26
pues esta es 00:22:36
la salida del toString 00:22:38
de object 00:22:40
el nombre de la clase efectivamente 00:22:42
como veis 00:22:44
el nombre de la clase es todo 00:22:46
no os miento, el nombre de la clase no es esto 00:22:48
el nombre de la clase es todo con el paquete 00:22:50
el nombre de la clase un arrobita 00:22:52
y la traducción a código esadecimal 00:22:54
del identificador de hash 00:22:56
hombre pues como salida del método toString 00:22:58
vaya mierda de descripción 00:23:00
de cuidador 00:23:02
no nos vale para nada 00:23:04
entonces ¿qué se suele hacer? 00:23:06
se suele sobreescribir en cada clase 00:23:08
el método toString de object 00:23:10
y es una de las cosas que se suele hacer 00:23:12
por sistema 00:23:14
igual que los constructores 00:23:16
los get y los set 00:23:18
pues igual que los constructores 00:23:20
los get y los set 00:23:22
digamos que en plan churro 00:23:24
como todo de carrerilla 00:23:26
también se sobreescribe toString 00:23:28
para que cada clase de la explicación 00:23:30
que le apetece dar 00:23:32
y no de la de object 00:23:34
que es una basurilla de explicación 00:23:36
entonces 00:23:38
¿cómo sobreescribiríamos toString? 00:23:40
pues para sobreescribir un método 00:23:42
porque hay que respetar la cabecera 00:23:44
tal cual 00:23:46
este es el que yo quiero sobreescribir 00:23:48
de object 00:23:50
pues venga lo voy a sobreescribir aquí 00:23:52
y aquí ya 00:23:56
pongo la descripción que a mi me de la gana 00:23:58
y la descripción que a mi me de la gana 00:24:00
puede ser 00:24:02
código 00:24:06
y lo concateno 00:24:08
con el código que sea 00:24:10
más 00:24:12
nombre 00:24:14
y lo concateno 00:24:16
con el nombre del cuidador 00:24:18
por ejemplo 00:24:20
me puede dar a mi la gana 00:24:22
que este sea el toString 00:24:24
de cuidador 00:24:26
vale este lo describe 00:24:28
pues entonces ahora ya 00:24:30
he pisado 00:24:32
a ver uno de los dos 00:24:34
no es eso uno de los dos 00:24:36
que elija venga 00:24:38
no de verdad 00:24:40
te lo juro lo siento 00:24:42
de verdad es que lo he dicho 00:24:44
me pone muy nerviosa 00:24:46
y si es contigo en todo el brazo 00:24:48
lo siento 00:24:50
y es que además aunque no te lo parezca 00:24:52
soy yo la que te lo deduco 00:24:54
venga quien elige 00:24:56
y aparte que 00:25:04
es estupendo que te explique las cosas 00:25:06
pero fuera de horario 00:25:08
vale 00:25:14
vale 00:25:16
vale 00:25:18
vale 00:25:20
vale 00:25:42
, si nos hemos equivocado 00:27:14
y aquí hemos puesto 00:27:16
en lugar de toString 00:27:18
pues lo hemos llamado de otra manera 00:27:20
y lo hemos llamado así 00:27:22
pues vale estupendo 00:27:24
habremos hecho otro método 00:27:26
habremos hecho otro 00:27:28
pero no estará sobre escribiendo 00:27:30
el toString de object 00:27:32
el que tiene aquí su mayúscula 00:27:34
y el resto del mundo cuando busque nuestra descripción 00:27:36
la va a buscar con el nombre estándar 00:27:38
con el nombre bueno que es el tu con la s mayúscula 00:27:40
entonces tenemos que adaptarnos a eso 00:27:42
y de hecho 00:27:44
es tan importante 00:27:46
que existe una cosa que se llama 00:27:48
anotaciones 00:27:50
para verificar muchas cosas en general 00:27:52
y una de ellas es para verificar 00:27:54
que este método realmente 00:27:56
sobreescribe el de arriba 00:27:58
o es uno que me he inventado 00:28:00
y esa anotación ahora si es el momento de meterla 00:28:02
es esta 00:28:04
arroba 00:28:10
overwrite 00:28:12
que es una anotación en general en java 00:28:14
una anotación en general 00:28:18
es algo que empieza 00:28:20
con la arroba 00:28:22
y tiene un término 00:28:24
que existe una sintaxis 00:28:26
no es comentario 00:28:28
porque los comentarios es algo 00:28:30
que para java no existen 00:28:32
los comentarios son para nosotros 00:28:34
para el programador que está leyendo el código 00:28:36
para java no existen 00:28:38
entonces no es comentario 00:28:40
pero tampoco es código 00:28:42
que se ejecute 00:28:44
es información sobre el código 00:28:46
que la máquina virtual 00:28:48
si tiene en cuenta 00:28:50
eso es en general el concepto de anotación 00:28:52
entonces configura partes del código 00:28:54
y hace muchas cosas 00:28:56
ahora mismo este año no vamos a tener la necesidad 00:28:58
de incorporar anotaciones en nuestros códigos 00:29:00
pero en segundo continuamente 00:29:02
habrá que incorporar anotaciones 00:29:04
para identificar bien esos códigos 00:29:06
bueno pues esta si es importante ahora 00:29:08
ya que la metamos 00:29:10
¿qué significa? 00:29:12
ojo que el método que viene después 00:29:14
sobre escribe uno de la clase 00:29:16
de la que heredas 00:29:18
¿no? de hecho 00:29:20
te lo está diciendo sobre escritura 00:29:22
te lo está diciendo 00:29:24
ojo que este método sobre escribe el de arriba 00:29:26
entonces no es obligatoria 00:29:28
podemos ponerla o no podemos ponerla 00:29:30
yo puedo no ponerla 00:29:32
puedo no ponerla 00:29:36
y simplemente 00:29:38
el hecho de que esta cabecera 00:29:40
sea idéntica calcada 00:29:42
a la cabecera de object 00:29:44
a esta 00:29:46
el hecho de que sea calcada 00:29:48
ya eso implica que está sobre escribiendo 00:29:50
ya eso implica 00:29:52
que está sobre escribiendo 00:29:54
no hace falta ponerla 00:29:56
pero ponerla es útil 00:29:58
¿por qué? 00:30:00
si yo la pongo en todos los métodos 00:30:02
que quiero que mi intención es que sean sobre escritos 00:30:04
la pongo y luego resulta que me equivoco 00:30:06
y lo escribo mal 00:30:08
automáticamente 00:30:10
el compilador va a detectar que hay un problema 00:30:12
te dice uy me dices que este sobre escrito 00:30:14
pues yo no lo conozco 00:30:16
en la clase padre no está 00:30:18
algo falla 00:30:20
entonces es muy útil ponerla 00:30:22
porque te avisa no vaya a ser que te hayas equivocado 00:30:24
a la hora de poner la cabecera 00:30:26
y no estés sobre escribiendo sino que estás haciendo otro 00:30:28
no estás haciendo otro distinto 00:30:30
entonces te permite detectar eso 00:30:32
por eso es útil 00:30:34
esta anotación 00:30:36
¿vale? 00:30:38
si yo tengo una anotación puesta 00:30:40
y lo escribo mal 00:30:42
a lo mejor me creo que estoy sobre escribiendo 00:30:44
el método toString 00:30:46
y no lo estás sobre escribiendo 00:30:48
estás haciendo otro distinto 00:30:50
y entonces ya vas a tener los dos coexistiendo 00:30:52
heredado de object que no ves 00:30:54
y el nuevo que has hecho 00:30:56
y eso es un problema 00:30:58
porque el resto de clases van a estar llamando al heredado que no ves 00:31:00
este es como si no existiera 00:31:02
¿vale? 00:31:04
pues la utilidad de la anotación es esa 00:31:06
¿vale? 00:31:08
vale pues entonces 00:31:10
si yo sobre escribo toString y decido así 00:31:12
pues hala estupendo 00:31:14
ahora yo cuando en mi main 00:31:16
haga un system.out.println de c1 00:31:18
en lugar de salirme esa cosa rara 00:31:20
me llamará 00:31:22
me llamará al toString de c1 00:31:24
y ya no llamará al toString de object 00:31:26
llamará al suyo propio que ha sobre escrito 00:31:28
y entonces ahora ya si 00:31:30
que nos saldrá algo pues más bonito 00:31:32
¿vale? 00:31:34
nos saldrá la descripción 00:31:36
anda ahora si que me salen las tildes 00:31:38
ah bueno es que siempre me han salido aquí 00:31:40
bueno da igual 00:31:42
entonces nos da una descripción más bonita 00:31:44
¿vale? 00:31:46
bueno pues entonces el método toString es un método 00:31:48
que vais a ver continuamente 00:31:50
que se incorpora en las entidades 00:31:52
porque ofrece 00:31:54
ofrece una 00:31:56
manera de 00:31:58
obtener una descripción mediante texto 00:32:00
de un objeto mediante texto 00:32:02
y a ese método toString 00:32:04
puede que recurran 00:32:06
hay muchas clases por ahí 00:32:08
puede que recurran 00:32:10
entonces vamos a sobre escribirlo bien 00:32:12
vamos a sobre escribirlo 00:32:14
y así esas clases que recurran a él 00:32:16
no van a tirar del de object del heredado 00:32:18
que saca una información muy extraña 00:32:20
¿vale? 00:32:22
bueno tanto es así lo de la utilidad de toString 00:32:28
que de hecho 00:32:30
el propio clipse 00:32:32
me ofrece generarlo automáticamente 00:32:34
voy a comentar 00:32:36
el nuestro 00:32:38
voy a comentar este 00:32:40
¿vale? entonces 00:32:42
si nos vamos de nuevo al 00:32:44
botón derecho para ver lo que me ofrece 00:32:46
la pestaña source este 00:32:48
pues una de las cosas que ofrece es 00:32:50
genera automáticamente un toString 00:32:52
genera uno 00:32:54
le damos 00:32:56
y te dice a ver 00:32:58
¿qué campus quieres que se incluya en la descripción? 00:33:00
pues quiero que se incluya 00:33:02
código y nombre solamente 00:33:04
métodos ninguno porque te genera automáticamente 00:33:06
unas descripciones muy extrañas 00:33:08
vale pues ya está 00:33:10
te lo crea 00:33:12
te dice venga ¿te gusta este toString? 00:33:14
que te devuelve este texto tan chulo 00:33:16
pues si y te pone el override 00:33:18
claro y te lo deja ya muy bien 00:33:20
¿te gusta este toString? 00:33:22
bueno pues puede ser 00:33:24
vamos a volver a probar en nuestro main 00:33:26
a ver si nos gusta 00:33:28
pues este 00:33:30
este es el toString que te genera el clipse 00:33:32
bueno 00:33:34
pues es cómodo 00:33:36
vale entonces es una buena práctica 00:33:38
que todas nuestras clases tengan toString 00:33:40
porque nunca sabemos cuando alguien 00:33:42
va a llamarlo 00:33:44
entonces para ofrecerle un arroba 00:33:46
un código hash o no se que 00:33:48
pues para eso le ofrecemos un mensajito 00:33:50
un poco más 00:33:52
más bonito 00:33:54
vale pues esto en cuanto al toString 00:33:58
de nuevo nos está sirviendo para ver 00:34:00
un ejemplo de 00:34:02
Mario 00:34:04
sobrescritura de métodos 00:34:06
vale 00:34:08
y recordad 00:34:10
que la sobrescritura 00:34:12
implica automáticamente 00:34:14
un polimorfismo el método toString 00:34:16
es el más polimorfo del mundo 00:34:18
si al toString lo llama un objeto cuidador 00:34:20
mostrará la descripción del cuidador 00:34:22
pero si al toString lo llama un objeto 00:34:24
no se que mostrará al toString de ese objeto 00:34:26
vale que eso era el polimorfismo 00:34:28
dependiendo del objeto 00:34:30
que lo llame ese método con 00:34:32
ese mismo nombre hace cosas distintas 00:34:34
bueno pues hala eso en cuanto al toString 00:34:40
y el segundo 00:34:42
que nos interesa heredado de 00:34:44
object que se usa continuamente 00:34:46
segundo que nos interesa 00:34:48
y que cuando veamos las colecciones 00:34:50
es imprescindible 00:34:52
manejarlo con soltura 00:34:54
el equals 00:34:56
vale pues entonces yo aquí ahora 00:34:58
en cuidador tengo los get los set 00:35:00
y el toString 00:35:02
son los que tengo 00:35:04
la versión que queráis 00:35:06
la que genera el eclipse la nuestra la que queráis 00:35:08
vale 00:35:10
y ya no tengo más 00:35:12
pero efectivamente en mi main 00:35:14
yo si puedo seguir llamando a métodos 00:35:16
que yo no he hecho 00:35:18
porque los he heredado con toString 00:35:20
por ejemplo hay un método que hemos usado 00:35:22
con la clase string sin entenderlo 00:35:24
en realidad 00:35:26
que es el método equals 00:35:28
vale 00:35:30
el método equals 00:35:32
es un método 00:35:36
que hasta ahora lo hemos 00:35:38
usado asociado 00:35:40
a un objeto string 00:35:42
y pasándole como parámetro otro 00:35:44
objeto string 00:35:46
pero eso no significa que solamente 00:35:48
los objetos 00:35:50
string puedan llamar a equals 00:35:52
a equals lo puede llamar cualquier objeto 00:35:54
del mundo cualquiera 00:35:56
y porque lo puede llamar cualquier objeto del mundo 00:35:58
pues porque 00:36:00
equals está en la clase object 00:36:02
es este 00:36:04
está en la clase object 00:36:06
vale 00:36:08
y el método equals de la clase object 00:36:10
te dice tu pasame 00:36:12
cualquier cosa que sea un object 00:36:14
y de nuevo 00:36:16
ya sabemos que en una referencia 00:36:18
caben objetos de esa clase 00:36:20
y de todas las herederas 00:36:22
entonces como todas las clases que uno dejaba 00:36:24
todas cualquiera todas van a heredar de object 00:36:26
en última instancia todas 00:36:28
pues a equals se le puede pasar 00:36:30
cualquier tipo de objeto cualquiera 00:36:32
a equals se le puede pasar cualquier objeto 00:36:34
cualquiera 00:36:36
vale y que devuelve el método 00:36:38
equals de object 00:36:40
un boolean 00:36:42
vale un boolean 00:36:44
entonces y que hace este método 00:36:46
equals en object que hace este método 00:36:48
equals te devuelve true 00:36:50
si la dirección 00:36:52
de memoria de este objeto 00:36:54
es la misma dirección de memoria 00:36:56
del objeto que llame al método 00:36:58
eso es lo que te devuelve 00:37:00
el equals de object 00:37:02
nos interesa esa versión de equals 00:37:04
nos interesa esa versión de equals 00:37:06
puede que nos interese 00:37:08
puede que no normalmente no 00:37:10
porque no tiene mucho sentido 00:37:12
realista y práctico 00:37:14
vamos a verlo 00:37:16
a ver entendemos que al haber aquí un doble igual 00:37:18
esto significa el contenido 00:37:20
de este variable objeto 00:37:22
y el contenido del variable objeto 00:37:24
es la dirección de memoria eso lo tenemos clarísimo 00:37:26
y esto significa el contenido 00:37:28
de esta variable no a lo que apunta 00:37:30
el contenido es su dirección 00:37:32
entonces el método equals 00:37:34
de object va a devolver true 00:37:36
si las dos direcciones de memoria 00:37:38
del que llama equals 00:37:40
y el pasado son la misma idéntica 00:37:42
y va a devolver el false si no 00:37:44
vale 00:37:46
lo tenemos claro que eso es lo que hace 00:37:48
el método equals tal cual 00:37:50
bueno pues entonces 00:37:52
con eso si yo llamo 00:37:54
equals 00:37:56
si yo llamo al método equals 00:38:02
de object lo llama el objeto c1 00:38:12
y le paso como parámetro 00:38:14
que va a hacer el if o el else 00:38:18
el if o el else 00:38:22
el else porque c1 es un objeto 00:38:24
apuntado por su dirección de memoria 00:38:26
y c2 es otro 00:38:28
eso está claro ¿no? 00:38:30
vale 00:38:32
si yo tengo aquí 00:38:38
c1 pues nada 00:38:44
c1 es en realidad 00:38:52
la dirección de memoria 00:38:54
de un espacio 00:38:56
en memoria 00:38:58
para contener ya las propiedades de código 00:39:00
vale y c2 que es 00:39:02
c2 es 00:39:08
otra dirección de memoria 00:39:16
otra distinta 00:39:18
que está ahí para contener las propiedades 00:39:22
de otro objeto 00:39:24
esto es lo que tenemos 00:39:26
luego c1 no es igual a c2 00:39:28
está claro c1 es una dirección de memoria 00:39:30
una dirección que lleva aquí 00:39:32
y c2 es una dirección que lleva aquí 00:39:34
c1 es igual a c2 00:39:36
vale 00:39:38
pues vamos a comprobarlo 00:39:40
entonces si ejecutamos esto 00:39:42
pues me dice que distintos 00:39:48
vale 00:39:50
vale y nosotros podríamos tirar 00:39:52
con ese sentido de equals 00:39:54
pero ese sentido de equals 00:39:56
no es el sentido real 00:39:58
en una aplicación 00:40:00
en una aplicación 00:40:02
para que las cosas tengan sentido 00:40:04
el criterio de igualdad no es ese 00:40:06
el criterio de igualdad siempre es 00:40:08
que las claves primarias sean la misma 00:40:10
por ejemplo si yo tengo dos personas 00:40:12
y las dos tienen el mismo nif 00:40:14
para mi aplicación 00:40:16
tienen que ser iguales 00:40:18
porque si no pierde el sentido la aplicación 00:40:20
si tengo 00:40:24
osea cada entidad 00:40:26
tendrá su código primario su clave principal 00:40:28
si estoy trabajando con clientes 00:40:30
cada cliente tiene un código 00:40:32
o con pedidos y cada pedido tiene un código 00:40:34
o con facturas que ahí se ve más claro 00:40:36
cada factura tiene un número de factura 00:40:38
entonces si mi aplicación ve 00:40:40
dos facturas que tienen 00:40:42
el mismo número de factura 00:40:44
a todos los efectos 00:40:46
para la aplicación tienen que ser la misma 00:40:48
porque si no pierde su sentido 00:40:50
entonces para que las aplicaciones sean coherentes 00:40:52
objetos 00:40:54
que tienen la misma clave primaria 00:40:56
que tienen el mismo identificador único 00:40:58
tienen que ser el mismo 00:41:00
tienen que ser el mismo 00:41:02
lo que pasa es que a lo mejor han aparecido duplicados 00:41:04
o lo que sea 00:41:06
pero los efectos de trabajo tienen que ser considerados 00:41:08
como el mismo y como iguales 00:41:10
luego el criterio de igualdad real 00:41:12
que es el que tiene que reproducir la aplicación 00:41:14
el real 00:41:16
no es este 00:41:18
no es que estén en posiciones de memoria distintas 00:41:20
ese no es el criterio de igualdad real 00:41:22
y operativo 00:41:24
el criterio de igualdad 00:41:26
tiene que ser 00:41:28
el mismo 00:41:30
entonces a lo mejor físicamente en memoria 00:41:32
tengo ahí esas dos referencias 00:41:34
porque las he generado dos veces 00:41:36
pero son la misma cosa 00:41:38
y las tengo que tratar igual 00:41:40
entonces el ver que son iguales 00:41:42
me permitiría a lo mejor olvidarme de uno 00:41:44
y empezar a trabajar con el otro 00:41:46
entonces el criterio de igualdad real en la vida 00:41:48
y por tanto en la aplicación 00:41:50
es que lo que identifica de forma única 00:41:52
a dos objetos 00:41:54
es igual, es el mismo, es el criterio real 00:41:56
este no tiene ninguna utilidad 00:41:58
bueno pues entonces 00:42:00
que es lo que tenemos que hacer 00:42:02
sobre escribir el equals 00:42:04
en nuestras clases para decir 00:42:06
oye si hay otro objeto 00:42:08
con este mismo código 00:42:10
o con este mismo nif 00:42:12
o con este mismo lo que sea 00:42:14
entonces es el mismo 00:42:16
aunque este alojado en posiciones de memoria distintas 00:42:18
ese es el uso 00:42:20
que tendría sentido 00:42:22
entonces 00:42:24
de hecho 00:42:26
el eclipse te ofrece 00:42:28
la posibilidad de sobre escribir el método equals 00:42:30
sobre escribirlo 00:42:32
pero vamos no hace falta que usemos el eclipse 00:42:34
para todo 00:42:36
podríamos sobre escribirlo nosotros 00:42:38
y hacer esto 00:42:40
lo voy a sobre escribir 00:42:42
en cuidador 00:42:44
voy a asegurarme 00:42:46
de que he puesto bien la 00:42:48
el este 00:42:50
poniendo el override 00:42:52
bueno vamos a hacerlo primero 00:42:54
porque si no me va a aparecer en rojo todo el rato 00:42:56
vale pues aquí uno ya tiene que decidir 00:42:58
acorde al sentido de su aplicación 00:43:00
recordad que una aplicación tiene que reproducir 00:43:02
lo que está pasando 00:43:04
tiene que pensar a ver para mi 00:43:06
que va a hacer que un cuidador sea igual a otro 00:43:08
que sean el mismo 00:43:10
que va a hacer que sean el mismo 00:43:12
pues miraría uno su modelo su descripción 00:43:14
y según el modelo de datos 00:43:20
el análisis que ha hecho todo lo que ha estudiado 00:43:22
diría hombre 00:43:24
pues dos cuidadores con el mismo código son el mismo 00:43:26
mi aplicación tiene que tratar 00:43:28
igual tiene que considerar que son lo mismo 00:43:30
que son el mismo 00:43:32
dos cuidadores con el mismo código 00:43:34
mi modelo de datos mi realidad no concibe 00:43:36
que en misológico haya dos cuidadores con código 00:43:38
distinto no lo concibe 00:43:40
los cuidadores 00:43:42
distintos códigos distintos 00:43:44
pues entonces tendría sentido 00:43:46
hacer un equals que te devuelva true 00:43:48
si los códigos del que llama el método 00:43:50
y el parámetro son iguales 00:43:52
y false en caso contrario 00:43:54
recordad que todo lo que programamos 00:43:56
todo lo que declaramos en las clases todo lo que hacemos 00:43:58
tiene que reproducir 00:44:00
la situación real 00:44:02
tiene que estar al servicio 00:44:04
de esa situación 00:44:06
bueno pues aquí podríamos hacer nuestro object 00:44:08
que fuera venga vamos a ver 00:44:10
vamos a hacerlo largo o sea escrito en varias 00:44:12
líneas para no liarnos 00:44:14
pues vamos a hacer un 00:44:16
bueno no que igual así os es más claro 00:44:20
pues venga vamos a hacer si 00:44:22
la propiedad código del 00:44:26
objeto que llame al equals 00:44:28
que es un entero con lo cual lo puedo 00:44:30
es igual 00:44:32
que la propiedad código del objeto 00:44:34
que le paso por parámetro 00:44:36
vale aquí nos viene de nuevo 00:44:40
objeto 00:44:42
está declarado como object 00:44:44
no tiene 00:44:46
una propiedad código verdad no la tiene 00:44:48
el compilador no me va a 00:44:50
decir dejar poner aquí 00:44:52
objeto punto código 00:44:54
porque yo querría 00:44:56
poner esto si los códigos 00:44:58
son iguales entonces 00:45:00
return true 00:45:02
else 00:45:04
return 00:45:06
false este sería la 00:45:08
idea de mi equals verdad sería esta 00:45:10
esta sería la idea de mi equals 00:45:14
si los códigos del que llama el método 00:45:16
y el pasado por parámetros son iguales 00:45:18
los códigos devuelve true 00:45:20
para indicar que esos objetos son el mismo 00:45:22
si no devuelve false 00:45:26
pero bueno no podemos ponerlo así no 00:45:28
por el mismo problema que nos surgió ayer 00:45:30
etcétera etcétera 00:45:32
porque obj está declarado como la clase 00:45:34
genérica object 00:45:36
por tanto el compilador no ve en esa clase 00:45:38
genérica code 00:45:40
que solución podemos poner 00:45:42
para eso 00:45:44
hacer un 00:45:48
hacer un casting efectivamente yo sé que lo que 00:45:50
le voy a pasar es un objeto cuidador 00:45:52
sé que le voy a pasar un cuidador pero voy a 00:45:54
comparar un cuidador con otro 00:45:56
tranquilidad 00:45:58
te haces un casting 00:46:00
de este 00:46:04
objeto de aquí 00:46:06
te haces un casting a cuidador 00:46:08
y listo 00:46:10
ala 00:46:12
ya tenemos un equals ya con sentido real 00:46:14
con sentido práctico 00:46:16
si además somos ya 00:46:18
perfectos 00:46:20
vamos a 00:46:22
anotarlo con overwrite 00:46:24
para asegurar 00:46:26
de que hemos escrito 00:46:28
bien la cabecera no vaya a ser que estemos 00:46:30
haciendo otro método que no es el equals 00:46:32
estándar que se usa 00:46:34
siempre sino otro añadido que nos hemos 00:46:36
inventado porque se nos ha olvidado 00:46:38
porque hemos puesto dos s en vez de una 00:46:40
si encima nos acordamos de poner el overwrite 00:46:42
estupendo 00:46:44
así sabemos que estamos sobre escribiendo 00:46:46
el de object 00:46:48
porque pueden venir otras clases por ahí 00:46:50
que quieran hacer igualdades entre cuidadores 00:46:52
y van a llamar al equals de 00:46:54
en su nombre real 00:46:56
van a llamar al equals de su nombre real 00:46:58
entonces vamos a sobre escribirlo 00:47:00
con su nombre real 00:47:02
vale pues entonces con el 00:47:06
equals sobre escrito 00:47:08
ahora ya si que nos pasaría 00:47:10
vamos a por ejemplo 00:47:12
vamos a 00:47:14
cambiar esto 00:47:16
y ya ejecutamos esto 00:47:18
y ya si que paramos 00:47:20
voy a quitar para que lo veamos 00:47:22
primero nuestra sobre escritura 00:47:24
de esta de aquí 00:47:26
entonces resulta que mi aplicación 00:47:28
tiene 00:47:30
dos cuidadores 00:47:32
ha introducido 00:47:34
donde estamos el main 00:47:36
ha introducido cuidadores 00:47:38
se le da a lo mejor 00:47:42
esta situación 00:47:44
pues que en una parte 00:47:46
un gestor lo introdujo 00:47:48
con el nombre de luis y el otro 00:47:50
le puso el nombre completo luis maria 00:47:52
pero en realidad son el mismo 00:47:54
son el mismo cuidador 00:47:56
y cuando hay que subir el sueldo 00:47:58
hay que subírselo a ese único 00:48:00
no hay dos cuidadores 00:48:02
hay uno que tiene su código uno 00:48:04
lo que pasa es que en la aplicación 00:48:06
por la razón que sea 00:48:08
pueden haberse instanciado dos objetos distintos 00:48:10
pero son el mismo cuidador 00:48:12
y a efectos del resto de funcionalidades 00:48:14
pues hay que trabajar con el único cuidador 00:48:16
que haya 00:48:18
entonces sin haber sobre escrito 00:48:20
el método equals 00:48:22
ejecutando esto 00:48:24
nos va a decir distintos ¿verdad? 00:48:26
nos va a decir distintos 00:48:28
y esto no tiene sentido 00:48:30
no tiene sentido 00:48:32
en el contexto de nuestra aplicación 00:48:34
no lo tiene 00:48:36
pero una vez que hayamos sobre escrito 00:48:38
el equals 00:48:40
según el sentido de nuestra aplicación 00:48:42
y el sentido es que 00:48:44
códigos iguales, cuidadores iguales 00:48:46
que todo esto viene 00:48:48
de haber hecho un buen análisis 00:48:50
claro, de ahí la importancia de los análisis 00:48:52
de entender la situación 00:48:54
de entender la aplicación 00:48:56
si hemos hecho un buen análisis 00:48:58
hemos llegado a la conclusión 00:49:00
es que en mi aplicación 00:49:02
los cuidadores tienen que tener códigos distintos 00:49:04
pues si yo después de haber hecho ese buen análisis 00:49:06
he llegado a que esa conclusión es así 00:49:08
pues entonces habré sobre escrito un equals así 00:49:10
y ahora ya cuando ejecutemos este main 00:49:12
pues lógicamente 00:49:14
ahora ya me va a decir que son iguales 00:49:16
me va a decir que los cuidadores son el mismo 00:49:20
y lo son 00:49:22
que son dos objetos distintos 00:49:24
con dos objetos distintos 00:49:26
me refiero 00:49:28
está este y está este otro 00:49:30
apuntado por ediciones distintas 00:49:32
pues sí, porque eventualmente la aplicación ha generado dos instancias 00:49:34
pero lo que importa 00:49:36
es el funcionamiento de la aplicación 00:49:38
¿vale? 00:49:40
y para que ese funcionamiento sea coherente 00:49:42
y consistente 00:49:44
pues hombre, tengo yo que incluir los criterios de igualdad 00:49:46
para poder usarlos cuando hagan falta 00:49:48
tengo que incluirlos 00:49:50
y aquí efectivamente estos dos cuidadores 00:49:52
pues según mi criterio de igualdad 00:49:54
son el mismo 00:49:56
y sobre escribir este método 00:50:00
es de vital importancia 00:50:02
para que luego todas las colecciones 00:50:04
todas las clases que nos van a usar 00:50:06
funcionen bien y tengan sentido lo que hacen 00:50:08
porque si no van a hacer cosas 00:50:10
sin errores 00:50:12
pero no van a tener sentido 00:50:14
¿vale? 00:50:16
bueno, ahora sí que vamos a parar aquí un momentito 00:50:18
se hace muy largo esto 00:50:20
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
8 de febrero de 2024 - 12:44
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
50′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
209.25 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid