Saltar navegación

Prog2223 visibilidad - 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 16 de diciembre de 2022 por Stefano C.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, todo lo que decís a partir de ahora será grabado 00:00:00
Y asumimos que me dais vuestro consentimiento para que sea grabado 00:00:06
Vale, entonces, decíamos la última vez que estamos hablando de organización de código 00:00:11
Que existían los packages, vale, que permiten pillar varias clases 00:00:16
Y hacer una estructura, un conjunto, vale, y tenerlos juntos en un paquete de clases 00:00:21
Por ahora es solo para organización de código 00:00:29
Luego a lo mejor usos más avanzados lo veremos más en el futuro 00:00:33
Lo que sí me interesa es el concepto de overloading 00:00:35
Existen dos conceptos en un cierto sentido relacionados 00:00:39
Pero no, uno es overload, otro es overwrite 00:00:44
Pero el overwrite lo veremos más adelante 00:00:47
Por ahora es el overload 00:00:50
Cuando se habla de overloading, que ya lo hemos visto anteriormente 00:00:51
rápidamente es que un mismo método se puede sobrecargar eso quiere decir cuando tengo un 00:00:55
método que tiene un determinado nombre el cálculo área el área lo puedo sobrecargar y hacer que de 00:01:01
este método área haya varias versiones vale haya un área que no pilla nada de parámetros hay un 00:01:08
área que pilla el lado hay un área que pilla el lado en la altura hay un área que pilla al lado 00:01:15
altura y no sé otra cosa vale el concepto es que el mismo método llamado igual puede tener 00:01:21
varias versiones que se diferencian en el número y tipo de parámetros que recibe es fundamental 00:01:29
que cada método de este tipo de cada sobrecarga de este método tenga un número o un número 00:01:39
diferente, lo pone aquí, o el número de parámetros de entrada son diferentes 00:01:47
o el tipo de algunos de los parámetros son diferentes 00:01:51
o una combinación de los dos anteriores 00:01:55
el concepto es que cuando yo llamo ese método y le paso 00:01:58
ciertos parámetros, el compilador, el 00:02:03
Java Internet Machine o quien lo ejecute, tiene que saber en ese instante 00:02:07
cual de las varias versiones, cual de las varias 00:02:11
métodos sobrecargados voy a utilizar 00:02:14
tiene que ser seguro 00:02:17
entonces si yo tengo un método 00:02:19
que tiene int e int 00:02:21
y hace una cosa 00:02:23
y otro método que tuviera int e int 00:02:25
lo mismo y tiene que hacer una cosa distinta 00:02:27
no puede funcionar 00:02:29
porque cuando a mi me pasan 3 y 7 00:02:30
yo no sé si usar la primera o la segunda 00:02:33
versión ¿vale? asumiendo que 00:02:35
tenga el mismo nombre 00:02:37
tengo un ejemplo 00:02:38
vamos a hacer un ejemplo 00:02:40
Básico 00:02:43
Imaginémonos que yo tenga 00:02:45
Public 00:02:51
Void 00:02:59
Método 00:03:01
Así, ¿vale? 00:03:02
Que hace algo 00:03:05
Yo puedo sobrecargar este método 00:03:06
Diciendo, vale 00:03:12
Hay otro método que se llama 00:03:13
Igual, ¿vale? Pero pilla un entero 00:03:15
Algo 00:03:18
Al ser posible 00:03:21
Usando X 00:03:25
Es muy mala programación 00:03:27
Tener dos métodos que hagan 00:03:32
Cosas distintas y se llaman igual 00:03:34
Pero a uno le pongo Y 00:03:36
Para poder sobrecargar y luego X no lo usa aquí dentro 00:03:37
Si te lo paso es porque 00:03:40
Tú hagas algo 00:03:42
Entonces, puedo crear 00:03:42
De estos cuanto me da la gana 00:03:46
Siempre y cuando o cambia 00:03:47
El tipo 00:03:49
O cambiar el número de parámetros 00:03:50
¿Vale? Por ejemplo 00:03:57
Mientras que yo cambie 00:03:58
Número de parámetros 00:04:15
O tipo de parámetros 00:04:19
Puedo hacer lo que me da la gana 00:04:21
Y meter el mismo método 00:04:23
Utilizando también 00:04:25
La idea es que si se llaman igual 00:04:27
Es porque hacen algo bastante parecido 00:04:29
¿Vale? 00:04:32
Calcular área, calculará una área 00:04:33
¿Vale? 00:04:35
Esto lo hará del método del mismo objeto 00:04:36
Este de aquí del mismo objeto 00:04:41
Pero utilizará este x para algo 00:04:43
No lo sé, ¿vale? 00:04:45
Es un ejemplo abstracto 00:04:47
Esto utilizará el double 00:04:48
Esto utilizará el double o el int 00:04:50
No lo sé, ¿vale? 00:04:51
Pero lo tiene que utilizar 00:04:52
Y si se llaman iguales 00:04:53
Porque son el mismo método 00:04:54
Es una sobrecarga o un método 00:04:56
No tendría sentido que esto haga una cosa 00:04:58
Y esto haga una cosa 00:05:00
Que no tiene nada que ver con el otro 00:05:01
¿Vale? Entonces se llaman los distintos 00:05:03
Y ya está 00:05:04
Si esto calcula la área y esto calcula el perímetro 00:05:05
Pues se llama la cálcula de área y la cálcula de perímetro 00:05:08
No hagas que se llaman los dos cálcula 00:05:10
Y uno a cálcula de área y uno a cálcula de perímetro 00:05:12
Es mala programación 00:05:14
¿Sí? ¿Se entiende? 00:05:16
Lo que no puede hacer 00:05:18
Es sobrecargar así 00:05:19
Ya está 00:05:23
Esto no funciona bien 00:05:28
¿Vale? Porque cuando yo 00:05:30
En algún lado llamo 00:05:32
Método, objeto 00:05:34
¿Vale? Porque no es estático 00:05:36
Objeto punto método 00:05:38
De tres 00:05:39
De dos 00:05:42
¿Qué voy a ejecutar? 00:05:42
¿Este código o este código? 00:05:47
No se puede saber 00:05:51
Porque aquí me están pasando un entero 00:05:52
Entonces 00:05:53
Hay este método aquí que pilla un entero 00:05:54
Este método aquí que pilla un entero 00:05:56
Uno de los dos me vale 00:05:58
Pero es que no sé cuál 00:05:59
Y si no es determinista la elección 00:06:01
Pues no me vale 00:06:04
En cualquier momento 00:06:05
El procesador o quien por él 00:06:08
Tiene que saber que va a ejecutar 00:06:10
Y así tú le estás haciendo una cosa ambigua 00:06:12
Hay dos opciones 00:06:15
Y podría elegir cualquiera de las dos 00:06:16
Porque a cualquiera de las dos le vale 00:06:18
Eso no se puede hacer 00:06:19
En un cierto sentido 00:06:21
Hacemos lo mismo con los 00:06:26
Constructores 00:06:27
Son sobrecargados también 00:06:29
Porque puede tener un constructor sin ningún parámetro 00:06:32
Un constructor 00:06:34
Con varios parámetros 00:06:35
Un constructor con un parámetro solo 00:06:37
Y el resto veo que hago, etc, etc 00:06:39
¿Dudas? 00:06:41
Vale 00:06:45
Tened en cuenta que lo que devuelve 00:06:45
No es parte 00:06:50
De la sobrecarga, es decir 00:06:52
Si esto dice, esto devuelve void 00:06:53
Esto devuelve int, son distintos 00:06:55
No, porque es lo mismo 00:06:57
Cuando yo lo llamo 00:06:58
No sé si este método de aquí que recibe un intero 00:07:00
Es este o este de aquí 00:07:03
Independientemente de que luego devuelva o no devuelva 00:07:04
¿Sí? 00:07:07
Entonces, digamos que para la sobrecarga lo que cuenta es 00:07:08
El número de parámetros y el nombre 00:07:11
Porque si son nombres distintos ya no está sobrecargando 00:07:14
Y el tipo de parámetros y el nombre de parámetros 00:07:17
¿Vale? 00:07:21
Lo que viene a ser lo que se llama, se conoce como firma 00:07:22
¿Vale? 00:07:25
La firma de un método es su nombre y los parámetros que recibe 00:07:27
Y tiene que ser única 00:07:31
Todo esto, tanto porque ya estamos 00:07:33
Es el prototipo 00:07:38
Cuando yo hablo del prototipo 00:07:41
De un método, es este de aquí 00:07:42
Si es público, privado 00:07:44
Lo que sea, lo que devuelve 00:07:47
Como se llama y los parámetros que pide 00:07:49
Prototipo 00:07:50
Este de aquí, en un cierto sentido 00:07:52
Sería la firma 00:07:54
Y se puede sobrecargar 00:07:55
Dudas 00:07:58
Creo que alguna vez lo hemos hecho 00:07:59
Con los constructores seguramente 00:08:04
con los métodos, no sé si hemos llegado 00:08:06
a hacer algún ejemplo, puede ser 00:08:08
con algún método de nombre y tal 00:08:10
lo de anónimo 00:08:12
por ejemplo, vale 00:08:13
y ya está 00:08:15
entonces, luego, bueno, se ha empezado 00:08:18
la creación de código 00:08:20
organizarse, los paquetes 00:08:21
pueden estar un paquete dentro de un paquete 00:08:24
dentro de un paquete, es algo parecido a lo que 00:08:26
funciona en un sistema operativo con las carpetas 00:08:28
de hecho 00:08:31
los paquetes que yo creo, luego 00:08:32
en SRC, en la carpeta SRC 00:08:34
Se crean como carpetas ahí dentro 00:08:36
Pero cuando me quiero referenciar a alguno de ellos 00:08:38
No uso la barra como en el sistema operativo 00:08:41
Sino uso los puntos 00:08:44
Cuando nosotros hacemos import java.util.scanner 00:08:44
Lo que estamos haciendo es pillar el paquete java 00:08:50
Entrar en el subpaquete útil 00:08:53
Y dentro del subpaquete útil 00:08:56
Si pongo asterisco pillo todo el subpaquete 00:08:57
Si pongo scanner pillo solo la clase scanner 00:08:59
Por ejemplo, ¿vale? 00:09:02
Pero esto lo veremos en un futuro 00:09:03
Y también está la variable classpath que la hemos configurado al principio 00:09:05
Hemos ya hablado un poquito de esto 00:09:10
Pero estas cosas luego son muy genéricas 00:09:11
Lo veis esto que tanto viene en el vídeo 00:09:15
Pero luego cuando sirven de verdad ya nos pondremos y profundizaremos allí 00:09:18
Por ahora no 00:09:25
Lo que sí me interesa ahora y a un poquito hablar 00:09:26
Es lo que se llama encapsulación y visibilidad 00:09:29
Es decir, las palabritas está public, protected, packaged, private, ¿vale? 00:09:32
Nosotros por ahora hemos casi siempre utilizado en los ejemplos que hemos hecho public o nada, ¿vale? 00:09:38
Aquí public, algunos ejemplitos que hemos puesto no hemos puesto nada, ¿vale? 00:09:48
Pero no sabemos qué quiere decir, ¿vale? 00:09:52
Entonces, la idea es qué visibilidad tiene este elemento de código que yo voy a crear, ¿vale? 00:09:55
Public, private se puede poner en clases, se puede poner en variables, se puede poner en métodos, ¿vale? 00:10:06
Es decir, que nosotros donde hemos visto public, para hacer un ejemplo aquí, lo hemos visto cuando declaramos una clase, 00:10:14
clase pública, cuando declaramos 00:10:20
por ejemplo un 00:10:22
constructor, cuando declaramos 00:10:23
un método, cuando construyamos 00:10:26
una 00:10:28
variable, la podemos declarar public 00:10:29
también, o nada, o lo que sea, ¿vale? 00:10:32
¿Más public entonces? 00:10:34
No, no, no, son dos cosas distintas, ahora 00:10:36
lo vamos a ver, ¿vale? Pero aquí puedo poner 00:10:38
public int ancho 00:10:40
o int ancho, o protect int 00:10:42
ancho, o private int ancho 00:10:44
¿vale? Es el modificador 00:10:46
que se pone aquí delante 00:10:48
Y repito, se puede poner en clases, variables, también en constructores y métodos 00:10:49
Probablemente en otras cosas, lo veremos en el futuro 00:10:56
Por ahora estas cosas aquí 00:10:59
¿Y para qué sirven? 00:11:00
Sirven para dar visibilidad a esa entidad, a ese elemento 00:11:02
Es decir, de dónde se puede ver ese elemento 00:11:06
Dependiendo de la palabra que pongo, podré acceder a ese método, a esa variable 00:11:10
Desde más o menos 00:11:16
Otros sitios 00:11:20
Por ejemplo, es más fácil de todo 00:11:22
Public, si yo pongo public 00:11:26
Cualquiera puede acceder 00:11:27
A esa variable o a ese método 00:11:30
Y con cualquiera quiero decir 00:11:31
Código dentro de esta variable 00:11:33
De esta clase 00:11:36
O código desde otra clase 00:11:37
¿Sí? 00:11:39
Esto, por ejemplo 00:11:41
Creo que aquí tengo un problema 00:11:42
Pongamos esta cosa aquí 00:11:45
Aquí son dos clases distintas 00:11:48
¿Sí? 00:11:50
Clase de rectángulo y la clase de rectángulo área 00:11:51
Si yo este de aquí lo declaro como public int largo 00:11:53
Desde aquí 00:11:57
Puedo hacer tranquilamente rec1.largo 00:11:58
¿Sí? 00:12:03
Porque esta variable es pública 00:12:07
Se puede acceder desde cualquier clase 00:12:09
Si alguien crea un rectángulo 00:12:11
Está autorizado a hacer 00:12:14
Rec1.largo 00:12:16
¿Vale? 00:12:18
En otra clase, si vale, pero aquí acedo 00:12:19
A este objeto que he creado 00:12:21
Y a su variable, porque es pública 00:12:23
Si este tiene 00:12:25
Public quinta área, por ejemplo 00:12:29
Yo puedo llamar 00:12:31
Rectángulo1.area desde otra clase 00:12:32
Tranquilamente, sin problemas 00:12:35
¿Vale? Cuando es público 00:12:36
Puede acceder a sus métodos públicos 00:12:38
O a sus variables públicas 00:12:41
Desde cualquier otra clase 00:12:43
Que haya creado un objeto de ese tipo 00:12:45
O que haya utilizado un método estático de ese tipo 00:12:47
¿Sí? Vale 00:12:50
Vamos restringiendo 00:12:52
Es decir 00:12:55
Si no es public 00:12:56
Quiere decir que no todos pueden acceder 00:12:58
¿Vale? 00:13:01
El siguiente paso es protected 00:13:02
Lo pongo en rojo 00:13:05
Porque para entender protected 00:13:07
Nos falta un concepto 00:13:10
Que es la herencia 00:13:11
Que nosotros no sabemos 00:13:12
entonces, mientras que no sabemos la herencia 00:13:14
protected es como que 00:13:16
¿vale? pero os lo pongo aquí 00:13:18
la definición en rojo para que 00:13:20
quitemos el rojo cuando luego sabemos la herencia 00:13:22
¿vale? y es lo siguiente 00:13:24
yo puedo acceder a esta 00:13:26
variable o a este método 00:13:28
solo desde clases que 00:13:30
o heredan 00:13:33
que es lo que no entendemos 00:13:34
¿vale? o son del mismo 00:13:36
paquete 00:13:39
es decir, si cuando creo las variables 00:13:39
Creo un paquete que puede ser el default package 00:13:42
O creo un paquetito que se llama operaciones 00:13:45
Y allí dentro hay varias clases 00:13:50
Cualquiera de estas clases puede acceder a una variable 00:13:52
O a un método declarado como protected 00:13:56
Si yo tengo dos paquetes 00:13:59
Y en el paquete B 00:14:03
Creo un objeto que está en el paquete A 00:14:05
E intento acceder a una variable protected 00:14:12
Del paquete A 00:14:15
Me va a decir no 00:14:16
Porque no estás en el mismo paquete 00:14:17
Si no estás en el mismo paquete 00:14:19
No puedes acceder a eso 00:14:21
Tampoco 00:14:24
Físicamente entonces los directorios 00:14:27
Tienen que estar 00:14:31
Al mismo nivel o por debajo 00:14:31
Quien define donde estoy 00:14:33
Es la primera línea 00:14:36
Cuando yo creo un paquete 00:14:37
Añado en la primera línea 00:14:39
Package y el nombre del paquete 00:14:41
Si las dos clases tienen el mismo package definido, pues son del mismo paquete, por lo tanto se pueden ver entre ellos si son protected, ¿vale? 00:14:43
Si en vez tienen un package distinto, pues entonces no están en el mismo paquete y si es protected no accede, ¿vale? 00:14:52
Recuerdo que protected es o hereda, ¿vale? O tiene una relación especial que nosotros no hemos visto todavía, el extend, para quien lo ha visto el año pasado, o está en el mismo paquete. 00:14:59
Entonces se pueden ver, si no, no 00:15:12
¿Sí? 00:15:13
La otra opción, package 00:15:15
Es lo mismo que protected 00:15:17
Pero sin herencia 00:15:19
O sea, si están en el mismo paquete 00:15:20
¿Vale? A nosotros por ahora 00:15:23
Estas dos cosas son iguales porque no sabemos que es la herencia 00:15:25
¿Vale? Entonces lo entenderemos 00:15:27
Por ahora nosotros usamos public package 00:15:29
O private 00:15:31
¿Sí? 00:15:32
Creo 00:15:36
Que siempre se me olvida 00:15:37
Que si no pongo nada 00:15:38
Por defecto es protected 00:15:40
Entonces cuando no ponemos 00:15:42
Ningún modificador 00:15:45
Él asume que es protected 00:15:46
Herencia y mismo paquete 00:15:48
¿Sí? 00:15:51
Aún así nosotros los ejemplos que hacemos ahora 00:15:52
Que trabajaremos ahora 00:15:54
A principio sobre todo 00:15:56
Utilizaremos public y private ¿Vale? 00:15:58
Para ir a los extremos 00:16:00
Luego más adelante cuando veremos un poquito 00:16:02
Las cosas más complejas pues a lo mejor 00:16:04
Ya empezamos a hilar más fin 00:16:05
¿Sí? 00:16:07
Y el último, el más restritivo de todos es private 00:16:08
El private solo se puede acceder desde la misma clase 00:16:12
¿Vale? 00:16:17
Son variables que yo accedo solo desde esta clase 00:16:19
No puedo acceder desde fuera 00:16:22
Eso quiere decir que si yo aquí en rectángulo 00:16:24
Pongo que largo es private int largo 00:16:27
Desde aquí no puedo hacer recuno punto largo 00:16:32
Me da error 00:16:36
Porque no estoy en la misma clase 00:16:37
Hasta si estuviera en el mismo paquete 00:16:39
¿Sí? 00:16:41
Clipset 00:16:45
Vamos a probar un poco 00:16:45
Hacemos un ejercicio sencillo 00:16:58
Donde probamos estas cosas 00:17:05
¿Vale? 00:17:07
Vamos a crear un par de clases 00:17:09
¿Vale? 00:17:19
La primera clase que creo es la clase cuenta 00:17:20
Que no será 00:17:23
Con el 00:17:27
Me la he puesto en geometría 00:17:29
Yo no la quiero en geometría 00:17:31
La pongo en otro paquete 00:17:33
Y luego creo 00:17:34
Luego después a lo mejor jugamos con los paquetes 00:17:39
¿Vale? 00:17:41
Otra clase que es main cuenta 00:17:42
Para usarla 00:17:45
¿Vale? 00:17:47
Entonces, ¿qué es mi clase cuenta? 00:17:49
Pues mi clase cuenta 00:17:52
Representa una cuenta de banco 00:17:53
muy sencilla vale porque en realidad como la demo no es muy segura vale entonces una cuenta 00:17:54
del banco que tiene propiedades de la cuenta del banco qué es el número un inter un string 00:18:02
que queremos hacer si yo uso otra letra también puede poner string si pongo solo solo numérico 00:18:14
Podría pensarlo como un int 00:18:21
Para tener en cuenta que tiene poco sentido 00:18:23
Por ejemplo, sumar entre ellas dos cuentas bancarias 00:18:26
Entonces no es un int 00:18:28
Es siempre un código 00:18:29
Int 00:18:30
Num cuenta 00:18:32
¿Qué más? 00:18:35
Saldo 00:18:40
Int saldo 00:18:41
Nosotros gastamos solo euros 00:18:43
Las céntimos no nos interesa 00:18:45
String titular 00:18:46
¿Vale? 00:18:50
y lo dejamos así, por ahora 00:18:53
luego después a lo mejor le añadimos 00:18:56
métodos de aumentar 00:18:58
disminuir, cosas por el estilo 00:18:59
entonces ahora yo tengo 00:19:01
el main cuenta, que es lo que utiliza esta cuenta 00:19:03
¿qué hago? me creo 00:19:06
un objeto 00:19:07
cuenta 00:19:08
¿sí? entonces 00:19:11
cuenta 00:19:13
mi cuenta 00:19:14
es igual a new 00:19:16
cuenta, por defecto tiene 00:19:19
¿Cómo se llama esto? 00:19:22
Un constructor por defecto 00:19:25
¿Vale? Me he creado un objeto 00:19:28
¿Sí? Y ahora tendrá 00:19:29
Estas cosas aquí 00:19:31
Y yo puedo hacer tranquilamente 00:19:33
Mi cuenta.titular 00:19:35
Es igual a yo 00:19:38
Y mi cuenta.sueldo 00:19:41
Saldo 00:19:48
Saldo es otra cosa 00:19:49
calderilla 00:19:54
lo que tenemos todos en nuestro 00:20:00
bolsillo y mi cuenta 00:20:02
punto 00:20:05
que es, no mi cuenta 00:20:06
es igual a 00:20:08
vale 00:20:12
estamos todos felices 00:20:15
todos nos fiaríamos de un banco 00:20:18
que tenga cuentas 00:20:20
a la que cualquiera pueda acceder 00:20:22
Y cambiar lo que le da la gana 00:20:24
Y cambiar de titular 00:20:26
Y si yo veo que tú tienes más dinero 00:20:27
Pues te accedas a tu cuenta, te cambias el titular 00:20:29
Y se acabó 00:20:31
Ningún problema 00:20:32
Y tened en cuenta que esta la puedo haber hecho yo 00:20:33
Como banco 00:20:37
Pero ahora la está usando 00:20:38
Una aplicación externa 00:20:40
De otra persona 00:20:43
Que usa mi cuenta 00:20:44
Del banco 00:20:47
Algo para decir 00:20:48
Estoy simplificando bastante 00:20:49
Entonces, ¿cómo puedo evitar 00:20:51
Que este señor 00:20:53
Empezamos desde lo básico, ¿vale? 00:20:56
Me he asignado yo mi cuenta 00:20:58
Y yo decido, me gusta el 37 00:21:00
Pues mi cuenta es la 37 00:21:03
Ahí, ya está 00:21:04
Tiene sentido 00:21:05
¿Cómo se asocia? 00:21:08
¿Cómo se crean las números de cuenta 00:21:12
De un cuenta corriente? 00:21:14
¿Al actoreo? 00:21:16
Al actoreo no, vale 00:21:17
Yo supongo 00:21:22
Que tengan un orden 00:21:23
Si aquí hay mil cuentas 00:21:25
El siguiente que venga tendrá la cuenta 1001 00:21:27
¿No? No sé si habrá 00:21:30
Algo de 00:21:31
Una parte que luego hará un código hash 00:21:32
Para que sea un... 00:21:35
No lo sé, hipotetizamos que 00:21:37
Si yo en mi banco tengo mil cuentas, pues el siguiente 00:21:38
Tiene que tener 1001 00:21:41
¿Vale? Entonces no quiero que pueda 00:21:42
Él cambiársela. ¿Cómo lo hago? 00:21:45
Pues 00:21:52
¿Cómo impido a que este señor 00:21:52
Pueda acceder a su nueva cuenta? 00:21:55
El field 00:21:57
Cuenta, punto, no cuenta 00:22:14
Is not visible 00:22:16
No puedes 00:22:17
Oye, cuidado, eh, aquí yo no estoy tocando 00:22:18
Nada de seguridad informática 00:22:22
O muy, muy básica, vale 00:22:24
No es que los bancos están seguros 00:22:26
Porque han puesto private, vale 00:22:28
Hay mogollón de más 00:22:30
De seguridad informática 00:22:32
De criptografía 00:22:34
De controles y cosas por el estilo 00:22:35
Vale, pero de algo 00:22:38
Tenemos que empezar, vale 00:22:39
Ahora, no es tanto 00:22:41
Que yo he salvado mi cuenta 00:22:43
¿Vale? Cuanto he dicho 00:22:45
Oye, mira, esta variable de aquí 00:22:47
Es una variable crítica 00:22:49
Yo no quiero que la gente haga lo que le da 00:22:50
La gana con esta variable 00:22:53
Quiero que yo tenga el control sobre esta variable 00:22:55
¿Vale? Entonces 00:22:57
Te voy a decir que fuera de esta clase 00:22:59
Que es la que desarrollo yo 00:23:01
Nadie puede tocar este 00:23:03
En un cuento 00:23:05
¿Vale? He empezado por ahí 00:23:06
Ahora, pero tendré que hacer algo 00:23:08
con este en un cuenta 00:23:10
entonces, por ejemplo, me creo 00:23:12
un constructor 00:23:14
fijaos, sin parámetros 00:23:15
pero yo ahora quiero que 00:23:23
este en un cuenta, como 00:23:25
desde fuera yo no puedo crear 00:23:27
un objeto cuenta y luego darle un 00:23:29
número, porque ahora ya no puedo acceder 00:23:31
quiero que la gestión de 00:23:33
este número 00:23:35
se realice desde aquí 00:23:36
es decir, que 00:23:39
soy yo, que cuando alguien me 00:23:41
pide de crear un nuevo objeto cuenta 00:23:43
Le asigno un número nuevo 00:23:45
¿Cómo lo hago? 00:23:47
Estático 00:24:06
Yo pondría arriba un contador estático 00:24:07
¿Cuántas cuentas? 00:24:10
¿Os gusta? 00:24:31
Por ejemplo 00:24:43
Entonces si yo quería la 37, ¿no? 00:24:44
Vale 00:24:47
Cuenta, punto 00:24:48
¿Cuántas cuentas? 00:24:51
Bueno, 36 00:24:56
Y ahora 00:24:57
Me creo 00:25:01
Mi buena 00:25:02
Cuenta, ya está, ya tengo el 37 00:25:03
Solucionado 00:25:06
¿Eh? ¿Era lo que queríamos? 00:25:08
Sí 00:25:11
Claro 00:25:11
Creo que esto va por 00:25:12
Al principio 00:25:23
¿Sí? O sea 00:25:24
Me creo una variable de clase 00:25:28
Que pero existe solo aquí dentro 00:25:31
Y que nadie desde fuera 00:25:33
Pueda ir a toquetear 00:25:35
Porque si no, tengo un problema 00:25:37
Igualmente, ¿vale? 00:25:39
Y luego 00:25:40
Esta de aquí 00:25:41
Crea un método de crear cuenta 00:25:44
Que solo 00:25:46
Se toquetea esta cosa aquí dentro 00:25:47
¿Vale? Y esto 00:25:50
Entonces ahora lo que he hecho es 00:25:51
Que no es que esto no se pueda cambiar 00:25:54
O no se pueda estanciar 00:25:56
Pero se puede estanciar solo con un método 00:25:57
Con un constructor en este caso 00:26:00
Que he proporcionado yo 00:26:01
Entonces tú vas a pasar por mis controles 00:26:02
Si quieres modificar algo 00:26:06
No puedes elegir tú el número que le das 00:26:08
37 porque me da la gana, pues no 00:26:09
soy yo que te lo doy 00:26:11
vale, muy bien, fenomenal 00:26:16
entonces ahora tengo 00:26:19
mi cuenta 00:26:21
que cuando creo una cuenta 00:26:22
y luego creo otra cuenta 00:26:25
vale 00:26:27
mi cuenta 2 00:26:28
yo también 00:26:31
y con saldo 00:26:33
esta, un poco más 00:26:36
Tengo dos cuentas 00:26:39
Vale, fenomenal 00:26:41
Ahora quiero escribir un clásico 00:26:43
Soy la cuenta 37 00:26:44
Y tengo 00:26:47
Mi titular es 00:26:48
No sé quién 00:26:50
Y tengo dentro no sé cuánto 00:26:51
Venga 00:26:54
¿Cómo no? 00:26:55
Tengo mi cuenta 00:27:04
Mi cuenta 00:27:05
Punto 00:27:06
¿Cómo no? 00:27:09
¿Por qué no? 00:27:18
Porque es privado, claro 00:27:20
¿Vale? 00:27:22
No puede acceder al número de cuenta 00:27:22
Porque ahora está bloqueada aquí 00:27:24
Entonces, aquí tengo dos opciones 00:27:26
O esta cosa de aquí 00:27:30
Se la hago escribir 00:27:32
A la cuenta 00:27:34
Es decir, yo tendré 00:27:36
Por ejemplo, ¿eh? 00:27:38
Si hizo 00:27:41
Si hizo otra vez 00:27:42
Mi cuenta 00:27:48
Punto toString 00:27:51
vale que es esta cosa aquí pues lo voy a crear aquí y me creo en estos 30 y 00:27:53
pongo sin resultado es igual a nada resultado es igual al resultado más 00:28:15
no cuenta o algo así no más más la cuenta la cuenta más cuenta tiene más saldo a separar 00:28:25
Return res 00:28:57
Se enfada 00:29:01
What is this? 00:29:11
No, no, que no puede porque 00:29:23
No puedo reducir 00:29:25
La visibilidad del 00:29:27
Método heredados 00:29:29
Desde object 00:29:31
What? 00:29:33
Es que 00:29:39
Es que hagamos un paso atrás 00:29:40
Vale, luego volvemos aquí, vale 00:29:43
Imprime 00:29:45
Ahí, ya está 00:29:46
Ningún problema 00:29:48
Ya está, solucionado 00:29:49
¿Vale? Esto funciona 00:29:55
Pasa atrás, luego vuelve 00:29:57
¿Vale? Esto funciona 00:30:04
Vamos a verlo 00:30:06
Lazo 00:30:07
Hay errores 00:30:10
Por otro lado, sí, mira 00:30:12
La cuenta cero tiene 00:30:14
Tres millones solo 00:30:16
Tengo que hacer uno, casi se me acaba 00:30:18
¿Vale? Ok, o sea que 00:30:22
Esto funciona, ¿vale? Tiene su sentido 00:30:24
Llama lo que tiene que llamar 00:30:26
Y funciona 00:30:28
Todavía nos falta trabajo 00:30:29
La cuenta cero 00:30:32
No debería tener 3 millones 00:30:37
Claro, porque lo estoy cambiando en mi cuenta 00:30:38
Ahora le pongo 2 aquí 00:30:40
Y ya está, solucionado 00:30:43
¿Vale? 00:30:46
Pero es una buena observación 00:30:47
O sea que 00:30:51
El hecho de que haya puesto 00:30:52
El número de cuenta allí dentro 00:30:54
Y que luego pueda hacer lo que me da ganas con titulares saldo 00:30:57
Sigue siendo una cosa fría 00:31:00
¿Vale? Ahora lo vamos a mejorar un poco 00:31:01
¿Vale? Pero la idea es que 00:31:03
Esto funciona, oye, fijaos 00:31:05
¿Por qué esto funciona? 00:31:07
Porque esto es protected 00:31:12
¿Vale? Y es, me parece a mí 00:31:13
O es mismo 00:31:15
Package y mismo 00:31:17
Heredado 00:31:22
¿Vale? Heredado no sabemos que es, por lo tanto lo dejamos 00:31:24
Y si yo muevo 00:31:25
Me encuentro 00:31:27
en otro package se enfada vale se enfada porque cuenta no la ha importado de hecho automáticamente 00:31:29
pero no lo encuentra algo raro vamos a hacer otra cosa vamos a dejar hacerlo con refactor 00:31:43
a ver si me lo hace, refactor, move 00:31:53
en geometría, ok 00:31:57
eso es lo que quiero hacer, pero antes de llegar a que esto me haga 00:32:00
problemas, pues lo que estoy intentando hacer es mover 00:32:10
main cuenta en otro package, vale, y me dice 00:32:15
importa cuenta, pero no me lo encuentra, vale, entonces a ver 00:32:19
que tengo que hacer aquí, me creo otro package que sea 00:32:23
banco. Y ahora muevo esta cuenta a ver si así me lo ve. Muevelo dentro banco. Veis 00:32:27
que estoy importando banco.cuenta. Fenomenal. Entonces ahora estoy reutilizando un viejo 00:32:45
proyecto banco que tenía dentro cuenta 00:32:55
para mi proyecto 00:32:58
nuevo yo, geometría, donde uso 00:33:00
algo de esta cuenta 00:33:02
y fijaos que va todo bien 00:33:03
excepto estos y estos 00:33:05
me da problemas, vamos a ver que problemas me da 00:33:07
pero si hace 00:33:09
un momento si quedan visibles 00:33:18
¿por qué? 00:33:20
porque si voy a ver cuenta 00:33:24
no le he puesto nada adelante 00:33:26
perdón, saldo y titular no le he puesto 00:33:27
nada adelante, esto quiere decir 00:33:30
que estos señores son visibles 00:33:31
Solo o si hereda 00:33:33
O si están en el mismo package 00:33:35
Y ahora no están en el mismo package 00:33:37
He importado el otro package para poder utilizarlo 00:33:39
¿Vale? 00:33:42
Entonces si quisiera verlos así 00:33:42
Caos que ahora ya no tengo problemas aquí 00:33:44
Se me queda 00:33:56
Este problema de aquí porque es lo mismo 00:33:57
Me dice, oye mira que 00:33:59
Tú, este de aquí 00:34:01
Es protected, ¿vale? 00:34:03
No le he puesto nada adelante 00:34:05
Y por lo tanto es 00:34:06
Solo se puede ver si hereda o si está en un 00:34:08
Y no está en el mismo package, por lo tanto no 00:34:11
Hasta si pusiera 00:34:14
Package 00:34:15
Sigue sin verse, ¿vale? 00:34:16
Aquí me da problema, no sé por qué 00:34:19
Entonces, lo que tengo que hacer es 00:34:20
Public 00:34:23
Ahora, como este es público 00:34:25
Pues desde aquí se debería poder ver 00:34:29
Entonces, ahora me vuelve a funcionar 00:34:32
No obstante, estén 00:34:35
En packages distintos 00:34:36
¿Dudas? 00:34:37
Me gusta 00:34:52
Vale, entonces 00:34:52
Vamos ahora a decir, vale, muy bien 00:34:55
Hasta ahora hemos jugado, ¿cómo modifico 00:34:58
Esto para hacerlo un poquito más serio? 00:35:00
No quiero que esto sea 00:35:15
Modificable desde fuera, ¿vale? 00:35:16
Y cuando creo una nueva cuenta, ¿qué hago? 00:35:19
El número se lo asigno yo 00:35:27
Pero normalmente 00:35:28
Cuando creo una cuenta 00:35:30
¿Qué tendré que saber? 00:35:31
Ahora yo el titular no lo puedo 00:35:44
Volver a modificar desde aquí, ¿vale? 00:35:46
Tendré que ponerle 00:35:49
El titular del momento 00:35:50
En que creo 00:35:52
La cuenta 00:35:53
Que tiene más sentido 00:35:55
¿Vale? 00:36:01
Al crear una cuenta 00:36:04
Yo le paso el nombre del titular 00:36:05
Él en automático me da el número 00:36:06
De la cuenta 00:36:09
Y asocia mi titular 00:36:11
¿Vale? 00:36:13
Y por ejemplo, en este caso de aquí 00:36:14
Podría decirle 00:36:16
Y el saldo es cero 00:36:18
Cuando creo una nueva cuenta 00:36:20
El saldo es cero 00:36:23
voy a ver qué es y si quiero crear una cuenta que tenga ya un saldo 00:36:24
entonces ahora para hacer cuenta uno por ejemplo le puedo poner así viene un 00:36:46
cliente me dice hoy soy yo tengo un millón de euros pues vale perfecto te 00:36:53
creo tu cuenta 00:36:58
ok vale perfecto está funcionado pero el segundo en vez de lo hace en dos partes 00:37:02
crea una cuenta antes 00:37:08
y luego se acuerda y dice 00:37:11
ya que la he creado, quiero meter algo 00:37:12
¿vale? 00:37:14
cuando la he creado, aquí, ya la he creado 00:37:16
con cero, ¿y ahora qué hago? 00:37:18
¿cómo le pongo 00:37:22
dinero? por ejemplo 00:37:22
entonces vamos a crear 00:37:32
un método 00:37:34
que me devuelva 00:37:35
bueno, un método que se llame 00:37:42
ingresar 00:37:44
int 00:37:46
cantidad 00:37:49
¿vale? 00:37:50
prototipo de este método, ¿qué tiene que devolver? 00:37:53
podría 00:38:00
devolver tres cosas, void 00:38:01
lo hace y no te dice nada 00:38:03
puede devolver boolean 00:38:05
si lo has podido hacer 00:38:07
me devuelves true, si ha habido algún 00:38:09
problema me devuelves false 00:38:11
tercero 00:38:12
podría ser un int 00:38:15
tú me dices cuánto entró y yo te doy 00:38:16
el saldo actual, para que tú 00:38:19
verifiques admitió 100 euros y ahora tienes 2.400 como lo queremos hacer teniendo en cuenta que está 00:38:21
esta parte de aquí es el objeto en el objeto poner diálogos con el usuario siempre presente 00:38:41
peligroso porque cuando yo le hago reutilizo esto en otro contexto donde no hay un usuario 00:38:51
Este se parará ahí a esperar que el usuario me ponga algo 00:38:57
¿Vale? 00:39:00
Es mejor que si yo quiero hacer algo de por el estilo 00:39:01
Lo haga desde mi cuenta 00:39:03
Tenga los métodos para trabajar con el 00:39:05
Con el objeto 00:39:08
Y es el trabajo puro 00:39:10
Y es en mi cuenta 00:39:12
Donde hago la interfaz con el usuario 00:39:13
Que le pido cosas si hace falta 00:39:15
Yo puedo intentar meter dinero 00:39:17
Y si me da un error 00:39:19
Pues entonces lo pido al usuario y vuelvo a intentar hacer 00:39:20
¿Vale? Pero no a nivel de cuenta 00:39:23
La cuenta debería ser 00:39:26
Más sencilla posible 00:39:27
Y trabajar sobre lo que es la cuenta 00:39:28
¿Sí? 00:39:30
Entonces, ingresar 00:39:32
Pues yo lo haría con el índice 00:39:34
¿No? Devolvamos el saldo 00:39:36
Actual 00:39:38
¿Sí? Porque es 00:39:39
Parecido al boolean 00:39:42
Pero es más preciso 00:39:44
Yo puedo devolver un entero 00:39:46
Negativo si no he podido 00:39:48
Hacerlo y 00:39:50
Un entorno, si te devuelvo en vez tu sueldo 00:39:52
Es que lo he podido hacer 00:39:55
no por ejemplo así tengo más información posible tengo si lo has podido hacer o no y tengo cuánto 00:39:56
tienes ahora en el banco entonces ingresar y bla bla bla entonces empiezo con un bueno 00:40:02
la verdad es que es muy fácil es decir que hago que dis operaciones igual a menos uno 00:40:10
luego digo que 00:40:26
dis.cuenta 00:40:31
no cuenta 00:40:35
saldo 00:40:37
es más o igual 00:40:39
a cantidad 00:40:44
esta es 00:40:46
dis.saldo es igual a 00:40:48
dis.saldo más cantidad 00:40:50
vale 00:40:51
op es igual 00:40:52
adbis.saldo 00:40:56
return op 00:40:58
en realidad este código es horrible 00:41:00
vale 00:41:05
y lo que deberíamos hacer es esto 00:41:06
también porque 00:41:09
a este 00:41:17
esto es lo que estoy haciendo, también porque 00:41:18
el concepto de añadir dinero no tiene problemas 00:41:35
aquí no tengo if, aquí no tengo 00:41:37
entonces esta operación se va a hacer 00:41:39
otra cosa es que 00:41:42
dependiera del usuario 00:41:43
Y si eres tú 00:41:45
Entonces te sumo 00:41:47
Si no eres tú no te sumo nada 00:41:48
Entonces podría fallar la operación 00:41:50
Pero aquí es, añade 100 euros 00:41:51
Si no hay mucha opción de fallar 00:41:53
¿Hasta qué punto sería eficiente 00:41:57
O bien hecho 00:41:59
Poner directamente 00:42:00
10 puntos saldo más cantidad 00:42:01
Porque es lo mismo 00:42:03
Si la operación te devuelve el valor 00:42:09
Sí 00:42:13
Pero no la guarda 00:42:13
Te devuelve 200 00:42:26
Pero te deja 100 00:42:29
Y eso no te va a gustar 00:42:30
¿Vale? 00:42:34
¿Sí? 00:42:36
Lo que dices tú 00:42:37
Es esto 00:42:39
Pero no sé si te lo hace 00:42:40
Esto podría funcionar 00:42:43
Pero es que no sé 00:42:48
Esta operación si devuelve 00:42:49
Resultado de la operación 00:42:51
Lo más probable es que esto devuelva 00:42:52
Un true o un false 00:42:54
O un 0 o un 1 00:42:55
O cosa por el estilo 00:42:56
No lo que queremos nosotros 00:42:57
Por lo tanto, así 00:42:59
Cuidado con, no siempre 00:43:01
Escribir menos es mejor 00:43:03
Porque a veces eso llega a un momento 00:43:05
En que lía 00:43:07
Y luego cuando tenéis que encontrar 00:43:09
Un error 00:43:11
Y lo habéis escrito todo súper comprimido 00:43:12
Puede ser realmente un problema 00:43:15
Con calma, pero 00:43:17
Yo creo que así es aceptable 00:43:18
Sumo la cantidad que me has pasado 00:43:21
Al saldo y luego te lo devuelvo 00:43:23
¿Dudas? 00:43:25
Entonces ahora, aquí, lo que puedo hacer es mi cuenta.ingresar mis 3 millones de euros. 00:43:27
Se enfada, porque no lo he puesto público. 00:43:41
Y ahora debería funcionar, ¿vale? 00:43:55
Volvamos un momento al toString. 00:44:09
En realidad, en Java, cualquier clase que yo creo 00:44:13
Usa la cosa que no sabemos que es la herencia 00:44:20
La herencia es como extender otra clase 00:44:24
Es como yo ya tengo una clase y voy a añadir cosas a esa clase 00:44:29
Por defecto, si yo no digo nada 00:44:33
Y siempre una clase extiende una clase especial que se llama object 00:44:36
objeto 00:44:42
mi clase es un objeto 00:44:43
cocodrilo es un objeto, rectángulo es un objeto 00:44:45
¿vale? entonces hay esta extensión 00:44:48
la clase object 00:44:50
tiene por defecto dentro 00:44:52
un metodito que es el método toString 00:44:54
entonces cuando yo utilizaba 00:44:56
antes toString 00:44:58
en realidad el toString estoy 00:44:59
sobrescribiendo 00:45:02
el toString 00:45:04
de la clase object 00:45:06
¿vale? que es el contrato de sobrescriptura 00:45:07
estoy pillando la clase object que tiene su método 00:45:10
y estoy diciendo, no, mira, para la clase 00:45:13
mía, no uses 00:45:15
el método de tu object, usa 00:45:16
el método mío, es un poco 00:45:18
retorcido porque no sabemos 00:45:20
todavía la herencia, ¿vale? 00:45:22
entonces, por ahora lo dejamos así 00:45:24
en el aire y luego volveremos 00:45:27
cuando estudiaremos la herencia y veremos la clase 00:45:29
object, pues volvemos al toString 00:45:31
porque es útil, ¿vale? toString con otras 00:45:32
cosillas son cosas que hay que 00:45:34
implementar, por ahora dejamos imprime 00:45:36
y estamos todos felices 00:45:39
pensamos así vale entonces nos faltaría otra cosa no tengo ingresar de vez en cuando querré sacar 00:45:40
hago dinero, no? lo copio, ctrl v, ingresar, sacar, relevar, retirar, retiro una cantidad 00:46:00
y hago así. Ya está, solucionado, ¿verdad? Claro, yo voy allí, tengo 3 euros en el banco, 00:46:22
le digo dame 100 y me lo dan enseguida. ¿Qué más da que haya un menos delante? Toma todo 00:46:31
el dinero que quieres. Son todos ricos. ¿Qué tendré que hacer? IF. IF punto saldo. Es 00:46:36
mayor de cantidad 00:46:53
mayor 00:46:55
igual 00:46:57
venga, si te quieres quedar a cero 00:46:59
puedes 00:47:01
entonces lo haces 00:47:01
y ahora sí que podría tener 00:47:04
sentido tener una variable 00:47:12
int op que valga menos uno 00:47:14
para hacerlo de alguna forma 00:47:16
y que 00:47:19
si ejecuto esto 00:47:20
entonces op vale 00:47:22
dis.saldo 00:47:24
después 00:47:25
Y aquí devuelvo 00:47:27
¿Para qué me sirve esto? 00:47:32
Y ejecuto esta operación 00:47:38
Si el resultado es menos uno 00:47:41
Es que no has podido retirar 00:47:43
Si es cualquier otro número 00:47:45
Es que has podido retirar 00:47:47
Imaginamos que yo tengo 100 00:47:49
Y pido 200 00:47:54
Pues esto 00:47:55
Será falso 00:47:56
Por lo tanto me salto todo esto 00:47:57
Y entonces devuelvo menos uno 00:47:59
Tenía 100, has pedido 200 00:48:01
No puedes hacer la operación 00:48:04
Si en vez 00:48:05
Tú tienes 200 y pides 100 00:48:07
Esto es verdadero 00:48:10
Entras aquí, haces que aquí dentro pones 00:48:11
Lo que hay aquí dentro, 200 menos 100 00:48:14
100, y luego devuelves 00:48:16
Escribes en op 100 00:48:17
Entonces devuelves 100 00:48:20
¿Sí? 00:48:21
Vamos a hacer pruebas 00:48:23
Entonces, ahora que he escrito 00:48:25
Pues voy a sacar dinero 00:48:29
Vamos a reducir 00:48:30
Entonces voy a 00:48:31
hacer una operación en mi cuenta vale si mi cuenta punto hemos quemado retirar retirar 00:48:35
lo siento es mayor o igual que cero has retirado correctamente 00:48:49
El se 00:49:11
No has podido 00:49:14
Retirar 00:49:22
Saldo insuficiente 00:49:25
Y hago lo mismo 00:49:31
Con cuenta 2 00:49:35
Retirando 5000 00:49:42
Esta es la cantidad 00:49:45
Quiero un café 00:49:47
Vale, entonces, ejecuto 00:49:49
Cuenta cero tiene un millón 00:49:52
Y has retirado correctamente 00:49:57
Aquí lo intento y me dice 00:49:59
No has podido sacar 00:50:01
Cosa por este 00:50:03
Vale 00:50:04
Ahora podría añadir aquí 00:50:06
Esta de aquí, bueno, la he escrito aquí 00:50:09
Podría reutilizar imprime 00:50:12
Para decir aquí, la cuenta uno 00:50:13
Tiene 300, saldo insuficiente 00:50:15
Bueno, en realidad 00:50:17
Cuando tenemos una situación como esta de aquí 00:50:27
¿Vale? O sea que todo está privado 00:50:30
Puedo acceder a ellos con el constructor 00:50:33
Y luego se suele poner 00:50:37
De las acciones que quiero hacer 00:50:40
Lo que se llaman los getter y setter 00:50:43
¿Vale? 00:50:45
Los getters son los que me permiten leer una variable 00:50:47
Y los setters los que me permiten modificar esa variable 00:50:50
¿Vale? 00:50:54
Pongamos por ejemplo 00:50:56
Que yo quiera poder leer mi saldo 00:50:57
Entonces hago un public int get saldo 00:51:01
Get es de pillar ¿Vale? 00:51:10
Por eso son los getters 00:51:13
Porque son todos los get 00:51:14
algo 00:51:16
y lo que hago es 00:51:17
return saldo 00:51:20
esta cosa de aquí 00:51:22
me permite ahora leer saldo 00:51:25
desde fuera 00:51:28
y aquí 00:51:29
puedo poner, no has podido retirar 00:51:31
saldo insuficiente 00:51:35
punto 00:51:37
tu saldo 00:51:38
saldo 00:51:40
actual 00:51:45
actual 00:51:46
Más 00:51:49
Mi cuenta 00:51:52
Dos 00:51:55
Punto get saldo 00:51:56
Fijaos que 00:51:58
Esto me permite hacerlo 00:52:02
Sin embargo si yo 00:52:04
Intentar acceder a saldo directamente 00:52:05
Me dice no, no es visible 00:52:08
¿Veis aquí? 00:52:10
Esto es que he leído el saldo 00:52:33
La cosa interesante de los getter 00:52:35
De los setters 00:52:37
Es que yo aquí puedo hacer una comprobación 00:52:38
Yo podría hacer aquí un 00:52:41
Si tú eres 00:52:44
El del banco 00:52:46
Y estás autorizado porque tienes 00:52:48
Algo que me has pasado aquí como parámetro 00:52:50
Por ejemplo, cosa por el estilo 00:52:53
Pues entonces te doy el sueldo, si no, no 00:52:54
¿Vale? Es decir, que no es como 00:52:56
Acceder directamente a la variable 00:53:00
Que yo accedo allí, leo y me lo das 00:53:02
No, este es un método 00:53:04
Como base te dice 00:53:04
Te doy la cosa, pero aquí yo podría 00:53:07
Decir que te lo devuelvo, si, solo si 00:53:09
Tú cumples una serie de 00:53:11
Cosas, por ejemplo 00:53:13
Podrías haber tenido antes que 00:53:14
Hacer una sesión de un login 00:53:16
En el cosa, y aquí me pregunto 00:53:19
Si el login es válido, entonces 00:53:21
Si eres el titular de esta cuenta 00:53:23
Pues entonces te doy el saldo, si no, no 00:53:25
¿Vale? O sea que podría complicarlo 00:53:27
Un poco, y también está 00:53:29
El public 00:53:31
void 00:53:35
set saldo 00:53:37
int x 00:53:39
sería 00:53:41
this.saldo es igual a x 00:53:45
esto me permitiría 00:53:47
setar el saldo 00:53:50
a un cierto valor 00:53:52
otra cosa es que lo quiera hacer 00:53:53
y también aquí 00:53:58
es un método, no es como escribir 00:53:59
directamente dentro saldo 00:54:02
es más bien un 00:54:03
oye mira 00:54:05
Ejecuta este método 00:54:06
Haz todas las comprobaciones que quieras 00:54:08
Mira si lo puedes hacer o no 00:54:11
Mira si tienes privilegios 00:54:13
Mira un fichero, mira un lo que sea 00:54:14
Y si todo está bien, ponlo 00:54:16
Si no, no 00:54:17
Lo puede hacer, ahora nosotros no lo hacemos 00:54:18
Pero, vale 00:54:21
Entonces, la idea es que 00:54:22
Por como lo utilizamos nosotros por un buen rato 00:54:24
La idea es que 00:54:28
Las variables críticas 00:54:29
Variables que no quiero modificar 00:54:31
Desde fuera 00:54:33
Las ponga como privada 00:54:34
Y la gestione 00:54:36
Así 00:54:38
O sea, en 00:54:40
En los constructores 00:54:42
Que me lo gestione él 00:54:45
Y que me haga las comprobaciones que tiene que hacer 00:54:46
Y que si la quiero leer 00:54:48
Normalmente no hay grandes problemas 00:54:50
¿Vale? La puedo leer 00:54:52
Con get 00:54:54
Con el get, ¿vale? 00:54:55
Y que se utilice 00:54:58
Con métodos que yo proporciono 00:55:00
¿Vale? Entonces yo tengo el 00:55:03
control, no hay nadie que pueda decir 00:55:04
ahora tengo un millón de euros, no, lo tienes que 00:55:06
ingresar o lo tienes que retirar 00:55:08
y estos métodos se llaman 00:55:10
desde fuera 00:55:11
lo llaman banco 00:55:13
claramente aquí no se hace nada 00:55:15
si tú me traes un millón de euros y yo te hago una ingresión 00:55:17
de un millón, pues te lo pongo 00:55:20
lo que no puedes hacer es directamente decirte 00:55:21
tengo un millón de euros 00:55:24
sin ingresar 00:55:25
no sé si me explico la idea que está 00:55:27
por detrás de esto 00:55:30
ahora, esto están 00:55:31
radicado, que si no me equivoco 00:55:34
por aquí hay una opción de 00:55:36
create get and set 00:55:38
¿dónde estará? 00:55:39
Forge 00:55:43
aquí 00:55:43
si os fijáis por aquí debería haber 00:55:45
aquí 00:55:48
hay una opción automática que si tú le das te crea 00:55:49
todos los getter y todos los setter 00:55:56
básicos, de eso de set x 00:55:57
se te pone 00:56:00
a ver 00:56:00
¿de cuál queréis el get y el set? 00:56:05
por ejemplo de un cuenta 00:56:07
Los dos, get y set 00:56:09
Pues le das generate 00:56:11
Y el me crea el get en un cuenta 00:56:12
Y el set en un cuenta 00:56:15
Claramente me lo da en versión 00:56:16
Básica, super básica 00:56:21
Luego si yo quiero hacer comprobaciones 00:56:23
Y cosas por el estilo 00:56:25
Soy yo que me tengo que poner a trabajar 00:56:26
Fijaos también 00:56:28
Que cuando estáis aquí en search 00:56:32
Aparece también nuestro amigo 00:56:34
Y aparece también nuestro amigo 00:56:37
¿Y por qué aparecen? 00:56:42
Pues ya lo veréis 00:56:46
¿Sí? 00:56:46
Pero 00:56:48
Lo que quiero decir con esto 00:56:49
Es que son tan 00:56:50
Tan común 00:56:52
Hacer estas cosas 00:56:54
Que hasta el 00:56:55
El eclipse 00:56:56
O el líder en general 00:56:57
Que utilizáis 00:56:58
Pues os da la herramienta 00:56:59
Para hacerlo 00:57:00
Porque la probabilidad 00:57:00
Que lo vayáis a hacer 00:57:01
Es bastante alta 00:57:02
¿Vale? 00:57:03
Y son también cosas 00:57:04
Que en su versión 00:57:06
Más básicas 00:57:07
Son triviales 00:57:08
¿Vale? 00:57:09
Son súper sencillas 00:57:10
Entonces en vez de estar aquí, ahora yo tengo 56 variables 00:57:12
A poner 56 veces esta variable, pues no pongo esta 00:57:16
¿Dudas? 00:57:21
Voy a parar esto porque... 00:57:23
Idioma/s:
es
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
8
Fecha:
16 de diciembre de 2022 - 13:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
57′ 26″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
685.74 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid