Saltar navegación

20251205 POO-Ejer_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 6 de diciembre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues vamos a ver, seguro que a muchos de vosotros os viene fenomenal hacerme caso 00:00:00
y a los que no les venga fenomenal o están en absoluto silencio o aparentan que no lo están haciendo. 00:00:04
Se puede elegir. 00:00:11
Venga, pues a ver, este ejercicio 11 de aquí. 00:00:13
Este ejercicio 11 tenemos que ponernos en contexto. 00:00:16
Se supone que responde a la aplicación de un cajero, 00:00:19
un cajero en la que yo puedo meter dinero y sacar dinero. 00:00:23
Ya está, responde a la aplicación de un cajero. 00:00:27
Entonces, cuando nosotros damos al botoncito que sea para aceptar hacer ingreso o para aceptar retirar dinero, pues ese botoncito invocará el método correspondiente, ¿vale? Para ello, previamente nos hemos autenticado con nuestra tarjeta y al autenticarnos con nuestra tarjeta ha aparecido en ese programa que se está ejecutando en el cajero, ha aparecido el objeto cuenta asociado a esa tarjeta, ¿vale? 00:00:29
Bueno, pues entonces, cuando nosotros hemos metido la tarjetita en el cajero, se ejecuta este programa, este main de aquí, se ejecuta en este programa y este programa, sacando los datos de nuestra tarjeta, instancia el objeto cuenta asociado, instancia el objeto cuenta asociado. 00:00:58
para ahora ya poder hacer cosas con esa cuenta 00:01:26
como ingresar o retirar, ingresar o retirar 00:01:29
que es las únicas dos cosas que me permite hacer 00:01:32
podría permitirme hacer más cosas, mostrar saldo 00:01:34
más cosas, pero bueno, este cajero solo nos permite 00:01:37
meter dinero y sacar dinero 00:01:40
nos hemos autenticado y ha instanciado nuestro objeto cuenta 00:01:41
cuenta es un objeto complejo porque tiene datos dentro 00:01:45
podría tener nombre del titular, saldo que tiene 00:01:49
lo que fuera, es un objeto complejo 00:01:52
con lo cual este objeto no se puede declarar 00:01:53
como un único tipo primitivo 00:01:56
o string, no, se declara 00:01:58
como un tipo cuenta porque tiene muchos datos dentro 00:02:00
y ahora ya 00:02:02
ese tipo cuenta que es un tipo objeto 00:02:03
no nos queda más remedio que declararlo 00:02:05
declararlo 00:02:07
dándole las propiedades que interesan 00:02:09
de la cuenta para esta 00:02:12
aplicación 00:02:14
esto ya me lo dice el enunciado, si no 00:02:14
pues el que 00:02:17
me ha dicho, oye ven a programarme 00:02:18
el software del cajero 00:02:22
Pues si no el que me lo ha dicho tendría que decirme 00:02:23
Oye, mi aplicación del cajero solo va a hacer esto 00:02:25
Entonces solo necesito estos datos 00:02:28
Pues ese ya nos lo ha dicho 00:02:30
Y nos ha dicho que los únicos datos que necesita de la cuenta del usuario 00:02:33
Para poder hacer las operaciones que se van a hacer 00:02:37
Son titular y cantidad 00:02:41
Muy bien 00:02:43
Pues entonces ya tenemos todo lo que necesitamos 00:02:44
Para declarar este tipo de datos complejo 00:02:46
Pues ahora ya nos hacemos 00:02:49
Nuestra clase cuenta 00:02:52
Y ahora esta clase cuenta de aquí 00:02:54
¿Por qué se caracteriza la cuenta del usuario? 00:03:03
No os lo acaban de decir 00:03:07
Pues se caracteriza por el nombre del titular 00:03:08
Y se caracteriza por el saldo que tiene 00:03:11
¿No? Nada más 00:03:15
Ábrete 00:03:16
Ahí 00:03:20
Por la cantidad puede tener decimales 00:03:21
Luego un double 00:03:24
ala, por estas dos cosas se caracteriza 00:03:25
ya está 00:03:31
entonces 00:03:32
cuando el programa de mi cajero 00:03:34
arranca 00:03:37
cuando estoy aquí 00:03:38
porque yo he metido la tarjeta 00:03:41
pues se instancia el objeto cuenta 00:03:43
y además 00:03:45
se inician sus propiedades 00:03:48
con las que lea de mi tarjeta 00:03:51
pues nombre, el que sea 00:03:54
aquí lo vamos a pedir por teclado 00:03:56
pero en una aplicación real 00:03:59
no te lo pediría por teclado 00:04:01
cómo te llamas y cuánto saldo tienes 00:04:03
sino que leería los datos de tu usuario 00:04:05
de la tarjeta, se conectaría a la base de datos 00:04:07
lo que fuera, pero bueno, aquí vamos a simular 00:04:09
que en lugar de cogerlo de la base 00:04:11
de datos con el identificador 00:04:15
de la tarjeta, pues te lo pide a ti 00:04:17
porque no sabemos 00:04:19
recoger datos de otra manera 00:04:21
entonces ponemos 00:04:23
el escáner 00:04:34
Vamos a usar 00:04:35
Vale 00:04:37
Y ahora el nombre 00:04:51
Pues el nombre que sea 00:04:53
Ah, perdón, cuenta.nombre 00:04:55
Ya lo he leído, nombre 00:04:57
Nombre 00:04:58
O pongo aquí el scan next line 00:05:00
Me da igual, vale 00:05:03
Puedo poner aquí, de hecho 00:05:05
Vaya tontería usar una variable auxiliar 00:05:06
Vamos a directamente 00:05:08
Poner esto aquí 00:05:10
Vale 00:05:15
entonces, dime tu nombre 00:05:19
y cuenta.nombre 00:05:22
no se puede resolver, no es un campo 00:05:25
porque lo he llamado titular 00:05:30
vale, lo he llamado titular, pues cuenta.titular 00:05:31
vale, y ahora el siguiente dato 00:05:36
en lugar de leerlo de una base de datos, nuestro cajero 00:05:39
pues, nos lo pide 00:05:41
porque no sabemos hacerlo de otra manera 00:05:45
y ahora el saldo 00:05:47
cuenta.cantidad 00:05:56
igual a scan.nextTab 00:05:58
ala 00:06:02
esto es lo que ha ocurrido 00:06:03
cuando el cajero arranca 00:06:06
y le metemos la tarjeta 00:06:08
que pum 00:06:09
se ha instanciado el objeto cuenta 00:06:10
asociado con nuestros datos 00:06:12
y nuestros datos son el titular y la cantidad 00:06:15
vale 00:06:17
y ahora el cajero se pone a ofrecernos 00:06:18
las únicas opciones que nos puede ofrecer 00:06:21
que son 00:06:24
según lo que me ha dicho el 00:06:25
que me ha pedido el software, el cliente 00:06:27
pues lo único que podemos hacer son 00:06:29
ingresar y retirar dinero 00:06:31
es lo único que se puede hacer 00:06:32
con esta 00:06:35
cuenta, lo único que se puede hacer 00:06:36
ingresar y retirar dinero, pues ahora 00:06:39
este cajero ahora ya 00:06:41
está todo el rato diciéndote que quieres hacer 00:06:43
hasta que le des la opción de salir 00:06:45
que ya me voy, que ya no quiero ingresar ni retirar más 00:06:47
pues 00:06:49
¿Qué quieres hacer? 00:06:52
Ingreso 00:06:54
¿O qué quieres hacer? 00:06:55
Retirada de efectivo 00:07:00
¿O te vas ya? 00:07:02
Si te vas ya 00:07:04
Pues ya cierro 00:07:05
Cierro todo 00:07:07
Ahora pues tendremos que mirar la opción 00:07:09
Y ahora en función 00:07:16
De la opción 00:07:30
La opción 00:07:31
Está sin declarar 00:07:33
¿Por qué no la declaro ahí dentro? 00:07:34
Ya no sabemos todas estas cosas de memoria 00:07:37
Porque la opción es la condición del bucle 00:07:39
Mientras la opción sea diferente de salir 00:07:41
Entonces como la opción es la condición del bucle 00:07:44
Y la condición del bucle está fuera de mi bloque 00:07:46
Pues tengo que declararlo fuera del bloque 00:07:50
Porque si lo he declarado adentro 00:07:52
Pues ya no sabemos de memoria que si lo declaro aquí dentro 00:07:54
Esa variable solo es accesible dentro de este bloque 00:07:57
Luego aquí no puedo ponerla 00:08:00
Dígame 00:08:02
no, esta es la condición para seguir 00:08:03
preguntándote, mientras sea diferente de cero 00:08:13
vuelve a entrar 00:08:15
ah, bueno, a ver, es que estoy haciendo 00:08:16
un cajero genérico hasta el punto de salir 00:08:21
vale, entonces tienes razón 00:08:23
aquí lo que dice exactamente, de forma repetida 00:08:25
y terminará, vamos a la relación 00:08:27
de salir o cuando te quedes sin dinero 00:08:29
vamos a darle las dos opciones, salir o cuando 00:08:31
te quedes sin dinero, entonces según eso 00:08:33
aquí la condición sería 00:08:35
mientras la opción sea diferente de cero 00:08:37
sigue preguntando y además de ser 00:08:39
diferente de cero 00:08:41
no, lo de salir 00:08:44
la opción de salir me la he inventado 00:08:47
cuenta, es decir 00:08:48
tú haces operaciones en el cajero 00:08:51
ingresa a retirar, ingresa a retirar 00:08:53
cuando te has quedado a cero, ya el cajero 00:08:55
se te bloquea, pero tú te puedes ir 00:08:57
antes, se ha habilitado la opción de irte 00:08:59
antes si quieres, sin necesidad de haber agotado 00:09:01
todo el dinero 00:09:03
¿Vale? Que sería 00:09:03
Hombre, feo, ¿no? Que te obligue el cajero a 00:09:06
Sacarlo todo antes de irte 00:09:08
Pues es un poco feo 00:09:10
Cuenta, punto, cantidad 00:09:11
Sea mayor que cero 00:09:14
Mientras no me des 00:09:17
A la opción de cero y además 00:09:19
Y además, te quedes saldo 00:09:21
Te permito seguir operando 00:09:23
Te permito seguir operando 00:09:25
Pero como me des la opción de salir 00:09:27
O te quedes a cero 00:09:29
Entonces 00:09:31
Te vas 00:09:33
El cajero se cierra 00:09:35
¿Vale? Entonces cuando salgamos de aquí 00:09:38
¡Hala! 00:09:40
Ya está 00:09:49
Le podríamos hasta informar 00:09:50
Si se va porque le hemos dado salir 00:09:52
O si se va porque se ha quedado sin dinero 00:09:54
Entonces 00:09:57
Si cuenta.cantidad 00:09:58
Es mayor que cero 00:10:01
Te vas 00:10:03
Porque has dado salir 00:10:04
no porque te obligue yo porque has llegado a cero 00:10:06
y si cantidad es igual a cero 00:10:09
entonces no puedes seguir operando 00:10:12
porque 00:10:16
te has quedado sin pasta 00:10:19
porque no tienes dinero 00:10:22
bueno, pues un pequeño tuneo de este cajero 00:10:33
vale, pues ahora 00:10:37
nos entramos en el do while 00:10:48
Una vez leída la opción 00:10:50
Ahora ya sí que sí, el cajero tiene que operar 00:10:51
Y en función de 00:10:54
La opción que el usuario 00:10:56
Ha introducido, pues ahora ya 00:10:58
¿Qué hemos introducido en la opción? 00:10:59
Uno 00:11:03
Pues haces una cosa 00:11:03
¿Qué hemos introducido en la opción? 00:11:05
Dos 00:11:11
Haces otra cosa 00:11:11
Ahora la pondremos 00:11:16
¿Qué has introducido en la opción? Cero 00:11:17
Nada 00:11:20
Porque ya te va a decir aquí 00:11:22
Gracias y adiós 00:11:24
Ya has introducido la 0 00:11:25
Ya está 00:11:26
Vamos a ponerle un default 00:11:28
Porque si no he introducido 00:11:33
Ni la 1 ni la 2 00:11:35
Bueno, en el caso de la 0 00:11:37
También te diría la 0 00:11:38
Para que sea opción incorrecta 00:11:39
Case 0 00:11:40
Y ahora en el caso de que 00:11:43
No sea ni la 1 ni la 2 ni la 0 00:11:49
Pues sí 00:11:51
Incorrecta 00:11:52
Ala, ya está 00:11:55
Ahora, estas opciones son las que nos interesan 00:11:56
Las que están aquí dentro 00:11:59
Bueno, pues aquí que hay que hacer 00:12:00
Meter dinero en la cuenta 00:12:03
Vale 00:12:05
Pues aquí un diseño 00:12:05
Por supuesto sería 00:12:09
Dime 00:12:10
Así de repente 00:12:11
Joder, pero porque no te has meado hace 10 minutos 00:12:13
Que era cambio de clase 00:12:17
Pues quien sabe como funciona el cuerpo 00:12:18
Anda tira 00:12:20
Pero de verdad es que 00:12:22
Tenéis una vejiga muy extraña 00:12:23
bueno 00:12:26
vale, entonces aquí 00:12:28
un diseño posible de la aplicación sería 00:12:30
pues 00:12:33
sería 00:12:34
dame el dinero 00:12:38
o sea, dime que dinero vas a introducir 00:12:41
aparte 00:12:44
lo metes físicamente, claro, tendrá la aplicación 00:12:46
luego ya su parte de sensores 00:12:48
para detectar que has 00:12:50
metido tu dinero 00:12:52
y contártelo, esa será la parte 00:12:53
de robótica, pero el resultado final 00:12:56
va a ser que al proceso este 00:12:58
que a la aplicación le llega ya una cantidad 00:13:00
38, 42,9 00:13:02
ya le llega una cantidad 00:13:05
llegará pues efectivamente por una parte 00:13:06
de sensores contando los billetes 00:13:08
pero al final le ha llegado una cantidad 00:13:09
pues aquí un posible diseño sería este que sería 00:13:11
pues muy horrible 00:13:14
que sería 00:13:15
a ver 00:13:17
int 00:13:23
una cantidad 00:13:37
con next double no next int 00:13:47
Entonces aquí se la vamos a decir a mano 00:13:49
Pero el cajero realmente sacaría ese dato 00:13:54
Esta cantidad 00:13:56
La sacaría de su lector de billetes 00:13:58
O de lo que fuera 00:14:00
Y ahora ya podríamos hacer 00:14:01
Cuenta.cantidad 00:14:03
Más igual 00:14:06
Esto 00:14:10
¿Vale? Este sería un diseño posible 00:14:10
De la aplicación y no pasa nada 00:14:14
Le estamos dando una cantidad 00:14:16
Y la suma a cuenta 00:14:17
Y es un diseño posible 00:14:19
Pero este diseño es feo 00:14:21
porque va en contra de los principios 00:14:23
de la relación entre dos objetos, que es 00:14:26
vamos a separar tareas, vamos a separar 00:14:28
partes, todo relacionado con cuenta 00:14:30
que se haga en la clase cuenta 00:14:31
y así esa clase cuenta se queda 00:14:34
como un objeto estupendo 00:14:36
que tiene propiedades y además tiene 00:14:38
comportamiento, todo dentro 00:14:40
y el programa 00:14:42
principal, el main, se despreocupa 00:14:44
ya de hacer el código de esos 00:14:47
ingresos y de esas retiradas, porque 00:14:48
ese código ya está metido 00:14:50
dentro de la clase cuenta 00:14:52
entonces ese es el principio de 00:14:53
encapsulación que se llama 00:14:56
todos los comportamientos 00:14:58
relacionados con las cuentas 00:15:00
que en este ejercicio sencillo es 00:15:01
ingresar una cantidad 00:15:03
o retirar una cantidad 00:15:06
todo ese comportamiento 00:15:07
vamos a declararlo y encapsularlo 00:15:08
dentro de la clase cuenta 00:15:11
y se queda ya como una cosa completita 00:15:12
con propiedades que la caracterizan 00:15:14
y cosas que puede hacer 00:15:17
y ahí se queda encapsulado 00:15:18
y ahora ya cualquier programa 00:15:20
este main u otro programa 00:15:22
de otro cajero que va a ser un poco 00:15:24
distinto pero también va a usar cuentas 00:15:26
pues cualquier otro software ahora con su propio 00:15:28
main, llama a cuenta 00:15:30
llama a su comportamiento 00:15:32
y le da exactamente igual como este 00:15:34
hecho por dentro, se limita a llamar 00:15:36
a los métodos 00:15:39
esa sería la manera buena de 00:15:40
programarlo, cada clase engloba 00:15:42
dentro, encapsula dentro 00:15:44
todos los detalles de el 00:15:45
comportamiento, de lo que va a hacer 00:15:48
y los main se limitan a llamarlo 00:15:50
como si fuera una función auxiliar 00:15:52
pero al main le da igual como hacerlo 00:15:54
sin embargo con este diseño 00:15:55
el main 00:15:57
está haciendo él 00:15:58
el propio código 00:16:01
está pidiendo la cantidad, la está leyendo, la está sumando 00:16:02
a esta propiedad, está haciendo el propio código 00:16:05
aquí son tres líneas 00:16:07
pero en una aplicación normal no es así 00:16:09
entonces sería un desastre de aplicación 00:16:11
si el propio main lo tiene que hacer todo 00:16:13
¿de qué nos vale entonces hacer una clase 00:16:15
si no podemos meter en ella 00:16:17
los detalles de su comportamiento? 00:16:18
vaya diseño tan 00:16:20
vaya a matar moscas a cañonazos 00:16:22
para hacerme 00:16:24
esto, un cuenta y dejarlo así 00:16:26
pues para esto no te hagas nada 00:16:29
¿vale? claro, es que no 00:16:30
diseñamos así 00:16:32
entonces si hemos hecho una clase cuenta 00:16:33
y queremos que con las cuentas se hagan 00:16:36
cosas como ingresar dinero 00:16:38
o retirar dinero 00:16:40
pues vamos a programar esos comportamientos aquí dentro 00:16:41
y ahí se quedan encerrados 00:16:44
y ahora ya cualquiera 00:16:46
que quiera trabajar con cuentas 00:16:48
llama a eso y se acabó 00:16:50
y le da igual como esté hecho 00:16:52
pues entonces, esto de ingresar 00:16:53
nada de hacerlo aquí 00:16:58
¿vale? 00:16:59
ahora ya el ejercicio nos lo dice 00:17:02
porque nos lo da detallado lo que tenemos que hacer 00:17:04
pero claro, nos lo dice porque este proceso 00:17:06
de diseño ya se ha hecho previamente 00:17:08
aquí nos dice 00:17:09
vamos a hacer un método 00:17:11
que ingrese una cantidad 00:17:12
dentro de la clase cuenta 00:17:16
a esa cuenta y ya está. 00:17:18
Si además es negativa, 00:17:21
asume que se ha equivocado 00:17:24
el cajero sumando 00:17:25
y no ingreses nada. 00:17:26
Pues venga, vamos a hacer ahora este método. 00:17:29
Este método, su sitio 00:17:31
es aquí, en la clase cuenta, 00:17:32
porque lo que va a hacer está relacionado 00:17:35
con las cuentas. 00:17:37
¿Cómo se va a llamar? Pues ingresar, 00:17:38
que es un nombre bien explicativo. 00:17:40
¿Qué hay que pasarle 00:17:44
como parámetro? Una cantidad. 00:17:45
La cantidad que vamos a ingresar 00:17:47
Vamos a llamarla cantidad, por ejemplo 00:17:49
Ahora 00:17:51
Este método me entrega algo de vuelta 00:17:53
No me entrega nada 00:17:56
Porque su efecto ya se queda reflejado aquí 00:17:57
Su efecto ya se va a quedar 00:18:00
Reflejado en esta variable 00:18:01
¿Verdad? 00:18:03
Entonces, el tipo de dato vamos a ponerlo ahora después 00:18:05
Porque 00:18:07
¿Qué hace el método? Para entender bien que no me devuelve nada 00:18:09
Pues vamos a mirar 00:18:12
Si cantidad 00:18:14
es positiva 00:18:15
porque sólo si es positiva 00:18:17
hago yo algo 00:18:19
si es negativa no hago nada 00:18:22
se supone que ha habido un error de lectura 00:18:23
pues si la cantidad es positiva 00:18:24
ahora eso es lo que decíamos ayer 00:18:27
tengo aquí la ambigüedad 00:18:28
pero espérate tú 00:18:30
cuando pongo yo aquí cantidad 00:18:31
¿a quién me estoy refiriendo? 00:18:33
¿me estoy refiriendo al parámetro cantidad? 00:18:35
¿o me estoy refiriendo a la propiedad cantidad de la clase? 00:18:38
¿a quién me estoy refiriendo? 00:18:41
aquí hay una antigüedad 00:18:42
una antigüedad, una ambigüedad 00:18:43
enorme 00:18:45
bueno, pues Jabba te dice 00:18:46
si tú me das cantidad 00:18:49
en una situación en la cual hay esta 00:18:51
ambigüedad, y es que un 00:18:53
parámetro se llama igual que una propiedad 00:18:55
si tú me das el 00:18:57
nombre, yo voy a entender siempre 00:18:59
que te refieres a este 00:19:01
ah, pues aquí entonces 00:19:03
está bien, has entendido bien, porque yo aquí me 00:19:05
refería a este, pero es que ahora quiero poner 00:19:07
que esta otra cantidad 00:19:09
quiero poner que esta otra 00:19:10
quiero poner que esta otra 00:19:12
se incremente con el parámetro 00:19:18
puesto así es una estupidez 00:19:20
porque cantidad a palo seco 00:19:24
ya Java me ha dicho 00:19:26
cantidad a palo seco es el parámetro 00:19:27
entonces al propio parámetro le estoy sumando su valor 00:19:29
es estúpido, es que este no es 00:19:32
el parámetro, esta es la propiedad 00:19:34
bueno, pues ya dijimos el miércoles 00:19:35
que como 00:19:37
especificábamos que este 00:19:39
término se refiere a la propiedad 00:19:42
y no se refiere al parámetro 00:19:44
Vale 00:19:45
Así 00:19:48
Entonces, ahora 00:19:50
Poniendo el dis delante, estamos especificando 00:19:52
Oye tú, ¿qué cantidad 00:19:55
Se refiere a la propiedad 00:19:56
Cantidad del objeto 00:19:59
En el que estoy 00:20:01
Dis de hecho viene de ahí 00:20:02
Viene de este objeto 00:20:05
Este, este 00:20:06
Este objeto 00:20:07
Puedes hacer, a lo mejor puedes hacerlo 00:20:09
a lo mejor no puedes hacerlo, porque a lo mejor esto 00:20:16
esto es lo que se llama la firma 00:20:18
del método, bueno nos falta poner todavía 00:20:20
entonces la firma del método 00:20:22
a veces, por diseño 00:20:24
te viene ya fijada 00:20:26
entonces a lo mejor tú no 00:20:28
puedes cambiar cosas, porque esa firma 00:20:30
ese método es llamado de muchos sitios 00:20:32
usado por muchas partes 00:20:34
y tú no puedes tocar y de repente cambiar las cosas 00:20:36
y es que no hay 00:20:38
necesidad, es que así 00:20:40
queda muy claro 00:20:41
así es que en realidad queda más claro 00:20:43
a la vista, al ojo, si tú ves aquí cantidad 00:20:55
que se llama igual que lo de arriba, automáticamente haces la conexión 00:20:57
de que seguramente son dos conceptos 00:21:01
relacionados, que con este estás queriendo 00:21:04
hacer algo relacionado con el otro 00:21:07
ya haces una conexión semántica 00:21:09
entonces sí que tiene sentido que se llamen igual 00:21:11
porque una cosa es la información 00:21:13
lo que te dice algo 00:21:15
y otra cosa es la meta información 00:21:17
que es lo que tú 00:21:20
extraes, la información añadida que tú 00:21:21
extraes, entonces tú viendo aquí 00:21:23
que esto se llama igual que esto 00:21:25
extraes automáticamente una información de que 00:21:27
seguramente ese parámetro va a 00:21:29
tocar o tiene relación con el de arriba 00:21:32
seguramente, entonces 00:21:34
sí tiene sentido que se llame igual, aparte que lo deja más 00:21:35
claro, y aparte es que no hay 00:21:37
como la alternativa 00:21:40
es muy sencilla, es poner el dis y ya está 00:21:42
¿vale? bueno, pues entonces este método 00:21:44
solo tendría este código 00:21:48
si la cantidad es negativa 00:21:49
la sumas 00:21:52
a la propiedad 00:21:53
que aquí cuando lo hemos hecho por código 00:21:54
en el main, aquí ni siquiera 00:21:57
lo habíamos verificado, aquí habría que haber metido 00:21:59
un if, o sea, no 00:22:01
bueno, ahora ya sí que 00:22:02
vamos a pensar, este método 00:22:05
me está devolviendo algo a mí 00:22:07
valor de retorno cuando yo le llame 00:22:09
no tiene por qué, porque su 00:22:11
efecto, que es subir una cantidad 00:22:14
su efecto ya se queda aquí 00:22:15
reflejado, en la propiedad del objeto 00:22:17
el propio objeto que llame al método 00:22:19
refleja el resultado 00:22:23
que es el incremento de la cantidad 00:22:26
luego este método no tiene que devolver nada 00:22:27
su efecto ya se ha quedado recogido 00:22:29
aquí arriba, en este incremento, no tiene que devolver nada 00:22:32
entonces como no devuelve nada 00:22:34
pues yo planto un void, porque no devuelve nada 00:22:35
y este método ya está aquí 00:22:38
ahora ya 00:22:41
un valor que tú quieres devolver 00:22:43
y haces un return 00:22:50
de esa variable 00:22:50
claro, por ejemplo, este método 00:22:52
podríamos modificarlo 00:22:57
porque nos gusta más 00:22:59
para que me devolviera 00:23:01
la nueva cantidad 00:23:03
por ejemplo 00:23:05
entonces yo añadiría esto 00:23:07
vale, entonces este método 00:23:09
me sigue haciendo lo que me tiene que hacer 00:23:15
que es lo que importa, lo que importa 00:23:17
es que me incremente la cantidad en el 00:23:19
objeto cuenta, eso es lo que importa 00:23:21
pero además me da el valor como información 00:23:23
por si yo lo que pone un mensaje o lo que sea 00:23:25
además me lo da como información 00:23:27
bueno, pues podemos hacer esta variante 00:23:29
pero si yo no quiero este return 00:23:31
que en realidad no me vale para nada 00:23:33
porque el método lo que cuenta, lo que importa 00:23:35
es que me suba la cantidad de mi cuenta 00:23:37
el único que importa es que me suba la cantidad de la cuenta 00:23:39
no que luego me informe de ella 00:23:41
y me la dé como retorno 00:23:43
entonces si yo no quiero hacer este retun no pasa nada 00:23:44
vale pero bueno 00:23:47
vamos a dejarlo así 00:23:49
no si tú no lo pasas a un siso 00:23:51
vale entonces ahora 00:24:00
este método está claro y aquí ya queda 00:24:02
encapsulado lo que hace 00:24:05
y ahora ya la ventaja enorme 00:24:06
es que cualquier programa 00:24:08
que trabaja con cuentas 00:24:10
llama a ingresar y el dinero se ingresa 00:24:12
y ese que llama a ingresar 00:24:15
no se preocupa ni le importa 00:24:17
cómo lo hace y lo deja de hacer, le da exactamente 00:24:19
igual, porque esa 00:24:21
información está encapsulada aquí 00:24:23
vale, pues ¿quién es el que va a llamar a ingresar? 00:24:25
pues este aquí 00:24:27
este aquí 00:24:28
pedimos la cantidad 00:24:29
esta cantidad en un caso real no la pediríamos 00:24:32
repito, sino que se leería del sensor 00:24:37
o de lo que fuera de billetes 00:24:39
y ahora ya 00:24:41
cuenta punto 00:24:42
ingresar 00:24:45
y ahora esa cantidad 00:24:48
que hemos leído 00:24:50
que vamos a leer 00:24:51
vamos a llamar al método en primer lugar así 00:24:52
pues ya está 00:24:59
ahora esto está separado 00:25:02
el main llama a ingresar 00:25:03
¿cómo está hecho el ingreso por dentro? 00:25:06
le da lo mismo 00:25:09
que llega un momento 00:25:10
que cambia el software del cajero 00:25:13
el ingreso necesita 00:25:15
ya que además se verifique algo con la Policía Nacional, 00:25:16
estás haciendo un ingreso en una cuenta que no puedes, 00:25:20
el main no se toca, el main se queda tal cual. 00:25:23
El que se tocaría es este. 00:25:26
Entonces tú vendrías aquí y dirías, cuidado, 00:25:28
pero esto ya sería un tema del cajero, no del que hace el usuario, 00:25:30
no del que hace el programa principal. 00:25:34
Entonces, uy, cuidado que me ha dicho que tengo que verificar 00:25:37
por cada ingreso, tengo que verificar algo. 00:25:40
Pues tú haces aquí la verificación, lo que sea, 00:25:43
y se queda todo aquí encerrado 00:25:45
el programa principal 00:25:47
seguirá llamando a ingresar 00:25:49
y ahí no hay que tocar nada, no hay que cambiar nada 00:25:51
¿vale? pues 00:25:53
por esto es por lo que se hace 00:25:55
programación orientada a objetos, entre otras cosas 00:25:57
por esto, porque si no 00:25:59
perdona, si no 00:26:01
si yo pongo aquí el chorizo 00:26:03
del ingreso, lo planto todo aquí 00:26:05
si de repente me dicen, cuidado que 00:26:07
cuando haces ingresos además tienes que hacer esto 00:26:09
pues me tengo que ir al main, buscar 00:26:11
en el case, empezar aquí a meterlo todo 00:26:13
pues no, es mucho más complicado, sin embargo ahí 00:26:15
tengo la clase cuenta, me voy directamente 00:26:17
a cuenta, porque está ahí colocada, aquí tengo 00:26:19
un main enorme y tengo que empezar a ver dónde está eso 00:26:21
¿vale? dime 00:26:23
¿y si en el método de ingresar 00:26:24
haces lo de que te devuelvan la cantidad? 00:26:26
claro, entonces, ahora mismo, tal y como 00:26:29
yo lo he llamado 00:26:31
tal y como yo lo he llamado, está bien 00:26:32
llamado y el ingreso se hace 00:26:35
lógicamente, pero 00:26:37
me devuelve el nuevo valor 00:26:39
que yo lo estoy tirando a la basura 00:26:41
no pasa nada, pero lo tira a la basura 00:26:43
porque lo que importa es que 00:26:45
mi cuenta se ha quedado con el 00:26:47
nuevo ingreso, eso es lo que cuenta 00:26:49
pero que yo quiero usar ese valor para poner un 00:26:50
mensaje de su nuevo saldo 00:26:53
es no sé qué, pues estupendo 00:26:55
pues estupendo 00:26:57
porque entonces podríamos hacer 00:26:59
esto de aquí, su nuevo 00:27:00
saldo es 00:27:07
y ahora le pasamos esto 00:27:09
al SISO 00:27:11
para que además de ejecutarlo 00:27:12
lo muestre 00:27:14
bueno, pues nada 00:27:16
a ver si le pongo un espacio ahí 00:27:26
ahora sí 00:27:30
vale 00:27:32
pues ahora 00:27:39
¿qué estoy haciendo? 00:27:41
al método lo estoy llamando igualmente 00:27:43
luego el ingreso se va a hacer sí o sí 00:27:45
lo estoy llamando igualmente, el ingreso que es lo que importa 00:27:47
se va a hacer, pero además 00:27:49
el valor de retorno que me está entregando 00:27:51
que es el nuevo saldo 00:27:53
se lo estoy pasando yo al system out 00:27:55
luego además el system out me va a mostrar 00:27:57
la cantidad resultante que me ha devuelto 00:27:59
esta llamada 00:28:02
bueno, pues ya está, me muestra la información 00:28:03
y ya está, no pasa nada, mejor 00:28:06
lo que importa 00:28:08
es que se ha llamado a ingresar 00:28:10
me da igual que se haya llamado a ingresar dentro de un SISO 00:28:12
o se haya llamado fuera 00:28:14
me da igual, se ha llamado a ingresar 00:28:16
y ese ingresar 00:28:18
es el que ha ejecutado 00:28:20
el incremento 00:28:22
¿vale? 00:28:25
¿está claro? 00:28:30
Claro, si nosotros tuviéramos la otra versión, la versión en la que no devuelvo nada, imaginaos que aquí no devuelvo nada y no devuelvo la nueva cantidad, no la devuelvo. Pues porque no quiero devolverla. Hago el incremento y ya está y no lo devuelvo. 00:28:31
Pues 00:28:49
Si yo hago eso 00:28:51
Si yo hago eso 00:28:53
Esto habría dejado de tener sentido 00:28:58
Lógicamente 00:29:01
Porque ahora ya cuenta.ingresar 00:29:02
Me hace el incremento 00:29:05
Pero como no me devuelve nada 00:29:07
El system out me dice 00:29:08
Perdóname, tienes que pasar algo 00:29:10
No me estás pasando nada 00:29:11
Porque este devuelve un void 00:29:13
Y el void es nada 00:29:14
Entonces le estamos pasando nada al system out 00:29:16
No se puede 00:29:19
entonces él diría, perdona, tienes que pasarme algo 00:29:19
y esto no devuelve nada 00:29:22
¿vale? 00:29:24
pero con esta versión en la que devuelve un valor 00:29:28
pues mira, nos encaja 00:29:31
uy, que feo esto 00:29:32
siempre 00:29:34
es bueno en principio 00:29:38
usar los 00:29:40
si el valor de retorno 00:29:43
no lo necesito, porque el método hace otras cosas 00:29:44
pues ya que se me ha quedado ahí 00:29:47
una posibilidad, usarlo 00:29:49
para devolver cosas, que además informen al usuario. 00:29:50
Por ejemplo, un boolean, true, 00:29:54
si se pudo hacer el ingreso o false, si no. 00:29:56
Para dejarlo desocupado, 00:29:59
pues usémoslo para devolver cosas 00:30:01
que luego el usuario puede usar o no puede usar. 00:30:03
Porque que yo aquí ponga aquí un double 00:30:05
y luego lo devuelva, 00:30:07
no significa que luego aquí tenga que usarlo obligatoriamente. 00:30:10
Puedo llamar a cuenta e ingresar o no, 00:30:14
pero al menos le doy esa posibilidad 00:30:16
al programa que me llama para usarlo. 00:30:17
entonces siempre es buena idea 00:30:19
ya que está de sobras 00:30:21
este valor, pues mira 00:30:23
usarlo para algo y si el usuario quiere 00:30:25
pero claro, todo eso yo tendría que dejarlo muy bien 00:30:27
documentado 00:30:29
todavía no habéis empezado lógicamente con las dos horas 00:30:30
que tenéis dentro de los de desarrollo, documentación 00:30:33
en javadoc y nada de eso 00:30:35
vale 00:30:37
bueno, es que claro, tenéis poco tiempo 00:30:40
pero dejamos un segundín que termine 00:30:43
claro, cuando uno hace un método 00:30:45
lo ideal 00:30:47
es que comente bien 00:30:49
lo que hace 00:30:51
que dé explicaciones 00:30:53
de lo que sirve cada parámetro 00:30:54
lo que devuelve, qué significa 00:30:56
eso es fundamental, que lo documente bien 00:30:58
porque luego 00:31:01
el desarrollador que va a usar el método 00:31:02
no se quiere meter aquí 00:31:05
a ver qué hace y qué es cada cosa 00:31:06
lo que quiere es ver la documentación 00:31:09
y decir, ah vale, este método me interesa 00:31:11
hace justo lo que quiero 00:31:13
pues entonces lo uso 00:31:14
y no se va a meter aquí 00:31:17
a ver esto 00:31:19
entonces, muy rapidísimo 00:31:19
esto lo veréis en más detalle si os 00:31:23
da tiempo en entornos de desarrollo 00:31:25
vosotros ya sabéis 00:31:27
y ahora Mario no me ha olvidado, me pregunta 00:31:29
lo que me vas a preguntar, ya sabéis que 00:31:31
en general comentar es así 00:31:33
o así si es un comentario 00:31:34
multilínea 00:31:37
lo que sea, bueno, uno puede comentar 00:31:39
y en cualquier momento, porque hay comentarios, se acabó 00:31:41
pero hay unos comentarios especiales 00:31:43
que son para documentar 00:31:45
código, porque 00:31:47
que son comentarios que sirven de entrada a aplicaciones 00:31:48
que luego, como la de Javadoc, que generan unos HTML estupendos. 00:31:51
Eso es lo que se supone que veis en entornos de desarrollo. 00:31:55
Entonces, esos comentarios siguen un formato especial, 00:31:57
que son la barra, dos asteriscos en lugar de uno, 00:32:02
dos asteriscos, y si le dais al Enter, 00:32:05
ya os aparece esto directamente 00:32:08
antes del método donde lo estáis haciendo. 00:32:10
Y aquí es buena idea explicar, porque aquí dices, 00:32:14
para cantidad que es cantidad la cantidad a ingresar retún que me estás devolviendo retún 00:32:17
pues devuelvo la cantidad el saldo actualizado y aquí se explicaría este método e ingresa una 00:32:25
cantidad y ahí uno cuenta 00:32:44
su rollo, ¿vale? 00:32:46
Entonces esta documentación de aquí 00:32:48
es magnífica 00:32:50
porque ahora ya, ¿qué es lo que ocurre? 00:32:51
¿Vale? Fijaos 00:32:58
en cuanto yo he puesto 00:32:59
mi cursor en ingresar, ¿qué me ha salido? 00:33:00
Toda la explicación. 00:33:03
Este método ingresa una cantidad. 00:33:05
Cantidad es la cantidad que ingresar. 00:33:07
Me devuelve el saldo actualizado. 00:33:09
Entonces el que está desarrollando 00:33:11
y llama a este método 00:33:12
pum, le aparecen todas 00:33:14
las explicaciones que yo estoy dando 00:33:17
entonces es buena idea 00:33:19
no es que sea buena idea, es 00:33:21
crucial cuando uno desarrolla 00:33:22
clases 00:33:25
los métodos de esas clases documentarlos 00:33:26
de esta manera, porque los que nos usen 00:33:29
no se van a meter en nuestro código 00:33:31
a averiguar lo que hace, van a esperar 00:33:33
que se lo expliquemos 00:33:35
pues se explica con ese tipo de comentarios 00:33:36
¿vale? 00:33:39
nosotros no vamos a hacer cada 00:33:42
método que hagamos, no vamos a estarlo documentando 00:33:43
porque es un rollo, pero bueno 00:33:45
que conozcáis esto 00:33:47
vale, esto 00:33:49
venía en relación a la pregunta de si es bueno 00:33:51
que devuelva o no devuelva, pues 00:33:53
depende de la situación en la que estés 00:33:55
y si lo tienes 00:33:57
inutilizado, mejor usarlo 00:33:59
pero siempre documenta 00:34:00
para que quien lo usa sepa eso que estás 00:34:03
devolviendo que es, y sepa si le 00:34:05
interesa usarlo, no le interesa usarlo, etc 00:34:07
vale 00:34:09
Vale, pues ingresar ya habría acabado. 00:34:10
Cantidad, su nuevo saldo es esto y se acabó. 00:34:15
Ahora, ¿qué es lo siguiente que puede hacer alguien en el cajero? 00:34:19
Sacar dinero. 00:34:23
Vale, pues sacar dinero, de nuevo, no tiene sentido que hagamos aquí todo el código para sacar dinero, 00:34:25
si te has quedado a cero, patatín, patatán. 00:34:30
Vamos a hacerlo, como es algo que se hace con los objetos cuenta, vamos a hacerlo aquí. 00:34:33
y el método sacar dinero 00:34:37
nos dicen aquí que 00:34:39
retira una cantidad, pero si 00:34:40
restando se queda negativa 00:34:43
no dejes el saldo en negativo, déjalo en cero 00:34:45
vale 00:34:48
pues hala 00:34:49
en principio este lo mismo 00:34:50
en principio no devolvería nada 00:34:57
porque 00:34:59
su efecto se queda en la cantidad 00:35:01
del objeto, se queda aquí 00:35:04
luego no tiene por qué devolver nada 00:35:05
y aquí que se retira 00:35:07
pues se retira una cantidad 00:35:12
Y ahora, ¿cuál es el problema? 00:35:14
Pues lo que se actualiza es esta cantidad de aquí 00:35:21
Esta es la que se actualiza 00:35:24
¿Y qué se le da? 00:35:26
Depende, la resta de la cantidad original menos esta 00:35:28
Si es mayor que cero o si no cero 00:35:33
Luego esto es un ternario, entonces 00:35:35
Un ternario que depende 00:35:38
Si dispunto cantidad menos la que voy a restar 00:35:40
menos cantidad 00:35:44
esto es mayor que cero 00:35:46
si es mayor que cero, estupendo 00:35:49
entonces la nueva cantidad 00:35:53
la actualizo a 00:35:54
descantidad menos cantidad 00:35:56
¿vale? muy bien 00:35:58
y si no 00:36:00
si no es mayor que cero 00:36:02
o es negativa, pues a cero 00:36:04
¿vale? es lo que me dice el método 00:36:06
si el resultado de la retirada 00:36:09
es positivo, pues quédate con ese 00:36:12
resultado, si 00:36:14
es negativo, da 00:36:16
cero, y aquí también 00:36:18
podríamos decir, oye, este valor 00:36:24
de retorno, voy 00:36:26
vale, ya que está sin usar 00:36:28
ya que está sin usar, voy 00:36:30
a usarlo para meter en esa caja 00:36:32
yo te doy una caja con el saldo actualizado 00:36:34
si quieres lo usas 00:36:36
y si no, no, me da igual 00:36:38
porque el resultado está hecho 00:36:40
el resultado está hecho, que es cambiar esta 00:36:42
propiedad, el resultado está hecho 00:36:44
Venga, pues ya que hemos seguido ese criterio 00:36:46
En el anterior, vamos a seguir 00:36:49
Vamos a seguirlo en este 00:36:50
Ya que hemos usado ese criterio, vamos a seguirlo aquí 00:36:52
Vamos a seguirlo aquí 00:36:55
Y ya de paso 00:36:58
Ya de paso lo devolvemos 00:37:00
Para que el usuario lo verifique o lo que sea 00:37:14
Mario, te iba a preguntar algo 00:37:16
Para dis es para referirte 00:37:17
El objeto en el que estoy 00:37:24
Con lo cual cantidad sería 00:37:26
La propiedad cantidad del objeto 00:37:28
Esta 00:37:30
Si yo no pongo aquí el dis 00:37:31
si no lo pongo 00:37:34
entonces se interpreta 00:37:35
que es este parámetro 00:37:38
porque el problema es que se llaman igual 00:37:39
el parámetro 00:37:41
pues entonces 00:37:50
tienes una ambigüedad que tienes que resolver 00:37:55
obligatoriamente con el dis 00:37:57
dis se refiere a la propiedad 00:37:58
y no dis 00:38:03
no poner nada se refiere a este 00:38:04
¿vale? con lo cual aquí 00:38:07
hay que ponerlo, no hay alternativa 00:38:11
si no lo ponemos, este método 00:38:13
no estaría haciendo lo que hay que hacer 00:38:15
porque estaría 00:38:16
si yo no pongo el dis, estaría 00:38:19
a este mismo parámetro sumarle el mismo 00:38:21
no es eso lo que queremos 00:38:23
queremos al de arriba 00:38:24
¿vale? con lo cual aquí hay que poner dis obligatorio 00:38:26
no tenemos elección 00:38:29
¿vale? 00:38:30
cuando no hay ambigüedad y el parámetro 00:38:32
no se llama igual 00:38:35
no hace falta que pongas el dis porque ahí no hay alternativa 00:38:36
te vas a referir siempre al de arriba 00:38:39
vale 00:38:40
vale, venga, pues paramos entonces 00:38:41
por lo que veo 00:38:45
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:
2
Fecha:
6 de diciembre de 2025 - 11:25
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
145.00 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid