Saltar navegación

Teoría Herencia parte 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 24 de enero de 2023 por Stefano C.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Sigo grabando, si decís algo es porque queréis y por lo tanto me autorizáis 00:00:00
Vale, hemos hecho este ejercicio rápidamente, vamos a ver más 00:00:06
Primero, existe una jerarquía de herencia en Java 00:00:12
Que quiere decir que como cada clase puede heredar de otra 00:00:17
Se crea una jerarquía, un árbol 00:00:23
Donde una persona hereda 00:00:26
Que sea un alumno 00:00:29
Hereda de persona 00:00:31
Que hereda de no se que 00:00:33
Que hereda de no se cuanto 00:00:34
Todos los objetos en Java 00:00:35
Por defecto 00:00:39
Sin que vosotros lo escribáis 00:00:41
Heredan de la clase 00:00:43
Object 00:00:45
Entonces 00:00:46
Todos los objetos 00:00:48
Que vosotros creéis en vuestra vida 00:00:50
Esa 00:00:52
Es un object 00:00:54
Existe esta clase super padre 00:00:56
Que todos los objetos, todas las clases derivan de aquí 00:01:03
Y por lo tanto todos los objetos en Java comparten algunas características 00:01:07
Algunos métodos, algunas partes de información 00:01:12
Porque todos importan desde el objeto 00:01:18
hasta si yo no escribo nada 00:01:22
pues en automático 00:01:24
extiende objeto 00:01:25
¿vale? si yo extiendo 00:01:28
desde alumno extiendo persona y persona 00:01:30
no extiende nada, persona extiende objeto 00:01:32
y por lo tanto estoy extendiendo también 00:01:34
objeto 00:01:36
por lo tanto cualquier clase 00:01:36
está extendiendo objeto 00:01:40
¿sí? 00:01:42
una clase puede o heredar 00:01:44
explícitamente de otra clase como 00:01:45
si yo ahora de 00:01:47
alumno extiende 00:01:48
persona o heredar implícitamente de la clase object. Si no escribo nada, en automático estoy 00:01:51
utilizando el evento. Y por lo tanto se me crea toda una estructura de todo lo que hemos visto nosotros. Por ejemplo, string puede ser de no sé quién que heredará de object. 00:01:58
A este punto 00:02:10
Vamos a mirar una cosa 00:02:15
Que va a ser de interés 00:02:17
Vuestro desde ahora 00:02:21
Para el resto de vuestra vida 00:02:22
Que se llama la API de Java 00:02:24
La API de Java es 00:02:26
Sostancialmente, nosotros hemos visto 00:02:29
Un par de clases o tres como 00:02:31
Scanner, String 00:02:32
Etcétera, etcétera 00:02:34
Que son clases que nosotros utilizamos 00:02:36
¿Vale? Pero no lo hemos hecho nosotros 00:02:39
En ningún momento vosotros habéis hecho public class scanner 00:02:41
Y os habéis puesto a programar 00:02:44
O public class string y os habéis puesto a programar 00:02:46
Pero la habéis podido utilizar 00:02:49
Esto porque Java, en su paquete, digamos, de desarrollo 00:02:51
Os incluye un mogollón de clases ya hechas 00:02:55
Y que vosotros podéis utilizar 00:03:00
Pero, ¿y estas clases cómo están hechas? 00:03:01
¿Qué métodos tienen? ¿Qué parámetros tienen? 00:03:04
No lo sé 00:03:07
Y entonces me voy a Internet, busco Java API y el nombre de la clase que quiero mirar 00:03:08
Por ejemplo en este caso queremos ver Object 00:03:18
Al darle Intro me salen cosas así 00:03:21
Y aquí por ejemplo tengo el API de Object 00:03:24
Si me voy al API de Object obtengo una página parecida a esta 00:03:30
Donde me dice, soy la clase object 00:03:34
Pertenezco al paquete java.lang 00:03:39
Mi nombre completo es java.lang.object 00:03:42
Y soy el objeto 00:03:47
La root of the class hierarchy 00:03:50
La raíz de la jerarquía de clases 00:03:54
Y aquí yo me puedo poner a mirar que tiene que ofrecer 00:03:58
Por ejemplo, me ofrece el object sin parámetros, como constructor, ¿vale? 00:04:02
Que es el constructor que siempre se llama cuando no hago un super, ¿vale? 00:04:08
Porque por defecto estoy llamando a... 00:04:14
Yo soy la clase, qué sé yo, ¿qué hemos hecho ahora? 00:04:17
La clase dispositivo. 00:04:20
Pues la clase dispositivo is a object. 00:04:22
Porque hereda, extiende. 00:04:25
Y por lo tanto, la primera cosa que se hace es llamar el constructor de object. 00:04:28
Este constructor de aquí 00:04:31
Que creará las cosas básicas para que tú puedas ser un objeto 00:04:33
A partir de allí, pondrás todas las cosas que te interese a ti 00:04:38
Pero esta es, digamos, una cosa escondida en nosotros 00:04:41
Que se hace por defecto para crear un objeto 00:04:44
Aquí se hará, aquí dentro, las cosas básicas 00:04:48
Que tiene que hacer la Java Vector Machine 00:04:52
Para poder crear un espacio de memoria donde crear un objeto 00:04:54
Y también tiene un montón de 00:04:57
Metoditos 00:05:03
Y algunos de estos metoditos 00:05:05
Los hemos visto 00:05:08
En algún momento 00:05:11
¿Os suena de algo? 00:05:12
¿Os suena de algo? 00:05:17
Estos métodos de aquí 00:05:24
En particular el equals 00:05:28
Y el toString 00:05:29
Son métodos interesantes 00:05:31
Porque los vamos a utilizar 00:05:33
Sobrescribiéndolos 00:05:35
En cuanto sepamos que es 00:05:37
Sobrescribir 00:05:39
Para que nuestros objetos 00:05:40
Se comporten 00:05:42
De alguna forma 00:05:44
Por ejemplo, el método toString 00:05:46
Devuelve una representación 00:05:48
En formato de string del objeto 00:05:51
Por defecto 00:05:53
Si yo hago el toString 00:05:58
Sobre cualquier objeto del mundo 00:06:00
Sin haber dicho nada 00:06:02
Me llama 00:06:04
El método toString de object 00:06:05
Yo tengo un dispositivo 00:06:08
El dispositivo es un objeto 00:06:10
Y por lo tanto cuando llamo el toString 00:06:11
Sobre el dispositivo me pillará 00:06:13
El de su padre que es object 00:06:15
¿Vale? 00:06:18
La, no sé si la habéis hecho alguna vez 00:06:20
En vuestra vida 00:06:22
Pero si vosotros pilláis un objeto 00:06:23
El objeto 00:06:25
De uno 00:06:27
Y le decís, oye, me imprimes de uno en pantalla 00:06:28
De uno, así 00:06:33
¿Qué hace? 00:06:36
Esto 00:06:42
En realidad, Java no debería hacer nada 00:06:43
Porque System.Auto.Println, ¿qué recibe aquí? 00:06:54
Un dispositivo 00:07:02
¿Qué ponemos normalmente aquí nosotros? 00:07:03
¿Qué tipo de datos ponemos aquí? 00:07:08
Un string 00:07:11
Este señor 00:07:12
Quiere aquí un string 00:07:14
Sin embargo le estoy dando un dispositivo 00:07:15
¿Y por qué no se queja? 00:07:18
Porque en realidad 00:07:21
Está haciendo esto 00:07:22
Oye, cuidado, pero 00:07:25
Esto yo no lo he declarado 00:07:30
No está escrito en dispositivo 00:07:33
En ningún lado el método toString 00:07:35
¿De dónde saco este toString? 00:07:36
De objeto, del objeto object 00:07:40
Es este tu string de aquí 00:07:46
¿Vale? 00:07:50
Entonces, si yo no le digo nada 00:07:55
Cualquier objeto tiene una forma 00:07:57
Para transformarse en un string 00:07:59
¿Vale? 00:08:02
Como es el caso aquí 00:08:03
Cuando Java dice 00:08:04
Mira, aquí necesitaría un string 00:08:07
Y tú me has puesto un objeto 00:08:09
Como yo necesito un string 00:08:11
Te lo voy a traducir a string 00:08:13
Utilizando el método toString 00:08:15
Que transforma tu objeto en una representación en formato string de tu objeto 00:08:18
Y como tú no me has dicho 00:08:23
Cómo se representa de forma string tu objeto 00:08:25
Un objeto dispositivo 00:08:30
Yo tiro de la representación genérica de un objeto 00:08:31
Que es la representación en formato string que me da object 00:08:36
El toString de object 00:08:39
¿Queda claro? 00:08:41
¿Y cómo podría hacer yo que mi dispositivo en vez de este código absurdo aquí 00:08:43
¿Dónde está? No 00:08:51
En vez de este código absurdo aquí 00:08:53
Me dijera algo como soy un dispositivo con número serial no sé qué 00:08:56
La forma sería irse al dispositivo y decir 00:09:03
Oye mira el dispositivo por algún lado aquí 00:09:12
Tú tienes un public string 00:09:15
Porque tienes que devolver un string 00:09:19
ToString 00:09:20
Este método de aquí 00:09:22
Espera que se han parado 00:09:25
Ah, sí, no 00:09:28
Tienes que devolver algo 00:09:29
Entonces string s es igual a esto 00:09:30
Return s 00:09:35
Este método de aquí 00:09:37
¿Es nuevo? 00:09:41
No, existía ya 00:09:43
¿Vale? 00:09:47
Existía como object 00:09:48
Y yo como este señor 00:09:49
No importando nada 00:09:52
Es como si estuviera 00:09:53
StandsObject 00:09:54
Por lo tanto ya lo tenía 00:09:56
Este método, de hecho ya he podido llamarlo 00:10:01
Sin codificarlo 00:10:03
Pero como ahora lo he vuelto a escribir 00:10:05
En un cierto sentido 00:10:07
Esto borra 00:10:09
Lo que es el toString 00:10:10
Del object 00:10:13
Y me pone este de aquí 00:10:14
De hecho si yo ahora vuelvo 00:10:16
¿Os acordáis que antes escribía esta cosa rara? 00:10:18
Vale, si yo ahora vuelvo 00:10:20
A lanzar esto, ¿qué me escribe? 00:10:22
Nada 00:10:26
Porque ahora cuando llama 00:10:27
El toString, llama este 00:10:31
ToString, y como este toString 00:10:33
Dice nada, pues me devuelve 00:10:35
Nada 00:10:37
Pero yo lo puedo cambiar como 00:10:38
Dispositivo 00:10:40
Num 00:10:43
Más numSerial 00:10:44
NumSerial 00:10:47
Número serial 00:10:48
Número serial 00:10:50
Y ahora cuando lanzo la prueba 00:10:52
Él me usa el toString 00:10:56
Del dispositivo 00:11:00
Está claro que si yo en vez de utilizarlo aquí 00:11:01
Lo utilizo sobre un móvil que pasa 00:11:05
Que pasará aquí al fondo 00:11:07
Si yo pongo M1 00:11:14
Me lo trata como si fuera 00:11:17
Un dispositivo 00:11:30
¿Vale? 00:11:32
Porque el móvil 00:11:33
Esto no aparece 00:11:35
Entonces va, digamos que el más cercano de móvil es la definición que está en su padre 00:11:36
Que es el toString 00:11:44
Entonces no necesita llegar hasta el object para trobar un toString 00:11:45
El móvil busca en su padre que es dispositivo 00:11:50
Aquí encuentra una definición de toString y usa esta 00:11:54
Y entonces hace esta cosa aquí 00:11:57
Si yo quisiera hacerlo una cosa distinta en el móvil 00:11:59
Copiaría esto aquí 00:12:04
En vez de dispositivo 00:12:06
Poner móvil 00:12:09
Y ahora 00:12:10
Cuando lo lanzo 00:12:13
Esto me dice dispositivo 00:12:17
Porque he llamado sobre un dispositivo 00:12:20
Y esto me dice móvil porque he llamado sobre un móvil 00:12:22
Sería buena 00:12:24
Praxis 00:12:29
Entre comillas 00:12:31
Que vuestros objetos 00:12:32
Cuando creáis objetos 00:12:33
Pues pongáis el toString 00:12:35
Para que en el momento en que 00:12:38
se imprime en pantalla 00:12:40
el toString se dé una representación 00:12:42
con sentido 00:12:44
de los objetos que estáis creando 00:12:45
si no, sale el codicilo 00:12:47
de antes, vamos a ver 00:12:50
que es el código de antes, fijaos 00:12:52
que pasa si yo borro esto 00:12:54
el de dispositivo 00:12:56
pero dejo el de móvil 00:12:57
¿qué pasará ahora? 00:12:59
que el móvil si te lo marca 00:13:03
pero el dispositivo 00:13:05
el móvil usa el de móvil 00:13:06
y el dispositivo 00:13:09
Usa el de su padre 00:13:10
El de object 00:13:13
¿Lo veis? 00:13:14
Como está hecho esto de object 00:13:16
Dice, ¿qué es esto? 00:13:17
Es la clase 00:13:23
¿Vale? 00:13:23
Entonces, por defecto 00:13:24
El toString de object 00:13:26
Crea un string que es 00:13:28
La clase del objeto 00:13:30
¿Vale? 00:13:32
De qué instancia es 00:13:33
Es una instancia de dispositivo 00:13:36
En posición 00:13:38
Un código raro 00:13:40
Esto, que no es verdad, pero lo podríamos pensar como una zona de memoria 00:13:42
Donde está guardado este objeto 00:13:48
En realidad esto es un código hash raro que hace cosas raras y cosas por el estilo 00:13:50
Pero la idea es que esto me representa en un cierto sentido 00:13:55
Donde está guardado mi ordenador, mi objeto 00:14:00
Es, en un cierto sentido, pensarlo así 00:14:06
Podría ser lo que está escrito en una referencia 00:14:10
¿Sabéis? Cuando yo digo esta variable es una referencia que apunta a un objeto 00:14:14
Pues esto es el código que representa dónde está este objeto 00:14:19
¿Sí? 00:14:25
No es exactamente así, ¿eh? 00:14:30
Por favor, tú que estás mirando el vídeo 00:14:31
No te enfades conmigo 00:14:34
¿Vale? 00:14:36
Pero una simplificación suficiente 00:14:37
Para entenderlo un poquito 00:14:40
¿Sí? 00:14:41
Vale 00:14:43
Sigamos 00:14:44
Entonces, acordaos que cualquier 00:14:46
¿Cómo se llama esto? 00:14:48
Cualquier clase que vosotros creéis 00:14:51
Directamente tira de este señor de aquí 00:14:53
Tened en cuenta también que si queréis 00:14:56
Tener más información sobre el ToString 00:14:58
Pincháis aquí 00:15:00
Y aquí viene 00:15:01
No, este es Notify, pero está por el lado 00:15:02
y os explica 00:15:04
que es, como funciona 00:15:08
para que sirve, bla bla bla 00:15:10
de hecho aquí 00:15:12
os dice 00:15:14
que es lo que viene después de la arroba 00:15:16
que es una 00:15:20
unsigned hexadecimal representation of the 00:15:21
hash code of the object 00:15:24
entonces no es exactamente donde se pone 00:15:25
pero bueno 00:15:28
entonces aquí lo podéis mirar 00:15:31
Pero es más que esto 00:15:34
Vosotros aquí, en este mundo maravilloso del API 00:15:35
Podéis ir a miraros todas las clases que nosotros hemos visto 00:15:39
Como por ejemplo, puedo irme a mirar string 00:15:45
Y ver todos los constructores de string 00:15:48
¿Vale? 00:15:52
Que son estos 00:15:54
String, string a través de un byte de bytes 00:15:55
String a través de un bar de... 00:16:00
¿Os acordáis el otro día cuando hicimos el ejercicio dado un array de char, sácame un string? 00:16:03
Si yo sé que existe esto, que hay un constructor de string que pilla un array de char, 00:16:10
eso se hace con new string del array de char. 00:16:23
Y aquí hay todos los posibles constructores de string. 00:16:29
Y luego empiezan todos los métodos de string 00:16:35
A lo mejor 00:16:38
Reconoceréis este método de aquí 00:16:40
Que lo hemos usado alguna vez 00:16:42
El charat 00:16:44
Pero hay un montón 00:16:45
Hay el compare to, hay el concat 00:16:48
El contains 00:16:50
¿Os acordáis eso de 00:16:51
Dada una secuencia de caracteres 00:16:52
Buscarla dentro de un string 00:16:55
Aquí la tenéis 00:16:57
Ya implementada 00:16:59
Y probablemente más eficiente 00:17:01
De lo que hacéis vosotros 00:17:03
¿Vale? 00:17:04
Copy, value, ends, width, equals 00:17:06
¿Esto suena de algo? 00:17:10
¿Dónde lo hemos visto? 00:17:13
Sí, pero ¿dónde lo hemos visto hace un minuto? 00:17:15
Este es object, ¿eh? 00:17:28
Este método de aquí no es un método de string 00:17:32
Es una sobrescritura del método de object 00:17:34
Que en vez de comparar dos objetos entre ellos 00:17:39
Compara dos strings entre ellos 00:17:42
Fijaos que recibe un objeto, no un string 00:17:44
¿Por qué? 00:17:50
Porque el que está en object trabaja con objetos, no con string 00:17:52
Entonces estoy forzado a reutilizar esto 00:17:58
Pero bueno, estas cosas con más calma en un futuro 00:18:02
Lo único es que a veces podéis echarle un vistazo a las nuevas clases que nosotros vamos a ver. 00:18:05
Dedicad un poco de tiempo para ir a la API de esa clase y mirar qué se puede hacer con esa clase. 00:18:15
El 70% de los ejercicios sobre string que hemos hecho son sustancialmente lo mismo. 00:18:24
mismo que ya están implementados en la clase string no necesitaba implementarlo vosotros 00:18:32
cuando yo soy un programador y sé programar no vuelvo a rehacer el búscame una cadena dentro 00:18:41
de otra cadena porque ya está implementado ya me han implementado y no vuelvo a implementar 00:18:48
Yo cada vez que lo uso, uso el contains 00:18:54
¿Vale? O uso 00:18:56
Todo lo que me da aquí, start to string 00:18:57
To lowercase 00:19:00
¿Vale? Dame una frase 00:19:01
Una secuencia en mayúsculas 00:19:04
Y te la pone en minúsculas 00:19:06
Pues aquí lo tenéis 00:19:08
Esto 00:19:09
¿Sí? Entonces 00:19:11
Acordaos 00:19:16
Y esto con todas las clases 00:19:17
De multiverso ya creadas 00:19:20
De Java 00:19:22
vale si vosotros buscáis cárner y tenemos nuestro escáner 00:19:24
vale con todos sus métodos incluidos eso de nex 00:19:32
next in the next double etcétera o sea que aquí están todos lo que podéis 00:19:39
utilizar 00:19:47
Entonces acordaos 00:19:50
Porque esta es una herramienta muy potente 00:19:52
El API 00:19:54
Vosotros podéis buscar allí un montón de información 00:19:55
Cuando encontréis a partir de ahora 00:19:58
Una clase nueva 00:20:00
Echadle un vistazo en el API 00:20:01
Para ver que puede hacer esa clase 00:20:03
Que os proporciona 00:20:05
Sigamos con nuestra herencia 00:20:06
Entonces 00:20:10
Hemos ya creado constructores con herencia 00:20:11
Fijamos algunos puntos 00:20:14
Cuando yo creo un objeto nuevo 00:20:17
Paso siempre por dos puntos 00:20:21
¿Vale? Por dos partes 00:20:23
La primera parte es que creo su parte base 00:20:24
Su parte que hereda 00:20:27
¿Vale? Creo mi padre, sustancialmente 00:20:29
Y después añado la parte propia de esta clase 00:20:32
Esto pasa siempre 00:20:37
Hasta una clase que no extiende nada 00:20:38
Porque siempre crearé en el punto uno 00:20:40
Llamo al objeto, a object 00:20:43
Creo todo lo que está en el constructor de object 00:20:45
Y una vez que he creado el objeto 00:20:51
Que es la parte base 00:20:54
Creo todo lo que yo creo 00:20:55
Que he dicho que existe 00:20:57
En mi clase dispositivo 00:20:59
En mi clase persona 00:21:00
En mi clase lo que sea 00:21:01
Pero es siempre así 00:21:03
Si yo soy una clase que extiende otra clase 00:21:05
Pues este paso 00:21:12
Se vuelve, el paso uno se vuelve a rehacer 00:21:14
Por cada extensión que he hecho 00:21:16
O sea, alumno que extiende persona 00:21:18
Hará el primer paso con 00:21:21
Persona extiende object 00:21:24
Por lo tanto, creo object 00:21:26
Le añado lo que es persona 00:21:28
Y por lo tanto, he creado una persona 00:21:29
Y a este punto le añado lo que es 00:21:31
Alumno 00:21:33
¿Vale? 00:21:36
Una cosa de ese estilo aquí abajo 00:21:36
Si yo tengo alumno que hereda de persona 00:21:38
El paso uno de crear 00:21:43
El paso uno de crear alumno es 00:21:46
Crear la parte correspondiente a persona 00:21:49
Creo lo que yo extendo 00:21:52
Y para crear la persona 00:21:54
Tengo que crear object 00:21:56
Y después de haber creado object 00:21:58
Añadir las cosas de persona 00:22:02
Y entonces he creado la persona 00:22:04
Y paso al punto 2 00:22:07
Donde añado las cosas de alumno 00:22:08
Entonces siempre creo lo más general 00:22:11
Y luego voy añadiendo la parte más concreta 00:22:17
Y más específica de esta clase en concreto 00:22:21
Constructores y herencia 00:22:24
En el constructor de la clase de base 00:22:30
Se realiza siempre una llamada a constructor de la clase de base 00:22:33
Una llamada a constructor super se hace siempre 00:22:35
Solo que puede ser implícita o explícita 00:22:39
¿Vale? 00:22:42
Explícitamente lo puedo escribir yo 00:22:43
O implícitamente si no pongo nada 00:22:45
En automático lo hace él 00:22:47
¿Vale? 00:22:48
La llamada al constructor de la clase base 00:22:51
De la superclase 00:22:54
Es la primera acción que tiene que hacer el constructor 00:22:55
No puedo llamarla super 00:22:58
Hacer una suma y luego llamar super 00:22:59
¿Vale? 00:23:01
Lo tengo que llamar en la primera línea 00:23:02
Porque antes creo, digamos, el entorno donde me estoy moviendo 00:23:04
Mi superclase 00:23:07
Y lo haga para que ya haga otras cosas 00:23:08
¿Vale? 00:23:11
Y puede ser que esta llamada 00:23:13
Al super constructor 00:23:15
¿Vale? Constructor de super 00:23:17
Es o no lo indico específicamente 00:23:18
O lo indico específicamente 00:23:21
Que entonces es en la prima línea 00:23:23
¿Vale? Ejemplo 00:23:24
Si no lo indico específicamente 00:23:26
Fijaos aquí 00:23:28
Es donde él 00:23:29
A escondida 00:23:32
Invisiblemente hace una llamada 00:23:34
A super 00:23:37
Esto 00:23:38
El constructor por defecto 00:23:41
De mi padre 00:23:44
Cuidado, si yo el constructor por defecto 00:23:45
De mi padre se lo he quitado 00:23:47
Esto es flojo 00:23:49
Porque intenta llamar esto 00:23:51
Y esto no está 00:23:54
Y da un error 00:23:56
Probémoslo 00:23:57
Entonces, en el ejemplo que hemos hecho nosotros 00:23:59
Por ejemplo, pillamos móvil 00:24:06
¿Vale? 00:24:08
Móvil 00:24:09
Imaginémonos 00:24:10
A ver, el dispositivo 00:24:15
Tiene solo esto, ¿vale? 00:24:17
El dispositivo no tiene un 00:24:19
Un método así, un constructor así 00:24:22
Esto sería el constructor por defecto 00:24:26
¿Vale? 00:24:31
Si yo creo un constructor cualquiera 00:24:33
Como este de aquí 00:24:36
Pues el constructor sin parámetros desaparece 00:24:37
A menos que yo no lo vuelva a implementar 00:24:40
Explícitamente así 00:24:42
Y poniendo aquí lo que tiene que hacer 00:24:44
En el caso en que no me ponga los parámetros 00:24:46
¿Vale? 00:24:48
Imaginémonos que no está 00:24:50
Y que yo desde móvil 00:24:51
Intente hacer esto 00:24:54
Esto explota 00:24:56
¿Vale? 00:24:58
Porque no existe 00:25:01
Un constructor de dispositivos 00:25:02
Sin parámetros 00:25:05
Realmente 00:25:06
Esto también se enfada 00:25:08
Porque como aquí no estoy llamando nada 00:25:10
En este punto de aquí 00:25:14
Me está llamando él solo 00:25:16
Esta 00:25:18
Y como no está definida aquí 00:25:18
Pues entonces no lo tiene 00:25:22
Dice, no lo puede hacer 00:25:24
No se puede construir un móvil 00:25:25
Con este 00:25:27
Super constructor 00:25:30
Y como no puedo construir tu padre 00:25:31
No te puedo construir a ti 00:25:34
¿Se entiende? 00:25:35
¿Tienes dudas? 00:25:40
Entonces, y si yo quisiera utilizarlo, pues debería ir aquí 00:25:40
Y decirle, oye mira el dispositivo, tendrás también un constructor sin parámetros 00:25:48
Que dará como número serial un número vacío 00:25:56
Ahora ya tiene el constructor sin parámetros 00:25:59
Entonces esto puede llamar super sin parámetros 00:26:04
Así como puede llamar nada 00:26:07
¿Veis que ahora no me da error? 00:26:09
Porque lo que hará es por defecto 00:26:11
Llamar super sin parámetros 00:26:14
Tú das 00:26:16
¿Vale? 00:26:20
Esto es, si no indico explícitamente 00:26:23
Si no digo nada dentro de un constructor 00:26:25
Y hago cosas 00:26:28
Nosotros hemos hecho constructores 00:26:29
Hasta ahora 00:26:32
¿Sí? En las clases que hemos hecho nosotros 00:26:33
¿Habéis alguna vez utilizado super 00:26:36
Paréntesis, paréntesis? 00:26:38
Sin embargo, todas vuestras clases 00:26:41
Heredan de Object 00:26:44
Habrían tenido que hacerlo 00:26:46
¿Vale? 00:26:48
Pero él lo ha hecho por defecto 00:26:50
¿Está claro? 00:26:55
¿Sí? 00:26:57
Y como Object tiene un constructor 00:26:57
Sin parámetros, pues entonces funciona 00:27:00
Y si no 00:27:02
La segunda opción es 00:27:04
Ponerlo explícitamente 00:27:05
Llamo a este 00:27:07
Constructor 00:27:09
Y le puedo poner los parámetros 00:27:11
Para decirle de los constructores 00:27:13
Que pueda tener mi padre 00:27:15
Que puede tener, habéis visto string 00:27:16
Que tiene como 10, 15 constructores distintos 00:27:18
Voy a utilizar el que recibe 00:27:20
Un string, otro string 00:27:22
Y un número 00:27:24
Entonces 00:27:25
Constructores o no lo pongo 00:27:34
Entonces llamo por defecto super 00:27:37
Sin parámetros o si no indico 00:27:39
Especialmente en la primera línea 00:27:41
Del constructor 00:27:43
Que super constructor 00:27:44
Pido 00:27:47
Vale, uso 00:27:48
Hasta aquí, dudas 00:27:50
Esto de la herencia 00:27:56
Conlleva también 00:28:02
Dos 00:28:04
Conceptos más, dos cosillas 00:28:05
Que se puede hacer con la herencia 00:28:07
Que son los shadowing 00:28:09
Y el overriding 00:28:10
Esto es como 00:28:12
Se relacionan 00:28:15
Entre dos clases 00:28:17
Que una extiende a la otra 00:28:19
Entonces clase padre, clase hijo 00:28:20
La relación entre 00:28:22
Atributos 00:28:24
Y entremétodos 00:28:26
¿Vale? 00:28:27
Vamos a ver 00:28:30
¿Qué se puede hacer? 00:28:31
Un atributo, ¿vale? 00:28:32
En la clase hijo 00:28:35
Puede tener el mismo nombre 00:28:36
De la clase base 00:28:39
De la clase superclase 00:28:41
¿Vale? 00:28:43
Y hasta distinto tipo 00:28:44
¿Vale? 00:28:46
Mismo nombre, pero el tipo que te da la gana 00:28:47
O el mismo, o otro 00:28:50
Si tú haces así 00:28:51
Estás ocultando 00:28:53
Haciendo sombra 00:28:55
¿Vale? Shadowing 00:28:57
Al atributo del padre 00:28:59
¿En qué sentido? 00:29:03
Pensad por ejemplo dispositivo 00:29:07
¿Vale? Dispositivo tiene 00:29:09
Esto por ejemplo, boolean encendido 00:29:11
¿Vale? Entonces cuando yo voy 00:29:15
A móvil, aquí 00:29:17
Está pensado que existe 00:29:19
Encendido como boolean 00:29:21
¿Y qué pasa si yo hago int encendido? Que el encendido del dispositivo como booleano sigue allí para los dispositivos, pero para los móviles encendido es un int. 00:29:22
Entonces ahora 00:29:45
Si yo tengo un móvil 00:29:48
Acceder al booleano 00:29:49
Es complejo 00:29:51
Lo estoy bloqueando 00:29:53
Lo estoy ocultando 00:29:55
Si yo soy un dispositivo 00:29:56
Seguiré 00:29:57
No, si yo soy un dispositivo 00:29:58
Y le digo 00:30:02
Donde está 00:30:03
Aquí de uno punto 00:30:05
Que era esto encendido 00:30:07
No puedo 00:30:09
Que no me 00:30:11
Ah, encendido 00:30:29
Ahora sí 00:30:32
Y punto encendido 00:30:33
Ten en cuenta que aquí 00:30:36
Le pasaré 00:30:42
Vale, vamos a ver 00:30:44
Y entonces cuando yo creo un móvil 00:30:46
Por ejemplo 00:30:48
A encendido 00:30:49
Le pongo cero 00:30:51
Vale 00:30:53
Entonces, ¿qué me escribirá esta cosa aquí? 00:30:54
Esta cosa aquí 00:30:59
¿Y qué me escribirá? 00:31:00
False 00:31:04
¿Y esta? 00:31:04
Cero 00:31:08
False y cero 00:31:09
¿Sí? 00:31:16
Entonces, esta cosa de aquí 00:31:20
De poder cambiar un 00:31:22
Un atributo 00:31:24
¿Vale? A otro atributo 00:31:26
Que sea hasta 00:31:29
De tipo distinto 00:31:30
Se llama Shadowing 00:31:31
Esencialmente lo que estoy haciendo es que desde un hijo 00:31:33
Impido a objetos de este hijo 00:31:36
O de los que están por debajo de este hijo 00:31:39
¿Vale? 00:31:42
Acceder al mismo 00:31:43
Atributo de un padre 00:31:45
¿Vale? 00:31:49
Porque le estoy haciendo sombra 00:31:49
¿Vale? Literalmente 00:31:51
Shadow 00:31:52
¿Para qué sirve? 00:31:53
Porque a lo mejor en determinados casos 00:31:55
Un valor que en general 00:31:57
Tiene un cierto sentido 00:31:59
Cuando paso a algo extendido 00:32:00
No lo quiero poder utilizar 00:32:03
Porque en la versión más 00:32:05
¿Cómo se dice esto? 00:32:07
Más específica 00:32:09
No tiene el mismo significado que la versión 00:32:10
Generalizada 00:32:13
¿Vale? Y entonces allí de alguna forma 00:32:15
Quiero bloquearlo 00:32:17
¿Vale? No es una cosa que yo haya visto 00:32:18
Muchas veces en mi carrera 00:32:21
¿Vale? Pero 00:32:23
Existe y se puede hacer 00:32:24
¿Sí? 00:32:26
Entonces este es shadowing 00:32:29
Que si no me equivoco aquí hay un ejemplo 00:32:31
¿Vale? 00:32:33
este de aquí por ejemplo 00:32:34
yo tengo la clase persona 00:32:36
la clase alumno que extiende persona 00:32:38
hay un nombre que 00:32:40
cuando es una persona el nombre 00:32:42
es un string y cuando 00:32:44
es un alumno el nombre es 00:32:46
su identificador 00:32:48
como alumno 00:32:50
cuando luego llego aquí en el main 00:32:51
y le digo que 00:32:54
escriba 00:32:56
el nombre de una persona me escribirá 00:32:57
el nombre de la persona cuando le digo 00:33:00
escríbeme el nombre del alumno 00:33:02
me escribirá el número 00:33:04
lo mismo que hemos hecho ahora 00:33:05
con dispositivo y cosas parecidas 00:33:08
entonces no se puede hacer con el super 00:33:09
de acceder a esa 00:33:16
variable 00:33:19
al booleano 00:33:21
al booleano 00:33:24
con el super a prior 00:33:25
no deberías acceder al del padre 00:33:27
vamos a ver 00:33:29
porque creo que después lo digo 00:33:31
podemos acceder a variables de la subclase 00:33:34
o de la superclase utilizando this o super 00:33:35
O sea que yo 00:33:37
Si desde el móvil 00:33:39
No uso encendido 00:33:41
Dis.encendido 00:33:43
Si no uso super.encendido 00:33:45
Entonces estoy accediendo 00:33:48
Al encendido de mi padre 00:33:49
Entonces ahí volverá a ser bueno 00:33:50
Es esto 00:33:52
Con calma 00:34:00
Llegamos 00:34:02
Es que si no complicamos la cosa 00:34:03
Entonces hay esta posibilidad 00:34:06
Lo shadowing 00:34:08
De ocultar a nivel de hijo un parámetro, un atributo que está en mi padre 00:34:09
Entonces la idea es, una vez ocultado no puedo acceder a ello 00:34:18
Pues sí, hay formas de hacerlo 00:34:22
Entonces, si definimos en una subclase un atributo del mismo nombre 00:34:24
El mismo tipo o tipo distinto que la superclase 00:34:31
La de la superclase queda oculta 00:34:35
Hasta aquí hemos llegado 00:34:37
Para acceder a la subclase o la superclase 00:34:38
Puedo utilizar dice super 00:34:42
¿Qué quiere decir esto? 00:34:44
Si yo desde aquí uso encendido 00:34:46
En cualquier lado, como aquí por ejemplo 00:34:51
Pues claramente estoy escribiendo mi encendido 00:34:54
Si en algún lado 00:34:58
Esto ahora ya no es un booleano, ¿vale? 00:35:00
Entonces le tengo que poner así por ejemplo 00:35:03
Si yo aquí quisiera en algún lado escribir mi padre 00:35:05
Por ejemplo, podría crear un método 00:35:12
¿Vale? 00:35:14
Donde quiero escribir los dos valores 00:35:23
¿Vale? 00:35:27
Entonces 00:35:30
Mi encendido 00:35:31
No, encendido móvil 00:35:33
Móvil encendido 00:35:35
Y aquí escribiría 00:35:36
This.encendido 00:35:40
¿Vale? 00:35:43
Y si en vez quiero 00:35:45
acceder al de mi padre 00:35:47
puedo acceder a él 00:35:49
como supe 00:35:55
punto excelido 00:35:56
entonces si desde aquí 00:35:59
en algún lado 00:36:04
llamo a 00:36:05
m1.test al final 00:36:08
m1.test 00:36:10
veis que 00:36:12
para el móvil 00:36:19
encendido es un cero 00:36:21
pero para dispositivo encendido es falso 00:36:22
tened en cuenta que lo estoy 00:36:26
llamando desde los dos desde móvil es este método de aquí a tener en cuenta 00:36:27
que son dos variables distintas no es que 0 corresponde a falsa 00:36:36
si yo cambio 0 a 35 pues el de mi padre se queda falsa son dos variables 00:36:40
distintas guardadas en sitios distintos 00:36:45
Pero es más, ¿vale? 00:36:51
Porque esto yo lo puedo hacer desde el móvil 00:36:54
Pero si estuviera aquí 00:36:58
No tengo súper 00:37:00
En esta prueba no tengo súper para acceder al padre del móvil 00:37:03
Entonces, o el móvil me proporciona un método para que yo pueda acceder al súper 00:37:08
¿Vale? 00:37:15
O si no, no lo puedo acceder 00:37:16
O sí 00:37:19
Está esta otra cosa de aquí 00:37:21
¿Vale? 00:37:24
Imaginémonos 00:37:26
Una situación como esta 00:37:27
Tengo transporte 00:37:29
Transporte puede ser tren 00:37:32
O un vehículo 00:37:34
Y vehículo puede ser la moto o un coche 00:37:35
¿Vale? 00:37:38
Y yo tengo, estoy en coche 00:37:39
Creo, ¿vale? 00:37:41
Que es la clase hija 00:37:42
Fijaos que 00:37:44
Este 00:37:45
¿Cómo se llama? 00:37:48
A estos niveles 00:37:51
El mismo 00:37:52
La misma 00:37:53
¿Cómo se llama? 00:37:56
El mismo atributo se sobrescribe 00:37:57
Se está haciendo shadowing 00:37:59
Sin cambiarle de tipo 00:38:00
Pero se está haciendo 00:38:03
Para que a nivel de esto 00:38:05
Ponga ferraria 00:38:08
A nivel de esto ponga turismo 00:38:09
A nivel de esto ponga terrestre 00:38:10
Cuando yo pongo el nombre 00:38:12
Pues entonces 00:38:13
Si yo estoy en el coche 00:38:16
Y pongo nombre a secas 00:38:18
Estoy hablando de este nombre de aquí 00:38:21
Nombre a nivel de pollo 00:38:24
Si yo pongo dis.nombre 00:38:25
Sigo hablando de esto 00:38:29
De este objeto 00:38:31
Si yo pongo super.nombre 00:38:33
Estoy hablando 00:38:38
De mi padre 00:38:39
Nombre, por lo tanto esto 00:38:41
¿Si? 00:38:43
Y vosotros podéis, ah bueno 00:38:47
Antes de otro paso 00:38:49
Puedo hacer un casting explícito 00:38:50
Decir, pilla this 00:38:54
Soy yo, soy un coche 00:38:56
Considérame un vehículo 00:38:58
Y una vez que me has considerado un vehículo 00:39:01
Haces a mi nombre 00:39:05
Entonces si a mí me considero un vehículo 00:39:06
Yo soy un vehículo, un coche es un vehículo 00:39:08
Pero ahora estaré aquí 00:39:10
Y entonces me escribí esto 00:39:12
Lo que no se hace bajo ningún concepto es esto 00:39:14
Super super no 00:39:21
Tampoco ultra 00:39:23
No se puede llamar dos veces super 00:39:25
Esto está mal 00:39:29
Y como hago esto 00:39:30
Pues con esta misma forma aquí 00:39:31
En vez de hacerme un casting 00:39:33
A vehículo 00:39:35
Hago un cast a transporte 00:39:36
Digo 00:39:40
Este es un objeto coche 00:39:41
Que es un vehículo que es un transporte 00:39:42
Por lo tanto yo también soy un transporte 00:39:44
Ahora considerame como si fuera un transporte 00:39:46
Y accede al nombre 00:39:48
Pues entonces es este 00:39:50
¿Los paréntesis sí o sí hay que ponerlos? 00:39:51
No valdría solo tres paréntesis de transporte 00:39:58
Transporte tipo 00:40:00
Yo lo pondría por claridad 00:40:01
Porque si tú no los pones 00:40:03
Esto de transporte podría ser que dis.nombre 00:40:05
Lo que sea 00:40:08
Lo que sea el resultado de dis.nombre 00:40:09
Tráctamelo como un transporte 00:40:11
Dis.nombre es un string 00:40:13
Entonces no te puede hacer un casting de un string a un transporte 00:40:14
Entonces sería cual 00:40:17
Esto es por preferencia de operadores 00:40:18
Para que sea claro que este transporte 00:40:23
Se aplica a TIS 00:40:25
Pues entonces tú pones que pilla lo que tú dices 00:40:26
Considera un transporte 00:40:29
Y ahora cede a su punto 00:40:31
¿Cómo sería en nuestro caso? 00:40:32
Vamos a probarlo 00:40:36
Entonces nosotros 00:40:37
Borro un poco de esto 00:40:42
Dejo los móviles 00:40:44
Entonces 00:40:49
ahora nosotros estamos así hemos creado un dispositivo y un móvil si yo hago no 00:40:50
me quiere escribir si yo ahora digo a nivel de móvil vale y le digo m1 punto encendido 00:41:06
él me escribe móvil y si ahora le digo oye sí pero escríbeme esto pero a m1 considera 00:41:23
melo un dispositivo y m1 trátalo como un dispositivo asume que es un dispositivo 00:41:42
Y acceda a encendido 00:41:57
¿Qué me pone? 00:41:59
¿Make sense? 00:42:08
Entonces 00:42:12
La idea es que puedo acceder 00:42:13
A varios, puedo hacer lo que me da la gana 00:42:17
Con estas cosas, ¿vale? 00:42:19
La idea es que existe 00:42:21
Este mecanismo, que es el 00:42:23
Shadowing, donde sostancialmente 00:42:25
Puedo un atributo 00:42:27
De otro 00:42:29
De mi clase padre 00:42:30
Ocultarlo de alguna forma 00:42:33
Impedir que se acceda directamente 00:42:34
Esto no quiere decir que no puedo luego recuperar esa cosa 00:42:36
Pero puede ser que este mismo valor, este mismo encendido 00:42:40
Para un móvil tenga un valor y para un dispositivo tenga un valor 00:42:45
Y yo normalmente cuando uso móvil, si lo uso encendido lo utilizo como móvil 00:42:50
En un particular caso en el que ahora necesito utilizarlo como si fuera un dispositivo 00:42:54
Pues siempre puedo acceder a él a través de un casting explícito 00:43:00
Diciéndole, oye, mira, esta cosa aquí 00:43:03
No me la trates como móvil, me la trato como dispositivo 00:43:05
Como existe 00:43:08
Una herencia y una relación 00:43:10
De es un 00:43:12
Pues entonces me funciona 00:43:13
Vale 00:43:15
Última cosa 00:43:21
Lo mismo en un cierto sentido 00:43:24
Pero con los métodos 00:43:28
¿Vale? 00:43:31
Esto es lo que hemos hecho antes 00:43:32
Cuando hemos puesto 00:43:34
El toString 00:43:35
O cuando hemos puesto el 00:43:38
Como me acuerdo me se llama 00:43:39
Describe, en vez de describe móvil 00:43:42
Con describe son 00:43:44
Es decir, que yo puedo reescribir 00:43:45
Métodos 00:43:48
¿Vale? 00:43:50
Esto es más importante que el otro 00:43:52
Es más interesante 00:43:54
La idea es que yo puedo tener 00:43:55
Subclases 00:43:57
Que cuando hacen un método 00:43:59
Que normalmente tiene también la superclase 00:44:01
Pues hagan 00:44:04
Algo más 00:44:06
de lo que hace la clase genérica 00:44:07
¿vale? por ejemplo 00:44:09
un dispositivo no tiene un número de teléfono 00:44:11
si yo te digo, descríbete 00:44:13
a un dispositivo 00:44:15
él no me puede decir que número de teléfono tiene 00:44:17
porque un ordenador no tiene un número de teléfono 00:44:19
por ejemplo, ahora un móvil 00:44:21
cuando le digo descríbete 00:44:24
sí que tiene el número 00:44:25
de teléfono, entonces estaría bien 00:44:27
que dijera, oye, este es mi número de teléfono 00:44:29
¿vale? para hacer eso 00:44:32
nosotros 00:44:34
en el ejemplo que habíamos hecho 00:44:35
habíamos creado 00:44:37
dos métodos distintos 00:44:39
habíamos creado el método estado 00:44:41
y había creado el método 00:44:43
estado móvil 00:44:46
¿vale? entonces no me puedo equivocar 00:44:47
¿sí? 00:44:50
pero el problema de esto es que para saber 00:44:51
que método utilizar tengo que saber en que clase 00:44:53
estoy 00:44:56
si es un móvil que hemos estado móvil, si es un dispositivo 00:44:56
que hemos estado 00:44:59
¿vale? y esto 00:45:00
Es un problema 00:45:02
¿Cuándo es un problema? 00:45:04
Vamos a hacer un ejemplo 00:45:06
Creamos un array de dispositivos 00:45:07
Dispositivo 00:45:11
Es igual a 00:45:12
New 00:45:18
Dispositivo 00:45:19
De 3 00:45:22
¿Vale? 00:45:25
Array de dispositivos 00:45:28
En dispositivo 00:45:29
De 0 00:45:32
Pongo un nuevo dispositivo 00:45:34
En dispositivo de uno 00:45:37
Pongo un nuevo móvil 00:45:50
Me da error 00:45:52
¿Por qué? 00:46:07
Porque un móvil es un dispositivo 00:46:09
Entonces puede estar en una red de dispositivos 00:46:11
Y finalmente 00:46:13
Esto no me sirve 00:46:16
Dejo dos 00:46:19
Vale 00:46:20
La cosa interesante aquí es que 00:46:21
Yo tengo una red de dispositivos 00:46:24
Vale, ahora quiero que los dispositivos se presenten 00:46:26
Entonces hago for 00:46:29
Int i es igual a cero 00:46:31
i es menor que 00:46:33
Disp.length 00:46:35
i más más 00:46:38
Disp de i 00:46:40
Punto 00:46:46
Queda esto 00:46:51
Estado 00:46:54
Esto funciona 00:46:56
Aparte que aquí me he cargado algo 00:47:01
Veamos un momento 00:47:13
Esto 00:47:19
Desnúmero 00:47:20
Super 00:47:24
Aquí 00:47:28
Vale 00:47:31
Entonces, aquí 00:47:32
Ahora, dispositivo 00:47:34
Si os fijáis, esto está funcionando 00:47:36
Pero me trata el móvil 00:47:39
Como si fuera un dispositivo 00:47:41
No como si fuera un móvil 00:47:44
¿Vale? 00:47:46
Lo que no puede hacer 00:47:47
A ver, ¿dónde está? 00:47:49
Es decirle 00:47:52
Usa estado móvil 00:47:53
Esto se enfada 00:47:54
¿Vale? 00:47:56
Porque lo que me está diciendo es 00:47:58
Estado móvil no está definido 00:48:02
En dispositivo 00:48:06
Porque eso está definido en móvil 00:48:08
¿Vale? Podría entonces decirle 00:48:10
Vale, pero tú tráctamelo como móvil 00:48:13
Claro 00:48:14
Pilla este elemento de aquí 00:48:24
El objeto que te da en esta posición 00:48:27
Tráctamelo como móvil 00:48:29
Y ahora llama estado móvil 00:48:31
Vale, fenomenal 00:48:32
Boom 00:48:34
¿Vale? 00:48:36
Class dispositivos 00:48:38
Cannot be cast to class móvil 00:48:42
Dispositivo no se puede 00:48:45
Tratar como móvil 00:48:47
Es un móvil que se puede tratar como un dispositivo 00:48:48
Entonces como puede hacer 00:48:53
Para que 00:48:56
Este señor de aquí 00:48:57
Me funcione 00:49:00
En el sentido que 00:49:01
Yo tengo una red de dispositivos 00:49:04
Pero que si tengo 00:49:06
Un dispositivo 00:49:08
me use el estado 00:49:09
del dispositivo 00:49:11
y si en vez es un móvil, me use 00:49:13
el móvil 00:49:15
y esto se logra 00:49:16
diciendo, vale, aquí en vez de 00:49:19
crearme un método propio 00:49:21
del móvil 00:49:23
sobre escribo 00:49:25
método de mi padre 00:49:31
entonces, ahora no hay estado 00:49:32
estado móvil, estado ordenador, estado no sé qué 00:49:35
hay estado 00:49:38
Cada hijo 00:49:39
Sobrascriberá 00:49:41
El funcionamiento del padre 00:49:43
Pero poniendo las cosas 00:49:45
Importantes de esta nueva clase 00:49:47
Como por ejemplo aquí ahora te digo 00:49:50
Que soy un móvil 00:49:51
En automático 00:49:52
Java 00:49:55
Cuando se llama 00:49:56
Sobre un determinado objeto 00:50:02
Utilizará el estado 00:50:04
Del objeto 00:50:06
De la instancia que es el objeto 00:50:09
Si el objeto que he metido allí es un dispositivo, usará el estado del dispositivo 00:50:11
Y si el objeto que he puesto allí es un móvil, usará el debo 00:50:16
Esto ha usado dispositivo porque disuno es un dispositivo 00:50:22
Y esto ha llamado móvil porque es un móvil 00:50:33
Y esto me abre un mundo 00:50:37
Simplemente lo he sobre escrito 00:50:42
A mí en este momento me interesa el concepto de sobreescribir el método 00:50:47
No tanto esta cosa de aquí 00:50:54
Esto se llama polimorfismo, lo veremos con más detalle un poquito más adelante 00:50:58
Es un ejemplo de por qué esto me puede servir 00:51:02
A mí lo que me interesa por ahora es la parte de sobreescribir 00:51:05
Yo puedo pillar un método de mi padre 00:51:12
Veis que es el mismo método 00:51:14
Idéntico a este de aquí 00:51:16
Mismo método 00:51:17
Y decirle, ahora 00:51:19
Este método de aquí no hace 00:51:21
Esto 00:51:24
Pero hace otra cosa 00:51:25
Se tiene que llamar igual 00:51:27
Porque lo estoy sobre escribiendo 00:51:31
Es como el método toString 00:51:32
El método toString representa 00:51:35
Una versión 00:51:37
Textual de mi objeto 00:51:38
Tú tienes el método toString 00:51:41
En object, que te da ese código raro 00:51:43
Si yo en vez de ese código raro 00:51:45
Cuando quieres imprimir mi objeto 00:51:47
Quiero algo que sea más parecido a mi objeto 00:51:49
Con los datos de mi objeto 00:51:51
Pues de todo lo que hago es sobre escribir el toString 00:51:52
Entonces cada vez que se utilizará el toString 00:51:55
Pues utilizará el mío, no el de object 00:51:57
Lo mismo con el equals 00:51:59
String 00:52:02
Cuando hago string1 00:52:03
Cuando hago algo como 00:52:06
Esto.equals 00:52:07
A esto 00:52:10
Este equals de aquí 00:52:14
Es una sobrescriptura 00:52:20
Del equals 00:52:23
Que está en object 00:52:25
¿Vale? 00:52:26
El de object hace una cosa 00:52:28
El de string hace otra cosa 00:52:30
El de object compara entre ellos 00:52:32
Dos objetos, en particular 00:52:34
Compara ese código que hemos visto 00:52:36
Que sea el mismo código 00:52:39
¿Vale? 00:52:41
Sin embargo, equals lo que hace es 00:52:42
Comparar que esta 00:52:44
Esta secuencia de caracteres 00:52:46
Es igual a esta secuencia de caracteres 00:52:48
Dentro string 00:52:51
No sé si me entendéis lo que quiero decir 00:52:52
Yo puedo pillar dispositivos 00:52:53
Y sobre escribir equals 00:52:56
Para que yo pueda luego preguntarme 00:53:00
Si dos dispositivos son el mismo dispositivo 00:53:03
¿Sí? 00:53:05
Es una buenísima 00:53:17
Demanda 00:53:19
Imaginaos que yo tenga un dispositivo 00:53:19
¿Vale? 00:53:25
Que es el dispositivo A 00:53:27
Apagado 00:53:28
El equals 00:53:31
De object 00:53:36
Me da true 00:53:39
Solo si esto 00:53:41
Y esto 00:53:43
Son exactamente 00:53:44
El mismo objeto 00:53:47
Efectivamente 00:53:48
Si no se que punto equals 00:53:52
No se cuanto 00:53:55
No se que y no se cuanto 00:53:56
Apuntan al mismo objeto real 00:53:58
Pues para object 00:54:01
Estos son los mismos 00:54:03
Sin embargo, por ejemplo en string 00:54:04
Yo tengo string gato 00:54:09
Y otra variable 00:54:11
Que dice gato 00:54:14
Y cuando hago equals 00:54:16
No está usando el equals de object 00:54:20
Porque si no me daría true 00:54:22
Solo cuando yo lo uso sobre el mismo objeto 00:54:24
En vez de yo estoy poniendo 00:54:27
Aquí, este objeto de aquí 00:54:29
Por ejemplo 00:54:31
Y aquí, este otro objeto de aquí 00:54:32
Son dos objetos distintos 00:54:34
Entonces la implementación de Equals en String 00:54:36
No puede ser la misma que Equals en Object 00:54:41
Contain Equals 00:54:44
Contiene 00:54:55
No lo sé, había que ver 00:54:57
Entonces, ¿qué pasa si yo me quiero hacer un Equals en dispositivo? 00:55:01
O sea, que aquí yo tengo el dispositivo 1 00:55:08
Y aquí un dispositivo 2 00:55:10
¿Cómo se implementa 00:55:13
Equals entre dispositivos? 00:55:16
Pues lo tengo que 00:55:18
Decidir yo 00:55:19
¿Vale? Soy yo que implemento este equals 00:55:21
Y yo tengo que decir cuando dos 00:55:24
Objetos equals, cuando esto está aquí 00:55:26
Y esto está aquí 00:55:28
¿Cuándo este método me da true? 00:55:29
¿Y cuándo este método me da false? 00:55:32
Por ejemplo, como nosotros 00:55:35
Tenemos un número serial, el número serial 00:55:36
Debería ser único, podría decir 00:55:38
Que cuando el número serial 00:55:40
Es el mismo, entonces devuelve true 00:55:41
Y cuando el número serial es distinto 00:55:44
Devuelve false, independientemente 00:55:46
De si está encendido o no, independientemente 00:55:48
De donde está guardado en memoria 00:55:50
¿Sí? 00:55:51
Pero esto quizás 00:55:55
Un poquito más, más en futuro 00:55:56
¿Vale? 00:55:58
Yo creo que me faltan 00:56:00
No, falta más de lo que pensaba 00:56:02
¿Vale? 00:56:04
Entonces 00:56:06
Entonces, el concepto de overriding o sobreescriptura es esta cosa aquí, ¿vale? De una clase hija puede sobreescribir un método de una clase padre, ¿vale? Para que haga una cosa distinta, una cosa posiblemente más específica para la clase hija. 00:56:06
A lo mejor el método que usa el padre es demasiado genérico, el método que usa el hijo es mucho más específico para ese hijo. 00:56:29
Haremos ejemplos en los próximos días. 00:56:39
También, como pasaba antes, puedo utilizar mi método, el método de este objeto, o puedo utilizar el objeto de mi padre. 00:56:44
O sea, el método de mi padre 00:56:55
¿Vale? Utilizando thisEsSuper 00:56:57
Puedo seguir utilizando la versión mía 00:56:59
O la versión de mi padre 00:57:02
O puedo utilizar dentro de la versión mía 00:57:03
La versión de mi padre 00:57:06
¿Vale? Por ejemplo 00:57:07
Como esto 00:57:09
Bueno, bueno 00:57:11
¿Os acordáis que la versión del padre 00:57:12
Escribía o esto o esto? 00:57:16
Pues yo el mismo método 00:57:18
O muy parecido lo podría hacer así 00:57:20
Escribe sin el n 00:57:22
El móvil 00:57:32
Y luego después 00:57:33
Super punto estado 00:57:37
¿Vale? 00:57:39
Si os fijáis, aquí la cosa sería 00:57:46
Vale, escribe siempre el móvil delante 00:57:49
Y después 00:57:51
Vas a llamar el método de mi padre 00:57:52
El método de mi padre 00:57:55
Este de aquí 00:57:56
Si está encendido, me escribirá detrás 00:57:58
El móvil con número serial 00:58:00
Está encendido, o si no, el número serial 00:58:02
Está apagado, por lo tanto 00:58:04
Me hace lo mismo 00:58:06
Vamos a ver si es verdad 00:58:07
Lo único es que 00:58:09
Este código de aquí 00:58:16
No he tenido que volver a escribirlo 00:58:18
Lo he reutilizado 00:58:21
Entonces, esto es más 00:58:23
Haber entendido el Diesel Super 00:58:34
¿Vale? Cada vez que uso Super 00:58:36
estoy hablando de la clase padre 00:58:38
cada vez que uso this estoy hablando de la clase 00:58:40
en la que estoy 00:58:42
entonces el super se puede utilizar 00:58:43
tanto para llamar 00:58:47
métodos como aquí 00:58:48
como para llamar constructores 00:58:50
vale 00:58:52
entonces 00:58:54
esto es el que dice 00:58:55
este es un ejemplo de overriding 00:58:58
entonces la clase persona 00:59:00
cuando imprime dice persona 00:59:05
es un hombre, la clase alumno 00:59:07
Que está en de persona, dice que es un alumno 00:59:09
Y cuando lo teste 00:59:11
Los dos escriben imprimir 00:59:12
Pero 00:59:15
Espera, no, ambas 00:59:17
¿Por qué ambas? 00:59:22
Porque personaP es igual a 00:59:25
Ah, sí, vale, sí, sí 00:59:26
Porque aquí he hecho 00:59:28
Cuando he hecho personaP igual a 00:59:30
Vale 00:59:33
Sostancialmente estoy utilizando 00:59:33
Una variable persona, pero la instancia 00:59:36
Que tengo dentro no es una persona 00:59:38
Es un alumno, porque ha hecho new alumno 00:59:40
Entonces acordaos que 00:59:43
No me baso sobre el tipo 00:59:46
De la variable, sino sobre el tipo 00:59:49
De la instancia a la que apunta 00:59:51
Y más o menos este es el resumen 00:59:53
Mañana hacemos un resumen 01:00:01
De todo esto, vale 01:00:03
Y queda esta cosa de aquí 01:00:04
¿Qué es lo que me preguntaba alguien de vosotros? 01:00:10
Que es el instance of 01:00:13
¿Vale? 01:00:14
El instance of es un operador que me dice 01:00:14
Si un cierto objeto es una instancia de una cierta clase 01:00:17
Se usa, por ejemplo, así 01:00:22
¿Vale? 01:00:24
Entonces, pensad que yo he creado un gato 01:00:27
¿Vale? 01:00:31
Aquí están las clases 01:00:33
Hay la clase animal 01:00:35
La clase gato que está en animal 01:00:36
Y la clase perro que está en animal 01:00:38
¿Vale? 01:00:40
Entonces, si yo me pregunto 01:00:41
La variable gato, que es un gato 01:00:43
¿Es una instancia de animal? 01:00:48
Esto me devuelve true 01:00:51
¿Vale? 01:00:52
Gato es una instancia de animal 01:00:54
Porque gato es un animal 01:00:56
Gato es una instancia de gato 01:00:58
También true 01:01:00
¿Vale? 01:01:02
Ahora, si yo intento gato en instancia de perro 01:01:04
Se enfada 01:01:06
Porque perro y gato no tienen nada que ver entre ellos 01:01:07
Entonces no va a funcionar 01:01:10
Esto me puede servir 01:01:12
Para lo que estábamos viendo antes 01:01:14
De yo voy buscando 01:01:16
En mi array 01:01:19
Y cada elemento que pillo 01:01:19
Hago un if de si esto es 01:01:22
Una instancia de móvil 01:01:24
Entonces utiliza lo que es de móvil 01:01:26
O castea la móvil 01:01:28
Si en vez no es una instancia de móvil 01:01:29
Pues no lo hagas 01:01:32
Mañana lo intentamos más. 01:01:33
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
6
Fecha:
24 de enero de 2023 - 14:13
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 01′ 44″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
516.30 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid