Saltar navegación

Herencia 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 13 de enero de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis me autorizáis a grabar vuestra voz. 00:00:00
Entonces, después de la introducción que hemos visto ayer de la herencia, 00:00:06
pues vamos a ver algunas cosillas siempre relacionadas con herencias, pero nuevas. 00:00:12
¿Qué es herencia? De estos ya hemos hablado, en el sentido que, claramente, 00:00:19
mientras yo voy creando nuevas clases que estén en otras clases, etc., 00:00:23
etcétera, voy creando un árbol, ¿vale? Voy creando una estructura jerárquica de clases que heredan 00:00:27
una de otra, ¿vale? Si no digo nada, las opciones que tengo es que no diga nada, no extenda nada, 00:00:34
entonces implícitamente estoy heredando de la clase Object, ¿vale? Que será la raíz del árbol, 00:00:40
¿vale? O sea, todas las clases que podemos crear en Java, pues heredarán al fin y al cabo de 00:00:47
o puedo heredar específicamente de otra clase. En este caso, por ejemplo, 00:00:54
alumno hereda de persona y persona hereda de object. Entonces, de alguna forma, 00:01:01
en un modo u otro, yo de object tengo que heredar. Sea directamente porque no he dicho nada, 00:01:06
o sea indirectamente porque heredo de otra clase que luego heredará de otra, 00:01:12
que heredará de otra, que heredará al final de object, siempre estoy relacionado con object. 00:01:18
Por eso tengo los métodos definidos en Object, lo que hemos visto aquí, pues estos métodos los tienen todos los objetos que vosotros tengáis. 00:01:22
En particular a nosotros nos interesa el ToString porque es el que se utiliza para dar una descripción del objeto en el que estoy, 00:01:35
coche tendrá su descripción, alumno tendrá su descripción, etcétera, etcétera, para que el ser humano cuando imprima en pantalla este objeto sepa qué objeto es y no un código que no se entiende de qué es. 00:01:44
Y también, antes o después, nos interesará el equals, que me permitirá pillar dos objetos que he creado yo y decir si estos dos objetos son iguales o no. 00:01:56
ser igual por defecto a nivel de objeto 00:02:08
la implementación de este señor de aquí 00:02:13
hace sustancialmente el igual igual 00:02:17
sustancialmente está haciendo lo mismo 00:02:22
la definición digamos básica del 00:02:42
equals te está diciendo que 00:02:46
dos objetos son iguales si 00:02:48
solo si son el mismo objeto. 00:02:50
La misma está. Esta es la definición 00:02:52
que es tan básica. Es una definición 00:02:54
verdadera 00:02:56
para cualquier objeto del mundo. Si tú tienes 00:02:58
dos objetos que son el mismo objeto, pues 00:03:00
la referencia A es igual a la referencia 00:03:02
B. Pues sí. Si ahora 00:03:04
tú quieres modificar 00:03:06
un poco estas cosas, como por ejemplo tú dices 00:03:08
estoy gestionando coches 00:03:10
y para mí si dos coches tienen el mismo 00:03:12
color son iguales porque porque en tu sistema se es un que se yo son carreras y si tiene el 00:03:14
mismo color que son el mismo equipo y a ti te interesa por equipo no tanto el coche por sí 00:03:22
mismo como por los equipos por lo tanto si dos coches distintos dos instantes distintas tienen 00:03:27
el mismo color pues entonces son el mismo objeto para ti porque parte del mismo team pues entonces 00:03:32
Entonces puedes modificar este equals para que te devuelva true cuando el color de los dos objetos es igual, 00:03:38
y false cuando el color de los objetos es distinto, ¿vale? 00:03:45
Pero en esto llegaremos un poco más adelante, ¿vale? 00:03:48
Sepáis simplemente que estas son dos cosas que existen en object y que vamos a utilizar. 00:03:52
Hay otras cosillas que están por aquí, ¿vale? 00:03:58
Esto Notify, NotifyAll y Wait y cosas por el estilo, si haréis el segundo de DAM en procesos y servicios, 00:04:00
programación de procesos y servicios, vais a ver que son estas cosas. 00:04:12
Que sustancialmente son mecanismos de sincronización para Multithreading. 00:04:16
¿Vale? Bueno, están aquí. 00:04:22
¿Qué más? 00:04:26
Constructores y herencias. Esto lo hemos hablado antes, ¿vale? 00:04:30
lo volvemos a decir porque así queda queda grabado pues nosotros cuando creamos un objeto primero se 00:04:33
crea su parte base y luego se crea la parte derivada primero se crea la parte de la super 00:04:40
clase y luego se crea la parte de la sub clase vale asumiendo que todas las clases heredan de 00:04:46
object, pues antes o después tendré, o sea, el primer paso siempre será crear un 00:04:54
object. La idea es que, si la clase B a base hereda de otra, etcétera, etcétera, se 00:05:00
hace el paso uno de la superior, paso uno de la superior, paso uno de la superior, hasta 00:05:08
llegar a, sustancialmente, object. Cuando llega object, no puedo ir por arriba de 00:05:13
object, porque esa es la raíz, entonces empezaré creando el object. Entonces, por 00:05:18
Por ejemplo, si creo un alumno que hereda de persona, los pasos serán estos dos pasos, uno y dos. 00:05:23
El paso uno es crear la parte correspondiente a persona, porque tengo que crear la parte base de alumno. 00:05:28
Y como alumno hereda de persona, pues creo persona. 00:05:35
Pero para crear una persona, ¿qué tengo que hacer? 00:05:38
Otra vez el paso uno, que será crear la parte base de persona. 00:05:41
Y como persona hereda de object, pues lo que hago es crear la parte correspondiente al object. 00:05:46
Una vez que he creado la parte del objeto, paso a la parte dos, que es añadir la parte derivada, 00:05:50
la parte derivada de persona, porque aquí estoy construyendo una persona. Estoy en la parte uno 00:05:57
de alumno en el que tengo que crear la persona. Entonces al objeto base le he añadido todo lo 00:06:01
que sea relacionado con persona y a este punto paso a la parte dos del alumno. He creado la 00:06:07
persona, añado los elementos de alumno. Quiero crear un alumno. Para crear un alumno tengo que 00:06:14
crear una persona. Para crear una persona tengo que crear un objeto. La primera cosa que se crea 00:06:24
es la parte relacionada al objeto. Esta es la parte núcleo. Todos tienen que empezar por allí, 00:06:29
porque todos al fin y al cabo alrededor del objeto. Alrededor del objeto le crearé la parte 00:06:36
más específica de persona, habiendo creado la superclase, la primera superclase de alumno. 00:06:43
¿Vale? Entonces ahora crearé la parte relacionada al alumno. ¿Se entiende? Y al final tendré mi 00:06:54
objeto alumno, que dentro tiene una persona, que dentro tiene un objeto. Por lo tanto, 00:07:07
un alumno es una persona y una persona es un objeto. Cualquier cosa que pueda hacer un objeto 00:07:12
lo puede hacer un alumno porque 00:07:16
todo lo que sirve para hacer las cosas del objeto 00:07:18
está aquí. Y cualquier 00:07:20
cosa que pueda hacer un alumno o una persona 00:07:24
lo puede hacer también un alumno porque cualquier cosa 00:07:26
que se necesita para trabajar con personas 00:07:28
está aquí. Y alumno lo tiene. 00:07:30
¿Vale? 00:07:33
Y alumno puede hacer todo lo que pueda hacer un alumno 00:07:34
porque todo lo que sirve para alumno está aquí. 00:07:36
Ahora, una persona no puede hacer 00:07:40
lo que está alumno porque si yo tengo una persona 00:07:41
cuando creo una persona crearé un object 00:07:43
y luego alrededor del objeto 00:07:46
les va a crear una persona, que tiene aquí sus datos, pero no tiene las cosas de alumno, 00:07:49
entonces no puede hacer la programación. ¿Entendéis? ¿Recordáis esto? No, no sé dónde está. 00:07:56
Esto. ¿Vale? Si creo un profesor, pues, si tengo que crear un profesor, que esta es su cosa, 00:08:10
pues, ¿qué tendré que hacer? Pues, profesor tiene que crear empleado, empleado tiene que crear 00:08:17
persona, persona tiene que crear object 00:08:24
la primera cosa que se crea es object 00:08:26
¿vale? alrededor de object se extenderá 00:08:28
con las cosas relacionadas con persona 00:08:30
esta cosa de aquí 00:08:32
que le servía a empleado, pues ahora 00:08:34
se extiende con las cosas del empleado 00:08:36
y esta cosa de aquí que servía 00:08:38
al profesor, ahora 00:08:40
se extiende con las cosas del profesor 00:08:42
¿entienden el mecanismo? 00:08:48
dudas 00:08:51
y difícil 00:08:52
esto 00:08:55
Constructor de herencia y constructor de la clase derivada 00:09:00
Se realiza siempre una llamada al constructor de la clase base 00:09:05
Siempre, ¿vale? 00:09:08
Siempre hay un super 00:09:10
Que sea implícito, explícito o lo que sea 00:09:11
Pero siempre se hará una llamada 00:09:14
¿Por qué? 00:09:16
Porque tiene que crear la superclase antes de poder 00:09:16
O sea, el superobjeto, digamos 00:09:19
Antes de poder crear la parte específica del objeto 00:09:21
Del que estoy llamando, ¿vale? 00:09:24
Bien, esta primera acción del constructor 00:09:26
Aparece en la primera línea, ¿vale? 00:09:27
Tiene que aparecer en la primera línea siempre y se puede o no indicarlo explícitamente o indicarlo explícitamente. 00:09:30
Siempre en la primera línea. 00:09:38
Si no lo hago explícitamente, él hace una llamada invisible a súper. 00:09:39
Si yo tengo un constructor que hace todas estas cosas, automáticamente, hasta si yo hago esto, 00:09:48
Veis que es un poco feo porque es el que habíamos dicho de no hacer. 00:09:55
Pero aquí se ha hecho la llamada de super. 00:10:00
Tened en cuenta que el nombre, apellido y año de nacimiento de alumno están definidos en persona. 00:10:04
Entonces, cuando yo llamo este super, cuando yo desde empiezo a crear un alumno, creo crear un alumno. 00:10:10
Y la primera cosa, hago el super, es porque me voy a crear un objeto con espacio suficiente 00:10:21
con espacio suficiente para poner aquí el nombre, aquí el año y aquí el 00:10:28
Y luego crearé mi alumno y hemos dicho que el nombre que me has pasado por parámetro lo guardo aquí. 00:10:40
Y fíjate que tengo este espacio porque lo he creado cuando he creado la persona. 00:10:55
Entonces ahora el nombre lo pongo aquí, el año de nacimiento lo pongo aquí, el no sé qué otro lo pongo aquí. 00:10:59
Y luego, en vez, los parámetros que son más propios del alumno, que son grupo y horario, pues estarán en esta parte de aquí. 00:11:05
Aquí habrá espacio para grupo y espacio para horario. 00:11:16
Entonces, el grupo lo pondré aquí y el horario lo pondré aquí. 00:11:19
Y ahora ya tengo toda la información. 00:11:24
Tanto como si fuera una persona y como si fuera un alumno. 00:11:26
¿Se entiende? 00:11:30
Entonces, no digo nada. 00:11:34
Él hace en automático 00:11:36
Siempre una llamada a super 00:11:39
Esto es el problema que decimos antes 00:11:41
Si yo en mi clase superior 00:11:43
Si yo en persona no tengo un constructor 00:11:45
Sin parámetros 00:11:47
Esto me dará un error 00:11:48
No lo puedo hacer porque implícitamente 00:11:50
Estoy haciendo una llamada a super sin parámetros 00:11:53
Y tú no has definido un constructor 00:11:55
Sin parámetros 00:11:58
¿Sí? 00:11:59
La otra opción es en vez que 00:12:02
Explícitamente llame yo 00:12:04
el super, entonces te estoy diciendo 00:12:06
mira, no uses, o sí 00:12:08
pero usa este constructor 00:12:10
de aquí, que yo sé que existe 00:12:12
arriba, ¿vale? 00:12:13
y por lo tanto no necesitas 00:12:15
tú hacer la llamada implícita 00:12:18
al constructor por defecto o a lo que sea 00:12:19
o al constructor sin parámetro 00:12:22
¿dudas? 00:12:23
vale 00:12:29
dos conceptos relativamente 00:12:29
complejos 00:12:33
¿vale? 00:12:36
shadowing y overriding 00:12:37
¿Vale? Overriding lo hemos visto ya. Es lo de tu stream. Es sustantivamente sobrecargar, no, sobre escribir los métodos de clases superiores. ¿Vale? Lo vemos después. 00:12:39
El shadowing es algo parecido, pero no con los métodos, 00:12:56
sino con los atributos. 00:13:02
Yo puedo declarar una subclase y en la subclase volver a declarar 00:13:04
un atributo con el mismo nombre de la superclase. 00:13:10
Esto le hace sombra. 00:13:15
La clase derivada puede definir un atributo con el mismo nombre 00:13:20
que uno de la clase base, o sea, que uno de la superclase, 00:13:26
Esto se llama Shadowing, o puede declarar un método con la misma signatura, con la misma firma que uno de la clase base, de la superclase. 00:13:29
Y esto se llama Overriding. 00:13:40
Lo más usual cuando se produce la escritura es que se le escriba un método. 00:13:44
O sea, normalmente se usa el Overriding. 00:13:49
El Shadowing yo tengo muy poca experiencia de haberlo utilizado. 00:13:51
servirá, se utilizará muchísimo, pero el overriding se usa constantemente, 00:13:54
shadowing mucho menos. 00:14:00
Shadowing, ejemplo. 00:14:04
Imaginaos la clase Persona que pone public string nombre cuando. 00:14:06
Y luego tengo la clase alumno que extiende Persona, 00:14:12
es una subclase de Persona, 00:14:16
y aquí pongo public int nombre y uno entero. 00:14:18
¿Veis que es el mismo nombre, el mismo identificador utilizado, pero aquí es un string y aquí es un int? 00:14:23
Podría ser otra vez string aquí, ¿eh? 00:14:32
Pero es como si yo defino que la persona tiene que tener un nombre y el alumno también tiene que tener un nombre, ¿vale? 00:14:35
Y este nombre de alumno hace sombra al nombre de persona. 00:14:43
Ahora, si tú usas un alumno, usarás este nombre de aquí. Y si usas una persona, usarás este nombre de aquí. 00:14:47
Grosso modo. De hecho, si tú creas un alumno y luego creas una referencia al mismo objeto alumno, 00:14:55
pero la referencia de tipo persona. Fijaos. ¿Cuántos objetos hay aquí? Uno. Hay un solo 00:15:05
objeto lo que he hecho es crear un objeto alumno este es el objeto alumno con dentro la cosa 00:15:18
persona lo que sea y le he dicho que el alumno a se llama a es una variable de tipo alumno 00:15:31
y apunta a este objeto y luego he dicho persona p es igual a entonces lo que he hecho es crear 00:15:42
una variable p de tipo persona y ésta apunta al mismo objeto. ¿Lo puedo hacer? ¿Puedo 00:15:49
poner un objeto alumno dentro de un objeto de una referencia persona? ¿Por qué puedo 00:15:59
hacerlo? Un alumno es una persona, por lo tanto yo puedo referenciar a un alumno como 00:16:09
Lo que no puedo hacer es referenciar con una referencia alumno, de tipo alumno, una persona. 00:16:20
Porque alumno implicaría que podría hacer más cosas de lo que puede hacer una persona. 00:16:32
Si yo tuviera un objeto persona, no lo puedo referenciar con una referencia alumno. 00:16:37
Porque entonces esto me permitiría hacer cosas que una persona en realidad no puede hacer. 00:16:46
Pero algunas cosas las podrías hacer también. 00:16:50
Pero no todos los demás. 00:16:52
Si tú me estás diciendo, este es un alumno, tiene que poder hacer todo lo que tenga que hacer un alumno. 00:16:54
Y si hay nota media y una persona no tiene nota media, no lo puedes hacer. 00:16:59
Entonces, esto no. 00:17:04
Sin embargo, esto sí, porque un alumno puede hacer absolutamente todo lo que tiene una persona. 00:17:07
Porque tiene una persona dentro. Cada alumno tiene una persona dentro. 00:17:12
No todos, todos, pero... 00:17:20
¿Vale? Entonces, 00:17:21
Entonces, si yo ahora escribo system.auto.ptml p.nombre, o sea, estoy usando la referencia de persona, me escribe Juan, porque me lo trata como persona y accede a este nombre. 00:17:24
Si en vez hago a.nombre, me accede como si fuera un alumno y me saca esta. 00:17:40
Cuidado, porque es el exacto opuesto que en el overriding. 00:17:57
¿Vale? Esto es como funciona en shadowing. 00:18:03
Veremos que en overriding no. 00:18:05
¿Sí? 00:18:09
Va a complicar un poco las cosas. 00:18:12
¿Vale? 00:18:14
Si definimos en una subclase un atributo con el mismo nombre y tipo que la superclase, 00:18:14
la superclase queda oculto. Podemos acceder a la variable de la subclase utilizando this 00:18:21
y super como, de esta forma. Imaginaos que está transporte, vehículo que hereda de transporte 00:18:27
y coche que hereda de vehículo. En transporte, en la clase transporte, ya he definido string 00:18:35
le he dado el valor terrestre. En vehículo tengo string nombre turismo y en coche tengo 00:18:42
string nombre Ferrari, como mi coche. Entonces, si yo uso nombre, si yo estoy en esta clase 00:18:49
de aquí, si yo estoy en coche, estoy usando un objeto de coche y le digo nombre, me utilizará 00:18:59
este nombre. ¿Vale? 00:19:06
Saldrá Ferrari. 00:19:08
Si hago dis.nombre, 00:19:10
lo mismo. 00:19:12
Si hago super.nombre, 00:19:14
me usará 00:19:17
el de vehículo. 00:19:18
Me está diciendo, en vez de usar dis, 00:19:20
usa super. 00:19:23
O sea, considera 00:19:24
este objeto, no como 00:19:26
si fuera una instancia de esta 00:19:28
clase, pero como si fuera 00:19:30
una instancia de la clase 00:19:32
super. Cuidado que este 00:19:34
super no es el mismo super que hemos visto 00:19:37
antes. 00:19:40
Repito. 00:19:45
Cuando 00:19:48
usas este super de aquí, este super es 00:19:48
igual a este dis. ¿Os acordáis que 00:19:50
dis era una referencia a este 00:19:52
objeto? Pues super es una 00:19:54
referencia a este objeto, 00:19:56
pero no considerado como si 00:19:58
fuera de esta clase, 00:20:00
sino como si fuera una instancia 00:20:02
de la clase superior. 00:20:04
O sea que en este caso 00:20:08
te está refiriendo a este objeto, pero 00:20:09
trátalo no como un coche, 00:20:11
sino como un vehículo. 00:20:13
O sea, super es un dis 00:20:16
para la clase superior. 00:20:17
Es un trata a este objeto 00:20:20
en referencia a este objeto, 00:20:21
pero considerado como si fuera 00:20:23
de la clase superior. 00:20:25
Si no quieres usar super porque te lía, 00:20:28
puedes usar esto. 00:20:29
Pillo dis, 00:20:32
lo casteo a vehículo, 00:20:33
entonces ahora 00:20:35
dis se transforma en un objeto 00:20:38
vehículo, y a este punto accedes al 00:20:40
nombre. Y entonces sale el nombre del vehículo 00:20:42
también. Turismo. 00:20:44
Lo que no puedes hacer es super, super. 00:20:49
Super, super, punto nombre, error. 00:20:52
Si quieres hacer super, super, 00:20:55
punto nombre, o sea que desde aquí 00:20:57
acceder a esta 00:20:58
variable de aquí, tienes que usar 00:21:01
este mecanismo diciendo, oye, 00:21:03
tú eres dis, eres este objeto. 00:21:05
Castéalo como si 00:21:07
estuvieras trabajando con un transporte, 00:21:08
transporte y a este punto accede a su nombre. Entonces estoy accediendo a éste. 00:21:10
No tendrías que pasar por vehículo directamente, hace referencia al supersuper. 00:21:17
Porque este objeto tú lo puedes tratar como coche, pero es también un vehículo. 00:21:22
También es un transporte. Aquí le estás 00:21:27
simplemente diciendo a qué clase quieres, qué tipo de instancia quiere que sea. 00:21:29
Realmente, si aquí le pongo gato, pues no funciona porque coche no es un gato. 00:21:37
Entonces, desde coche, desde los métodos de coche, si yo puedo acceder a las tres variables que han sido sombreadas, que han sido hechas shadowing, que han sido ocultadas usando estas cosas de aquí. 00:21:42
Si yo uso nombre a secas, pues me usará el nombre propio de esta árbol. 00:21:58
Ahora, si usa esto, ¿es cómodo? ¿Para qué sirve? 00:22:02
No lo he usado. 00:22:09
No he llegado en sitios en mi carrera de profesor en el que ha sido necesario usar el shallot. 00:22:11
Seguramente en algunas situaciones está. 00:22:21
Por ejemplo, una cosa de ese estilo podría servir para ocultar la identidad de un alumno. 00:22:23
Yo creo un alumno y le asigno un código. 00:22:34
Por detrás está una persona con su nombre. 00:22:37
Pero luego al profesor que corrige el examen no le doy acceso a la persona, 00:22:40
no le doy acceso a métodos que permiten llegar a la persona. 00:22:46
Entonces él cuando verá y buscará el nombre del alumno 00:22:50
Siempre le saldrá un código 00:22:54
Anonimizado 00:22:55
No sabe quién es 00:22:57
Pero una vez que ha acabado la corrección 00:22:58
El profesor 00:23:01
Debe dar las notas 00:23:03
Y el sistema podrá acceder 00:23:04
Por cada alumno 00:23:07
A su nombre real 00:23:09
Accediéndolo como persona 00:23:10
Hay otra forma de hacer eso 00:23:12
Vale, este era el shadowing 00:23:18
Si habéis 00:23:27
entendido algo de lo que os he dicho 00:23:29
nosotros accedemos 00:23:32
a una variable 00:23:35
a un atributo, nombre por ejemplo 00:23:37
¿vale? 00:23:39
hay una referencia 00:23:41
estas cajitas de aquí 00:23:43
que apuntan a un objeto 00:23:44
y yo de allí accedo a su nombre 00:23:48
en el shadowing 00:23:50
¿sí? 00:23:52
el atributo que voy 00:23:55
a tocar depende 00:23:59
de la referencia que use. 00:24:01
Es decir, 00:24:05
¿cuántos 00:24:07
objetos hay aquí? Uno. 00:24:07
¿Y ese objeto qué tipo tiene? 00:24:11
Alumno. 00:24:17
El new lo he hecho de alumno. 00:24:20
¿Esto es una instancia 00:24:23
de qué clase? 00:24:24
De alumno. 00:24:26
Pero dependiendo 00:24:29
de su referencia, 00:24:30
si uso 00:24:32
A o uso P, que son la referencia 00:24:34
A es una referencia de tipo alumno 00:24:36
y P es una referencia de tipo persona, 00:24:38
pues accederé a un nombre o a otro. 00:24:40
Lo que cuenta es el tipo de la referencia, 00:24:45
no el tipo de la instancia. 00:24:49
Tanto P como A son alumnos. 00:24:51
La instancia es un alumno. 00:24:55
Yo he creado un objeto alumno. 00:24:57
Pero dependiendo de si me refiero a él como alumno 00:25:00
o me refiero a él como persona, 00:25:02
me contestará el número o me contestará cuál. 00:25:04
¿Se entiende? 00:25:07
¿Sí? 00:25:10
Pues en los riding es al revés. 00:25:11
No es así. 00:25:13
¿Cómo es riding? ¿Qué es? 00:25:15
Es la reescritura de métodos 00:25:17
de una superclase 00:25:19
en una subclase. 00:25:23
¿Vale? Entonces yo estoy en una subclase, 00:25:25
sé que mi padre o mi superclase 00:25:27
tiene un método ya implementado, 00:25:29
pero 00:25:32
se me queda corto. 00:25:32
¿Vale? 00:25:35
Como por ejemplo el describir, ¿no? Cuando nosotros hemos hecho esto y hemos hecho el estado, ¿vale? El estado del dispositivo solo habla de si está encendido y del número serial, que para un dispositivo vale, pero cuando llega un móvil me gustaría saber algo más porque yo tengo algo más de solo el número serial y el estado. 00:25:36
Tengo también el número. Entonces, me gustaría que usara también eso. 00:26:01
Entonces, a nivel de dispositivo, tengo el método, que es este de aquí. 00:26:06
Lo puedo usar, pero lo quiero especificar más para la subclase. 00:26:11
Quiero hacer algo más o algo distinto. 00:26:17
A lo mejor en el dispositivo solo dice esta cosa. 00:26:21
En el móvil quiero que haga cosas más, cosas distintas, cosas... 00:26:24
Quiero cambiar. 00:26:27
¿Vale? Entonces, lo que puedo hacer es 00:26:28
sobreescribirlo. Overwrite. 00:26:30
¿Vale? Que sería 00:26:33
esto. ¿Vale? No es 00:26:34
overwrite, no es overwrite. 00:26:36
¿Vale? Pero en español 00:26:39
creo que se dice sobreescribir. 00:26:40
Entonces, vuelvo a escribir 00:26:42
el mismo método 00:26:44
con la misma firma. 00:26:46
Fijaos que la firma es la misma. 00:26:48
Y yo dentro de aquí 00:26:52
no lo podría hacer. Porque me 00:26:54
dice, ¡ay, mira! Tienes dos 00:26:57
métodos con la misma firma. 00:26:59
Pero si yo tengo una clase y otra clase la hereda y vuelve a escribir esto, Java te dice, vale, lo puedes hacer. Lo que estás haciendo es pillar ese método que existía para dispositivo, pues ahora existe para móvil. 00:27:01
Y que si tú tienes una instancia, no una referencia, una instancia de dispositivo, yo usaré el método del dispositivo. 00:27:16
Si tú tienes una instancia de móvil, yo usaré el método de móvil. 00:27:31
No referencia, instancia. 00:27:41
Aquí cuenta sobre qué has hecho la new. 00:27:44
él siempre usará el método más cercano a la instancia que tú has creado. 00:27:48
Está claro. 00:27:58
Que es lo que no hacía con el shadowing. 00:28:00
Con el shadowing contaba la referencia. 00:28:02
Si yo tenía el mismo objeto, pero una referencia alumno o persona, 00:28:05
si lo llamaba con alumno era una cosa, si lo llamaba con persona era otra. 00:28:09
Ahora, si yo tengo un alumno y dos referencias, alumno y persona, 00:28:12
pues siempre va a usar el de alumno 00:28:15
porque la instancia es alumno 00:28:17
no es persona 00:28:19
es decir esto 00:28:20
es decir donde estoy 00:28:23
yo tengo 00:28:27
Juan con el método imprimir 00:28:34
¿vale? y luego tengo la persona 00:28:36
que pone imprimir también 00:28:38
¿vale? 00:28:40
si aquí creo al alumno A con yo alumno 00:28:42
en la persona P que es igual a 00:28:44
la misma situación que antes 00:28:46
ahora tanto A.imprimir como P.imprimir 00:28:48
me hacen lo mismo, ¿vale? 00:28:51
¿Qué será esto? 00:28:53
Porque los dos harán referencia, 00:29:00
pillarán el método de la instancia, 00:29:03
no de la referencia. 00:29:06
¿Se entiende? 00:29:08
Vale, el va atrás. 00:29:11
Entonces, vamos a ver qué dice más. 00:29:12
¿Vale? ¿Para qué sirve reescribir un método? 00:29:14
¿Vale? ¿Para ampliar la funcionalidad del método 00:29:17
o para particularizar la funcionalidad de un método 00:29:19
a la clase derivada? 00:29:22
Tengo el mismo método, lo tenía ya hecho, 00:29:23
pero quiero o ampliar 00:29:26
su funcionalidad o quiero 00:29:28
especializarla para la nueva 00:29:30
cosa. Tengo 00:29:32
saludar para alumno, para persona 00:29:33
que dice hola a todos, pero ahora 00:29:36
quiero un alumno y como soy un alumno 00:29:38
quiero que diga oye, soy un alumno 00:29:40
y te saludo. 00:29:42
Lo quiero especializar para el alumno. 00:29:43
Pues entonces, sobreescribo el método. 00:29:46
Si definimos en la subclass 00:29:49
el método con la misma asignatura, 00:29:50
con la misma función, con la misma firma, 00:29:51
nombre de un tipo de parámetros vale que en la superclase el de la superclase queda oculto 00:29:54
entonces se oculta como antes vale como el shadowing de antes pero ahora es sobre métodos no sobre 00:30:01
atributos entonces si yo desde esta clase llamo arrancar pues ejecuto el método del coche vale 00:30:07
estoy en una situación parecida aquí si llamo arrancar se llama tis punto arrancar ejecuto 00:30:12
el método de coche. Ahora tengo la posibilidad de llamar el método de mi padre, que es usando 00:30:19
super punto arrancar. Esto sirve para esta fase aquí. Si yo quiero que haga todo lo 00:30:29
que hacía mi padre, más otras cosas, pues lo que puedo hacer es llamar super punto el 00:30:39
nombre del método así hace todo lo que hacía mi padre y ahora le hago hacer más cosas si yo quiero 00:30:45
decir la persona dice hola a todos y el alumno dice hola a todos soy un alumno pues lo que puede 00:30:51
hacer es llamar saludar super punto saludar que me dirá hola a todos y luego añadir yo como alumno 00:30:58
soy un alumno. 00:31:05
Ahora hacemos un ejemplo. 00:31:07
No se puede usar súper, súper. 00:31:10
¿Se puede usar esto aquí? 00:31:14
Pregunta de un millón de dólares. 00:31:17
Una cosa como esto 00:31:19
se puede usar aquí. 00:31:21
Vamos a ver. 00:31:38
Entonces, esta situación es 00:31:40
tengo dispositivo 00:31:42
y móvil que hereda el dispositivo. 00:31:44
Por ejemplo, tengo 00:31:46
aquí estado que dice 00:31:47
algo 00:31:50
y tengo móvil, que dice algo distinto. Si yo ahora aquí quito todo y llamo mov.estado, 00:31:51
pues esto va a llamar el de móvil. Si yo llamo disp.estado, llama el de dispositivo. 00:32:05
¿Estamos de acuerdo hasta aquí? 00:32:25
Ahora, ¿cómo podría yo desde aquí llamar al de mi padre? 00:32:30
Opción número A. 00:32:36
Borro esto. 00:32:38
Entonces ya el de móvil no existe. 00:32:43
Entonces cuando lo llamo sobre el móvil, me usa el del padre. 00:32:46
No, pero yo lo quiero porque quiero hacer lo mismo que hace el padre y luego algo más. 00:32:53
¿Vale? 00:32:58
Entonces me voy al móvil. 00:32:59
Lo vuelvo a poner y digo, ¿cómo podría de aquí decir algo más, pero decir antes todo lo que hace mi padre normalmente? 00:33:00
O sea, quiero ejecutar el método como si fuera un dispositivo y luego algo más. 00:33:17
Super, punto estado. 00:33:27
Esto me está diciendo, utilízame a mí como si fuera una instancia superior. 00:33:31
Y llama el método estado. 00:33:39
O sea, ejecuta esto. 00:33:41
Cuando lo hayas ejecutado, escribes también esta cosa. 00:33:43
Vamos a ver si funciona. 00:33:49
Mi padre y yo. 00:33:51
¿Estás de acuerdo hasta aquí? 00:33:56
¿Dudas o no? 00:33:59
Repito. 00:34:05
Esto es el método de dispositivo, 00:34:09
que simplemente dice el número serial y se está encendido o parado. 00:34:11
Esto es el método del móvil, que hereda de dispositivo. 00:34:16
Entonces, con esta llamada, yo lo que le estoy diciendo es, antes haz todo lo que haría un dispositivo y después añades algo más que es lo que hace el móvil. 00:34:21
Estoy extendiendo la funcionalidad. Estoy diciendo, cuando un móvil quiere hacer su estado, pues hará todo lo que hace un dispositivo cualquiera y luego hará algo específico del móvil. 00:34:38
para esto uso super 00:34:48
super me está diciendo 00:34:53
tráptame como si fuera 00:34:55
una instancia de una clase 00:34:57
superior 00:34:59
tráptame como si fuera una instancia 00:35:00
de dispositivo 00:35:03
y entonces cuando tú 00:35:05
haces dispositivo punto 00:35:07
estado ejecutarás esto 00:35:08
¿vale? esto 00:35:11
y después 00:35:13
una vez que has ejecutado 00:35:16
todo esto, entonces has hecho lo que haría 00:35:18
un cualquier dispositivo, pues ahora 00:35:20
pasas a hacer lo que haría 00:35:22
un móvil en concreto. 00:35:24
A ver, esto funciona. 00:35:29
La pregunta es 00:35:31
esto 00:35:32
que, fijaos, por el 00:35:43
shadowing funcionaría. 00:35:48
Porque hemos dicho que se puede hacer. 00:35:50
¿Dónde está? 00:35:52
Aquí, ¿veis? 00:35:53
Y yo el disk 00:35:56
lo casteo a lo que quiero 00:35:57
castear y accedo al atributo que 00:35:59
quiero acceder, accedo a ese nivel. Si hago esto accedería a turismo, si hago esto accedería a 00:36:01
terrestre. En el Shadowing esto funciona. La pregunta es ¿esto funcionará? No es equivalente 00:36:09
a super.estado, no es lo mismo esto que esto, porque esto me está diciendo trátame como una 00:36:18
instancia de la clase superior o sea de dispositivo y ahora llama estado de 00:36:30
dispositivo vale y esto me está diciendo píllame a mí castéame, trátame como un 00:36:33
dispositivo y llama estado. Funciona? 00:36:40
Pam! 00:36:52
Os suena de algo esto? O ya solo usáis inglés en el 00:37:01
Hay una página web que se llama Stack Overflow. 00:37:07
Bienvenidos a Stack Overflow. 00:37:16
¿Qué ha pasado aquí? 00:37:19
Que no está funcionando. 00:37:21
Nosotros hemos dicho que el overreading no se basa sobre la referencia, 00:37:24
mas se basa sobre la instancia. 00:37:29
Entonces, no obstante yo le diga, oye mira, soy un dispositivo, 00:37:32
la instancia que tengo dentro es un móvil. 00:37:35
Entonces, cuando hago esto, estoy volviendo a llamar este método. 00:37:39
Y este método, como primera cosa, lo que hace es llamarse otra vez. 00:37:45
Y este método, lo que hace es llamarse otra vez. 00:37:49
Y esta es la primera cosa que hace, es llamarse otra vez. 00:37:52
Y se llama otra vez, y se llama otra vez, y se llama otra vez, y se llama otra vez. 00:37:54
¿Lo veis? Se llama estado, llama estado, llama estado, llama estado, llama estado, llama estado, llama estado. 00:37:57
Y por unas cuantas veces. 00:38:03
Unas cuantas veces. 00:38:04
Lo que pasa es que cada vez que tú haces una llamada de método, la pones en una cosa 00:38:08
que se llama pila. 00:38:16
¿Vale? 00:38:17
Tú llamas un método, otro método, otro método, otro método, otro método, otro 00:38:18
método, otro método, otro método, porque cuando luego acaba este método, tú vuelves 00:38:22
al método que lo habías llamado, y cuando acaba este método, vuelves al método que 00:38:27
lo habías llamado. 00:38:31
Pero el problema es que aquí estamos llamando métodos y llamando métodos sin nunca acabar 00:38:32
el método. 00:38:36
Entonces esta pila crece, y crece, y crece, hasta que a un cierto momento, overflow, he hecho demasiadas llamadas de método, y entonces no lo aguanto, y es pronto. 00:38:37
Es decir que esta cosa de aquí, que sí funcionaba en el otro, no puede funcionar aquí. 00:38:54
esto implícitamente quiere decir 00:39:02
que antes con el 00:39:05
riding podía escalar 00:39:07
cuanto me daba la gana 00:39:09
es decir, desde aquí 00:39:10
desde coche podía llegar al vehículo 00:39:13
pero también podía llegar al transporte 00:39:15
mientras ahora con el roller riding 00:39:19
como mucho puedo llegar a mi padre 00:39:21
usando el 00:39:23
super punto estado 00:39:25
ahora lo que puede hacer mi padre 00:39:26
es llamar super punto estado 00:39:29
eso sí 00:39:30
Pero yo como clase solo puedo acceder a los métodos de mi padre. 00:39:33
Veamos un poco. 00:39:49
Aquí está descripción. 00:39:51
Si yo estoy en esta clase de aquí. 00:39:56
Si hago dist.decirDescripción estoy usando este método de aquí que sobreescribe esto. 00:40:04
si uso super punto decir la descripción, estoy usando este método de aquí, ¿vale? 00:40:10
Pero no podría llegar a algo que está por aquí. 00:40:17
Esta sí puede llegar a su padre, yo puedo llegar a mi padre, pero no puedo llegar al abuelo. 00:40:20
Al mandar un mensaje a un objeto, el método seleccionado depende de la clase real de la que el objeto es una instancia, ¿vale? 00:40:27
No de la clase de referencia, lo que decíamos antes. 00:40:36
Es decir, cuando yo llamo un método, no voy a mirar la referencia, 00:40:38
mas voy a mirar la instancia real. 00:40:43
Cuando yo tengo que elegir aquí, si voy a utilizar imprimir de alumno, 00:40:45
imprimir de persona, no voy a mirar la referencia, 00:40:50
mas voy a mirar el objeto creado. 00:40:55
Y como los dos, en este caso, son referencias al mismo objeto 00:40:58
y el objeto es tipo alumno, los dos llamadas llamarán el de alumno. 00:41:01
¿Entienden? 00:41:08
siempre el más específico, vale 00:41:09
super, referencia al objeto actual como si fuera un instante 00:41:21
de una superclase, vale, a diferencia de la referencia 00:41:26
super, se puede acceder especialmente a métodos de la superclase 00:41:30
a través, vale, para reescribir 00:41:34
métodos, no solo el constructor, puede ser útil usar la referencia 00:41:38
super, vale, como aquí, este es el ejemplo que hemos hecho nosotros, este ejemplo aquí 00:41:42
Y yo lo que voy a hacer es llamar lo que hace mi padre, y una vez que he hecho todo lo que hace mi padre, pues sigo con las cosas específicas de mi padre. 00:41:46
Entonces, super, la palabra super, la palabra de se vea super, nosotros la hemos visto para dos cosas distintas. 00:42:05
Por un lado, es super con las paréntesis, o super con las paréntesis con parámetros dentro. 00:42:12
Este es como un super método, se usa en los constructores, es un super constructor, ¿vale? 00:42:17
Es la primera línea del constructor y lo que hace, que si no pone nada hay una implícita a esta de aquí, 00:42:24
y lo que hace es usar el constructor de la super clase antes de seguir con este constructor. 00:42:30
Esa es una forma de usar super, ¿vale? Es un tipo de super. 00:42:39
Y luego hay un super distinto, que es super que luego tiene un punto. 00:42:43
Este es super con paréntesis detrás y este es super con punto y puedo hacer super punto método o super punto atributo. 00:42:47
Lo que está haciendo este aquí es trátame como si yo fuera una instancia dis pero de clase superior que accede a este método o accede a este atributo. 00:42:56
¿Entonces no hay una manera de llegar al abuelo, a un método del abuelo? 00:43:06
parámetros no, sí y no. Lo tengo. Imagínate que tengo móvil y luego tengo otra clase, que sea el abuelo, que sea móvil hijo, que esténs móvil, móvilo, quito móvilo. 00:43:14
se enfada porque no hay el super constructor, vale, entonces yo digo public movilojo, no 00:43:49
sé por qué ha salido así, con string s y no sé qué más necesitaba. 00:43:59
tengo un móvil que crea fijaos que aquí yo estoy usando el super o sea que antes de crear un móvil 00:44:09
ojo tendré que crear un móvil y antes de crear un móvil tendré que crear un dispositivo y antes 00:44:40
de crear un dispositivo tendré que crear un object, luego creo el object, le añado a este object estas 00:44:48
dos cosas, luego entonces vuelvo a este de aquí y le añado el número y luego vuelvo al móvil ojo y le 00:44:57
añado lo que quieran añadirle al móvil ojo que no lo sé. Entonces nuestra pregunta era, ¿desde aquí 00:45:05
¿Puedo yo acceder a esto, a estado, a este estado? Y la respuesta es no. ¿Vale? No directamente. 00:45:14
Lo que yo puedo hacer es, por ejemplo, decir public void, de verdad void, estado, y hacer 00:45:28
super punto estado. Entonces este super punto estado está llamando este super punto estado. 00:45:40
Y como este estado a su vez está llamando el super punto estado, sí que estoy utilizando este 00:45:51
desde movilogio. Pero a través de, tengo que escalar cada uno. Si en algún momento de mi 00:46:00
escalada esto no hace el súper, hasta aquí hemos llegado. Pero, como lo desarrollo yo, acepto. 00:46:10
O sea, que tendrías que concatenar o usar métodos para llegar a niveles más de otras superfrases. 00:46:18
Podría yo hacer trampas, siempre si yo soy el desarrollador, y cuidado con lo que hacéis. Aquí, 00:46:28
por ejemplo hacer un public void estado abuelo que lo que hace es super punto estado y nada más 00:46:33
entonces ahora estoy dando está estoy dando la posibilidad a quien hereden de mí de utilizar 00:46:47
hasta el abuelo como esto. Esto lo que está haciendo es, pasando por aquí, acceder al 00:47:00
estado del dispositivo. Poder se puede hacer. No está codificado directamente también 00:47:17
porque normalmente no te sirve. Tienes dispositivo móvil y otra cosa. Todo lo que tú quieres 00:47:24
hacer es extender. Como tú extendes las clases, tú eres un móvil y tú eres un dispositivo, 00:47:31
es difícil que tú quieras hacer completamente algo igual al dispositivo abuelo. Lo que estás 00:47:38
haciendo tú es pillar lo que hacía el de arriba y hacer algo más. Entonces, tú eres 00:47:45
un móvil especializado, o sea, un móvil foldable, que sí, ¿vale? Que eres un móvil. 00:47:52
quieres hacer todo lo que hacía el móvil más algo tuyo entonces no tienes que ir para ti si quieres 00:47:57
ir para arriba porque eres distinto de un móvil debería ser realidad del móvil debería ser el 00:48:06
dispositivo mal hecho vale entonces hay estos dos súper vale que queden claro el súper con 00:48:11
paréntesis el súper con punto vale son dos cosas un poquito distintas esto se usa en constructores 00:48:25
para llamar a los constructores de la clase superior 00:48:31
y esto de aquí en vez de se llama 00:48:33
para utilizar métodos o atributos 00:48:35
de la clase de la que debe. 00:48:38
Y casi se acaba. 00:48:41
Dos. 00:48:42
También repaso de overriding y overloading. 00:48:45
Overriding es lo que hemos visto aquí, 00:48:48
que es la subclase sustituida 00:48:50
a la implementación de un método de la superclase. 00:48:52
Antes métodos tienen la misma 00:48:55
signature, la misma firma. 00:48:56
¿Vale? En vez de cuando se habla de overloading o sobrecarga, se está diciendo que existen dos métodos con el mismo nombre, pero distintas firmas. 00:49:00
¿Vale? Y los métodos sobrecargados pueden definirse la misma clase o en clases distintas de la jerarquía. 00:49:11
¿Sí? 00:49:17
Última cosa, el comando instance of. 00:49:19
Nosotros hemos empezado a ver ahora un problemilla, que es que por un lado están las instancias 00:49:22
y por un lado están las referencias y hasta hoy nosotros si creamos un objeto gato lo 00:49:31
poníamos una variable gato y si llamamos una variable persona o una instancia persona 00:49:38
la metemos en una 00:49:44
variable persona. 00:49:46
Pero ahora 00:49:49
hemos empezado a hacer estas cosas de aquí. 00:49:50
O sea, de crear 00:49:53
un alumno y meterlo en un alumno 00:49:54
o crear un alumno y meterlo 00:49:56
en una persona. 00:49:58
O sea que, mientras antes 00:50:01
referencia e instancias 00:50:02
eran del mismo tipo para nosotros, 00:50:04
ahora estamos empezando a ver 00:50:07
que no tiene por qué ser así. 00:50:08
Con la herencia 00:50:11
herencia, como un alumno 00:50:12
es una persona y un objeto 00:50:14
alumno lo puedo guardar 00:50:16
dentro de una referencia alumno 00:50:18
entonces podrá hacer todo lo que hace un alumno 00:50:20
o lo podré guardar dentro de una referencia 00:50:22
persona, entonces podrá hacer todo lo que 00:50:24
hace una persona 00:50:26
entonces puede ser que en un determinado 00:50:27
momento yo tenga una referencia 00:50:30
una variable y no 00:50:32
tenga ni idea de que hay 00:50:34
ahí dentro 00:50:36
yo tengo la persona P y no sé 00:50:37
si hay dentro de la persona un alumno 00:50:40
Porque los dos se pueden portar como personas 00:50:42
Pero no sé si es una instancia de personas 00:50:45
O si es una instancia de alumnos 00:50:47
Entonces me ayuda 00:50:48
Instance of 00:50:50
Por ejemplo, si yo tengo la clase gato 00:50:52
¿Vale? Fijaos 00:50:55
Hay la clase animal, la clase gato 00:50:57
Que está en animal y la clase perro que está en animal 00:50:59
¿Vale? 00:51:01
Si yo pregunto gato 00:51:03
¿Veis que es un gato? 00:51:05
Es una instancia de animal 00:51:07
True 00:51:08
esto devuelve true, porque gato es un animal. Si yo pregunto, ¿gato es una instancia de gato?, 00:51:10
también me devuelve true, porque gato es un gato. Si gato es una instancia de perro, me dice que 00:51:19
no. Pero con esto de aquí, yo puedo preguntarme si gato es una instancia de gato, entonces lo 00:51:27
puedo usar como gato. Si en vez me digo gato es una instancia de gato y me dice no, no es un gato, 00:51:37
pues entonces lo uso como animal. 00:51:42
Si se me explica lo que es. 00:51:45
Lo veremos porque esto es útil. 00:51:47
Cuando veremos el polimorfismo. 00:51:51
¿Sí? 00:51:54
Pero acordaos que está esta cosa aquí. 00:51:54
Por ejemplo, 00:51:56
yo podría hacer 00:52:02
dispositivo 00:52:03
es igual 00:52:07
a mov1. 00:52:09
Lo puedo hacer porque el dispositivo 00:52:13
es, o sea, el móvil es un dispositivo. 00:52:15
Si ahora me pregunto 00:52:17
SISO de instancios dispositivo que me da TRU. Fijaos que soy un móvil, pero un móvil es un 00:52:19
dispositivo. Me puedo preguntar, fijaos que esta es una instancia de dispositivo. Puedo decir eres 00:52:43
un móvil soy una referencia de tipo dispositivo pero estoy apuntando a un 00:52:50
objeto que es una instancia de móvil entonces ahora lo que podría hacer es si 00:53:01
esta referencia que me estás diciendo que es un dispositivo 00:53:10
en realidad de una instancia de un móvil pues entonces móvil m es igual a 00:53:19
móvil de si tú vas tienes esta referencia que me dices que es un dispositivo y verificas que 00:53:28
efectivamente es de un móvil la instancia que tiene dentro es un móvil no es un dispositivo 00:53:42
entonces lo que puede hacer es hacer una referencia móvil y castigar el dispositivo a móvil 00:53:47
y ahora tengo una referencia de móvil 00:53:58
¿por qué quiero una referencia de móvil? 00:54:01
porque si ahora vosotros hacéis de punto 00:54:03
aquí 00:54:05
aquí cuando hacéis de punto 00:54:06
aquí aparecen sólo los métodos 00:54:11
del dispositivo 00:54:14
pero si yo 00:54:16
ahora tengo M. 00:54:18
pues aquí aparecerán también los métodos 00:54:22
del móvil 00:54:24
lo veremos con más calma 00:54:25
por ahora que simplemente 00:54:31
os quede claro que existe 00:54:33
instance of. Si yo no sé 00:54:35
si una referencia es una instancia de otra 00:54:37
cosa, le puedo preguntar 00:54:39
oye mira, es una instancia de móvil 00:54:41
y si me dice true, pues 00:54:43
es como si 00:54:45
estuvieses cambiando el tipo 00:54:47
de objeto. 00:54:49
El tipo de la 00:54:52
referencia. El tipo 00:54:53
del objeto no varía. 00:54:55
Porque cuando tú has creado el objeto 00:54:57
el objeto existe. 00:54:59
Este es un móvil. Su instancia es una instancia de móvil. 00:55:01
Pero tú lo puedes referenciar como un dispositivo o referenciar como un móvil. 00:55:04
¿Por qué? Porque el móvil es un dispositivo. 00:55:14
¿Para qué me sirve esto? ¿Para que lo entendáis? 00:55:21
Porque yo mañana haré un array de dispositivos y dentro pongo tanto móviles como ordenadores. 00:55:24
Porque todos son dispositivos. Solo que cuando luego los pillo, estoy pillando dispositivos 00:55:32
y me tengo que preguntar, ¿lo que he pillado ahora es un móvil o es un ordenador? Repito, 00:55:40
me crearé una red de dispositivos y dentro le pongo móviles y ordenadores. 00:55:46
¿El dispositivo solo puede tener dispositivos? Sí, pero el móvil es un dispositivo y el ordenador 00:55:53
es un dispositivo. Entonces estoy poniendo dentro de una red de dispositivos tanto móviles 00:55:59
como dispositivos, como ordenadores. Ahora, pero cuando luego lo recorro y pillo uno de 00:56:04
estos objetos, sé que es un dispositivo, pero no sé si es un móvil o si es un ordenador. 00:56:10
Y entonces usaré esto para saber si lo puedo tratar como móvil o si lo puedo tratar como 00:56:16
operador. Más de esto más adelante. Vale. 00:56:22
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
13 de enero de 2026 - 14:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
56′ 33″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
474.50 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid