Saltar navegación

20251203 POO_ClasesMetodos_3 - Contenido educativo

Ajuste de pantalla

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

Subido el 3 de diciembre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Las clases, por tanto, tienen dos partes, la declaración de propiedades, atributos o campos y la parte de métodos, ¿vale? Métodos es un trozo de código, un trozo de código que los objetos de esta clase pueden ejecutar, pueden llamar desde el main y eso era lo importante. 00:00:00
lo que ponemos aquí en métodos 00:00:22
el código que pongamos aquí en métodos 00:00:25
solo lo puede 00:00:27
lanzar 00:00:29
alguna instancia 00:00:29
u objeto de esta clase 00:00:33
es la única forma de lanzarlo 00:00:34
no es que lo podamos llamar desde cualquier momento 00:00:35
como cualquier otra función de esta declaración 00:00:38
antigua de toda la vida, no 00:00:40
este trozo de código que está aquí 00:00:42
solo lo puede llamar un objeto 00:00:44
de la clase alumno 00:00:46
por eso aquí en este main 00:00:48
en este por ejemplo 00:00:49
creábamos un objeto alumno 00:00:52
como por ejemplo este, alumno2 00:00:54
es mi objeto alumno creado 00:00:56
y ahora este objeto 00:00:58
puede llamar a este método 00:00:59
de la manera en la que se llama punto y nombre 00:01:02
del método, que los métodos 00:01:04
siempre llevan paréntesis, a diferencia 00:01:06
de las propiedades que no las llevan, es una variable sin más 00:01:08
los métodos sí, bueno pues 00:01:10
esa dinámica entendida, el método 00:01:12
se programa aquí, ahora vemos 00:01:14
más detalles de cómo se programan los métodos 00:01:16
y al método 00:01:18
lo llama un objeto 00:01:20
ya desde la clase main en ejecución. 00:01:22
Entonces, en función del objeto que lo llame, 00:01:25
aquí lo está llamando alumno, por ejemplo. 00:01:29
Aquí lo está llamando alumno2. 00:01:32
Cualquier objeto de la clase alumno lo puede llamar. 00:01:34
Pues en función del objeto que lo llame, 00:01:37
cuando ahora ya este código se ejecute, 00:01:39
¿a qué nos referimos con edad? 00:01:44
Bueno, pues depende. 00:01:47
En este caso nos referimos a la edad 00:01:48
del alumno este 00:01:51
porque es el que lo llama 00:01:54
sin embargo aquí cuando se ejecute 00:01:54
este código 00:01:57
¿a quién nos referimos con edad? 00:01:58
pues cuando se ejecute este código 00:02:02
aquí con edad nos estaremos 00:02:03
refiriendo a la de alumno 2 00:02:05
entonces este método tendrá unos resultados 00:02:07
o tendrá otros 00:02:10
yo lo llamo igual, lo llamo de la misma manera 00:02:11
en ambos casos punto es mayor de edad 00:02:13
pero este método 00:02:16
hace unas cosas diferentes a estas 00:02:17
porque este método usa 00:02:19
las propiedades de este 00:02:21
y sin embargo este usa las propiedades 00:02:22
de este otro, entonces los resultados 00:02:25
son distintos 00:02:27
los resultados son distintos 00:02:28
bueno, eso que es lo más importante 00:02:30
en realidad está claro 00:02:33
bueno, pues ahora vamos a ver más detalles 00:02:34
de programación de métodos 00:02:37
ese es el primero que habíamos 00:02:40
hecho, lo que habíamos 00:02:41
dicho sí o sí, el método 00:02:43
tiene un nombre 00:02:45
lógicamente, en el que yo 00:02:46
recojo, pues si puede ser 00:02:49
explicativo sobre lo que hace, mejor 00:02:51
aunque sea un nombre muy largo de método, no pasa 00:02:53
nada, los métodos en Java se llaman 00:02:56
con 00:02:58
100 caracteres si hace falta 00:03:00
lo que importa es que explique bien lo que 00:03:01
hace para el que luego ve el código de otros 00:03:03
pues no tenga que andar ahí metiéndose 00:03:06
en cada método para ver 00:03:07
lo que hace por dentro 00:03:09
bueno, pues esta parte está 00:03:10
claro, el nombre, ahora 00:03:13
esto de aquí que hemos 00:03:15
puesto nosotros, hasta ahora 00:03:17
hemos hecho solo un único método 00:03:19
con void. ¿Qué significa cuando 00:03:21
pongo void? Cuando pongo void 00:03:24
significa que el método me hace un código 00:03:26
pero no me devuelve, 00:03:29
no me entrega a mí 00:03:31
como método main que 00:03:32
llama al programa, no me devuelve ningún 00:03:34
valor de retorno. Para 00:03:37
entenderlo mejor, vamos a poner otro método más, 00:03:40
otro método, este ya lo tenemos hecho y 00:03:42
entendido, ¿verdad? Vamos a poner un 00:03:44
método que sí que devuelva un valor de retorno. 00:03:46
Por ejemplo, vamos a hacer 00:03:48
un método que 00:03:50
me devuelva 00:03:52
el número de matrícula 00:03:53
del alumno, porque la matrícula 00:03:56
el código, vale 00:03:58
vamos a hacer aquí un método 00:03:59
para que me devuelva 00:04:01
no que me muestre por consola, es diferente 00:04:04
mostrar por consola es una cosa 00:04:06
y entregarme, darme a mí 00:04:08
es otra, vale, no es lo mismo 00:04:10
que tú 00:04:12
me escribas algo 00:04:14
en la pizarra 00:04:16
que yo lo veo, a que me des 00:04:16
a mí eso que estás escribiendo, bueno pues 00:04:19
el system out, me lo estás escribiendo 00:04:21
y yo lo veo, pero no me estás entregando nada 00:04:23
entonces cuando el método devuelve algo 00:04:26
tú no me lo escribes en la pizarra, es que 00:04:28
me das directamente lo que estás mostrando 00:04:29
bueno, pues entonces 00:04:31
vamos a hacer un método que me 00:04:33
entregue a mí el 00:04:35
número de matrícula de este alumno 00:04:37
del alumno que llame al método 00:04:39
pues lo primero, vamos a elegir bien el nombre 00:04:41
del método, pues yo 00:04:43
que sé, por ejemplo, getNumeroMatricula 00:04:45
código 00:04:48
GetCódigoMatricula 00:04:49
Vale, ya he elegido bien el método 00:04:53
Parece que está claro por su nombre lo que hace 00:04:57
Ahora, ¿qué es lo que pongo delante? 00:04:59
Delante, ahora este método 00:05:04
Si quiero que me devuelva algo 00:05:05
En concreto que me va a devolver 00:05:07
El código de la matrícula 00:05:09
Que el código de la matrícula es un entero 00:05:10
Porque está aquí dentro como entero 00:05:13
Luego lo que me va a devolver es un número entero 00:05:15
Pues entonces tengo que poner aquí 00:05:17
El tipo de dato 00:05:20
Del valor que me va a devolver 00:05:22
¿Vale? Entonces si el método 00:05:23
Retorna o devuelve 00:05:32
Algún valor 00:05:35
Como es el caso de este método 00:05:42
Hay que poner 00:05:43
El tipo de dato de ese valor 00:05:50
El tipo de dato 00:05:52
Bueno, pues aquí me va a devolver 00:05:55
El código de matrícula que es un entero 00:06:02
Pues pongo in 00:06:04
Si yo hiciera un método que me devolviera algo 00:06:04
Que es una cadena, pues pondría string 00:06:07
Si hiciera un método que devolviera algo 00:06:09
que es un array, podría poner 00:06:11
el tipo array, por ejemplo 00:06:14
es decir, imaginaos que este método devuelve 00:06:15
un array de números, no sé por qué 00:06:17
pues podría poner esto 00:06:19
y no pasa nada 00:06:21
jolines, donde está el 00:06:23
aquí 00:06:25
¿vale? podría poner esto 00:06:27
en este caso, este método 00:06:30
me tendría que devolver 00:06:31
un array de números 00:06:33
¿vale? entonces este método 00:06:35
puede hacer cosas y devolver cosas 00:06:37
ahora veremos cómo las devuelve 00:06:39
Pero lo que yo tengo que poner aquí delante 00:06:41
Sí o sí, es el tipo de dato 00:06:43
De eso que devuelve 00:06:44
Array de enteros 00:06:46
Entero, mondo y lirondo 00:06:47
String, lo que sea 00:06:50
¿Vale? Solo puede devolver 00:06:52
Un valor, entonces diréis, si devuelve dos números 00:06:56
¿Qué ponemos? Int, int 00:06:59
Si devuelve dos números, no 00:07:00
Es que los métodos solo pueden devolver 00:07:01
Un valor, resultado 00:07:05
Solo uno 00:07:06
Bueno, devuelve 00:07:07
Un array 00:07:12
Lo que pasa es que el array tiene dentro muchas cosas 00:07:13
Pero es un objeto array 00:07:15
¿Vale? 00:07:18
No podría devolver dos arrays 00:07:22
Dos arrays no, pero uno sí 00:07:24
Porque es un objeto array 00:07:25
Vale 00:07:27
Bueno, pues por ahora 00:07:32
Y ahora ya hemos puesto int 00:07:35
Por ahora ya sabemos que paréntesis tiene que tener 00:07:36
Pues vamos a dejar los paréntesis sí o sí 00:07:38
Por ahora vacíos, todavía no lo estamos metiendo en paréntesis 00:07:41
Porque este de antes 00:07:43
Los hemos puesto vacíos 00:07:45
sin más, y este de aquí también vacíos 00:07:46
todo método tiene que tener sus paréntesis 00:07:49
y ahora ya sí, vamos a calcular 00:07:52
el valor que este método tiene que devolver 00:07:56
bueno, pues es el código de matrícula del alumno este 00:07:58
lo tengo yo para devolverlo 00:08:02
vamos a ver las propiedades del alumno 00:08:05
las propiedades del alumno son su NIV, nombre, edad, anda, sí 00:08:07
una propiedad del alumno que llame a ese método 00:08:10
es matrícula 00:08:13
Y matrícula yo puedo acceder a su código con punto código, ¿verdad? 00:08:14
Pues entonces el valor que yo quiero devolver, si lo guardo aquí en una variable auxiliar, pues sería este, matrícula.código, ¿verdad? 00:08:20
Este es el valor que yo querría devolver. 00:08:35
la propiedad matrícula 00:08:38
de este alumno que llama al método 00:08:40
a la que tengo acceso 00:08:42
que está aquí arriba directamente 00:08:44
la propiedad matrícula 00:08:45
y dentro de la propiedad matrícula 00:08:47
solo su código 00:08:50
es lo que yo quiero que este método devuelva 00:08:51
vale, aquí lo tengo en una variable guardadita 00:08:54
una variable local, ahí auxiliar 00:08:56
una variable guardada 00:08:58
pero claro, ahora este método tiene que 00:08:59
mandarlo para afuera 00:09:01
tiene que mandarlo para afuera 00:09:03
no imprimirlo, porque esto 00:09:05
no es mandarlo para afuera 00:09:07
esto sería escribirmelo en la pizarra 00:09:08
no me lo está mandando para afuera 00:09:11
con lo cual este método, si yo quiero hacerlo 00:09:13
así, quiero que lo muestre 00:09:15
tendría que poner aquí un void 00:09:17
entonces si pongo un void, vale 00:09:18
pero en este caso 00:09:20
me está mostrando en la pizarrita 00:09:22
no me lo está entregando a mí 00:09:25
yo quiero que me lo entregue a mí 00:09:26
para eso he puesto aquí un int 00:09:29
para decirle, oye tú, tienes que retornarme 00:09:30
este valor 00:09:33
bueno pues como 00:09:35
cuál es la sentencia para que el método 00:09:37
mande para afuera 00:09:40
tire ese valor para afuera para que 00:09:41
alguien lo recoja desde fuera 00:09:44
pues la sentencia para que ese método lance 00:09:45
fuera ese valor para que alguien fuera lo pueda 00:09:47
recoger es la sentencia 00:09:49
return vale pues 00:09:51
return y después ponemos ese valor 00:09:53
que el método tiene que lanzar para afuera 00:09:56
para que alguien recoja 00:09:57
¿qué valor es? 00:09:59
result 00:10:02
¡Hala! Pues ya tengo este método 00:10:02
Estupendamente hecho 00:10:07
Podría ahorrarme la variable local 00:10:08
Incluso si me da la gana 00:10:16
Y poner directamente return matricula.código 00:10:17
Pongo return matricula.código 00:10:20
Y hasta me ahorro 00:10:23
Esta variable local 00:10:24
Da igual, eso ya son detallitos 00:10:25
¿Vale? Son detallitos 00:10:27
¿Vale? 00:10:29
Cualquier variable que uno declare aquí 00:10:31
A lo mejor yo aquí declaro una variable 00:10:33
Porque voy a hacer una suma de no sé qué 00:10:36
porque el método tiene que hacer la suma de los precios 00:10:38
de no sé cuántos, lo que sea, pues cualquier variable que yo 00:10:41
declare aquí dentro para hacer la operativa que sea 00:10:44
son variables locales a este método, está en este bloque 00:10:47
recordáis lo de los bloques, ¿no? un bloque es cualquier 00:10:50
código entre llaves, un bloque se abre en un if 00:10:53
se abre en un for, un bloque se abre en muchos sitios 00:10:56
pues también ahora ya 00:10:59
vemos que un bloque se abre cada vez que 00:11:02
haces un método, cada vez que haces un método 00:11:05
se abre un bloque 00:11:07
con lo cual, todas las variables 00:11:08
que declaremos ahí dentro 00:11:11
desaparecen 00:11:13
tal cual la ejecución del método termine 00:11:15
porque serán variables locales 00:11:18
igual que todas las variables que 00:11:19
declaramos locales a un if, al bloque 00:11:21
de un if, en cuanto el if termina esas variables 00:11:23
han desaparecido, pues aquí igual 00:11:25
entonces esta variable int result 00:11:27
sería local 00:11:32
porque la he declarado aquí dentro, cuando el método 00:11:33
termina, se va a la basura, pero es que 00:11:35
no me importa nada que se vaya a la basura, porque 00:11:37
la he usado solo como contenedor 00:11:39
auxiliar para 00:11:42
pasársela al return y decirle al return, oye tú 00:11:43
lanza este contenido fuera 00:11:45
que es el que tengo que entregar 00:11:47
esa variable es local, desaparece 00:11:49
¿vale? 00:11:51
bueno, pues este método ya estaría 00:11:53
completo, ahora ¿cómo lo usamos? 00:11:55
pues ya sabemos cómo se 00:12:00
usan los métodos, tiene que haber 00:12:01
un objeto, en mi 00:12:03
programa que se está ejecutando, en mi programa 00:12:05
que arranca con un main 00:12:07
tiene que haber un objeto para ejecutarlo, si no ese 00:12:08
método no puede ser lanzado 00:12:11
venga, pues vamos a 00:12:13
lanzarlo por ejemplo con el objeto 00:12:15
alumno2, alguno 00:12:17
que tuviera matrícula, alumno, alumno tiene 00:12:19
matrícula porque se la hemos puesto antes 00:12:21
hemos creado alumno en este main 00:12:23
le hemos puesto sus datos 00:12:25
y le hemos metido una matrícula 00:12:27
pues venga, ahora resulta 00:12:30
que yo quiero 00:12:32
mostrar la 00:12:33
el código de matrícula 00:12:40
del alumno 00:12:43
el código de 00:12:43
matrícula 00:12:49
del alumno, este que está 00:12:52
en esta variable, del alumno que está en la variable 00:12:56
alumno que he creado arriba 00:12:59
bueno, pues entonces, este objeto 00:13:00
alumno es el que tiene que llamar 00:13:03
al método que hace eso, es el que tiene que 00:13:05
llamar 00:13:07
pues venga, que llame a este método 00:13:07
y lo llama con sus paréntesis 00:13:10
como hay que llamar a los métodos, hay que poner el paréntesis 00:13:12
vale, el método ya está llamado 00:13:15
vale, el objeto alumno 00:13:18
llama a este método, muy bien 00:13:21
ya sabemos lo que hará este método 00:13:22
entonces, se mete 00:13:24
aquí, coge el 00:13:26
código de la matrícula del alumno 00:13:28
que llama al método 00:13:31
que en este caso es alumno, coge 00:13:32
su código de matrícula 00:13:34
y pum, me lo 00:13:36
lanza, me lo lanza 00:13:38
para que yo lo recoja, y yo estoy aquí 00:13:40
yo he llamado 00:13:42
al método, el método me ha lanzado una cosa 00:13:44
y yo estoy aquí que o la 00:13:46
recojo o se va a la basura 00:13:48
pues tal y con lo que he escrito no lo he recogido 00:13:50
en ningún sitio, con lo cual 00:13:52
se está yendo a la basura, es decir 00:13:54
es un poco estúpido que yo llame a este 00:13:56
método para que me devuelva 00:13:58
con el return, me devuelva un valor 00:14:00
y yo aquí no lo 00:14:02
recoja, porque se va tal cual 00:14:04
a la basura, vale, pues 00:14:06
¿cómo recogemos ese valor? 00:14:08
¿cómo recogemos el valor que 00:14:10
este me ha lanzado con el return? 00:14:12
¿Cómo lo recogemos? Pues asignándoselo mediante una asignación. Se lo asigno yo a la variable, por ejemplo, lo puedo guardar, por ejemplo, en esta, yo qué sé. 00:14:14
Pues ahora ya este valor se va a guardar en esta variable, se va a guardar en esta variable, que yo la quiero mostrar, que es la idea, 00:14:33
Porque si no, ¿para qué la he calculado? 00:14:44
Pues la muestro y ya está 00:14:48
¿Vale? 00:14:50
¿Entendido? 00:15:00
Repito, yo podría llamar al método así 00:15:06
Y no pasa nada 00:15:08
Podría llamar al método así 00:15:10
Pero es una pérdida de tiempo 00:15:12
Porque el valor que me está entregando 00:15:14
No lo estoy guardando en ningún sitio 00:15:16
Luego al no guardarlo en ningún sitio 00:15:18
Luego no puedo aprovecharme de él 00:15:19
Para mostrarlo, para hacer el cálculo que toque 00:15:21
¿Para qué lo llamo un método? 00:15:23
Para que me devuelva un valor 00:15:26
si no recojo ese valor en ningún sitio 00:15:27
entonces cuando 00:15:29
llamamos a métodos que devuelven 00:15:31
valores 00:15:33
pues guardamos ese valor en algún sitio 00:15:34
porque es que si no, menuda tontería 00:15:37
y ahora ya con ese 00:15:39
valor resultante de esa llamada 00:15:41
yo hago ya lo que quiera 00:15:43
lo que quiera, vale 00:15:45
entonces 00:15:49
si lo ponemos aquí por ejemplo 00:15:53
para luego 00:15:57
en la ejecución verlo 00:15:58
¿Y si ponemos el... para llamar al método en SIS? 00:15:59
Claro. 00:16:08
Sí, sí, sí, ahora lo escribo. 00:16:11
Y te ahorras la variable. 00:16:15
¿Vale? 00:16:18
Aquí está el código de matrícula. 00:16:21
La matrícula es este, 43. 00:16:24
Esto de aquí es esto. 00:16:28
entonces efectivamente lo que dice él 00:16:31
yo aquí he usado una variable auxiliar 00:16:35
para guardarlo ahí 00:16:38
y luego pasarle esa variable 00:16:40
al system out 00:16:42
pero bueno, podría hacerlo así 00:16:43
y estaría haciendo lo mismo 00:16:46
directamente al system out 00:16:47
pasarle ya la llamada al método también 00:16:50
podríamos pasar la llamada al método 00:16:52
porque este método 00:16:56
ya te va a devolver el valor 00:16:57
y ese valor ya se lo estás enchufando tú 00:17:00
al system out 00:17:02
nos ahorramos el intermediario 00:17:02
este me da 00:17:05
un valor que yo enchufo a la variable 00:17:07
y ahora le enchufo la variable 00:17:08
al system out 00:17:11
pues aquí me ahorro el intermediario 00:17:12
este me entrega un valor que en lugar 00:17:14
de guardarlo en un contenedor intermedio 00:17:17
se lo enchufo directamente a este 00:17:19
de aquí, pero bueno, eso ya es un detalle 00:17:21
si por ahora os es más claro 00:17:22
de esta 00:17:25
manera, mejor para entender 00:17:27
bien que el método 00:17:29
que tiene aquí un tipo de dato 00:17:30
que tiene aquí un tipo, el método 00:17:32
que no tiene iVoid, el que tenga ahí un tipo 00:17:34
me devuelve algo 00:17:36
y yo ese algo o lo guardo 00:17:38
en algún sitio, o se lo enchufo 00:17:40
a otro método, pero bueno, o lo guardo en algún sitio 00:17:42
o lo pierdo 00:17:44
¿el Void solo es para...? 00:17:46
el Void es para métodos que no devuelvan 00:17:48
nada, normalmente si no devuelves 00:17:50
nada, pues de alguna manera tendrás que dar la realimentación 00:17:52
entonces la sueles dar por System.out 00:17:55
claro, pero puede ser un método 00:17:56
que a lo mejor se conecta a una base de datos 00:17:58
y hace algo con ella. 00:18:00
Por ejemplo, podría ser 00:18:01
algo que no te devuelva ningún valor resultado. 00:18:02
¿Vale? 00:18:05
Hombre, esta misma idea 00:18:08
de mostrar el código de matrícula, 00:18:09
claro, uno podría haberla hecho así, 00:18:11
con un... 00:18:14
¿No? 00:18:22
La podríamos haber hecho, pues, de esta otra manera. 00:18:22
¿Vale? 00:18:31
Lo podríamos haber hecho así. 00:18:31
Y entonces, este método 00:18:33
te la muestra directamente, 00:18:34
el código. 00:18:36
No te lo devuelve para que tú le muestres. 00:18:37
Diríais, uy, pues, mucho mejor, 00:18:39
me ahorro tiempo. 00:18:40
Pues no. 00:18:41
está muchísimo peor 00:18:42
muchísimo peor 00:18:44
¿por qué es muchísimo peor? 00:18:46
pues a nivel conceptual de desarrollo 00:18:49
de diseño 00:18:51
en una aplicación 00:18:51
sobre todo en un software 00:18:54
lo que queremos es que sea 00:18:56
y esta palabra ya la he usado alguna vez pero insistiré en ella 00:18:58
porque a lo mejor suena rara 00:19:00
queremos que un software sea lo más desacoplado 00:19:01
posible, que tenga el mayor nivel de desacoplamiento 00:19:05
posible 00:19:07
¿qué significa que un software 00:19:08
sea desacoplado 00:19:11
que cada parte 00:19:12
se hace completamente 00:19:15
por separado, por ejemplo 00:19:17
la parte de dar resultados 00:19:18
al usuario, le hago 00:19:21
en este trozo de código, la parte de 00:19:22
la operativa matemática, la hago aquí 00:19:25
la parte de comunicarse con la base de datos 00:19:26
la hago aquí, en lugar de hacerlo todo mezclado 00:19:29
todo mezclado 00:19:31
pues yo separo conceptualmente 00:19:32
cada parte de la aplicación 00:19:35
en clases distintas 00:19:36
eso es que esté desacoplado 00:19:38
y eso es bueno, ¿por qué? 00:19:40
porque si yo hago cualquier pequeño cambio 00:19:43
me voy solo a esa parte, oye es un cambio solo en la vista 00:19:46
en lo que se llama la vista de la aplicación, que es lo que ve el usuario 00:19:49
en la interfaz gráfica, el cambio es solamente en la vista 00:19:51
pues me voy a la parte de la vista y cambio ahí 00:19:55
el resto de la aplicación no tengo ni que mirarla, ni que abrirla, ni que nada 00:19:57
por eso es bueno que esté desacoplada 00:20:00
bueno, pues este método 00:20:02
está desacoplado y el de abajo no 00:20:05
¿por qué? porque el de arriba 00:20:08
separa 00:20:10
la parte de cómo ve las cosas 00:20:12
el usuario, de la parte del cálculo 00:20:14
y eso es bueno 00:20:16
este método te calcula y te da el valor 00:20:18
y te dice, ahora tú decide cómo lo muestras 00:20:20
cómo te da a ti la gana mostrarlo 00:20:23
¿que quieres un system out? 00:20:24
pues pon un system out o pon lo que te dé la gana 00:20:26
a mí es que me la trae floja 00:20:29
¿que quieres mostrar una interfaz gráfica? 00:20:30
pues muy bien, ahora coges 00:20:33
el código que yo te doy 00:20:35
Y los metes en una interfaz gráfica. 00:20:36
Pero está separado. 00:20:38
Este método de aquí no se entera. 00:20:39
Este método dice, 00:20:41
oye, yo me limito a darte el valor. 00:20:43
Y tú ya, 00:20:46
desde tu otra parte del software, 00:20:47
decides cómo lo muestras. 00:20:49
Ese es tu problema. 00:20:51
Sin embargo, de esta manera, 00:20:53
el propio método te está comprometiendo, 00:20:55
te está forzando, te está obligando 00:20:57
a mostrarlo en un system out. 00:20:58
Si tú cambias la aplicación 00:21:01
y de repente te gusta que sea con interfaz gráfica, 00:21:02
pues tienes que ir aquí al método, quitar este 00:21:05
system out, entonces estás mezclando 00:21:07
conceptos, estás mezclando, hacer los cálculos 00:21:09
con cómo se ven 00:21:11
¿vale? ahora nosotros 00:21:13
en nuestro ejemplo este cortito y sencillito 00:21:15
pues está haciendo 00:21:18
lo mismo esto que esto, está haciendo lo mismo 00:21:19
pero bueno, es que estamos aquí con programas 00:21:21
de cuatro líneas donde no es tan 00:21:23
grave separar por partes ¿vale? 00:21:25
pero sí es importante que cojáis esta idea 00:21:27
esta idea de 00:21:29
buena práctica de diseño 00:21:31
no es no buena, es que es imprescindible 00:21:33
la del desacoplamiento 00:21:35
de la aplicación, separo partes 00:21:37
y de hecho hay un montón de patrones de diseño relacionados con eso 00:21:39
el modelo vista y controlador 00:21:41
vista por un lado, controles por otro 00:21:42
casi todo lo que se llaman patrones 00:21:44
de diseño, que es 00:21:47
cómo organizar el código 00:21:48
de tu aplicación, cómo organizarlo 00:21:51
pues están orientados a eso 00:21:53
a separar en partes 00:21:54
vale, pues entonces 00:21:55
vamos bien 00:21:58
vale 00:22:01
vámonos ahora a meternos 00:22:04
y ya completamos 00:22:07
la parte de declaración de métodos 00:22:09
de un poco 00:22:11
el resumen más por encima 00:22:11
vamos ahora a meternos con estos paréntesis 00:22:14
porque yo hasta ahora con los métodos 00:22:17
estos que he declarado 00:22:19
me he limitado a ponerlos ahí 00:22:20
porque son obligatorios, todos los métodos 00:22:23
tienen que llevar paréntesis en la declaración 00:22:25
y luego en la llamada 00:22:27
también, hay que ponerlos 00:22:29
para la llamada, pero 00:22:31
hasta ahora no he dicho para qué valen esos paréntesis 00:22:33
bueno 00:22:35
pues esos paréntesis 00:22:37
valen para darle 00:22:39
al método alguna información 00:22:41
del exterior para que trabaje con ella 00:22:43
porque si el 00:22:45
método tiene los paréntesis vacíos 00:22:47
y ahí no hay nada 00:22:49
el método solamente puede trabajar 00:22:50
con las propiedades del objeto 00:22:53
con eso claro que puede 00:22:55
trabajar, las tiene ahí encima y trabaja con las 00:22:57
propiedades del objeto para hacer lo que sea 00:22:59
pero ya está 00:23:00
no puede trabajar con más información 00:23:02
luego se puede 00:23:05
crear variables locales, claro, pero son variables 00:23:06
locales que se crea él y le da 00:23:08
él el valor que quiera 00:23:10
pero puede ocurrir que haya un método 00:23:11
que necesite información del exterior para 00:23:14
trabajar, por ejemplo 00:23:16
imaginaos, ahora vamos a 00:23:18
hacer un método dentro de la clase 00:23:20
matrícula para variar 00:23:22
que este método 00:23:28
No necesite, oye, yo de secretaría te dice, necesito de las matrículas de los usuarios, necesito saber cómo es la cantidad, a ver qué podemos hacer que tenga sentido, porque las matrículas no llevan IVA, ¿verdad? 00:23:30
Pero da igual, le vamos a poner un IVA 00:23:49
El de secretaría dice 00:23:52
Oye, necesito saber cuál es la cantidad que tiene que pagar 00:23:54
Si le pongo el IVA 00:23:56
Necesito saberlo 00:23:59
Con lo cual, vamos a añadir un método 00:24:00
Matrícula 00:24:02
Cantidad con IVA, por ejemplo 00:24:06
Yo que sé 00:24:08
Cantidad con IVA 00:24:09
Este método tiene que calcular lo que cuesta la matrícula 00:24:14
Ya con el IVA incluido 00:24:18
Y devolvérmelo 00:24:20
devolvérmelo para lo que sea 00:24:21
con lo cual este método 00:24:23
que le pondría yo ahí como tipo de retorno 00:24:25
le pondríamos un double 00:24:27
porque me va a devolver una cantidad double 00:24:29
va a operar con la cantidad 00:24:31
aquí mis paréntesis 00:24:32
vale 00:24:36
pero claro 00:24:42
ahora yo me pongo a programar el método y digo 00:24:44
oye espérate 00:24:47
para calcular yo la cantidad con IVA 00:24:47
me tendrás que decir 00:24:50
cuál es el IVA 00:24:52
porque yo no tengo esa información, la única información que yo tengo es 00:24:54
el código de la matrícula del alumno, la descripción de esa matrícula 00:24:58
y lo que cuesta, y me estás pidiendo que haga un cálculo para el cual necesito 00:25:03
que tú me digas algo, me des una información 00:25:07
bueno, pues esa información del exterior que puede hacer falta para que un método 00:25:09
trabaje, se pasa aquí en los paréntesis, y es lo que se llama 00:25:15
parámetros, ¿vale? entonces, si un método 00:25:19
necesita datos 00:25:27
ajenos al objeto, como en este caso 00:25:32
IVA es ajeno al objeto, no tiene nada que ver con el objeto, el IVA es el IVA, lo que sea 00:25:37
datos ajenos al objeto 00:25:40
para operar, hay que pasárselo 00:25:45
como parámetro 00:25:49
pasárselo como parámetro 00:25:51
Vale, ¿y cómo se pasan los parámetros? 00:26:02
Aquí en los paréntesis 00:26:06
Bueno, pues parámetros se pueden pasar 00:26:08
De 1 a 2.000 millones 00:26:12
Bueno, de 0 00:26:13
Aquí, por ejemplo, no estoy pasando ninguno 00:26:16
Los métodos que he hecho aquí 00:26:18
Como no necesito información del exterior, 0 parámetros 00:26:19
Aquí tampoco necesitaba 00:26:22
Información del exterior, 0 parámetros 00:26:24
Aquí sí, necesito 00:26:26
Un parámetro, el IVA, un valor 00:26:28
Double, por ejemplo 00:26:30
bueno, pues yo ahí tengo que poner 00:26:31
el parámetro 00:26:32
exactamente igual que como declaraba 00:26:35
una variable 00:26:37
el iba como va a ser, pues 00:26:38
vamos a ponerle que sea entero 00:26:40
pues int 00:26:42
y el nombre que yo le doy a ese parámetro 00:26:44
el nombre que a mí me da la gana darle a ese parámetro 00:26:47
el que yo quiera 00:26:49
venga, pues le voy a dar el parámetro iba 00:26:50
ala, pues ya está 00:26:52
ya tengo una declaración 00:26:55
de método 00:26:57
en la que estoy indicando, oye tú 00:26:57
para operar voy a 00:27:00
necesitar que me pases un número 00:27:03
entero, es lo que estoy diciendo 00:27:05
cuando me pases un número entero 00:27:07
yo operaré 00:27:09
haré lo que sea y te lo devolveré 00:27:10
de vuelta, el resultado 00:27:13
necesito que me pases 00:27:15
un número entero y ese número entero será el que sea 00:27:17
pero el método lo va a 00:27:19
identificar con este nombrecito 00:27:21
el nombre que le ha dado la gana ponerle a él 00:27:22
tú pásame un número entero que yo lo 00:27:24
paso en mi cajita que se llama IVA 00:27:27
como si se llama pepito, la cajita 00:27:29
eso es lo de menos 00:27:31
lo importante es esto 00:27:32
el tipo de dato, entonces tú pásame 00:27:34
un tipo de dato coherente 00:27:37
con esa declaración 00:27:39
de ahí, yo eso 00:27:41
lo meto en mi cajita y ahora ya opero 00:27:43
aquí y hago lo que tenga que hacer, ahora ya 00:27:45
sí que lo puedo hacer 00:27:47
pues venga, aquí que tenemos que hacer 00:27:48
el este 00:27:51
pues será, si lo ponemos en una 00:27:55
variable aparte 00:27:57
pues el doble resultado 00:28:00
pues el doble resultado será 00:28:01
la cantidad 00:28:03
más la cantidad con el IVA que será 00:28:04
cantidad 00:28:07
por 00:28:09
IVA 00:28:12
ahora aquí ya 00:28:15
cuando mezclemos tipos de datos distintos 00:28:16
acordaos de que ahí se salte 00:28:19
la alarma para ver si todo va bien 00:28:21
entonces cantidad por IVA 00:28:23
estoy mezclando 00:28:25
un entero que es IVA con 00:28:26
un double, no pasa nada 00:28:29
porque cuando hay una operación matemática 00:28:30
que mezcla tipos numéricos 00:28:33
distintos 00:28:35
el de menos precisión promociona 00:28:35
el de más precisión, con lo cual 00:28:39
todo esto se va a promocionar a double 00:28:41
y ahora con ese double que tengo que hacer 00:28:43
yo, pues dividirlo entre 100 00:28:45
¿verdad? ¿vale? 00:28:46
y ahora 00:28:56
este de su resultado 00:28:57
se lo 00:28:58
devuelvo 00:29:11
¿vale? 00:29:13
caerá ahí, o sea, este método 00:29:16
aquí estamos en la parte de declaración, acordaros 00:29:23
aquí, yo no se está ejecutando 00:29:25
nada, es como cuando os decía aquí 00:29:27
aquí no se está ejecutando nada, aquí estoy 00:29:29
diciendo lo que va a pasar cuando se ejecute 00:29:31
pero no se está ejecutando nada 00:29:33
entonces, aquí lo mismo 00:29:34
aquí no se está ejecutando nada, yo estoy diciendo 00:29:36
cuando esto se ejecute 00:29:39
tú me pasarás 00:29:41
un valor entero y yo haré esto con él 00:29:43
cuando esto se ejecute, no se está ejecutando nada, no estamos 00:29:45
en un main todavía, esto 00:29:47
lo que te dice es, vale, cuando tú 00:29:49
me llames, me llamarás 00:29:51
dándome un número entero, y yo 00:29:53
con ese número entero haré esto 00:29:55
y te lo devolveré. 00:29:56
Pero aún no se está ejecutando nada, con lo cual 00:29:59
no necesito 00:30:01
ningún valor numérico aquí. 00:30:03
Solo necesito decir lo que voy a hacer. 00:30:05
Vale, antes de ahora ver 00:30:09
cómo ejecutamos este método. 00:30:10
Cuidado 00:30:14
con lo de mezclar los int y los 00:30:14
double y todo eso, por eso digo que siempre 00:30:16
hay situaciones en las que uno tiene que decir 00:30:18
uy, cuidado que esta es una situación en la que 00:30:20
se me tiene que activar una neurona extra 00:30:22
imaginaos que ahora 00:30:24
me cambia la aplicación y me dice, no, no, las cantidades 00:30:26
solo enteras, que es que con decimales 00:30:28
me hago un lío que no veas 00:30:30
entonces 00:30:33
dices, ah, no pasa nada 00:30:34
yo te lo cambio a int, magnífico 00:30:36
pues la hemos cagado 00:30:38
porque ahora ya 00:30:40
esto se convierte 00:30:41
en un entero 00:30:44
esto se convierte en división entera 00:30:45
con lo cual esto va a ser cero siempre 00:30:48
siempre va a ser cero porque es el cociente 00:30:50
¿vale? no es lo mismo 00:30:52
la división entera que la división con decimales 00:30:55
entonces si esto es un número entero 00:30:57
esta es la división 00:30:59
entera que es el cociente y esto va a ser 00:31:01
una cantidad menos de 100 00:31:03
con lo cual 00:31:05
yo al dividirla 00:31:07
pues me puede dar cero perfectamente 00:31:08
entonces esto tiene que ser double 00:31:10
tiene que ser double 00:31:12
si esta cantidad es double no hay problema 00:31:13
porque ya iba a promocionar automáticamente 00:31:16
Bueno, ahora vamos a ver 00:31:18
Cómo ejecutamos esto 00:31:24
Pues esto lo tiene que ejecutar un objeto 00:31:25
Como todos los métodos, lo tiene que ejecutar un objeto 00:31:31
No hay otra 00:31:33
Bueno, pues vámonos a un main que ya tenga objetos 00:31:34
Venga, este main de aquí 00:31:37
Tiene ya un objeto alumno 00:31:40
Con un montón de datos que los hemos metido 00:31:42
Pues vamos a ver cuál es el precio 00:31:43
Con IVA 00:31:46
Vale, pues a ver, ¿de qué objeto 00:31:47
queremos mostrar 00:32:11
ese precio 00:32:13
del objeto alumno 00:32:15
vale, pues entonces tendrá que ser el objeto alumno 00:32:17
el que llame al método, para que el método 00:32:20
trabaje con los datos de alumno 00:32:22
venga, ¿tengo algún método 00:32:24
que me haga esto que me han pedido? uy, sí, qué suerte 00:32:26
tengo un método 00:32:28
que hace justo 00:32:29
lo que 00:32:31
lo que yo quería 00:32:32
ah, perdón, perdón, perdón 00:32:35
mucho más divertido, claro 00:32:38
el método matrícula 00:32:39
lo he metido aquí 00:32:42
en la clase matrícula 00:32:44
luego lo tiene que llamar 00:32:46
un objeto matrícula 00:32:48
¿vale? 00:32:49
al método matrícula, perdón 00:32:51
al método cantidad con IVA 00:32:53
lo tiene que llamar un objeto matrícula 00:32:54
¿vale? 00:32:57
yo quiero que lo llame 00:32:58
el objeto matrícula de este alumno 00:33:00
luego ¿qué escribiría aquí? 00:33:03
dictarme alumno 00:33:05
punto matrícula 00:33:06
Punto, cantidad con IVA. 00:33:09
Pero claro, ahora es el momento, ahora sí que sí, 00:33:14
es el momento de decir, ahora que te vas a ejecutar, 00:33:19
ahora que ya te vas a ejecutar, ahora ya sí que sí, 00:33:21
te tengo que dar el valor concreto con el que te vas a ejecutar. 00:33:25
Ahora es el momento, porque ahora sí que se va a ejecutar el método. 00:33:27
Entonces, ahora ya le damos el valor que sea, 00:33:31
ahora ya hay que darle un valor, 13, 1 leído por teclado, 00:33:33
un valor concreto. 00:33:37
Entonces, en el momento de la llamada al método... 00:33:39
Sí, este sería el IVA, que yo he decidido que sea 13. 00:33:41
Claro, como podría ser cualquier otro. 00:33:46
En el momento de llamar al método, los parámetros tienen que tener un valor. 00:33:57
Tienen ya un valor concreto, porque ya estoy ejecutando. 00:34:03
Igual que alumno matrícula, ya es un objeto concreto. 00:34:12
alumno, ya es un objeto concreto 00:34:15
vale, entonces de nuevo 00:34:17
como este método me devuelve 00:34:19
me lo devuelve como retorno 00:34:21
si lo llamo así, pues vaya pérdida 00:34:22
de tiempo, pues vamos a guardarlo 00:34:25
en algún sitio 00:34:27
para no perderlo 00:34:28
lo guardamos en algún sitio 00:34:30
para no perderlo 00:34:33
y ya está lo que nos haya salido 00:34:34
uy, me falta el 00:34:46
esto 00:34:47
vale 00:34:49
entonces en el momento de llamar al método 00:34:53
ahí es cuando se va a ejecutar en el main 00:34:56
cuando yo lo llamo 00:34:58
y ahí ya tengo que comprometerme, paso el valor 00:34:59
tal cual 00:35:02
ni pongo el tipo de datos ni pongo nada 00:35:03
porque aquí no estoy declarando nada 00:35:06
la declaración la hice aquí 00:35:07
por eso aquí sí que puse el tipo de datos 00:35:10
aquí puse ya el valor 00:35:11
entonces 00:35:14
ejecutamos esto por si hemos escrito algo mal 00:35:15
pues el precio de la matrícula 00:35:18
con el 13 ha subido 00:35:22
de 76 a 85 00:35:24
vale 00:35:25
que hay más parámetros 00:35:27
porque necesita más cosas 00:35:35
pues separados 00:35:37
separados por comas 00:35:38
y ya está 00:35:40
y aquí todos los parámetros 00:35:41
que hicieran falta 00:35:42
si es que hicieran falta más 00:35:43
porque este método 00:35:45
hiciera muchas cosas raras 00:35:46
y entra muchas cosas 00:35:46
pues uno pone los parámetros 00:35:47
que le den la gana 00:35:50
que necesito esos tres 00:35:51
para hacer lo que sea 00:35:54
que voy a hacer ahí dentro 00:35:54
pues a la uno tras otro 00:35:55
separados por comas 00:35:57
eso sí 00:35:58
luego en la llamada 00:35:59
Tendríamos que pasarle 00:36:01
Las tres cosas 00:36:03
En la llamada tendría que pasarle 00:36:04
Número entero 00:36:09
El número dabel 00:36:12
El string 00:36:15
Si yo he dicho aquí 00:36:17
Que necesito 00:36:19
Tres parámetros 00:36:21
Que luego, es mentira, vamos, no los necesito 00:36:22
Si yo he dicho ahí que necesito tres 00:36:24
Pues tengo que pasar luego en la llamada 00:36:26
Esos tres, en ese orden exactamente 00:36:29
tal cual, en ese orden tal cual 00:36:31
y con el mismo 00:36:33
tipo, por ejemplo 00:36:35
como aquí, en ese orden tal cual 00:36:37
y con el mismo tipo 00:36:39
no, return solo 00:36:40
puede volver un valor 00:36:47
y por eso aquí solo ponemos un tipo de dato 00:36:48
porque solo puede volver un valor 00:36:51
claro, claro 00:36:53
parámetros puede haber todos los que hagan falta 00:36:59
y tú con esos parámetros operas, haces lo que sea 00:37:01
pero solamente puedes 00:37:03
devolver un valor, a ver 00:37:05
si quieres devolver muchos, los metes 00:37:07
en un array y devuelves el array 00:37:09
porque el array es un objeto 00:37:11
entonces tú devuelves un array 00:37:13
podrías devolver un array de cosas 00:37:15
uy, vale, entonces aquí 00:37:17
estoy devolviendo muchos enteros 00:37:21
en realidad, pero un único 00:37:23
objeto array, tendría que crear aquí un array 00:37:25
y devolverlo, pero lo que 00:37:27
devuelves es un único 00:37:29
valor, me da igual que ese valor sea de un objeto 00:37:31
de un array, de un stream 00:37:33
pero un único valor 00:37:35
Vale 00:37:36
Entonces, dime 00:37:37
Bueno, pero eso 00:37:39
Ya es que sería otro programa 00:37:52
Entonces, pues tú aquí 00:37:54
Podrías, aquí antes de esto 00:37:56
Preguntar y decir, ¿cuál va a ser el IVA que quiere usar? 00:37:58
Tú lo metes ese IVA en una variable 00:38:01
Y luego le pasas aquí la variable 00:38:03
Vale 00:38:04
Voy a quitar esto 00:38:05
Eso ya es que son detalles 00:38:07
Pues del programa 00:38:11
Yo aquí es que he hecho el ejemplo 00:38:13
Pasándole el 13 sí o sí 00:38:16
Pero bueno 00:38:18
Este programa pues podría ser 00:38:20
Pide antes el IVA por teclado 00:38:22
Pero eso ya son detalles del programa 00:38:24
A mí lo que me importa ahora es 00:38:28
El paso, que entendáis el paso 00:38:29
A los métodos 00:38:32
¿Qué IVA quiere? Pues aquí lo lees 00:38:33
Tenemos escáner 00:38:35
Vale, entonces 00:38:38
¿Qué IVA quiere? 00:38:54
Pues entonces lo leemos aquí 00:38:56
En nuestro int 00:38:58
Lo llamo de otra manera 00:39:00
Lo puedo llamar como me dé la gana 00:39:03
IVA matrícula 00:39:05
Como a mí me dé la gana, es una variable del main 00:39:08
IVA matrícula 00:39:10
Igual a scan.nextInt 00:39:12
Y ahora 00:39:15
A la llamada al método 00:39:17
Le paso esa variable 00:39:19
me da igual pasar el valor 00:39:20
concreto que pasar una variable 00:39:24
con ese, entonces yo le paso esta 00:39:26
variable y entonces ahora ya este método 00:39:28
va a operar con el valor que 00:39:30
tenga esta variable dentro, el que sea 00:39:32
que esta variable 00:39:34
se puede llamar como le dé la gana 00:39:35
no tiene por qué llamarse igual que esta 00:39:38
que esta, estos son cosas independientes 00:39:40
¿vale? es decir 00:39:44
aquí en la llamada 00:39:46
este le dice, oye 00:39:47
él se ha creado una caja verde 00:39:49
donde tiene un 7 00:39:51
y ahora en el momento de hacer 00:39:53
cantidad con IVA de la caja verde 00:39:56
saca el 7 y te lo da 00:39:58
ahora cantidad con IVA 00:40:00
tiene ese 7 en la mano 00:40:02
y lo mete en su cajita azul 00:40:03
¿qué más me da? lo mete en su cajita azul 00:40:06
y ahora ya opera con él, lo que importa es el 7 00:40:08
me da igual que el envolvente para el método 00:40:09
aquí se llame IVA 00:40:12
y aquí se llame 00:40:13
IVA matrícula, me da lo mismo 00:40:14
no es el envolvente de ese valor 00:40:18
que se está pasando uno al otro. 00:40:20
Dime. 00:40:21
Sí, tú aquí podrías usar cualquier cosa 00:40:25
que dé como resultado un número. 00:40:28
Entonces, scanNextInt 00:40:31
te da como resultado un número también. 00:40:33
Luego yo lo puedo pasar aquí, ¿vale? 00:40:36
Porque esto me da un número. 00:40:38
Pues ese número se enchufa a cantidad con IVA. 00:40:39
Eso tenías que poner antes. 00:40:47
Claro, aquí lo único que puedes poner 00:40:48
es algo que se transforme a un número entero. 00:40:50
Entonces, scan next in se transforma en un número entero, luego es válido. Y va matrícula también, porque es una variable. El propio 13 también, o sea, cualquier cosa que sea en realidad un número entero. Es lo que hay que poner ahí, ¿vale? 00:40:53
No, no, no, no, que más da 00:41:07
Espera, vamos a ponerlo como estaba 00:41:15
Vale, aquí 00:41:16
En este extremo 00:41:24
De la llamada, o sea, hay dos personas que se están 00:41:26
Comunicando, hay dos extremos 00:41:29
Este es un extremo de la 00:41:31
Comunicación, este es el A 00:41:32
Y el otro es este 00:41:34
Que es el B, entonces aquí 00:41:36
Tenemos 00:41:38
A ver 00:41:41
Aquí tenemos el método 00:41:45
¿Vale? 00:41:54
El método que te está diciendo 00:41:57
Que necesita una cosita 00:42:00
Entera que tú le tienes que pasar 00:42:02
Es lo que te está diciendo 00:42:04
Y aquí tenemos el main 00:42:05
Entonces el main 00:42:07
Es el que llama al método 00:42:10
Vamos a llamarle a este método 00:42:11
El main es el que llama al método 00:42:13
Y le pasa el valor 00:42:15
¿Vale? Entonces 00:42:17
Este lo que te está diciendo es 00:42:18
Tú pásame un número 00:42:22
pásame un número el que tú quieras 00:42:23
yo ese número lo voy a coger 00:42:25
y lo voy a poner en mi caja que se llama IVA 00:42:27
mi caja yo la he llamado IVA 00:42:30
entonces tú pásame un número que yo lo voy a meter aquí 00:42:32
entonces este es el main que ha hecho 00:42:34
el main lo que ha hecho es 00:42:36
pues ha leído por teclado 00:42:40
y en una cajita suya 00:42:41
en una cajita suya 00:42:43
que se llama 00:42:46
IVA no sé qué 00:42:47
IVA M por ejemplo 00:42:49
en una cajita suya que se llama IVA no sé qué 00:42:50
con el escáner 00:42:53
ha metido un 7, por ejemplo 00:42:54
vale, pues entonces, ahora aquí 00:42:57
nosotros pasamos esta variable 00:42:59
¿qué significa hacer esto? 00:43:02
pues significa, llevamos a este método 00:43:04
cogemos la caja que se llama IVA-M 00:43:07
cogemos esta caja y sacamos el 7 fuera 00:43:09
sacamos el 7 fuera 00:43:13
ahora este 7 viaja por aquí 00:43:15
y se mete en esta que se llama IVA o como se llame 00:43:18
me da lo mismo, y ahora a partir de aquí 00:43:21
este método, cuando 00:43:23
se refiera a IVA, se va a 00:43:25
referir al 7 que salió de esta otra 00:43:27
variable, ¿entiendes? 00:43:29
De esta variable con este 00:43:32
nombre sale el 7 y cae 00:43:33
en esta otra 00:43:36
me da igual como se llamen, porque de esta 00:43:36
sale para caer en esta 00:43:39
y a partir de aquí ya se va a llamar así 00:43:41
¿vale? 00:43:43
Venga, pues a ver 00:43:48
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:
3
Fecha:
3 de diciembre de 2025 - 14:13
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
166.40 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid