Saltar navegación

Teoría Herencia parte1 - Contenido educativo

Ajuste de pantalla

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

Subido el 24 de enero de 2023 por Stefano C.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, este vídeo es una grabación, por lo tanto si decidís de hablar, automáticamente me dais el consentimiento a que se grabe vuestra voz, ¿vale? 00:00:00
Hoy vamos a hablar de un tema nuevo que es la herencia, ¿vale? 00:00:11
Entonces, ¿qué es la herencia así en plan definición básica? 00:00:16
Pues es un mecanismo para la reutilización de software, ¿vale? 00:00:24
La idea es que una de las cosas importantes cuando yo voy a trabajar y a desarrollar aplicaciones y cosas por el estilo 00:00:28
es que mi código debería ser reutilizable, ¿vale? 00:00:37
Muchas veces en un proyecto o en un proyecto nuevo, las cosas que necesito, 00:00:44
Algunas clases, algunas herramientas que me permiten conectarme a otro sistema 00:00:50
A una base de datos o cosas por el estilo 00:00:57
Ya están desarrolladas anteriormente 00:00:59
Y muchas veces no necesito volver a reinventar la rueda 00:01:04
Para decir, mira, voy a crear otra vez la conexión a la base de datos 00:01:08
Porque tengo ya una clase que hace los métodos que necesito 00:01:13
Pero lo hago otra vez 00:01:16
Hay momentos en el desarrollo de un sistema en que esto puede ser necesario o útil 00:01:17
Si hay una clase que se usa ya desde 20 años 00:01:22
Que usa un Java antiguo y que funcionaba hace 20 años y hasta ahora ha funcionado 00:01:26
Y ahora me viene un momento en que la necesidad me dice 00:01:32
Mira, esta clase hay que rehacerla nueva para que sea más eficiente 00:01:34
Y cosas por el estilo, pues se rehace desde cero 00:01:37
Fenomenal 00:01:39
Pero en general la idea es que yo pueda utilizar componentes o módulos o clases o paquetes de otros proyectos 00:01:40
Si es que esos me sirven para el proyecto nuevo que estoy haciendo 00:01:50
Y esto todo es como idea general de utilización de software, de coding 00:01:53
Pues la herencia es un mecanismo que me permite eso 00:01:59
Es un mecanismo que me permite estructurar de forma más organizada lo que es mi código 00:02:04
Para que yo luego pueda heredar, pueda pillar el código ya creado y reutilizarlo fácilmente 00:02:13
Permite sostancialmente definir una clase a partir de otras clases reutilizando su código 00:02:22
Un ejemplo básico para entender de lo que estamos haciendo es este de aquí 00:02:30
Imaginaos que yo tenga una clase Persona 00:02:36
La clase Persona tiene un string nombre y un ente edad 00:02:39
Y cualquier persona tiene estos datos 00:02:42
A mí me interesa en mi sistema el nombre de las personas y la edad de la persona 00:02:46
A partir de aquí mi sistema me pide, por ejemplo, que cree una clase Profesor 00:02:50
Ahora, el profesor es una persona 00:02:57
La clase profesor debería tener nombre, debería tener edad 00:03:00
Y además algo más que estas informaciones para que haga algo más 00:03:05
Que puede ser un método más, puede ser un atributo más 00:03:11
Por ejemplo, me interesa un array de string que me diga las asignaturas que imparte este profesor 00:03:14
La idea es que si yo no tuviera este nuevo mecanismo que ahora vamos a ver 00:03:21
Pues debería crear una nueva clase profesor 00:03:26
Donde vuelva a escribir que tiene string nombre 00:03:30
Tiene int edad 00:03:33
Y además tiene string asignatura impartida 00:03:34
La idea es que evite esto 00:03:38
Y simplemente le diga a la clase profesor 00:03:41
Oye, mira profesor 00:03:43
Tú, en algún modo, heredas 00:03:44
Tienes una relación con persona 00:03:48
Tú, profesor, eres una persona 00:03:51
Por lo tanto tendrás todo lo que tiene persona 00:03:55
Y además de eso, algo más que hace que tú seas un profesor 00:03:57
Y yo luego con un profesor puedo pedirle su nombre, puedo pedirle su edad 00:04:02
Y además puedo pedirle esa cosa extra 00:04:07
O por ejemplo, puedo crear un estudiante 00:04:10
Y también el estudiante es una persona 00:04:14
Entonces yo pondré que también estudiante es hereda de persona 00:04:18
Y además de todo lo que tenga persona, pues le añado sus notas 00:04:23
Por ejemplo, una red de int que son sus notas 00:04:28
Entonces aquí yo tengo tres clases, ¿vale? 00:04:31
Que se relacionan entre ellos 00:04:34
Yo puedo crear una persona cualquiera que no es ni profesor ni estudiante 00:04:35
Tendrá solo nombre y edad 00:04:39
O puedo crear un profesor que tendrá todo lo que es la persona más lo propio del profesor 00:04:41
O crear un estudiante que tendrá todo lo que es una persona más las notas 00:04:47
La cosa interesante es que antes, en una situación como esta, entre personas, profesores, estudiantes, repitiendo todo, si yo quería hacer un cambio en, por ejemplo, cómo se maneja el nombre o la edad de las personas, tenía por triplicado este código. 00:04:53
Que tenía que ir en tres clases distintas a cambiar, a modificar, a actualizar el código que tenía 00:05:10
En vez de ahora, en cierto sentido, tengo el código una sola vez en persona 00:05:18
Y las otras dos clases heredan de esta persona 00:05:24
Si yo hago un cambio en cómo se gestiona el nombre, la edad o los atributos que tiene una persona 00:05:28
Automáticamente las otras clases que heredan de ellas adquirirán estos cambios 00:05:34
¿Cuándo y para qué se usa la herencia? 00:05:40
Hay dos escenarios posibles en que la herencia nos viene muy bien 00:05:51
Uno es el caso de especialización 00:05:56
Por ejemplo, la clase coche como especialización de vehículo 00:05:58
Esto es en el caso en el que yo quiero desarrollar una nueva clase 00:06:02
Una clase extra en mi sistema 00:06:07
Y que esta clase se parece mucho a otra clase ya existente 00:06:09
Que buena parte del código de esta clase nueva ya está en otra clase 00:06:14
Entonces, que ya existe 00:06:20
Entonces, en vez de estar a escribir otra vez el mismo código 00:06:22
Y a duplicar el código, que si luego me doy cuenta que hay un error 00:06:27
Lo tengo que cambiar en 2, 3, 4, 50 clases 00:06:31
Pues lo que hago es extender la clase que ya existe 00:06:34
Pues en este caso existe ya vehículo 00:06:39
Y yo extendo la clase vehículo con coche, que es un vehículo, por lo tanto tendrá todo lo que tiene este vehículo, y además algo más, una característica o un método o las dos cosas adicionales para especificar cuál es la diferencia entre un coche y un vehículo. 00:06:41
Entonces, la solución de un escenario como ese en el que ya tengo una clase y quiero crear una clase nueva 00:06:59
Que esta clase nueva comparte muchísimo de la clase anterior, pero extiende en algo 00:07:09
Es crear una subclase, o clase liga o clase derivada, ¿vale? Así sea 00:07:14
¿Qué es? Creo esta clase nueva, hago que se refiera a la clase anterior 00:07:19
Pilla todo lo que había en común con la clase anterior y es como si lo duplicara 00:07:24
Y además añado el específico de esta nueva clase 00:07:29
La segunda opción en que la herencia es útil es el proceso al revés 00:07:32
Es la generalización, ¿vale? 00:07:38
O sea, crear la clase vehículo como generalización de coche, moto, patinete y bicicleta 00:07:41
Esto pasa cuando como escenario tenemos un conjunto de muchas clases 00:07:48
Y nos damos cuenta que en estas clases de mi sistema hay algo en común 00:07:54
Hay muchos elementos que son parecidos 00:08:02
Si pensáis, por ejemplo, yo tuviera la clase coche, la clase moto y la clase patinete 00:08:07
Pues a lo mejor todos tienen, qué sé yo, número de ruedas, tienen velocidad máxima 00:08:14
tienen algunos atributos y métodos, o moverse como método y cosas por el estilo, que se parecen mucho. 00:08:19
Entonces puede llegar un momento en que digo, vale, en vez de tener este código muy parecido, 00:08:28
por triplicado, cuadruplicado y cosas por el estilo en varias clases, la parte común de todas estas la pongo en una clase única, 00:08:34
que es una clase que generaliza el concepto que estoy modelizando. 00:08:44
para luego dejar las clases que tenía ahora como hijas, como clases que heredan, como subclases de esta clase generalizada, 00:08:49
poniendo solo en cada uno la parte distinta con respecto a todos los demás. 00:08:59
Entonces, la herencia normalmente se piensa desde arriba hasta abajo, o sea, yo tengo ya una clase hecha y creo una clase hija que extende, 00:09:08
añade algo a la clase 00:09:17
que existía. Pero si yo estoy 00:09:20
haciendo una realización o 00:09:22
llego en una empresa nueva o 00:09:23
un proyecto viejo o 00:09:25
un sistema que ya 00:09:27
está construido, pues puede ser útil 00:09:30
hacer un análisis y ver si 00:09:32
alguna de las clases que ya existen en realidad 00:09:34
comparten mucho código y este 00:09:36
código se puede agrupar 00:09:38
en una única clase, mejorando 00:09:40
mucho lo que es 00:09:42
la mantenibilidad 00:09:44
De este sistema 00:09:46
¿Vale? 00:09:47
Porque ahora no tengo que ir en 7 puntos distintos 00:09:47
Cada vez que quiero hacer un cambio 00:09:50
Los tengo todos centralizados en una clase 00:09:51
Que luego se hereda en la otra 00:09:53
Vale 00:09:55
Este es un ejemplo más 00:10:00
Directo, entre comillas 00:10:02
Para entender de qué estamos hablando 00:10:05
No sé si se ve bien 00:10:07
Vamos a ver 00:10:08
La situación sin herencia 00:10:11
¿Vale? 00:10:14
Entonces, imaginémonos que estamos en una situación parecida a esta 00:10:15
Nosotros tenemos tres clases 00:10:18
Tenemos la clase recurso, que es un recurso genérico 00:10:20
Y luego tenemos la clase aula y la clase ordenador 00:10:23
Que son recursos de mi escuela, por ejemplo 00:10:26
¿Vale? 00:10:29
Entonces, recurso tiene un nombre, una descripción 00:10:30
Un método que es tu nombre, de qué recurso eres 00:10:33
Y decir descripción, ¿vale? 00:10:38
Es exactamente un osguete 00:10:40
¿Vale? 00:10:41
Vale, fenomenal 00:10:43
Cuando voy al aula 00:10:43
El aula es un recurso también en general, ¿vale? 00:10:45
Pero que tiene su nombre, su descripción, su decir nombre, su decir descripción 00:10:49
Y además tiene localización y decir localización, ¿vale? 00:10:53
Aquí si yo veo, la parte en azul es sustancialmente código redundante 00:10:58
Código que ya existía antes y que he vuelto a escribir en esta clase aquí 00:11:04
Y que será muy parecido 00:11:08
Pero tiene también la parte negra, digamos, que es la parte nueva 00:11:10
Son cosas que un recurso genérico no puede decir 00:11:14
Mientras que un aula sí 00:11:18
Lo mismo pasa con el ordenador 00:11:19
El ordenador tiene nombre, descripción y los métodos relacionados 00:11:21
Que igualmente, porque es un recurso y me sirve para identificar el ordenador 00:11:24
Pero también tiene el sistema operativo que tiene instalado 00:11:30
Entonces, en una situación como esta 00:11:32
La herencia me sirve 00:11:35
Porque lo que puedo hacer es pasar a esto 00:11:39
Es decir, crear a este punto una clase padre o superclase 00:11:42
O clase... no sé, hay varios nombres, ahora lo veremos 00:11:51
Que está por arriba, digamos, de recursos 00:11:55
Es una clase generalizada, es una idea general de recursos 00:11:58
Todos los recursos están hechos así 00:12:02
Hemos visto que tanto aula como ordenador tenía estas cosas 00:12:03
Por lo tanto, un recurso genérico tiene que tener un nombre, una descripción 00:12:07
Decir su nombre, decir su descripción 00:12:10
Y luego hago que aula y ordenador hereden de esta clase de cursos 00:12:12
Entonces este concepto de herencia que estamos viendo hasta ahora 00:12:20
Lo que está haciendo es como si el código de recurso lo copiara dentro de aula 00:12:24
Y luego añadiera lo extra 00:12:30
Pero en realidad no lo está haciendo 00:12:33
Esto es una cosa interesante porque si mañana 00:12:36
Quiero añadir algo a un recurso genérico 00:12:40
O quiero modificar, por ejemplo, decir nombre, decir descripción 00:12:42
Para que haga algo distinto y haga algo más formal 00:12:46
O resolver un error o encontrar un algoritmo que hace algo de forma más eficiente 00:12:50
Lo tengo que cambiar solo en recurso 00:12:55
No en todas las clases que antes tenían estos datos 00:12:57
Y automáticamente, como todas las otras clases se heredan de esto 00:13:01
Los opinios 00:13:05
Dudas 00:13:07
En general, cuando se habla de una cosa así de herencia 00:13:09
Se dice que la clase debajo, esta clase hija 00:13:20
Extiende o hereda la otra 00:13:23
Hereda en referencia a la herencia, el concepto de herencia 00:13:26
Que es inheritance en inglés, creo 00:13:32
Y extiende porque veremos que la palabra que se utiliza 00:13:34
Para, digamos, relacionar las dos clases es extends 00:13:39
En un cierto sentido es como si pillara esta clase 00:13:43
Y la extendo con más información 00:13:46
¿Dudas? 00:13:50
Esto es nomenclatura, ¿vale? 00:13:53
Imaginémonos que tenga dos clases 00:13:56
La clase taxi y la clase vehículo 00:13:58
¿Vale? 00:14:02
Claramente vehículo será la clase que está arriba 00:14:03
Y hago una clase taxi a partir de este vehículo que es más genérico 00:14:05
Entonces, para indicar la relación entre estas dos clases 00:14:11
Puedo decir todas estas cosas 00:14:15
Es decir, que taxi hereda desde vehículo 00:14:17
O que taxi extiende vehículo 00:14:20
O que taxi es subclase de vehículo 00:14:23
O que taxi es clase derivada 00:14:26
O es clase hija 00:14:29
Todo esto es para decir que taxi 00:14:31
De alguna forma está relacionada con vehículo 00:14:33
Porque importa todo lo que está allí 00:14:36
Y añade algo más 00:14:38
Y al revés 00:14:40
Yo puedo decir que vehículo es superclase de taxi 00:14:42
O es clase base de taxi 00:14:46
O es clase padre de taxi 00:14:49
¿Vale? 00:14:51
Este es hija, este es padre 00:14:52
¿Sí? 00:14:53
Además, una cosa realmente interesante 00:14:55
Es que la herencia crea un vínculo 00:14:57
Una relación es un 00:15:01
En inglés, is a 00:15:04
¿En qué sentido? 00:15:06
Cuando yo digo que taxi hereda de vehículo 00:15:09
Estoy diciendo que, sustantivamente, taxi es un vehículo 00:15:12
La relación que tengo aquí 00:15:16
Esta que me une, por ejemplo, taxi con vehículo 00:15:20
Es que me está diciendo que taxi es un vehículo 00:15:24
Pero algo más 00:15:26
O aquí es autobús, es un vehículo 00:15:28
Pero algo más 00:15:31
El hecho que es un vehículo 00:15:32
Me está diciendo que hace todo lo que puede hacer un vehículo 00:15:35
Más algo más 00:15:38
¿Dudas? 00:15:41
Esto está relacionado también con una cosa que veremos dentro de un rato 00:15:46
Que es el operador instance of 00:15:49
Que me permite saber si un determinado objeto 00:15:51
Es un instante de una determinada clase 00:15:55
¿Vale? 00:15:57
Si yo hago un objeto taxi 00:15:58
¿Taxi es una instancia de la clase taxi? 00:16:02
¿Taxi es una instancia de la clase vehículo? 00:16:09
Porque taxi es un vehículo 00:16:12
Por lo tanto, también 00:16:16
Y esto me servía para saber 00:16:19
Qué puedo hacer con una clase o no 00:16:21
Si yo entiendo el taxi como vehículo 00:16:25
Podré hacer las cosas que hace un vehículo 00:16:28
Y si yo entiendo el taxi como un taxi 00:16:30
Podré hacer todo lo que hace un vehículo 00:16:33
Y algo más 00:16:34
¿Vale? 00:16:35
Está claro que si yo he declarado un objeto vehículo 00:16:36
Un objeto vehículo no puede hacer lo que hace taxi 00:16:38
Porque vehículo es una instancia de vehículo 00:16:40
Un objeto vehículo es una instancia de la clase vehículo 00:16:45
Pero un objeto vehículo no es una instancia de la clase taxi 00:16:48
Lo que tú quieras 00:16:52
Es que tú tienes que 00:17:00
Si tú estás hablando de taxi 00:17:02
Pues creará todos tus taxis 00:17:05
Sí, pero a un cierto momento 00:17:07
y tienes un vehículo extra que no es ni un taxi ni un autobús 00:17:08
y quieres simplemente tratarlo como vehículo genérico 00:17:12
porque en tu sistema solo los taxis y los autobús tienen un comportamiento extra 00:17:15
todos los otros vehículos son todos iguales 00:17:20
pues entonces lo crearás como vehículo 00:17:22
no es que tienes que 00:17:25
tú puedes hacer las tres, los tres son objetos 00:17:28
está claro que si yo creo un vehículo y luego le intento decir algo propio 00:17:33
De taxi, como por ejemplo 00:17:37
El getNumeroLicencia 00:17:40
El vehículo no tiene número de licencia 00:17:42
Es el taxi que tiene el número de licencia 00:17:44
Según lo que está escrito aquí 00:17:46
Cualquier vehículo le podré preguntar 00:17:48
GetMatricula 00:17:53
Pero solo los taxis tienen el número de licencia 00:17:54
Entonces, si yo creo un taxi 00:17:56
Le podré preguntar 00:17:59
Si hay el número de licencia 00:18:01
O tratarlo como si fuera un vehículo cualquiera 00:18:02
Y decirle, dame tu matrícula 00:18:04
Porque el taxi es un vehículo 00:18:06
Si creo un vehículo genérico 00:18:08
No le puedo la guayera a dir 00:18:11
Dame tu número de licencia 00:18:12
Porque tú no eres un subtaxi 00:18:13
A revés no va 00:18:15
¿Verdad? 00:18:16
Sintaxis de cómo creo una clase 00:18:23
Muy fácil 00:18:26
¿Vale? 00:18:26
Simplemente en Java 00:18:27
¿Vale? 00:18:28
Tengo mi clase 00:18:29
Public clase 00:18:30
Lo que sea 00:18:31
La clase hija 00:18:32
Extends 00:18:34
¿Vale? 00:18:35
Clase padre 00:18:36
¿Vale? 00:18:37
Estoy diciendo simplemente 00:18:38
Que la clase hija 00:18:39
Extende la clase padre 00:18:40
Esto sería taxi 00:18:43
Extends 00:18:44
Vehicle 00:18:45
Y a partir de aquí 00:18:48
Yo desarrollo mi clase 00:18:51
Normal y corriente de toda la vida 00:18:52
Pero aquí dentro 00:18:54
En automático es como si 00:18:57
Hubiese en un cierto sentido 00:18:59
Copiado la clase padre 00:19:01
Aquí arriba y luego desarrollo 00:19:03
El resto 00:19:05
Entonces, si la clase padre tiene matrícula 00:19:07
Pues aquí dentro, dentro de esta clase 00:19:13
Puede utilizar matrícula sin necesidad de declararla 00:19:16
Porque ya existe 00:19:19
Existe heredada desde la clase padre 00:19:20
¿Entienden? 00:19:23
Es como si fuera un atributo de la clase 00:19:27
¿Vale? 00:19:30
Esto siempre a nivel de declaración 00:19:31
Imaginaos una estructura de este tipo 00:19:34
Que hay una persona en general 00:19:36
La persona puede ser empleados o alumnos 00:19:38
Y los empleados pueden ser profesores 00:19:40
¿Vale? 00:19:43
Entonces a nivel de declaración 00:19:44
Sería una cosa de ese estilo 00:19:46
Tengo un public class persona por algún lado 00:19:47
Que me define la persona 00:19:49
Una clase alumno que estende persona 00:19:50
Y una clase empleado 00:19:54
Que estende persona 00:19:56
Y luego tengo una clase profesor 00:19:57
Que estende empleado 00:20:00
Entonces un profesor 00:20:01
Por ejemplo 00:20:04
Tendrá todo lo propio de un profesor 00:20:05
Todo lo propio de un empleado 00:20:07
Y todo lo propio de una persona 00:20:09
Un profesor es un empleado 00:20:11
Y el profesor también es una persona 00:20:16
¿Se entiende? 00:20:19
Preguntas 00:20:27
Vale 00:20:28
Siempre una clase en Java 00:20:31
Puede extender solo una clase 00:20:38
¿Vale? 00:20:40
Entonces no hay lo que se llama herencia múltiple 00:20:41
Hay lenguaje de programaciones que permite herencia múltiple 00:20:44
Como por ejemplo C++ 00:20:46
Pero en Java está limitado 00:20:48
Tú puedes extender una sola clase 00:20:51
Si tú tienes que extender dos clases 00:20:53
Tienes un problema 00:20:56
A ver cómo se hace 00:20:57
O haces en cadena 00:20:59
Esta extiende esta, esta extiende otra 00:21:01
O haces utilizando otro mecanismo 00:21:02
Que veremos más adelante 00:21:06
Que son las interfaces 00:21:07
¿Las dudas? 00:21:08
Vale, entonces este es un ejemplo de subclase 00:21:17
Por ejemplo la clase alumno 00:21:20
Esta sería toda la clase alumno que tiene sus atributos y métodos, ¿vale? 00:21:22
Y la clase alumno tiene sus propios atributos y sus propios métodos aquí debajo 00:21:26
Que son propios de la clase alumno, pero como hereda de la clase persona 00:21:30
Pues incluye la parte aquí de arriba que está heredada directamente desde persona 00:21:36
Entonces todos los atributos de persona y todos los métodos que tiene persona, ¿vale? 00:21:42
Estos métodos de aquí, la parte 00:21:48
Digamos, heredadas, no aparece en la clase 00:21:50
Lo que yo pongo en la clase alumno 00:21:53
Después de haberla declarada así 00:21:55
¿Vale? De public class está en persona 00:21:56
Es solo la parte de abajo 00:21:59
Porque la parte esta de aquí 00:22:01
Se da por hecho, se da como si 00:22:02
Existiera porque por algún lado 00:22:04
Tendrá que haber la clase persona 00:22:06
Donde hay el declarado 00:22:08
Y todo el código que permita ver 00:22:10
Lo que hace una persona 00:22:12
Entonces yo 00:22:13
En un main 00:22:16
Creando un alumno 00:22:18
Puedo pedir por ejemplo 00:22:19
El apellido del alumno 00:22:20
Y eso existe 00:22:22
Hasta si en el código del alumno mismo 00:22:23
En ningún lado he puesto string alumno 00:22:26
Porque ya existe dentro de eso 00:22:30
Pero allí ya 00:22:32
Es un poquito más complejo 00:22:41
Y vamos hacia otros temas 00:22:43
Como polimorfismo 00:22:45
Que todavía no sabemos muy bien 00:22:46
Pero sí, en principio sí 00:22:48
Como un alumno es una persona 00:22:50
Si yo tengo un array de personas 00:22:52
Puedo poner en un array de personas alumnos 00:22:53
Lo que 00:22:55
En un array de alumnos 00:22:58
No puedo poner personas 00:23:05
La alumna es una persona 00:23:07
Una persona no es un alumno 00:23:13
No tiene por qué ser un alumno 00:23:14
Si yo tengo un array de alumnos 00:23:16
Asumo que todos los objetos dentro de alumnos 00:23:18
Pueden hacer, por ejemplo 00:23:21
Imprime grupo 00:23:23
Sin embargo 00:23:24
Si yo le pongo una persona 00:23:26
Personas no tienen imprimir grupo 00:23:28
Entonces me diría, ¿qué es esto? 00:23:29
Claro 00:23:32
Tú dices que un alumno es una persona 00:23:33
Una persona no es un alumno 00:23:36
Puede no serlo 00:23:37
¿Sí? 00:23:39
Vale, vamos a ver un ejemplo 00:23:41
Con código 00:23:43
¿Vale? De esto, para ver 00:23:45
De qué estamos hablando 00:23:47
¿Vale? Aquí estamos creando la clase 00:23:49
Persona 00:23:51
Y aquí tengo 00:23:52
Por ejemplo 00:23:57
Unos atributos 00:23:59
Atributos nombre, apellido 00:24:02
Y año de nación 00:24:04
Fijaos 00:24:05
Que para este caso 00:24:07
Es puesto que los 00:24:09
Los atributos 00:24:11
Son protected 00:24:14
Nosotros hemos visto nada 00:24:15
Hemos visto public 00:24:17
Y hemos visto private 00:24:19
Este es otro 00:24:21
Modificador 00:24:23
Protected 00:24:26
Que sostancialmente me dice 00:24:27
Que estas cosas son visibles 00:24:28
O dentro de la clase 00:24:30
O dentro de 00:24:33
Clases que heredan 00:24:35
De esta clase 00:24:38
¿Vale? 00:24:38
Además que dentro del paquete 00:24:39
¿Vale? Entonces 00:24:41
Otras clases del paquete 00:24:42
Otra clase 00:24:44
Esta misma clase 00:24:45
Clases que heredan de esta 00:24:47
Si yo heredo desde esta clase 00:24:50
Como si nombre fuera mío 00:24:52
Y lo puedo utilizar 00:24:53
¿Sí? 00:24:54
Esto no lo vimos antes 00:24:56
Porque cuando lo vimos os lo nombré 00:24:58
Pero os dije, claro, hasta que no sepamos 00:25:00
Que es la herencia, esto no tiene sentido 00:25:02
Ahora que empezamos a entender 00:25:04
Que puede ser la herencia 00:25:06
Pues entonces eso tiene sentido 00:25:08
Sabemos que hay clases que estenden estas 00:25:09
Y yo puedo decirle aquí un private 00:25:11
Entonces una clase que me estende 00:25:13
No tiene acceso a estas cosas 00:25:16
O protected 00:25:18
Entonces una clase que me estende 00:25:19
Si tiene acceso directo a estas cosas 00:25:21
Aquí tengo un public persona 00:25:22
Public persona con nada 00:25:26
¿Vale? 00:25:29
Si yo creo una persona sin darle ningún tipo de parámetros 00:25:29
Me crea una persona que no tiene edad 00:25:34
No tiene apellidos 00:25:37
Y de nombre se llama anónimo 00:25:38
Esto sobre escribe el constructor por defecto 00:25:39
Y luego tenemos un constructor un poquito más complejo 00:25:46
Que es persona con 00:25:50
Dame nombre, dame apellido y dame edad 00:25:53
Y yo crearé una persona 00:25:55
Que como nombre tengo el nombre que me has dado 00:25:58
Como apellido tiene el apellido que me has dado 00:26:00
Y como año de nacimiento 00:26:02
El año de nacimiento que me has dado 00:26:03
Con esto torbático y todo 00:26:05
¿Dudas? 00:26:06
Y una persona puede hacer esto 00:26:11
Imprimir, ¿vale? 00:26:13
Cuando una persona se imprime 00:26:15
Ves que no es estático 00:26:17
Este método, por lo tanto 00:26:20
Se llama sobre un objeto 00:26:21
Y lo que hará es inscribir todos los datos personales 00:26:22
De esta 00:26:25
De esta persona 00:26:26
Pillando los valores 00:26:28
De la persona propia, ¿vale? 00:26:30
Entonces dice, nombre personal 00:26:32
Datos personales, el nombre 00:26:34
Seguido del apellido 00:26:36
Seguido del año de nacimiento 00:26:38
Los datos de esta persona 00:26:40
¿Dudas? 00:26:42
Hasta aquí 00:26:46
Poco más, ¿vale? 00:26:47
Estaríamos en esta parte de aquí en un cierto sentido 00:26:49
¿Vale? 00:26:52
Hemos definido la parte persona 00:26:52
Hemos definido todo lo que llega aquí 00:26:55
Ahora vamos a extender esta clase en la clase alumno 00:26:57
Es aquí la parte nueva 00:27:01
Esta es la clase alumno 00:27:04
Fijaos que la clase alumno extende persona 00:27:17
Entonces, este alumno es una persona 00:27:21
Este alumno puede hacer todo lo que hace una persona 00:27:24
Y tiene todos los datos de una persona 00:27:27
¿Vale? 00:27:29
Pero además tiene 00:27:31
Grupo 00:27:33
Y tiene horario 00:27:34
¿Vale? 00:27:36
Cosas que uno se me... 00:27:38
Primera cosa nueva 00:27:39
¿Qué es esto? 00:27:43
Tengo un constructor 00:27:52
Public alumno 00:27:53
Sin datos 00:27:54
¿Vale? 00:27:56
Y de allí, súper 00:27:58
¿Qué hará este súper? 00:27:59
¿Qué hará el constructor? 00:28:07
¿Qué sentir? 00:28:08
Lo que está haciendo este súper es 00:28:12
Llama el constructor de mi superclase 00:28:13
Con los parámetros que te pasan 00:28:18
Entonces, este señor 00:28:21
Cuando crea un alumno sin darle nada 00:28:23
¿Qué alumno creeré? 00:28:26
El nombre anónimo sin nada 00:28:29
Nombre anónimo 00:28:34
Y todo el resto con datos por defecto 00:28:35
Pero la idea es que 00:28:37
Aquí por ningún lado dice que su nombre es anónimo 00:28:41
Pero como esto 00:28:44
Está tirando de esto 00:28:46
¿Vale? 00:28:48
Super sin parámetros sería este constructor 00:28:51
Este constructor 00:28:54
Lo que me define es que su nombre es anónimo 00:28:55
Por lo tanto 00:28:58
Este código de aquí 00:28:59
Llama el constructor 00:29:00
Más arriba 00:29:02
Sin parámetros está llamando ese constructor de ahí 00:29:04
El nombre será anónimo 00:29:07
Todo el resto se deja vacío 00:29:08
O con valor por defecto 00:29:11
Nul o cero 00:29:13
O falso o lo que sea 00:29:15
¿Se entiende? 00:29:17
Entonces, esto es como 00:29:19
Desde la clase hija 00:29:20
Desde la subclase 00:29:23
Llamo a constructores 00:29:24
De la clase madre 00:29:27
De la superclase 00:29:29
¿Vale? Utilizando super 00:29:30
Tened en cuenta, ahora tanto lo repitiré 00:29:32
Pero que este super, si lo uso 00:29:35
Tiene que ser el primer 00:29:37
Comando del constructor 00:29:39
La idea es que yo 00:29:42
Si quiero crear un alumno 00:29:44
Antes creo la persona 00:29:45
Usando un constructor de la persona 00:29:47
Y a partir de allí construyo todo lo que es un alumno 00:29:49
Pero en un cierto sentido 00:29:52
No puedo construir un alumno 00:29:54
Sin construir una persona 00:29:56
Porque un alumno es una persona 00:29:57
¿Cutas? 00:29:58
Veamos un ejemplo 00:30:05
Una pizca más complejo 00:30:06
Si yo hago un alumno al que le paso 00:30:07
Nombre, apellido y año de nacimiento 00:30:10
Estos son justo los datos 00:30:12
Una persona 00:30:16
¿No? Pero nada más 00:30:19
Que esto 00:30:20
Esto debería ser 00:30:21
El constructor 00:30:23
¿Vale? 00:30:28
Dis.nombre, igual a nombre 00:30:29
Dis.apellidos, apellidos 00:30:31
Dis.nacimiento, nacimiento 00:30:33
Pregunta, pero nombre, apellido, nacimiento 00:30:34
En alumno nos parece 00:30:37
¿Cómo puedo hacer dis? 00:30:38
Porque esto es extendiendo 00:30:41
¿Vale? Y como lo desestendo 00:30:42
Pues accedería 00:30:45
Oye, pregunta, ¿pero esto lo puedo hacer siempre? 00:30:46
¿Puedo hacer siempre dis.nombre desde alumno? 00:30:49
Si está protected y no private 00:30:51
Si está protected o public o lo que sea 00:30:53
Si está private, por ejemplo, allá 00:30:56
Pues no 00:30:59
Esto me daría un error 00:31:00
Me diría, no, no estás en la clase correcta 00:31:01
Pero en vez de estar a reescribir otra vez 00:31:04
Un código que ya está en persona 00:31:10
Y cuidado, el constructor normalmente 00:31:13
Para nosotros son constructores sencillos 00:31:14
Pero podría ser 00:31:17
Que yo tenga que hacer comprobaciones 00:31:19
Sobre estos datos que me han dado 00:31:22
A lo mejor no me están dando directamente el nombre 00:31:23
Me están dando un código 00:31:25
Que yo lo tengo que ir a buscar en una base de datos 00:31:27
Y en esta base de datos encontraré una ficha 00:31:29
Donde está su nombre, de ahí lo pillo 00:31:32
¿Vale? 00:31:34
Entonces este código de aquí podría no ser trivial 00:31:35
No ser fácil como el que hacemos nosotros 00:31:38
Podría ser mucho código 00:31:40
Y yo no lo quiero volver a reescribir aquí 00:31:41
El mismo código de una clase que heredo 00:31:44
Que ya tengo 00:31:46
Y entonces 00:31:47
Hago esto 00:31:49
Super 00:31:52
Llamo 00:31:53
Al constructor 00:31:56
De la clase superclase 00:31:58
Pasándole 00:32:00
Los parámetros 00:32:02
Lo que hará 00:32:04
Java, Java Tutor Machine 00:32:06
Es ir a mirar la clase superior 00:32:08
La clase padre 00:32:11
Mirar si hay un constructor 00:32:12
Que pilla justo estos tipos 00:32:15
De atributos, de parámetros 00:32:17
Y si lo hay 00:32:19
Que si lo hay, es el segundo constructor 00:32:20
Pues usa ese constructor 00:32:22
Hace todo lo que tiene que hacer 00:32:24
Vuelve aquí 00:32:26
Y como se ha acabado el constructor, se ha acabado 00:32:28
El concepto de 00:32:30
Ahorrar 00:32:37
Reutilizar código 00:32:39
¿Vale? 00:32:42
No lo estoy reescribiendo aquí 00:32:43
Y si mañana me doy cuenta que un error lo tengo 00:32:45
Tanto en persona como en alumno 00:32:47
Como en todas las clases de alumno 00:32:49
Utilizo super 00:32:50
Si lo arreglo en persona 00:32:52
Automáticamente todos los que heredan y usan super 00:32:54
Pueden solucionar 00:32:57
Otra pregunta 00:32:58
Hemos dicho que aquí 00:33:01
Si nombre es privado 00:33:04
No funcionaría 00:33:08
Si nombre es protected o public 00:33:10
O lo que sea 00:33:13
Pues entonces sí funcionaría 00:33:13
Pregunta para vosotros 00:33:15
Si nombre, apellido y anonimación son privados 00:33:17
¿Esto funciona? 00:33:20
Porque yo desde aquí no estoy tocando esos parámetros 00:33:24
Esos parámetros son propios de la superclase 00:33:34
Para tocarlos yo estoy llamando un constructor de la superclase 00:33:37
Y al llamar al constructor de la superclase 00:33:42
Él sí puede toquetear sus propios parámetros 00:33:45
Porque estamos dentro de esa superclase 00:33:48
Entonces 00:33:50
Un método, una forma de 00:33:52
Crear objetos de la superclase 00:33:55
Sin tener acceso a sus atributos 00:33:58
Es utilizar super 00:34:00
¿Tudas? 00:34:02
¿Preguntas? 00:34:06
¿Sigo? 00:34:08
Entonces, ahora vamos a ver 00:34:10
Otro, un tercero constructor de alumno 00:34:12
Que pilla todo 00:34:14
Nombra, apellido, año de nacimiento 00:34:16
También el grupo y el horario 00:34:18
Entonces, ¿qué hago? 00:34:19
Pues, lo que hago es 00:34:21
Pillar el 00:34:22
¿Cómo se llama esto? 00:34:25
Constructor de la clase superior 00:34:28
Para hacer la parte 00:34:31
Que es de persona 00:34:33
¿Vale? Lo mismo que he hecho ahora 00:34:35
Entonces, este se irá 00:34:37
Al otro constructor 00:34:39
De la clase persona 00:34:41
Hará todos los trabajos que son 00:34:42
Incluidos si tiene que hacer 00:34:45
en la base de datos, mandar un picture 00:34:47
hará todo lo que hace el otro 00:34:49
constructor, al haber hecho 00:34:51
eso, una vez que ha creado la persona 00:34:53
volverá aquí 00:34:55
y seguirá adelante, y por ejemplo 00:34:57
aquí, lo que hará es llamar 00:34:59
el método ponGrupo con 00:35:01
parámetros grupo y horario, y ahora 00:35:03
veremos que es, este es un método 00:35:05
de esta misma clase 00:35:07
entonces, la idea sería esa, yo lo que voy 00:35:08
a hacer es crear 00:35:11
una instancia, entre comillas 00:35:12
llamar al constructor de mi superclase, una vez que he creado la parte de superclase, 00:35:14
pues añado la parte mía. Os recuerdo que esto, que la llamada a un supermétodo, a 00:35:22
un superconstructor, pues es la primera llamada que se hace dentro de un constructor. La primera 00:35:29
cosa que hago es construyo mi superclase y cuando mi superclase está construida, pues 00:35:35
y luego los métodos propios de este mes de este de esta clase vale que es un grupo que lo que hace 00:35:40
es aceptar el grupo aceptar el horario justo lo que me faltaba para poner aquí por lo tanto lo 00:35:57
usa aquí vale y imprime grupo que me escribe una cosa así está claro que una persona no puede ni 00:36:03
utilizar este método ni utilizar este método entre un alumno puede utilizar 00:36:10
estos dos métodos acceder a grupo de horario y hacer todo lo que pueda hacer 00:36:14
un pecho 00:36:20
aquí estamos definiendo esta parte de abajo 00:36:24
no está parte esta sala no definida en el otro 00:36:28
y listo la persona se define la parte de arriba y en en este de aquí se define este 00:36:34
entonces aquí hemos utilizado súper que es acceder a constructores o métodos de aspectos dudas 00:36:43
como pruebo esta cosa pues por ejemplo un mail creó una persona vale que la vecina que en un 00:36:51
persona luisa bla bla bla de 1978 y luego un alumno que es ahora puedo llamar por ejemplo 00:37:05
un alumno punto con grupo modificaría fijaos que aquí estoy utilizando el mismo constructor 00:37:16
que el constructor de persona vale no le estoy poniendo aquí el grupo el horario por lo tanto 00:37:23
Esto estaría utilizando 00:37:28
Este 00:37:30
¿Dónde está? Este de aquí 00:37:31
¿Vale? Que llama el constructor de persona 00:37:34
Pero en un cierto sentido 00:37:36
En estas dos llamadas 00:37:38
Estoy utilizando el mismo 00:37:40
Constructor 00:37:42
No es verdad, pero 00:37:43
Porque esto usa directamente el constructor de persona 00:37:45
Y esto usa el constructor de alumno 00:37:48
Que llama al constructor de persona 00:37:50
¿Vale? 00:37:52
Sin embargo, luego a un alumno 00:37:54
Puedo llamar las cosas de un alumno 00:37:56
Si hiciera vecina.pongrupo 00:37:58
Me daría un error 00:38:00
Me decía en la clase 00:38:01
Vecina es una 00:38:03
Instancia de la clase persona 00:38:05
La clase persona no está declarado 00:38:06
El método pongrupo 00:38:09
Si yo llamo vecina imprime 00:38:11
Y un alumno imprime me funciona 00:38:13
Y fijaos que imprime 00:38:15
Es un método definido donde 00:38:18
En persona 00:38:19
Pero 00:38:21
Vecina es persona y me vale 00:38:23
Un alumno es alumno, pero alumno es persona 00:38:25
Y por lo tanto me vale también 00:38:29
Además, alumno, un alumno puede llamar también en primer grupo 00:38:31
Lo que me saldría es algo así 00:38:35
La persona escribiría esta cosa aquí 00:38:38
El alumno escribiría lo mismo 00:38:42
¿Vale? 00:38:45
Porque sostancialmente aquí estaría tratando el alumno 00:38:46
Como si fuera una persona 00:38:49
Y luego después, un alumno punto en primer grupo 00:38:51
Me escribiría esta parte aquí final 00:38:55
¿Dudas? 00:38:57
Esto ya lo hemos hecho 00:39:07
¿Qué pasaría si el alumno 00:39:08
El atributo nombre fuera declarado private? 00:39:10
Ya lo hemos hablado 00:39:14
Y discutido entre nosotros 00:39:15
Que si yo intento hacer esto 00:39:16
Dentro de alumno 00:39:18
¿Vale? 00:39:20
Explotaría, porque me diría 00:39:22
No puedes acceder a él porque es privado 00:39:24
Sin embargo 00:39:27
Si llamo el super constructor 00:39:28
Pues entonces me funciona 00:39:31
Porque no lo estoy gestionando yo 00:39:33
Está gestionando él 00:39:35
Y os recuerdo que el constructor es public 00:39:36
Es un poco 00:39:38
Como cuando nosotros hacíamos 00:39:40
Un elemento, un atributo private 00:39:43
Y decíamos 00:39:45
No puede acceder al atributo 00:39:46
Pero si creo un método público 00:39:48
Get es atributo 00:39:50
O set es atributo 00:39:52
Si que puedo manejarlo 00:39:53
Pero la ventaja es que no lo manejo yo directamente 00:39:55
Y voy allí y lo cambio a lo que me da la gana 00:39:58
Sino que paso por un método 00:40:00
Proporcionado por la misma clase 00:40:02
Que me puede hacer los controles necesarios 00:40:04
Para que el valor que tú me has dado 00:40:07
Sea un valor correcto 00:40:09
Si alguien me intenta poner como edad 00:40:10
Menos 7 00:40:12
A lo mejor dentro del método 00:40:13
De creación me dice 00:40:17
Si edad es negativo 00:40:18
Pues ponle que no puede ser 00:40:20
O explota o manda un error 00:40:22
O ponle 0 por defecto 00:40:24
O lo que sea 00:40:26
Constructores private 00:40:27
Ah si existen constructores private 00:40:35
en un futuro 00:40:37
un método private está pensado 00:40:38
para que yo lo use solo dentro de esa clase 00:40:44
entonces a otras clases 00:40:46
incluidas las heredadas no lo pueden llamar directamente 00:40:48
pero imagínate que yo 00:40:51
llamo un método público y dentro 00:40:52
de este método público 00:40:54
usa este método privado 00:40:55
pues como yo desde fuera estoy llamando el método público 00:40:57
me funcionaría, solo que luego 00:41:00
hace cosas dentro 00:41:01
un método sería 00:41:03
privado cuando tú quieres 00:41:06
estar seguro al 100% 00:41:08
que se ejecute ese método 00:41:10
cuando alguien te llama, ¿vale? 00:41:12
Entonces dices, cuando tú 00:41:14
los dejas públicos, uno desde fuera 00:41:16
podría utilizarlo o no. Si tú 00:41:18
dices, cuando a mí me llaman, siempre 00:41:20
llama a este método aquí que es privado interno 00:41:22
aquí, pues ya no das 00:41:24
opciones. 00:41:26
Entonces esto 00:41:31
esto es el error que os daría, ¿vale? 00:41:32
Si fuera 00:41:38
si desde alumno 00:41:38
llamáis nombre 00:41:40
y le decís que es 00:41:42
que es private 00:41:44
pues os diría, oye mira 00:41:46
este atributo 00:41:48
no es visible 00:41:51
fijaos que dice de persona 00:41:52
porque estamos hablando 00:41:54
de persona 00:41:56
hacemos un ejercicito 00:41:57
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
6
Fecha:
24 de enero de 2023 - 14:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 07″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
352.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid