Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 15-12-23 - 2 - 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 18 de diciembre de 2023 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Vale? Pues entonces, este método que está ahí puesto, el código en particular lo entendemos, ¿no? 00:00:00
El código en sí lo entendemos. Silencio, todo el mundo, estos de atrás también, me tienen muerta. 00:00:12
A ver, este código sin más, lo entendemos, ¿verdad? 00:00:19
Cogemos este valor y en cuanto encontremos un elemento de este array, 00:00:26
un elemento de este array que es igual a él, cambiamos a true. 00:00:32
Esto no es nada distinto a lo que hemos hecho, lo entendemos. 00:00:35
A la duda, lo que nos puede ahora confundir y resultar raro es, 00:00:37
ya, pero espérate, este array de clientes, de qué pedido es, 00:00:41
¿con qué array estoy comparando? Porque yo he cogido el array de arriba. 00:00:46
Esto, en realidad, ¿no? Que por ahí va tu pregunta. 00:00:49
Ese array de clientes, ¿de qué pedido es? 00:00:52
Vale, pues entonces, no perdamos de vista que este método está dentro de una clase, 00:00:55
todavía, no está dentro de un main. 00:01:01
Lo que se ejecuta es un método main, ahí es donde empiezan a ejecutarse cosas. 00:01:03
Ahí es donde empiezan a ejecutarse. 00:01:07
Esto es una declaración de cosas que se pueden hacer, 00:01:08
pero aquí todavía no se está ejecutando nada. 00:01:11
Esto lo que significa es, cuando haya pedidos, 00:01:14
esos pedidos podrán hacer que se ejecute esto. 00:01:17
Cada uno de ellos. 00:01:22
Que hay un pedido P1, ese pedido P1 podrá hacer que se ejecute esto. 00:01:23
Y en ese caso, este array será el array del pedido P1. 00:01:27
Que luego dentro de 7 líneas hay un pedido P2. 00:01:32
Ese pedido P2 también podrá hacer que se ejecute esto. 00:01:35
Ahora veremos cómo. 00:01:38
Y entonces, este array de clientes será el del pedido P2. 00:01:39
Luego este array de aquí significa, así en general, 00:01:43
este array es el array clientes del pedido que llame al método 00:01:46
cuando alguien lo llame. 00:01:51
Nadie lo ha llamado todavía. 00:01:53
Esto es una declaración de clase. 00:01:54
Estamos en tiempo de escritura de código. 00:01:56
No hay nada ejecutándose. 00:01:58
Nada. 00:01:59
Esto es una declaración de clase que dice, 00:02:00
cuando haya un pedido alguna vez, 00:02:03
si es que alguna vez hacemos un main y lo ejecutamos, 00:02:04
pues cuando haya un pedido, 00:02:07
ese pedido tendrá un código concreto, 00:02:08
una descripción concreta y un array de clientes concreto 00:02:12
y ese pedido además podrá llamar a esto. 00:02:15
Pero eso cuando exista un pedido alguna vez, 00:02:18
si es que lo hay porque hacemos un main y lo creamos. 00:02:20
Esto ahora mismo es una plantilla. 00:02:24
No hay nada que se esté ejecutando. 00:02:27
Es una declaración de intenciones de que los pedidos 00:02:29
se caracterizarán por eso si alguna vez existen 00:02:32
y los pedidos podrán hacer que este código se ejecute 00:02:35
si es que alguna vez existen. 00:02:38
Bueno, pues vamos a hacerlos existir ahora. 00:02:40
Venga, pues vamos a hacer aquí un main. 00:02:44
Bueno, en este mismo main que estábamos de prueba. 00:02:46
Vamos a hacer ahora. 00:02:49
Ahora ya cómo queremos usar esto. 00:02:53
Pues vamos a crear. 00:02:55
Bueno, ya tenemos aquí de hecho el pedido gomas creado. 00:02:56
Ya teníamos un pedido gomas creado con un array de clientes. 00:02:59
Entonces en este main del que partimos 00:03:03
ya el pedido gomas existe y el pedido bolis también. 00:03:05
Luego tenemos dos pedidos. 00:03:09
El pedido bolis con un código, una descripción 00:03:10
y un array de clientes. 00:03:13
Y el pedido gomas con un código, una descripción 00:03:16
y un array de clientes. 00:03:19
Dos pedidos cada uno con sus propiedades. 00:03:20
Bueno, pues esos pedidos que ya existen 00:03:22
porque esto es un main que ahora ya 00:03:24
cuando ejecutemos estos ya existirán 00:03:26
cada uno de ellos con sus propiedades. 00:03:29
Cuando este programa se lance y se ejecute 00:03:35
pues tendremos pedido bolis. 00:03:38
Pedido bolis que apuntará a un espacio en memoria 00:03:44
con el código de pedido bolis 00:03:49
que no sé qué código le dimos. 00:03:51
Ah, es que se metieron por teclado. 00:03:54
Pues el que se meta en la ejecución. 00:03:55
Cuando se ejecute este programa a pedido bolis 00:03:58
le daremos un código, el que le metamos por teclado. 00:04:00
Le daremos una descripción, la que le metamos por teclado. 00:04:03
Y le estamos dando a capor unos clientes. 00:04:07
Luis y Juan en un array. 00:04:09
Vale, pues aquí habrá un array. 00:04:11
Luis y Juan. 00:04:13
Todo eso está en el objeto pedido bolis. 00:04:20
El main sigue. 00:04:23
Por ahí arriba hicimos otro pedido gomas. 00:04:24
Tendremos un pedido gomas por ahí. 00:04:27
Y ese pedido gomas que ha creado ese main 00:04:43
pues habrá creado otro espacio para él 00:04:46
con un código, el que le hayamos metido por teclado. 00:04:49
Por ahí arriba está la sentencia 00:04:51
a la que metemos un código y lo asignamos. 00:04:52
Una descripción con la que le hayamos metido. 00:04:54
Y un array que en lugar de metérselo por teclado 00:04:57
lo estamos dando a tiro fijo. 00:05:00
Este en particular tiene cuatro clientes. 00:05:02
Que son pues estos, Luis, los que sean. 00:05:05
Vale, pues esta es la situación de nuestro main 00:05:17
llegados a este punto. 00:05:19
Llegados a este punto la situación es esta. 00:05:21
Un pedido bolis con sus propiedades rellenas, las suyas. 00:05:23
Un pedido gomas con sus propiedades. 00:05:27
Es decir, dos objetos de clase pedido. 00:05:29
Cada uno con su nombre, el que nos ha dado la gana con él. 00:05:33
Ahora, esos dos pedidos, además de almacenar valores 00:05:35
que es una cosa que están haciendo, además de almacenar valores 00:05:41
pueden llamar a los métodos de la clase. 00:05:44
Y ahora ya sí se ejecutará el método. 00:05:48
Porque ahora ya hay un objeto, existe en memoria un objeto, 00:05:50
lo ha creado el main, existe un objeto 00:05:53
y ahora ya el objeto que existe puede llamar al método. 00:05:56
Entonces ahora ya sí que se ejecutará. 00:05:59
Bueno, pues, ¿y cómo va a llamar al método? 00:06:04
Ahora lo escribimos ahí. 00:06:07
Pues por ejemplo, ahora la aplicación me dice 00:06:08
oye, introduzca un número de clientes, un nombre de cliente 00:06:10
y te voy a decir si está en el pedido de bolis. 00:06:13
Pues entonces introduciremos un nombre de cliente. 00:06:18
¿Vale? Pues imaginamos que hemos leído ya el nombre de cliente 00:06:24
y el nombre de cliente pues está aquí ya leído. 00:06:27
Lo hemos leído. 00:06:30
Y ahora ya queremos averiguar si ese cliente que hemos leído por teclado 00:06:31
está contenido dentro de los clientes de pedido de bolis. 00:06:36
Bueno, pues es que tenemos ya un método en la clase 00:06:42
que recogía esa funcionalidad. 00:06:44
Pues entonces ahora ¿cómo este objeto llama a ese método para hacer eso? 00:06:48
Pues nombre del objeto. 00:06:53
Punto, nombre del método. 00:06:59
¿El método cómo se llamaba? 00:07:02
Comprueba cliente se llamaba. 00:07:03
Pues punto, comprueba cliente. 00:07:06
Pero esto ahora es un método, no es una propiedad. 00:07:15
Entonces a los métodos hay que pasarles por parámetro en los paréntesis 00:07:18
el dato que necesitan. 00:07:24
¿Qué dato necesitan? 00:07:26
Bueno, lo que me pida a mí. 00:07:27
Pues el método comprobar cliente, no era comprueba sino comprobar. 00:07:29
Comprobar. 00:07:33
¿Vale? 00:07:40
Pues ese método necesita un string, un nombre para trabajar. 00:07:41
Entonces un string. 00:07:45
¿Vale? ¿Con qué nombre quiero yo que trabaje? 00:07:46
Porque ahora ya sí que se va a ejecutar. 00:07:47
Ahora ya hay un objeto que lo está llamando. 00:07:49
Ahora ya sí que se va a ejecutar. 00:07:51
No cuando lo escribí en la clase. 00:07:52
Ahí es un propósito de futuro. 00:07:53
Pues se va a ejecutar con lo que yo le pase aquí. 00:07:56
Venga, le quiero pasar el nombre C. 00:07:59
Es el que le doy por teclado. 00:08:01
Pues sí, lo paso. 00:08:02
Exactamente igual que pasábamos parámetros a funciones 00:08:03
cuando hemos visto funciones en el pasado. 00:08:06
Igual. 00:08:08
¿Vale? 00:08:09
Aquí no hay un punto. 00:08:10
¿Vale? 00:08:11
Pues pedido bolis. 00:08:12
Punto. 00:08:13
Comprobar cliente automáticamente hace que 00:08:14
¡Paf! 00:08:16
Se ejecute ese código de ahí. 00:08:18
Ya está. 00:08:22
Ya entraremos. 00:08:23
Bueno, a ver. 00:08:24
¿Esto se pone en la clase pedido o en el main? 00:08:25
En el main. 00:08:27
¿Vale? 00:08:32
Entonces automáticamente esto saltará a ejecutar esto. 00:08:33
Saltará a ejecutar esto y entonces ahora, 00:08:37
ahora ya la pregunta de 00:08:40
¡Oye! 00:08:42
¿Este array de clientes cuál es? 00:08:43
Pues el array de clientes sobre el que trabaja el método 00:08:48
cuando le llamamos aquí, 00:08:50
es el de este. 00:08:52
El de este. 00:08:53
Entonces, 00:08:55
comprobar cliente va a ejecutar esto, 00:08:56
pero ¿quién va a ser este array? 00:08:58
¿Quién va a ser este array? 00:09:00
Va a ser el array de este, 00:09:01
del que lo llamo. 00:09:02
Es decir, 00:09:03
este de aquí. 00:09:04
Entonces, 00:09:05
este método funcionará 00:09:06
comprobando si este cliente C 00:09:08
está en 00:09:11
este array. 00:09:13
¿Vale? 00:09:16
Y me devolverá true o false. 00:09:17
Si está o no está. 00:09:18
Depende 00:09:19
si me han metido uno que esté o no esté. 00:09:20
Entonces, 00:09:22
hombre, 00:09:23
si yo hago la llamada sin más, 00:09:24
no pasa nada, 00:09:25
el código se ejecuta, 00:09:26
pero el retún 00:09:28
lo estoy perdiendo, 00:09:31
lo tiro a la basura. 00:09:32
Esto es lo mismo que cuando 00:09:33
hacemos funciones igual. 00:09:34
Entonces, 00:09:36
hombre, 00:09:37
yo quiero guardar el resultado, 00:09:38
quiero guardar el true o el false, 00:09:39
¿no? 00:09:40
Para decir, 00:09:41
pues, 00:09:42
si está o no está. 00:09:43
Bueno, 00:09:44
pues el valor de retorno de un método, 00:09:45
el valor de retorno de un método, 00:09:46
lo tengo que asignar a alguna variable 00:09:48
si no quiero perderlo. 00:09:50
Si no quiero perderlo, 00:09:51
tengo que asignarlo a alguna variable. 00:09:52
El valor de retorno de este método, 00:09:55
¿de qué tipo es? 00:09:57
Boolean. 00:09:58
Tengo que asignarlo a una variable Boolean 00:09:59
porque si no, 00:10:00
lo pierdo. 00:10:01
Bueno, 00:10:03
pues ya la variable que sea, 00:10:04
yo que sea esta misma. 00:10:05
Vale, 00:10:06
pues entonces ahora, 00:10:07
repito, 00:10:08
¿qué va a hacer esta línea de código del main? 00:10:09
Esta línea del código. 00:10:11
Pues llamará, 00:10:13
saltará automáticamente 00:10:14
al código de ahí, 00:10:15
pero esto se va a ejecutar 00:10:17
con 00:10:18
esa variable 00:10:19
siendo esta 00:10:20
la propiedad 00:10:24
cliente 00:10:25
será la propiedad de este. 00:10:26
La del que lo llama 00:10:28
y ahora ya el resultado que me devuelva 00:10:30
pues se va a guardar en B. 00:10:32
Que yo ahora quiero decirle, 00:10:34
oye, 00:10:35
si B, 00:10:36
entonces el cliente está 00:10:37
y si no, 00:10:38
no está. 00:10:39
Pues ya está, 00:10:40
en función del resultado de B, 00:10:41
una cosa u otra. 00:10:42
¿Vale? 00:10:43
Que quiero hacer lo mismo 00:10:44
pero ahora quiero comprobar 00:10:45
si C está en el pedido gomas. 00:10:46
Pues lo único que tengo que cambiar 00:10:48
es esto. 00:10:49
Entonces, 00:10:53
ahora esto 00:10:54
vuelve a llamar a ese método, 00:10:55
pero ahora 00:10:56
quien lo está llamando 00:10:57
es este objeto. 00:10:58
Lo está llamando 00:10:59
otro objeto distinto 00:11:00
con otras propiedades distintas, 00:11:01
otro objeto distinto. 00:11:02
Pues entonces, 00:11:04
el parámetro es este, 00:11:05
pero 00:11:07
la propiedad cliente 00:11:08
es la del que lo llama 00:11:11
pedido gomas 00:11:12
que tendrá los valores que tenga 00:11:13
porque cada objeto 00:11:14
tiene las suyas propias. 00:11:15
Luego, 00:11:22
los objetos, 00:11:23
una vez que ya están creados 00:11:24
existen 00:11:25
y tienen sus propios valores, 00:11:26
pueden llamar 00:11:28
a métodos de la clase 00:11:30
de esta manera, 00:11:31
nombre del objeto 00:11:33
punto 00:11:34
nombre del método, 00:11:35
pasando de los parámetros 00:11:36
que hagan falta. 00:11:37
Y ese método 00:11:38
ya se va a ejecutar 00:11:39
con el código 00:11:40
que esté en la clase 00:11:41
declarado, 00:11:42
pero se va a ejecutar 00:11:44
para los valores 00:11:45
de propiedades 00:11:46
que tenga este objeto 00:11:47
en concreto. 00:11:48
Luego, 00:11:50
pedido gomas 00:11:51
punto comprobar cliente 00:11:52
tendrá un resultado 00:11:53
bastante distinto 00:11:54
a pedido bolis 00:11:55
punto comprobar cliente 00:11:56
porque los datos 00:11:57
de pedido gomas 00:11:58
y los de pedido bolis 00:11:59
son distintos 00:12:00
y si hay pedido mesas 00:12:01
pues pedido mesas 00:12:02
punto comprobar cliente 00:12:03
tendrá un resultado 00:12:04
bastante distinto 00:12:05
porque cada método 00:12:06
se va a ejecutar 00:12:07
tomando 00:12:08
las propiedades 00:12:09
de esta clase 00:12:10
ahí dentro. 00:12:11
Vale, 00:12:17
vamos a 00:12:18
meterlo en la aplicación. 00:12:19
Bueno, 00:12:21
pues, 00:12:22
esto ya está declarado. 00:12:23
Entonces, 00:12:24
primero uno 00:12:25
tiene que declarar 00:12:26
la clase 00:12:27
y decir, 00:12:28
vale, 00:12:29
¿qué me va a interesar a mí 00:12:30
que ahora en los pedidos? 00:12:31
Primero, 00:12:32
¿qué propiedades 00:12:33
me va a interesar? 00:12:34
Eso es lo primero, 00:12:35
me va a interesar 00:12:36
su código, 00:12:37
su no sé qué, 00:12:38
las planto. 00:12:39
Y ahora, 00:12:40
en toda esa fase mía 00:12:41
de diseño, 00:12:42
de decidir mi aplicación, 00:12:43
¿qué funcionalidades 00:12:44
me va a interesar a mí 00:12:45
ejecutar desde el main 00:12:46
para cada pedido? 00:12:47
Pues me va a interesar 00:12:48
ejecutar esta, 00:12:49
comprobar un cliente, 00:12:50
ver si el pedido 00:12:51
es la cantidad que me den. 00:12:52
Pues una vez que 00:12:53
ha identificado 00:12:54
qué funcionalidades 00:12:55
le interesa, 00:12:56
serán diferentes métodos 00:12:57
de esa clase, 00:12:58
serán diferentes métodos. 00:12:59
Vale, 00:13:00
todos esos son 00:13:01
las tareas de diseño. 00:13:02
Las tareas de diseño 00:13:03
es decidir 00:13:04
qué clases forman 00:13:05
mi aplicación 00:13:06
y cada clase 00:13:07
que va a tener dentro. 00:13:08
Todos esos son 00:13:09
tareas de diseño. 00:13:10
Y luego ya 00:13:11
entro a 00:13:12
programar código 00:13:13
ya dentro de cada método, 00:13:14
dentro de cada método, 00:13:15
ya para hacer 00:13:16
lo que toque hacer. 00:13:17
Pero después de haber eso, 00:13:18
una fase de diseño 00:13:19
en la que decidimos 00:13:20
qué clases hay, 00:13:21
qué quiero yo 00:13:22
que se haga en cada clase, 00:13:23
etcétera. 00:13:24
Bueno, 00:13:25
pues en este caso 00:13:26
una funcionalidad 00:13:27
ya teníamos hecha 00:13:28
que es esta, 00:13:29
comprobar cliente. 00:13:30
Ahora la podemos usar 00:13:31
aquí en nuestro main. 00:13:32
Pues venga, 00:13:33
vamos a comprobar, 00:13:34
vamos a pedirle 00:13:35
un nombre 00:13:36
al tío 00:13:37
y para ver 00:13:38
si ha hecho 00:13:39
un pedido de bolis 00:13:40
o de gomas. 00:13:41
Introduzca 00:13:44
nombre 00:13:45
cliente. 00:13:48
Pues venga, 00:13:50
le vamos 00:13:54
a meter un nombre. 00:13:55
Vale, 00:14:04
y ahora 00:14:05
con este nombre 00:14:06
vamos a comprobar 00:14:07
dos cosas. 00:14:08
Primero, 00:14:09
si ha hecho 00:14:10
el pedido de bolis 00:14:11
y segundo, 00:14:12
a ver si ha hecho 00:14:13
el pedido de gomas. 00:14:14
Vamos a hacer 00:14:15
dos comprobaciones 00:14:16
por separado. 00:14:17
Pues venga, 00:14:18
vamos a comprobar primero 00:14:19
a ver si ha hecho 00:14:20
un pedido de bolis. 00:14:21
Pues nada, 00:14:22
el pedido, 00:14:23
el objeto 00:14:24
pedido 00:14:25
bolis 00:14:26
vamos a 00:14:29
llamar 00:14:30
al método 00:14:31
comprobar cliente 00:14:32
y me va a devolver 00:14:35
true o false 00:14:36
en función 00:14:37
si el nombre 00:14:38
este que yo le he metido 00:14:39
está 00:14:40
dentro 00:14:41
del array 00:14:42
clientes 00:14:43
de pedido bolis. 00:14:44
Bueno, 00:14:45
pues vamos a 00:14:46
ponerlo aquí 00:14:48
si ve 00:14:50
si ve 00:14:52
pues si ve 00:14:53
entonces 00:14:54
vamos a poner 00:14:58
este 00:14:59
en minúscula 00:15:01
ha pedido 00:15:08
bolis 00:15:09
y si no 00:15:13
pues no ha pedido 00:15:14
bolis 00:15:15
vale 00:15:18
entonces 00:15:19
este código 00:15:20
nos permitirá 00:15:21
mostrarle 00:15:22
al usuario 00:15:23
de la aplicación 00:15:24
el nombre 00:15:26
que le hemos dado 00:15:27
ha pedido 00:15:28
bolis 00:15:29
o no ha pedido 00:15:30
bolis 00:15:31
vale 00:15:32
que queremos 00:15:33
hacer lo mismo 00:15:34
pero ahora 00:15:35
queremos saber 00:15:36
si ha pedido 00:15:37
gomas 00:15:38
o no ha pedido 00:15:39
gomas 00:15:40
pues lo único 00:15:41
que cambia 00:15:42
de este código 00:15:43
lo único que cambia 00:15:44
es el objeto 00:15:45
que llama 00:15:46
el método 00:15:47
ahora queremos 00:15:48
hacer lo mismo 00:15:49
pero es otro objeto 00:15:50
ahora el que nos interesa 00:15:51
que llame al método 00:15:52
comprobar 00:15:53
comprobar 00:15:54
cliente 00:15:55
se llama 00:15:56
comprobar 00:15:57
cliente 00:15:58
entonces voy a copiar 00:15:59
y pegar 00:16:00
se me va a dar 00:16:01
entonces 00:16:02
y ahora 00:16:03
retocamos 00:16:04
porque no puedo 00:16:05
declarar la variable 00:16:06
otra vez 00:16:07
claro 00:16:08
ahora retocamos 00:16:09
vale 00:16:10
vale 00:16:18
entonces 00:16:19
como la variable 00:16:20
voy a poner aquí otra 00:16:22
como ahora esto 00:16:23
lo voy a cambiar 00:16:24
vamos a dejarlo así 00:16:25
vale 00:16:26
bueno pues 00:16:27
estoy haciendo 00:16:28
primero 00:16:29
compruebo 00:16:30
si el cliente 00:16:31
está en la lista 00:16:32
de clientes 00:16:33
de bolis 00:16:34
llamando al método 00:16:35
para pedido 00:16:36
bolis 00:16:37
y en función del resultado 00:16:38
digo una cosa o no 00:16:39
y ahora 00:16:40
con ese mismo cliente 00:16:41
con el mismo cliente 00:16:42
voy a comprobar 00:16:43
a ver si ha hecho 00:16:44
el pedido 00:16:45
de gomas 00:16:46
pues entonces 00:16:47
el que tendrá que 00:16:48
llamar al método 00:16:49
es pedido gomas 00:16:50
vale 00:16:51
luego el código 00:16:56
del método 00:16:57
es el mismo 00:16:58
lo que cambia 00:16:59
es quien llama 00:17:00
al método 00:17:01
y esa es la clave 00:17:02
porque este método 00:17:05
de arriba 00:17:06
se va a ejecutar 00:17:07
con los datos 00:17:08
de este 00:17:09
y este de aquí 00:17:10
se va a ejecutar 00:17:11
con los datos 00:17:12
de este 00:17:13
con los datos 00:17:14
de este 00:17:16
¿está más o menos claro? 00:17:18
vale a ver 00:17:26
vamos a hacerlo 00:17:27
sí 00:17:30
no B1 igual a tú 00:17:31
no hace falta 00:17:32
no una cosa 00:17:33
para simplificar esto 00:17:34
esto está bien 00:17:35
no vamos 00:17:36
sintácticamente está bien 00:17:37
pero para simplificar esto 00:17:38
que el código así 00:17:39
queda un poco feo 00:17:40
a ver 00:17:41
guardar esto en un booleano 00:17:42
y meter aquí 00:17:43
el booleano 00:17:44
es un 00:17:45
dar un paso intermedio 00:17:46
que hombre 00:17:47
lo natural 00:17:48
es acortarlo 00:17:49
o sea 00:17:50
el resultado de esto 00:17:51
el resultado de esto 00:17:52
es que ya es un boolean 00:17:53
en sí 00:17:54
ya es true o false 00:17:55
entonces queda 00:17:56
más bonito 00:17:57
y es más habitual 00:17:58
si queremos hacer esto 00:17:59
en concreto 00:18:00
pues que en lugar 00:18:01
de guardar 00:18:02
una variable intermedia 00:18:03
y ahora meter aquí 00:18:04
esa variable intermedia 00:18:05
en lugar de usar 00:18:06
esa variable intermedia 00:18:07
pues directamente 00:18:08
pongo esto 00:18:09
pongo esto 00:18:10
¿no? 00:18:13
y me quito esto 00:18:14
así queda 00:18:15
mucho más bonito 00:18:16
esto 00:18:18
me llama al método 00:18:19
y ya el valor 00:18:20
que me devuelve 00:18:21
en función 00:18:22
de si es true o false 00:18:23
pues el lib 00:18:24
ya se va 00:18:25
por un lado 00:18:26
o por otro 00:18:27
así mejor 00:18:28
queda más clara 00:18:29
la vista 00:18:30
y todo 00:18:31
perdón 00:18:32
repite 00:18:33
que no 00:18:34
te he oído 00:18:35
la pregunta 00:18:36
¿cómo sin que tú 00:18:41
se lo pongas? 00:18:42
o sea 00:18:43
el resultado de esto 00:18:44
solo hay dos posibilidades 00:18:45
o es true o es false 00:18:46
si es true 00:18:47
hace esto 00:18:48
y si es false 00:18:49
hace esto 00:18:50
¿cómo que no? 00:18:52
a ver 00:18:54
claro 00:18:55
pero es que esta cosa 00:18:56
es el resultado 00:18:57
de la llamada al método 00:18:58
pero es que 00:19:04
es lo mismo 00:19:05
que poner 00:19:06
si b igual a true 00:19:07
me da lo mismo 00:19:08
decir que b doble 00:19:09
igual true 00:19:10
que b 00:19:11
es lo mismo 00:19:12
o sea 00:19:13
me da lo mismo decir 00:19:14
es el ejemplo de siempre 00:19:15
me da lo mismo decir 00:19:16
tú te llamas María 00:19:17
que decir 00:19:18
que tú te llames María 00:19:19
es verdad 00:19:20
o sea 00:19:21
si pongo b igual a true 00:19:22
estoy diciendo 00:19:23
que tú te llames María 00:19:24
es verdad 00:19:25
si pongo b 00:19:26
estoy diciendo 00:19:27
tú te llamas María 00:19:28
ambas cosas 00:19:29
son condiciones 00:19:30
son ciertas o falsas 00:19:31
es decir 00:19:32
todo esto 00:19:33
todo esto 00:19:34
es el resultado 00:19:35
del método 00:19:36
y el resultado 00:19:37
del método 00:19:38
es o true 00:19:39
o falsa 00:19:40
luego todo esto 00:19:41
es o true 00:19:42
o falsa 00:19:43
no hay otra 00:19:44
que es justo 00:19:45
lo quita un if 00:19:46
un if 00:19:47
necesita que le metamos 00:19:48
algo aquí 00:19:49
que sea true 00:19:50
o falsa 00:19:51
es lo único que nos pide 00:19:52
un if 00:19:53
esta misma 00:19:54
a ver 00:19:55
es que 00:19:56
a ver 00:19:57
condición 00:19:58
y boolean 00:19:59
son sinónimos 00:20:00
o sea 00:20:01
variable boolean 00:20:02
y condición 00:20:03
son sinónimos 00:20:04
de hecho una variable 00:20:05
boolean 00:20:06
una variable boolean 00:20:07
le puedes meter 00:20:08
una condición 00:20:09
o le puedes meter 00:20:10
cualquier cosa 00:20:11
que sea boolean 00:20:12
y el 00:20:13
pues pones no 00:20:24
le pones el no delante 00:20:25
si tú 00:20:26
lo contrario 00:20:27
le pones esto 00:20:28
claro claro 00:20:31
pues eso es 00:20:32
como una variable 00:20:33
que tiene dentro 00:20:34
true o falsa 00:20:35
como una variable 00:20:37
que tiene dentro 00:20:38
true o falsa 00:20:39
porque es el resultado 00:20:40
del método 00:20:41
y el resultado 00:20:42
del método 00:20:43
es esto 00:20:44
el resultado del método 00:20:45
es boolean 00:20:46
entonces todo esto 00:20:47
llamado con el 00:20:48
es boolean 00:20:49
entonces que tú 00:20:50
quieres el negado 00:20:51
de eso 00:20:52
el no delante 00:20:53
que quieres además 00:20:54
poner por ejemplo 00:20:55
si ha pedido gomas 00:20:56
y además 00:20:57
se llama 00:20:58
juanito 00:20:59
pues esto mismo 00:21:00
podrías 00:21:01
concatenarlo 00:21:02
con un and 00:21:03
así 00:21:04
es una cosa 00:21:05
vale 00:21:12
esto también sería 00:21:13
valido 00:21:14
claro 00:21:15
una condición 00:21:16
que sería 00:21:17
esto es true 00:21:19
es decir 00:21:20
que el nombre 00:21:21
está dentro del array 00:21:22
y además 00:21:23
nombre igual a juan 00:21:24
vale 00:21:25
o sea todo esto 00:21:26
tienes que verlo 00:21:27
con una variable 00:21:28
boolean 00:21:29
normal y corriente 00:21:30
porque es que es 00:21:31
el resultado 00:21:32
de un método 00:21:33
con una variable 00:21:34
boolean 00:21:35
porque lo pone aquí 00:21:36
claro si no devolviera 00:21:37
boolean 00:21:38
no puedo hacer esto 00:21:39
vale 00:21:40
entonces como esto 00:21:41
lo tienes que ver 00:21:42
como una variable 00:21:43
boolean 00:21:44
puedes combinarlo 00:21:45
con and 00:21:46
con or 00:21:47
con lo que haga falta 00:21:48
para hacer condiciones 00:21:49
más complejas 00:21:50
ponerle un no delante 00:21:51
cualquier cosa 00:21:52
que haces con un boolean 00:21:53
cualquier cosa 00:21:54
porque lo es 00:21:55
es el resultado 00:21:56
de ese método 00:21:57
que es un boolean 00:21:58
eso es 00:21:59
lo que es incuestionable 00:22:00
es que todo esto 00:22:01
es o true o false 00:22:02
lo combinas con and 00:22:03
con or 00:22:04
lo que tú quieras 00:22:05
luego 00:22:06
vale 00:22:07
vale 00:22:08
pues entonces 00:22:09
esta versión 00:22:10
abreviaría esto de aquí 00:22:11
y es más bonita 00:22:12
vale 00:22:13
entendiendo todo esto 00:22:14
que hemos dicho ahora 00:22:15
que no es que sea 00:22:16
especialmente fácil 00:22:17
de entender 00:22:18
pero bueno 00:22:19
hay que empezar 00:22:20
a familiarizarse 00:22:21
con eso 00:22:22
pues bueno 00:22:23
esto queda más bonito 00:22:24
si el resultado 00:22:25
de esto 00:22:26
es true 00:22:27
vale 00:22:28
entonces 00:22:29
si el resultado 00:22:30
de esto 00:22:31
lo que he metido 00:22:33
yo ahí es true 00:22:34
y lo que he metido 00:22:35
yo ahí 00:22:36
es el resultado 00:22:37
del método 00:22:38
si eso es true 00:22:39
mostraré esto 00:22:40
y si no esto 00:22:41
vale 00:22:42
pues si hago variable 00:22:43
intermedia 00:22:44
me da lo mismo 00:22:46
hace lo mismo 00:22:47
entonces vamos 00:22:48
a hacer que 00:22:49
por ejemplo 00:22:50
vamos a meterle 00:22:51
voy a 00:22:52
comentar esto 00:22:55
para que no me líe 00:22:56
el código 00:22:57
que es el system 00:22:58
out de arriba 00:22:59
código 00:23:00
descripción 00:23:01
aquí me mostraba 00:23:02
el que tenía 00:23:03
el código más grande 00:23:04
venga 00:23:06
pues vamos a hacer 00:23:07
los dos pedidos 00:23:08
y luego nos va a pedir 00:23:09
el nombre de un cliente 00:23:10
a ver 00:23:14
venga 00:23:19
vamos a 00:23:20
introduzca código 00:23:24
del pedido bolis 00:23:25
que era el primero 00:23:26
uno 00:23:27
introduzca descripción 00:23:28
pues la descripción 00:23:29
va a ser 00:23:30
bolis 00:23:31
vale 00:23:32
introduzca código 00:23:33
del pedido dos 00:23:34
dos 00:23:35
introduzca descripción 00:23:36
del pedido dos 00:23:37
pues ala 00:23:38
esta descripción 00:23:39
me da igual 00:23:40
ahora ya el programa 00:23:41
pues hacía esto 00:23:42
de aquí arriba 00:23:43
que es 00:23:44
le ponía 00:23:48
estas propiedades 00:23:49
a bolis 00:23:50
la que hemos leído 00:23:51
la descripción 00:23:52
a gomas 00:23:53
le ponía ese código 00:23:54
esa descripción 00:23:55
y ahora ya 00:23:56
se inventa 00:23:57
la raíz de clientes 00:23:58
que lo hemos inventado 00:23:59
lo hemos metido 00:24:00
hacia capón 00:24:01
por simplificar 00:24:02
porque meterle todos los clientes 00:24:03
por teclado 00:24:04
es un rollo 00:24:05
pues les hemos puesto tal cual 00:24:06
vale 00:24:07
y ahora me pide 00:24:08
el nombre del cliente 00:24:09
sabemos que 00:24:10
los bolis tienen 00:24:11
Luis y Juan 00:24:12
y los gomas tienen 00:24:13
Luis, Juan, Carlos y Marga 00:24:14
pues venga 00:24:15
le vamos a dar Carlos 00:24:16
y me va a tener que decir 00:24:17
que no ha pedido bolis 00:24:18
y si ha pedido gomas 00:24:19
vamos a ver 00:24:20
si lo hemos escrito bien 00:24:21
o no 00:24:22
a ver 00:24:25
porque como se me ha ido el este 00:24:26
a la descripción 00:24:29
vale 00:24:30
ahora 00:24:31
Carlos 00:24:32
venga 00:24:33
pues Carlos 00:24:34
efectivamente 00:24:35
no ha pedido bolis 00:24:36
pero si ha pedido gomas 00:24:37
claro 00:24:38
si volvemos a ejecutar esto 00:24:39
con uno que lo haya pedido 00:24:40
los dos 00:24:41
por ejemplo 00:24:42
Luis 00:24:46
que Luis 00:24:47
si ha pedido los dos 00:24:48
pues venga 00:24:53
uno 00:24:54
dos 00:24:56
Luis 00:25:00
ha pedido los dos 00:25:01
vale 00:25:02
¿veis? 00:25:08
entonces 00:25:09
la llamada es la misma 00:25:10
comprobar cliente 00:25:11
el resultado del método 00:25:13
es diferente 00:25:14
en función del objeto 00:25:15
que lo llame 00:25:16
es distinto 00:25:17
es distinto 00:25:18
en función del objeto 00:25:19
que lo llame 00:25:20
porque 00:25:21
cuando el método 00:25:22
se ejecute 00:25:23
la primera vez 00:25:25
este array de clientes 00:25:26
es el del pedido de bolis 00:25:27
y la segunda vez 00:25:29
este array de clientes 00:25:30
es el del pedido de gomas 00:25:31
vale 00:25:42
pues a ver 00:25:43
vamos a modificar 00:25:44
esta clase pedidos 00:25:45
para que sea 00:25:46
un poquito más bonita 00:25:47
y ahora 00:25:48
este método 00:25:49
que vamos a añadir 00:25:50
lo hacéis vosotros 00:25:51
a ver 00:25:52
vamos a 00:25:56
a escribir un par de ellos 00:25:57
pues venga 00:25:58
vale 00:26:04
pues vamos a hacer 00:26:05
un método 00:26:06
que 00:26:08
lo escribís vosotros 00:26:10
método 00:26:14
que recibe 00:26:15
una 00:26:17
una nueva 00:26:18
una descripción 00:26:19
y actualiza 00:26:21
la del objeto 00:26:27
con esa descripción 00:26:34
o sea esta es para actualizar 00:26:35
a ver 00:26:40
como es muy cortito de hacer 00:26:41
lo vais a hacer vosotros 00:26:42
pero lo vamos a 00:26:43
escribir aquí 00:26:44
vale 00:26:45
entonces este método 00:26:46
nos han dicho 00:26:47
el cliente que nos está pidiendo 00:26:48
la descripción 00:26:49
el usuario 00:26:50
nos dice 00:26:51
oye también voy a necesitar 00:26:52
de los pedidos 00:26:53
poder cambiar la descripción 00:26:54
porque hay veces que 00:26:55
me cambia la marca 00:26:56
de lo que tengo que servir 00:26:57
y en la descripción 00:26:58
quiero cambiar 00:26:59
la marca 00:27:00
porque si me han pedido 00:27:01
big 00:27:02
pero yo 00:27:03
luego solo tengo 00:27:04
pilot o lo que sea 00:27:05
pues le tengo que decir 00:27:06
no voy a cambiar 00:27:07
la descripción 00:27:08
bueno pues vale 00:27:09
pues es una utilidad 00:27:10
que puede ser 00:27:11
que haga falta 00:27:12
bueno pues entonces 00:27:13
uno ya automáticamente 00:27:14
en la isla 00:27:15
uno tiene que 00:27:16
en esa fase de análisis 00:27:17
apuntando todas 00:27:18
las funcionalidades 00:27:19
que tiene que hacer 00:27:20
pues ya hemos 00:27:21
identificado una segunda 00:27:22
poder cambiar 00:27:23
la descripción del pedido 00:27:24
porque me ha cambiado 00:27:25
la marca de lo que 00:27:26
tengo que servir 00:27:27
del producto 00:27:28
lo que sea 00:27:29
poder cambiarla 00:27:30
pues venga 00:27:31
como operaríamos aquí 00:27:33
primero 00:27:34
nombre del método 00:27:35
venga 00:27:36
que alguien me diga 00:27:37
un método 00:27:38
nombre de un método 00:27:39
que elegiría 00:27:40
perdón 00:27:41
actualizar descripción 00:27:42
actualizar descripción 00:27:43
actualizar descripción 00:27:44
actualizar descripción 00:27:45
actualizar descripción 00:27:46
actualizar descripción 00:27:47
más que 00:27:48
esto lleva en manías 00:27:49
a mí me 00:27:50
yo normalmente 00:27:51
uso las cosas 00:27:52
con el infinitivo 00:27:53
comprobar cliente 00:27:54
pero muchas veces 00:27:55
hay mucho 00:27:57
costumbre también 00:27:58
comprueba cliente 00:27:59
entonces eso 00:28:00
lleva en gustos 00:28:01
vale 00:28:02
o sea que 00:28:03
actualizar cliente 00:28:04
es una lección 00:28:05
actualiza cliente 00:28:06
es otra 00:28:07
va un poco 00:28:08
por manías 00:28:09
vale 00:28:10
pero bueno 00:28:11
en cualquier caso 00:28:12
porque hay 00:28:13
elementos 00:28:14
que son 00:28:15
pero bueno 00:28:16
en cualquier caso 00:28:17
porque hay las dos 00:28:18
explica perfectamente 00:28:19
lo que hace el método 00:28:20
vamos a poner 00:28:21
venga 00:28:22
actualiza descripción 00:28:23
ala 00:28:24
venga 00:28:25
el nombre 00:28:26
ya lo tenemos 00:28:27
siguiente pregunta 00:28:28
a ver 00:28:29
Ismael 00:28:30
que parámetro 00:28:31
de entrada 00:28:32
le pasamos 00:28:33
a este método 00:28:34
o que parámetros 00:28:35
si es que 00:28:36
le pasamos 00:28:37
alguno 00:28:38
que puede ser 00:28:39
que no 00:28:40
le pasemos 00:28:41
nada 00:28:42
¿de qué tipo? 00:28:43
¿de qué tipo? 00:28:44
¿de qué tipo? 00:28:45
vale 00:28:46
necesita 00:28:47
la nueva descripción 00:28:48
efectivamente 00:28:49
necesita la nueva 00:28:50
pues venga 00:28:51
necesita la nueva 00:28:52
pues string 00:28:53
vale 00:28:54
ahora 00:28:55
pregunta 00:28:56
ahora ya 00:28:57
con un poquito 00:28:58
más de truco 00:28:59
a ver 00:29:00
Claudia 00:29:01
tiene que devolver 00:29:03
me va a devolver 00:29:04
es necesariamente 00:29:05
un método 00:29:06
¿de qué tipo? 00:29:07
¿de qué tipo? 00:29:08
¿de qué tipo? 00:29:09
¿de qué tipo? 00:29:10
¿de qué tipo? 00:29:11
¿de qué tipo? 00:29:12
¿de qué tipo? 00:29:13
me va a devolver 00:29:14
es necesario que me devuelva 00:29:15
¿hay algún valor 00:29:16
de retorno? 00:29:17
a ver 00:29:18
no es una pregunta 00:29:19
sencilla 00:29:20
porque 00:29:21
tu dirías 00:29:22
que un string 00:29:23
¿el qué? 00:29:24
la nueva descripción 00:29:25
la que le estamos pasando 00:29:26
pues pensas 00:29:27
que es un poco raro 00:29:28
porque al método 00:29:29
ahora ponemos 00:29:30
en el chip 00:29:31
el me 00:29:32
yo le digo 00:29:33
al usuario 00:29:34
introduzca descripción 00:29:35
le damos al método 00:29:36
y el método 00:29:37
me devuelve 00:29:38
la descripción 00:29:39
¿y el método 00:29:40
me devuelve 00:29:41
la descripción? 00:29:42
le damos al método 00:29:43
y el método 00:29:44
me devuelve 00:29:45
la propia descripción 00:29:46
¿pa qué? 00:29:47
si ya se la acabo de meter 00:29:48
entonces es una cosa 00:29:49
un poco rara 00:29:50
entonces 00:29:51
en lugar de pensar 00:29:52
en el valor de retorno 00:29:53
vamos a cambiar 00:29:54
orden las preguntas 00:29:55
como parece que 00:29:56
esa pregunta 00:29:57
nos angustia un poco 00:29:58
y tiene sentido 00:29:59
que digamos 00:30:00
me tiene que devolver algo 00:30:01
vale, pues 00:30:02
vamos a saltárnosla 00:30:03
por ahora 00:30:04
vámonos aquí 00:30:05
vamos a codificar el método 00:30:06
este método 00:30:07
tiene que 00:30:08
coger 00:30:09
el parámetro 00:30:10
y usarlo 00:30:11
para actualizar 00:30:12
pisar 00:30:13
la descripción 00:30:14
del método 00:30:15
perdón 00:30:16
del objeto que lo llame 00:30:17
eso es lo que tiene que hacer 00:30:18
nada más 00:30:19
no le tiene que hacer 00:30:20
bueno, pues ahora 00:30:21
con esa información 00:30:22
os digo yo 00:30:23
¿qué tengo que escribir ahí? 00:30:24
que alguien me lo dicte 00:30:25
la clase es esta 00:30:26
¿vale? 00:30:27
venga 00:30:28
que me dicte alguien 00:30:29
tiene que coger este parámetro 00:30:30
y con este parámetro 00:30:31
actualizar 00:30:32
¿vale? 00:30:33
tiene que coger este parámetro 00:30:35
y con este parámetro 00:30:40
actualizar 00:30:41
pisar 00:30:42
darle valor 00:30:43
a la descripción 00:30:44
del objeto que llame 00:30:45
al método 00:30:46
y las propiedades 00:30:49
del objeto que llama 00:30:50
al método 00:30:51
¿dónde están? 00:30:52
declaradas 00:30:53
aquí arriba ¿no? 00:30:56
es lo que hemos dicho antes 00:30:58
el array de clientes 00:30:59
del objeto que llame 00:31:01
al método 00:31:02
el array de clientes 00:31:03
está declarado aquí arriba 00:31:04
la descripción está declarada 00:31:06
¿vale? 00:31:10
pues entonces 00:31:11
para asignar 00:31:12
a la descripción del objeto 00:31:13
que llama al método 00:31:15
el valor de esta variable 00:31:18
¿qué sentencia pondríais? 00:31:19
dictadmela tal cual 00:31:22
no penséis que estoy 00:31:23
preguntando nada raro 00:31:24
venga 00:31:25
que alguien me diga algo 00:31:28
descripción 00:31:30
sí, sí, sí 00:31:34
y nueva descripción 00:31:39
vale 00:31:45
vale 00:31:47
a ver 00:31:48
esto tiene por supuesto 00:31:49
efectivamente 00:31:50
esto es lo que yo 00:31:52
haga que me dijeráis 00:31:53
esto 00:31:55
¿vale? 00:31:56
este es el parámetro 00:31:57
de descripción 00:31:58
claro 00:32:01
ese es el parámetro 00:32:03
de descripción 00:32:04
que yo le paso 00:32:05
y ¿qué tengo que hacer 00:32:06
con él? 00:32:07
asignárselo 00:32:08
a la propiedad 00:32:09
de descripción 00:32:10
del objeto que lo llama 00:32:11
la propiedad de descripción 00:32:13
que se llama así 00:32:14
entonces 00:32:16
efectivamente la sentencia 00:32:17
es que es correcta 00:32:18
es esta 00:32:19
pero claro 00:32:20
automáticamente 00:32:21
aquí os surge 00:32:22
la pregunta de 00:32:23
descripción 00:32:24
igual a descripción 00:32:25
pero aquí hay mucha 00:32:26
descripción 00:32:27
entonces cuando yo aquí 00:32:28
pongo descripción 00:32:29
¿a qué descripción 00:32:30
me refiero? 00:32:31
a esta 00:32:32
a la propiedad de arriba 00:32:33
o sea esto 00:32:34
estoy asignando esta 00:32:35
a la otra 00:32:36
o esta a la otra 00:32:37
sería 00:32:38
he elegido mal el nombre 00:32:39
es que ya me vale 00:32:40
si he elegido mal el nombre 00:32:41
pues elijo un nombre mejor 00:32:42
imaginaos que yo he elegido 00:32:43
este 00:32:44
si yo he elegido este 00:32:46
la sentencia sería esta 00:32:49
y esto ya parece 00:32:51
que lo vemos más bonito 00:32:52
¿verdad? 00:32:53
el parámetro 00:32:54
de script 00:32:55
que actualiza 00:32:56
descripción 00:32:57
¿vale? 00:32:58
pero hombre 00:33:00
es obligatorio 00:33:01
es que entonces 00:33:03
tengo yo prohibido 00:33:04
tengo prohibido 00:33:05
para los restos 00:33:06
usar aquí el término 00:33:07
descripción 00:33:08
no, es que me da la gana 00:33:09
usar descripción 00:33:10
nada de script 00:33:11
nada 00:33:12
yo creo llamarlo descripción 00:33:13
porque me da la gana 00:33:14
con lo cual 00:33:15
¿cómo soluciono este problema? 00:33:16
este problema 00:33:17
vale, pues el problema 00:33:18
que se plantea 00:33:19
que es lo que quiero 00:33:20
que entendáis 00:33:21
es que aquí hay un problema 00:33:22
y es que hay una confusión 00:33:23
hay una ambigüedad 00:33:24
cuando yo aquí dentro 00:33:25
use descripción 00:33:26
hay una ambigüedad 00:33:27
que es 00:33:28
¿a quién me refiero? 00:33:29
¿a la propiedad pasada 00:33:30
desde fuera? 00:33:31
perdón 00:33:32
¿al parámetro pasado 00:33:33
desde fuera? 00:33:34
¿o me refiero a la propiedad 00:33:35
del objeto? 00:33:36
¿a quién me estoy refiriendo? 00:33:37
hay ambigüedad 00:33:38
porque se llaman igual 00:33:39
pues entonces 00:33:40
Java te dice 00:33:41
específicamente 00:33:42
hay ambigüedad 00:33:43
por favor 00:33:44
sácame de la ambigüedad 00:33:45
si tú 00:33:47
no me dices nada 00:33:48
y pones descripción 00:33:49
tal cual 00:33:50
yo voy a interpretar 00:33:51
que te refieres a esta 00:33:52
y si quieres referirte 00:33:54
a la propiedad 00:33:56
del objeto 00:33:58
entonces vas a tener que ponerle 00:33:59
un apellido delante 00:34:02
que sea este 00:34:04
ahora ya sí 00:34:07
de hecho el amarillo 00:34:09
que me ha aparecido detrás 00:34:10
ya fue el aviso 00:34:11
bueno pues 00:34:15
otra cosa 00:34:16
de las 3.512 00:34:17
que tenemos que incorporar 00:34:18
otra cosa a incorporar 00:34:20
¿qué es esto? 00:34:21
¿qué es el dis? 00:34:22
fundamental 00:34:23
el dis 00:34:24
pero ¿realmente se utiliza para esto? 00:34:25
o obviamente se cambia el nombre 00:34:26
de las del 00:34:27
claro 00:34:28
esto de hecho es un setter 00:34:29
que es el método básico 00:34:30
en cualquier entidad 00:34:31
eso no 00:34:37
porque cambiar el nombre 00:34:38
es una restricción 00:34:39
contra natura 00:34:42
descripción 00:34:43
los nombres de los parámetros 00:34:44
deberían ser 00:34:46
lo más explicativos posibles 00:34:47
¿por qué? 00:34:48
porque luego 00:34:49
cuando uno usa esta clase 00:34:50
cuando uno usa esta clase 00:34:51
imagínate que yo reutilizo esta clase 00:34:52
yo la reutilizo 00:34:55
entonces yo la entrego 00:34:56
cuando yo la reutilizo 00:34:57
la persona que la reutiliza 00:34:58
lo que va a hacer 00:34:59
va a ser llamar a los métodos 00:35:00
y la ayuda que va a tener 00:35:02
la ayuda que va a tener 00:35:04
para saber lo que eso hace 00:35:05
y cómo significa 00:35:07
van a ser estos nombres 00:35:08
entonces esos nombres 00:35:10
tienen que ser muy explicativos 00:35:11
y a mí me da la gana 00:35:12
llamarlo descripción 00:35:13
porque descripción 00:35:14
es mucho más explicativo 00:35:15
que descrip 00:35:16
descripción nueva 00:35:17
descripción bonita 00:35:18
me da la gana 00:35:19
llamarlo descripción 00:35:20
entonces Java no te puede prohibir 00:35:21
que tú lo llames 00:35:22
como a ti te dé la gana 00:35:23
entonces 00:35:24
de hecho 00:35:25
el convenio 00:35:26
es que se llamen 00:35:27
los parámetros 00:35:28
igual que los métodos 00:35:29
para obligarte al DIS 00:35:30
para obligarte 00:35:32
ya lo vamos a ver 00:35:33
con los LETTERS y los HETER 00:35:34
dime 00:35:35
¿cómo interpreta DIS? 00:35:37
vale 00:35:39
ahora 00:35:40
espera 00:35:41
vamos a revisarlo ahora 00:35:42
entonces 00:35:43
¿qué significa DIS? 00:35:44
DIS significa 00:35:45
el objeto en el que estoy 00:35:47
significa eso 00:35:49
el objeto en el que estoy 00:35:51
luego DIS 00:35:52
punto descripción 00:35:53
significa 00:35:55
propiedad 00:35:56
descripción 00:35:57
del objeto en el que estoy 00:35:58
y sin embargo 00:36:00
descripción sin el DIS 00:36:01
significa 00:36:03
el parámetro que me estás pasando 00:36:04
que viene por ahí 00:36:05
y ya está 00:36:06
¿vale? 00:36:08
pero imagínate que 00:36:10
tienes tú declarado 00:36:11
tres descripciones 00:36:12
pues cada una 00:36:13
¿dónde? 00:36:14
¿como variables de la clase? 00:36:15
en el código de grandes 00:36:16
en un código de grandes 00:36:17
hay tres descripciones 00:36:18
pero un código que está 00:36:19
¿dónde? 00:36:20
propiedades de la clase 00:36:21
pues cada una tiene que 00:36:22
llamar de su manera 00:36:23
o sea, eso sí que sí 00:36:24
obviamente 00:36:25
estas variables tienen que 00:36:26
llamar de forma distinta 00:36:27
cada una 00:36:28
¿eh? 00:36:29
no hombre 00:36:30
las variables se tienen que 00:36:31
llamar de forma diferente 00:36:32
siempre 00:36:33
tú nunca puedes declarar 00:36:34
variables 00:36:35
pero es que no queremos 00:36:36
cambiarla 00:36:37
que la propiedad 00:36:38
sea una descripción 00:36:39
porque está muy bien 00:36:40
elegida 00:36:41
porque describe 00:36:42
lo que significa 00:36:43
esa propiedad 00:36:44
que significa 00:36:45
descripción del objeto 00:36:46
y este parámetro 00:36:47
tampoco queremos cambiarlo 00:36:48
porque 00:36:49
explica muy bien 00:36:50
lo que significa 00:36:51
que es una descripción 00:36:52
que yo le estoy pasando 00:36:53
entonces 00:36:54
no la quiero cambiar 00:36:55
y por eso 00:36:56
tengo que usar el dis 00:36:57
y por eso 00:36:58
siempre 00:36:59
se usa el dis 00:37:00
el objeto dis 00:37:01
y el conocimiento 00:37:02
de esto es básico 00:37:03
y los getter 00:37:04
y los setter 00:37:05
que son 00:37:06
que ya veremos 00:37:07
dentro de poquito 00:37:08
que son 00:37:09
las formas de 00:37:10
modificar cada uno 00:37:11
de los objetos 00:37:12
se basan en el uso 00:37:13
del dis 00:37:14
tenéis que programar 00:37:15
bien 00:37:16
no diciendo 00:37:17
oye pero si hago este cambio 00:37:18
me va a quedar como 00:37:19
más intuitivo 00:37:20
hay que programar 00:37:22
bien 00:37:23
¿vale? 00:37:24
es decir 00:37:25
os tenéis que contratar 00:37:26
¿vale? 00:37:27
pues entonces 00:37:28
¿qué significa dis? 00:37:29
dis significa 00:37:30
el objeto 00:37:31
en el que estoy 00:37:32
con lo cual 00:37:33
dis. 00:37:34
será 00:37:35
propiedad 00:37:36
descripción 00:37:37
del objeto 00:37:38
en el que estoy 00:37:39
luego dis. 00:37:40
descripción 00:37:41
es la descripción 00:37:42
de arriba 00:37:43
es la descripción 00:37:44
de arriba 00:37:45
descripción 00:37:46
sin el dis 00:37:47
este parámetro 00:37:48
luego ya no hay 00:37:49
ambigüedad 00:37:50
ya no hay ninguna 00:37:51
ambigüedad 00:37:52
ya no hay ninguna 00:37:53
ambigüedad 00:37:54
¿vale? 00:37:55
entonces 00:37:56
este método 00:37:57
tiene que hacer 00:37:58
algo más 00:37:59
no ya está 00:38:00
ya hizo lo que 00:38:01
tenía que hacer 00:38:02
ya hizo lo que 00:38:03
tenía que hacer 00:38:04
que era cambiar 00:38:05
la propiedad 00:38:06
de descripción 00:38:07
ya no tiene que 00:38:08
hacer nada más 00:38:09
luego este método 00:38:10
ya ha cumplido 00:38:11
su función 00:38:12
¿verdad? 00:38:13
ya ha cumplido 00:38:14
su función 00:38:15
que es actualizar 00:38:16
ya ha cumplido 00:38:17
no tiene que hacer 00:38:18
nada más 00:38:19
se acabó 00:38:20
no tiene que hacer 00:38:21
nada más 00:38:22
¿no? 00:38:23
luego como respuesta 00:38:24
a la pregunta anterior 00:38:25
tengo que devolver 00:38:26
algún valor 00:38:27
¿tiene que haber 00:38:28
algún retún ahí? 00:38:29
no tiene que devolver 00:38:31
nada 00:38:32
ya ha hecho su función 00:38:33
ya ha cumplido 00:38:34
su función 00:38:35
que es actualizar 00:38:36
la propiedad 00:38:37
del objeto 00:38:38
ya la ha cumplido 00:38:39
luego entonces 00:38:40
¿qué valor de retorno 00:38:41
se pone? 00:38:42
¿qué tipo? 00:38:43
perdón 00:38:44
cuando no devuelve 00:38:45
y ahora está 00:38:47
este método 00:38:48
ya está completo 00:38:49
completo y estupendo 00:38:50
no devuelve nada 00:38:54
claro 00:38:55
el efecto 00:38:56
que tiene el método 00:38:57
es un efecto 00:38:58
que ya queda recogido 00:38:59
en la actualización 00:39:00
de la propiedad 00:39:01
ya queda ahí recogido 00:39:02
no hace falta 00:39:03
devolver nada 00:39:04
vale y ahora 00:39:16
si miramos 00:39:19
este método 00:39:20
con esto del DIS 00:39:21
que yo he dicho aquí 00:39:22
si miramos este método 00:39:23
y ahora os llevo 00:39:25
al de arriba 00:39:26
os llevo al de arriba 00:39:27
¿no surge una pregunta? 00:39:30
con esto que he dicho 00:39:34
del DIS 00:39:35
¿os vuelva a llevar 00:39:36
al código de arriba? 00:39:37
¿no surge la pregunta 00:39:41
de oye 00:39:42
que aquí has usado 00:39:44
la propiedad clientes 00:39:45
del objeto 00:39:46
y no has puesto 00:39:47
DIS punto clientes 00:39:48
¿no? 00:39:49
me deberíais decir 00:39:50
perdona 00:39:51
aquí estás usando 00:39:52
la propiedad de descripción 00:39:53
del objeto en el que estoy 00:39:54
que es esta de aquí arriba 00:39:57
y le estás poniendo el DIS 00:39:59
y aquí arriba 00:40:02
estás usando 00:40:03
la propiedad clientes 00:40:04
exactamente igual 00:40:05
que es una propiedad 00:40:06
de aquí arriba 00:40:07
y aquí no le estamos poniendo 00:40:08
el DIS 00:40:09
y ahí todo perfectamente 00:40:10
¿no? 00:40:11
y ¿por qué? 00:40:12
a veces sí y a veces no 00:40:13
porque el DIS es opcional 00:40:14
se pone solo 00:40:16
si lo necesito 00:40:17
para resolver ambigüedad 00:40:18
aquí es que solo hay una cosa 00:40:20
que se llama clientes 00:40:21
solo hay una 00:40:22
que es la de arriba 00:40:23
entonces no me hace falta 00:40:24
que lo quiera poner 00:40:25
magnífico 00:40:26
lo pongo 00:40:27
y mi programa queda estupendo 00:40:28
y muy claro 00:40:29
lo puedo poner tranquilamente 00:40:30
y el programa queda clarísimo 00:40:32
de hecho lo vais a encontrar 00:40:33
muchísimo más 00:40:34
que no lo vayáis a encontrar 00:40:36
porque 00:40:38
queda más claro 00:40:39
porque entonces 00:40:40
yo automáticamente 00:40:41
cuando vea este método 00:40:42
que es clientes 00:40:43
es la propiedad del objeto 00:40:44
la que está arriba 00:40:45
vale, lo deja muy clarito 00:40:46
pero cuando no hay ambigüedad 00:40:48
porque solo hay una propiedad 00:40:50
que se llame clientes 00:40:51
perdón 00:40:52
solo hay una variable 00:40:53
que se llama clientes 00:40:54
porque aquí no hay ninguna 00:40:55
que se llame clientes 00:40:56
pues es opcional 00:40:57
lo puedo quitar 00:40:58
si me da la gana 00:40:59
lo puedo quitar 00:41:00
¿vale? 00:41:01
si yo a este método 00:41:02
por la razón que fuera 00:41:04
vete a saber 00:41:05
le pasara cualquier cosa 00:41:06
que se llamara clientes 00:41:07
imagínate que le llamo aquí 00:41:09
pues cualquier cosa 00:41:10
cualquier chorrada 00:41:11
que se llama clientes 00:41:12
automáticamente 00:41:13
apareció la ambigüedad 00:41:14
entonces al aparecer 00:41:16
la ambigüedad 00:41:17
el dis 00:41:18
ahora ya es obligatorio 00:41:19
y cuando yo ponga dis 00:41:21
me referiré a la raíz de arriba 00:41:22
y cuando ponga clientes 00:41:24
sin más 00:41:25
me referiré al parámetro 00:41:26
por ejemplo 00:41:28
imaginaos que quiero 00:41:29
mostrar ese parámetro 00:41:30
yo que sé 00:41:31
perfectamente me deja 00:41:34
y me estoy refiriendo 00:41:36
a dos cosas distintas 00:41:37
clientes 00:41:39
es este parámetro 00:41:40
estoy pasando 00:41:41
y dis.clientes 00:41:43
es la propiedad clientes 00:41:45
del objeto que llame al método 00:41:46
resuelta la ambigüedad 00:41:49
no hay problema 00:41:50
entonces esta situación es 00:41:54
constante 00:41:55
obviamente 00:41:56
que los nombres de los parámetros 00:41:57
y los nombres de las propiedades 00:41:59
de la clase 00:42:00
sean iguales 00:42:01
porque suelen significar 00:42:02
lo mismo 00:42:03
en la vida real 00:42:04
me refiero 00:42:05
su significado real 00:42:06
es lo mismo 00:42:07
entonces si su significado real 00:42:08
es lo mismo 00:42:09
porque una aplicación 00:42:11
tiene que ser clara 00:42:12
al ojo humano 00:42:13
y al entendimiento humano 00:42:14
entonces si el parámetro 00:42:15
de descripción 00:42:16
significa la descripción 00:42:17
del objeto 00:42:18
y la propiedad del objeto 00:42:19
indica la descripción 00:42:20
que se llame descripción 00:42:21
los dos 00:42:22
¿por qué le voy a cambiar 00:42:23
uno del nombre? 00:42:24
no, para eso tengo 00:42:25
el objeto dis 00:42:26
para distinguir 00:42:27
uno del otro 00:42:28
¿vale? 00:42:29
pero claro 00:42:30
repito 00:42:31
si no hay ambigüedad 00:42:32
me lo puedo ahorrar 00:42:33
entonces si aquí 00:42:34
yo no tenía 00:42:35
este parámetro clientes 00:42:36
que era mi caso 00:42:37
yo no tenía 00:42:38
clientes 00:42:39
porque no lo tenía 00:42:40
entonces no hay 00:42:44
ninguna ambigüedad 00:42:45
clientes 00:42:46
solo puede ser 00:42:47
la de arriba 00:42:48
solo puede ser esa 00:42:49
no hay ninguna 00:42:50
pues si me da la gana 00:42:51
quito el dis 00:42:52
si me da la gana 00:42:53
eso ya es a mi elección 00:42:54
si me da la gana 00:42:55
lo quito 00:42:56
y si no, no 00:42:57
¿vale? 00:42:58
muy a menudo 00:42:59
se conserva 00:43:00
para evitar 00:43:01
a lo mejor errores 00:43:02
porque imagínate 00:43:03
que uno 00:43:04
amplía este método 00:43:05
con algo 00:43:06
y al ampliarlo 00:43:07
este método es muy largo 00:43:08
y añade una 00:43:09
una variable 00:43:10
por ahí 00:43:11
que se llame clientes 00:43:12
pues creo la ambigüedad 00:43:13
automáticamente 00:43:14
y si no tenía el dis 00:43:15
puesto ahí 00:43:16
va a tener que empezar 00:43:17
a revisarlos todos 00:43:18
para ponerlo 00:43:19
entonces siempre 00:43:20
es buena práctica 00:43:21
conservar el dis 00:43:22
si es un código 00:43:23
urgentemente largo 00:43:24
para que a lo mejor 00:43:25
pase eso 00:43:26
que yo le añado 00:43:27
una propiedad 00:43:28
que no es igual 00:43:29
y ya está 00:43:30
ya tenemos liada 00:43:31
con la ambigüedad 00:43:32
¿vale? 00:43:33
bueno pues 00:43:36
de nuevo 00:43:37
muy importante 00:43:38
esto 00:43:39
¿vale? 00:43:40
entonces la forma correcta 00:43:41
de hacer este método 00:43:42
sería esta 00:43:43
llamarlo igual 00:43:44
porque significa lo mismo 00:43:45
en la realidad 00:43:46
es el mismo concepto 00:43:47
y la aplicación 00:43:48
tiene que representar 00:43:49
un modelo real 00:43:50
vale 00:43:55
venga vamos a parar 00:43:58
un par de minutos 00:43:59
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
18 de diciembre de 2023 - 14:01
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
839.01 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid