Saltar navegación

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

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

7 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues venga, entonces yo hasta ahora 00:00:00
para que no me salgan errores raros 00:00:03
y no tener que explicar 00:00:05
por qué me salían, pues yo veréis 00:00:07
que he dejado ahí 00:00:09
disimulando, a ver si no habéis dado cuenta 00:00:11
que he dejado la propiedad sin ponerle 00:00:13
el privado, deja la propiedad ahí suelta 00:00:15
y ya está, vale, luego he puesto los get 00:00:17
y los set con public como todos 00:00:19
vale, pero nosotros normalmente 00:00:21
hemos dicho que cuando programamos 00:00:23
entidades, las propiedades 00:00:25
privado y damos acceso 00:00:28
a ellas a través de los get 00:00:29
y los set, vale, damos acceso a ellas a través 00:00:31
de los get y los set, vale, bueno 00:00:33
pues vamos a hacerlo así 00:00:35
vale 00:00:36
bueno 00:00:39
entonces el objeto animal 00:00:44
tiene ya su propiedad 00:00:47
sus constructores que no se van 00:00:49
a heredar 00:00:52
silencio 00:00:52
así mejor 00:00:54
vale 00:00:58
, sus constructores 00:00:59
coño, me levanto, calláis, me siento, habláis 00:01:00
silencio 00:01:03
jolines 00:01:07
me estás poniendo, no sé si eres Edison o no 00:01:15
el que habla, pero me da igual, el Edison genérico 00:01:18
que se calle 00:01:20
vale 00:01:21
a ver, yo aquí tengo mis constructores 00:01:23
de toda la vida 00:01:28
bueno, solo he hecho uno 00:01:29
con lo cual no tengo el constructor sin parámetros 00:01:30
vale 00:01:33
los get y los set para acceder 00:01:35
bueno, solo uno, get y set 00:01:38
y estos métodos 00:01:40
este que se hereda, bueno, y este en particular 00:01:41
que es el abstracto 00:01:44
venga, pues nada, esta clase la vamos a dejar así 00:01:46
y ahora ya 00:01:48
tenemos perro, vale 00:01:49
que de nuevo vamos a 00:01:52
ponerle 00:01:56
voy a quitar el constructor 00:01:59
porque yo lo he puesto así alegremente 00:02:01
como no me metía en ellos 00:02:04
lo he puesto alegremente para que no me dé errores 00:02:06
y ya está 00:02:08
vale, pongo su propiedad privada 00:02:09
como siempre, sus get y set 00:02:11
y luego además 00:02:13
y luego además he puesto los métodos 00:02:15
este que sobrescribía obligatoriamente 00:02:17
el de arriba 00:02:20
este lo tenía que sobrescribir sí o sí 00:02:20
vale 00:02:23
y no he hecho constructores todavía 00:02:25
vale, bueno, pues venga, vamos a verlo 00:02:27
vamos a hacerle un constructor 00:02:29
el constructor de toda la vida 00:02:30
si queremos que inicialice 00:02:33
las dos propiedades que tiene 00:02:35
que son raza y la que yo no veo 00:02:37
pero que está ahí, que es nombre 00:02:39
si quiero que inicialice las dos propiedades 00:02:41
pues el constructor 00:02:44
que inicializa las dos 00:02:45
pues es un constructor que funciona así, ¿verdad? 00:02:46
yo le paso 00:02:52
para el nombre un parámetro 00:02:53
porque sé que tiene una propiedad nombre 00:02:56
aunque yo no la vea físicamente 00:02:57
y para la raza le paso otro parámetro 00:02:59
como he hecho toda la vida 00:03:03
y ahora 00:03:04
¿cómo usamos estos parámetros que yo paso? 00:03:06
pues el uso habitual es usarlos 00:03:09
para inicializar 00:03:11
las propiedades 00:03:13
de este objeto 00:03:16
que estoy instanciando 00:03:17
la propiedad nombre 00:03:18
¿cuál será? 00:03:20
pues dis.nombre 00:03:23
igual al parámetro nombre 00:03:25
y la propiedad 00:03:26
raza 00:03:29
este ha sido 00:03:30
nuestro constructor de siempre, ¿verdad? 00:03:37
este ha sido nuestro constructor de siempre 00:03:39
si mi clase tiene dos propiedades 00:03:40
raza y nombre, y es que sé que las tiene 00:03:43
sí o sí, porque nombre 00:03:44
la está heredando de animal 00:03:46
si tiene dos propiedades 00:03:48
lo normal es que yo haga un constructor 00:03:50
al que le paso dos parámetros 00:03:52
y los usa para inicializar 00:03:54
las dos propiedades 00:03:56
¿vale? 00:03:57
pero efectivamente aquí nos encontramos 00:03:59
con que no me deja 00:04:01
dice, oye, dis.nombre 00:04:02
pero si está, nombre está 00:04:05
es una propiedad que le he dado, está 00:04:07
si miramos el error nos dice 00:04:09
ya, pero es que no es visible 00:04:11
no es visible significa no puedes escribirla 00:04:13
no puedo acceder a ella 00:04:16
claro 00:04:17
es que el tema de los modificadores de acceso 00:04:18
es peliagudo 00:04:21
porque ¿qué significaba cuando poníamos 00:04:22
un private de estos en una clase? 00:04:26
cuando poníamos un private 00:04:28
significaba 00:04:29
a ese término nombre 00:04:30
como tal 00:04:31
solo puedes acceder desde la propia clase 00:04:33
eso es lo que significaba 00:04:36
así punto pelota 00:04:38
y el compilador se lo toma tan a pecho 00:04:39
que dice 00:04:42
sí ya, sí estupendo 00:04:43
si perro tiene una propiedad que se llama nombre 00:04:46
eso seguro, la tiene 00:04:47
de hecho, ¿vale? 00:04:48
pero 00:04:50
no puedes acceder a ella 00:04:51
no puedes 00:04:55
porque está aquí como privada 00:04:56
soluciones, muchas 00:04:59
si uno tiene acceso 00:05:03
a la clase animal de la quereda 00:05:05
puede cambiar 00:05:08
la visibilidad de este modificador 00:05:11
¿no? 00:05:13
uno podría hacer 00:05:15
pataplof 00:05:16
le quito el privado 00:05:17
¿qué significa cuando no hay ningún modificador? 00:05:19
no hay ni privado, ni público, ni nada 00:05:23
¿qué significa? 00:05:24
que es accesible desde cualquier clase 00:05:24
de ese paquete 00:05:27
entonces ya algo hemos arreglado 00:05:29
si es que tenemos acceso a esta clase, repito 00:05:31
entonces como perro está en este mismo paquete 00:05:33
¿vale? 00:05:36
pues entonces 00:05:37
perro ya sí que nos deja 00:05:38
acceder 00:05:41
porque perro y animal están en el mismo paquete 00:05:42
nos deja 00:05:44
si perro estuviera en otro paquete 00:05:46
es que ni siquiera 00:05:48
quitándole este 00:05:52
tendríamos que ponerle el public 00:05:54
además 00:05:56
porque el public significa desde cualquier 00:05:56
clase de cualquier otro paquete 00:05:59
entonces en este caso 00:06:01
como perro y animal están en el mismo 00:06:03
quitándole el modificador me ha valido 00:06:05
pero si no es que 00:06:08
ni siquiera, si está en otro paquete 00:06:09
tenía que poner public 00:06:11
entonces hombre, es una solución 00:06:12
cambié el modificador 00:06:14
pero primero, eso es muy patatero 00:06:15
para empezar exige que yo tenga acceso 00:06:17
a tocar esta clase 00:06:20
y lo más normal es que no tenga acceso 00:06:21
porque esta es una clase que se ha fijado 00:06:24
precisamente para dar 00:06:26
unas pautas de funcionamiento 00:06:27
tú tienes que sobreescribir y avisar acción 00:06:29
pagar factura para ti, para nada 00:06:31
y esa clase me la han dado 00:06:32
yo no puedo tocarla 00:06:34
entonces no es tan fácil 00:06:35
tocar esa clase 00:06:37
entonces esta solución 00:06:38
pues es un poco pataterilla 00:06:41
a lo mejor ni puedo 00:06:42
y aparte otro problema es 00:06:43
que jolines 00:06:46
quitándole el privado 00:06:47
no solo estoy dando acceso a perro 00:06:50
sino que estoy dando acceso a todos 00:06:51
no solo a perros 00:06:53
sino a todas las que estén en el paquete 00:06:55
a todas 00:06:56
y si pongo public ya ni te cuento 00:06:56
estoy dando acceso a todo el mundo 00:06:58
entonces hombre 00:07:00
cambiar el modificador así alegremente 00:07:03
y quitarle el privado no es sencillo 00:07:05
entonces hay una opción 00:07:07
hay pseudo pataterilla 00:07:09
que es 00:07:12
venga nos inventamos un modificador 00:07:13
de acceso adicional 00:07:15
que es el que mencionamos en su momento 00:07:15
y dije ese ya lo mencionaremos 00:07:17
cuando veamos la denuncia 00:07:19
que es este 00:07:19
el modificador de acceso 00:07:21
protected significa 00:07:26
solo 00:07:27
accesible la propiedad 00:07:28
desde esta clase 00:07:30
y desde las herederas 00:07:31
hombre algo hemos limitado 00:07:33
ya no es desde todas las del paquete 00:07:35
ahora al menos es desde todas las que heredan de mí 00:07:38
algo ya hemos arreglado 00:07:41
vale algo ya hemos arreglado 00:07:44
entonces efectivamente me está dejando 00:07:46
con el protecto 00:07:49
me está dejando 00:07:50
porque perro hereda de animal 00:07:51
si no heredara de animal 00:07:54
no me dejaría acceder a nombre 00:07:55
vale 00:07:57
entonces bueno este modificador 00:07:58
se usa mucho 00:08:00
a ver depende 00:08:02
en función de la aplicación que uno tenga 00:08:03
es que hay miles de situaciones distintas 00:08:05
miles de aplicaciones diferentes 00:08:06
miles de diseños 00:08:08
miles de todos 00:08:08
entonces este modificador 00:08:09
pues uno lo tiene que tener fresco 00:08:11
en lo que significa 00:08:13
y significa eso 00:08:13
todas las clases que hereden de mí 00:08:15
pueden 00:08:17
acceder directamente a ese término nombre 00:08:18
acceder directamente 00:08:21
pero eso solo las querían 00:08:22
vale 00:08:24
pero bueno a lo mejor 00:08:25
podría ocurrir 00:08:28
que yo ni siquiera quiera poner protecter 00:08:28
que quiera dejarlo en privado 00:08:30
porque lo quiero dejar en privado 00:08:32
no lo siento pero no 00:08:34
no puedes cambiar el modificador 00:08:35
entonces si no puedes cambiar 00:08:40
el modificador de acceso 00:08:42
aquí ya sí que estamos 00:08:43
vendidos 00:08:45
porque hacer dis.nombre dentro de perro 00:08:46
imposible 00:08:50
porque nombre está escrita 00:08:51
está escrita físicamente en la clase de arriba 00:08:53
y es privado 00:08:55
y luego solo es de la clase de arriba 00:08:57
entonces aquí sí que estamos vendidos 00:08:58
bueno pues a ver 00:08:59
hay soluciones también 00:09:02
que es hombre 00:09:04
una 00:09:05
podría ser 00:09:08
pues usalset 00:09:09
podría ser usalset 00:09:10
si lo que tú quieres es fijar 00:09:12
la propiedad nombre 00:09:14
con el valor que me dan como parámetro 00:09:16
esto no podemos hacerlo 00:09:17
¿está claro? 00:09:20
vale es private 00:09:28
voy a poner aquí 00:09:42
tendría que ser protected 00:09:44
vale 00:09:46
esto no podemos 00:09:51
bueno pero lo que sí que hemos heredado 00:09:52
es un método 00:09:56
que se puede hacer 00:09:57
precisamente para hacer las propiedades 00:09:58
hombre pues esto siempre lo podría hacer 00:10:00
¿no? si a mí me da la gana 00:10:02
dis.set 00:10:03
nombre 00:10:06
hombre pues sí 00:10:07
hace lo que yo quiero 00:10:10
¿no? es una solución 00:10:12
a la propiedad nombre 00:10:13
de este objeto 00:10:16
ponle este valor 00:10:17
entonces estoy utilizando el set que he heredado 00:10:19
el set que he heredado 00:10:22
bueno pues vale 00:10:24
sí 00:10:25
, vale lo voy a poner ahí 00:10:28
como una posibilidad 00:10:31
lo importante es entenderlo 00:10:32
o sea que esto tiene sentido 00:10:35
pero 00:10:36
esta posibilidad 00:10:41
pues hombre 00:10:46
es feilla 00:10:48
también 00:10:51
sobre todo porque depende 00:10:51
depende de que exista el método set 00:10:54
arriba 00:10:57
y esté heredado 00:10:58
bueno si existe está heredado 00:10:59
no hay otra 00:11:01
depende de que exista el método set arriba 00:11:02
y hombre puede existir o puede no existir 00:11:04
normalmente como pauta general de programación 00:11:07
en las entidades del modelo 00:11:09
pues ponemos get y set 00:11:11
pero hombre 00:11:12
depender de que exista 00:11:14
pues es 00:11:16
hacernos demasiado dependientes 00:11:18
puede existir puede no existir 00:11:20
entonces lo que se suele hacer no es esto 00:11:21
lo que se suele hacer es 00:11:24
lo siguiente 00:11:28
es decir vamos a ver 00:11:28
pues me voy a apoyar 00:11:30
me voy a apoyar 00:11:32
en el constructor de la clase de arriba 00:11:33
es decir la clase animal 00:11:35
ya tiene un constructor 00:11:38
cuyo código 00:11:40
es para hacer esta sentencia que es justo la que quiero 00:11:41
esta sentencia es la que yo quiero 00:11:44
esta es la que yo querría hacer 00:11:46
y esta es la que tengo prohibida 00:11:47
hacer aquí abajo 00:11:49
esta es la que tengo prohibida 00:11:50
la tengo prohibida 00:11:52
pero es que la tengo en el constructor de arriba 00:11:53
pues diríamos 00:11:55
jo pues si yo tengo que hacer esto 00:11:57
si yo tuviera una forma 00:11:58
de llamar al constructor de arriba 00:11:59
magnífico 00:12:01
estaría ejecutando la sentencia 00:12:02
que no me dejan hacer 00:12:05
estaría ejecutando la sentencia que no me dejan hacer 00:12:06
si yo puedo llamar al constructor de arriba 00:12:09
y llamar desde una subclase 00:12:10
al constructor de la superclase 00:12:13
siempre se puede hacer 00:12:15
no hay más que poner super 00:12:17
ya está ya has llamado al constructor 00:12:19
de la superclase 00:12:21
pues venga 00:12:22
vamos a llamar al constructor de la superclase 00:12:24
desde aquí 00:12:27
vale 00:12:28
super 00:12:34
ya estoy llamando al constructor de la superclase 00:12:35
pero 00:12:38
si el constructor de mi superclase 00:12:40
me está pidiendo un parámetro 00:12:42
lógicamente porque lo que hace es esto 00:12:44
pues vamos a pasarle el parámetro 00:12:46
¿qué parámetro le quieres pasar? 00:12:48
este 00:12:49
pues ala 00:12:50
magnífico 00:12:52
voy a dejar esto comentado 00:12:55
y voy a pasarle el parámetro 00:12:57
¿qué me está diciendo? 00:12:58
vale 00:13:04
si lo es 00:13:05
vale entonces ¿por qué lo he puesto aquí arriba? 00:13:11
porque si uno usa 00:13:17
la llamada al constructor de arriba 00:13:19
tiene que ser siempre la primera línea 00:13:20
de todo lo que hay en el constructor 00:13:23
si hay un super en algún sitio 00:13:24
tiene que ser la primera línea 00:13:27
tiene que ser la primera línea 00:13:27
tiene que ser la primera línea 00:13:27
tiene que ser la primera línea 00:13:27
tiene que ser la primera línea 00:13:28
vale, pues se lo ha puesto al principio 00:13:28
que me está diciendo, tienes que ponerlo al principio 00:13:30
pero joder, hay que estar al principio, ¿no? 00:13:32
ah, call, claro 00:13:36
que es que no sé, efectivamente, he hecho un constructor 00:13:37
con un void ahí, vale, vale, gracias 00:13:40
vale, vale, sí, sí es 00:13:41
vale 00:13:44
bueno, pues esto sí es lo habitual 00:13:44
esto sí es lo habitual 00:13:50
cuando hay clases que le dan unas de otras 00:13:52
que el constructor de una subclase 00:13:54
se construya 00:13:57
apoyándose en llamadas 00:13:58
al constructor de arriba 00:14:00
y en las llamadas al constructor de arriba 00:14:01
las aprovecho para inicializar 00:14:04
las propiedades que no veo 00:14:06
como nombre 00:14:08
no la vemos, no pasa nada 00:14:10
le paso el parámetro 00:14:12
al constructor de arriba 00:14:13
y a través del constructor 00:14:15
de arriba ya hago la línea 00:14:18
que no podía hacer 00:14:20
vale, pues así 00:14:21
se suelen hacer 00:14:26
voy a poner esto aquí para que quede más pegadito 00:14:27
así es como se suelen hacer los constructores 00:14:30
apoyándose en el de arriba 00:14:36
primero llamas al de arriba 00:14:38
para inicializar las propiedades 00:14:40
a las que tú no tienes acceso porque has heredado 00:14:41
y tienen privado 00:14:43
y luego ya inicializas las propias tuyas 00:14:44
suele ser lo habitual 00:14:48
vale 00:14:50
entonces, aquí hemos llamado a super 00:14:52
con un parámetro 00:14:56
porque el constructor de arriba 00:14:56
recibe un parámetro 00:14:59
pero claro, el constructor 00:15:02
puede recibir lo que 00:15:05
cualquier cosa, depende de lo que sea 00:15:06
vale 00:15:10
y en 00:15:11
vale 00:15:15
en pez, pues lo mismo 00:15:18
lo ideal sería en donde estamos 00:15:19
donde está el pez 00:15:21
vale, pez 00:15:26
yo lo he generado automáticamente 00:15:27
y me lo ha generado ya él así 00:15:29
vale 00:15:30
vamos a 00:15:31
vale 00:15:34
bueno, pues así tenemos los constructores 00:15:37
de perro y de pez 00:15:41
apoyados en el de arriba 00:15:43
vale 00:15:45
está entendido entonces lo que significa el super 00:15:47
super es la llamada 00:15:51
al método constructor de arriba 00:15:53
que a mí me puede interesar hacerla 00:15:54
o no 00:15:56
pero normalmente dentro de un constructor 00:15:56
suele ser la forma 00:15:59
de inicializar tus propiedades 00:16:00
las heredadas las inicializas 00:16:03
llamando al constructor de arriba 00:16:05
y las tuyas propias 00:16:07
ya las inicializas directamente una a una 00:16:09
vale 00:16:11
entonces, al constructor de perro 00:16:13
como tiene dos propiedades 00:16:15
pues le pasamos dos cosas 00:16:17
aunque yo aquí solamente vea una 00:16:18
pero es que la otra está arriba 00:16:20
la inicializo aquí 00:16:21
y la otra aquí 00:16:23
vale 00:16:25
está entendido 00:16:26
vale 00:16:29
¿y qué pasa aquí con ave? 00:16:33
bueno, aquí para empezar 00:16:37
me dice que tengo que sobrescribir 00:16:38
el método abstracto 00:16:40
pero aparte se ha hecho aquí un poco la pichonía 00:16:41
con los constructores 00:16:44
ahora ya podemos entender por qué se la está haciendo 00:16:45
vale 00:16:47
de hecho es el primer error que me está dando 00:16:49
bueno, me está dando dos errores 00:16:51
ahora mismo la clase ave está de aquí 00:16:56
me está diciendo 00:16:58
dos cosas mal 00:16:59
me está 00:17:02
regañando en dos cosas 00:17:04
esta de abajo 00:17:08
ya la hemos dicho antes 00:17:12
me dice, perdona 00:17:13
pero el tipo ave, lo siento 00:17:15
debe dar cuerpo al método abstracto heredado 00:17:16
realizar acción 00:17:19
eso ya lo hemos dicho 00:17:20
este es un método abstracto en animal 00:17:21
lo siento mucho 00:17:23
si quieres heredar de animal 00:17:24
tienes que implementar 00:17:25
implementar es dar cuerpo 00:17:28
dar código 00:17:30
tienes que implementar el método heredado 00:17:31
eso ya lo sabemos 00:17:33
bueno, vamos a dejar ese problema 00:17:34
para que nos quede solo el error de arriba 00:17:36
que tiene que ver con los constructores 00:17:38
venga, pues hombre 00:17:39
uno tendría que escribir la cabecera 00:17:41
y ya dar lo que sea 00:17:44
pero bueno, como estamos vagos 00:17:45
y si controlamos y sabemos 00:17:47
el eclipse es útil 00:17:51
si no, el eclipse nos hunde 00:17:53
pues vamos a tener que 00:17:54
vamos a, venga 00:17:55
añade métodos no implementados 00:17:56
pues le das aquí, añade 00:17:58
y él te copia la cabecera del de arriba 00:18:00
y ya abajo te lo deja en blanco 00:18:02
para que tú hagas lo que sea 00:18:04
vale, pues estupendo 00:18:04
esto es lo que nosotros queríamos 00:18:09
para arreglar ese segundo error 00:18:11
este, te dice 00:18:12
esta anotación 00:18:15
por ahora la quitamos 00:18:15
ni molesta, ni deja de molestar 00:18:16
ahora mismo no nos interesa 00:18:20
así que la quitamos 00:18:21
vale, pues ya está sobrescrito 00:18:22
y ya está listo 00:18:24
hombre, a ver, no tiene cuerpo 00:18:25
no tiene, vamos a ponerle algo 00:18:27
realizar acción del animal 00:18:29
pues bueno, este es un ave 00:18:31
pues ala, ya está sobrescrito 00:18:32
ya tiene su acción 00:18:35
ya tienen el perro 00:18:36
el pez y el ave 00:18:39
ya todos tienen su acción sobrescrita 00:18:40
al heredar de animal 00:18:42
han tenido obligatoriamente que sobrescribir la acción 00:18:44
vale, pero nos sigue quedando un error 00:18:47
nos sigue quedando un error 00:18:49
por resolverlo 00:18:55
que es 00:18:55
nos dice aquí 00:18:58
oye, el constructor animal sin parámetros 00:19:02
no está definido 00:19:06
hombre, claro que lo sé 00:19:07
que no está definido 00:19:09
claro que sé que no está definido 00:19:11
vámonos animal 00:19:12
aquí en animal solo está este 00:19:14
el sin parámetros no está 00:19:16
claro, la pregunta sería 00:19:18
pero y por qué este 00:19:22
necesita que se suba 00:19:24
para que el de arriba sin parámetros esté 00:19:25
bueno, pues vamos a intentar entenderlo 00:19:27
a ver 00:19:32
vámonos a esta clase animal 00:19:34
esta clase tal y como está 00:19:40
no tiene ningún constructor 00:19:43
no tiene ninguno 00:19:46
no tiene nada 00:19:46
no tiene ningún constructor 00:19:48
vale, nosotros ya sabemos 00:19:50
porque ya lo hemos dicho en su momento 00:19:52
que cuando en una clase no es 00:19:53
no he escrito ningún constructor 00:19:55
en realidad es como si tuviera 00:19:57
uno sin parámetros vacío 00:19:59
es lo que hemos dicho siempre 00:20:01
si yo no he escrito ninguno 00:20:02
en realidad lo que tengo ahí escondido 00:20:04
aunque yo no lo vea 00:20:06
es este 00:20:07
es lo que hemos dicho siempre 00:20:09
si yo en una clase no pongo un constructor 00:20:22
entonces se asume 00:20:24
que por defecto está eso ahí 00:20:26
claro 00:20:28
pero eso es así 00:20:30
si la clase no hereda de nadie 00:20:32
si la clase hereda de alguien 00:20:33
Java lo que se inventa 00:20:36
es que entonces el constructor por defecto 00:20:38
es este más el súper vacío 00:20:41
esto es lo que él se inventa 00:20:43
esto 00:20:45
se inventa esto 00:20:46
dice que tú no tienes nada 00:20:47
en ninguna clase no tienes nada 00:20:49
pues es como si tuvieras un constructor 00:20:51
que no hace nada 00:20:54
nada más que llamar al 00:20:54
de la súper clase sin parámetros 00:20:56
él se inventa y dice 00:20:58
no me has escrito ningún constructor 00:21:00
pues entonces es el que te pongo 00:21:01
te pones ese 00:21:02
aunque no lo veamos físicamente 00:21:03
aunque no lo veamos 00:21:04
este es el que nos ha puesto 00:21:06
luego tenerlo yo escrito 00:21:08
y no tener nada 00:21:10
es lo mismo es equivalente 00:21:10
porque este es el que nos está poniendo 00:21:12
claro y aquel compilador dice 00:21:14
pues no 00:21:15
imposible 00:21:16
porque esto que es 00:21:17
llamada al constructor de la súper clase 00:21:19
pero todos los constructores 00:21:21
el que no tenga parámetro 00:21:23
nos vamos a animal 00:21:24
y no hay ningún constructor sin parámetros 00:21:27
no hay ninguno 00:21:30
pues es justo lo que nos está diciendo 00:21:31
el compilador 00:21:34
cuando yo he quitado esto 00:21:34
me está diciendo 00:21:36
tienes un constructor 00:21:38
que llama al súper sin parámetros 00:21:41
me voy yo a animal 00:21:43
y no veo ningún constructor sin parámetros 00:21:44
lo siento 00:21:46
no puedes 00:21:47
por eso me sale este error aquí 00:21:48
si yo no escribo nada 00:21:50
¿vale? 00:21:51
soluciones 00:21:53
pues claro 00:21:53
desde el momento en que yo hago un constructor ya suyo 00:21:54
con parámetros 00:21:56
un constructor normal y corriente 00:21:57
como este 00:21:59
pues ya está 00:22:01
ya está solucionado 00:22:03
me he hecho un constructor 00:22:05
que llama a un constructor que ya existe 00:22:06
¿eh? 00:22:09
pues a mí no me está dando error 00:22:11
porque yo siempre tengo un constructor sin parámetros 00:22:13
claro 00:22:14
claro 00:22:15
con esta combinación nos daría 00:22:15
pero con la otra tampoco 00:22:17
yo lo dejo así sin parámetros 00:22:19
y digo bueno no pasa nada 00:22:21
me voy a animal 00:22:22
y te hago un constructor sin parámetros 00:22:23
ala venga 00:22:24
te voy a hacer uno 00:22:25
public animal 00:22:27
ala sí vacío 00:22:30
ya está 00:22:31
estupendo 00:22:32
a ave se le quita el error 00:22:34
porque ahora ya 00:22:36
esto que realmente tiene 00:22:37
aunque yo no lo vea 00:22:40
perdona 00:22:41
era esto 00:22:42
esto que realmente es lo que tiene 00:22:43
aunque yo no lo vea 00:22:48
a lo que está llamando ahora 00:22:49
es a la versión del constructor sin parámetros 00:22:50
que ya sí que existe 00:22:53
y así que existe 00:22:54
entonces el compilador dice 00:22:56
marín magnífico 00:22:56
pero que yo esto lo quito 00:22:57
fuera que esto lo quito 00:22:59
pues el ave está 00:23:01
pues se vuelve loca otra vez 00:23:04
me dice 00:23:06
entonces bueno 00:23:06
de nuevo se trata de entender las cosas 00:23:09
y luego ya cada uno 00:23:11
pues da la solución que estime oportuna 00:23:13
aquí en este caso natural 00:23:16
es que todas las clases tengan su constructor 00:23:17
con parámetros que utiliza las propiedades 00:23:20
entonces pues 00:23:22
en este caso lo que 00:23:24
esto por ejemplo 00:23:25
en este caso que el ave tiene además 00:23:26
una propiedad suya 00:23:31
que debería tenerla 00:23:32
hombre 00:23:33
es lo natural 00:23:33
porque si no para que hereda 00:23:34
pues privado el ave 00:23:35
pues yo que sé 00:23:38
que tiene un ave 00:23:39
que no tenga el resto de animales 00:23:40
aparte de alas 00:23:41
pero 00:23:42
claro y eso como 00:23:43
venga velocidad de vuelo 00:23:48
pues ya está 00:23:49
la velocidad que pueda alcanzar 00:23:50
yo que sé 00:23:53
altura 00:23:53
y después 00:23:54
La altura a la que puede volar 00:23:54
Bueno, pues aquí uno podría ya tener su 00:23:55
Y ahora aquí ya tendríamos 00:24:01
Pues esto, dis.altura 00:24:08
Aquí ya no hay ningún problema 00:24:10
O sea, al tener un constructor 00:24:16
Ya hecho 00:24:17
El constructor sin parámetros ya no está 00:24:19
Ya se, ya no está 00:24:21
Entonces no hay ningún problema 00:24:22
¿Vale? 00:24:24
Bueno, está entendidísimo 00:24:40
Pues esto en realidad es 00:24:42
Todo lo importante de la herencia 00:24:46
Todo, y luego ya de aquí se derivan 00:24:49
Muchas posibilidades de programar 00:24:51
De para ti si uno lo usa bien 00:24:52
Claro, si uno se lo usa bien 00:24:54
Pero es esto 00:24:55
Y luego esto, ¿por qué se queda cojo a veces? 00:24:55
Pues por lo que ya dijimos el otro día 00:24:59
Que solo se puede heredar de una clase 00:25:01
Entonces, ¿cómo recojo yo el hecho 00:25:03
De que un cliente 00:25:06
Un cliente tienda 00:25:08
Pues sea a la vez cliente 00:25:10
Y a la vez sea socio 00:25:11
El ejemplo este que os hice el otro día 00:25:12
A la vez sea 00:25:14
Si se lo puede heredar de una 00:25:14
No lo recojo 00:25:16
Bueno, pues entonces se siguen poniendo 00:25:16
Nuevas cosas, etcétera, etcétera 00:25:18
Como interfaces, etcétera, etcétera 00:25:20
¿Vale? 00:25:22
Vale 00:25:22
Y ya para terminar 00:25:27
Y ya nos vamos 00:25:33
Porque ya hoy no nos va a dar tiempo 00:25:33
A hacer ningún ejercicio ya ni nada 00:25:35
Eso ya mañana 00:25:36
Vale, ya vamos a completar 00:25:37
En realidad 00:25:40
Hay una clase 00:25:42
Que está por ahí 00:25:43
La máquina virtual nos la da 00:25:45
Si uno mira aquí en la máquina virtual 00:25:52
Todas las cosas que le da 00:25:55
Pues por ejemplo 00:25:57
Hay una clase 00:26:00
Que se llama 00:26:01
Object 00:26:04
De todas las miles de clases 00:26:08
Que me da a mí la máquina virtual 00:26:12
Para yo poder llamarlas y hacer cosas 00:26:13
Como la clase string 00:26:15
La clase escáner 00:26:17
Bueno, muchas 00:26:18
Hay una que es 00:26:20
Especial 00:26:21
Que es la clase object 00:26:23
Bueno, pues la clase object 00:26:24
Es una clase 00:26:26
De la cual 00:26:27
Cualquier otra clase hereda 00:26:28
Aunque yo no ponga el extens 00:26:30
O sea, si yo hago una clase 00:26:31
Y no pongo extens algo 00:26:35
Esa clase hereda de esta 00:26:37
Hereda de esta 00:26:39
Por narices 00:26:41
Entonces esta clase 00:26:42
Ofrece algunas cositas 00:26:46
Pero son muy abiertas 00:26:47
Uno las tendría luego que sobrescribir 00:26:50
Es decir, esta es la clase object 00:26:53
Esta clase object 00:26:55
Que 00:26:56
Ofrece 00:26:58
Pues 00:27:01
Métodos 00:27:02
Vale 00:27:04
El equals 00:27:07
Ofrece aquí un montón de métodos 00:27:09
Que cualquiera de nuestras clases 00:27:14
Está heredando 00:27:16
Sin saberlo, son muy poquitos 00:27:16
Que los ofrece 00:27:18
Y algunos de ellos 00:27:19
Son muy poquitos 00:27:20
Los iremos entendiendo 00:27:20
Entonces 00:27:22
Por ejemplo, la clase animal 00:27:22
La clase animal 00:27:24
No tiene ningún extens 00:27:26
No tiene ninguno 00:27:27
No tiene nada 00:27:28
¿Qué significa? 00:27:29
Que en realidad 00:27:32
Aunque yo no lo ponga 00:27:32
Está heredando de object 00:27:34
Entonces dejarlo en blanco 00:27:35
O dejar esto 00:27:37
Es lo mismo 00:27:39
Es lo mismo 00:27:43
Por eso no se pone 00:27:45
Por eso no se pone 00:27:46
¿Vale? 00:27:48
Cualquier clase 00:27:49
Sin embargo 00:27:50
Si no se indica 00:27:50
De cual hereda 00:27:51
Hereda de la clase object 00:27:52
¿Vale? 00:27:53
Que ahora 00:27:56
Perro hereda de animal 00:27:57
Pues entonces 00:27:59
Perro hereda de animal 00:28:02
Y como animal a su vez 00:28:03
Hereda de object 00:28:05
Perro también se ha quedado 00:28:06
Con todo lo de object 00:28:07
¿No? 00:28:08
O sea, lo de la 00:28:09
Lo del abuelo 00:28:10
Que es object 00:28:12
Pasa todo al hijo 00:28:12
Que es animal 00:28:15
Al padre, vamos 00:28:16
Entonces animal tiene 00:28:18
Todo lo de object 00:28:19
Y lo suyo 00:28:20
Entonces quien herede de animal 00:28:20
Se queda con todo lo de animal 00:28:23
Que a su vez es 00:28:24
Todo lo de object 00:28:25
Y todo lo de animal 00:28:26
¿No? 00:28:26
O sea, la herencia 00:28:27
Se va 00:28:28
Que alguien hereda de perro 00:28:29
Pues el que herede de perro 00:28:31
Se queda con todo lo que tiene perro 00:28:32
Que a su vez es 00:28:34
Todo lo que tenía animal 00:28:35
Que a su vez es 00:28:36
Todo lo que tenía object 00:28:37
¿Vale? 00:28:38
Entonces hay una jerarquía 00:28:39
Una herencia 00:28:40
De varios niveles 00:28:40
Obviamente 00:28:42
De hecho 00:28:43
Cuando nosotros 00:28:48
Tenemos un objeto 00:28:49
Animal por aquí 00:28:50
Cualquiera 00:28:51
En nuestro main 00:28:52
Por ejemplo 00:28:55
Vamos a 00:28:55
Me aparece aquí en rojo 00:28:56
Y no veo el error 00:29:03
Ah, está aquí abajo 00:29:04
Ah, aquí 00:29:06
Que había comentado 00:29:07
El objeto animal 00:29:08
Vale 00:29:10
Vale 00:29:10
Vale 00:29:12
Entonces le voy a quitar 00:29:19
Un momento 00:29:20
Animal el abstracto 00:29:20
Para poder instanciar 00:29:21
Objetos de él 00:29:23
Le voy a quitar 00:29:23
Un momento el abstracto 00:29:26
Para poder 00:29:27
Instanciar objetos suyos 00:29:28
¿Vale? 00:29:32
Le voy a quitar el abstracto 00:29:33
De aquí 00:29:35
Y aquí entonces 00:29:35
Le pondría esto 00:29:44
Vale 00:29:45
Le he quitado el abstracto 00:29:47
Solamente 00:29:47
Y lo he dejado 00:29:48
Un método 00:29:49
Ya con llaves 00:29:50
Aunque no haga nada 00:29:51
Para poder instanciar 00:29:51
Un objeto animal 00:29:54
Para poder instanciarlo 00:29:55
Entonces haberle quitado 00:29:56
El abstracto 00:29:57
Ahora ya puedo instanciarlo 00:29:57
¿Vale? 00:29:58
Tengo el nuevo animal 00:29:58
Vale 00:29:59
Pues este objeto 00:30:00
Si yo miro 00:30:03
Todo lo que tiene 00:30:05
Pues además 00:30:06
De lo que yo he escrito 00:30:09
En animal 00:30:10
Que era 00:30:11
¿Vale? 00:30:12
¿Vale? 00:30:12
¿Vale? 00:30:12
¿Vale? 00:30:12
¿Vale? 00:30:13
¿Vale? 00:30:13
¿Vale? 00:30:13
¿Vale? 00:30:13
¿Vale? 00:30:14
¿Vale? 00:30:14
¿Vale? 00:30:14
¿Vale? 00:30:15
¿Vale? 00:30:15
¿Vale? 00:30:15
¿Vale? 00:30:15
¿Vale? 00:30:16
¿Vale? 00:30:16
¿Vale? 00:30:17
¿Vale? 00:30:17
¿Vale? 00:30:18
¿Vale? 00:30:21
¿Vale? 00:30:21
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:22
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
¿Vale? 00:30:23
Claro, eso 00:30:23
Para poder instanciar un objeto 00:30:24
A ver lo que hereda 00:30:26
Pues además de comer 00:30:27
Que lo he hecho en animal 00:30:28
Y está claro que lo tengo 00:30:29
Y además del get 00:30:30
Y del set 00:30:32
Estas son las únicas tres cosas 00:30:33
Que he hecho yo en animal 00:30:35
Comer 00:30:36
Get 00:30:37
Y el set 00:30:38
El único que he hecho 00:30:39
Pues todo lo demás 00:30:41
Me está dejando llamarlo también 00:30:42
Y todo lo demás 00:30:43
¿Qué es? 00:30:45
Métodos de object 00:30:46
Son métodos de object 00:30:46
Lo que pasa es que son métodos de object 00:30:48
Que me ofrecen muy poquitas cosas 00:30:51
¿Vale? 00:30:53
Los de notify 00:30:54
En particular 00:30:55
Están relacionados con sincronización 00:30:56
Cuando hay varios hilos 00:30:58
Otros no los vamos a usar 00:30:59
El toString 00:31:00
Es un método 00:31:03
Que me devuelve un string 00:31:04
Que se supone que es 00:31:05
La explicación 00:31:07
De la explicación 00:31:08
De lo que es el objeto 00:31:08
Pero es una explicación 00:31:10
Que no vale para nada 00:31:10
Entonces lo ideal es que uno 00:31:11
Se sobreescriba el toString 00:31:13
¿Vale? 00:31:15
El hashcode es para generar 00:31:18
Un código hash 00:31:19
Pero eso tiene que ver 00:31:20
Con colecciones 00:31:20
Con conjuntos 00:31:21
Ofrece pocas cosas 00:31:22
El equals 00:31:23
El equals 00:31:25
Es un método 00:31:27
Que está en object 00:31:29
Que lo único que te devuelve 00:31:29
Es true 00:31:32
Si la dirección de memoria 00:31:32
Del objeto este 00:31:34
Que tú le pasas 00:31:36
Es la dirección de memoria 00:31:37
De la aplicación 00:31:38
Del que llama 00:31:38
Te devuelve eso 00:31:39
Que te interesa ese equals 00:31:40
¿Vale? 00:31:41
Que no 00:31:42
Sobreescribes el equals 00:31:42
¿Vale? 00:31:43
No nos da tiempo 00:31:45
Ahora a ver ejemplos 00:31:45
¿Has tenido que quitar 00:31:46
El modificador de astras 00:31:47
Para poder? 00:31:48
Claro, claro 00:31:49
Si no, no puedo crear objetos 00:31:50
A ver, lo que yo quería era 00:31:51
Instanciar aquí 00:31:52
Un objeto animal 00:31:53
Aquí hacer el new 00:31:54
Para poder ver los métodos 00:31:56
Entonces si yo no quito el astra 00:31:58
No puedo instanciarlo 00:31:59
Por eso lo he quitado 00:32:01
Se supone que la clase animal 00:32:02
Era de un objeto 00:32:03
Porque no 00:32:05
No lo recogió 00:32:06
¿Vale? 00:32:07
Bueno, sí, a ver 00:32:08
Sí, sí, sí 00:32:10
Sí, lo que pasa es que ahora estoy 00:32:13
Sí, pero lo que pasa es que 00:32:15
A ver 00:32:16
Que ahora yo estoy en mi main 00:32:17
Y quería tener un objeto a 00:32:18
Quería tenerlo ahí hecho 00:32:20
En mi main 00:32:21
Para poder llamar a sus cosas 00:32:21
Quería que existiera ese objeto 00:32:23
Quería que existiera 00:32:25
Pues para jugar a llamar a cosas 00:32:26
Entonces para que este objeto exista 00:32:28
Y poder yo hacer pruebas 00:32:30
Y llamar a cosas 00:32:31
Tiene que existir 00:32:32
Si no, luego no podría ejecutar esto 00:32:34
Entonces por eso 00:32:35
Yo no puedo hacer el new 00:32:37
Y no puedo hacer el new 00:32:38
No puedo 00:32:38
Si es abstracta 00:32:39
Por eso le he quitado el abstracto 00:32:41
Para poder hacer el new 00:32:43
Solamente para poder hacer el new 00:32:44
¿Vale? 00:32:46
A ver, que yo para 00:32:47
Para ver el listado de métodos 00:32:49
El área no me hace falta 00:32:50
Porque el compilador ya me los va a ofrecer 00:32:52
O sea, yo no hago el new 00:32:54
Y ahora hago, hago aquí 00:32:56
A punto 00:32:58
Y la oferta me la hace igual 00:32:59
Porque esto es un tema de compilador 00:33:03
El compilador me dice 00:33:04
Ah, está declarado arriba como animal 00:33:05
¿Puedes llamar a eso? 00:33:08
¿Puedes llamar a esto? 00:33:08
Lo que pasa es que si luego ejecutáramos esto 00:33:09
A no está instanciado 00:33:11
Entonces yo no podría ejecutar nada 00:33:13
Porque el objeto A no existe 00:33:16
¿Vale? 00:33:17
Entonces simplemente he quitado el abstracto 00:33:18
Para poder hacer este A igual a new animal 00:33:21
Solamente 00:33:23
Porque si no, no puedo 00:33:25
No puedo instanciar objetos de una clase abstracta 00:33:26
¿Vale? 00:33:29
¿Vale? 00:33:32
Pues entonces 00:33:33
Estos métodos que me ofrece TheObject 00:33:34
Equals to string 00:33:38
Yo puedo ahora ya aprovecharme de ellos 00:33:39
Sobrescribiéndolos 00:33:41
Puedo aprovecharme y hacer mi aplicación 00:33:42
Un poquito más, más vistosa 00:33:44
Pero bueno, vamos a dejarlo ya para 00:33:46
Para el próximo día 00:33:48
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
5 de febrero de 2024 - 20:21
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
33′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
152.30 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid