Saltar navegación

2025-04-30-Programacion - 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 30 de abril de 2025 por Jose Manuel M.

33 visualizaciones

Solución tarea tema 9 . Colecciones

Más información Transcripción

Descargar la transcripción

Buenos días, como tuvimos un problema del apagón eléctrico en la anterior tutoría y dado que no 00:00:00
vamos a tener muchas clases para poder ir completando el temario, también me habéis 00:00:06
hecho la propuesta por ahí en algún foro, vamos a hacer un pequeño vídeo resolviendo la 00:00:12
tarea del tema 9. Esta tarea consistía en seleccionar un tipo de jugada, teníamos 00:00:16
dos opciones que era jugada de cartas con baraja española o con baraja francesa. Luego a través de 00:00:25
los parámetros de entrada de la aplicación se introducían tres datos. Una era el número de 00:00:33
jugadores, aquí tenemos algunos ejemplos, el número de jugadores como primer dato, el número de cartas 00:00:38
que tenía cada uno de los jugadores y a continuación se indicaba con un cero si trabajábamos con la 00:00:44
baraja española o la baraja francesa. Cada una de las barajas pues bueno tiene una serie de 00:00:49
cartas que son diferentes en un caso o en otro y en el caso el ejercicio nos propone que en el 00:00:55
caso de introducir a través de los parámetros 4 5 1 se entiende que el juego al que se pretende 00:01:01
con el que se pretende trabajar es póker uno es baraja francesa y por ser póker además hay que 00:01:08
añadir dos cartas adicionales que serían los comodines bueno vamos nos ponemos en marcha y 00:01:14
vamos desarrollando el ejercicio a la par que vamos repasando el enunciado. 00:01:21
Para ello nos venimos a Eclipse, damos de alta un nuevo proyecto, podemos llamarlo 00:01:28
tarea 10, es el tema 10 sobre el que estamos trabajando. Vamos a crear una clase 00:01:33
en el proyecto, todo el desarrollo lo podemos hacer en una clase, también podría 00:01:51
estar distribuida según el diseño en varias clases. Este ejemplo lo voy a poner 00:01:54
ya en una única clase, hoy perdón, creo que es el tema 9, bueno de igual nombre el proyecto, ponemos 00:01:59
tema 9 y aquí bueno vamos a empezar definiendo el método main, que recibe un array de strings 00:02:06
que es precisamente a través del cual va a obtener los datos de parámetros de entrada del programa, 00:02:29
el número de jugadores, número de cartas y baraja con la que vamos a trabajar. Podemos definir una 00:02:35
serie de atributos en la clase que nos permitan identificar cada uno de estos todos estos datos 00:02:41
vamos a trabajar con ellos estáticos vamos a necesitar instanciar más de un objeto de la 00:02:47
clase para 9 para tema 9 y si lo definimos estático es bueno no va a resultar cómodo para ir accediendo 00:02:52
a todos ellos a partir a través de la información de la decimos aquí es definimos primer parámetro 00:02:59
que sea el número de jugadores podemos inicializar a 4 cuando el enunciado nos propone que cuando 00:03:07
hay dos circunstancias de juego que se sale un poco de lo habitual una cuando hay errores en 00:03:16
los datos de entrada que dice bueno considera en ese caso el juego del mus que tiene esta 00:03:24
combinación 4 4 0 como si estuviéramos si no decimos nada es que vamos a jugar al mus y luego 00:03:29
la otra es que cuando sea 451 hay que añadir los dos comodines estas dos situaciones un poco 00:03:35
extras al juego más típico nos propone el enunciado entonces vamos a definir el número de jugadores 00:03:40
el número de cartas por jugador y static int y baraja el tipo de baraja que podrá ser 0 si 00:03:48
estamos suponiendo 0 para baraja española y 1 para baraja francesa estas inicializamos estos 00:04:02
valores porque son precisamente los que los que hay que considerar en el caso de que se metan 00:04:14
mal los atributos de entrada que sería el juego de hermoso bien pues nada otra cosa podemos definir 00:04:20
aquí son una serie de arrays con la información que tienen las barajas que 00:04:29
son precisamente las que el enunciado nos está proponiendo por aquí. Entonces nos 00:04:33
venimos y definimos unos arrays, static, arrays de strings, los palos que tiene la 00:04:40
baraja española, un array, recordamos que podemos dimensionarlos con un new y luego 00:04:52
ir dando valores y una de las alternativas también para dar el tamaño 00:04:58
a los arraís es a través de la inicialización entonces vamos a inicializar este con cuatro 00:05:02
valores que serán los horóscopos espadas y bastos los cuatro palos de la baraja española hacemos lo 00:05:09
mismo para la baraja francesa baraja francesa que son rombos corazones picas y tréboles y ahora 00:05:27
vamos a hacer lo mismo pero para las cartas en sí, en las cartas españolas 00:05:52
según el anuncio, tenemos el as 00:06:02
el 2 3 00:06:07
4 5 6 7 5 00:06:14
6 7 00:06:25
sota 00:06:30
caballo 00:06:34
en el caso de la baraja 00:06:35
francesa tenemos el 2 3 4 5 6 7 en este caso 00:06:57
tenemos números hasta el 10 8 9 y 10 00:07:06
8 9 00:07:11
luego J, Dama y Rey en lugar de Sota, caballo y rey 00:07:15
J, Dama y rey 00:07:21
no soy muy experto en las cartas, no juego mucho a las cartas, no sé si voy a meter la pata a la que vaya contándoos algo 00:07:25
y luego podemos definir un array más que podrían ser los comodines para la baraja francesa 00:07:36
tendría dos entradas, podríamos definir como comodín 1 o joker 1 y comodín 2 00:07:44
Bien, estas son todas las cartas que vamos a tener disponibles y el ejercicio, bueno, estamos en el tema de colecciones y de mapas. 00:07:56
¿Qué podemos elegir para...? Vamos a definir el mazo de cartas a través del cual vamos a ir utilizando luego para hacer el reparto en función de estas características de entrada. 00:08:11
En realidad, bueno, pues se trata de una... Desde luego no es un mapa porque no tenemos un índice y un dato relacionado el dato con el índice. 00:08:22
directamente son las cartas 00:08:31
las tenemos por aquí en cuando habéis hecho entrega de la práctica algunos habéis creado un objeto de carta está 00:08:33
correcto muy bien yo no lo voy a hacer así 00:08:39
alternativa diseño puede haber distintos y pueden ser todos correctos 00:08:43
nosotros cada carta la vamos a construir a través de 00:08:47
estrés que va a ser una combinación de el palo y el número 00:08:50
entonces pues podemos hacer no necesitamos un mapa vamos a 00:08:57
trabajar con una colección y luego tened en cuenta que vamos a barajar las cartas con lo 00:09:01
cual no nos interesa que tenga ningún orden. En este caso podemos tirar por una colección y quizás 00:09:07
la más sencilla. Vamos a definir para el mazo de cartas una ArrayList, por ejemplo, 00:09:13
de strings. Cada una de las cartas va a ser un string que va a ser una combinación entre el 00:09:20
palo y la carta para la baraja española y para la francesa su palo y la carta y luego habrá dos 00:09:27
cartas adicionales en caso de ser el juego del póker que serán los dos comodines, entonces definimos 00:09:33
el ArrayList, pues podemos definirlo como ArrayList mazo, aquí estamos definiendo un objeto de este 00:09:39
tipo, ArrayList de string, con lo cual ahora como hacemos habitualmente cuando hacemos una variable 00:09:48
y le podemos hacer un new y llamar a lo que sería el constructor. 00:09:53
No me compila porque tengo que importar el mazo 00:09:57
y lo importo desde Java útil. 00:10:01
Bueno, ya estamos con una definición de datos y en disposición de empezar 00:10:05
a trabajar en el main. ¿Qué es lo primero que vamos a hacer? Pues vamos a validar 00:10:09
los datos de entrada que nos llegan cuando ejecutamos el programa. 00:10:13
Los datos tienen que ser, como nos dice por aquí en el ejemplo, fijaros 00:10:17
bloques de tres en tres y de tipo numérico y luego esto respecto al formato tres datos numéricos y 00:10:21
luego funcionalmente podemos hacer alguna validación extra cuando vayamos avanzando con el código lo 00:10:29
vemos para hacer esta validación lo primero que podríamos hacer es decir mira vamos a comprobar 00:10:34
que el número de datos que me entran su longitud es mayor o igual que tres como poco necesito tres 00:10:39
si meto más de tres argumentos, vamos a entender que descartamos 00:10:51
a partir del tercero el resto, pues bueno, es información que no me interesa. 00:10:55
Si esto se da, en cuanto al número de argumentos, vamos 00:10:59
bien, estamos trabajando como corresponde. 00:11:03
Si se meten dos o un argumento en la 00:11:07
ejecución, luego hacemos ejecuciones con diferentes alternativas, pues estaremos 00:11:11
teniendo problemas porque no tendremos estos tres datos, entonces tendremos que considerar 00:11:15
esta como opción por defecto en el caso de que se metan los tres argumentos bien pues vamos a 00:11:19
cargar estos datos entonces cojo y digo que el número de jugadores lo cargo desde fijaros que 00:11:26
ese es un array de strings entonces con la clase con la clase wrapper integer cojo y lo hago un 00:11:33
parseInt a un string. ¿Dónde tenemos 00:11:42
un string? Pues como primer elemento de 00:11:47
este array. Su posición 0 la voy a 00:11:51
intentar cargar como número de jugadores, que por otra parte es como nos dice 00:11:55
que tiene que funcionar el enunciado. El número de cartas sería el segundo 00:12:02
de los apartados, el segundo de los atributos introducidos y el 00:12:06
tercero debe ser un 0 o un 1 si el dato es correcto 00:12:12
que nos indica el tipo de baraja, recordamos que 0 corresponde a la baraja española y 1 a la baraja francesa 00:12:16
vale, si hemos metido todos los datos bien, si resulta que tenemos 3 argumentos como poco y todos están metidos bien 00:12:25
por aquí vamos bien, ¿qué puede suceder? que a la hora de meter los 3 argumentos lo hayamos hecho correctamente 00:12:31
por ejemplo, decir 4 jugadores, 5 cartas por jugador, baraja francesa, pues muy bien 00:12:38
pero puede ser que realmente los datos hayamos metido aquí algo que no sea un número con lo 00:12:43
cual esto que nos provocará una excepción pues vamos a hacer un try catch de esto para garantizar 00:12:49
que tenemos recogida esa consideración hacemos un try capturamos una excepción catch vamos a 00:12:55
capturarla por ejemplo como una excepción general vamos a hacer diferenciación entre 00:13:11
diferentes tipos de excepciones. Recordad que podríamos hilar más fino 00:13:15
y hacer una aritmética excepción, que sería la que se daría en ese caso que ponía 00:13:19
como ejemplo. Vamos a hacer una excepción general. ¿Esto qué pasaría? 00:13:23
Si alguno de los tres parámetros que metemos al hacer el integer parseIn 00:13:27
ha resultado no ser un número, se provocaría excepción, que podría pasarnos 00:13:31
en esta línea, en esta o en esta. Entonces, ¿dónde se nos iría? 00:13:35
Aquí, a la parte de excepción. ¿Qué nos interesa en ese caso? 00:13:39
pues bueno, podemos considerar que continúa el programa ejecutándose con los valores 00:13:42
por defecto, como si hubiéramos metido un número de argumentos menor de 3. 00:13:46
Como alguno de los valores puede ser que se haya sobrescrito ya por aquí, 00:13:51
lo que podemos hacer es ahí volver a dar los valores de inicio 00:13:54
a estos tres. Entonces cogemos 00:13:58
y decimos que en caso de que se produzca una excepción porque alguno de los datos 00:14:02
durante este try haya sido erróneo, haya 00:14:06
nos haya provocado que casque el programa vuelvo a darle los valores que considero por defecto 00:14:09
bueno aquí podríamos poner si el número de él es correcto podemos poner un elsa aquí si queréis 00:14:16
para tenerlo constancia cuando hagamos pruebas un sistema o frente el n indicando que el número 00:14:27
de parámetros incorrecto 00:14:36
se consideran los valores 00:14:43
por defecto. Fijaros que aquí estamos 00:14:53
inicializando los valores por defecto, cosa que no estamos haciendo aquí. ¿Y por qué no lo hacemos? 00:14:56
Porque si el número de atributos no ha sido al menos 3 00:15:01
esto no se va a ejecutar, con lo cual no vamos a sobreescribir ninguno y sí que hemos 00:15:05
tenido la consideración de inicializarlos aquí allá al orden por defecto. 00:15:09
Con lo cual aquí en este no es necesario volver a dar esos valores. 00:15:13
En cambio aquí en el catch sí es necesario porque si el error se produce en el tipo de baraja, 00:15:17
estos dos parámetros sí que podrían haber modificado estas variables. 00:15:22
Entonces en este volvemos a meter los valores por defecto, en este no, no es necesario. 00:15:27
Y aquí, bueno, pues si queréis incluso para hacer una traza del programa 00:15:32
podríamos poner System of Println diciendo 00:15:37
que se ha producido un error en los 00:15:41
parámetros de entrada. Bien, llegado a este punto 00:15:48
consideramos estas tres variables 00:15:56
las tres variables con información 00:16:02
correcta. Bien, porque los hemos cargado 00:16:07
a través de unos datos correctos que hemos metido 00:16:11
bien, porque no hemos metido suficientes parámetros, pero se está considerando 00:16:14
el juego del Moose, como nos dice el enunciado, o si alguno de estos datos 00:16:18
ha sido correcto y ha producido un error, como lo hemos cogido con un try-catch 00:16:22
los estamos volviendo a poner aquí los de por defecto, con lo cual ahí tenemos 00:16:26
datos que ya nos resultan interesantes para poder trabajar 00:16:29
todavía se nos puede dar, esto es 00:16:34
en cuanto a tipo de formato, número de atributos, fijaros 00:16:38
sí que no hemos metido en alguno de los datos 00:16:41
de entrada al programa una cadena de caracteres, pero se puede dar la situación 00:16:45
de que hayamos metido datos del siguiente tipo 00:16:49
imaginaos que metimos 4 jugadores, 4 cartas y baraja la 5 00:16:53
¿qué sucede aquí? pues eso no te da ninguno de todos estos errores 00:16:57
los argumentos son al menos 3 y no se produce 00:17:00
un error, pero en cambio 5 nos va a saber gestionar el programa 00:17:05
digamos que tenemos aquí un error de tipo funcional o imaginaros que metemos aquí que 00:17:09
hay 10 jugadores y a cada jugador le damos 20 cartas de la baraja española pues 200 cartas 00:17:17
no va a tener la baraja española con lo cual tampoco se va a poder realizar la jugada entonces 00:17:22
podemos realizar por código una serie de validaciones para considerar estos escenarios 00:17:26
una vez llegados aquí pues podemos hacer una llamada a un método a un método que nos valide 00:17:31
esto ese método lo podemos considerar que bueno que nos devuelve un boolean 00:17:38
true verdadero si los datos son válidos y false si no lo son entonces 00:17:44
podríamos decir aquí a ver si creamos un método que sea 00:17:49
valida con minúsculas valida datos tenemos que desarrollar este método que 00:17:57
nos devuelve la true si es correcto y false si no lo es correcto entonces 00:18:07
devuelve, true, sí 00:18:11
son datos introducidos 00:18:16
válidos, false 00:18:21
sí, no lo son. Si los datos han sido 00:18:24
correctos, por aquí continuaremos con el resto del programa 00:18:33
y si no, podemos poner un else aquí 00:18:37
es decir, una vez que hemos valido estos datos, ahora hacemos el método, si no ha sido correcto 00:18:39
nos vendremos al else y en else 00:18:45
podemos decir si lo que vamos a validar 00:18:47
sobre todo van a ser las cartas 00:18:50
si hay suficientes cartas 00:18:53
para hacer el juego 00:18:54
podemos poner system out 00:18:55
.println 00:18:58
vamos a poner aquí por ejemplo 00:18:59
cartas 00:19:04
insuficientes 00:19:05
en la baraja 00:19:07
vamos a validar 00:19:10
antes de continuar 00:19:13
creamos este método, recordad que 00:19:15
esperamos que no 00:19:18
devuelva un boolean porque lo hemos metido aquí dentro de un if 00:19:20
entonces podemos hacer aquí un static 00:19:23
que devuelva un boolean, el nombre del método 00:19:26
y vamos a hacer el trabajo este, ponemos 00:19:32
por ejemplo boolean b 00:19:40
def, el valor devuelto, decimos que lo inicializamos a que sí 00:19:42
que va a ser correcto, si durante las comprobaciones vemos que 00:19:48
no lo es, ya nos preocuparemos de cambiarlo. Y hacemos un return 00:19:52
dbdef. Vamos a crear una variable, como hemos 00:19:55
dicho otras veces, para poner un único return en todo el método. 00:20:00
¿Qué es lo primero que podemos valorar? Pues recordad que los 00:20:06
datos que estamos recibiendo y que los tenemos ahora mismo cargados en estas 00:20:10
tres variables, durante este proceso que hemos hecho aquí, 00:20:13
una de las cosas que tiene es que la baraja tiene que ser 00:20:18
cero para que sea española, uno para que sea francesa, y si no son ninguno de esos 00:20:20
dos valores, pues el programa no dispone 00:20:24
de una baraja como para trabajar con ello. Entonces podemos 00:20:28
coger una primera comprobación que podemos hacer, es decir, que si 00:20:32
el tipo de baraja y baraja 00:20:35
que lo hemos cargado bien por aquí, probablemente 00:20:40
si el tipo de baraja es igual 00:20:43
a 0 o el tipo de baraja 00:20:52
es igual a 1, esos dos datos no os gustan. 00:20:56
Con lo cual sería una baraja válida. Pero 00:21:01
si no es ni 0 ni 1, si lo negamos, resulta que 00:21:04
ya no tenemos baraja disponible para el dato que hemos metido 00:21:08
como tercer parámetro y que se ha cargado aquí. En ese caso 00:21:12
¿qué podemos hacer? Bueno, pues podemos irnos a un valor por defecto como hemos hecho otras veces 00:21:16
y os parece decir que en ese caso vamos a considerar que la baraja es española. 00:21:20
Podríamos lanzar un error, decir, oye, la baraja no es correcta, 00:21:25
se acaba la aplicación porque tienes que seleccionar entre 0 y 1. 00:21:29
El enunciado no nos obliga a hacer nada en particular. 00:21:32
Bueno, pues vamos a tomar una decisión y vamos a decir que si la baraja introducida no es correcta, 00:21:35
consideramos baraja española. 00:21:40
En cambio, si la baraja ha sido correcta, la hemos metido bien, 00:21:46
pues vamos a validar otras cosas. 00:21:50
¿Qué otra cosa podemos validar? Pues que el número de jugadores multiplicado por el número de cartas por jugador sea mayor que las cartas disponibles en la baraja. 00:21:52
en este caso, ¿qué pasa? que no podemos jugar, ¿no? 00:22:12
si, como os decía antes, si tenemos 10 jugadores y a cada uno le pretendemos dar 40 cartas 00:22:16
y en la baraja tenemos 40 cartas, pues no disponemos de 400 para hacer el reparto 00:22:20
vale, pues vamos a hacer esa una vez que 00:22:26
bueno, esto lo podemos poner con un else 00:22:29
no, aquí no, esto es independiente, vale 00:22:35
bueno, lo que sí que, aquí lo que hemos hecho ha sido asegurarnos que la baraja es española 00:22:42
y ahora según sea la baraja española o sea francesa tenemos un número diferente de cartas 00:22:47
entonces podemos decir aquí que si la baraja con la que trabajamos es española 00:22:53
resultará que lo que podemos comprobar es que si el número de jugadores 00:22:59
por el número de cartas que tenemos en cada jugador 00:23:07
estos dos parámetros que hemos recibido de entrada 00:23:18
es mayor que el número de cartas de la baraja española 00:23:20
fijaros que estamos trabajando con la baraja española 00:23:27
para esto quizás nos interese 00:23:29
por trabajar con más cosas 00:23:32
podríamos poner aquí un 40 directamente 00:23:34
pero si queremos hacer un programa 00:23:36
un poco más, digamos, un poco más versátil 00:23:38
y tenerlo ahí un poco 00:23:40
más ordenado y todo, es el momento en el que 00:23:42
podríamos coger y definir aquí incluso 00:23:44
unas constantes de ese tipo 00:23:46
y así trabajamos con algo más 00:23:47
vamos a definir una constante 00:23:50
acordaros las constantes 00:23:51
le ponemos la etiqueta final 00:23:54
de tipo entero 00:23:56
y normalmente ponemos todo el nombre 00:23:57
de lo que sería la constante con mayúsculas, digamos un 00:24:01
compendio no obligatorio para que compile el programa, pero sí para 00:24:05
hacernos una idea de que esto estamos hablando de 00:24:09
una constante, que ya os digo se ha convertido en constante 00:24:12
porque no hemos metido la etiqueta final, entonces decimos que la baraja 00:24:17
española tiene un número de carotas de 40, la baraja 00:24:21
que son 10 por cada uno de los palos 00:24:25
la barja francesa, bueno pues tiene alguno más 00:24:29
la barja francesa tiene, son 10, 11, 12, 13 00:24:36
13 por 4 palos, pues son 00:24:40
13 por 4 palos, 13, 1, 2, 3, 4 00:24:44
5, 6, 7, 8, 9, 10, 11, 12, 13, 13 por 4 00:24:51
serían 59 cartas, 40, 4 por 3, 12 00:24:55
no, 52 cartas 00:25:02
4 por 52 cartas 00:25:04
sí, 44 por 312 00:25:07
yo creo que 52, sí 00:25:13
y luego sería 00:25:14
static 00:25:16
final int 00:25:17
podemos poner 00:25:20
la baraja francesa 00:25:22
con un número de cartas 00:25:24
cuando considera 00:25:27
también que tiene comodines 00:25:31
que en ese caso serían 00:25:33
2 más 54 00:25:35
serían las 52 anteriores más 2 que son estos dos comodines 00:25:36
con esta constante podemos coger y venirnos aquí y decir que 00:25:42
si resulta que la baraja, o sea el número de jugadores por el número de cartas 00:25:48
que pretendemos repartir es mayor que el número de cartas que tiene la baraja española 00:25:54
que lo hemos definido como 40, pues esto nos da mal resultado 00:25:59
Entonces, este validar datos, recordad que está haciendo un return de esta variable en caso de que sea correcto, lo tenemos inicializado a true, pero en este caso no, nos estamos encontrando en una situación de error, con lo cual indicamos que sea falso. 00:26:06
Ahora, esta es la comprobación que podemos hacer a este respecto con la baraja española. Si resulta que tenemos, que estamos trabajando con la baraja francesa, aquí tened en cuenta que solamente puede ser 0-1 porque después de todas las validaciones, Ibaraja tendría con toda seguridad un número. Si el dato es correcto, un 0-1-1 será el que sea y si no, lo hemos inicializado a 0, con lo cual haría esta comprobación. 00:26:20
si en cambio y baraja viene con valor 1 00:26:47
es decir, queremos trabajar con la baraja francesa 00:26:50
pues tendremos que hacer dos comprobaciones 00:26:53
a diferencia de lo que hemos hecho con la baraja española 00:26:56
que era el número de cartas en sí 00:26:59
que será si el número de cartas es la francesa 00:27:01
o estamos trabajando con el número de cartas relacionados con el comodín 00:27:04
entonces tenemos que hacer esta distensión aquí 00:27:08
y decimos sí 00:27:12
resulta que el número de jugadores resulta que es igual a 4 00:27:13
y el número de cartas que se reparten es igual a 5 00:27:24
en ese caso estamos hablando de que van a jugar al póker 00:27:40
y el póker es el que incluye los dos comodines 00:27:44
entonces como incluye los dos comodines 00:27:48
la comprobación que haremos aquí 00:27:50
es que el número de cartas por el número de jugadores en este caso es cuando es póker considerando los comodines 00:27:52
no podrá ser en ningún caso mayor de esta constante que es las cartas disponibles en la baraja cuando trabajemos con comodines 00:28:01
tened en cuenta que es cuatro jugadores con cinco cartas y estamos entrando por el else que nos obliga a que sea baraja francesa 00:28:10
Es decir, con toda seguridad estamos tratando el tema del juego del póker. 00:28:21
Y en este otro caso, baraja francesa no es el juego del póker, 00:28:29
el número de jugadores por el número de cartas, tendrá que considerar un máximo de cartas 00:28:35
de la baraja francesa pero sin comodines, que sería este otro. 00:28:39
Y de nuevo damos el FALSE. 00:28:43
Entonces, la situación de este método es, si la baraja que se ha indicado no es ni francesa ni española, indicamos que es a la española, aquí tenemos un criterio de decir, bueno, vamos a utilizar un valor por defecto, y en cambio, si el número de cartas es incorrecto, no hay suficientes cartas, aquí no utilizamos valor por defecto. 00:28:50
Lo que vamos a hacer va a ser devolver un false para que el programa nos envíe un mensaje y finalice. 00:29:10
Si la baraja era española, validamos el número de cartas que hay que repartir respecto a la constante de cartas que tiene la baraja española. 00:29:16
Y si no, si es francesa, respecto a la francesa, con el matiz de si estamos jugando al póker, consideramos dos cartas más. 00:29:24
vale, pues resulta que si el número de cartas no es válido 00:29:31
esto devuelve un false, se viene por el else, nos dirá el número de cartas insuficiente 00:29:38
y se termina el programa, llegados a este punto 00:29:42
hay cartas suficientes para repartirlo y tenemos aquí datos 00:29:45
que nos resultan válidos para poder trabajar con ello 00:29:50
entonces, ¿qué podemos hacer? 00:29:55
podemos decir, mira, el juego puede ir por dos lados 00:29:59
por la baraja española o por la baraja 00:30:02
francesa. Entonces decimos 00:30:04
if baraja es 00:30:06
igual a cero, baraja 00:30:08
española. 00:30:13
Else, 00:30:19
vamos a la baraja francesa. 00:30:20
Para la baraja 00:30:23
española lo que vamos a hacer 00:30:25
es, considerando 00:30:26
los datos de la baraja española, 00:30:28
cargarlas 00:30:32
en el mazo de juego. 00:30:32
Y de la misma forma, cuando sea la 00:30:34
francesa, con 00:30:36
los datos de la baraja francesa cargarlos en el mazo con el matiz además de incluir esto si se 00:30:38
trata del póker para hacer un poquito más ordenadito si os parece creamos un método en 00:30:45
lugar de ponerlo aquí entonces podemos aquí cargar espanola un método y aquí podemos poner cargar 00:30:52
francesa 00:31:02
ahora vamos a crear estos métodos 00:31:07
creamos el método 00:31:09
y vamos a cargar la baraja española 00:31:18
cargar la baraja española 00:31:27
publicitatis 00:31:36
void 00:31:38
implica 00:31:40
que considerando estos palos 00:31:42
y estas cartas 00:31:44
tenemos que añadir una carta 00:31:46
de cada uno de ellos al mazo 00:31:48
voy a copiar esto 00:31:50
para aprovechar y hacer 00:31:54
y hacer copia y pega ahora ahora borro simplemente es para traerme los datos 00:31:56
aquí no tener que estar yendo para arriba para abajo me interesa esto 00:32:01
y ahora después lo borro así lo tengo aquí a mano para poder trabajar con ello 00:32:12
en el mazo quiero añadir cada una de las cartas tenemos que añadir un as un 2 un 00:32:16
3 una sota un caballo un rey para cada uno de estos palos entonces lo que 00:32:21
hacemos es crear vamos a hacer vamos a recorrer estos 00:32:26
a raíz fijaros que estos hemos trabajado en esta 00:32:31
parte con estructuras de datos tipo array y 00:32:36
para crear más hemos utilizado una colección esto podrían ser colecciones 00:32:45
también y ahora acceder a ellos a través de colecciones 00:32:48
o sea que alternativas en realidad tenemos muchas decimos for 00:32:52
Hacemos int i igual a cero, mientras i sea menor que el número de palos que tenemos en la baraja española, hacemos un i más más. 00:32:57
Esto lo que hace es un bucle por cada uno de los palos y por cada uno de los palos queremos recorrer las cartas. 00:33:23
Entonces cogemos y hacemos dentro de este for, otro for, for int j igual a cero, mientras j sea menor que el número de cartas que tiene cada uno de los palos, a ver, s, cal, es, punto, no me ofrece, vale, porque tenía ahí un error, hago un j más más, entonces este bug le ha anidado como se entiende, para cada uno de los palos, 00:33:32
una ejecución de este for, que será cada una de las cartas que tiene que haber 00:34:10
en cada uno de los palos. Y lo que me interesa es meter 00:34:16
en el mazo, que como es una colección, utilizamos el método 00:34:20
ADD, y fijaros, carga un string, y este string lo vamos a construir 00:34:24
a partir de la información de los dos 00:34:28
de los dos array. Entonces, cogemos y decimos, ese car 00:34:31
es posición J 00:34:37
esto me dirá as 2 3 4 5 6 7 sota caballo y rey más dejamos aquí un espacio decimos de y ahora 00:34:41
decimos el palo decimos ese palo y pues en cada una de estas veces dirá para el as de 00:34:53
oros, copas, espadas, bastos 00:35:11
luego la siguiente vuelta de este foro dirá 00:35:15
el 2 de oros, el 3 de oros 00:35:17
el 4 de oros, cuando acabemos con el rey 00:35:21
habrá recorrido todo este bucle 00:35:24
se vendrá aquí y se irá al siguiente bucle 00:35:26
al siguiente valor del bucle más general 00:35:29
con lo cual nos iremos a copas, empezaremos por el ar de copas 00:35:32
2 de copas y todos ellos vamos haciendo 00:35:35
vamos añadiendonos aquí al mazo 00:35:38
Bueno, aquí ya tenemos cargado ahora en el mazo la baraja española. En el caso de que sea la baraja francesa, pues vamos a hacer algo parecido, tan parecido que va a ser prácticamente lo mismo, pero con los otros valores. 00:35:40
entonces cogemos 00:35:57
static, pull it 00:35:59
void 00:36:02
cargar la baraja 00:36:03
francesa, voy a volver a 00:36:06
coger aquí, ahora después lo borro 00:36:10
ahora los palos que me interesan son los 00:36:12
de la francesa, las cartas de la francesa 00:36:21
y vamos a considerar el comodín también 00:36:23
cuando el juego sea 00:36:25
poker 00:36:28
entonces para la francesa lo que vamos a hacer 00:36:29
va a ser un recorrido 00:36:32
parecido 00:36:34
vamos a hacer copia y pega de este for 00:36:36
el mazo de cartas 00:36:39
sobre el que vamos a trabajar 00:36:42
va a seguir siendo mismo 00:36:43
entonces el palo, decimos 00:36:45
para el palo de la baraja 00:36:46
recorriendo los palos de la baraja francesa 00:36:48
vamos a coger las cartas de la baraja 00:36:53
francesa 00:36:55
entonces tenemos aquí la carta de la baraja francesa 00:36:56
palo de la baraja francesa 00:36:59
ya está, es exactamente la misma 00:37:01
jugada que antes 00:37:03
lo único que ahora hemos cargado 00:37:04
para los palos y las cartas de la baraja francesa y nos queda tener en consideración si el juego es 00:37:06
póker para meter los comodines sea póker o sea cualquier otro todos los cartas de la baraja 00:37:13
francesa tienen que entrar y solamente en el caso de ser póker es cuando tenemos que meter los 00:37:21
comodines y cuando eran los comodines pues cuando jugaban cuatro jugadores con cinco cartas vamos a 00:37:27
en esa comprobación decimos sí y no jugó y no jugó si es igual a 4 el número 00:37:32
de cartas es igual a 5 estamos hablando de póker 00:37:59
debemos incluir comodines y en este caso lo que tenemos que hacer es añadir al 00:38:13
mazo los dos comodines y los dos comodines los tenemos fijaros en este otro array a ver no está 00:38:25
aquí bueno son dos posiciones aquí podríamos hacer un bucle como son sólo dos pues si queréis 00:38:36
vamos a ponerla directamente la instrucción que meta el elemento 1 el elemento el primer elemento 00:38:44
que está en la posición 0 de la del índice y el segundo de los comodines que está en la posición 00:38:52
Y aquí ya tendríamos el mazo cargado en el caso de que sea la baraja francesa con las cartas francesas, incluyendo los comodines en caso de que sea póker. 00:38:58
Entonces si volvemos aquí al main, asegurándonos que se han validado los datos, si la baraja es la española cargamos española y si es francesa cargamos la francesa. 00:39:10
Aquí ya tenemos el mazo cargado con lo que haya correspondido según la información que hayamos ido metiendo. 00:39:20
¿Y ahora qué queda hacer? Yo creo que tenemos que hacer el reparto de cartas. 00:39:33
Antes de hacer el reparto de cartas podemos barajarlas. 00:39:37
Ya tenemos la baraja en nuestras manos, vamos a barajarlas un poco las cartas. 00:39:41
entonces lo que podemos hacer para barajarlas es utilizar no sé si recordáis que la clase 00:39:46
colección colección tiene un método que es el método sáfer 00:39:53
como era esto lo que hace es mezclar las cartas de que de una lista tenemos un array list que 00:40:00
cuelga que hereda de lista pues nos vale del array mazo pues aquí ya hemos barajado las cartas 00:40:12
En cada una de las ejecuciones se mezclarán de forma aleatoria las cartas mediante este método estático, Shuffle, que tenemos disponible en la clase Collections en nuestras librerías de Java. 00:40:20
Y ahora vamos a hacer el reparto de cartas. Podemos utilizar, ya que lo estamos haciendo bastante modular, un método que sea el método repartir cartas. 00:40:33
ahora vamos a hacer el método repartir cartas 00:40:42
vamos a desarrollarlo 00:40:48
static 00:40:49
public boy 00:40:56
podría ser privado porque realmente 00:41:02
todo está en una clase 00:41:05
pero bueno, método repartir 00:41:06
cartas 00:41:09
y entonces ahora lo que vamos a hacer va a ser 00:41:10
para cada uno de los jugadores 00:41:19
coger 5 cartas 00:41:21
de la baraja 00:41:23
en realidad 00:41:26
podríamos alternar y darle una carta 00:41:27
a cada uno de los jugadores 00:41:30
una a otra a otra, o podemos darle las cartas que correspondan 00:41:31
al jugador que toque en particular, vamos a hacerlo de esta segunda forma 00:41:35
y si no sería, para cambiarlo y ir dando carta a carta 00:41:39
sería hacer el for que está dentro fuera y el que está de fuera dentro 00:41:44
decimos inti, mientras i sea 00:41:48
menor que el número de jugadores, el número de jugadores que están 00:41:55
participando justo en esta partida, la tenemos en esta variable 00:41:59
hacemos un y más más y esto es el recorrido por cada uno de los jugadores 00:42:02
entonces podemos poner aquí un sistema para indicar que vamos a darle las 00:42:14
cartas a uno de los jugadores podemos poner aquí barra en y vamos a dar un 00:42:18
espacio vamos a dar un tabulador y decimos jugador más 00:42:30
vamos a recorrer todos los jugadores con las posiciones en los array 0 1 2 y 3 00:42:39
pero para el mensaje nos interesa que aparezca 1, 2, 3 y 4 00:42:45
jugador 1, jugador 0, queda un poco más feo 00:42:48
entonces podemos poner aquí 1 y más 1 para que nos muestre 00:42:51
vamos a poner aquí también para que nos quede un poquito más bonito 00:42:54
luego el dibujo, unos cuantos asteriscos 00:43:02
luego vemos cuánto nos hace falta 00:43:04
entonces para cada uno de los jugadores se dirá jugador 1 00:43:06
y a cada uno de los jugadores le queremos dar una serie de cartas 00:43:12
que es el inum cartas 00:43:16
Entonces, ¿qué tenemos? Para cada jugador, otro bucle aquí, decimos for j igual a cero, mientras j sea menor, en este caso, que la longitud, que el número de cartas que tiene cada uno de los jugadores, a ver, algo estoy haciendo mal, vale, tengo que decirle que esto es un int, mientras j sea menor que, esto está mal escrito, punto, 00:43:17
Ah, no, es que he puesto número de cartas y no un cartas, ya está, mientras sea menor que el número de cartas, esto no es un array, no tengo que poner .length, correcto, J++. 00:43:58
Y ahora lo que hacemos en este caso es, pues nada, darle, repartir las cartas, ¿qué hacemos? Cogemos una carta, la primera que tenemos disponible del mazo, 00:44:14
Como no queremos que la misma carta se vea diferente, lo que haremos será un remove. El método remove de un ArrayList nos devuelve el elemento y una vez devuelto el elemento lo elimina de la lista. 00:44:26
entonces podemos aprovechar y sacarlo por pantalla si queréis aquí, system.auth.println 00:44:40
vamos a poner aquí un barra T para hacer una tabulación y que se quede tabulado junto a lo del jugador 00:44:46
y cogemos una carta del mazo, que ya la habíamos llamado rlmazo 00:44:59
y hacemos un remove, fijaros un remove nos va a pedir que indiquemos que carta del índice de todas las relays 00:45:16
que queremos rescatar y nos va a devolver 00:45:23
un string con la carta que estamos recuperando 00:45:25
como el remove 00:45:27
cada vez que cogemos una carta 00:45:29
nos la quita ya el mazo, pues vamos a coger 00:45:31
siempre la que está arriba del todo 00:45:33
entonces decimos que nos quite 0 00:45:34
nos devuelve el string 00:45:36
como es remove, lo quita de la lista 00:45:38
y al estarlo devolviendo nos lo estará mostrando 00:45:40
el system of printl 00:45:43
y ya está, yo creo hecho el reparto de cartas 00:45:44
cada uno de los jugadores 00:45:53
nos dirá jugador 1 00:45:55
jugador 2, jugador 3 y luego hacemos 00:45:57
una vuelta quitamos tantas cartas como tengamos aquí en el ningún cartas para cada uno de los 00:45:59
jugadores y lo mostramos por pantalla no sé si no estoy seguro que sea el formato que nos está 00:46:05
pidiendo el enunciado pero bueno en cualquier caso sería cuestión de dar formato diferente al 00:46:10
sistema sprint el n a la hora de sacarlo por pantalla y bueno y fijaros una repartida las 00:46:15
cartas aquí si queréis incluso para que nos quede todo más cerradito ahora hacemos ejecuciones y 00:46:24
probamos. Ya os he comentado 00:46:30
otras veces que es mejor ir 00:46:32
haciendo pruebas parciales del código 00:46:34
y no meter todo el código como estoy haciendo yo 00:46:36
y luego querer probar 00:46:38
porque si hay errores es más difícil encontrarlos 00:46:40
con mucho código que si lo vamos haciendo poco 00:46:42
a poco. Así que lo que 00:46:44
he hecho yo 00:46:46
no lo cojáis como práctica habitual 00:46:46
y mejor ir haciendo pruebas, ir 00:46:50
probando el programa 00:46:52
cada cosita que vayáis haciendo. 00:46:53
Lo que se me ocurría, lo que os proponía 00:46:57
que podíamos hacer ahora es 00:46:59
indicar cuántas cartas han quedado sin repartir si queréis esto lo podemos 00:47:01
poner aquí diciendo system.out.println ya una vez hecho ya el reparto 00:47:06
cuántas cartas han quedado sin repartir pues aquí podemos poner un mensajito 00:47:14
diciendo vamos a meter alguna linta más vamos a poner un barra t que estamos 00:47:19
está volando todo y decimos han quedado más y el número de cartas que han quedado en el mazo 00:47:24
están son las que hay aquí la gente había sin repartir decimos al punto y las podemos utilizar 00:47:35
el método side que dice el tamaño que tiene el mazo ahora teniendo en cuenta que saben con los 00:47:44
remus se han ido descontando cartas ya y aquí podemos poner cartas sin repartir y bueno con 00:47:50
esto yo creo que tendríamos el ejercicio razonablemente resuelto vamos a probar vamos 00:48:02
a hacer una primera ejecución así sin meter ningún parámetro como no hemos metido parámetros se 00:48:08
entiende que ha hecho la ejecución por defecto no dice el número de parámetros incorrectos no 00:48:17
hemos metido ninguno, se consideran valores por defecto, los valores por defecto 00:48:23
es el juego del Moose, dice el jugador 1, 2, 3, 4 jugadores, 4 cartas 00:48:27
por jugador y cartas y baraja española 00:48:31
así a simple vista, no veo, no me parece que se repitan 00:48:34
con lo cual sí que se ha cargado bien la lista porque nos ha dado cartas 00:48:39
de la baraja española y el remove ha ido funcionando porque 00:48:43
han desaparecido, o sea no parece que haya repetidos 00:48:46
Y luego, bueno, fijaros, 40 cartas que tiene la barra española, menos una, menos, ¿cuántas hemos repartido? 4 menos 16, pues 16 más 24 nos vamos a las 40. 00:48:50
Vamos a hacer algunas ejecuciones con otros datos, mirad, nos venimos aquí para meter datos en Eclipse, nos iríamos aquí a Run, Run Configuration, en Eclipse y nos venimos aquí a Arguments. 00:49:04
Entonces vamos a meter, por ejemplo, primero una con dos atributos que no llega a tres, para comprobar una de las validaciones. Hacemos ejecución, nos dice número de parámetros incorrectos, se consideran los valores por defecto y volvemos a tener una jugada de Moose, cuatro jugadores con cuatro cartas. 00:49:17
Vamos a poner un atributo diferente, vamos a poner que este, no sé para qué validar el try-catch que pusimos a la hora de considerar los argumentos de entrada, aquí en lugar de un número ponemos una cadena de texto, entonces cogemos y dice error en los parámetros de entrada, que es el mensaje que hemos puesto en el catch, poníamos los valores por defecto, volvemos a tener cuatro jugadores y juego del Moose. 00:49:35
Vale, pues nos venimos a RAN Configuration por aquí de nuevo y ahora vamos a poner que haya tres jugadores a tres cartas cada uno en este juego y baraja española. 00:50:02
Pues vale, tres jugadores, baraja española, cada uno con tres cartas. 00:50:19
Como se han repartido nueve cartas, pues dice que nos quedan por repartir treinta y una. 00:50:24
Vamos a hacer una prueba con la baraja francesa, 331 por ejemplo. 00:50:27
dice, bueno, pues tres jugadores, efectivamente tenemos ahora cartas de la baraja francesa y habíamos dicho que había 52 cartas, verdad, creo recordar, habíamos echado el cálculo, a ver, aquí en el código, en la constante, habíamos considerado que cuando no metíamos los comodinios había 52 cartas, como se han repartido 9, pues nos quedan 43 por repartir y no parece que haya repetidos, pues nada, la jugada parece que sigue bien. 00:50:38
y si ponemos 4-5-1 que era el juego típico del póker 00:51:08
en ese caso, damos aquí a la ejecución 00:51:15
para el juego del póker tenemos 54 cartas en total 00:51:17
resulta que hemos repartido a 4 jugadores 5 00:51:24
pues serían 20 cartas repartidas y dice que nos quedan 34 00:51:28
así que parece que sí que ha tenido en consideración lo de meter los comodines 00:51:32
y no sé si ha caído en esta vez, no parece que haya caído en ningún comodín, vamos a hacer un par de ejecuciones 00:51:36
a ver si sale en alguno de los comodines, en alguna, mirad, aquí resulta que ha tenido suerte el jugador 4 y le ha tocado el comodín 00:51:42
y bueno, y poca cosa más, simplemente vamos a aprovechar que estamos hablando de los parámetros y os voy a enseñar a ver si nos funciona bien 00:51:50
desde Eclipse hemos visto que los parámetros en el proceso de ejecución 00:52:02
los metemos aquí a través de Run Configuration Arguments 00:52:06
pero la idea de esto es que el programa cuando estén en un entorno 00:52:10
de trabajo sin IDES, pues lo podamos 00:52:14
configurar para que haga el reparto que corresponda. Entonces si nos vamos 00:52:18
aquí al Workspace, hemos llamado Tarea 10 00:52:22
al proyecto, nos venimos a los binarios y aquí 00:52:29
tenemos el punto class con el base code del programa con el que estamos trabajando entonces 00:52:36
si ahora ponemos aquí llamamos al intérprete de java 9 y le pasamos aquí los parámetros vamos a 00:52:40
hacer una ejecución sin pasar de parámetros pues fijaros que nos ha hecho un reparto de la baraja 00:52:47
española y nos dice el número de parámetros incorrecto si ahora cogemos y le decimos pues 00:52:53
mira quiero tres jugadores que tenga cada uno dos cartas de la baraja francesa veis cómo metemos 00:52:59
desde el terminal cuando hacemos una ejecución 00:53:05
sin entorno de desarrollo los parámetros 00:53:08
que luego se cargan en el método main 00:53:10
en el array arc S 00:53:12
pues tres jugadores 00:53:14
uno, dos, tres, dos cartas 00:53:16
baraja francesa 00:53:18
pues aquí tenéis la ejecución 00:53:20
quería enseñaros esto desde el terminal 00:53:21
para que vierais como podemos 00:53:24
parametrizar nuestro programa a través 00:53:26
del array arc S 00:53:28
de esta forma si entregamos este punto 00:53:29
class a un cliente que nos lo haya solicitado 00:53:32
puede hacer diferentes ejecuciones sin necesidad de si vamos a repartir con una o con otra, hacer nuevas compilaciones del programa. 00:53:34
El mismo programa, considerando los métodos recibidos por ARS, tiene comportamientos diferentes, en este caso, en tanto en cuanto seleccionamos una baraja, el número de jugadores y el número de cartas. 00:53:42
Con esto yo creo que queda razonablemente resuelto la tarea. Espero que os resulte útil. Paro ya la grabación y nos vemos el siguiente lunes si no tenemos ningún percance. Esperemos que no. Venga, que tengáis buen puente. Hasta luego. Un saludo. 00:53:54
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
JM
Subido por:
Jose Manuel M.
Licencia:
Dominio público
Visualizaciones:
33
Fecha:
30 de abril de 2025 - 12:11
Visibilidad:
Clave
Centro:
IES ALONSO DE AVELLANEDA
Duración:
54′ 13″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
120.14 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid