Saltar navegación

20250121 Herencia_ClasesAbstractas_1 - 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 21 de enero de 2025 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a acabar esta aplicación que estamos muy hartos y aburridos de hacer lo mismo una y otra vez. 00:00:00
¡Hala! Pues ya está. 00:00:05
Ahora ya vamos a hacer una aplicación, vamos a hacer un main. 00:00:06
El main, en este caso, cambia respecto al que teníamos de pruebas, 00:00:11
porque nosotros en nuestro main original, en nuestra aplicación, 00:00:18
nuestro main trabajaba con un único departamento 00:00:23
y ahora ya nuestro main agregaba 00:00:27
empleado a ese único departamento 00:00:29
etcétera, vale 00:00:31
entonces, vamos a dejar 00:00:33
este main así 00:00:35
empleado temporal tiene sus getsuse 00:00:39
y no tenía nada más 00:00:45
no, ok 00:00:46
Aquí está 00:00:47
Echa el otro día 00:01:01
Esto lo escribimos el otro día 00:01:03
Y nos fuimos con ello ya escrito 00:01:06
Sí 00:01:08
Ah, pero pensaba que eso era de la empresa 00:01:09
Ah, espera un momento 00:01:12
Este es nuestro antiguo mail 00:01:14
entonces al que acabo de entrar 00:01:15
y nuestro antiguo main 00:01:17
nuestro antiguo main 00:01:19
lo hicimos para hacer pruebas 00:01:24
con las clases que teníamos hasta ese momento 00:01:25
que eran departamento, gerente y empleado 00:01:27
pues nos creamos 00:01:30
un departamento 00:01:31
y agregamos empleados al departamento 00:01:32
y mostramos el total del departamento 00:01:35
¿vale? vamos a hacernos 00:01:37
un main 2, bueno lo vamos a dejar esbozado 00:01:39
ya lo completáis vosotros para que podamos 00:01:42
pasar a otro ejercicio 00:01:43
vamos a dejar ya un main 2 00:01:44
esbozado, que ya sería el main 00:01:47
que me piden en el ejercicio 00:01:49
pues venga, nos vamos a hacer una clase 00:01:51
bueno, vamos a llamar 00:01:54
vamos a refactorizar la anterior 00:02:03
para que sea main pruebas 00:02:05
porque es el main que hicimos el otro día para probar 00:02:06
las clases que teníamos 00:02:09
entonces a mi clase main antigua 00:02:10
le voy a cambiar el nombre 00:02:13
con refactor rename 00:02:15
para que se llame 00:02:16
main pruebas 00:02:19
ya se llama 00:02:20
main pruebas 00:02:23
y ahora me voy a hacer un main 00:02:23
que será el propio main de este ejercicio 00:02:26
o al menos lo vamos a dejar 00:02:29
planteado, vale 00:02:31
pues venga 00:02:32
nos hacemos 00:02:34
mi verdadera clase main 00:02:35
con su método main 00:02:39
sí, entonces 00:02:40
dime 00:02:47
si esta clase 00:02:48
puede heredar de otra 00:02:55
esténs, pues imagínate 00:02:56
a ver, puede tener sentido 00:02:59
puede no tenerlo, pero claro que puede heredar 00:03:01
o sea, la clase main es una clase más 00:03:03
que un main herede de otra clase main 00:03:05
a ver 00:03:08
una clase 00:03:10
sí, vamos a ver, una clase main 00:03:12
es una clase normal y corriente en todos los 00:03:14
aspectos, salvo porque tiene 00:03:17
este método, es lo único que la diferencia 00:03:19
que tiene ese método 00:03:21
y ese método es un método especial 00:03:22
porque no se invoca 00:03:25
por código, sino que lo arranca la máquina 00:03:27
virtual, pero como 00:03:29
las clases main son clases normales 00:03:30
y corrientes, yo podría tener otra clase 00:03:33
main, por ejemplo, 00:03:35
¿vale? 00:03:40
Y puede heredar perfectamente. 00:03:41
Claro, hereda, pero en el momento que crece 00:03:44
el public, esta tipo de main... 00:03:46
Entonces, esta clase, claro, 00:03:48
estaría heredando todo lo que tiene 00:03:50
esta otra, en ese caso su main, 00:03:52
pero aquí tendrías un problema. 00:03:54
Y es que tienes ahora dos clases 00:03:56
con dos métodos 00:03:58
main. Entonces, la aplicación 00:04:00
ya no tiene un único punto de arranque 00:04:02
entonces 00:04:04
a la máquina virtual habría que decirle 00:04:06
cuál de las dos es el punto de arranque 00:04:08
de la aplicación 00:04:11
¿vale? 00:04:12
entonces 00:04:15
hacerlo puedes, pero la situación que generas 00:04:15
pues tienes luego que saber manejarla y gestionarla 00:04:19
entonces lo tendrías que hacer 00:04:21
con un manifest, mf 00:04:23
que es el fichero en el que dices cuál es el punto de arranque 00:04:24
de la aplicación 00:04:27
cuando hacíamos el hard veíamos que había un fichero 00:04:28
Sí, pero esa no sería la manera de hacer 00:04:30
esa situación no la harías así, en cualquier caso 00:04:43
siempre harías un main 00:04:45
y tú en función del administrador 00:04:46
efectivamente pues 00:04:49
se lo podrías pasar como parámetro 00:04:51
al main porque el main, aunque no lo hemos usado 00:04:53
hasta ahora, el main 00:04:55
es un método que en realidad 00:04:57
puede recibir parámetros 00:04:59
esos parámetros, ¿quién se los pasa? 00:05:00
la máquina virtual cuando la llama 00:05:04
como nosotros 00:05:06
estamos llamando directamente 00:05:07
a la aplicación sin más, no le está pasando nada 00:05:09
y esos parámetros están 00:05:11
a null todos 00:05:13
pero esos parámetros podemos decirle a la máquina virtual 00:05:14
cuando ejecutamos, cuando hacemos la teclita 00:05:17
verde, además de hacer la teclita 00:05:20
verde, podemos decirle 00:05:22
ahora podemos ver cómo, oye 00:05:23
no solo ejecútate, sino además 00:05:25
te voy a pasar estos parámetros 00:05:27
y esos parámetros van a rellenar automáticamente 00:05:29
este array, de tal manera que 00:05:32
el primero, vamos a hacer una prueba 00:05:34
rapidísima, tengo aquí 00:05:35
mi main pruebas, este main por ahora no tiene nada 00:05:37
hasta olvidémonos de él, vale 00:05:39
voy a hacer aquí mi main 00:05:41
de pruebas y voy a decirle 00:05:44
que antes de arrancar 00:05:46
me muestre los parámetros que ha recibido 00:05:47
vale, por ejemplo el primero 00:05:50
y el segundo, vale 00:05:53
entonces 00:06:00
esta sentencia la puedo hacer 00:06:02
entonces args0 ¿cuál es? 00:06:04
la cadena 00:06:07
que está en la primera 00:06:09
posición de este array args 00:06:11
args1 ¿quién es? la cadena 00:06:12
que está en la segunda posición 00:06:15
de este array args ¿qué tiene este array 00:06:17
args? lo que la máquina virtual le haya pasado 00:06:19
si nosotros ejecutamos 00:06:21
la aplicación como la estamos ejecutando hasta ahora 00:06:23
que es ejecuta y me callo 00:06:25
no digo una palabra más, ahí no hay nada 00:06:27
de hecho vamos a ejecutar este 00:06:29
main pruebas 00:06:31
bueno, claro 00:06:31
lo primero que me dice es esto 00:06:38
porque no hay arc 0 00:06:40
no tiene nada, entonces es null 00:06:42
me ha salido una excepción 00:06:44
porque 00:06:48
aquí no le he pasado nada 00:06:49
yo he llamado a la máquina virtual 00:06:54
y luego no le he dicho 00:06:56
oye y además recibe parámetros 00:06:57
con lo cual efectivamente 00:06:59
en lugar de no salir de excepción 00:07:00
voy a decir 00:07:03
Que me muestre la longitud de ese array 00:07:05
La longitud de ese array 00:07:07
Ah, me va a dar error 00:07:09
No, la longitud de ese array no 00:07:10
Porque me va a dar cero 00:07:12
Pues si es nulo o no es nulo 00:07:13
Por ejemplo esto 00:07:16
Vamos a hacer esto 00:07:18
Pasado parámetros 00:07:20
Y él sé que los muestre 00:07:33
Que los muestre recorriendo el array 00:07:37
Para cada string 00:07:40
Aquí 00:07:43
arts, pues que lo muestre 00:07:45
vale, pues lo primero 00:07:47
que hace este programa cuando lo arranquemos es 00:07:53
ver si la máquina virtual le ha dado 00:07:55
alguna colección de parámetros 00:07:57
si no le ha dado ninguna colección de parámetros 00:07:59
me dirá, no has pasado parámetros 00:08:01
y si sí que se la ha dado, la recorrerá 00:08:03
para mostrar cada parámetro 00:08:05
vale, y luego ya sigue 00:08:07
entonces si ejecutamos esto 00:08:09
pues 00:08:10
como es que me debería decir 00:08:12
no has 00:08:16
Ah, bueno, es que igual en lugar de null 00:08:17
Lo que me hace es crear uno de posición 0 00:08:20
Si args es igual 00:08:21
Si args es igual a null 00:08:23
O args.len 00:08:25
Igual a 0 00:08:32
Es decir, si me has pasado un parámetro null o 1 00:08:33
Con ninguna 00:08:36
Posición 00:08:38
Ahora ya sí que, bueno, vamos a 00:08:39
Pararlo 00:08:42
Antes que nada 00:08:43
Lo volvemos a ejecutar 00:08:45
Vale 00:08:48
no has pasado parámetros 00:08:49
y luego ya el programa arranca 00:08:51
vale, bueno, pues resulta que 00:08:52
además viene bien porque esto en algún momento 00:08:54
teníamos que contar, que arrancamos esto 00:08:56
todo el rato, lo arrastramos y no sabemos 00:08:58
lo que significa, vale, pues entonces podemos 00:09:00
ahora arrancar un programa y además 00:09:02
el momento de arrancarlo 00:09:05
pasarle unos cuantos parámetros, que son cadenas 00:09:06
de texto, las que me den la gana 00:09:09
entonces, eso, si lo hacemos 00:09:10
desde consola 00:09:13
cuando arrancamos nuestra aplicación desde consola 00:09:14
recordad que lo hacíamos 00:09:17
siempre así 00:09:18
java y luego poníamos el nombre 00:09:20
de la clase a ejecutar 00:09:23
podríamos pasárselo así 00:09:25
los parámetros 00:09:27
java, el nombre de la clase 00:09:28
a ejecutar, el programa que fuera 00:09:31
y luego le podemos pasar aquí ya los parámetros 00:09:33
lo que a mi me dé la gana 00:09:35
entonces aquí estaría ejecutando 00:09:37
este código y además 00:09:41
pasándole parámetros 00:09:43
como nosotros no estamos ejecutando desde consola 00:09:44
sino desde el eclipse 00:09:47
el eclipse tiene que tener una manera 00:09:49
de indicar, oye 00:09:51
cuando tú le das al verde 00:09:53
quieres ejecutarlo 00:09:54
solamente o además quieres pasar 00:09:57
parámetros, eso se 00:09:59
configura en el entorno de configuración 00:10:01
en configuraciones de ejecución 00:10:03
lo que aparece aquí 00:10:05
venga, pues entonces 00:10:06
¿veis? y aquí me aparece 00:10:09
una pestañita que dice argumentos 00:10:11
¿veis que hay una 00:10:13
pestaña que dice argumentos? 00:10:15
o sea, aquí a mí me aparece main 00:10:16
que me dice, ¿qué clase quieres ejecutar? main pruebas 00:10:18
vale, estupendo 00:10:21
¿qué argumentos quieres pasar? 00:10:22
pues ahora mismo no tenemos pasando argumentos 00:10:25
vamos a pasarle 00:10:26
hola, ¿qué tal? 00:10:27
creo que hay que pasárselos ahí separados por espacio 00:10:30
creo, vale 00:10:32
y apply 00:10:34
vale, y ahora ya vamos a ejecutarlo 00:10:36
¿veis? entonces 00:10:41
él ahora ya, además de ejecutar 00:10:45
la máquina virtual 00:10:47
ha recibido los parámetros que le he pasado 00:10:50
porque están aquí en la 00:10:53
pestañita de parámetros 00:10:55
y esos parámetros 00:10:57
han ido a parar 00:10:59
a este array 00:11:01
¿vale? 00:11:05
entonces, situación que me decías tú 00:11:06
pues que una aplicación arranque de una manera 00:11:08
u otra en función de que usó el arranque 00:11:11
la forma de programar eso 00:11:13
nunca la haríamos con 00:11:15
diferentes main 00:11:17
o con diferentes métodos main, no 00:11:18
una aplicación de escritorio siempre tiene que tener 00:11:21
un único método main 00:11:23
y ahora ya que ese método main distinga 00:11:24
que tiene que hacer para irse por un método 00:11:27
o por otro y ya está, entonces la forma de distinguir 00:11:29
si has entrado como perfil 00:11:32
de usuario, como perfil de lo que sea 00:11:33
pues puede ser a partir de aquí 00:11:35
por ejemplo, puede ser a partir de aquí 00:11:36
y entonces este distinguiría 00:11:39
el parámetro que me has pasado es parámetro del perfil 00:11:40
de usuario, parámetro del perfil 00:11:43
de administrador, pues yo ya tiro por un lado o por otro 00:11:45
sería una opción, otra 00:11:47
que el main lo primero que hiciera 00:11:48
fuera pedirte 00:11:51
tu login y conectarse a la sede de datos 00:11:53
para ver cuál es tu perfil. Mil formas 00:11:55
diferentes para distinguir cuál es tu perfil y a partir 00:11:57
de ahí irse por un camino o por otro. Pero siempre 00:11:59
un main. ¿Vale? Siempre un main 00:12:01
en la aplicación. ¿Vale? 00:12:03
Pero, aparte, dicho esto, 00:12:05
una clase main, como es una clase 00:12:08
como otra cualquiera, salvo que tiene 00:12:09
ese método main, que debe ser único, 00:12:11
puede heredar de quien quiera. 00:12:13
Y si hereda, pues recibe todo lo que tiene. 00:12:15
Claro. 00:12:18
pero hacer que una clase 00:12:18
en main que tiene un método main 00:12:21
herede de otra que también tiene método main 00:12:23
todo eso 00:12:24
no vas a ganar nada, nada más que hacer 00:12:26
un lío que vete a saber por dónde sale 00:12:29
¿vale? 00:12:31
bueno, pues todo, ahora este era 00:12:33
nuestro main del ejercicio 00:12:35
y ahora este main 00:12:38
va a trabajar para una empresa 00:12:40
esta es una aplicación, ahora ya para una empresa 00:12:44
luego, los datos 00:12:45
de esta aplicación van a ser la empresa 00:12:47
con la que está trabajando 00:12:49
pues esta empresa, esta única empresa 00:12:50
bueno, no he puesto ni el método 00:12:53
aquí 00:12:57
vale, pues 00:12:58
estos son los datos, los datos es la empresa 00:13:10
en la que estoy y se acabó 00:13:12
como tenía un constructor solo con el nombre 00:13:13
pues ya está 00:13:19
vale, y ahora esta empresa 00:13:21
ya está creada 00:13:27
esta empresa no tiene departamentos 00:13:28
todavía 00:13:31
y ya está 00:13:31
y ahora ya a través de la aplicación de gestión del menú 00:13:34
ya hago las cosas que tenga que hacer. 00:13:38
Entonces, ¿qué funcionalidades? 00:13:40
Dice, bueno, aquí dice con cuatro departamentos sin empleados. 00:13:43
Venga, vamos a hacer este main tal cual para este ejercicio. 00:13:46
Vamos a hacerlo porque tendría quizá más utilidad 00:13:49
que en el menú hubiera una opción que fuera agregar un departamento. 00:13:51
Pero bueno, vamos a hacer lo que nos dice, 00:13:56
que es vamos a crear la empresa con cuatro departamentos. 00:13:58
bueno pues entonces 00:14:02
la empresa 00:14:04
sus departamentos van a estar en este 00:14:05
array, entonces esto lo podemos hacer de mil maneras 00:14:08
que es 00:14:10
crear directamente en el main 00:14:12
un array de cuatro departamentos sin empleados 00:14:14
y meter el array 00:14:16
y ya está, podemos hacer eso y se acabó 00:14:17
y ahora vamos a crear 00:14:19
los departamentos 00:14:40
departamento 00:14:42
ojo, esto 00:14:44
un for each que era mi tentación por la costumbre 00:14:46
sí que aquí ya sí que jamás 00:14:48
porque ahora vamos a recorrer este array 00:14:51
para ahora ya sí crear 00:14:53
un objeto nuevo, departamento para 00:14:55
cada posición, luego al crear un objeto 00:14:57
creo una dirección de memoria nueva 00:14:59
si lo hago a través del for each 00:15:01
esa dirección de memoria iría a la copia 00:15:03
no iría a la verdadera posición del array 00:15:05
luego no me serviría de nada 00:15:07
luego aquí sí que un for each 00:15:08
no tendría error de sintaxis 00:15:11
pero no te crearía nada en el array 00:15:13
crearía objetos que luego desaparecerían 00:15:15
Claro, tiene que ser un for normal, sí o sí. 00:15:17
¿Pero el for each no sirve? 00:15:24
No, porque si yo hago esto con un for each, 00:15:27
para cada departamento de mi array de departamentos. 00:15:31
¿Vale? ¿Qué vamos a hacer? 00:15:37
Vamos a crear un departamento. 00:15:38
New departamento. 00:15:41
¿Qué propiedades necesita el departamento? 00:15:46
Vamos a ponerle sin empleados por ahora, solamente con el nombre. 00:15:48
Pues venga 00:15:51
D.set 00:15:53
Nombre 00:15:54
Y que lo vaya pidiendo 00:15:56
Por teclado 00:15:59
Vale, entonces este array teóricamente 00:16:01
Cuatro veces 00:16:03
Porque este array tiene cuatro posiciones 00:16:05
Me instancia un objeto departamento 00:16:07
Y le pone como nombre una cadena 00:16:09
Que me ha pedido, y así cuatro veces 00:16:11
Vale 00:16:13
Nos creemos que el array ya está construido 00:16:14
Con departamentos dentro de él 00:16:18
Vamos a recorrerlo, a ver 00:16:19
vamos a recorrerlo para mostrar 00:16:20
los nombres de los departamentos 00:16:22
que acabamos de crear 00:16:24
para cada departamento en este array 00:16:25
que aparentemente he creído 00:16:29
rellenar 00:16:30
vamos a mostrar 00:16:33
de punto 00:16:35
getNombre 00:16:37
vale, pues ejecutamos este main 00:16:38
vale, y me va pidiendo 00:16:41
los nombres de los cuatro departamentos 00:16:48
departamento 1, departamento 2 00:16:49
departamento 3 00:16:52
departamento 4 00:16:53
y me sale un null pointer exception 00:16:55
claro, es justo lo que os estaba diciendo 00:16:57
¿por qué me sale un null pointer exception? 00:17:00
esto que ya se os quede 00:17:03
grabado en la cabeza 00:17:04
para siempre 00:17:06
porque yo aquí 00:17:08
en la instancia de un nuevo objeto de departamento 00:17:10
¿qué estamos haciendo? 00:17:12
aparece un nuevo objeto en memoria 00:17:13
con una dirección que se acaba de reservar 00:17:15
una dirección que aparece en una 00:17:16
esa dirección se la asignamos 00:17:17
a este objeto de 00:17:20
y este objeto D 00:17:22
es una copia 00:17:24
de la dirección que tiene 00:17:26
el array, no es la propia 00:17:29
posición del array 00:17:31
entonces el objeto lo dejo apuntado 00:17:32
por D que es una copia, no lo dejo 00:17:34
apuntado por la posición del array 00:17:36
entonces el array no se ha enterado de nada 00:17:38
estoy creando todo el rato variables D 00:17:40
que apunta a un nuevo departamento, otra variable D 00:17:42
otra variable D y otra variable D 00:17:44
y ya está 00:17:46
entonces el array no se ha enterado 00:17:47
si yo simplemente quiero consultar 00:17:49
sí, porque me da igual 00:17:53
consultar en la propia posición del array 00:17:55
que en una copia de esa 00:17:57
porque ambas son direcciones que me llevan al mismo sitio 00:17:59
pero si estoy cambiando la dirección 00:18:01
a donde apunta, no la puedo cambiar 00:18:05
ahí, la tengo que cambiar aquí 00:18:07
bueno, pues entonces, esto con un 00:18:09
for each, por tanto, nunca lo podríamos hacer 00:18:13
lo tendríamos que hacer 00:18:15
y ahora esto sería 00:18:16
de 2di 00:18:26
Igual al new departamento 00:18:29
Esto ya sí, si ejecutamos esto 00:18:31
Me van a salir ya los nombres perfectamente 00:18:36
De uno 00:18:38
De dos, de tres 00:18:41
De cuatro 00:18:43
Ya están, de uno, de dos, de tres, de cuatro 00:18:44
Vale 00:18:46
Bueno, entonces ya tenemos 00:18:51
El array de cuatro departamentos creado 00:18:54
Vamos a ponérselo a la empresa 00:18:56
Como su array de departamentos 00:18:58
Bueno, pues ya está, la empresa para eso 00:18:59
La empresa que acabamos de crear 00:19:01
Tiene su método set 00:19:04
a la que yo le doy un array 00:19:05
y lo pone como 00:19:08
valor para esa propiedad array, pues ya está 00:19:09
la empresa ya tiene entonces 00:19:12
su nombre, que se lo he dado en el 00:19:13
constructor, y su 00:19:16
array de departamentos, los cuatro que 00:19:18
acabo de crear 00:19:20
ya tendría empresa, sus dos 00:19:21
propiedades, las únicas que necesita 00:19:24
y ahora ya, pues 00:19:25
me dice el main, venga, pues 00:19:30
¿qué funcionalidades queremos para esa empresa 00:19:31
que tiene cuatro departamentos 00:19:34
por ahora sin empleados 00:19:36
porque del departamento solamente le hemos puesto el nombre 00:19:38
cada departamento a su vez 00:19:40
tiene una raíz de empleados que está a cero 00:19:42
vale 00:19:44
pero es que para eso ya está 00:19:45
las opciones del menú 00:19:48
incorporar un empleado 00:19:50
a un departamento 00:19:52
vale, pidiendo para ello 00:19:53
nombre del departamento al que los vas a incorporar 00:19:56
y datos del empleado 00:19:58
si es gerente o temporal, metelo en ese departamento 00:20:00
mostrar 00:20:02
la salida total de la empresa 00:20:04
y mostrar departamento 00:20:05
que más salario paga. 00:20:08
Pues hacéis esas tres 00:20:10
funcionalidades. 00:20:12
¿Ahora? No. 00:20:14
Ahora no. 00:20:19
En casa. 00:20:20
Vale, a ver. 00:20:22
Pues eso, 00:20:25
nuestro main ahora sería esto. 00:20:26
Una opción, 00:20:30
y ahora ya todo el rato, el do 00:20:31
incorporar 00:20:33
empleado 00:20:44
a departamento 00:20:45
dado nombre 00:20:54
departamento 00:20:57
y solicitando datos del empleado. 00:21:00
Estoy poniendo la opción larguísima para que quede claro. 00:21:03
Datos del empleado también, si es gerente, temporal, etc. 00:21:15
En realidad es lo mismo que esto. 00:21:19
Ya lo hemos hecho en este main de aquí. 00:21:22
Agregar empleado. Lo que pasa es que en este 00:21:23
el empleado lo agregábamos al único departamento que teníamos. 00:21:25
al único, o sea es utilizar esto 00:21:29
pero en lugar de agregarlo al único departamento que teníamos en el otro main 00:21:33
que solo teníamos uno, que era este, solo uno 00:21:37
pues tenemos que una vez que tenemos el empleado ya leído por teclado 00:21:40
que ya lo tenemos aquí ya leído por teclado este empleado 00:21:45
tendremos que recorrer todos los departamentos de la empresa para ver 00:21:48
cuál es el que se llama como me han pedido y agregárselo a ese 00:21:53
O sea, será, cambiará respecto a esta versión del main de pruebas el meter esto en un for, el único que cambiará, meter eso en un for para agregarse al departamento que toque, ya está, meter eso en un for y listo, tendremos la opción 2, que será mostrar salario total de la empresa, que será lo mismo meter en un for el salario total de cada departamento, 00:21:57
pues mostrar salario total de la empresa 00:22:33
pues mostrar salario 00:22:36
de empresa 00:22:42
será en nuestro main de pruebas 00:22:43
mostrábamos el salario del único 00:22:46
departamento que teníamos, que era esto 00:22:48
pues lo único que cambiará 00:22:50
será meter esto en un for 00:22:53
para que haga la suma acumulativa de todos 00:22:54
ni siquiera, porque ya hay un método 00:22:56
en la clase empresa 00:22:58
ya hay un método en la clase empresa que hemos hecho 00:22:59
para mostrar el sueldo total 00:23:02
de la empresa 00:23:04
y hay un método en la clase empresa 00:23:06
que muestra todo lo que paga la empresa 00:23:08
pues esta opción 2 00:23:10
será llamar ese método para este objeto 00:23:12
esta opción 2 es una línea 00:23:14
es para mi empresa llamar al método 00:23:15
sueldo total y se acabó 00:23:18
esa será la opción 2 00:23:20
y la opción 3 de nuevo es recordar 00:23:21
la programación, recordarla 00:23:25
hacer máximos, mínimos, etc 00:23:27
recordarlo 00:23:28
mostrando el departamento que más se gasta 00:23:31
pues tendréis que hacer un máximo 00:23:33
dentro de todo el array 00:23:35
de departamentos 00:23:37
de mi empresa, ver 00:23:40
el departamento que más paga, etcétera 00:23:41
y esto de aquí, estas tres funciones 00:23:47
son, ya esto ni es herencia 00:23:53
ni es nada, es lo de siempre 00:23:54
lo de siempre una y otra vez 00:23:56
y aquí pues como siempre 00:23:58
le demos la opción 00:24:03
y ahora ya pues lo de siempre 00:24:04
en el caso 00:24:11
de que sea uno, pues lo que haya que hacer 00:24:22
que es un copia y pega de nuestro main de pruebas 00:24:23
pero añadiendo un bucle 00:24:27
en el caso 2 00:24:28
una línea 00:24:31
una línea, es el caso 2 00:24:32
y el caso 3, pues hacer un máximo 00:24:35
dentro de la raíz de departamentos 00:24:39
y aquí acabaría 00:24:43
mi switch 00:24:47
y aquí acaba 00:24:48
aquí acaba el switch 00:24:50
y el doom 00:24:53
esta me sobra 00:24:57
Y aquí es el while 00:25:00
Opción 00:25:02
Diferente de la de salir, sea la que sea 00:25:04
La 0 por ejemplo 00:25:07
Bueno, pues esto 00:25:09
Otra cosa que hacéis en casa 00:25:24
Completar este main 00:25:26
Que es nada 00:25:27
Esto es hacer un máximo 00:25:29
Que son 4 o 5 líneas 00:25:32
Si se sabe hacer un máximo 00:25:33
Porque en casa hay que vencer la pereza 00:25:42
Y hacer cosas 00:25:45
¿Vale? 00:25:46
Ya me encargaré personalmente 00:25:48
De que no apruebe nadie 00:25:50
Solamente por venir a clase 00:25:53
Vale, a ver 00:25:55
Figura geométrica 00:25:58
Este ejercicio que nos va a permitir ya 00:25:59
Introducir las clases abstractas 00:26:05
Venga 00:26:07
Ejercicio 00:26:08
Lo voy a meter 00:26:14
En un paquete 00:26:23
Que ponga ejercicio 00:26:24
Figuras 00:26:27
Porque son un montón de clases 00:26:29
Una clase por cada figura, entonces cada ejercicio lo estaba metiendo en un paquete 00:26:33
que a su vez todos en un mismo proyecto para subirlo así a la aula virtual. 00:26:37
Lo que digo una y otra vez, pues eso, otra vez. 00:26:41
Que efectivamente me repito muchísimo porque... 00:26:46
Venga, pues vamos a hacer este. 00:26:50
Se supone que esta es una aplicación para hacer funcionalidades 00:27:06
con figuras geométricas. 00:27:11
en este caso 00:27:14
perímetros y áreas 00:27:17
lo típico 00:27:18
vale, una aplicación que me permita de forma 00:27:20
rápida calcular perímetros y áreas 00:27:23
diferentes figuras 00:27:27
bueno, en particular 00:27:28
ahora mismo va a trabajar 00:27:32
con triángulos cuadrados y círculos 00:27:35
vale 00:27:37
entonces yo podría hacer la aplicación 00:27:38
sin herencia 00:27:41
haciendo una clase triángulo, una clase cuadrado y una clase círculo 00:27:46
o haciendo, viendo que todas son figuras geométricas 00:27:51
pues decir, oye, voy a meter una arquitectura de herencia 00:27:56
voy a hacer una superclase figura geométrica 00:27:59
y que todas se hereden de ella 00:28:03
porque así a lo mejor, a lo largo del desarrollo 00:28:04
puedo ver que incluyendo cosas en la superclase 00:28:08
se me facilitan las cosas 00:28:12
¿Vale? Pues entonces 00:28:15
Una vez que hemos identificado 00:28:17
Que tiene sentido hacer un modelo de herencia 00:28:20
En el cual haya una superclase figura geométrica 00:28:22
Y las subclases que ahí me den la gana 00:28:24
Pues vamos a hacer 00:28:26
Esa superclase 00:28:28
Pues es lo primero que hacemos 00:28:30
La superclase 00:28:35
Figura 00:28:36
Geométrica 00:28:41
Geométrica 00:28:44
Vale, aquí ya como el diseño me lo han hecho 00:28:45
No tenemos que pensar mucho, pero me dicen 00:28:53
todas las figuras van a tener un nombre 00:28:55
pues entonces 00:28:58
como todas van a tener un nombre 00:28:59
esa propiedad nombre 00:29:01
la puedo poner en la superclase 00:29:02
porque todas, me da igual que sean 00:29:06
triángulos, cuadrados, círculos 00:29:07
trapezoides, polígonos 00:29:09
pentágonos, todas van a tener 00:29:11
un nombre, pues entonces esa propiedad 00:29:14
la pongo en la superclase 00:29:16
vale, y además 00:29:17
como parece ser que ya después de 00:29:29
haber analizado cosas del futuro 00:29:32
de esta aplicación, alguien ha debido ver que saber 00:29:33
los lados que tiene esa figura es interesante 00:29:37
pues dice, vamos a hacer una propiedad específicamente para guardar el número de lados que tenga 00:29:40
5, 7, 8, entonces como todas las figuras geométricas 00:29:45
tienen lados, el círculo no 00:29:49
con lo cual esta se queda un poco fea, pero bueno 00:29:55
el que hizo el diseño nos ha dicho que pongamos una propiedad número de lados en figura 00:29:58
geométrica, no sé que se entiende por 00:30:03
el número de lados en círculo, pero bueno, vale, venga, pues un constructor 00:30:07
que inicialice los atributos, get y set y tirando, vale 00:30:18
ahora ya sí vamos a ver que figuras geométricas vamos a trabajar 00:30:46
en esta aplicación, pues nos dice, vamos a trabajar 00:30:50
con triángulo, con cuadrado 00:30:55
y con círculo 00:30:59
triángulo se caracteriza por los tres lados que tiene 00:31:02
cuadrado solo por uno porque el cuadrado 00:31:06
todos sus lados son iguales, luego con poner la medida de uno solo 00:31:10
tengo la medida de los tres, a diferencia del triángulo que sus lados pueden ser distintos 00:31:15
entonces tengo que poner las tres medidas y círculo 00:31:19
con tener el radio ya lo tengo completamente caracterizado 00:31:22
pues venga, hacemos las tres subclases 00:31:25
Triángulo 00:31:28
Que herede de 00:31:42
Figura geométrica 00:31:48
Vale 00:31:52
Vamos a hacerle su constructor 00:31:54
Bueno, vamos a añadir primero 00:31:58
Sus tres propiedades específicas 00:31:59
Que son las tres longitudes 00:32:03
De sus tres lados 00:32:10
Y ahora ya un constructor 00:32:11
Porque el constructor ya no nos vale 00:32:17
Vale, entonces al constructor 00:32:19
Le paso todas las cinco cosas 00:32:37
nombre, num, lados, lado 1, lado 2, lado 3 00:32:39
llamo al constructor de la clase padre 00:32:41
el constructor llamando al super lo podéis generar automáticamente 00:32:45
con generar constructor y os acordáis de aquí arriba 00:32:50
seleccionar la super clase 00:32:54
seleccionáis la super clase 00:32:56
y ya te genera él, la llamada, el constructor de la super clase 00:33:01
Con super, etc 00:33:06
Vale, y luego get y set de las tres cosas que nos faltan 00:33:07
Vale, ya tenemos el triángulo 00:33:12
Pues lo mismo con el cuadrado 00:33:20
Cuadrado solo añade una propiedad propia 00:33:22
Que es la longitud del lado 00:33:36
Como todos tienen la misma longitud 00:33:38
Pues solo añade una propiedad propia 00:33:40
Entonces, ponemos el constructor 00:33:43
Ahí se me olvidó poner el extens 00:33:47
El extens de figura geométrica 00:33:50
y ahora ya si genero el constructor 00:33:53
vale, y el getty set de la única propiedad que he añadido 00:34:04
tenemos el cuadrado con sus particularidades 00:34:22
y nos quedaría el círculo 00:34:37
bueno, pues el círculo 00:34:39
también hereda de figura geométrica y este añade 00:34:49
el radio, estoy haciendo todo en int 00:35:01
tendré que hacer el constructor específico 00:35:05
para él porque los heredados 00:35:10
no le valen 00:35:11
hago el constructor apoyándome en el de arriba 00:35:12
y el get y set para el nuevo 00:35:18
¡Hala! pues ya tenemos 00:35:20
tres subclases de la superclase 00:35:34
todas ellas tienen 00:35:36
un nombre y un número de lados 00:35:38
sus get, set y todo eso 00:35:40
y luego cada una de ellas tiene algo propio 00:35:42
bueno 00:35:44
vale, luego aquí la aplicación 00:35:45
ahora sigue 00:35:47
haciendo la clase manejador de figuras 00:35:52
manejador de cuadros, manejador de círculos 00:35:53
que ahora hacemos 00:35:55
¿vale? 00:35:57
pero, primera cosa que 00:35:58
vamos a pensar 00:36:00
entonces, se supone que 00:36:02
esta aplicación es para 00:36:05
calcular perímetros 00:36:07
y áreas de 00:36:09
figuras geométricas 00:36:11
como triángulo, cuadrado y círculo 00:36:12
y todas las que yo quiera incorporar 00:36:15
vale, pero esas cosas 00:36:17
que va a calcular como 00:36:19
perímetros y áreas 00:36:21
solo tiene sentido calcularlas 00:36:22
sobre objetos, sobre figuras ya concretas 00:36:25
como un triángulo, un cuadrado, un círculo 00:36:29
es decir, figura geométrica es una superclase 00:36:31
pero que no es nada en realidad 00:36:34
una figura geométrica es un concepto 00:36:36
pero no se puede concretar 00:36:39
un triángulo si es así, tiene su perímetro, su área 00:36:41
un círculo es así, tiene su perímetro, su área 00:36:44
una figura geométrica es un concepto 00:36:47
de alguna manera abstracto 00:36:49
No se puede concretar. 00:36:51
Luego, esta clase de aquí, 00:36:53
esta clase de aquí es una clase de la cual, 00:36:59
en principio ya prevemos que nunca vamos a instanciar objetos. 00:37:02
No vamos a instanciar una figura geométrica, 00:37:05
porque en mi aplicación no van a existir figuras geométricas. 00:37:08
En mi aplicación van a existir círculos, cuadrados, triángulos, 00:37:11
que son con los que trabajo. 00:37:15
No van a existir figuras. 00:37:17
En la aplicación anterior que hemos hecho, 00:37:18
teníamos empleado 00:37:20
de los cuales heredaban empleado 00:37:22
temporal y gerente 00:37:24
pero podíamos tener de los tres tipos 00:37:26
podía haber objetos empleado 00:37:28
podían existir 00:37:30
existir empleados temporales y gerentes 00:37:31
pero esta es una situación un poco distinta 00:37:34
ya vemos que es distinta 00:37:36
de la superclase 00:37:37
la superclase es como una especie de conceptos 00:37:39
una especie de plantilla que tiene lo básico 00:37:41
pero de la superclase no van a existir objetos 00:37:44
porque no existen 00:37:46
figuras geométricas abstractas 00:37:47
No existen en la realidad, no puedo ver una figura geométrica, 00:37:50
puedo ver un triángulo, un cuadrado, una figura geométrica, 00:37:53
necesito concretarla, necesito concretarla un poco más, 00:37:55
no puedo verla, ¿vale? 00:37:58
Vale, de hecho, por ejemplo, 00:38:00
todas las figuras estas de aquí, 00:38:03
triángulo, cuadrado, círculo, 00:38:05
se va a poder obtener de ellas el perímetro, por ejemplo, ¿no? 00:38:08
Entonces, imaginaos que queremos hacer 00:38:11
un método perímetro 00:38:14
para obtener los perímetros de estas figuras. 00:38:16
entonces en triángulo 00:38:19
necesitaríamos que hubiera un método perímetro 00:38:21
en cuadrado necesitaríamos 00:38:22
que hubiera un método perímetro 00:38:25
y en círculo otro 00:38:26
porque el perímetro de triángulo 00:38:27
el de cuadrado y el de círculo se hacen de forma distinta 00:38:30
vale 00:38:33
entonces en las tres debería haber un método 00:38:34
perímetro 00:38:37
vale por ejemplo en la clase 00:38:37
triángulo si 00:38:40
nos 00:38:44
hacemos un 00:38:47
método 00:38:48
perímetro para nuestra clase triángulo, pues ya sabemos 00:38:50
que esta clase triángulo me devolvería como perímetro 00:38:55
esto, lado 1 más lado 2 más 00:38:59
lado 3, ¿vale? Sería esto simplemente, el método 00:39:03
perímetro de la clase triángulo sería este, ¿verdad? Me devuelves 00:39:07
la suma de los tres. El método perímetro de 00:39:13
cuadrado, pues sería 00:39:17
parecido, me devolvería 00:39:21
lado 00:39:24
multiplicado por 4 00:39:25
eso es lo que me devolvería, el método 00:39:27
perímetro de cuadrado 00:39:29
lado por 4 00:39:31
y el método perímetro de círculo 00:39:33
¿qué nos devolvería? 00:39:41
pues 2 00:39:46
por pi 00:39:47
por 00:39:49
el radio 00:39:53
¿vale? me sale en rojito 00:39:55
¿por qué? 00:40:10
¿por qué me sale en rojo? 00:40:12
Por el pi, ¿qué más? 00:40:16
Pero más, concreta más. 00:40:18
La posibilidad que crea el número de decimales. 00:40:20
Claro, porque pi es decimal. 00:40:22
Entonces, cuando hacemos una operación entre decimales y enteros, 00:40:25
se hace la promoción del entero al decimal, 00:40:29
con lo cual el total se convierte en decimal. 00:40:32
Luego este total se ha convertido en decimal, 00:40:35
pero a mí me han dicho un entero. 00:40:38
Pues no, casa. 00:40:40
Bueno, pues si tiene que ser entero, 00:40:40
porque tiene que ser entero, como yo estoy trabajando, 00:40:42
pues no pasa nada. 00:40:45
le hago un casting que me quita la parte decimal 00:40:46
y apañado 00:40:48
le hago un casting a todo 00:40:50
le quito la parte decimal 00:40:53
vale, pues entonces 00:40:56
está claro que el método 00:40:58
perímetro en cada clase tiene que ser distinto 00:41:00
pero ahora 00:41:02
entonces yo ya 00:41:04
estoy perdiendo un poco las ventajas 00:41:06
de la herencia 00:41:08
he ganado la de no tener que escribir aquí 00:41:08
nombre cada vez 00:41:12
al hacer el instance, lo he ganado 00:41:13
pero cuál era la verdadera y la importante 00:41:15
que si yo quiero trabajar con muchas figuras geométricas 00:41:18
pues las meto todas en una raíz 00:41:21
y luego cada una de ellas puede ser 00:41:22
círculo, cuadrado, me da igual porque todas serían de la misma 00:41:24
pero claro 00:41:26
como el método perímetro 00:41:28
no está aquí 00:41:30
porque la figura geométrica no tiene perímetro 00:41:31
depende, depende de si es triángulo 00:41:34
cuadrado, círculo, como no está aquí 00:41:36
si ahora yo tuviera 00:41:38
vamos a hacernos nuestro 00:41:41
main de pruebas 00:41:43
Para ver 00:41:44
Main de pruebas aquí en el paquete 00:41:45
Siempre se me olvida esto 00:41:52
Vale 00:41:54
Imaginaos que yo ahora voy a trabajar 00:42:04
Con un montón de figuras geométricas 00:42:07
Con lo cual lo meto en un array 00:42:09
Aquí voy a meter todas mis figuras 00:42:12
Por ejemplo 00:42:25
Supongo que metemos dos 00:42:30
Dos figuritas 00:42:31
En la primera posición 00:42:35
Voy a poner 00:42:38
En figuras de 0 voy a meter un círculo 00:42:41
Que se llama mi círculo 00:42:45
Número de lado 0 porque es un círculo 00:42:57
Y radio 4 00:43:01
Y ahora en figuras de 1 voy a meter pues un cuadrado 00:43:02
Por ejemplo 00:43:08
Mi cuadrado, número de lados, pues 4 00:43:09
Y lado del cuadrado, venga, que sea 6 00:43:24
bueno, pues entonces 00:43:29
aquí tengo un main concreto 00:43:36
particular, un main concreto que tiene 00:43:39
dos figuras 00:43:41
entonces las he metido las dos en mi array de figuras 00:43:42
y ahora yo ya puedo trabajar con ese array 00:43:45
en conjunto, pero claro, si yo quiero 00:43:47
mostrar los perímetros, pues ya sabemos 00:43:49
ya avanzamos 00:43:51
lo que nos va a pasar 00:43:53
en el figura de abajo 00:43:54
en la posición debería 00:43:57
poner un nombre 00:43:59
ay, perdón, sí, sí, sí, en la posición 00:44:00
es que he hecho copia y pega, sí 00:44:02
vale, pues si yo ahora recorro 00:44:04
cada una de mis figuras geométricas 00:44:08
que están en mi array 00:44:11
para calcular el peri 00:44:12
para que me muestre el perímetro de todas ellas 00:44:15
pues efectivamente 00:44:17
tengo el problema que ya prevemos 00:44:19
que no tengo el método 00:44:20
perímetro, vale, no lo tengo 00:44:23
entonces 00:44:29
lo de la herencia ha sido imprescindible 00:44:31
porque si yo no puedo meter todas las figuras 00:44:33
en un solo array 00:44:35
y aquí tengo dos, pero si tengo tres mil 00:44:36
pues no voy a trabajar con 00:44:39
3000 referencias distintas 00:44:42
tienen que ir todas a un array 00:44:44
pero que ocurre 00:44:45
que yo en la clase figura geométrica 00:44:47
no he metido la propiedad 00:44:50
perímetro porque aquí no tiene sentido 00:44:52
porque la figura geométrica 00:44:54
no tiene una forma de definir 00:44:56
su perímetro 00:44:58
depende de que tipo sea 00:44:59
entonces el momento de definirlo es aquí abajo 00:45:01
vale 00:45:03
pero claro el compilador ya sabemos 00:45:05
por enesísima vez 00:45:07
ya sabemos que el compilador dice 00:45:09
¿de qué clase es esta referencia? 00:45:12
figura geométrica, voy a verificar que en figura 00:45:13
geométrica hay un método 00:45:16
perímetro, uy no lo hay, pues no te dejo seguir 00:45:17
vale, entonces en figura 00:45:20
geométrica debería haber un metro perímetro 00:45:22
porque si no, no hacemos nada 00:45:24
entonces en figura geométrica hay que hacer 00:45:25
un método perímetro 00:45:29
perímetro 00:45:30
vacío 00:45:39
vacío no lo puedo dejar 00:45:41
porque tiene que devolver un int 00:45:43
pues al menos tiene que hacer un retun 00:45:46
porque devuelve int 00:45:48
luego un retun al menos tiene que tener 00:45:49
entonces 00:45:52
vale, si yo lo dejo así 00:45:54
esto ya funciona y casa 00:45:55
porque ahora ya, ya sabemos 00:45:57
que la máquina virtual no es el compilador 00:45:59
entonces la máquina virtual 00:46:02
cuando vea esto 00:46:04
va a decir, oye FG 00:46:06
¿cómo te instanciaste? 00:46:07
como círculo, pues llamo al perímetro 00:46:09
de círculo, que es el 00:46:11
bueno, oye tú 00:46:13
FG, ¿cómo te instanciaste? como cuadrado 00:46:15
pues llamo al perímetro de cuadrado 00:46:17
que es el bueno, es decir, a este no le va a llamar 00:46:19
nadie 00:46:21
no le va a llamar, pero lo hemos tenido 00:46:23
que hacer, porque si no el compilador se calla 00:46:25
pero, esta solución 00:46:27
tampoco nos gusta, porque estamos metiendo ahí 00:46:30
un retún cero 00:46:33
que es que el mensaje que transmites 00:46:34
oye, todas las figuras del mundo 00:46:37
su perímetro es 0 00:46:38
porque algo hemos tenido que poner 00:46:40
como si pongo esto, algo he tenido que poner 00:46:41
para que se calle, entonces eso ya es feo 00:46:44
la idea que transmite 00:46:47
y de hecho puede tener efectos 00:46:48
secundarios peligrosos 00:46:50
porque tú haces de repente 00:46:53
ahora un pentágono 00:46:55
y se te olvida sobre escribir 00:46:56
la clase perímetro, se te olvida 00:46:59
cuando ahora metas 00:47:01
aquí la llamada 00:47:03
perímetro de pentágono 00:47:05
te va a devolver esta que te va a devolver cero. 00:47:06
Entonces, la aplicación va a funcionar. 00:47:11
El usuario se puede creer que el perímetro de ese pentágono es cero. 00:47:14
Y no, lo que pasa es que el desarrollador no hizo el método perímetro. 00:47:18
Luego, el tener que hacer aquí uno con un contenido absurdo, 00:47:24
aparte de feo, puede tener ese efecto. 00:47:30
Luego, ¿qué es lo que se hace en una situación como esta? 00:47:33
en la cual la superclase nunca va a ser instanciada. 00:47:36
Pues entonces, nosotros decimos, 00:47:41
oye, este método realmente lo que yo ponga aquí es un invento, 00:47:43
no vale para nada, no vale para nada. 00:47:47
Entonces no voy a poner nada 00:47:49
y lo voy a cerrar aquí con punto y coma. 00:47:51
Que es la primera vez en la vida 00:47:54
que después de un método, en lugar de abrir con llaves 00:47:56
y por el código que sea, cerramos con punto y coma. 00:47:59
Vale, pues podemos hacerlo. 00:48:02
Cuando lo cerramos con punto y coma, 00:48:04
lo que estamos diciendo es que ese método es abstracto. 00:48:05
Es decir, que está por definir, está por definir o por implementar. 00:48:10
Es una palabra más bonita. 00:48:28
Vale, justo. 00:48:30
Si el método es abstracto, estoy obligada a ponerle un abstracto, ¿vale? 00:48:33
Para indicarlo ahí. 00:48:41
Vale. 00:48:46
entonces, este método significa 00:48:46
que está por implementar 00:48:48
¿qué? 00:48:50
esto también lo podríamos hacer con lo de cliente 00:48:51
y cliente tienda y cliente online 00:48:53
sí, claro 00:48:54
si nunca más, si no va a haber clientes 00:48:57
solos, solamente va a haber cliente tienda 00:48:59
y cliente online sí 00:49:01
bueno, pues entonces 00:49:01
este método está por 00:49:05
implementar, luego 00:49:07
lo hemos convertido en abstracto y para ello 00:49:09
aparte de cerrarse con punto y coma hay que poner aquí 00:49:11
el abstracto, ahora ¿qué ha pasado? 00:49:13
Pues desde el momento en que una clase tiene al menos un método abstracto, al menos uno, 00:49:16
la clase se convierte en clase abstracta. 00:49:22
Y convertirse en clase abstracta, ¿qué implica? 00:49:28
Que para que el compilador se calle y todo encaja, estamos obligados a poner aquí abstracto. 00:49:30
¿Vale? 00:49:37
Sí, te lo pide seguro. 00:49:39
Vale. 00:49:41
Pues esto es una clase abstracta. 00:49:43
abstracta, clase abstracta, y ahora ya paramos un momentín, clase que tiene al menos un método abstracto, ¿vale? 00:49:44
De esa clase no se pueden instanciar objetos, desde el momento en que la ha convertido en abstracta 00:50:02
No se pueden instanciar objetos 00:50:17
Nada 00:50:19
Yo antes cuando no era abstracta 00:50:21
Podía haber hecho aquí un new figura geométrica 00:50:24
Y no habría pasado nada 00:50:26
New figura geométrica 00:50:28
Con su nombre y número de lados 00:50:30
Bueno tengo una figura geométrica 00:50:31
Podría haberlo instanciado 00:50:33
Pero si yo la hago abstracta 00:50:37
Ya no se puede instanciar 00:50:39
Si yo pretendiera aquí hacer esto 00:50:42
Esto con lo que fuera 00:50:45
el nombrecito que fuera y su número de lados 00:51:09
lo que me pida el constructor 00:51:12
pues no me deja, me deja 00:51:14
oye cuidado la clase es abstracta 00:51:17
luego no puedes instanciar esta clase 00:51:21
no puedes porque es abstracta 00:51:23
si yo no lo hubiera hecho como abstracta 00:51:25
es decir, esto en lugar de haberlo hecho así 00:51:27
hubiera optado por la otra opción que he dicho 00:51:31
dejar el método aquí vacío 00:51:34
o con un retún cualquiera 00:51:36
podría haber optado por este diseño 00:51:38
y si yo soy cuidadosa en todo lo que hago 00:51:42
y me acuerdo de sobre escribir 00:51:44
ahora bien los métodos perímetro 00:51:46
me acuerdo de hacerlo todo bien, la aplicación va a funcionar igual 00:51:47
pero aparte de que el diseño 00:51:49
es más feo, transmite un mensaje feo 00:51:52
y es que una figura geométrica abstracta 00:51:54
tiene un perímetro que es 7, pues no es mentira 00:51:55
pues aparte de eso 00:51:57
le doy la opción 00:51:59
al universo 00:52:01
de instanciar figuras geométricas 00:52:02
y eso no debería ser 00:52:05
porque eso no tiene sentido 00:52:07
una figura geométrica no se puede instanciar 00:52:09
se puede instanciar un cuadrado, un círculo 00:52:12
una figura geométrica que es 00:52:13
no es nada, no la puedo instanciar, no es real 00:52:14
no la puedo instanciar 00:52:17
luego, el diseño 00:52:18
es mucho más bonito 00:52:21
si yo identifico todo eso 00:52:23
que describe mejor mi situación 00:52:25
y digo, oye, este método está por definir 00:52:28
no tiene sentido que yo aquí lo defina 00:52:30
de cualquier manera 00:52:32
a la espera de que me sobrescriba, no tiene sentido 00:52:33
punto y coma, este queda por definir 00:52:36
le pongo el abstract 00:52:38
y ahora ya al haberle puesto el abstract 00:52:39
mi clase se convierte en abstract 00:52:43
y no pasa nada 00:52:45
acabo de prohibir 00:52:47
que me instancien 00:52:49
acabo de prohibir que me instancien 00:52:50
ya esto imposible, no me pueden instanciar 00:52:52
y aparte 00:52:54
he ganado algo más que lo decimos después 00:52:57
vale 00:52:59
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
15
Fecha:
21 de enero de 2025 - 17:41
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
53′ 01″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
251.02 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid