Saltar navegación

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

Clase 6-02-24 - 2 - Contenido educativo

Ajuste de pantalla

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

Subido el 8 de febrero de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

bueno pues esto del equals 00:00:00
efectivamente tiene tanta 00:00:04
implicación práctica 00:00:06
tiene tanta trascendencia que de nuevo 00:00:09
el eclipse y 00:00:11
casi cualquier otro entorno de desarrollo 00:00:12
me deja generarlo de forma automática 00:00:14
y me ahorro escribirlo todo 00:00:17
pero cuidado porque estamos 00:00:18
utilizando muchísimo 00:00:21
esos recursos de vagos 00:00:22
y hay que tener cuidado 00:00:24
de que se usen cuando realmente se sabe 00:00:26
lo que uno quiere hacer 00:00:28
entonces voy a comentar mi versión 00:00:30
y a ver que genera 00:00:32
el eclipse 00:00:34
aquí de nuevo en source 00:00:35
pues uno tiene uno que pone 00:00:39
generar hashcode and equals 00:00:40
no deja por separado 00:00:43
hashcode and equals 00:00:46
entonces el te dice 00:00:47
lo que te saca aquí es a ver 00:00:48
cual es el campo que marca tu igualdad 00:00:50
entonces tu seleccionas 00:00:54
el código 00:00:56
con que los códigos de dos cuidadores 00:00:57
sean iguales pues eso para mi es la igualdad 00:01:00
podría ser que no, podría ser no 00:01:01
en mi aplicación 00:01:03
dos cuidadores sean iguales 00:01:05
si son iguales tanto el código como el nombre 00:01:08
depende 00:01:10
estas conclusiones derivarán del análisis que hayamos 00:01:11
hecho y del estudio que hayamos hecho 00:01:14
con el cliente de la aplicación con el que nos 00:01:15
explica con habremos estudiado la situación 00:01:18
al detalle todas las casuísticas que se pueden 00:01:20
dar pues después de haber estudiado 00:01:22
todos los requisitos 00:01:24
al dedillo de nuestra aplicación 00:01:26
y situación 00:01:27
podemos responder a estas cosas claro 00:01:29
entonces en nuestro caso a lo mejor la respuesta podría ser no no en mi caso 00:01:33
el código lo identifica de forma única 00:01:36
si el nombre es diferente es que se han hecho dos instancias porque uno se 00:01:39
llamó luis pepito y el otro luis 00:01:43
pero se refieren al mismo se refieren al mismo cuidado 00:01:45
bueno pues eso repito estas preguntas se tienen que resolver después de que uno 00:01:48
haya estudiado bien 00:01:52
su caso concreto bueno pues si en nuestro caso hemos decidido que el 00:01:53
código es lo que marca la unicidad es decir que es la clave primaria 00:01:57
pues marcamos solamente código venga general y cual saber cómo lo generas y 00:02:03
él me genera dos meje al jasco que ahora mismo no nos hace falta 00:02:09
pero va a ser fundamental más adelante también para mí me nos hace falta fuera 00:02:12
y nos genera un eequals como veis nos hace un equals un pelín más sofisticado 00:02:17
un pelín más sofisticado 00:02:24
¿Vale? Pero lo podemos entender perfectamente. 00:02:27
Él nos dice, a ver, si las direcciones de memoria son la misma, 00:02:31
ahí es que no hay más que mirar. 00:02:35
Obviamente es que los códigos van a ser el mismo. 00:02:37
Si las direcciones de memoria son la misma, es que están apuntando al mismo lado. 00:02:40
Entonces ahí está claro, el igual tiene que devolver true. 00:02:43
¿No hay otra? ¿Cómo no van a ser iguales los códigos 00:02:46
si las direcciones están apuntando al mismo sitio? 00:02:48
Ahí devuelve true. ¿Vale? 00:02:51
Luego te dice, a ver, si el objeto que le pasas es null, 00:02:53
entonces ya sé que es falso, que no puede ser igual que el otro. 00:03:01
¿Por qué no puede ser igual que el otro? 00:03:07
Porque me podríais decir, anda, y si el otro es null, son iguales. 00:03:09
¿Por qué no puede ser igual que el otro? 00:03:12
Porque es imposible que el que llama al método sea null. 00:03:17
Es imposible, porque un null no puede. 00:03:21
Si yo hago c1.equals y c1 es null, 00:03:23
es que ni entraría jamás al método. 00:03:29
No entraría, porque la máquina virtual me diría 00:03:31
e null pointer exception, ni entra. 00:03:34
Con lo cual, si he llegado a este punto, es porque he entrado en el método 00:03:37
o lo que es lo mismo, porque el objeto que lo llamo no es null. 00:03:40
Porque es que si no, no habría entrado, me habría salido un null pointer exception. 00:03:44
Entonces, si he llegado aquí, es porque el que le llamo no era null. 00:03:48
Con lo cual, si este sí lo es, 00:03:51
pues es que son distintos, obviamente, pues falsos. 00:03:53
Vale, ya tenemos dos casos que entendemos. 00:03:57
Ahora, este es un método, también de object, 00:04:01
que te devuelve la clase, o sea, un identificador, una cosa interna, 00:04:06
de la clase del objeto. 00:04:13
Ahora mismo, no hace falta que nos metamos en complicaciones en él, 00:04:16
simplemente, como está en object, lo puede llamar cualquier objeto. 00:04:19
Y te devuelve, empaquetado de una manera extraña, 00:04:23
codificado de una manera extraña, 00:04:28
cuál es el nombre de la clase a la que pertenece ese objeto, 00:04:30
el nombre de la clase. 00:04:34
Vale, pero no te lo devuelve en string, en string no. 00:04:36
Lo devuelve en otro formato. 00:04:38
Vale, pues entonces, este te dice, a ver, 00:04:40
si la clase a la que pertenece dis, 00:04:43
porque esto es como si hubiera aquí un dis, ¿verdad? 00:04:45
Porque cuando tenemos una llamada a un método al que nadie lo llama, 00:04:49
es como si fuera esto. 00:04:51
A lo mejor así lo veis más claro. 00:04:53
Pues si la clase del objeto que llama al equals es diferente de esta clase, 00:04:56
de nuevo, puedo devolver false, 00:05:01
porque es que no tiene sentido decir que los cuidadores son iguales, 00:05:03
si este objeto no es cuidador, o este no lo es, 00:05:07
o sea, que no pertenece a la misma clase. 00:05:10
Entonces, si no pertenece a la misma clase, 00:05:12
también puedo concluir que imposible que sean iguales. 00:05:15
Es que ni pertenecen a la misma clase, luego imposible que sean iguales, false. 00:05:17
Vale. 00:05:22
Entonces, si hemos llegado a este punto, 00:05:22
es porque ni ha salido por aquí, ni ha salido por aquí, ni ha salido por aquí. 00:05:23
Con lo cual, si hemos llegado a este punto es 00:05:29
porque este objeto obj no solo no es null, 00:05:32
sino que su clase es la misma que la que el que llama al método, 00:05:36
que es la misma. 00:05:40
Porque si no, habría salido por aquí. 00:05:41
Pues como ya sabemos que es la misma, 00:05:43
pues hace el casting sin ningún problema, 00:05:46
lo hace sin problema porque sabe 00:05:50
que la clase 00:05:52
de obj es la misma que la clase del objeto disk, que es cuidador. 00:05:53
Lo sabe, entonces hace el casting sin ningún problema, 00:05:57
lo convierte en este y ahora ya te devuelve 00:06:01
true si los códigos son iguales. 00:06:06
Vale, y es como si hubiera un disk, es lo mismo. 00:06:09
Te devuelve true si los códigos son iguales y falsos y son diferentes. 00:06:16
Entonces, es una versión un poquito más completa, 00:06:20
es una versión más completa. 00:06:22
Es una versión más completa. 00:06:22
Nosotros en el nuestro de arriba no habíamos distinguido si éste era null, 00:06:23
si la clase era distinta. 00:06:30
Nos habíamos lanzado a hacer el casting directamente confiando en que el que llamara 00:06:32
equal siempre lo iba a llamar pasándole un objeto cuidador distinto de null. 00:06:36
Entonces, si le pasa siempre un objeto cuidador distinto de null, 00:06:41
este equal funciona perfectamente. 00:06:44
El equals que teje en el eclipse es un poquito más completo porque considera todos los casos. 00:06:46
Que tú le pases un objeto cuidador distinto de null, 00:06:51
que tú le pases un null, 00:06:53
que le pases un objeto de otra clase distinta, 00:06:54
que no es cuidador, 00:06:56
te considera todos los casos. 00:06:57
Pero en última instancia, 00:07:01
si tú le pasas un objeto cuidador, 00:07:02
te devuelve true si los códigos son iguales 00:07:04
y falses y no, 00:07:06
que es de lo que se trata. 00:07:07
Que el equal se devuelva true o falsa. 00:07:09
¿Vale? 00:07:12
Bueno, pues entonces, de nuevo, 00:07:13
en general, 00:07:16
cuando uno tiene sus entidades ya definidas en una aplicación, 00:07:17
client de factura, no sé qué, no sé cuántos, 00:07:20
pues lo habitual es que en ellas se incluyan 00:07:23
los constructores, por supuesto, 00:07:25
los get y los set para acceder a las propiedades, 00:07:27
el toString por si alguien lo usa alguna vez 00:07:30
para mostrar una descripción, 00:07:33
como el system.out.println, por ejemplo, 00:07:36
que ya hemos visto que lo usa, 00:07:38
y el equals para recoger la condición de igualdad entre objetos, 00:07:40
para recogerla. 00:07:46
Habrá aplicaciones en las cuales 00:07:49
que la igualdad entre objetos no está recogida, 00:07:50
no importa, 00:07:53
porque no hay ninguna funcionalidad 00:07:54
que tenga en ningún momento 00:07:56
que distinguir si los objetos son iguales o no. 00:07:57
Pero es muy raro. 00:08:00
Es muy raro que una aplicación, 00:08:01
según se va ampliando en funcionalidad, 00:08:03
no necesite alguna vez 00:08:04
ver si los objetos son iguales. 00:08:05
Es muy raro que no lo necesite. 00:08:07
Entonces, por defecto, 00:08:09
lo natural es que se incluya en las clases de entidades 00:08:12
también una sobrescritura del equals. 00:08:14
Una sobrescritura del equals. 00:08:17
¿Y para qué esta sobrescritura? 00:08:19
Para que la sobrescritura sea correcta, 00:08:20
pues tengo yo que entender bien mi aplicación 00:08:22
y entender qué hace que dos objetos sean iguales. 00:08:24
Qué es lo que hace. 00:08:27
Si es el código, si es el código y el nombre, 00:08:28
si es no sé qué. 00:08:30
Y todo eso, de nuevo, 00:08:31
pues deriva de que yo entienda bien mi aplicación, 00:08:32
lo que tengo que hacer, 00:08:35
cómo tiene que funcionar, etcétera, etcétera. 00:08:36
Vale, luego es importante que entendáis bien todo esto, 00:08:42
porque ahora ya no se trata de 00:08:45
hago un programa, me funciona o no me funciona. 00:08:46
Programar no va de eso. 00:08:49
A ver, va, pues bueno, programas pequeñitos 00:08:52
que uno hace en plan divertimento. 00:08:54
Pues hacer factoriales, hacer no sé qué. 00:08:56
Vale, ahí sí va, me funciona o no me funciona. 00:08:57
Pero en general va de desarrollar aplicaciones 00:09:00
que funcionar, pues te van a funcionar. 00:09:02
Tú haces un código, lo despliegas en un servidor 00:09:04
y te hace cosas. 00:09:06
Pero esa aplicación puede ser una caca o no. 00:09:08
Funcionando igualmente. 00:09:12
Y que sea una caca o no. 00:09:13
Es decir, que lo que me saque, 00:09:15
pues sea realmente utilizable, tenga sentido. 00:09:19
Yo lo pueda luego ampliar. 00:09:22
Pues va a depender de tener mucho control 00:09:24
de todas estas cosas. 00:09:26
Esto ya no es me está funcionando o no me está funcionando. 00:09:27
Esto es, esto está bien hecho, 00:09:29
según los criterios de desarrollo. 00:09:31
Esto es usable, esto es reutilizable. 00:09:33
Esto es ampliable, que lo que se suele llamar es escalable. 00:09:36
O sea, yo puedo escalar y añadir otra funcionalidad fácilmente. 00:09:39
Esto le meta todos los casos de prueba que le meto. 00:09:42
Lo que me saca tiene sentido. 00:09:48
O a veces me saca cosas que, uh, qué raro. 00:09:50
¿Y cómo me saca esto? 00:09:52
Pues te saca esto, 00:09:53
pero no te das cuenta de que aquí no es sobre escrito este método. 00:09:54
Entonces te está tirando de otra cosa y tú no lo sabes. 00:09:56
Pero es importante que todo esto lo tengáis controlado. 00:09:59
Porque no es algo que se vea en, uy, me funciona o no me funciona. 00:10:03
No se ve así. 00:10:06
Entonces es difícil detectar por qué algo no funciona 00:10:08
si esto no está controlado. 00:10:12
¿Vale? 00:10:14
¿Eh? 00:10:19
¿Qué has dicho? 00:10:21
¿Qué es prueba de examen? 00:10:22
¿Qué es prueba de examen dices? 00:10:24
A ver, es muy difícil, es muy complicado. 00:10:26
En un examen de dos, tres horas, obviamente, 00:10:28
pues va a hacer algo que ponga en, que meta en cuestión de todas estas cosas. 00:10:31
Pero, pero aquí se trata de aprobar por un lado y luego de vuestro futuro. 00:10:39
O sea, aprobar solamente no vale. 00:10:46
Aprobar solo no vale. 00:10:49
Es aprobar y además haber sacado todo el aprobé. 00:10:52
Porque es que es imposible. 00:10:56
No podemos examinar de todo lo que van a esperar de vos, 00:10:57
de todas las destrezas que van a esperar de vosotros. 00:11:00
Es que no se puede, no se puede examinar. 00:11:02
No podemos poner una aplicación en la que estéis dos semanas 00:11:04
y la traigáis por razones obvias, pero la podéis copiar. 00:11:06
¿Vale? 00:11:09
Entonces, aprobar, hombre, es condición necesaria. 00:11:10
Pero para que a uno le vaya bien y no acabe en la calle rápidamente, 00:11:14
pues además tiene que aprovechar 00:11:18
todo lo que pueda estos dos años, 00:11:20
pues para coger, empaparse de todo lo que vea 00:11:23
y de todas las solturas que, 00:11:25
y de todo lo que de alguna manera os decimos 00:11:27
y vosotros mismos vais indagando por ahí. 00:11:29
Bueno, pues entonces. 00:11:32
¿Del equals? 00:11:35
¿Alguna duda? 00:11:37
El equals en realidad ya lo hemos venido usando. 00:11:40
Lo hemos venido usando con el famoso stream. 00:11:43
Con el famoso stream. 00:11:45
¿Verdad? 00:11:48
¿Qué ocurría? 00:11:50
Y ya con esto de verdad que me callo por ahora. 00:11:52
¿Qué ocurría con el stream? 00:11:59
Vamos a ver. 00:12:01
Vamos a poner aquí. 00:12:02
Sí. 00:12:05
Voy a ponerlo aquí. 00:12:09
Ejemplos de equals. 00:12:16
Con stream. 00:12:19
En mi main. 00:12:25
¿Vale? 00:12:26
Porque luego este proyecto 00:12:27
lo subo entero pisando el que había. 00:12:28
Bueno, para que tengáis ahí. 00:12:30
Vale. 00:12:39
¿Qué hemos hecho nosotros? 00:12:40
¿El equals hasta ahora nosotros para qué lo habíamos usado? 00:12:41
Exclusivamente para esto. 00:12:44
Nosotros a lo mejor hacíamos un objeto stream S1. 00:12:46
Imaginaos que le damos un valor. 00:12:48
Pues ya está. 00:12:50
Hola. 00:12:51
Hala. 00:12:52
Tengo yo aquí mi stream S1. 00:12:53
Y ahora pues tenemos otro stream por ahí. 00:12:54
Stream S2. 00:12:55
Hala. 00:12:56
Hala. 00:12:57
Hala. 00:12:58
Hala. 00:12:59
Hala. 00:13:00
Hala. 00:13:01
Hala. 00:13:02
Hala. 00:13:03
Hala. 00:13:04
Hala. 00:13:05
Hala. 00:13:06
Hala. 00:13:07
Hala. 00:13:08
Hala. 00:13:09
Hala. 00:13:10
Hala. 00:13:11
Hala. 00:13:12
Hala. 00:13:13
Hala. 00:13:14
Hala. 00:13:15
Hala. 00:13:16
Hala. 00:13:17
Hala. 00:13:18
Entonces esta es la clase de stream. 00:13:19
Es una clase que ya está hecha en la máquina virtual. 00:13:20
No la hemos hecho nosotros. 00:13:22
Y ahora que ya entendemos los objetos ya en detalle, podemos ver algunas cosas que hemos 00:13:23
estado usando de ella un poco así, con las buenas, que no salen muy bien. 00:13:30
Por ejemplo, esto es muy raro. 00:13:34
Si S1 es un objeto, desde cuando un objeto se puede instanciar sin un new. 00:13:36
Desde nunca. 00:13:41
¿No? 00:13:42
Siempre hemos dicho que S1 tiene una variable objeto. 00:13:43
declarada como objeto 00:13:46
y ese 1 lo es 00:13:48
para habilitar el espacio 00:13:49
hay que hacerlo con new 00:13:51
no hay otra 00:13:52
y eso es verdad 00:13:53
lo que pasa es que la clase string está hecha 00:13:55
de tal manera que la programó 00:13:57
la programó para permitir este truco 00:13:59
y ese es un truco 00:14:01
que nos evita tener que hacer esto 00:14:03
que es llamar específicamente 00:14:06
al constructor de string 00:14:09
pasándole el parámetro 00:14:10
para iniciar la propiedad 00:14:12
o sea, uno podría instanciar 00:14:13
un objeto string con la forma ortodoxa 00:14:16
new string 00:14:19
el constructor de la clase string 00:14:20
al que podríamos entrar 00:14:22
porque está en la máquina virtual 00:14:23
vemos que recibe una cadena 00:14:24
y la usa para inicializar 00:14:26
la propiedad interna del string 00:14:28
que se sea raíz de chat 00:14:30
podría usar el método ortodoxo 00:14:31
para instanciar un objeto string 00:14:35
pero claro, como los objetos string 00:14:37
se usan continuamente 00:14:39
pues la clase string está hecha 00:14:40
para que nos permita 00:14:42
este atajo 00:14:43
nos permite este atajo 00:14:44
que nada, yo pongo directamente la cadena 00:14:46
y la máquina virtual 00:14:47
pues cuando llame a la clase string 00:14:49
ya ve, entra en el atajo y ya está 00:14:51
entonces, primera cosa 00:14:53
que ya era rara 00:14:55
pero ya hemos aclarado 00:14:58
string es un objeto, hay que instanciarlo 00:14:59
es que no hay otra, hay que instanciarlo 00:15:01
pero la clase nos permite este atajo 00:15:02
que es, le digo directamente esto 00:15:06
y esto es como hacer new string 00:15:08
¿vale? eso por un lado 00:15:09
vale, siguiente cosa 00:15:13
cuando comparábamos dos string 00:15:18
yo os decía 00:15:19
no comparéis nunca el string 00:15:21
con doble o igual 00:15:24
¿verdad? 00:15:25
compararlo con equal 00:15:28
precisamente por eso, porque esto 00:15:30
con lo que yo he dicho 00:15:31
S1 y S2 00:15:33
¿vale? 00:15:36
son dos objetos distintos 00:15:37
son dos objetos distintos 00:15:39
son dos direcciones de memoria distintas 00:15:41
entonces, según esto, no lo probéis 00:15:43
no lo hagáis 00:15:45
porque ahora os explico luego lo que pasa 00:15:46
¿vale? no lo hagáis 00:15:49
entonces 00:15:50
cuando yo tengo un string S1 00:15:52
que tiene hola 00:15:55
un string S2 que tiene hola 00:15:56
el sentido real de mi aplicación 00:15:58
es que si yo quiero ver 00:16:02
si S1 y S2 son iguales es que me diga true 00:16:03
es el sentido real 00:16:05
como cuando quiero ver dos cuidadores 00:16:07
son iguales, el sentido real es que si los códigos 00:16:09
sean iguales me diga true 00:16:11
pues aquí a mí me da igual que S1 00:16:13
sea una dirección de memoria que apunte a hola 00:16:15
y que S2 sea otra que apunte a otro hola distinto 00:16:17
son dos objetos distintos 00:16:20
está claro, apuntados por dos direcciones 00:16:23
la S1 y la S2 00:16:24
pero lo que tiene sentido 00:16:25
que me dijeran que son iguales 00:16:29
la condición de igualdad 00:16:31
tiene que ser por el contenido 00:16:33
de la cadena, no por las direcciones de memoria 00:16:36
¿vale? 00:16:38
por eso es por lo que os insistíamos 00:16:39
cuidado, si quieres ver si dos cadenas son iguales 00:16:41
no las compares así 00:16:43
así no 00:16:46
porque si las comparas así 00:16:48
lo que te compara es 00:16:50
la dirección de memoria S1 00:16:51
con la dirección de memoria S2 00:16:53
y ese no es el sentido real de las cosas 00:16:54
el sentido real de las cosas es 00:16:57
yo quiero ver si esta cadena y esta cadena 00:16:59
tienen el mismo texto 00:17:01
entonces decíamos 00:17:02
no la comparéis así 00:17:05
comparadla 00:17:06
así 00:17:08
y esto ya es otra cosa 00:17:13
¿vale? 00:17:15
porque esto ahora como ya sabemos 00:17:19
equals está sobrescrito 00:17:20
en la clase string 00:17:23
no usa el equals de object 00:17:24
usa el equals que está sobrescrito en la clase string 00:17:25
que ahora ya se mete en las cadenas 00:17:29
a ver si son iguales 00:17:30
¿vale? 00:17:32
entonces 00:17:33
, nosotros si ejecutamos esto 00:17:43
pues nos saldrá 00:17:50
iguales 00:17:51
¿verdad? 00:17:53
ay, perdón 00:18:00
es que no lo he puesto en el else 00:18:01
ahí 00:18:02
ahí, vale 00:18:04
¿vale? 00:18:06
si ejecutamos esto 00:18:08
nos sale 00:18:09
obviamente que son iguales 00:18:13
son dos objetos distintos 00:18:15
pero son iguales 00:18:17
y sin embargo 00:18:19
si hago esto 00:18:20
pues me saldrá 00:18:22
obviamente que son distintas 00:18:23
las cadenas 00:18:25
¿está claro, no? 00:18:25
porque el equals que está usando 00:18:26
es el sobrescrito de la clase string 00:18:28
si entramos en 00:18:30
aquí 00:18:32
este es 00:18:35
el método 00:18:37
equals que está en la clase string 00:18:38
en esta clase 00:18:41
la clase string 00:18:43
y la clase string tiene 00:18:48
su método 00:18:51
equals 00:18:52
este 00:18:53
que sobrescribe 00:18:56
¿vale? 00:18:59
que sobrescribe el método equals de object 00:19:00
y mirad que lo sobrescribe 00:19:02
haciendo aquí 00:19:04
un montón de basurilla 00:19:05
¿vale? 00:19:07
hace aquí un montón de cosas raras 00:19:08
y lo que hace es meterse 00:19:09
en la propiedad que tiene el onSharp 00:19:11
a eso ni me interesa 00:19:13
que sea igual, etcétera 00:19:13
lo sobrescribe 00:19:14
porque si no lo sobrescribiera 00:19:15
estaría comprando las direcciones de memoria 00:19:16
¿vale? 00:19:18
bueno, pues aquí hemos estado usando 00:19:21
el equals 00:19:23
todo el rato 00:19:25
¿vale? 00:19:27
ahora ya entendemos 00:19:29
que el equals es un método 00:19:30
que puede usar cualquier objeto 00:19:31
porque lo hereda de object 00:19:32
pero si usamos la versión heredada 00:19:33
dos objetos son iguales 00:19:36
solos 00:19:38
y las direcciones de memoria son iguales 00:19:39
y si queremos añadir otro criterio de igualdad 00:19:40
lo tendremos que sobrescribir en la clase 00:19:43
¿vale? 00:19:45
bueno, entendido, entendido 00:19:52
todo lo de equals 00:19:54
vale, pues no se puede olvidar 00:19:56
porque afecta de forma directa 00:19:58
a cualquier aplicación 00:20:00
sobre todo si se manejan colecciones 00:20:01
se manejan una serie de historias 00:20:03
que vamos a tener que manejar 00:20:05
claro 00:20:06
¿vale? 00:20:07
entonces, según eso 00:20:13
con lo que yo he dicho 00:20:14
ahora ya con todo eso entendido 00:20:17
si yo ejecuto esto 00:20:20
¿qué me saldría? 00:20:21
si he cambiado el equals por doble igual 00:20:23
¿iguales o distintas? 00:20:25
porque está sin miedo 00:20:30
distintas 00:20:31
pues no 00:20:43
estas son las maravillas 00:20:46
de la programación que me encanta 00:20:53
claro 00:20:54
pero por otro pequeñito matiz 00:20:56
que ya es el último que me falta por incorporar 00:20:58
¿vale? 00:21:00
esto prácticamente no lo sabe nadie 00:21:02
porque nadie se encuentra 00:21:05
con esta situación porque todo el mundo pone 00:21:07
equals 00:21:08
¿vale? 00:21:09
pero es que desde cierta 00:21:11
versión de Java hay una pequeña particularidad 00:21:13
que hace 00:21:15
que pase esto 00:21:17
y podemos obviarla 00:21:19
y hacer como que no existe 00:21:21
usamos equals siempre 00:21:22
y eso sería lo correcto 00:21:24
cuando yo comparo objetos 00:21:26
en concreto string, equals siempre 00:21:27
¿vale? 00:21:30
pero hay una pequeñita particularidad que os añado 00:21:31
para que la sepáis, vosotros si vais a ser de los más listos 00:21:33
y es 00:21:36
que Java para ahorrarse 00:21:37
espacio y memoria 00:21:39
hasta cierta cantidad 00:21:40
de cadenas 00:21:43
que no sé si son hasta 1048 00:21:44
o las que sean 00:21:46
esta cantidad 00:21:47
si detecta que dos objetos cadena 00:21:47
tienen el mismo texto 00:21:51
¿vale? 00:21:53
si detecta 00:21:54
entonces los lleva al mismo sitio 00:21:55
y los hace apuntar por la misma dirección 00:21:57
para no duplicar 00:21:59
lo hace internamente él 00:22:01
entonces ¿qué ha pasado? 00:22:03
ahora nosotros solo tenemos dos cadenas 00:22:05
nosotros, ese uno y ese dos 00:22:06
entonces su manejo interno 00:22:07
dice ah lo llevo al mismo sitio 00:22:09
lo llevo al mismo lado 00:22:10
entonces ¿qué pasa? 00:22:12
pues al llevarlo al mismo lado 00:22:13
el efecto es que esto también se cumple 00:22:14
pero ojo con eso 00:22:17
porque eso es a partir de cierta cantidad de cadenas 00:22:18
entonces 00:22:21
lo mejor es que nos olvidemos de que eso ocurre 00:22:22
y de que Java hace eso 00:22:25
por ahorrar 00:22:26
cosas suyas 00:22:27
que nos olvidemos 00:22:30
lo mejor es que usemos siempre equals para comparar cadenas 00:22:31
y así jamás 00:22:35
nos equivocaremos, jamás 00:22:36
¿tú utilizas ahora mismo el método 3-5 00:22:38
para cada uno de los otros objetos? 00:22:40
bueno el método toString de String 00:22:43
te da directamente la cadena 00:22:45
es que no puedo porque está sobrescrito 00:22:47
al estar sobrescrito 00:22:54
en cuanto yo haga ese uno toString 00:22:58
el de object ya no vale 00:23:00
me va a mostrar siempre 00:23:01
el de String 00:23:03
pero a ver 00:23:05
el tema es que 00:23:07
Java hace internamente estas cosas 00:23:09
por un tema de eficiencia de uso suyo 00:23:10
pero la idea es 00:23:13
que no las tengamos en cuenta a la hora de programar 00:23:14
porque si las tenemos en cuenta 00:23:17
nos puede inducir a error 00:23:18
porque a ver, yo sé 00:23:20
que hasta cierto número de cadenas va a funcionar así 00:23:22
entonces me da igual 00:23:25
usar el equals que el doble igual 00:23:26
pero para qué arriesgarme 00:23:28
que más me da, pongo el equals y ya está 00:23:30
y sé que así no me voy a equivocar jamás 00:23:32
os lo ponía solo como anécdota 00:23:34
porque hay veces que les sale una cosa 00:23:36
y decís, ¿y esto por qué? 00:23:38
pues bueno, son pequeños detalles de funcionamiento interno 00:23:40
que podemos obviar 00:23:43
y trabajar con lo ortodoxo 00:23:44
que es, dos cadenas se comparan con el equals 00:23:47
y así jamás, jamás 00:23:49
va a salir un resultado erróneo 00:23:51
nunca, porque el equals está hecho 00:23:53
para comparar que los dos textos sean iguales 00:23:55
¿vale? 00:23:57
entonces esto como si no lo hubiera escrito 00:23:59
dos cadenas 00:24:01
¿por qué me sale este? 00:24:04
dos cadenas 00:24:07
se comparan siempre 00:24:08
con el equals 00:24:11
y listo 00:24:13
porque son objetos 00:24:14
esto es con lo que nos queremos quedar 00:24:16
¿vale? 00:24:18
¿vale? 00:24:25
bueno, pues por ahora 00:24:29
verencia, nos quedamos con todo esto 00:24:30
que en realidad ya es mucho 00:24:33
entre los días que llevamos ya es bastante 00:24:34
bueno, pues vamos a 00:24:36
poner aquí algún ejercicio 00:24:39
o algo para que 00:24:41
ya se vea bien 00:24:42
ya vosotros con vuestra cabeza 00:24:43
lo hagáis un poco ya organizadamente 00:24:44
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
8 de febrero de 2024 - 12:46
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
24′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
108.00 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid