Saltar navegación

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

Clase 18-03-24 - 1 - Contenido educativo

Ajuste de pantalla

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

Subido el 3 de abril de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues a ver, insisto. Obviamente tiene bastante interés que los que no lo hayáis clavado especialmente, los que les haya resultado facilísimo y lo hayáis clavado, pues no. 00:00:00
Pero los que no, pues vayáis siguiendo la corrección. 00:00:13
Claro. 00:00:16
Leche. 00:00:18
Vale, pues venga. 00:00:21
Vamos a empezarlo, ¿vale? 00:00:25
a ver, Andoni 00:00:35
y Moisés 00:00:44
os calláis 00:00:45
¿qué ha pasado? 00:00:46
que Moisés no estaba haciendo nada 00:00:54
dado la vuelta 00:00:56
señándome ahí el torso 00:00:58
digo, la espalda 00:01:01
A ver, así estaba, ha dado la vuelta 00:01:05
Eh, no, pero os lo paso luego 00:01:08
Vale, silencio 00:01:17
A ver, silencio 00:01:23
Venga, pues entonces 00:01:26
Nosotros lo vamos a ir haciendo como se supone 00:01:28
Que lo ibais haciendo vosotros en el examen 00:01:30
Y por tanto encontrándoos las cosas raras 00:01:32
Diciendo, ¿y ahora qué hago con esto? 00:01:34
No es que lo vaya a hacer yo así 00:01:36
Ah, lo haces en el examen, perfecto 00:01:37
no, puede que haga alguna burrada 00:01:38
también, como seguramente a lo mejor 00:01:40
hicisteis vosotros 00:01:42
díganme 00:01:44
¿por qué? por el 2, si el 2 lo hacemos en un pijas 00:01:45
¿para qué? ¿para animarte? 00:01:50
¿quieres empezar por el 2 para animarte? 00:01:55
a ver, por el 1 00:01:57
que tenéis que estar más frescos mentalmente 00:01:58
¿vale? 00:02:00
venga, pues ya está 00:02:03
aquí se supone que uno lo leía 00:02:04
hasta que lo entendía, yo os lo leí 00:02:06
de cabo a rabo para explicar bien 00:02:08
cómo tenía que funcionar y de hecho 00:02:10
os di bastantes pistas 00:02:11
sobre cómo solucionar algunos problemas. 00:02:14
Os expliqué algunas cosas 00:02:16
sobre cómo 00:02:18
podríais solucionar algunos problemas. 00:02:18
Entonces, bueno, esa parte de entender 00:02:21
cómo funciona y todo eso, 00:02:23
pues uno ya la tiene hecha y ha entendido 00:02:26
de qué va esto. Ahora ya empieza a programar 00:02:28
porque ya ha entendido más o menos 00:02:30
el conjunto del ejercicio de qué va. 00:02:31
Entonces, cuando ya lo ha entendido, el conjunto 00:02:34
del ejercicio de qué va y tiene en su cabeza 00:02:36
un poquito, algunas ideas 00:02:37
sobre el diseño, ya se puede 00:02:40
empezar a programar, pero no se pone uno 00:02:42
directamente a jimineas de código 00:02:44
sin haber pasado esa fase, directamente 00:02:45
venga, carta, me hago la carta, baraja 00:02:47
me hago la baraja, no, se pone uno entero 00:02:50
entiende en su conjunto 00:02:52
se para a pensar un poco 00:02:54
en él, luego ya dice, venga 00:02:56
yo creo que esto más o menos va a tener este aspecto 00:02:57
y ahora ya empieza 00:03:00
venga, pues empezamos porque 00:03:01
esa fase, repito, ya la hemos hecho 00:03:03
pues hala, una carta 00:03:05
Se caracteriza por el palo, que será un string 00:03:07
Y el número de carta, que será un entero 00:03:10
Pues ala, hacemos entonces eso 00:03:13
Lo voy a poner todo en el mismo paquete 00:03:16
Ejercicio 1 00:03:19
Y así no voy a separar ni el main 00:03:20
Ni el modelo de datos, ni nada 00:03:22
¡Los de atrás, callaos! 00:03:24
¿Cómo que no se ve? 00:03:30
A ver, espérate un segundo 00:03:32
A ver, carta 00:03:34
vale 00:03:39
ya está, carta 00:03:40
vale, pues la carta tendrá 00:03:46
hemos dicho, su palo, que como es 00:03:49
oros, copas, espadas, bastos, pues tendrá que ser 00:03:51
un string 00:03:53
y su numerito 00:03:53
aquí es donde caería 00:03:58
que ni pintado 00:04:07
el concepto, que a lo mejor os suena a algunos 00:04:08
tipo enumerado, pero como no lo hemos 00:04:12
visto, pues no lo podemos usar, no lo hemos visto todavía 00:04:15
o sea, un tipo enumerado es 00:04:17
un tipo 00:04:19
que solo tiene un conjunto finito de valores 00:04:20
posibles 00:04:22
y este es el caso, porque el palo 00:04:23
solamente puede tener oros 00:04:26
copas, espadas y bastos 00:04:28
entonces hemos puesto un string 00:04:30
el string no se adapta en realidad muy bien 00:04:32
porque un string puede ser cualquier cosa 00:04:34
también podría yo poner el palo de bastitos 00:04:36
¿vale? 00:04:38
entonces lo ideal sería ahí hacer un tipo 00:04:40
enumerado que se llaman, pero no lo hemos 00:04:42
visto todavía, entonces 00:04:44
obviamente no lo podemos incorporar 00:04:45
Pero bueno, que os vaya sonando, un tipo enumerado es un tipo que restringe los posibles valores a un conjunto finito. 00:04:47
Entonces los posibles valores de este queremos que sean oros, copas, espadas y bastos, solo eso, no queremos que sean más. 00:04:58
Pues justo, esa es la definición de tipo enumerado. 00:05:04
Un tipo enumerado es un tipo que solo tiene un conjunto finito de valores posibles. 00:05:07
bueno, aquí lo ideal sería ponerlo 00:05:13
pero como no lo hemos puesto, lo dejamos 00:05:16
string, pues string, el palo es string 00:05:18
vale, entonces aquí 00:05:20
haríamos lo de siempre 00:05:22
entonces aquí pues habríais hecho 00:05:24
habréis hecho los getty set 00:05:26
y seguramente 00:05:29
pues hayáis hecho algún 00:05:30
constructor y ya está 00:05:32
entonces en principio 00:05:40
pues uno lo deja así 00:05:41
y luego según va avanzando 00:05:44
a lo mejor tiene que volver aquí 00:05:46
para decir, a ver, voy a usar carta en este tipo 00:05:48
de colección. Entonces voy a 00:05:50
necesitar un icon. Yo necesito... 00:05:52
Vale, bueno, podéis añadir un toString. Bueno, 00:05:54
en principio esta es la información básica. 00:05:57
Luego uno, según va avanzando 00:05:59
la aplicación, dice, ah, me interesa meter en 00:06:00
carta este método. Bueno, pues entonces vuelve y lo mete. 00:06:02
Pero ahora mismo lo podemos 00:06:05
dejar así. ¿Vale? 00:06:07
Bueno, pues uno sigue avanzando 00:06:09
con la enunciada y dice, ya tengo carta. Vale. 00:06:10
Baraja. Pues venga, 00:06:13
vamos a hacer la siguiente clase. 00:06:14
vale, la clase baraja nos dicen 00:06:16
oye, la clase baraja se caracteriza 00:06:26
solo por el 00:06:28
conjunto de cartas que contiene la baraja 00:06:30
que tiene que ser un set 00:06:33
vale, pues 00:06:34
entonces, la clase 00:06:36
baraja se caracteriza 00:06:38
solo, en principio, pues lo ponemos 00:06:40
así, por el conjunto de cartas 00:06:42
que tiene que ser un set 00:06:44
de cartas, estas son 00:06:45
las cartas de la baraja 00:06:53
al nombre de la variable 00:06:54
pues llamadla como mejor 00:06:56
os apañéis 00:06:58
entonces 00:07:00
aquí como hemos dicho siempre 00:07:01
cuando tenemos un tipo, una propiedad 00:07:04
de tipo colección 00:07:06
en ese punto la solemos 00:07:07
instanciar, para aunque siga 00:07:10
estando vacía, al menos 00:07:12
no sea null, entonces sigue estando 00:07:14
vacía, ya la rellenaré de cartas 00:07:16
cuando este objeto aparezca 00:07:19
o cuando la aplicación me diga, ya la rellenaré 00:07:20
pero ahora mismo al menos la dejo instanciada 00:07:22
para que no haya ahí un null 00:07:24
que los null, pues pueden molestar 00:07:26
si alguien se dedica a hacer un cartas.size 00:07:28
por ejemplo, si hacen algo en cartas.size 00:07:31
pues 00:07:33
si no está inicializada, pues le sale 00:07:34
un null pointer exception, y si está inicializada 00:07:36
le sale 0, que es mucho mejor que te salga 00:07:39
0 que un null pointer exception 00:07:41
vale, bueno, lo bajo 00:07:43
aquí para que se vea bien 00:07:45
entonces 00:07:46
este es el que hemos visto 00:07:47
entonces, este de aquí 00:07:50
importamos 00:07:55
bueno, pues entonces ahora ya 00:07:56
llegados a este punto, es cuando uno de repente 00:08:04
tal cual 00:08:06
tiene que hacer ya la conexión 00:08:08
neuronal 00:08:10
que dice 00:08:11
en mi aplicación 00:08:12
hay un haset 00:08:16
de objetos 00:08:17
carta 00:08:20
pues para que un haset de objetos carta 00:08:21
funcione correctamente 00:08:24
en la clase 00:08:26
carta tienen que estar declarados 00:08:28
que métodos y el hash code 00:08:30
entonces automáticamente 00:08:35
desde el momento en que uno 00:08:37
ve que en su aplicación 00:08:38
en la clase que sea, da igual, en su aplicación 00:08:40
entra en juego 00:08:43
un hash set de objetos 00:08:44
carta, para que el hash set funcione 00:08:46
correctamente y haga 00:08:49
los add detectando duplicados 00:08:51
funcione con los remove 00:08:52
porque si no hay, funcione con el 00:08:54
contains para que sus métodos funcionen 00:08:57
como hemos dicho mil veces 00:08:58
en esta clase tiene que estar 00:09:00
el hascod y el equals, porque si no 00:09:03
el remove, el método equals no 00:09:05
le va a funcionar, y el método contains tampoco 00:09:06
porque va a tirar del hascod y el equals 00:09:09
de object, y eso son por dirección de 00:09:11
memoria, no son por propiedades 00:09:13
pues entonces aquí rápidamente, en cuanto uno 00:09:14
hace esto, hace ya la conexión neuronal 00:09:17
y se va a carta 00:09:18
y eso no lo habéis hecho prácticamente nadie 00:09:19
el hascod y el equals en 00:09:22
carta ha sido una rareza 00:09:25
y esto sí que no es de pensar 00:09:26
esto es de 00:09:30
pues a ver, de alguna manera he estudiado y he trabajado 00:09:31
no es de pensar 00:09:34
pero vamos, no 00:09:35
os echo broncas, lo que os trato 00:09:36
es de incidir en las 00:09:40
cosas 00:09:42
venga, pues entonces 00:09:42
ahora 00:09:46
cuando decidimos el 00:09:49
jasco de equals 00:09:52
o sea, antes de ponerlo, ahora es cuando nos hacemos la 00:09:53
pregunta, vamos a ver 00:09:56
¿qué propiedades marcan la unicidad 00:09:57
de mi carta? 00:10:00
El palo, el número, la combinación de los dos 00:10:01
En este caso, la combinación de los dos 00:10:06
Es decir, dos cartas con el mismo palo no tienen por qué ser la misma 00:10:10
Puede ser el 3 de oros y el 3 de copas 00:10:14
Y dos cartas con el mismo número no tienen por qué ser la misma 00:10:17
Puede ser el 3 de oros y el 3 de copas 00:10:21
entonces 00:10:24
dos cartas van a ser iguales 00:10:26
solo si, si tienen 00:10:28
el mismo palo y el mismo número 00:10:30
entonces sí, el 3 de copas 00:10:32
y el 3 de copas son la misma carta 00:10:34
aunque estén en direcciones de memoria distintas 00:10:36
3 de copas y 3 de copas 00:10:39
son la misma, sin embargo 00:10:40
3 de oros y 3 de copas, ¿no? 00:10:42
y 3 de copas y 7 de copas 00:10:45
tampoco, luego para que 00:10:46
dos cartas sean la misma tienen que tener 00:10:48
el mismo palo y el mismo número 00:10:50
entonces ahora, una vez que uno 00:10:52
ya ha caracterizado eso 00:10:55
ahora ya hace el hashcode y el equals 00:10:56
basada en las dos propiedades 00:10:58
¿vale? cuando hacíamos el hashcode 00:11:00
y el equals basado en una única propiedad 00:11:03
como nif, como código 00:11:04
es porque dos objetos con mismo nif eran el mismo 00:11:06
o dos objetos con mismo código eran el mismo 00:11:08
pero es que aquí para que dos cartas 00:11:10
sean la misma, tienen que tener el mismo 00:11:12
palo y el mismo número 00:11:14
las dos cosas 00:11:16
pues entonces 00:11:17
hacemos aquí 00:11:19
el Hasco de Equals 00:11:21
basado en las dos propiedades 00:11:23
ala 00:11:25
entonces ya podemos volver aquí ya tranquilos 00:11:28
ya hemos hecho 00:11:31
un HashSet de objetos carta 00:11:33
y esto ya todos sus métodos 00:11:34
remove, contains, add 00:11:36
van a funcionar de forma coherente 00:11:38
con las cartas 00:11:40
si yo tengo en mi baraja un 3 de copas 00:11:42
e intento hacer un add 00:11:44
de un 3 de copas, no lo va a hacer 00:11:46
no lo va a hacer porque ya tengo el Hasco de Equals 00:11:48
antes de tener el hashcode del equal, si yo tenía un 3 de copas 00:11:51
en mi baraja y le hago un add 00:11:54
de otro 3 de copas, lo va a meter también 00:11:55
porque le va a parecer 00:11:57
que son distintos, porque no tiene el hashcode 00:12:00
del equal y no queremos eso, no queremos 00:12:02
dos 3 de copas en la baraja 00:12:03
¿vale? bueno, pues entonces 00:12:05
fundamental, esto 00:12:07
fundamental 00:12:09
y basado en las propiedades 00:12:10
que lo identifican de forma única 00:12:13
vale, pues 00:12:15
nada, esta es nuestra baraja 00:12:18
Entonces, podemos hacer el get set de esto de aquí 00:12:19
Y ahora, dejo el constructor después 00:12:23
Porque si uno lee lo que viene por aquí, le dice 00:12:30
A ver, cuidado 00:12:33
El constructor sin parámetros lo vas a hacer 00:12:34
Para que dentro de él 00:12:37
Se construya una baraja de 40 cartas 00:12:39
Porque como todas las barajas en el momento inicial 00:12:42
Sabemos las propiedades que van a tener 00:12:46
Todas las barajas, cuando inician 00:12:48
En esta aplicación concreta, van a ser 00:12:51
40 capas de cartas 00:12:53
del 1 al 10 de cada palo 00:12:55
hay otros objetos que cuando se crean 00:12:57
cada uno se crea con propiedades distintas 00:13:00
en el arranque, yo creo un objeto alumno 00:13:02
y uno se creará rubio, y otro no, y otro no sé qué 00:13:04
pero aquí cada vez que yo creo una baraja 00:13:06
todas se crean iguales 00:13:08
40 cartas 00:13:10
entonces el constructor 00:13:11
que ya haga esa construcción en el inicio 00:13:13
es lo que me está diciendo 00:13:16
bueno pues nada, hacemos aquí 00:13:18
el constructor sin parámetros 00:13:20
Como me habían dicho 00:13:22
El constructor de baraja 00:13:23
Y ahora aquí se trata de meter las 10 cartas 00:13:27
¿Vale? 00:13:30
Pues entonces, aquí ya 00:13:31
A ver 00:13:33
Veo de todo, pero es que 00:13:36
Se trata de no ser vago 00:13:39
Y no hacer esto 00:13:42
Que se supone que sois programadores 00:13:44
Es decir 00:13:46
Se supone, ¿no? 00:13:48
Lo sois 00:13:51
Es decir 00:13:51
no se trata 00:13:56
de escribir esta línea 00:13:58
40 veces 00:14:00
40 veces 00:14:02
y en cada una de ellas cambiar esto 00:14:04
ahora otras 10 00:14:06
copas 1, copas 2, otras 10 00:14:08
hombre 00:14:10
que funciona así, pero es que 00:14:11
sois programadores 00:14:14
no escribáis 40 líneas 00:14:15
para qué están los bucles 00:14:18
y si la baraja es una baraja de 300 cartas 00:14:19
de esas raras de rol 00:14:24
Pues 300 líneas 00:14:26
Entonces, hombre, para eso están los bucles 00:14:29
Entonces, hombre, a ver 00:14:32
Se puede hacer 00:14:34
Desde lo más reducido de todo 00:14:35
Hasta intermedio 00:14:37
Lo más natural, pues a lo mejor es hacerse 4 bucles 00:14:38
Lo que os ha salido a casi todos 00:14:41
Es hacer 4 bucles for que interen con esto 00:14:43
El primer bucle for para oros 00:14:46
El segundo para copas 00:14:47
Vale, eso sería una opción 00:14:50
Bueno, ya intermedia 00:14:52
No esta, por ejemplo 00:14:54
Las voy a hacer las dos 00:14:55
Pues para que nos sirva todo esto 00:14:57
Como repaso incluso 00:14:59
Básico desde el principio 00:15:00
Vale, pues bueno 00:15:02
Repetir este bucle cuatro veces 00:15:26
Vale, vale, tampoco ya 00:15:28
Es algo un poquito más profesional realmente 00:15:29
Y es un poco lo que 00:15:31
Esperábamos que hicierais 00:15:39
Pues la mayoría 00:15:40
Bueno, pues este constructor 00:15:41
Vale, bueno, es decente 00:16:02
Es decente 00:16:03
rellena con 00:16:05
40 cartas 00:16:06
10 de oros, 10 de copas, 10 de espaldas y 10 de vasos 00:16:09
pero insisto 00:16:11
este add funciona 00:16:12
si se ha hecho el hascode y el equals 00:16:15
funciona correctamente 00:16:17
si no se ha hecho el hascode y el equals 00:16:19
y si yo aquí me he equivocado 00:16:21
hago dos veces este for por ejemplo 00:16:24
no me va a detectar los duplicados 00:16:27
y me va a meter dos veces la misma 00:16:30
y si hemos hecho un hasset 00:16:31
Precisamente es porque no queremos duplicar 00:16:34
¿Vale? 00:16:36
Bueno, entonces, a ver 00:16:39
Si queremos hacerlo más profesional todavía 00:16:40
Hacemos, hombre, cuatro for 00:16:42
Y si me hago otro for que lo contenga iterando 00:16:43
Por oros, copas, espadas y bastos 00:16:46
Pues eso sería todavía mucho más bonito 00:16:48
¿No? 00:16:50
Por ejemplo 00:16:52
¿Qué otra versión podríamos hacer? 00:16:53
Nos vamos a hacer un string 00:16:56
Una raíz de string 00:16:58
Con los cuatro palos 00:17:00
Así 00:17:02
vale, a ver 00:17:06
ah, es que aquí me falta este 00:17:26
vale, nos vamos a hacer 00:17:29
un string con los cuatro 00:17:31
palos, vale, recordad 00:17:33
no olvidéis que esto era una forma 00:17:35
en la cual uno podía 00:17:36
cuando declaraba un array 00:17:38
y en el momento de declararlo solo 00:17:40
una vez que estaba declarado ya no puedes asignarle un valor 00:17:42
de este tipo 00:17:45
recordad que cuando uno declaraba un array 00:17:46
de lo que fuera, podía 00:17:49
crearlo e inicializarlo 00:17:50
todo junto a la vez, poniendo entre llaves 00:17:52
los valores que dirán la gana 00:17:55
entonces si hacemos esto 00:17:56
ahora podemos iterar por aquí 00:17:59
y en cada parada 00:18:01
a su vez hacer ya el bucle 00:18:03
de dentro, entonces nos queda un código 00:18:05
pues de bastantes menos líneas 00:18:07
podríamos hacer esto 00:18:09
podemos hacer 00:18:11
vamos a iterar por los palos 00:18:19
desde igual a 0 00:18:21
mientras si sea menor que palos.led 00:18:23
que es 4 00:18:25
incrementando y 00:18:26
Pues ahora ya sí que hacemos esto 00:18:28
Bueno, me falta el for de dentro, claro 00:18:30
Ahora hacemos 00:18:34
Desde j igual a 1 00:18:37
Mientras j sea menor o igual que 10 00:18:40
Incrementando j 00:18:43
Ahora ya sí que hacemos 00:18:46
Pero aquí ponemos palos de i 00:18:49
Y aquí j 00:18:51
Vale, pues esta es otra versión de lo de arriba 00:18:55
Que hace lo mismo 00:18:59
Pero bueno, esta es un poquito más bonita 00:19:00
¿Vale? 00:19:04
El bucle de arriba va pasando 00:19:09
Por oros, copas, espadas y bastos 00:19:11
Entonces, palos de ahí 00:19:13
En la primera iteración es oros 00:19:14
En las segundas copas, donde espadas y donde bastos 00:19:16
Y ahora el de abajo, para cada palo en concreto 00:19:18
Para cada palo crea la pieza 00:19:21
¿Vale? 00:19:23
Entonces, bueno, hombre, esta más bonita que la de arriba 00:19:26
Entonces voy a dejar en la corrección 00:19:28
Puestas las dos 00:19:31
Pero para que no se me... 00:19:32
Porque en realidad 00:19:35
aunque esté hecho dos veces 00:19:36
si llamáis a este constructor 00:19:40
esto no lo va a meter 00:19:42
porque va a ver 00:19:44
que esta carta está duplicada 00:19:46
porque es un haset 00:19:48
entonces yo voy a dejar los dos códigos 00:19:51
puestos 00:19:54
para cuando se suba la corrección 00:19:55
veáis las dos versiones 00:19:58
y no afecta al funcionamiento 00:19:59
no afecta al funcionamiento 00:20:02
precisamente por cómo funciona el haset 00:20:05
Aquí ya hemos metido 40 cartas 00:20:06
Y cuando aquí intentemos meterlas otra vez 00:20:09
Como va a detectar que están duplicadas 00:20:12
Porque el 1 de oro ya existe 00:20:14
El 2 de oro ya existe 00:20:15
El 1 de espadas ya existe 00:20:16
Pues este add no va a meter nada 00:20:18
Va a meter nada porque es un hash set 00:20:20
Y hemos hecho el hasco de equals 00:20:22
Si no hubiéramos hecho el hasco de equals 00:20:24
Aquí en carta 00:20:27
Si no lo hubiéramos hecho 00:20:28
El hasco de equals 00:20:30
Esto metería 80 cartas en la baraja 00:20:31
Luego este mismo código 00:20:35
Mete 40 cartas 00:20:38
O mete 80 00:20:39
En función de si en carta hemos hecho 00:20:40
Fasco de hijos o no hemos hecho 00:20:43
¿Vale? Importante entender eso 00:20:44
Bueno, pues nada 00:20:48
El constructor de baraja ya está 00:20:50
Vale 00:20:53
La baraja ya estaría 00:20:56
Bueno 00:21:00
Y ahora, la clase jugador 00:21:03
Que es la tercera clase entidad 00:21:06
Y luego ya viene el main 00:21:09
Y la clase jugador, pues ya tiene tres métodos 00:21:11
Entonces esta ya es más 00:21:13
Más rarita 00:21:14
Vale, pues venga 00:21:17
La clase jugador 00:21:35
¿El jugador por qué se caracteriza? 00:21:37
Pues el jugador se caracteriza 00:21:39
Se caracteriza por su nombre, los puntos que tiene y las cartas que tiene en la mano en cada momento, que tiene que ser una lista. 00:21:41
Silencio. 00:21:54
Vale, pues entonces el jugador se caracteriza por su nombre, los puntos que tiene y las cartas que tiene, que va a ser una lista de cartas, nos han dicho. 00:21:56
Entonces, estas son las cartas que tiene en la mano, cartas jugador, por ejemplo, y lo de siempre, no es mala costumbre, no es mala costumbre, pues ya dejar este objeto instanciado, vacío, sin cartas, pero instanciado. 00:22:17
Entonces pues aquí lo que más le guste a uno 00:22:33
Como lo que estamos 00:22:36
El juego al final va a ser todo el rato 00:22:39
Echar la carta, robar, echar, robar 00:22:41
Echar, robar 00:22:44
Pues cuando uno está echando y robando 00:22:45
Echando y robando, echando y robando 00:22:47
Un ArrayList es una locura 00:22:48
Entonces pues siempre sería mejor un LinkedList 00:22:49
Pues muy bien Moisés 00:22:51
Vale 00:22:55
Bueno entonces uno por sistema 00:23:02
Por defecto haría ya GetSet y Constructores 00:23:06
Y luego ya se pone en el trabajo duro 00:23:08
Que es los métodos de esa clase 00:23:10
Que esta ya sí que tiene métodos 00:23:12
Venga, vamos a hacer un constructor 00:23:13
Aquí es útil 00:23:20
Con nombre y puntuación 00:23:24
Y así podemos iniciar un jugador sin cartas 00:23:26
¿Vale? 00:23:29
Tenemos un constructor con nombre y puntuación 00:23:31
Solamente 00:23:33
Y las cartas por ahora vacías 00:23:33
Ahí ese constructor 00:23:36
Pues siempre queda mejor, ¿no? 00:23:38
Cuando una propiedad es colección 00:23:39
Pues un constructor que inicialice todo 00:23:41
Menos lo que es colección 00:23:44
Y luego las colecciones ya se irán metiendo 00:23:45
Pero bueno, que luego nos hace falta otro 00:23:47
Según hagamos el programa vemos que 00:23:49
Uy, me viene bien un constructor que meta esto 00:23:51
Pues lo añadimos después, no pasa nada 00:23:52
Venga, como hemos deshabilitado el constructor sin parámetros 00:23:54
Pues vamos a hacerlo 00:23:58
Que siempre viene bien también un constructor sin parámetros 00:23:59
Get y set 00:24:05
Y ala 00:24:07
Estupendo 00:24:13
Pero ahora ya viene lo complicado 00:24:14
El jugador puede hacer tres cosas 00:24:17
Mostrar las cartas que tiene en la mano 00:24:20
Recibir una carta 00:24:23
Y jugar una carta 00:24:25
Puede hacer tres cosas 00:24:29
Pues hay que programar esas tres cosas 00:24:30
Vale, si uno le aleve que la más sencillita 00:24:32
Es mostrar las cartas que tiene 00:24:35
Porque recorre el linked list 00:24:37
Entonces uno se quita cuanto antes este método 00:24:38
Que es el más sencillito y ya está 00:24:40
Pues venga 00:24:41
Nos quitamos primero este método 00:24:44
Bueno, pues a ver 00:24:46
Aquí vamos a recorrer la lista y mostrarlo 00:24:57
Pues ya está 00:25:02
Como vamos a mostrar solamente un for each 00:25:03
Que es muy sencillo 00:25:05
A ver, María 00:25:07
Bueno, pues luego lo hablamos 00:25:13
Pero hombre, sed un poquito más finos y delicados 00:25:21
A ver 00:25:23
vale, entonces 00:25:25
aquí es donde uno dice 00:25:31
bueno, si me hago 00:25:35
un toString en carta 00:25:37
que no me cuesta nada porque lo escribo 00:25:38
rapidísimo, pues le puedo pasar 00:25:41
c directamente al system.println 00:25:43
y bueno, pues me voy a carta, me hago un toString 00:25:45
y así no tengo que hacer aquí c.get 00:25:47
palo, c.get número 00:25:49
pero bueno, que si uno hace aquí 00:25:50
c.get palo, c.get número 00:25:53
No, porque este método 00:25:55
Ya llama directamente 00:26:00
Cuando le pasas aquí un objeto 00:26:02
Lo que hace es llamar al toString de ese objeto 00:26:03
Y mostrar el resultado 00:26:06
O sea, poner aquí c.toString y no ponerlo 00:26:07
Es el mismo efecto 00:26:09
Porque este método ya está programado para que llame al toString 00:26:10
Vale, pues entonces 00:26:14
A ver 00:26:17
System.out.println 00:26:21
es un método que necesita que aquí se le pase 00:26:24
un string sí o sí, porque está así 00:26:27
programado, entonces si le pasas algo que no es 00:26:29
un string, él si entráramos 00:26:31
dentro, él vería instance of no es string 00:26:33
pues lo que hace es llamar a tu string 00:26:35
que lo hace él automáticamente 00:26:36
no hace falta que lo llamemos nosotros 00:26:37
entonces 00:26:40
pues bueno 00:26:43
vamos a hacer aquí un toString 00:26:45
bueno, que 00:26:46
para mostrar la mano nos gusta este aspecto 00:26:51
como no nos han dicho 00:26:54
ningún aspecto para mostrar las cartas de la baraja 00:26:54
pues bueno, dejamos esto y ya está 00:26:57
y nos complicamos la vida 00:26:59
bueno, pues el método mostrar mano 00:27:00
ya está 00:27:03
entonces con esto 00:27:05
ya tenemos 00:27:07
un dos y medio 00:27:09
que parece que no 00:27:12
pero es la mitad del aprobado 00:27:13
con lo que hemos hecho hasta aquí 00:27:15
que era fácil 00:27:17
hasta aquí no había nada que pensar 00:27:19
ahora ya sí que empiezan las cosas de pensar 00:27:21
vale, pues venga, nos vamos al método 00:27:24
recibir carta 00:27:27
de jugador 00:27:28
recibir carta 00:27:32
este método recibe una carta 00:27:38
como parámetro 00:27:44
recibe una carta como parámetro 00:27:46
vale, y quien nos dice esto 00:27:48
que tiene que hacer 00:27:50
tiene que, primero 00:27:52
dos cosas 00:27:54
esa carta, meterla en la lista de cartas del jugador 00:27:55
hasta ahí facilísimo 00:27:59
hasta ahí facilísimo 00:28:01
las cartas de jugador 00:28:04
están en la propiedad cartas jugador 00:28:07
que está aquí arriba, en esta propiedad 00:28:09
que es una lista 00:28:11
pues meter en la lista 00:28:12
es tan fácil como hacer esto 00:28:14
entonces la primera parte del método 00:28:16
es esta, ya está, cojo la carta 00:28:19
y la lista de cartas 00:28:21
pero ahora viene lo retorcido 00:28:22
lo retorcido es, esa carta 00:28:24
sale de algún lado 00:28:26
sale de la baraja tuya 00:28:28
que se habrá instanciado en el programa 00:28:30
principal y de esa baraja tiene que salir 00:28:32
en algún momento 00:28:34
tienes que hacer, apañártelas 00:28:36
para hacer un remove de este objeto 00:28:38
carta de la baraja 00:28:40
con la que está trabajando tu aplicación 00:28:42
¿vale? entonces esa es la parte 00:28:43
complicada 00:28:46
que era la otra mitad de este 00:28:47
de este punto, entonces aquí es donde uno ya 00:28:49
se queda desconcertado y piensa 00:28:52
pero vamos a ver, la baraja de mi aplicación 00:28:54
¿dónde está? La baraja de mi 00:28:56
aplicación está aquí 00:28:58
en esta 00:29:00
propiedad de este 00:29:02
objeto, entonces 00:29:04
se supone que mi aplicación 00:29:07
instanciará ese objeto 00:29:10
baraja, instanciará ese objeto baraja 00:29:12
y al momento de instanciarlo ya se crea 00:29:14
¿vale? Pero yo aquí 00:29:16
aquí 00:29:18
no tengo opción 00:29:19
de acceder a ese, ¿dónde estoy aquí? 00:29:22
Yo aquí no tengo opción de acceder 00:29:24
a la baraja, o sea, yo aquí tengo que 00:29:26
de alguna manera acceder a las cartas de la baraja 00:29:27
acceder para hacer esto 00:29:30
es lo que me falta 00:29:32
para hacer esto 00:29:34
de alguna manera tengo que acceder 00:29:36
a las cartas de la baraja 00:29:38
y es lo que me falta 00:29:39
entonces ahí es lo que os decía 00:29:40
pues ahí dad la solución que creéis conveniente 00:29:42
uno podía decir 00:29:46
y era sencillo 00:29:47
que os dije que si lo hacéis no pasaba nada tampoco 00:29:49
pues voy a cambiar el diseño 00:29:51
a este método que se le pase la baraja 00:29:53
con la que se está jugando 00:29:56
y no pasa nada, porque eso tiene sentido 00:29:57
es algo que tiene sentido 00:29:59
¿vale? 00:30:00
entonces os dije, tenéis que cambiar algún método 00:30:03
para que el resultado 00:30:05
final funcione, como tiene que funcionar 00:30:08
no pasa nada, lo que queremos es ver 00:30:10
qué soluciones vais dando, esa sería la más sencilla 00:30:11
es decir, vale, a recibir carta 00:30:14
dame la carta y dame la baraja 00:30:15
de trabajo, me das la baraja 00:30:18
de trabajo, me das la baraja 00:30:20
de trabajo, además de la 00:30:28
carta, y entonces yo ahora aquí 00:30:30
lo único que tengo que hacer es 00:30:32
baraja.getCartas 00:30:33
y remove 00:30:35
¿vale? esto sería una posibilidad 00:30:37
admisible 00:30:40
y la más sencilla de entender 00:30:42
en realidad 00:30:45
insisto 00:30:46
este add y este remove 00:30:49
funcionan 00:30:50
si en carta está el jascodiel 00:30:52
igual, si no este remove no va a funcionar 00:30:55
la carta no se va a ir de la baraja 00:30:57
no se va a ir 00:30:59
porque aunque tenga el mismo palo 00:31:01
y el mismo número 00:31:03
si no está el jasco de eliquas 00:31:04
va a tirar del de object que va a ser 00:31:07
pero no es la misma dirección de memoria, entonces no la quito 00:31:09
entonces insisto por enesima vez 00:31:11
todo esto con el haset 00:31:13
todos estos add, remove 00:31:15
tienen sentido y funcionan correctamente 00:31:17
si está el jasco de eliquas 00:31:19
entonces esta sería una posibilidad 00:31:20
una posibilidad 00:31:21
pero yo os comenté también otra 00:31:23
cuando os estuve leyendo el enunciado 00:31:29
vale, pues otra posibilidad sería 00:31:31
que vosotros os ocurriera 00:31:43
y dijerais, vamos a ver, 00:31:45
mi aplicación solo tiene una baraja. 00:31:47
Solo tiene una. 00:31:49
Que es la baraja con la que juegan todos. 00:31:51
Solo va a tener una. 00:31:54
Solo voy a tener un objeto baraja 00:31:55
y solo me interesa un set 00:31:57
que es el que esté en ese único objeto baraja. 00:31:59
Pues entonces, 00:32:02
como solo va a haber una 00:32:03
y solo me interesa una, 00:32:04
si yo hago esto estático, 00:32:07
pues gano un mundo de posibilidades. 00:32:09
Porque al hacer esto estático, 00:32:12
estático, ya puedo 00:32:13
acceder desde cualquier sitio 00:32:15
a través del nombre de la clase 00:32:17
sin necesidad de haber 00:32:19
instanciado ningún objeto ni nada. 00:32:21
¿Vale? Pues entonces, 00:32:25
¿qué es la otra cosa que os...? 00:32:26
Entonces, si lo hacemos 00:32:31
static, 00:32:31
lo que pasa es que si no 00:32:34
cambiamos el private, 00:32:35
hay que acceder a través del get. 00:32:37
Entonces, había varias opciones. 00:32:40
O lo ponéis public para acceder 00:32:42
directamente con baraja.cartas 00:32:44
al ser este static 00:32:47
el get y el set 00:32:50
se convierten en static directamente 00:32:51
¿vale? 00:32:54
entonces 00:32:57
o bien ponéis aquí static 00:32:58
y al poner aquí 00:33:01
static uno podría ahora 00:33:06
hacer esto 00:33:08
otra posibilidad 00:33:08
vamos a ver 00:33:12
y ya nos vamos con esto 00:33:13
Recibir carta 00:33:16
Vale, pues otra posibilidad 00:33:20
Añadir la carta 00:33:32
Es lo mismo 00:33:35
Y ahora yo ya puedo acceder tranquilamente a la baraja 00:33:36
De esta manera 00:33:39
Baraja.getCartas.remove 00:33:40
Y ala, ya tengo el método hecho 00:33:44
Vale, he podido acceder 00:33:47
Porque es estático 00:33:50
Un segundo y ya nos vamos 00:33:51
Lo que pasa es que 00:33:52
este, eso así está bien 00:33:54
¿vale? pero hombre para que el diseño 00:33:57
sea más bonito las variables estáticas 00:33:59
normalmente no se hacen para acceder a ellas a través de los 00:34:00
set, sino para acceder 00:34:03
directamente a través de la variable 00:34:05
eso cuando hicimos stat ya lo vimos 00:34:07
entonces si yo cambio una variable 00:34:09
a static, el diseño más habitual 00:34:10
es que entonces ya la ponga public 00:34:13
ya la ponga public 00:34:15
y entonces ya ni get ni set ni nada 00:34:16
de hecho recordad que dijimos 00:34:19
que de las variables estáticas 00:34:21
no se suelen hacer reset, nunca 00:34:23
lo que se las pone es public y accedes directamente 00:34:25
a ellas 00:34:27
bueno, pues si yo hago eso 00:34:28
entonces si yo hago esto 00:34:30
entonces ahora aquí tendría esto 00:34:33
así 00:34:35
con protected 00:34:35
no lo sé 00:34:39
tendría que probarlo porque ahora mismo 00:34:42
no lo tengo claro 00:34:43
pero vamos, lo normal en las variables 00:34:45
estáticas es que sean public, no te vuelvas 00:34:47
tampoco loca por restringir 00:34:49
estando en el mismo paquete 00:34:50
sí, claro 00:34:54
no, no, sigo teniendo mis dudas 00:34:55
porque protected es 00:34:58
ella misma y las herederas 00:35:00
o luego lo comprobamos, pero en cualquier caso 00:35:02
las variables static 00:35:04
normalmente se hacen public 00:35:05
siempre, porque están pensadas para que acceda 00:35:09
cualquiera, están pensadas para eso 00:35:10
entonces como están pensadas para eso 00:35:12
no facilitas la tarea 00:35:14
bueno, pues esta sería 00:35:15
la otra versión de recibir 00:35:18
carta, que como 00:35:20
y esta pasa por darnos cuenta de que 00:35:22
solo va a haber un objeto baraja en toda nuestra aplicación 00:35:24
solo va a haber uno, pues solo va a haber 00:35:26
uno, lo hago estático y facilito el trabajo 00:35:28
de todo el mundo, y así 00:35:30
me queda ya el método así, vale 00:35:34
y ahora esto ya sí que sería 00:35:35
en cuatro, hasta aquí ya en cuatro, dos y medio 00:35:39
tres y cuatro 00:35:41
vale, venga y ahora paramos 00:35:43
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
3 de abril de 2024 - 18:36
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
35′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
178.18 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid