Saltar navegación

20250113 Herencia - 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 2025 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me dais el permiso de grabar vuestra voz y que se grabará en esta grabación. He dicho grabación 20 veces. 00:00:00
Vale, entonces, después de haber visto los conceptos de objeto y de clase y la diferencia que hay, que repasamos muy rápidamente, la clase es como una idealización, una generalización, una abstracción de un concepto que estoy modelizando. 00:00:11
Y luego a partir de esta abstracción puedo crear instancias concretas, réplicas de este molde que he creado, creando objetos. 00:00:28
Entonces la clase Persona me dirá que todas las personas tendrán un nombre, un apellido y un DNI. 00:00:38
Y luego tendré un objeto concreto que tiene un determinado valor en nombre, un determinado valor en apellido, un determinado valor en DNI. 00:00:44
Y podré hacer cuantos objetos me da la gana a partir de este molde general que es la clase 00:00:51
Vamos a ver algunos conceptos un poquito más avanzados de la programación orientada a objetos 00:00:58
¿Qué son estos conceptos? Son herramientas, son opciones, son posibilidades que me proporciona la programación orientada a objetos 00:01:05
para que pueda lograr aprovechar mi código de una forma mejor, digamos así. 00:01:14
¿Es obligatorio utilizarlas? No, ¿vale? 00:01:26
Según qué proyecto hacemos, todos los proyectos que hemos hecho hasta ahora, 00:01:30
todos los ejercicios que hemos hecho ahora, pues no necesitan de estas cosas 00:01:33
porque son proyectos muy, muy sencillos. 00:01:36
Pero nosotros tenemos que, con ejemplos sencillos, aprender a utilizar estas herramientas porque luego en proyectos más complejos o en varios proyectos, en una empresa que desarrolla muchos proyectos, etc., pues estas herramientas nos proporcionan grandes ventajas como principalmente reuso de código. 00:01:39
La idea de que cada vez que empezamos un nuevo proyecto tengamos que reinventar los mismos conceptos o remodelizar conceptos que ya hemos utilizado en otros proyectos no es una cosa positiva. 00:01:59
A veces es necesario, a veces yo me doy cuenta de proyectos anteriores que, como había modelizado la persona, pues no es eficiente porque me provoca varios problemas, pues entonces rehago el concepto de personas de cero aprovechando del conocimiento que he ganado en los proyectos anteriores. 00:02:18
Pero no siempre es así. Muchas veces una empresa que se dedica a un determinado aspecto, entonces es experta en un determinado problema, en un determinado contexto, pues ya ha creado su conjunto de clases que se reutilizan en proyectos distintos y quiere reutilizar lo que antes había. 00:02:37
Sin embargo, muchas veces reutilizar cosas anteriores puede que no sea posible al 100%, que a lo mejor el nuevo proyecto tiene que añadir algo, quitar algo o modificar algo. 00:02:56
Y entonces existen estas técnicas para que esto sea más fácil y sea más interesante, sea más productivo para las empresas. 00:03:08
el primer mecanismo que vamos a ver es el mecanismo de herencia 00:03:19
un poquito la herencia, ya lo hemos visto 00:03:24
porque cuando en episodios anteriores de programación 00:03:27
hemos visto el concepto que existe una clase objeto 00:03:31
y que todas las clases que habéis creado vosotros son objetos 00:03:34
y que tienen los mismos métodos de la clase object 00:03:38
pues en realidad allí eso es la esencia de la herencia 00:03:41
Lo que hemos dicho las otras veces es que vuestros objetos se heredan de object 00:03:47
Pero vamos a formalizar un poquito más este concepto 00:03:53
Mirando aquí que nos dice la transparencia 00:03:58
Es un mecanismo para la reutilización del software 00:04:01
Permite definir a partir de una clase otras clases que reutilicen todo o parte de los atributos o métodos de la clase que heredan 00:04:05
Ejemplo, yo hago una persona 00:04:14
Esta persona tiene un nombre y una edad 00:04:16
A partir de este concepto de persona 00:04:19
Yo podría crear dos clases nuevas 00:04:22
Una que es profesor y una que es estudiante 00:04:25
Ahora, tanto profesor como estudiante 00:04:28
Comparten un nombre y una edad 00:04:30
Porque tanto profesor como estudiante son personas 00:04:33
Entonces la idea es que yo 00:04:36
En vez de crearme una nueva clase entera 00:04:39
Donde le diría, el estudiante tiene string nombre 00:04:41
El estudiante tiene int edad 00:04:44
más, por ejemplo, aquí tiene un array de int de sus notas, pues lo que voy a hacer es que le voy a decir, 00:04:46
mira, el estudiante es una persona, el estudiante hereda de persona, importa en un cierto sentido, 00:04:52
hasta si importar es un término feo porque existe import, que es un poquito distinto, 00:05:00
pero recibe desde persona todo lo que persona tiene y a partir de allí puede hacer cosas, 00:05:05
Puedo añadir nuevas características 00:05:15
Por ejemplo, puedo decir que una persona no tiene un grupo 00:05:19
Pero un estudiante sí que pertenece a un grupo 00:05:23
Vosotros perteneces a uno 00:05:26
Entonces podría ser que al estudiante le ponga string grupo 00:05:28
Pero seguramente el estudiante es una persona 00:05:32
Por lo tanto tendrá nombre y edad 00:05:35
Y además su grupo y además sus notas 00:05:37
Ahora, también el profesor es una persona 00:05:40
Entonces también el profesor tendrá nombre y edad 00:05:42
Pero además tiene un array de string que es las asignaturas que imparte. Por ejemplo, o podría tener un array de asignaturas siendo asignatura otra clase. 00:05:45
esto lo está haciendo como ejemplo muy básico 00:05:55
solo con atributos 00:06:00
pero cuando se hereda, se heredan también los métodos 00:06:03
entonces si la persona tenía un método saludar 00:06:07
que decía hola soy y su nombre 00:06:09
pues ahora también los profesores y los estudiantes 00:06:12
tienen ese método 00:06:15
si una clase A hereda de una clase B 00:06:17
Quiere decir que la clase A puede hacer todo lo que hace una clase B 00:06:22
Y posiblemente más 00:06:26
O, y lo veremos un poquito más adelante 00:06:28
Puede hacer lo mismo de la clase B 00:06:31
Pero de forma distinta 00:06:34
¿Vale? 00:06:35
Ejemplo de esto lo hemos hecho 00:06:38
¿Os acordáis del equals? 00:06:39
Que perdimos un buen rato el viernes mirando ese ejemplo 00:06:40
Pues cuando yo he creado mi clase que era tarea 00:06:43
Y que heredaba el método equals desde object 00:06:46
Y lo hemos probado antes sin hacer nada 00:06:52
Y hemos utilizado el mismo método de object 00:06:54
Y luego hemos creado un equals dentro de tarea 00:06:56
Y hemos creado que hace lo mismo 00:06:59
Porque puede utilizar el método equals 00:07:01
Pero lo hace de una forma distinta 00:07:03
Ahora en vez de equipararse como hace object 00:07:05
Se equiparaba de otra forma 00:07:07
Entonces más o menos estas ideas 00:07:09
Ya las hemos trabajado 00:07:11
Para que hoy cuando la veáis 00:07:13
La formalicemos 00:07:15
Pero no suenen como es la primera vez que lo escucho 00:07:16
Vale, cuando hablamos de herencia podemos aplicarla, podemos utilizarla o nos sale a la mente y nos viene útil en dos posibles contextos. Uno es especializando y uno es generalizando. 00:07:20
¿Qué quiere decir? Por ejemplo, un ejemplo de especialización es cuando uso la clase coche especificándola, especializándola desde vehículo. 00:07:42
Imaginaos que yo ya tengo la clase vehículo, que es una cosa genérica, y yo digo, vale, a partir de vehículo creo coche. 00:07:53
Entonces, coche es un vehículo. Entonces, coche herederá de vehículo. 00:08:01
Todo lo que puede hacer un vehículo lo puede hacer un coche, pero el coche tendrá algunas características extra más específicas para el coche mismo, ¿vale? Por ejemplo, el tipo de ruedas, que por ejemplo un vehículo como un barco no tiene tipos de ruedas, ¿sí? Y cosas por el estilo. 00:08:05
Esto sería parecido a lo que hemos hecho aquí. Persona es genérico y luego lo que he hecho es especializarlo en un profesor, que es una persona con algo más, más específica, y estudiante, que es otra persona, pero más específica de otra forma. 00:08:24
Entonces, el escenario en el que utilizamos la especialización es que tenemos que desarrollar una nueva clase que se parece mucho a una que ya tenemos, pero que necesita información como características o comportamientos adicionales. 00:08:39
¿Sí? Tengo un vehículo, este ya está existente, tengo que crear coche, que es algo más específico que vehículo, pero mucha parte, por ejemplo, moverse, por ejemplo, parar, por ejemplo, acelerar, pues son todas cosas que puede hacer un vehículo y, por lo tanto, lo reutilizaría en coche. 00:08:54
¿Sí? 00:09:10
La solución de este escenario con especialización es que creo una subclase, ¿vale? Esta nomenclatura se puede llamar subclase, se puede llamar clase hija, se puede llamar clase derivada, ¿vale? 00:09:11
que es una clase nueva a la que heredamos todo lo que está antes, pillamos todo el código 00:09:22
como si copiáramos todo el código que estaba en vehículo, en la clase superior digamos 00:09:31
lo copio sin tener que copiarlo en esta subclase y luego me pongo a añadir y a modificar 00:09:36
las cosas puntuales que quiero modificar para este nuevo elemento concreto 00:09:43
El segundo caso es en caso de generalización 00:09:49
O sea, crear la clase vehículo como generalización de coche 00:09:54
¿Qué quiere decir esto? 00:09:59
El escenario es, imaginaos que yo tengo un conjunto de varias clases 00:10:00
Que en mi proyecto han surgido 00:10:05
Y antes estaba haciendo una parte, he creado varias clases 00:10:07
Luego he hecho otra parte, he pensado una escuela 00:10:09
Y he creado alumno para gestionar alumno 00:10:12
Luego he creado profesor para generar profesor 00:10:15
luego he creado, no sé, secretario para poner la parte de secretaría que está ahí, 00:10:17
y me he dado cuenta que todas estas clases que estoy creando comparten una parte. 00:10:23
O sea, en todas estas, en alumno, en profesor, en secretario, 00:10:28
todas tienen nombre, apellido, DNI y que pueden hacer operación de ejecutar su trabajo. 00:10:33
No lo sé. 00:10:40
Como me doy cuenta que todas estas clases comparten una parte, 00:10:42
yo puedo sacar esa parte 00:10:45
ponerla en una nueva clase 00:10:49
que sería una clase más general 00:10:51
que esta de aquí, como por ejemplo la clase persona 00:10:53
y a ese punto hacer que toda esta parte 00:10:55
que antes se replicaba en cada una de las clases 00:10:59
ahora está bonita, empaquetada 00:11:03
organizada en una única clase 00:11:06
de las que las otras heredan 00:11:09
es decir, es ver esto pero al revés 00:11:11
Es ver esto que en vez de decir yo había creado persona y ahora las especializo en profesor y estudiante 00:11:14
Yo tenía un proyecto en que tenía profesor y estudiante 00:11:21
Y me doy cuenta que tanto profesor como estudiante tienen nombre y edad 00:11:24
Y por lo tanto lo que hago es crearme una clase persona de la que luego profesor y estudiante heredarán 00:11:28
¿Por qué esto es útil? 00:11:36
Porque si yo tengo un método, el ejecutar mi profesión 00:11:38
Que está tanto en alumno como en profesor y que hace lo mismo en todas. Y ahora de repente me doy cuenta que hay un error, que quiero que haga una cosa distinta, etc. Debería entrar en todas las clases y modificarlo. 00:11:42
Sin embargo, si yo he podido extraer estos datos, meterlos en una única clase, superclase 00:11:58
En una clase padre, en una clase superior 00:12:07
Y este método está allí, cuando yo modifique este método 00:12:11
En automático lo estoy modificando para todas las clases que heredan de esta clase superior 00:12:15
¿Se entiende? 00:12:20
Entonces, el mecanismo de herencia es único 00:12:22
Es eso, yo puedo pillar una clase y decir que otra clase hereda de esta aquí, ¿vale? Entonces estaría como copiando esta clase aquí y luego añadiendo cosas o modificando cosas. 00:12:25
Sin embargo, cuando se utiliza, la forma de pensar a cuando voy a utilizar la herencia tiene estos dos casos. Tiene el caso de tengo una cosa general y la quiero especializar en cosas con información adicional o al revés, generalización. 00:12:36
Tengo muchas clases que coinciden en algunas partes, entonces la parte que coincide en todas, pues la extraigo, la pongo en una clase superior y luego hago que todas las demás hereden de esta. 00:12:51
De esta forma, en vez de duplicar código en muchas clases, tengo un único sitio donde estoy poniendo este código compartido, digamos, entre las otras clases. 00:13:02
Cuando 00:13:14
Hago así, o sea, la clase 00:13:16
Superior, digamos, se puede llamar 00:13:18
Superclase, clase padre o clase 00:13:20
Base, ¿vale? Según la nomenclatura 00:13:22
Que utilicéis y como queráis 00:13:24
Llamarla, ¿vale? 00:13:26
Movemos el código que se repite 00:13:29
A un único sitio, a una superclase 00:13:30
Y luego las otras clases tiran de allí 00:13:33
Si hago una modificación a este código repetido 00:13:34
Automáticamente es como si lo estuviera 00:13:36
Modificando 00:13:38
En todas las clases 00:13:40
que heredan desde allí 00:13:42
¿vale? entonces, esto es un ejemplo 00:13:44
no hago zoom porque si no 00:13:47
se estropea la grabación 00:13:48
¿vale? pero os lo leo 00:13:50
más o menos, aquí tengo 00:13:52
una clase recurso, que representa 00:13:53
un recurso general, que tiene nombre 00:13:56
descripción, decir nombre, decir 00:13:58
descripción, ¿vale? un get nombre 00:14:00
un get descripción 00:14:02
y luego tengo como recurso un aula 00:14:03
o un ordenador, ¿vale? y me doy 00:14:06
cuenta que un aula tiene nombre, descripción 00:14:08
decir nombre, decir descripción, pero 00:14:11
además tiene localización y tiene decir localización mientras que un ordenador la 00:14:12
localización no me interesaba y tenía sistema operativo es decir sistema operativo pero me 00:14:18
doy cuenta que toda la parte azul es como una de estas tres clases de hecho está recurso podría 00:14:22
ser visto como una generalización de aula ordenador y no sé qué más cosa impresora y 00:14:30
y espacio y que se yo 00:14:35
proyector, que se yo, todos tienen que tener un nombre 00:14:39
en la descripción y sus métodos para llamar ese nombre a esa descripción, entonces que hago 00:14:44
pues pillo recurso, lo dejo con estos 00:14:48
datos que son los datos que todos los recursos tienen que tener 00:14:52
y lo hago como una super clase de la que aula y ordenador 00:14:55
heredan, a este punto en aula y ordenador no tengo 00:15:00
que volver a reescribir esta información 00:15:04
más solo añado 00:15:06
las dos informaciones 00:15:07
propias y específicas 00:15:10
de aula de ordenador 00:15:12
si lo veo como antes tenía 00:15:13
estos y a partir de esto 00:15:16
me he creado recursos y ahora 00:15:18
hago que hereda, estaría haciendo una generalización 00:15:20
si lo veo como no 00:15:22
tenía un recurso y luego a partir 00:15:24
de allí voy creando 00:15:26
mis varios recursos concretos 00:15:27
como aula, ordenador, proyector y que se yo 00:15:30
pues entonces lo estoy viendo como 00:15:32
Especialización 00:15:33
¿Dudas? 00:15:34
¿Cómo se hace esto 00:15:39
En Java? Es decir, ¿cuál es la sintaxis 00:15:41
Que me permite, dada una clase 00:15:43
Hacer que otra clase 00:15:45
Rede de ella? Pues con la palabra 00:15:47
Reservada extends 00:15:49
¿Vale? Extiende 00:15:51
En cierto sentido da esta cosa de 00:15:53
Voy a pillar todo lo que es esta clase 00:15:55
Y además la extiendo con algo más 00:15:57
Entonces 00:15:59
Yo tengo la clase recurso 00:16:00
public class recurso normal, con dentro esta cosa aquí 00:16:02
cuando voy a declarar la clase aula, public class aula 00:16:06
extends recursos, entonces 00:16:10
en este caso estaría diciendo que todo lo que está en recurso lo voy a añadir 00:16:14
a aula, más lo que esté dentro de aula 00:16:19
o public class ordenador extends recurso 00:16:21
¿dudas? 00:16:26
No necesariamente 00:16:28
No, puede extender clases de otros packages 00:16:35
Siempre que tenga acceso a ellas 00:16:39
Si la clase no es public 00:16:42
Entonces no puede acceder a otro 00:16:45
Los atributos y métodos que aparecen en azul de la clase padre 00:16:48
Se repiten en las clases hijas 00:16:54
¿Vale? Aquí, ¿veis? 00:16:55
Entonces no necesito repetir el código 00:16:57
Basta con decir que una clase extiende o hereda de la otra 00:16:59
Y ya está 00:17:02
¿Dudas? 00:17:03
Además, imaginamos que decir nombre lo quiera cambiar 00:17:06
¿Vale? 00:17:09
Aquí, en este contexto de aquí, yo lo debería cambiar en tres sitios 00:17:09
Aquí, aquí y aquí 00:17:12
Ahora, ¿con qué lo cambio aquí? 00:17:14
Pues ya, tanto en aula como en ordenador, he hecho el cambio 00:17:17
¿Se entiende? 00:17:20
¿Dudas? 00:17:23
Esto es como se llaman las cosas 00:17:24
Para entendernos cuando hablamos 00:17:31
Para que si yo digo una palabra 00:17:33
Pues vosotros entendáis que se está entendiendo 00:17:35
Entonces imaginamos una clase taxi 00:17:39
A partir de vehículo 00:17:41
Entonces taxi es la subclase 00:17:44
Y vehículo es la superclase 00:17:48
Entonces se puede decir que taxi hereda las variables y métodos de vehículo 00:17:51
O que taxi es tiende vehículo. Se puede decir que taxi es una subclase de vehículo. Se puede decir que taxi es una clase derivada o una clase hija de vehículo. Al revés, puedes decir que vehículo es una superclase de taxi o una clase base o una clase padre de taxi. 00:17:56
La herencia realiza una relación es un, es decir, que un taxi es un vehículo 00:18:14
Un vehículo no es un taxi, ¿se entiende? 00:18:23
Esto es un es interesante porque luego veremos que en determinados casos, y aquí entrará cosas como el polimorfismo, etc. 00:18:32
Yo puedo utilizar, allá donde me han dicho que puedo utilizar un vehículo, yo puedo utilizar un taxi, porque el taxi es un vehículo. 00:18:40
Entonces, no obstante su tipo sea taxi, pero como hereda todo lo que es vehículo, se puede portar como un vehículo. 00:18:52
Sin embargo, no puedo poner un vehículo donde he dicho que aquí va un taxi, porque el vehículo no es un taxi. 00:19:00
¿Se entiende? 00:19:07
aquí en un sitio donde me dicen 00:19:07
puedes usar un recurso aquí, yo puedo poner tanto un aula como un ordenador 00:19:14
porque los dos tendrán todo lo que hace falta de un recurso 00:19:18
por lo tanto si este método requiere un recurso y luego de este recurso 00:19:21
pilla, usa el nombre, decir nombre 00:19:26
o el método de decir nombre, pues tanto si es un recurso 00:19:29
como si es un aula, como si es un ordenador, tendrá este método 00:19:34
lo puede utilizar, ahora si yo te digo que aquí recibo un aula 00:19:37
como parámetro y luego dentro de este método usando este parámetro 00:19:41
aula uso decir localización, si tú me has pasado un aula 00:19:45
lo podrá hacer, pero si tú me has pasado un recurso no lo puede hacer 00:19:49
porque el recurso no lo tiene decir localización, entonces no funcionaría 00:19:53
mismo aquí, tengo una persona 00:19:56
y esta persona tiene que saludar, vale, yo si te paso una persona 00:20:00
tendrá el método de saludar y se saludará. Si te pasa un profesor, tendrá todos los métodos y datos de persona 00:20:05
y por lo tanto podrás saludar también un profesor. Al revés, si el profesor tiene asignatura y te digo 00:20:11
lístame tus asignaturas, un profesor lo puede hacer, pero si pongo un estudiante o pongo una persona, 00:20:17
como no tiene la lista de... no lo puede hacer. ¿Se entiende? 00:20:22
Entonces, hay esta relación de es un 00:20:25
Las subclases son un superclase 00:20:30
Entonces, mi clase animal es un 00:20:36
Mi clase animal es un 00:20:42
Exacto, object 00:20:50
Porque todas las clases se reten de object 00:20:58
Lo habíamos dicho 00:21:00
¿O no? 00:21:01
Pues eso 00:21:03
Es lo único que se puede decir 00:21:04
¿Puede ser un ser vivo? No lo sé 00:21:05
Depende, si se extiende de la clase 00:21:06
Ser vivo, sí 00:21:10
¿Vale? Entonces tendría que mi animal 00:21:11
Extiende de la clase ser vivo 00:21:14
Que extiende de object 00:21:16
Porque siempre subiendo, subiendo, subiendo 00:21:17
Llegaré a object 00:21:20
Que es la 00:21:21
Clase padre de todos 00:21:23
La superclase definitiva 00:21:25
¿Sí? 00:21:28
¿Dudas? 00:21:29
Sintaxis 00:21:34
En Java para indicar que una clase red 00:21:34
se usa extends, ya lo hemos dicho 00:21:36
vale, modificador, aquí podemos poner 00:21:38
public, private, lo que sea, class 00:21:40
el nombre de la clase, hija 00:21:42
extends, clase padre 00:21:44
y luego ya la defino, vale 00:21:46
entonces aquí 00:21:48
por ejemplo, esto sería persona 00:21:50
public class persona 00:21:52
aquí no pongo nada, pero es como si estuviera 00:21:54
poniendo extends 00:21:56
object, si no 00:22:06
pongo nada, aquí estoy poniendo 00:22:08
extends object 00:22:10
O sea que aquí arriba estaría object 00:22:13
¿Sí? 00:22:17
Tengo persona 00:22:18
Luego tengo public class alumno 00:22:19
Que extends persona 00:22:22
Entonces alumno 00:22:23
Es un 00:22:25
Persona 00:22:27
Un objeto alumno es un objeto persona 00:22:29
Que es un objeto object 00:22:32
¿Sí? 00:22:34
Public class empleado 00:22:37
Extend persona también 00:22:38
Y esto no necesariamente 00:22:40
se acaba aquí, yo puedo hacer public class 00:22:42
profesor que extensa empleado 00:22:44
entonces la persona tiene nombre 00:22:46
y apellido, el empleado tiene también 00:22:48
un sueldo, el profesor tiene también 00:22:50
además que un sueldo, que un nombre 00:22:52
que un apellido, tiene también una lista de asignaturas 00:22:54
¿se entiende? 00:22:56
y esto lo puedo hacer cuanto me da la gana, creando 00:22:59
una jerarquía de clases 00:23:01
es automático 00:23:04
lo hace él, si tú no me dices de quién 00:23:10
extendes, en automático extendes de obvio 00:23:13
eso es una buenísima pregunta 00:23:15
Y es no en Java 00:23:22
Porque hay otros lenguajes de programación que sí lo permiten 00:23:25
Java no permite multiherencia 00:23:29
Herencia múltiple 00:23:32
Siempre tú puedes heredar de una sola clase 00:23:33
Puedes hacer una secuencia 00:23:37
Te dices, mira, profesor necesita heredar de empleado y de persona 00:23:39
Vale, pues persona necesita de empleado, empleado de profesor 00:23:44
Eso sí 00:23:47
Pero no puedes decirle extend 00:23:47
Persona y extend 00:23:49
Animal 00:23:51
Por eso son animales 00:23:55
Solo en los exámenes 00:23:57
Y entonces 00:24:03
Si yo tuviera que crear una estructura 00:24:04
Como esta, estas serían 00:24:07
Claramente como son public 00:24:09
Cada una en su 00:24:10
Fichero 00:24:13
Esto en persona.java tendría esta definición 00:24:14
Aquí, en alumno.java 00:24:17
Esta definición aquí, etc 00:24:19
Esta es un poquito la idea 00:24:20
¿Vale? 00:24:30
Cuando yo tengo una clase alumno 00:24:32
Sería la 00:24:34
La estructura externa 00:24:35
Tengo todos 00:24:37
Los atributos, tanto de persona como alumno 00:24:39
Como los métodos de persona y de alumno 00:24:43
¿Vale? 00:24:45
En teoría es como si 00:24:47
El objeto de la subclase 00:24:49
Encrustara dentro un objeto 00:24:52
De la superclase 00:24:55
y veremos ahora cuando veremos 00:24:56
los constructores 00:25:00
cuando yo me creo un objeto alumno 00:25:02
antes me estoy creando 00:25:05
un objeto persona 00:25:07
y antes me estoy creando 00:25:07
un objeto object 00:25:09
¿sí? 00:25:12
¿dudas? 00:25:15
por eso un alumno puede tener 00:25:16
acceso a los nombres, apellidos, al año de nacimiento 00:25:18
a imprimir y además 00:25:21
a las cosas suyas, mientras una persona 00:25:22
sólo tendría acceso a estas cosas aquí. Duda. Te he contestado. Más dudas. Ejemplo. ¿Os acordáis los 00:25:24
modificadores que eran public, protected, package y private? Y nosotros decimos, bueno, protected no 00:25:42
sabemos qué es porque no lo entenderemos hasta que veremos las la herencia pues ahora ya hemos 00:25:54
visto la herencia según que es que es protected pues si os acordáis public esta clase o este 00:26:02
método esta variable es accesible desde cualquier lado no me importa private sólo desde dentro la 00:26:08
clase package sólo desde dentro la clase u otras clases que parte que pertenecen al mismo 00:26:16
package? Pues con protected es a otras clases que pertenecen al mismo package o que hereden 00:26:23
de esta clase. Si yo tengo una clase que está en otro package, que pero extiende esta clase 00:26:32
de aquí, pues entonces puede acceder a sus métodos y a sus variables. Son cuatro niveles 00:26:40
de protección, de privacidad 00:26:48
que tiene. Desde lo más privado posible, que es sólo esta clase puede utilizar 00:26:53
estas cosas, hasta lo más amplio posible, que es 00:26:57
todos lo pueden utilizar. Y con esto puedo jugar. 00:27:00
No tiene acceso a esas variables. Pues tú puedes utilizar 00:27:05
los métodos públicos, que es lo que se suele hacer. 00:27:32
Cuando tú pones el private, no lo pienses con herencia. 00:27:36
Cuando nosotros poníamos el sueldo de mi cuenta es private, pero luego el sacar dinero, meter dinero, pues lo ponías como público. Lo que tú querías es que la gente no atacara directamente la variable, 00:27:39
va a pasar por un método en el que tú haces los controlos necesarios para evitar que él saque 100 00:27:54
euros cuando tienen sólo 50 en el banco o sea que el método es público entonces tú heredas eso la 00:28:00
private te dice que no puedes acceder a la variable directamente pero puedes seguir utilizando los 00:28:06
métodos que tú tienes si tú la tienes protected como has heredado podrás acceder cosa que a lo 00:28:11
mejor una otra clase desde fuera del package no puede atacar porque es protect entonces eso luego 00:28:17
Luego, para los ejercicios que hacemos nosotros no valen mucho, pero luego en un programa más complejo donde la seguridad empieza a ser interesante, saber limitar el acceso a métodos o cosas así, o de todas formas hacer que el acceso sea controlado porque tú accedes desde un método particular y no del método que te da la gana. 00:28:24
Pero luego tú tengas métodos de apoyo 00:28:45
Que sí que utilizas dentro 00:28:48
Asumiendo que todo funciona bien 00:28:49
Porque lo has hecho tú dentro del package 00:28:51
No sé si me explico, pues eso lo puedes hacer 00:28:53
Entonces con eso tienes los varios niveles 00:28:55
De seguridad 00:28:58
No me sale 00:29:00
Visibilidad 00:29:02
¿Sí? Vale, entonces aquí 00:29:04
Tenemos una clase protected, vale 00:29:07
Tenemos public persona 00:29:09
Con nombres igual a 00:29:11
Anónimo, vale, public persona 00:29:13
que son dos constructores 00:29:15
vale, uno es sin nada, es constructor 00:29:18
por defecto, entonces me pone solo que el nombre 00:29:20
anónimo y no me pone nada en este de aquí 00:29:22
me pondrá null y me pondrá 00:29:24
cero aquí, y si no persona 00:29:26
con tres datos que accede 00:29:28
a ellos de ahí, vale 00:29:29
entonces public 00:29:31
void imprime que accederá 00:29:34
a estas cosas, el acceso 00:29:36
a los constructores y 00:29:37
al método 00:29:40
imprime es público, todo lo pueden 00:29:42
hacer, pero si quiero modificar estas 00:29:44
cosas, la puedo modificar solo desde el mismo 00:29:45
package, clase del mismo package 00:29:48
o clases que hereden 00:29:49
esta persona, vale, esto es 00:29:51
un poco, en cierto sentido 00:29:54
como meterlo privado, pero 00:29:55
permito a quien 00:29:57
estenda persona de poder 00:29:58
trabajar con estas variables 00:30:01
vale 00:30:03
en este contexto 00:30:08
vale, de protect 00:30:11
de cosas así 00:30:12
ahora veremos por qué 00:30:13
a la pregunta que has hecho tú. Existe una palabra reservada, que se usa en dos contextos 00:30:16
distintos, esto es para constructores o métodos, que es la palabra super. Super es algo parecido 00:30:25
al concepto de dis. ¿Os acordáis dis? ¿Qué era dis? Estoy hablando de una instancia, 00:30:33
pero sin saber cuál es la instancia. Es esta instancia. ¿Por qué? Porque estoy definiendo 00:30:45
una clase, todavía no tengo un objeto 00:30:50
creado, es la clase en general 00:30:52
pero tengo que decir que cuando tú tendrás 00:30:54
un objeto, pilla ese objeto 00:30:56
y haz algo con él, pero como no 00:30:58
tengo una referencia, no es x, no es 00:31:00
new objeto, porque todavía no lo tengo 00:31:02
pues entonces lo llamo this 00:31:04
pues super es algo parecido 00:31:06
pero se refiere no a mi 00:31:08
sino a mi super clase 00:31:10
es una referencia 00:31:12
a la clase de la que yo heredo 00:31:14
¿sí? 00:31:16
Ahora, superasís normalmente se suele utilizar en términos de constructor, ¿vale? 00:31:19
Y también de método, eso lo veremos después 00:31:28
Si vosotros miráis este es alumno que extiende persona, ¿vale? 00:31:30
Como alumno extiende persona, tiene su grupo y su horario, que son cosas propias de alumno 00:31:34
Pero tendrá también nombre, apellido y año de nacimiento, porque lo derivan desde persona, ¿sí? 00:31:41
Ahora, cuando yo creo un alumno vacío 00:31:47
Que no sé nada de él 00:31:51
Lo que quiero hacer es crear una persona 00:31:53
O sea, un alumno con nombre anónimo 00:31:57
Entonces, lo que estoy haciendo aquí, con esta línea de aquí 00:32:00
Es, vale, cuando creas un alumno 00:32:04
Llama al constructor de la superclase sin parámetros 00:32:07
Es decir, esto 00:32:13
Entonces, cuando yo estoy llamando alumno así, lo que hará él es llamar primero al constructor sin parámetros de arriba, porque lo estoy llamando aquí, a esto. 00:32:17
Entonces me pondrá, me creará todo lo que es una persona con sus atributos, me creará la parte esta aquí gris, ¿vale? 00:32:34
Poniendo en nombre anónimo, y aquí datos por defecto porque no los tengo. 00:32:42
Y después seguirá con este constructor 00:32:47
Y como este constructor no tiene nada 00:32:51
Lo dejará ahí, así 00:32:53
Entonces este constructor de aquí 00:32:54
La parte debajo del super 00:32:56
Crearía la parte blanca 00:32:57
Que pero como es un constructor por defecto 00:32:59
No hace nada 00:33:02
Pondría dentro group null 00:33:02
Y dentro echar 00:33:04
No sé qué carácter 00:33:05
Un carácter 00:33:07
Nulo 00:33:07
¿Están de acuerdo? 00:33:09
Vale 00:33:13
Fijaos en esto 00:33:13
A ver, pero alumno es una persona 00:33:15
Entonces, cuando yo creo un alumno 00:33:24
Antes de crear un alumno, tengo que crear una persona 00:33:27
Porque un alumno es una persona 00:33:30
Entonces, si no tengo una persona, no puedo crear un alumno 00:33:32
Entonces, esta cosa de aquí 00:33:34
Te está diciendo, vale, para crear un alumno 00:33:37
Porque este es el constructor del alumno 00:33:40
Haz, llama el constructor de mi clase padre 00:33:42
¿Vale? 00:33:47
Y como aquí no tiene parámetros, el que no tiene parámetros 00:33:48
Es decir, esto 00:33:51
Entonces, este de aquí 00:33:52
Lo que hará 00:33:57
Es construir la parte gris 00:33:59
El corazón 00:34:01
La parte que es persona 00:34:03
Y que pondrá en nombre 00:34:05
Anónimo, porque lo pone aquí 00:34:07
Y como en los demás no te hace nada 00:34:09
Pues pondrá en apellidos null 00:34:11
Y en año de nacimiento, cero 00:34:13
Y ahora he creado esta parte aquí 00:34:14
Pero no he creado un alumno 00:34:17
He creado solo la parte persona 00:34:18
Volvería aquí y seguiría con este 00:34:20
Constructor, que pero como no hace nada 00:34:24
Pondrá dentro de grupo 00:34:26
Y de horario valores por defectos 00:34:28
Y ya está, ya tengo mi alumno con la parte 00:34:30
Dentro y la parte fuera creada 00:34:32
¿Vale? Déjame explicar el próximo 00:34:33
Que a lo mejor es más claro 00:34:36
O sea, se clarifica algo 00:34:38
Pongamos un alumno, un constructor 00:34:39
De alumno que pilla solo nombre, apellido 00:34:42
Y no nacimiento 00:34:44
Pero no pilla ni grupo ni horario 00:34:45
¿Vale? Entonces yo lo que puedo 00:34:48
Hacer es, vale, muy bien, vete a 00:34:50
Llamar super de nombre, apellido y año nacimiento. 00:34:52
O sea, estoy buscando un constructor de mi clase superior que tenga estos tres parámetros, string, string, int. 00:34:59
Y voy a mirar y efectivamente tengo un constructor string, string, int. 00:35:13
Entonces, esta vez no estaré usando esto, estaré usando esto. 00:35:17
Y como hemos dicho que soy una persona, primero creo una persona y luego crearé la parte de alumno. 00:35:21
Y en la parte de persona pondré nombre dentro de nombre, apellido dentro de apellido, 00:35:27
y como luego no tengo nada más, pues la parte de alumno se quedará como vacía. 00:35:31
Se quedará con valores por defecto. 00:35:37
Esto es crear un alumno, pero sin saber las características de alumno. 00:35:41
Y luego finalmente tengo el constructor propio de alumno de verdad 00:35:45
Que sería alumno con nombre, apellido, año de nacimiento, su grupo y su horario 00:35:51
Entonces, ¿qué hará esto? 00:35:57
Pues primero construir una persona 00:36:01
Y para hacer una construcción de una persona, llamará el constructor super 00:36:03
Con los parámetros necesarios a crear una persona 00:36:07
Esto creará la parte gris 00:36:10
y después seguirá llamando, por ejemplo, este método que es ponGrupo al que le paso este grupo y este horario 00:36:12
y si os fijáis, ponGrupo lo que hace es rellenar dis.grupo y dis.horario, comprobando que el grupo no sea nulo. 00:36:24
Es un ejemplo. ¿Se entiende? 00:36:34
Entonces, si ahora aquí tengo tres constructores de alumnos, puedo hacer un alumno anónimo, 00:36:38
Puedo hacer un alumno que sepa los datos de personas, pero todavía no sepa su grupo y su horario, o puedo crear un alumno que sepa todo. Y lo que voy a hacer es usar los constructores ya existentes de la persona. 00:36:42
de la persona 00:36:58
ahora, la pregunta es 00:36:59
centrémonos en esto 00:37:02
¿no podría haber hecho esto? 00:37:04
es decir, ver que public 00:37:08
alumno con estos datos son los mismos 00:37:10
en vez de llamar super 00:37:12
bla bla bla, hacer que dis.nombre 00:37:14
es igual a nombre, dis.apellida es igual a 00:37:16
apellida, dis.nacimiento es igual a nacimiento 00:37:18
¿funcionaría? 00:37:20
funcionaría, sí 00:37:25
lo podría hacer perfectamente 00:37:29
en este caso 00:37:31
o sea que esto 00:37:33
O esto 00:37:35
Son idénticos en este caso 00:37:36
¿Vale? 00:37:39
Se suele usar esto 00:37:41
¿Por qué? 00:37:43
Primero porque es más 00:37:45
Más 00:37:46
¿Cómo se dice? 00:37:49
Conciso 00:37:50
Pero por otro lado 00:37:51
Tiene también otra razón 00:37:55
Que viene más adelante 00:37:57
¿Dónde viene? 00:37:58
Más adelante 00:37:59
Entonces la veremos más adelante 00:38:00
¿Vale? 00:38:02
Pero pasa por 00:38:02
Si yo esto lo meto private 00:38:04
Esta cosa de aquí ya no funcionaría 00:38:07
Entonces no podría crear la persona con los datos que le he pasado 00:38:11
Sin embargo, si uso super 00:38:15
Como el constructor sí es público 00:38:17
Sí lo puede hacer, en parte 00:38:21
No lo hemos visto todavía porque viene más adelante 00:38:30
Por algún lado viene esta cosa explicada 00:38:32
Pero, de algún modo es esto 00:38:34
Si tú aquí le pones privado 00:38:36
Entonces desde la subclase no puede acceder 00:38:39
Entonces, ¿qué hago? Pues uso cosas como esta. Por ejemplo, accediendo al super, pues entonces sí puede acceder porque super sí es accesible. El constructor. Fijaos que por ahora super aquí lo hemos usado solo como constructor. Tenemos dos otras formas de usar super, que es como referencia para acceder a sus variables o como método. Y lo veremos ahora en la próxima transparencia. 00:38:41
dudas hasta aquí 00:39:07
porque no estoy accediendo a la variable 00:39:08
estoy accediendo al constructor 00:39:16
y si tú querías hacer alguna protección o cosa por el estilo 00:39:17
has metido aquí la protección 00:39:21
no me está 00:39:22
permitiendo de acceder a año nacimiento 00:39:24
y poner menos 7 00:39:27
porque tú dentro de este constructor 00:39:28
habrás comprobado que año nacimiento 00:39:30
no puede ser negativo y que por lo tanto 00:39:32
no me meterá nunca menos 7 00:39:34
luego no lo has hecho pues el problema es tuyo 00:39:36
Prueba 00:39:43
Vamos a ver 00:39:47
Esta es una clase prueba 00:39:50
Tiene un main 00:39:51
Persona vecina es igual a new persona 00:39:53
Con estos datos 00:39:56
Alumno, un alumno es igual a new alumno 00:39:57
Con estos datos 00:40:00
Un alumno.pongrupo le pasa dos cosas 00:40:01
Os recuerdo pongrupo es esto 00:40:04
Vale, entonces 00:40:06
Aquí en vez de utilizar este constructor 00:40:07
He usado este constructor y luego he rellenado 00:40:09
Estos dos utilizando su método 00:40:12
aquí 00:40:14
si ahora llamo 00:40:15
vecina.imprime 00:40:17
imprime es esto 00:40:19
es un método de clase persona 00:40:21
y lo que hace es decir 00:40:24
datos personales y luego pone su nombre 00:40:26
su apellido y su año de nacimiento 00:40:28
pues si yo llamo 00:40:30
vecina.imprime 00:40:32
lo que obtendré es 00:40:34
datos personales 00:40:36
Luis Asenjo Martínez 00:40:37
si ahora 00:40:39
hallamos un alumno.imprime, oye, en alumno no está imprime. Está imprime grupo, pero 00:40:43
no está imprime. Pero como extende persona, está importando, está copiando este de aquí. 00:40:51
Y entonces usará el imprime definido en persona, que fijaos, usa solo nombre, apellido 00:40:58
y año nacimiento, que son los datos que están en persona y que también alumno tiene. Por 00:41:06
Por lo tanto, el alumno podrá escribir datos personales Juan Ugarte López, 1985. 00:41:12
¿Sí? Exactamente como el otro. 00:41:20
Y luego dice, un alumno, punto, imprime grupo. 00:41:21
Es decir, sobre un alumno utiliza este método de aquí, que escribe el grupo y el horario. 00:41:25
¿Sí? 00:41:33
Y lo puede hacer porque el alumno está definido en primer grupo. 00:41:33
¿Podría hacer vecina punto en primer grupo? 00:41:39
¿Cuánto atrás? 00:41:50
¿Y podría hacer vecina punto en primer grupo? 00:42:00
No, ¿por qué no? 00:42:03
Porque alumno es una persona 00:42:06
Pero persona no es un alumno 00:42:10
Con el alumno puedo usar todo lo que está en persona 00:42:13
Pero en persona no puedo usar las cosas que están en alumno 00:42:17
¿Se entiende? 00:42:21
¿Dudas? 00:42:23
Vale 00:42:28
¿Qué pasaría si el atributo 00:42:28
Ah, sí, está aquí, que es lo que decía antes 00:42:30
Que el atributo nombre fuera privado, declarado private 00:42:32
Si yo aquí 00:42:35
El nombre lo pongo 00:42:36
Como private 00:42:38
Nombre 00:42:40
Si hiciera esto 00:42:41
De aquí, de alumno 00:42:44
Esto es el constructor de alumno 00:42:46
Y hago dis.nombres igual a nombre 00:42:48
Dis.apellidos, apellidos, etc, etc 00:42:50
Cuando hago esto 00:42:52
Se enfada 00:42:53
Me dice, tú no puedes acceder al nombre 00:42:55
Porque el nombre lo has declarado en persona 00:42:58
Y es privado 00:43:02
Entonces se puede usar solo dentro de persona 00:43:03
Solo dentro de esta clase 00:43:06
Sin embargo, si yo lo uso con super nombre, apellido 00:43:08
Yo no estoy accediendo a la variable nombre 00:43:13
Yo estoy usando el constructor de persona 00:43:16
Y el constructor de persona es público 00:43:20
Puede acceder tranquilamente a él 00:43:22
Y será él desde dentro de persona 00:43:24
Que accede al nombre 00:43:26
Entonces sí lo puede hacer 00:43:27
No accede directamente al campo privado 00:43:29
Si no llamo al constructor de la superclase 00:43:39
Que podría incluir controles adicionales 00:43:41
Sobre el campo que se ha declarado private 00:43:43
Y podría preguntarme 00:43:45
Que no sea null 00:43:47
Que sea al menos un carácter 00:43:49
Que no sé qué, no sé cuánto 00:43:51
¿Dudas? 00:43:52
Vale, vamos a darnos una pausa 00:43:59
Sobre la teoría 00:44:01
Y intentamos crear esta estructura de aquí 00:44:03
Vamos a crear una clase dispositivo 00:44:07
Que tenga dos otras clases 00:44:12
Que son la clase móvil y la clase ordenador 00:44:15
Las dos que hereden desde dispositivo 00:44:17
Tened en cuenta que aquí hay algunos metodillos 00:44:20
Como por ejemplo el método enciende 00:44:24
Que escribirá el dispositivo está encendido 00:44:25
Y que probablemente se terá el encendido a true 00:44:28
Apaga, apaga el dispositivo 00:44:32
Estado que dice el número serial 00:44:35
O sea, este dispositivo está encendido 00:44:37
O apagado, dependiendo de si 00:44:39
Está encendido o apagado 00:44:41
El móvil 00:44:42
Además que todo lo que hace un dispositivo 00:44:45
Añade su número 00:44:47
Número de teléfono 00:44:49
Y tiene estado móvil 00:44:50
Que fijaos 00:44:54
Es parecido a estado, solo que estado móvil 00:44:54
Lo que hace, te dice que 00:44:57
El móvil con número no sé qué 00:44:59
Y número serial no sé cuánto 00:45:01
Está encendido o apagado 00:45:02
Es una especificación de ese estado 00:45:04
Y aquí también estará ordenador 00:45:06
Que tiene un IP 00:45:08
Y dice estado del ordenador 00:45:09
Que dirá, escribe el móvil 00:45:11
No, el móvil no, será el ordenador 00:45:13
Con IP, IP 00:45:15
Y número serial está encendido o apagado 00:45:16
¿Lo hacéis vosotros? 00:45:18
¿No queréis que lo haga yo? 00:45:22
Haced vosotros 00:45:26
Haced vosotros 00:45:27
Venga haciéndolo vosotros 00:45:29
¿Cuánto tardáis en hacer esto? 00:45:32
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:
10
Fecha:
13 de enero de 2025 - 14:26
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
45′ 38″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
115.49 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid