2025-01-27-Programacion | Mediateca de EducaMadrid

vale pues alguna cosita por ahí alguna pregunta que queráis que tengáis antes de arrancar a 00:00:01

contaros yo cosas pues había pensado normalmente cuando cerramos un tema pues me gusta repasar la 00:00:08

tarea ya para dejarlo concluido el tema por completo y bueno pues ahora que vamos haciendo 00:00:24

la tarea pues siempre es buena oportunidad para ir repasando un poco los conceptos que hemos visto 00:00:29

durante la tarea esta, así que si os parece pues resolvemos, aunque ya tenéis una versión 00:00:35

también abierta incluso en el aula virtual resuelta, pues la trabajamos aquí y así 00:00:41

pegamos un último repaso y la semana que viene pues ya hablamos de cosas del tema 00:00:47

que justo está recién abierto esta semana. En particular, bueno, pues hay como dos bloques 00:00:53

en el tema 6, uno que sigue hablando de cosas 00:00:58

de Java, bueno todo es Java 00:01:01

lógicamente, pero cosas más 00:01:04

de clases en sí de Java, habla de la clase 00:01:07

Stream con un montón de métodos que tiene 00:01:10

es una clase muy interesante 00:01:12

porque se utiliza muchísimo y los métodos 00:01:16

nos pueden ayudar a resolver bastantes cosas 00:01:19

y luego tiene otro bloque que habla de expresiones regulares 00:01:21

que no es una cosa ni mucho menos exclusiva 00:01:25

de Java, aunque también se pueden integrar las expresiones regulares en los programas 00:01:28

de Java. Y bueno, conocerlas es también porque 00:01:32

da mucha potencialidad a la posibilidad 00:01:36

de hacer filtros o de hacer búsquedas, tanto 00:01:40

dentro de un lenguaje como, por ejemplo, en accesos 00:01:44

a base de datos, con instrucciones de consulta, 00:01:48

como consultas desde lenguajes 00:01:53

de programación. Conoceremos un poco las expresiones 00:01:56

regulares también y como hay clases que tenemos en las librerías 00:02:00

disponibles que nos permiten integrar estas expresiones regulares 00:02:04

dentro de nuestro código. ¿Os parece bien el plan? ¿Arrancamos 00:02:08

con la tarea del tema anterior? 00:02:14

Vale, pues nadamos con ello. 00:02:19

Una cosilla respecto a la tarea, ni mucho menos es bronca 00:02:23

y no es que me moleste mucho. En algunas tareas, que no todas, pues bueno, pues se ve mucho la mano de ChaGPT. 00:02:27

Yo que sé, a mí me resulta un poco incómodo ponerme a corregir una tarea e intentar sacar algunos comentarios 00:02:37

o expresar mis puntos de vista sobre alguna de esas tareas cuando sé que en realidad se la estoy corrigiendo a ChaGPT, ¿no? 00:02:41

Entonces me parece que no resulta útil en verdad para nadie, ni para quien la entrega. 00:02:47

Y bueno, para mí el rato ese, bueno, no es que me importe porque al final tengo mi horario para hacer estas cosas de corrección de tareas, pero sí que me parece que resulta poco útil. Me refiero a algunos casos particulares. Simplemente lo lanzo ahí y ya está. Yo no me voy a poner a discutir con nadie, creo que tu tarea está entregada por ChagPT o no, o inteligencia artificial equivalente a ChagPT. 00:02:52

entonces bueno, yo os invito a los que trabajéis las tareas 00:03:16

pues que si no entendéis cosas 00:03:20

pues utilizad los foros, preguntadlas 00:03:23

aunque sean incluso de la propia tarea que tenemos abierta 00:03:25

si no me importa, si lo útil de las tareas 00:03:28

es que vayáis aprendiendo de cara a luego el examen 00:03:30

que es donde de verdad sin posibilidades de herramientas adicionales 00:03:34

vais a tener que escribirlo y además 00:03:38

afortunado o desafortunadamente va a ser en un papel 00:03:39

entonces el entrenamiento de las tareas os puede venir bien para eso 00:03:43

y un copy y paste de chat GPT no va a ayudar en nada. 00:03:46

Entonces, bueno, si os complican algunas de las prácticas, 00:03:52

es normal, estamos ahí en el proceso de ir aprendiendo. 00:03:55

Aprovechar los foros y ya os digo, 00:03:59

aunque cuando lo vayamos comentando 00:04:02

no pongamos el resultado total de la tarea en ese momento, 00:04:04

pero bueno, pues puede resultar interesante 00:04:08

para ir viendo ciertas cosas o ir avanzando en la práctica 00:04:10

o ir entendiendo algunos aspectos. 00:04:13

creo que para vosotros incluso puede resultar más útil. 00:04:16

Bueno, ¿por qué os lo digo? Bueno, pues alguna de las tareas, pues ves cosas por ahí que salen bastante de un poco el modelo 00:04:21

o un poquillo del modelo de cómo vamos viendo nosotros la programación. 00:04:30

Y es cierto que algunos de vosotros podéis tener también experiencia previa y saber programar muy bien, muy bien en Java. 00:04:34

entonces, bueno, pues como me descuadra un poco 00:04:39

pues yo también soy capaz de coger el enunciado, ponerlo en ChagPT 00:04:43

y bueno, pues ves que la propuesta que te ofrece ChagPT 00:04:46

pues es muy parecida a la que a lo mejor está entregada 00:04:50

cuando está incluyendo ciertas cosas 00:04:52

que realmente no se ajustan al modo en el que estamos 00:04:54

un poco contándolas aquí en clase 00:04:58

bueno, simplemente es una reflexión 00:05:00

ya os digo, hacer un poco lo que queráis 00:05:03

las prácticas son para vuestro entrenamiento 00:05:05

A mí no me, bueno, me cuesta un rato, lógicamente, corregirlas, pero forma parte de mi trabajo, con lo cual, bueno, pues lo hago gustosamente. Pero quien se base un poco en esta línea, pues realmente no va a sacar el rendimiento que de verdad podría sacar trabajándolo con la práctica. 00:05:07

Pero bueno, dicho esto, simplemente por expresarlo. Vamos al ataque, a leer el enunciado y vamos a ver cómo planteamos el ejercicio. 00:05:25

Mirad este ejercicio, lo hemos enunciado un momento así de forma rápida, tiene un poquito de blablabla por aquí, una calle peatonal, en definitiva, hay tres tipos de actividades en academias, de música, inglés y baile. 00:05:41

Proponemos que cada una de las actividades tenga dos horarios los sábados, que son de 10 a 11 y de 11 a 12, y en cada una de las clases entra un máximo de dos personas. 00:05:58

Y luego, en el total de actividades que se pueden reservar un sábado, aunque haya plazas porque no se cubran entera, de forma completa, pues proponemos que haya un máximo de cuatro alumnos. 00:06:11

A lo mejor los cuatro alumnos han decidido ir a esa mañana a clase de música, repartidos en los dos horarios, y a inglés y baile no va nadie. Pero bueno, bloqueamos en el enunciado hasta un máximo de cuatro alumnos. 00:06:23

Nos da dos opciones, que lo comentaba a una pregunta que me hacía un compañero ahí en el foro. Nos da la posibilidad de gestionar también el máximo este de cuatro y luego, además, para probar en línea general ese programa, metiendo cuatro alumnos en cada ejecución, nos permite probar prácticamente todas las cosas con dos o tres ejecuciones y así no nos pasamos mucho rato metiendo datos hasta un máximo de doce, 00:06:37

que sería el máximo de alumnos que podría entrar dentro de las tres academias cualquiera de los sábados. 00:07:05

Además propone que cuando estamos metiendo hasta un máximo de cuatro alumnos, 00:07:14

pues se pueda dejar inscribir a la actividad alumnos poniendo la palabra fin. 00:07:19

Bueno, pues un control más que hay por ahí. 00:07:25

En el desarrollo, pues bueno, se propone que se haga en dos clases, Academia y Agenda. 00:07:27

Digamos que la Agenda sería la clase donde se inicia el programa y tiene instancias, digamos, de objetos, 00:07:38

instancias de la clase, de las diferentes clases Academia, y el código de la clase Academia que sea común 00:07:47

y, bueno, pues podamos diferenciar una academia u otra en función de sus atributos. 00:07:54

Y el nombre que en particular diferencia unas academias de otras, pues es el atributo nombre. 00:08:00

Entonces, para la clase agenda, pues lo que propone es que sea desde donde inicia, aquí con el main, 00:08:06

que tenga tres atributos, que tenga tres instancias, perdón, tres objetos, 00:08:14

de los objetos que podemos crear en la clase 00:08:19

agenda, uno para música, baile e inglés 00:08:22

al cual le asignaremos en el atributo nombre 00:08:27

la actividad para la que está dedicado. 00:08:31

Aquí dice, ¿valora si estas referencias pueden ser estáticas? 00:08:35

¿Cuándo podrían ser estáticas? Cuando todos los posibles 00:08:39

objetos de la clase tuvieran 00:08:43

a ver, como os diría, si definimos 00:08:47

estas referencias dentro de la clase de academia, las podríamos, agendas, las podríamos 00:08:54

definir estáticas en el momento en el que todas las posibles 00:08:58

agendas que existiesen tuvieran, utilizasen la misma 00:09:02

academia de inglés, la misma academia de baile y la misma academia de música 00:09:05

porque todas las agendas compartirían 00:09:10

estas tres academias. Como solamente 00:09:12

consideramos una agenda, pues ella misma es capaz de compartirlo 00:09:17

con sí misma, con lo cual sería posible definir las estáticas. 00:09:22

Bueno, podemos no hacerlo durante el desarrollo del ejercicio o sí. 00:09:26

Pero ya os digo, como todas las agendas comparten las mismas 00:09:33

academias, de hecho, en este caso es así porque solamente existe 00:09:36

una agenda, entonces la comparte consigo mismo y con nadie más, 00:09:41

estas academias podrían llegar a ser estáticas. 00:09:45

Y luego propone que se cree un método 00:09:50

MostrarAgenda que indique con esta estructura 00:09:54

las reservas que se han hecho de cada una de las academias. 00:09:59

Digamos que la clase Agenda es la clase conductora del programa 00:10:06

y la clase Academia es de la que vamos a ir instanciando academias 00:10:10

que van a ir dando, digamos, el servicio a la clase agenda, por decirlo de alguna forma. 00:10:14

Y la clase academia, bueno, pues tiene aquí unos cuantos atributos que se nos ha ocurrido poner. 00:10:20

El nombre, podemos aplicarle si se trata de una agencia de música, inglés o baile a través del constructor. 00:10:24

Probablemente lo diga por ahí en el enunciado. 00:10:34

Dos atributos que sean el número de reservas que hay en la sesión 1 y la sesión 2. 00:10:37

Fijaros que estos dos atributos existirán para cada una de las instancias de academia, con lo cual podrá valer 1 o 2 y es un máximo de 2 porque así lo indica el enunciado por aquí, que en cada una de ellas habrá dos alumnos por sesión como máximo y ese es el motivo por el que creamos aquí una constante con valor 2 del número de alumnos que puede haber en cada una de las sesiones. 00:10:43

de cada una de las academias 00:11:13

dice que tendrá un método constructor 00:11:17

que recibe un string 00:11:20

en el cual indicamos el tipo de actividad 00:11:21

y este tipo de actividad se terminará guardando 00:11:24

en el atributo nombre 00:11:27

comprobar disponibilidad 00:11:29

en una determinada sesión 00:11:32

para ver si esa academia en particular 00:11:34

tiene disponibilidad 00:11:37

o ya se han ocupado las dos plazas 00:11:38

el método reservar plaza 00:11:40

este método reservar plaza es en principio el que llamaremos desde 00:11:42

la clase, desde métodos de la clase agenda 00:11:46

y el método infosesión que para una sesión devuelve 00:11:50

un string con la información de la sesión 00:11:56

por la que se está preguntando para esa academia en particular 00:12:00

y la idea es que este método sea el que vayamos llamando para 00:12:04

ambas sesiones de cada una de las tres academias desde el método 00:12:08

mostrar agenda de la clase agenda y luego bueno pues dice aquí pues desarrolla los getters y los 00:12:12

setters que sean necesarios. La secuencia del programa dice se solicita el nombre de los alumnos 00:12:21

por teclado, se irán introduciendo nombres hasta un número hasta un máximo de cuatro como decía por 00:12:27

aquí arriba o hasta que se meta a fin por si antes de llegar a cuatro, si llegamos a cuatro ya concluye 00:12:32

la entrada de datos verdad para reservar horas de la en las academias y si antes de llegar a 00:12:44

4 metemos fin pues terminamos el de igual forma de introducir los reservas dice cada uno de ellos se 00:12:51

le pregunta por teclado a qué actividad quiere apuntarse y en qué sesión si hay plazas disponibles 00:12:58

fijaros esto lo preguntaremos a través de teclado pues clase escáner estaremos trabajando con un 00:13:04

un bucle por aquí hasta que hayamos metido hasta cuatro alumnos o introduzcamos fin y para cada uno de ellos dentro del bucle le pediremos como decimos su nombre, le indicaremos a qué actividad y en qué sesión quiere apuntarse y haremos una llamada al método reservar plaza que lo tenemos disponible para la academia a la que se quiera apuntar y en la sesión a la que se quiera apuntar. 00:13:12

Este reservar plaza tendrá que devolver un verdadero o falso si la plaza ha sido reservada y para ello internamente tendrá que mirar a ver si hay disponibilidad y de haberla, coger y bloquear una de las plazas para quien lo está solicitando y devolver una plaza reservada para que desde el main también, desde la clase academia, sea capaz de notificarlo por pantalla. 00:13:42

Y luego después de hacer todo el recorrido para cada uno de ellos, la idea es mostrar el resumen llamando al método mostrarAgenda que hemos identificado aquí en la clase agenda y este hemos dicho que iba a recoger su información a base de llamadas al método infosesión de cada una de las academias. 00:14:09

Cuando vayamos haciendo el código, fijaros que en la clase agenda lo que vamos a hacer va a ser llamadas a métodos que identifican muy bien las funcionalidades de lo que queremos. 00:14:33

que va a ser reservar plaza y mostrar agenda. 00:14:51

O sea, desde mostrar agenda vamos a llamar a infosesión 00:14:58

y cuando lo vayamos haciendo vamos a llamar a reservar plaza, 00:15:02

¿se llama? A ver, como hemos dicho, a reservar plaza. 00:15:07

Y desde la clase agenda, que puede estar siendo desarrollada 00:15:11

por un equipo de trabajo diferente, lo único que conoceremos 00:15:14

o que deberíamos conocer de la clase academia es su interfaz. 00:15:17

El interfaz es el conjunto de métodos mediante los cuales podemos comunicar 00:15:24

con objetos de la clase academia. 00:15:30

Entonces, a través de esos métodos, nosotros pedimos que vayan pasando ciertas cosas. 00:15:34

Por ejemplo, resérvame una plaza. 00:15:39

Fijaros que desde quien esté haciendo el desarrollo de la clase agenda, 00:15:42

Si no estamos haciendo en conjunto una sola persona o un solo grupo de trabajo todo el ejercicio, no tendríamos por qué saber cómo se las arregla para ver si hay plazas disponibles y para hacer una reserva. 00:15:46

Simplemente tendremos a través de la interfaz que llamando a este método, indicándole la sesión y un nombre de quien quiera hacer la reserva, esperamos que se haga la reserva porque en la otra clase estará programado. 00:16:00

Esto es una de las características propias de la programación orientada a objetos, que es la capacidad de encapsulación y de ocultación del código. 00:16:16

¿Qué superventaja tiene esto? Pues mirad, pensad que las academias pudieran funcionar para hacer las reservas en base a ver información en unos ficheros. 00:16:24

Pues vale, nosotros desde la clase agenda llamaríamos a reservar plaza y sin saber desde la clase agenda cómo se está consultando si hay plazas libres, 00:16:36

obtendríamos un resultado Boolean diciendo si ha hecho la reserva o no se ha hecho. 00:16:45

Pensad que en la clase academia de repente hay un cambio de tecnología, se instala una base de datos 00:16:52

y ya no hacemos la lectura a través de unos ficheros, sino que necesitamos hacer unos accesos a la base de datos. 00:17:00

Lógicamente reservar plaza y comprobar disponibilidad tendríamos que modificarlo 00:17:07

porque ahora tienen que acceder a una base de datos en lugar de un fichero, pero al tener encasulado el código y ocultado para las otras clases, dando información solamente de nuestra interfaz de acceso, como esta no cambia, seguimos llamando a reservar plaza a través de la, indicando la sesión y el nombre desde el método main de agenda, 00:17:12

el resto de clases no se verían afectadas, es decir, es un cambio 00:17:34

que quedaría encerrado 00:17:39

justo en el código de la clase Academia 00:17:41

es un proyecto gigantesco que necesita hacer accesos a la Academia para las Reservas 00:17:47

desde muchos puntos diferentes 00:17:51

el nuevo mantenimiento, en este caso perfectivo, para modificar 00:17:54

el acceso a las Reservas, que antes era un fichero y ahora ha pasado a ser 00:17:59

un acceso a una base de datos, se trabaja únicamente y exclusivamente en una parcela muy clara del código. 00:18:03

Eso, claro, pues es una ventaja. Imaginaos que esto no fuese así y que el cambio de fichero a base de datos 00:18:08

implicase que, de forma desparramada por ahí por todo el código, tuviéramos que estar haciendo pequeñas actualizaciones 00:18:16

en muchos sitios, que a lo mejor ese cambio luego pudiese tener implicaciones en algunos otros. 00:18:24

Pues claro, se complicaría mucho el análisis para ver dónde hay que tocar, la actualización, la necesidad de volver a probar muchos módulos de código en lugar de única y exclusivamente la clase academia y sería muchísimo más complicado que si trabajamos con esta característica de la aprobación orientada a objetos que es la encasulación y el ocultamiento de la información mostrando cómo interactúo yo con el resto de programas 00:18:30

a través de lo que es el interfaz, que viene a ser aquellos métodos 00:18:59

y aquellos atributos que no tienen propiedad privada, 00:19:02

private, y que son accesibles desde otros puntos del código. 00:19:07

Bueno, dicho esto y contado esto, 00:19:13

vamos a programarlo y vamos a estar haciendo hincapié 00:19:16

incluso en esto que os cuento. Vamos a arrancar Eclipse. 00:19:19

Dudas que os puedan surgir me vais diciendo, 00:19:41

según estemos trabajando, se toma su tiempo 00:19:43

vamos a cerrar aquí estos ficheros de practicar de otros días 00:19:59

entiendo que no me habéis dicho nada, los vídeos podéis acceder bien, ¿verdad? 00:20:07

de las tutorías que vamos grabando, pues nada, vamos a poner aquí tarea 5 00:20:14

creamos la clase agenda 00:20:27

y la clase academia, la agenda es la que tiene 00:20:52

el inicio del programa, así vamos a crear el método main 00:21:07

Vale, como atributos, cosas que pueden caracterizar una agenda, aquí recordando un poco los ámbitos de las variables, aquí podríamos definir todos los métodos que tengan, todas las variables que tengan que ver con cualquier método incluso y como estarían definidas en este ámbito las tendríamos disponibles. 00:21:11

Pero la idea de los atributos de clase es definir aquellos atributos, aquellas características que tienen que ver justo con la clase que estamos definiendo. En este caso, ¿qué cosas podría definir una agenda en el contexto de nuestro programa? 00:21:48

pues bueno, las academias con las que podemos ir formando las reservas. 00:22:08

Por ejemplo, una variable que en un momento dado, una variable de tipo entero, inti, 00:22:13

que luego vamos a ir utilizando para recorrer un bucle, pues esta variable no caracterizaría una agenda. 00:22:17

Si la ponemos aquí y la utilizamos en el main, nos va a compilar y el programa va a funcionar, 00:22:24

pero no tendría sentido a nivel de diseño. 00:22:29

entonces por nada, definimos aquí los 00:22:32

los objetos de la clase academia 00:22:43

podemos poner academia, mi música vamos a poner 00:22:47

la academia de música 00:22:54

podemos definir un objeto de la clase academia 00:22:55

para la academia de música 00:23:07

para la segunda de las academias había una de inglés 00:23:08

verdad pues inglés y para la de baile recordad que bueno ahora me compila directamente fijaros 00:23:13

que en la clase academia no tengo nada definido aún así el constructor por defecto siempre está 00:23:28

disponible para bueno pues para permitirnos aunque no definamos ningún constructor en la 00:23:33

clase de la que instancia mos objetos pues para que para que aquello compile en el momento que 00:23:38

definamos cualquier constructor tanto el que no tiene parámetros como cualquier otro el de por 00:23:44

defecto dejaría de funcionar. Entonces sí que es cierto que hemos dicho que una de las cosas que 00:23:50

vamos a tener en las academias va a ser el atributo de nombre. Si aquí en la clase academia 00:23:55

definimos un string ese nombre, pues este nombre habíamos propuesto en el enunciado que se cargase 00:24:02

a través del constructor. Vamos a definir el constructor de momento por aquí. Fijaros, los 00:24:13

atributos, le podemos indicar, aparte del tipo, 00:24:19

le podemos indicar el alcance que tenga. Este, recordad, podría ser 00:24:24

private, protective, 00:24:27

package, para que tuviera acceso a todo el paquete si no decimos nada, 00:24:32

o public, para que esté accesible desde cualquier sitio. 00:24:35

Lo ideal es siempre restringir 00:24:40

al máximo el acceso, que dé el servicio que se 00:24:43

precisa de los atributos y los métodos al programa, pero bueno, 00:24:47

¿para qué vamos a dejar, no sé, si no tenemos necesidad, para qué 00:24:51

vamos a dejar especialmente abierto un atributo para que actualizaciones 00:24:55

en el código pudieran llegar a hacer cosas imprevisibles en nuestros atributos? 00:24:59

Pues mira, vamos a ponerle de momento aquí un private 00:25:04

y vamos a decir que sea privado, solamente tenga acceso desde la propia clase 00:25:06

y luego si durante el desarrollo del programa necesitamos desde fuera de la clase 00:25:11

acceder a este, pues creamos un getter y un setter para tener controlado 00:25:15

cómo asignamos el valor y cómo lo devolvemos. 00:25:19

La asignación, bueno, la podríamos hacer a través de un setter 00:25:27

o como lo vamos a hacer a través del constructor, pues en principio 00:25:29

no vamos a definir el setter, entonces diríamos que definimos 00:25:34

un método constructor, recordad, los métodos constructores no devuelven 00:25:37

nada, pero tampoco se lo indicamos aquí. 00:25:42

el nombre de 00:25:45

el convenio para el nombre de los métodos 00:25:49

siempre es que empiecen con minúscula y de las clases que empiecen con mayúscula 00:25:54

con la excepción de los constructores que al coincidir el nombre 00:25:58

de la clase y del método pues no puede ser a la vez mayúscula y minúscula 00:26:02

y se mantiene el criterio de la clase 00:26:06

y este método en particular, bueno pues lo empezamos con una mayúscula 00:26:09

con el mismo nombre que la clase y justo me interesa el método es que dentro de la sobrecarga 00:26:13

recibe un nombre. Entonces decimos que la variable de clase ese nombre queremos que tenga el valor 00:26:21

del nombre. Los constructores en línea general son aquellos métodos que utilizamos para inicializar 00:26:33

los objetos cuando van a empezar a funcionar, a formar parte del programa. Fijaros que la llamada 00:26:43

los constructores siempre aparecen después del new que es el que nos hace la reserva necesarias 00:26:48

en memoria ram y ha sucedido que antes me compilaba porque podíamos utilizar el constructor 00:26:54

por defecto pero en el momento en el que construimos un definimos un constructor dentro 00:27:01

de la clase deja de tener ya sentido el constructor por defecto y ya no funciona ese por defecto si 00:27:06

necesitamos un constructor que no reciba parámetros tendríamos que definirlo en el momento que ya 00:27:13

Existe otro sobrecargándolo dentro de la clase academia. 00:27:18

En principio no es necesario, los tres objetos los vamos a crear pasándole el nombre, 00:27:23

pues este constructor nos resulta suficiente. 00:27:26

Entonces vamos a crear aquí, vamos a decirle que este es el de música, 00:27:31

este es el de inglés y este es el de baile. 00:27:37

Bueno, aprovechando a pasarle al constructor para que el nombre de los objetos 00:27:41

lo sepamos asociar justo a la actividad que tienen 00:27:46

y que se guarde en el nombre de la clase. 00:27:50

Decíamos, estos objetos, los diferentes 00:28:00

objetos pueden ser estáticos. 00:28:04

Pues mira, si tuviéramos varias academias de música y de baile 00:28:08

aquí, pues resulta que si definimos 00:28:12

las cosas o si las utilizamos luego por ahí, si las 00:28:18

definimos de forma estática pues bueno pues podríamos tener ciertos problemas pero como 00:28:21

solamente hay uno no va a dar igual definirlo estático o no estático si lo definimos estático 00:28:26

es cierto que luego podríamos acceder a mi música poniendo agenda punto mi música y si no pues lo 00:28:32

ponemos así lo vamos a mantener así si os parece en el método main vamos a ir interactuando a 00:28:40

a través del teclado. Pues mira, vamos a definir un objeto de la clase Scanner, ScannerMyScan, igual a New, Scanner, SystemIn. 00:28:49

Fijaros que, bueno, de partida no me compila. ¿Por qué? Porque no tenemos, pertenece a una librería que está fuera del proyecto 00:29:02

y no la tenemos importada, aquí nos lo ofrece Eclipse 00:29:09

y decimos, si hacemos un system.out.println 00:29:13

y imprimimos algo, aquí tampoco hemos importado el system.out 00:29:21

y en cambio, no se me quejen, me compila 00:29:27

¿por qué es este motivo? 00:29:29

pues en algún momento lo comentábamos 00:29:31

todo lo que está definido en las librerías de Java 00:29:34

java lang en esa colgando esa estructura es se entiende que son funciones que son tan comunes 00:29:37

a todos los programas que directamente se importan de forma automática sin tener que ponerlo 00:29:46

explícitamente en todos los proyectos pero lo que no pertenezca a java lang si quieres utilizarlo 00:29:52

pues hay que importarlo tanto si es de un paquete en nuestro proyecto diferente al paquete en el que 00:29:57

estamos como si es desde librerías de java entonces para que no funcione 00:30:01

escáner cogemos y le metemos el java útil y ahí lo tenemos ya como vamos a ir 00:30:06

leyendo información de aquí pues podemos definir una variable 00:30:15

lectura para ir trabajando con ella fijaros recordad que decíamos que íbamos 00:30:20

a ir cogiendo información de diferentes alumnos para que se apunten a las 00:30:29

academias hasta un máximo de 4 o hasta que introduzcamos el texto fin, necesitaremos 00:30:35

llevar un contador del número de alumnos que hasta ahora están matriculados, podríamos 00:30:41

definirlo como 0 o como 1, según definamos aquí un 0 o un 1, según interpretemos que 00:30:49

esta variable recoge el siguiente alumno que se va a apuntar o los que hay apuntados hasta 00:30:56

el momento, pues la podríamos inicializar a 0 o a 1 y en consecuencia de cómo lo hagamos 00:31:01

aquí tendremos que ir trabajando luego en los 00:31:06

bucles. Vamos a ponerlo por ejemplo a cero 00:31:09

inicialmente y bueno 00:31:12

pues ahora luego vamos metiendo más variables según nos vaya 00:31:17

demandando el programa. Entonces vamos a pedir 00:31:20

para trabajar con escáner, lógicamente siempre 00:31:25

habrá que ir poniendo system out en pantalla 00:31:28

para que el usuario entienda lo que 00:31:30

tiene que ir introduciendo. Entonces vamos a decir 00:31:34

pedir al alumno información de la actividad a la que se quiere apuntar. 00:31:36

Bueno, pues ponemos aquí un System. 00:31:52

Podemos adornar un poquito el texto, podemos meter ahí un tabulador quizás, 00:32:03

o un par de tabuladores. 00:32:09

Ponemos una primera línea así que, para que nos saque aquí unos asteriscos. 00:32:11

¿Alguno de vosotros habéis metido códigos o alguno de vosotros que hacía que alguna parte se pusiera en negrita y todo esto? 00:32:18

Bueno, pues muy chulo, la verdad, os ha quedado. 00:32:26

Entonces, vamos a poner aquí, reservando, podemos poner 1, 2, reservando actividades para el próximo fin de sábado. 00:32:30

Metemos un par de tabuladores para que quede de la misma forma. 00:33:03

indica tu nombre o pulsa fin para terminar. 00:33:07

Si ponemos en el System of Print el N, nos va a saltar a la siguiente línea 00:33:16

para que introduzcamos por teclado el nombre o fin. 00:33:19

Vamos a poner un System of Print, dejamos aquí un espacio y así se me queda la misma línea. 00:33:23

Y aquí vuelvo a pegar esto y así ya me queda. 00:33:31

Indica tu nombre, aquí podemos poner incluso alumno. 00:33:38

para ir secuenciando el alumno con el que estamos trabajando 00:33:43

podemos decir alumno y utilizamos esta variable, esta variable vale 0 00:33:55

podemos poner aquí en el mensaje 00:34:00

entre paréntesis decimos la variable alumno 00:34:03

ahora lo repasamos, dice aquí alumno 00:34:08

pues al principio dirá esto vale 0, pues dirá alumno 00:34:17

1, indica tu nombre o pulsa fin para terminar y como este 00:34:21

mensaje lo iremos sacando cada vez que se meta información de uno de los alumnos 00:34:25

luego lo podemos meter en un método incluso y hacer una llamada al método 00:34:29

esto irá incrementando cada nuevo alumno que se vaya conectando 00:34:33

pues entonces cuando valga 1 nos dirá al 1 2 y después de incrementar 00:34:37

otra vez irá al 1 3, de esta forma vamos gestionándolo 00:34:42

bueno pues lo ponemos así que nos lo muestre y ahora 00:34:45

tendremos que estar recogiendo información 00:34:53

hasta que se introduzca la información de cuatro alumnos o se meta fin. 00:34:57

Pues bueno, pues podemos hacer un while aquí mientras el número de alumnos sea menor de cuatro, ¿no? 00:35:02

Es decir, entrará por aquí cuando sea cero, cuando sea uno, cuando sea dos y cuando sea tres. 00:35:17

Y tenemos que poner doble condición porque nos tendremos que salir cuando sea fin. 00:35:26

Y, bueno, aquí tendremos que utilizar la variable donde hayamos leído la información. Vamos a poner ese lectura. Recordad que string es un tipo de datos un poquito especial. Habíamos hablado de los tipos de datos referenciados y primitivos. 00:35:30

los enteros, los datos numéricos, los Boolean 00:35:56

son tipos de datos primitivos, tienen 00:36:01

características muy particulares, que es que no es necesario hacer un new cuando definimos 00:36:04

una de sus variables, digamos que se hace de forma automática 00:36:09

no disponen de métodos para trabajar con ellos, como por ejemplo 00:36:12

la clase Scanner que tiene el NSynth, si queremos trabajar con esos tipos de datos 00:36:17

tenemos que utilizar las clases Wrapper, os acordáis de las clases envoltorios que 00:36:21

cada una asociada con uno de los tipos de datos primitivos 00:36:25

de Java, pues la clase string 00:36:28

está un poquito a medias entre uno y otro. En realidad 00:36:31

es un tipo de datos referenciado, pero 00:36:34

luego tiene bastantes características que se parecen a las 00:36:37

de los primitivos. Y una de las cosas 00:36:40

que tienen los primitivos es que podemos comparar dos números 00:36:43

con igual igual o dos variables boolean 00:36:46

con igual igual, pero en cambio 00:36:49

la clase string por la característica de ser referenciada 00:36:51

no lo podemos hacer así. Entonces para hacer comparaciones podemos utilizar 00:36:55

un montón de ellas que tienen, que vemos algunas o muchas 00:36:59

de ellas ahora en el tema que tenemos abierto, pues podemos utilizar el método 00:37:03

makeEquals que nos devuelve un boolean si son iguales dos cadenas 00:37:07

o el compareTo que nos devuelve si una es mayor que otra 00:37:11

o es menor que otra o si es igual, en ese caso devolvería un número 00:37:15

que es un 0. Aquí como no queremos saber 00:37:19

la ordenación, nos vale con diferenciar si es igual o no, equals 00:37:23

nos resulta suficiente. Entonces decimos 00:37:27

que si el número es menor que 4 y 00:37:31

necesitamos comparar esto pero que no sea 00:37:36

fin, esto nos dice si es fin nos devuelve un true, pues vamos a darle la vuelta 00:37:41

a false. Si sean esas dos características 00:37:45

pues vamos a ver aquí que es lo que tenemos que hacer 00:37:49

que será intentar reservar una plaza 00:37:53

a ver, no sé, me sobra 00:37:55

uno, paréntesis 00:38:00

y aquí otro, no 00:38:02

vale, bueno, no se me están quejando los paréntesis 00:38:07

se me está quejando de que 00:38:18

esa lectura está sin inicializar 00:38:20

vamos a poner aquí 00:38:21

cuando llega esa comparación, vamos a ponerlo así 00:38:22

de momento para que me compile 00:38:26

esa lectura me interesa que tenga 00:38:27

en este momento aquí o un nombre 00:38:30

o fin, y aquí ya lo acabo de pedir 00:38:32

Vamos a capturarlo. Vamos a decir que esa lectura sea igual a mi scan. Hacemos un next line. Recibo nombre de alumno o fin. Una de dos. 00:38:34

Bueno, si hemos entrado aquí, quiere decir que estamos intentando recoger, está un alumno intentando apuntarse. 00:39:05

Lo primero que necesitaremos será conocer a cuál de las tres actividades quiera apuntarse. 00:39:11

Siguiendo un poco esta estructura, podemos separar otra línea aquí, hacer un barra N y decimos indica la actividad. 00:39:17

Si lo ponemos con print lo dejamos en la misma línea en la que estamos. 00:39:39

las actividades puede ser, se lo podríamos indicar también por teclado 00:39:45

que sea música, baile o 00:39:55

inglés. Aquí podríamos validar que la actividad es 00:39:59

una de esas tres, bueno, después lo hacemos, si nos da tiempo 00:40:05

antes de acabar la clase. De momento vamos a 00:40:15

suponer que se mete bien el nombre de la actividad 00:40:19

y bueno, pero esta actividad la tenemos que cargar 00:40:23

en algún sitio, pues entonces podemos coger y definir aquí una variable 00:40:27

fijaros, bueno, os cuento otra cosa, S, actividad 00:40:31

el reservar memoria RAM para una variable única y exclusivamente, bueno, pues 00:40:34

no supone mucho al ordenador, pero bueno, si queremos ser 00:40:41

estrictos e irnos a la teoría, hay diferencias entre definir 00:40:45

esta variable aquí, donde la tenemos ahora mismo, o definirla 00:40:49

aquí, de la misma forma que decíamos 00:40:54

O sea, en el programa antes, si mi scan yo lo defino aquí, me va a compilar y me va a ir bien porque está dentro del ámbito del main. 00:40:59

Pero mi scan es algo que caracterice las agendas? No. 00:41:06

Pues entonces vamos a definirla en el método main, que es una variable auxiliar a este método. 00:41:09

Igual que definir escáner aquí o aquí tiene sus matices, definir string es actividad aquí o aquí, pues también lo tiene. 00:41:14

mira, si la definimos aquí, esta variable 00:41:23

lógicamente va a estar disponible aquí 00:41:31

porque es una variable que hemos puesto dentro 00:41:34

del main, pero molestaremos al sistema operativo 00:41:39

en cuanto a rendimiento, probablemente sea un poquito mejor definirla aquí porque molestaremos 00:41:43

al sistema operativo para hacer una única reserva 00:41:47

bueno, con la clase string tendría sus matices, en la clase int 00:41:51

para hacer una única reserva. Si esta variable la defines aquí 00:41:55

si la defines dentro del while, cada vez estaríamos 00:41:59

pidiendo al sistema operativo, oye, hazme una reserva nueva. ¿Por qué? Porque se va 00:42:03

fuera del ámbito del while. Probablemente definir 00:42:07

las variables aquí permitirían que el programa tuviera un pelín 00:42:11

mejor rendimiento que definirlas aquí. Con el matiz 00:42:15

de que string justo no es el mejor ejemplo para lo que os estoy contando 00:42:19

porque al tratarse de una variable un poquito especial, justo en el tema 00:42:23

que estamos viendo ahora, dice que cada vez que se le asigna un valor 00:42:28

hace una reserva de memoria run, con lo cual no nos libraríamos de esto 00:42:32

que os estoy comentando, pero si estuviéramos hablando de una variable 00:42:35

de tipo int, long o de una variable de tipo objeto de una de las clases 00:42:38

que tenemos por aquí, pues se podría dar esta circunstancia. 00:42:46

Vamos a definirla aquí, esa actividad, y decimos que la actividad la vamos a capturar a través de miScan.nestLine. 00:42:49

Y lo siguiente que vamos a pedirle va a ser la sesión. 00:43:02

Pues definimos aquí también un int y sesión y se la pedimos también. 00:43:09

Vamos a poner uno o dos, luego si acaso lo vamos modificando, que va en diferentes periodos de tiempo. 00:43:29

bueno pues para hacer la lectura 00:43:37

hay varias alternativas 00:43:42

para hacer la lectura siempre asegurándonos 00:43:46

que dejamos el buffer limpio 00:43:48

una de las posibilidades podría ser 00:43:49

decir isession 00:43:52

punto igual 00:43:53

a mi scan 00:43:55

punto nest 00:43:58

podríamos hacer un nesint 00:43:59

ya sabéis que no soy especialmente amigo yo de esto 00:44:15

porque deja el enter 00:44:17

en el buffer pero si que es verdad 00:44:19

que luego puede limpiar el buffer haciendo un nestline 00:44:21

dices, bueno, pues hago luego un next line y limpio el enter, aquí cargo el número 00:44:23

y luego limpio el enter, y otra posibilidad, bueno, pues es 00:44:27

hacer aquí un string, ese aus 00:44:31

voy a decir una variable auxiliar por aquí, la leo 00:44:35

con un next line 00:44:40

y ahora hago un isesión 00:44:50

que sea igual, fijaros, tengo el número 00:44:56

cogido en una variable auxiliar, pero en realidad 00:45:00

es un número escrito de forma alfanumérica. Entonces podemos hacer 00:45:04

un integer.parseInt y aquí indicarle ese aus 00:45:08

y ya me guarda la información como una 00:45:12

variable de tipo int, que es lo que tenemos en mi sesión. 00:45:16

Bueno, pues una vez que tenemos el dato, lo que vamos a hacer va a ser 00:45:23

intentar reservar la plaza. Para la reserva de plaza 00:45:26

lo que vamos a hacer va a ser llamar a un método de la clase academia 00:45:30

entonces, a ver un momentito, como decía aquí 00:45:35

reserva la plaza, recibe la sesión y el nombre de la persona 00:45:41

que quiera hacer la plaza, y devuelve si ha sido capaz de reservarla o no 00:45:47

vamos a decir aquí, vamos a hacer 00:45:52

un public, vamos a definirla como 00:45:55

bueno, sería necesario público, si agenda está en el mismo paquete, podríamos dejarlo así 00:45:59

reserva plaza, devuelve 00:46:04

boolean, recibe 00:46:14

un int y sesión y un nombre, el nombre 00:46:21

del alumno que quiera reservarlo, ese nombre 00:46:28

Bueno, fijaros que lo que he hecho ha sido definir 00:46:30

algo que no tiene un código que sea correcto en absoluto, nos falta por desarrollar toda la 00:46:45

clase academia, pero de cara a agenda 00:46:49

ya tenemos el interfaz de un método que recibe este nombre 00:46:52

que nos va a devolver algo que va a ser un boolean 00:46:57

y que recibe estos dos parámetros de método. 00:47:00

Entonces, para el grupo de trabajo que podría ser totalmente independiente 00:47:06

de la clase academia, gracias a la encapsulación puede seguir trabajando perfectamente. 00:47:10

Y dicen los de la agenda, yo no es mi responsabilidad, yo les pido 00:47:14

que reserven una plaza, si le paso estos dos 00:47:18

atributos en la llamada, si me dice true, yo ya doy por hecho 00:47:22

que la plaza está reservada. Si luego hay problemas de reserva 00:47:26

que a los que han hecho el desarrollo de la clase academia, bueno, pues les pregunten cuál ha sido 00:47:30

el motivo. Y los de la clase academia, bueno, según lo había 00:47:34

pensado yo, la reserva plaza, o sea, 00:47:45

lo primero que voy a hacer luego aquí va a ser comprobar a ver si hay disponibilidad de forma interna 00:47:49

dentro de la clase Academia. 00:47:53

Bueno, sí. 00:47:57

Sí. 00:48:06

Bueno, bueno, sí, bueno, 00:48:09

es igual, ¿sabes? Es una cuestión 00:48:11

de interpretación, a lo mejor, del enunciado. 00:48:13

O sea, tú llamas, consideraste 00:48:15

el método que se llama 00:48:17

de la agenda, el de comprobar disponibilidad 00:48:19

y en caso de disponibilidad, hacía la llamada 00:48:21

a la reserva y yo, bueno, pues 00:48:23

lo consideraba al revés. 00:48:25

Pero vamos, que no está ni mejor 00:48:27

ni peor pensado. Que se llame 00:48:29

oye, resérvame una plaza internamente en la academia 00:48:31

que haga la comprobación y si tiene la disponibilidad se la reserve 00:48:35

y si no le diga que no ha sido capaz de reservarla. 00:48:38

Pero bueno, más o menos, 00:48:42

o sea, es una cuestión de criterio requisito, digamos, 00:48:44

de cómo se engrana un poco la reserva en sí. 00:48:48

Pero yo lo había pensado así, 00:48:51

que el método del interfaz que la academia ofrece hacia afuera, 00:48:53

hacia la clase agenda sea el método reserva plaza de hecho mi intención es que el de comprobar 00:48:58

disponibilidad sea privado para que no haya acceso desde la agenda que haga la comprobación ahora 00:49:04

aquí cuando me ponga a programar esto y en caso de que sea correcto de que no haya plazas que 00:49:11

reservar devuelva reservar plaza un falso y si existe entonces ya coja y haga él para que ponga 00:49:15

por aquí el código para concretar la reserva es como lo había pensado yo bueno entonces una vez 00:49:23

aquí ya tengo la actividad a la que me quiero conectar tengo el nombre que lo he cogido por 00:49:34

aquí también en estas tres variables tengo el nombre el nombre en esa lectura tengo el nombre 00:49:40

pues mira lo voy a cambiar aquí voy a poner ese nombre en esta variable tengo el nombre aquí tengo 00:49:50

la actividad y aquí la sesión. Pues aquí es donde puedo hacer la comprobación 00:50:05

para llamar a unos. Entonces, como cada una de las tres 00:50:11

academias tienen su reserva plaza, voy a diferenciar dentro de la agenda 00:50:15

a quién quiero solicitar la reserva de la plaza, le indico la sesión 00:50:19

y el nombre del alumno. Entonces digo sí. 00:50:23

Esto, bueno, con cualquier estructura de condición lo podríais ver, con Swiss 00:50:29

también lo podríais hacer. Entonces digo sí, la actividad que 00:50:33

la he cargado aquí, esa actividad, punto 00:50:37

recordad que para comparar utilizamos el equals 00:50:41

si resulta que es música, si esa actividad que lo he cargado 00:50:44

por aquí, recordad que no he hecho comprobación a ver si el dato 00:50:57

que habíamos introducido era correcto, aquí si nos da tiempo luego hacemos 00:51:02

una comprobación y si no pues nada, si es música 00:51:05

pues sé que a la academia sobre la que tengo que trabajar es música, pues me voy 00:51:09

al objeto de academia mi música, punto, porque no me deja aquí, me dice que lo meta aquí 00:51:13

entre un tricatch o que la ponga static, claro, el método main es static, pero lo tengo aquí 00:51:37

definido, vamos a ponerlo static, si no le ponemos ahí el tricatch, si es equals, no 00:51:48

Equals no. A ver, se me ha ido el santo al cielo. 00:52:11

Lo que hacemos es reservar, reservar plaza, ¿en qué sesión? 00:52:16

Pues en iSesión, ¿con qué nombre? Con ese nombre. 00:52:22

Esto me devolverá, me indicará si, me devolverá un verdadero o un falso 00:52:26

en función de si aquí se ha concretado la reserva de la plaza o no. 00:52:31

Entonces, para trabajar sobre eso, lo que vamos a hacer es definir aquí 00:52:37

una variable boolean, boolean de reserva realizada, 00:52:39

y lo mismo para las otras dos, si la actividad 00:52:55

no venimos aquí a la de baile y por aquí a la de inglés 00:53:14

alguien hizo algo que 00:53:32

está curioso también, que es una posibilidad para hacerlo, algunos de vosotros 00:53:44

que lo que hizo fue decir, mirad, voy a coger 00:53:48

como aquí estoy comparando si es la de música 00:53:52

y luego esta reserva o la otra, pues lo que hizo fue 00:53:56

definir una academia auxiliar para la cual 00:54:00

no hago un new ni nada, no apunta a ninguna posición de memoria de forma 00:54:08

inicial, no me puedo evitar hacer la comparación 00:54:12

es cierto, pero aquí en lugar de llamar a reserva 00:54:20

plaza de uno, de otro o de otro 00:54:34

lo que hizo fue decir que el academia aus 00:54:37

resulta que si entra por aquí por la de música de forma 00:54:41

queremos que Academia AUS apunte a donde está apuntando ya la de música, 00:54:45

a la misma posición de memoria. 00:54:51

Si es baile, que apunte a la que está apuntando ya la de baile. 00:54:57

Y si es inglés, que apunte a la que está apuntando ya la de inglés. 00:55:02

Con lo cual, AKAUS apunta en memoria RAM a la posición donde apunta 00:55:08

el objeto de la Academia de Música, si hemos introducido como actividad música, 00:55:12

a donde apunta baile, si hemos introducido baile o inglés, si hemos introducido inglés 00:55:17

y en este caso, bueno, pues como está apuntando a la que toca 00:55:21

ya sí que podemos poner aquí reserva plaza 00:55:26

bueno, pondríamos esto una sola vez, bueno, valdrá una otra 00:55:28

u otra, pero se me queja si no lo he inicializado 00:55:36

¿veis? entonces aquí llamaría una vez solamente a reserva plaza 00:55:41

para una academia auxiliar que estaría apuntando 00:55:45

de memoria RAM o bien a música o bien a baile o bien inglés. Es equivalente a un código 00:55:48

u otro. Pero bueno, me llamó la atención que 00:55:52

alguno de vosotros lo programaréis así y por compartirlo con el resto. 00:55:56

Me lo cargo esto porque es lo mismo un caso que otro. 00:56:02

Entonces, llegados aquí, esta variable, fijaros que aquí no tenemos nada 00:56:10

programado, pero el grupo de trabajo de la clase Academia 00:56:14

que ha venido a trabajar hoy de la clase Agenda, pero los de Academia todavía no han llegado, 00:56:17

llegar un poquito más tarde. Están a punto de acabar con su trabajo 00:56:21

gracias a que tienen una definición del 00:56:25

interfaz de la clase academia donde se sabe que van a llamar 00:56:29

a que existe un método con el cual pueden interactuar pasándole 00:56:33

la sesión y el nombre y que devuelve un boolean. ¿Cómo lo hayan programado 00:56:37

los de la clase academia? A los que están haciendo el trabajo de la clase agenda les da 00:56:41

un poco igual. Luego, para que funcione todo el programa, lógicamente 00:56:45

habrá que hacer este desarrollo, pero digamos que conociendo 00:56:51

la interfaz en la clase agenda de la clase academia 00:56:55

tienen suficiente. Entonces aquí decimos sí 00:56:58

la reserva ha ido correcta 00:57:02

luego ya os digo que si nos da tiempo, hacemos todo más 00:57:08

bonito. Me dice inicialízalo, aunque luego lo vamos a ir modificando 00:57:22

por aquí. Pero sí que es verdad que es posible que llegue el código aquí en una ejecución 00:57:36

si no hemos metido ni inglés, ni música, ni baile. 00:57:40

Entonces, podría llegar aquí y estar sin inicializar. 00:57:43

Es por lo que se queja esto. 00:57:46

Entonces, aquí diría clase reservada. 00:57:49

No ha sido posible reservar la clase. 00:57:57

Si hemos hecho una reserva de una clase, ¿qué es lo siguiente? 00:58:15

Tenemos que mirar más alumnos hasta que sean cuatro o se introduzca a fin. 00:58:19

Después de hacer aquí la primera de las reservas, 00:58:24

la segunda o lo que sea según la iteración del bucle que tengamos 00:58:26

pues lo que tocará será sacar otra vez este mensaje 00:58:30

que luego podemos quitar, definir un método 00:58:33

que sea un método menú y trabajar con él 00:58:36

directamente y después de sacar 00:58:39

el mensaje volver a coger el nombre 00:58:43

vemos el mensaje, cogemos el nombre, se termina 00:58:45

el while, nos venimos aquí, habrá que 00:58:54

incrementar ahora el número de alumnos que han hecho la reserva 00:58:57

y volvemos a hacer la comprobación. 00:59:00

¿En qué caso podemos incrementar el número de alumnos? 00:59:03

Pues bueno, según el criterio que tengamos en el enunciado, 00:59:07

si es cuatro intentos de nuevos alumnos, 00:59:10

pues podríamos poner aquí un y alumno más más, 00:59:14

tanto si se ha hecho la reserva de la clase como si no se ha hecho, 00:59:18

y si pretendemos que sean cuatro alumnos que efectivamente han conseguido reservar, 00:59:21

reservar, aunque recorramos el bucle 10 veces, pues lo podríamos 00:59:26

poner aquí. Vale, pues aquí terminamos el bucle, después ejecutamos 00:59:30

y ahora lo que nos dice el programa es que 00:59:38

antes de terminar el método main, pues mostremos la agenda. Dice que tiene que existir 00:59:42

en la clase agenda un método que sea mostrar agenda. 00:59:46

Entonces, ponemos aquí mostrar agenda. Bueno, no le gusta de momento 00:59:50

porque no está definido, pues vamos a definirlo. Hacemos aquí 00:59:58

lo podemos definir este método estático, ya que va a ser 01:00:02

único para todos los objetos de la clase agenda 01:00:07

y además nos ahorra tener que instanciar un objeto de la clase agenda 01:00:10

cosa que sería necesaria si no la definimos static 01:00:15

para que pueda ser llamado desde un sitio estático como es el main 01:00:18

entonces ponemos aquí 01:00:21

un public, podemos definirlo como private, void, que no devuelva nada 01:00:24

static 01:00:30

y si lo pongo en su sitio sería 01:00:31

mucho mejor aquí. Aquí la llamada 01:00:37

y aquí aunque no lo tengamos hecho, de nuevo el 01:00:43

grupo de trabajo que está desarrollando la agenda dice 01:00:52

el interfaz de la clase academia me dice 01:00:55

que va a tener un método que se llama 01:00:58

infosesión, que recibe la sesión 01:01:00

y va a devolverme un string 01:01:07

con la información de la academia. Pues entonces 01:01:10

infosesión, podemos poner aquí 01:01:16

infosesión 01:01:20

como es de la clase 01:01:23

academia, pues para cada uno de ellos 01:01:25

punto 01:01:30

y de qué sesión me interesa 01:01:31

que me devuelva, pues de la 1 01:01:33

para música de la 2 01:01:35

para inglés 01:01:43

de la 1 01:01:49

y perdón 01:01:51

inglés de la 1 01:01:52

y para baile de la 1 y de la 2 01:01:55

también, no me compila 01:01:59

lógicamente porque 01:02:04

no tengo definido el método aquí, como estoy accediendo 01:02:06

desde otra clase, pues voy a definirla 01:02:12

con una etiqueta que podría ser, bueno, pues se podría 01:02:15

package, por ejemplo, desde el mismo paquete, igual que aquí, decimos que devuelvo 01:02:20

un string, el método de infosesión y que recibe la sesión 01:02:24

para la que queremos que se nos muestre la información 01:02:28

bueno, de momento por aquí nos compila, más allá de validar 01:02:31

datos y todo esto, aquí yo creo que la clase agenda la tenemos 01:02:44

prácticamente desarrollada. Vamos a ir 01:02:48

metiendo información en la academia y luego la vamos poniendo más bonita. 01:02:51

Bueno, la clase academia tenía 01:02:59

varios atributos, nos pedía uno que fuera el nombre de la academia, 01:03:00

este ya lo hemos utilizado aquí en el constructor, luego tenía 01:03:06

enteros que nos permitían 01:03:10

saber cuántas reservas iban 01:03:14

hasta ese momento en la academia. Entonces vamos a poner 01:03:18

enum al ses uno 01:03:21

números, cuántos alumnos han reservado ya en la sesión 01:03:25

uno, en la sesión dos. 01:03:30

Lo teníamos para los nombres, string 01:03:33

es enum sesión 01:03:36

1, alumno 1, sesión 01:03:41

1, alumno 2, sesión 01:03:48

2, alumno 1 y sesión 2, alumno 2. 01:03:55

Y no sé si teníamos más atributos 01:04:02

identificados. Estas variables están hechas para guardar 01:04:05

los nombres de los alumnos que van reservando 01:04:09

en la sesión que corresponde, el primero de los alumnos y el segundo. Y para la sesión 01:04:12

dos, el primero de los alumnos y el segundo. El ejercicio nos dice 01:04:17

yo creo que sean privados y que vayamos, si es necesario, utilizando 01:04:21

getes y setters, vamos a definir los privados 01:04:25

y de momento ya tenemos aquí el código del constructor 01:04:28

aunque estas variables se inicializan por defecto, por ser de tipos 01:04:32

numéricos y alfanuméricos, tal cual la vamos a poner en el constructor 01:04:37

vamos a ponerlas en cualquier caso y las inicializamos 01:04:41

aunque sea volver a repetirlo 01:04:43

si fueran valores diferentes 01:04:47

pues entonces necesitaríamos sí o sí 01:04:49

ponerlas en el constructor 01:04:51

en este caso no lo podríamos haber ahorrado 01:04:52

disculpad 01:04:55

fijaros como 01:05:19

como bueno, están perfectamente 01:05:20

accesibles a pesar de ser privados 01:05:23

porque claro, la etiqueta privado 01:05:25

lo que hace es restringir el acceso a esas variables 01:05:27

fuera de la clase, constructores 01:05:30

de la propia clase, pues nada, sin problema 01:05:31

lo acepta. Vale, pues nada, vamos a reservar plaza. 01:05:33

Mirad, en reservar plaza, lo primero que se me ocurría a mí era 01:05:45

comprobar a ver si hay plazas. Podemos hacer un comprobar 01:05:48

plaza para una determinada sesión. ¿Para qué sesión? 01:05:52

Pues para la que me están preguntando que si puedo reservar plaza. 01:05:58

El método comprobar plaza, pues mirad, a ver si hay... 01:06:02

Bueno, en el enunciado nos decía que definamos una... 01:06:05

básicamente, bueno, no es 01:06:10

estrictamente necesario, tampoco vamos a utilizar en muchos sitios 01:06:13

el número de plazas, pero sí que en el enunciado, pues me preocupé de ponerlo 01:06:18

para que trabajaréis también y definierais dentro de la 01:06:22

tarea una variable que fuera una constante 01:06:26

que fuera de tipo final, entonces ponemos final de tipo entero 01:06:30

numplazas igual a 2 01:06:34

recordar las variables que identificamos 01:06:40

como final se convierten en constantes. Esto implica 01:06:50

a diferencia de las variables que si intentamos modificarlas durante el código 01:06:53

pues ya no nos deja. ¿Por qué? Pues porque hemos dicho que es una constante. Una constante no cambia 01:06:58

su valor. Además, esto sí por convenio, aunque no 01:07:02

por compilador de Java, se suele poner todo el nombre 01:07:08

con mayúsculas. Igual que vamos teniendo por ahí pequeñas 01:07:11

pistas de a qué se refieren, pues hemos dicho antes que los nombres de los métodos 01:07:16

empiezan con minúscula, menos el constructor, los nombres de las clases 01:07:21

empiezan con mayúscula, pues las constantes 01:07:25

todas las letras en mayúscula. Estábamos, íbamos a trabajar sobre 01:07:28

el método comprobar plaza, pues ponemos aquí 01:07:36

lo de, lo de, comprobar plaza nos puede 01:07:42

devolver un verdadero, nos devuelve un verdadero, si existe la plaza disponible 01:07:47

y un falso o sea un boolean si no lo existe podemos vamos a definir la privada de tal 01:07:51

forma que no formará parte del interfaz de la clase academia de caras afuera sino que 01:07:59

será un método de consumo interno que de hecho lo estamos definiendo para llamarlo desde el 01:08:04

método reservar plaza es privada por lo tanto entonces devuelve un boolean le damos comprobar 01:08:13

plaza y recibe la sesión 01:08:20

para la que queremos hacer la comprobación, ISES por ejemplo 01:08:24

aquí estamos haciendo esa llamada, vamos a recoger su resultado poniendo 01:08:29

aquí un boolean, B plaza disp 01:08:37

en la variable plaza disp recogemos si existe 01:08:41

disponibilidad de plazas todavía para esta sesión 01:08:47

en la academia donde se está ejecutando reservar plaza y aquí para hacer 01:08:51

la comprobación de la plaza, pues lo que podemos hacer 01:08:58

es decir que si if, si 01:09:02

y sesión, y ses, es igual 01:09:04

a 1, recordad que estamos obligando 01:09:13

estamos pidiendo por aquí, y luego si metemos algo diferente 01:09:17

y nos da tiempo, hacemos comprobaciones, pero estamos diciendo que se meta un 1 o un 2 01:09:21

según lo que introdujésemos aquí, pues habría que hacer las comprobaciones ahora 01:09:24

si la sesión sobre la que preguntamos es 01:09:28

un 1 y el número de plazas que van 01:09:32

reservadas hasta ahora, para esa sesión, que parece 01:09:40

para lo que tenemos esta variable por aquí, es menor 01:09:44

de 2, pues quiere decir que hay plazas disponibles, ¿verdad? 01:09:49

Entonces, aquí tendríamos que devolver 01:09:57

un verdadero. Si ponemos aquí un return, lo he puesto 01:10:00

no es incorrecto, lo acepta Java, ¿verdad? 01:10:04

Fijaros, un return true, pues por aquí nos tendrá que aparecer un return 01:10:08

false, que es necesario como instrucción, 01:10:12

como punto de escape de un método que devuelve algo, es obligatorio 01:10:16

ponerlo. Típicamente, a mí me lo enseñaron desde 01:10:20

siempre, se desaconseja en métodos poner 01:10:24

esparcidos a lo largo de su código diferentes returns. 01:10:27

¿Por qué? Porque estás abriendo muchas puertas de salida al método y luego ante un posible mantenimiento que tengas que hacer del código, aquí se ve muy claro porque no es nada, pero si es un método largo que hace llamadas a otros métodos y empieza a haber muchas alternativas de salida, pues muchas salidas es complicado. 01:10:31

Imaginaos que, para lo que os quiero contar, estamos en un estadio y más allá de conglomeraciones porque tenga que salir mucha gente al mismo tiempo, queremos tener un control de las personas que salen. Pues si tenemos 600 puertas, pues va a ser mucho más complicado que si tenemos una puerta solo para la salida del estadio. Matices aparte, si es un estadio grande y tiene que salir mucha gente al mismo tiempo. 01:10:50

En lo que respecta al control un poco y poder hacer un seguimiento del método, sobre todo si hay que hacer un mantenimiento, siempre se recomienda que la salida sea única. 01:11:13

¿Cómo podemos conseguir esto? Pues como de verdad tenemos aquí discrepancias entre lo que hay que devolver, que una vez será true y otra vez será false, pues lo que podemos hacer es poner aquí una variable auxiliar y decirle, por ejemplo, que sea false aquí al principio. 01:11:24

es una de las alternativas 01:11:40

y aquí 01:11:41

coger y hacer un return 01:11:44

ve aus 01:11:45

queremos comprobar 01:11:46

que si hay plaza en la sesión 1 01:11:51

para esta academia, si hay plaza en la sesión 1 01:11:54

es esto lo que tiene 01:11:56

que pasar, pues me dice 01:11:58

oye que si que hay plaza, perfecto 01:11:59

y si no hubiera plaza 01:12:01

si estamos hablando de la sesión 1 01:12:03

ahora tenemos que meter para la sesión 2 01:12:05

lo que tenemos que devolver es un false 01:12:06

necesitaríamos poner aquí un false 01:12:09

tendríamos que poner aquí un else para indicar false 01:12:11

en caso de que no haya disponibilidad, bueno pues podríamos 01:12:19

poner aquí el else en esta compruebo si hay disponibilidad true, else 01:12:23

false o directamente no ponerlo y habernos asegurado que lo inicializamos 01:12:27

aquí a false, de partida consideramos no hay plaza 01:12:31

y ahora en caso de que la haya sobre escribimos la variable y cuando llego 01:12:38

aquí si la he sobre escrito devuelvo true y si no 01:12:45

informo de lo que de partida ya consideraba. 01:12:48

Este método, en función de la sesión, 01:12:53

me tiene que validar si hay plaza en una sesión u otra 01:12:55

y aquí hemos hecho la comprobación para la sesión 1. 01:12:57

Podemos poner aquí un else. 01:13:03

Si la sesión es la 2 01:13:06

y el número de alumnos de la sesión 2 es menor que 2, 01:13:08

pues le decimos un true aquí. 01:13:17

Y podríamos poner esto o esto, 01:13:26

meter en un único if los dos, con un or 01:13:38

si ese, si en la sesión uno o en la sesión 01:13:51

dos, pues devuelvo otro, con un solo if 01:14:01

lo que pasa es que nos complica en este caso 01:14:09

la parte de evaluar el verdadero o falso y en este caso 01:14:11

es más fácil esa parte, pero lo hemos repartido en dos comprobando 01:14:17

a ver si en la sesión dos, y si no se da esa 01:14:21

o esa o el conjunto de esta, pues mantenemos el valor de inicialización 01:14:27

de falso y me dice que no es posible. De la comprobación 01:14:32

de la plaza hemos llegado por aquí. A ver por qué 01:14:36

no haya puesto el nombre bien en alguno de los dos sitios. 01:14:40

Entonces aquí ya tengo si hay plaza. Si hay plaza tendré que 01:14:48

hacer lo que toque y si quiere hacer la reserva y si no 01:14:52

pues no hacer la reserva. Aquí diríamos 01:14:56

If, si hay plaza, pues aquí tengo que hacer la reserva y me aseguraré de que reservar plaza devuelve también un verdadero. 01:15:00

¿Para qué? Para que aquí se sepa que se ha reservado la plaza en la llamada. 01:15:17

Se carga aquí. 01:15:22

Y si no se ha podido reservar la plaza, pues es porque no hay disponibilidad, entonces aquí tendríamos un else. 01:15:25

¿Cómo vamos a hacer para que haya un único return? 01:15:34

por la misma jugada de antes. Yo cojo y digo aquí, bueno, 01:15:36

este Boolean ya lo tengo aquí. Aquí cojo y digo, devuélveme 01:15:43

si se ha producido plaza. Si fue posible hacerla 01:15:48

si había disponibilidad de plaza, pues es porque la 01:15:56

va a reservar aquí. Entonces ya devuelvo directamente bien, reservada. 01:15:59

Y si no fue posible porque no había disponibilidad, pues devuelvo, no hay disponibilidad 01:16:04

de plaza. Podemos hacer esto o podríamos hacer también 01:16:08

lo siguiente, bueno en el else en verdad no hay nada de código 01:16:13

aquí tendríamos que hacer la reserva de la plaza 01:16:20

y otra posibilidad sería hacer así, mirad, if 01:16:22

sí, y llamar directamente aquí al método, comprobar 01:16:27

plaza, en lugar de estar definiendo una variable, esto sería 01:16:36

sustituyendo a este trozo, aquí estaríamos 01:16:40

diciendo, si es posible reservar plaza 01:16:47

pues ya directamente me entro el if, no lo hago en dos pasos 01:16:50

que es cargarlo en una variable booleana y luego hacer la comprobación 01:16:54

de esa variable, es cierto que si hago esto, pues pierdo esta variable 01:16:58

si usamos esta jugada, aquí 01:17:02

tendríamos que hacer la reserva de la plaza 01:17:06

y en caso de no poder reservarse, pues se iría por el else 01:17:08

que ni siquiera existe, entonces no hacemos nada 01:17:14

Entonces, bajo esta alternativa lo que haríamos sería definir una variable aquí boolean, b, plaza disp, la inicializamos a false, decimos inicial, consideramos que no hay plaza y devuelvo esto. 01:17:16

si ha habido plaza, ejecutará esto. 01:17:42

Entonces, ¿qué hago? 01:17:48

Que será la reserva de la plaza que la vamos a hacer ahora. 01:17:49

Entonces, lo que haría esto sería poner esta variable a true. 01:17:52

Entonces, digo, inicialmente considero que no hay plaza, 01:17:58

comprobo si hay plaza. 01:18:00

Este comprobar si hay plaza no lo estoy cargando en ningún sitio. 01:18:03

Si hay plaza, digo, oye, voy a sobrescribir esta variable 01:18:05

que inicialmente estaba considerando que no había plaza 01:18:08

y la ha habido. 01:18:10

De hecho, aquí voy a hacer la reserva de la plaza. 01:18:11

Y digo, ya que sí. 01:18:13

¿Que no hay plaza disponible? 01:18:16

no ejecuta el if, se viene por aquí, no hay else, devuelve lo que tiene 01:18:17

plaza disponible, que es directamente un false. 01:18:21

O si queréis hacerlo pasito a pasito, de esto, y luego hacer la comprobación 01:18:25

aquí. Ahora, está bien que lo hagáis pasito a pasito, 01:18:29

a lo mejor lo veis más claro, con el tiempo os iréis ahorrando poner líneas 01:18:34

cuando ya vais cogiendo más destreza, y a lo mejor haréis esta otra 01:18:37

alternativa. Habíamos llamado a reservar plaza, recordad, 01:18:41

comprobamos a ver si hay plaza, pues venga, si 01:18:48

hay plaza, esto devuelve verdadero, que es 01:18:54

lo que está haciendo esto con el return, y si es verdadero 01:18:58

estamos aquí dentro del if, modificamos la variable esta que vamos a utilizar 01:19:02

para el return a true, porque sí que se ha reservado la plaza 01:19:06

y hacemos un return por aquí, y en 01:19:10

el método reservar plaza toca reservarla aquí, hay plaza 01:19:14

pues vamos a reservar. Pues venga, para hacer la reserva tenemos que mirar 01:19:25

a ver en qué sesión vamos a reservar. Entonces decimos la sesión 01:19:35

en la que queríamos reservar, if, si la sesión en la que queremos reservar 01:19:39

es la 1, sabemos que hay plaza con toda seguridad, con lo cual esta variable 01:19:46

valdrá o 1 o 2, o sea, o 0 o 1 01:19:52

o no ha reservado nadie todavía, o 01:19:56

hay una reserva hecha, entonces podemos decir sí, esto es igual a 0 01:19:59

todavía no ha reservado nadie, el nombre de la reserva que estamos recibiendo 01:20:07

lo tendremos que guardar, como todavía no hay reservas, en la variable 01:20:15

sesión 1 al 1, 1, else, si el comprobar reserva estaba bien 01:20:19

y hemos sido capaces de entrar aquí a reservar plaza, quiere decir que esto 01:20:37

vale 0 o vale 1, o sea el else es que eso vale 1 sí o sí, entonces el nombre 01:20:43

se lo aplicamos a la sesión 1 01:20:48

alumno 2. Y sea el caso que sea 01:20:52

lo que hacemos es incrementar esto en 1. Esto es si la sesión es la 1 01:20:56

y si la sesión es la 2. No valdría un else si hemos 01:21:03

hecho las comprobaciones oportunas antes. Entonces sería 01:21:14

el número de alumnos de sesión 2 si es 0. Entonces 01:21:17

el nombre de la sesión 2 del 01:21:23

alumno 1 será ese nombre y el nombre de la sesión 2 01:21:27

el alumno 2 será ese nombre. 01:21:32

Y finalmente devuelvo por aquí, indico 01:21:41

que true para decir, oye, la plaza se ha realizado y 01:21:44

en ese caso devolveré por aquí, correcto, se ha realizado. Para aquí 01:21:48

la llamada al método reserva2, pues lo considero 01:21:52

por aquí. Y en la clase academia 01:21:56

si no recuerdo mal lo que nos queda por implementar 01:22:05

es sesión, entonces el texto 01:22:10

vamos a hacer un primer mensaje así rápido, luego 01:22:19

adornamos mensajes en función de como nos dé tiempo pero 01:22:22

para poder acabar el ejercicio en este 01:22:26

ratillo, vamos a decir si la sesión es 01:22:31

la sesión 1, fijaros este método 01:22:35

pues igual que los otros, va a devolver algo, va a devolver un string 01:22:43

pues si va a devolver un string, lo suyo 01:22:47

por lo que os comentaba antes, si queremos seguir ese criterio, es tener un único return 01:22:51

pero como se va a ir construyendo el mensaje que vamos a devolver 01:22:55

bajo diferentes condiciones, si fels es sesión 1, es sesión 2 01:22:59

como es una cosa u otra, pues entonces lo que vamos a hacer va a ser 01:23:03

definir aquí una variable, ese 01:23:07

InfoDev. La información a devolver 01:23:10

la podemos ir construyendo poco a poco. Entonces decimos la información 01:23:14

a devolver, podemos poner, no sé si es justo el mensaje que pone el 01:23:19

enunciado, vamos a poner Academia aquí, esta parte del mensaje 01:23:23

es común para todos, mi nombre de Academia lo tengo guardado en ese nombre 01:23:27

pues vamos a poner aquí Academia ese nombre. Sesión para la sesión 01:23:33

aquí, alumno 01:23:49

uno, bueno, esto vamos a dejarlo ya, si en la 01:24:00

sesión uno, alumno uno 01:24:07

bueno, luego vamos a ver si alumno uno lo ponemos aquí o lo ponemos a continuación 01:24:11

entonces decimos, si la sesión es la uno, lo que vamos a hacer es que 01:24:17

ese info dev sea igual a ese 01:24:21

info dev 01:24:24

para que tenga toda esta información, verdad, si es como una cualquiera de todos los 01:24:28

mensajes, más 01:24:33

alumno 01:24:34

1, y esto lo tenemos 01:24:36

sesión 1, alumno 1, lo tenemos 01:24:43

aquí, más 01:24:45

después 01:24:53

jugamos un poco para si 01:25:09

este no existe, que ponga un punto 01:25:11

después del alumno 1, pues 01:25:14

lo adornamos un poquito más 01:25:15

si nos da tiempo, ya os digo 01:25:17

que igual no, al final 01:25:19

por pegar un repaso a 01:25:21

tanto concepto teórico, al final 01:25:26

no 01:25:29

me da tiempo a cerrar el ejercicio del todo. 01:25:29

Sesión 2, alumno 1, sesión 01:25:33

2, alumno 2. 01:25:37

Y ahora devolvemos aquí 01:25:42

ese info. Bueno, vamos a hacer una ejecución a ver qué pasa. 01:25:44

Esto de meter todo el código y no hacer ninguna ejecución 01:25:54

parcial no es lo más recomendable, porque si ahora tenemos problemas 01:25:58

pues hay muchos puntos sin validar 01:26:02

antes que estaban más o menos bien y donde buscar 01:26:06

los errores, siempre es más fácil ir haciendo pequeñas pruebas 01:26:09

del código y así si tenemos luego un error pues es muy probable 01:26:13

que sea sobre el último código que hemos metido y es más fácil de localizar 01:26:18

a ver, bueno, fijaros por aquí, nos sale esto un poco descolocado 01:26:21

reservado de actividades, no me ha salido 01:26:29

mensaje para terminar para quitar este de aquí para que se me quede ahí lo tengo aquí indica 01:26:35

el nombre de alumno 1 jose indica la estabilidad música sesión 1 esto me lo pone después vale 01:26:58

pues vamos a poner fin y no me ha hecho nada con el fin vamos a ver evitar este mensaje bueno 01:27:12

cuando un programa no nos funciona, una herramienta bien útil 01:27:41

es ir poniendo trazas, a ver qué va pasando, vamos a poner aquí, vamos a poner trazas 01:27:45

system.out.println, a ver si llega aquí 01:27:49

a mostrar agenda, jose, fin 01:27:53

no, la actividad ha dicho que sea esa, vamos a decirle fin aquí 01:28:15

bueno, sí que pone mostrar agenda, vale, bueno, lógico 01:28:20

que no haya mostrado nada, sí que llega aquí al mostrar agenda 01:28:24

pero lo que hemos hecho ha sido llamar a infosesión de mi música 01:28:28

efectivamente muy bien, nos ha devuelto con el return 01:28:32

el infosesión, nos ha devuelto un string, correcto 01:28:35

pero luego aquí no hemos hecho nada con ello, entonces es normal que no aparezca 01:28:39

nada por pantalla, ahora con lo que nos devuelve a infosesión 01:28:44

lo vamos a mostrar por pantalla, vamos a ver si está correcto o no, pero 01:29:19

algo ya nos pretenderá mostrar por pantalla, a ver, entonces decimos aquí 01:29:22

José, actividad, música, sesión 1, vamos a poner un fin, bueno y por ahí aparece José, vamos a ver, José, actividad, música, 1, Ana, música, 1, dice que no va diciendo clase reservada de momento, vamos a poner Noa, música, 1, 01:29:27

y dice, no ha sido posible reservar la clase, fijaros, como solamente tenía 01:30:08

dos reservas, intenta hacer una tercera, Sandra, vamos a poner música 01:30:12

dos, clase reservada 01:30:23

todavía me sigue ofreciendo, al final había seguido el criterio de hasta reservar cuatro 01:30:26

vamos a intentar una cuarta, Rubén 01:30:31

vamos a volver a hacer música, y completamos las de música, dos 01:30:34

y no ha terminado, no he debido incrementar 01:30:38

bien el contador. 01:30:45

Vamos a poner aquí un A. 01:30:48

Ah, bueno. 01:30:51

Me ha pedido de nuevo el nombre. Sí que lo había considerado, 01:30:51

pero me ha pedido de nuevo el nombre. Pues esto sería 01:30:53

una cosa a validar. 01:30:55

Fijaros, entonces me dice por aquí José y Ana. 01:30:57

Rubén. 01:31:01

Y aquí 01:31:03

no me ha metido 01:31:03

José, Ana, Rubén. 01:31:04

Sandra. Sandra no me lo ha puesto. 01:31:11

Música 2. 01:31:13

Vale, pues vamos a revisar el código. 01:31:16

en la reserva, infosesión, comprobar 01:31:18

plaza, en la reserva, sesión 2 01:31:23

alumno 2, sospechaba que esto lo iba a haber dejado coincidiendo 01:31:30

con este, pero veo que no, no sé por qué no me ha puesto a Sandra 01:31:38

ahora vemos, vamos a corregir otra de las cosas que nos ha hecho 01:31:42

fijaros que después de 4, se ha quedado ahí 01:31:46

y nos ha vuelto a pedir otro nombre, el A y luego ha terminado, eso es porque 01:31:50

cuando ya he cuargado aquí 4, sigo pidiendo esto. 01:31:54

Pues aquí tendría que poner un if, sí. 01:32:00

Resulta que el número de alumnos ya es 4, que lo acabo de poner aquí. 01:32:04

No me vuelvas a mostrar eso porque ya lo que quiero es terminar. 01:32:09

Ese se resuelve por ahí. 01:32:18

Y vamos a hacer otra ejecución. 01:32:19

Voy a poner de nombres A, B, C y D para ir más rápido. 01:32:27

música 1 01:32:30

ahora no me ha pedido el nombre 01:32:33

claro 01:32:42

vale, no me ha pedido el nombre porque he puesto 01:32:44

esto mal aquí 01:32:47

digo, muéstralo 01:32:48

si es 4 01:32:53

no, pero lo tiene que 01:32:55

mostrar mientras 01:32:57

sea menor de 4 01:32:58

para que lo muestre con 0, con 1, con 2 01:33:03

y con 3 01:33:05

ejecutamos por aquí 01:33:06

música 1 01:33:14

B, música 1 01:33:17

C, música 2 01:33:21

D, música 2 01:33:26

Vale, ahora fue, me ha pasado lo mismo que antes 01:33:30

respecto a guardar la información, vale 01:33:36

pues vamos a ver por aquí, en academia 01:33:39

puede ser en la reserva o puede ser al crear este texto 01:33:44

donde tengamos el problema, en la reserva parece que no 01:33:48

por lo que hemos visto, reservar plaza, guarda el nombre en uno 01:33:51

y guarda en otro, en el que tenemos problemas en 2 al 1 2 01:33:56

parece que está bien, pero al informar, pues tampoco 01:34:00

porque aquí 2 al 1 1, 2 al 1 2 01:34:06

1 al 1 1, 1 al 1 2, no termino de ver 01:34:11

donde tengo el error aquí, ya sesión la 2 01:34:21

sesión uno, alumno dos, sesión uno, alumno uno 01:34:32

ah, vale, sesión dos, alumno uno, sesión dos, alumno dos 01:34:51

ah, vale, bien, el problema está aquí. Fijaros, aquí estoy incrementando 01:35:03

el número de alumnos de la sesión uno y aquí el número de alumnos de la sesión 01:35:12

uno de nuevo. Dos, aquí, sesión dos 01:35:16

copia y pega, tienes dos problemas. Vamos a hacer 01:35:21

la prueba. A, música 01:35:25

1, B, música 01:35:31

1, C, música 01:35:35

2, D, 01:35:40

música 2. Vale, ahí lo tenemos ya. 01:35:44

Ya me lo muestra bien. Vamos a hacer una reserva 01:35:47

para diferentes academias. Por ejemplo, decimos 01:35:52

A, decimos música 2, 01:35:56

B, baile 1 01:36:00

C, inglés 01:36:05

2, y ahora ponemos fin 01:36:09

vale, pues ya termina por aquí, y bueno, no recuerdo exactamente 01:36:12

yo creo que hemos dicho esta distribución, yo creo que lo he hecho bien 01:36:19

el fin parece que también funciona, nos quedan 5 o 10 minutillos 01:36:22

vamos a hacer alguna pequeña corrección por aquí 01:36:33

por ejemplo vamos a validar los datos que vamos metiendo 01:36:36

lo primero que nos pide por aquí es la actividad 01:36:41

música, baile o inglés, pues aquí podríamos hacer una 01:36:45

comprobación con el Nestline hasta que la actividad con toda seguridad 01:36:48

pues sea una de esas, entonces podríamos hacer aquí 01:36:52

while mientras, mientras la 01:36:56

actividad que estamos comprobando 01:37:03

recordad como es un string hay que utilizar el compare to 01:37:07

ponemos aquí música o baile 01:37:10

o inglés, bueno compare to 01:37:25

vamos a poner equals, el problema que me está dando es que compare to 01:37:40

devuelve un número, que no se puede transformar directamente 01:37:43

a un boolean 01:37:46

entonces mientras la actividad sea o música 01:37:48

o baile o inglés, que eso es lo correcto 01:37:52

ese es el caso en el que querría salir de aquí 01:37:55

entonces lo que voy a hacer va a ser todo el conjunto 01:37:58

negarlo, entonces si es 01:38:00

si es música o es baile o es inglés 01:38:06

es true, pero como lo que quiero es que sea 01:38:10

false, lo niego y lo convierto a false, entonces me voy del while 01:38:13

y continúo, y si no es eso 01:38:16

pues lo que diré será un system.out.println 01:38:19

repite la actividad 01:38:24

y digo aquí que sea 01:38:29

música, baile, inglés 01:38:31

y vuelvo a cargar, vuelvo a leer 01:38:41

el nombre de la alumna, vamos a poner una A 01:38:50

indica la actividad, ponemos cualquier cosa por ahí 01:39:00

y se repite, nada, no le gusta 01:39:03

ponemos baile y ya le gusta, ya continúa 01:39:06

vamos a volver a repetir esta validación 01:39:09

ponemos trin trin, no le gusta, inglés 01:39:12

sí, le gusta, ponemos fin 01:39:15

y bueno, nos ha funcionado por ahí. Entonces esto nos sirve para validar 01:39:18

la actividad. Luego podríamos jugar también 01:39:23

a que se meta en mayúsculas o minúsculas. Como estamos trabajando 01:39:26

todo el rato con minúsculas, pues podríamos coger y hacer una esa actividad 01:39:31

que sea igual a ese 01:39:34

actividad.toLowerCase y nos convierta 01:39:38

a minúsculas. Lo ponemos en los dos sitios y ahora ya 01:39:42

si al meterlo ponemos la primera letra en mayúsculas o ponemos 01:39:49

todo el texto en mayúsculas, pues también le vale. 01:39:53

Decimos A, ponemos aquí música. Vale, pues le gustó. 01:39:57

B, ponemos lo que sea por ahí. Y C, esto no me gusta. 01:40:02

Vamos a poner baile, pues también le gusta. Ya con el 01:40:06

to lowercase lo convierte a minúsculas. Para validar 01:40:11

los números, la sesión que tiene que ser 1 o 2, bueno, pues podemos 01:40:22

a hacer lo mismo, fijaros, podemos coger y decir, podemos validarlo 01:40:26

o bien una vez ya siendo un número o todavía validarlo 01:40:33

siendo cadena de caracteres, entonces podemos 01:40:36

coger aquí y decir, while mientras 01:40:41

ese aus equals a 1 01:40:44

o ese aus equals a 2, eso es lo que me gusta 01:40:48

ahora tenemos solo dos opciones, no tres, repite 01:40:52

la sesión, que sería 01:40:56

1 o 2, fuera esto 01:41:00

el tool over case este no tiene sentido, y luego hago aquí el parse 01:41:12

común, le vamos a validar también 01:41:15

el número de la actividad, ponemos aquí 01:41:19

un A, indica la actividad, música, ponemos 01:41:28

aquí cualquier texto, y le dice no, repite 01:41:34

la sesión, ponemos la sesión 9 y tampoco le gusta, decimos la sesión 2 01:41:38

y ahora ya sí le gusta, clase reservada. Vale, pues esa variación 01:41:42

también está ya. Bueno, ya es cuestión de adornar un poco 01:41:49

más los mensajes quizás. 01:42:00

Mirad aquí el mensaje, por ejemplo, para la sesión 1, pues aparece 01:42:04

la sesión 1, si está vacía o si no está. Bueno, pues aquí podríamos 01:42:08

meter un if, es decir, if si tenemos 01:42:12

un número de reservas por sesión, que lo tenemos aquí, 01:42:18

estamos dentro de la sesión 1, entonces decimos, si la sesión 01:42:22

1 es igual a 0, pues quiere decir que no hay reservas. 01:42:25

Entonces, sobre este mensaje 01:42:30

cogeríamos y diríamos, más 01:42:33

no tiene reservas. Esto valdrá 0, valdrá 1, 01:42:47

valdrá 2. Entonces, el shift, si resulta 01:42:55

que hay una reserva, pues lo que le metemos es este bloque 01:43:03

diciendo alumno 1 y else, quiere decir que aquí no había 01:43:15

reservas, aquí se había hecho una sola reserva, pues aquí ya 01:43:29

resulta que tenemos dos reservas. Este es el mensaje que 01:43:32

teníamos de antes. Entonces vamos a hacer una última 01:43:42

ejecución o una nueva ejecución de esto. 01:43:46

No hemos modificado la sesión 2, hemos mantenido lo que había antes. 01:43:52

Bueno, para probar a ver este modelo, este formato de mensaje, hemos 01:43:56

trabajado sobre la sesión 1. Entonces, fijaros, lo que vamos a hacer va a ser 01:44:00

poner A, la actividad de música en la sesión 1, reserva. B, la actividad 01:44:06

de música en la sesión 1, y C en la actividad de baile en la sesión 1, y le damos aquí 01:44:14

un fin. Entonces, en música, que están los dos, pues sale al 1-1, al 1-2-B, en inglés 01:44:23

que no hemos hecho reserva, dice la sesión 1 no tiene reservas, y en baile que hemos 01:44:33

hecho una, en este hemos hecho las dos sesiones, nos aparecen los dos bien, en este que no 01:44:37

hemos hecho reservas dice no tiene reservas y en este como hemos hecho una sola sesión pues 01:44:42

coge y dice reserva alumno 1c y bueno más allá de que nos quede un poquito más bonito el menú 01:44:47

menos pues yo creo que no nos queda mucho más por probar esto fijaros podríamos coger ya que 01:45:01

este código se repite dos veces una y dos pues podríamos coger y decir aquí un private void 01:45:07

menú fijaros para mostrar este menú necesitamos una variable entera que la estamos utilizando 01:45:20

ahí vamos a poner y nun al claro aquí tenemos un pequeño problema que el next line lo tenemos 01:45:27

aquí metido, bueno podemos poner simplemente esto 01:45:39

los mensajes en el menú, entonces llamo aquí a 01:45:42

menú, ahora lo repaso y os lo cuento 01:45:52

bueno, como teníamos el mismo código repetido dos veces y sería mucho 01:46:04

más útil si lo tuviéramos repetido un montón de veces, fijaros que si 01:46:37

queremos hacer un cambio en un código que se repite muchas veces y que además 01:46:40

tiene una funcionalidad bien identificada, como en este caso puede ser mostrar el menú 01:46:44

pues un pequeño cambio, tendríamos que modificarlos 01:46:48

en todas esas partes y si una se nos queda 01:46:51

sin modificar, pues se quedaría 01:46:54

incongruente el menú según fuera 01:46:55

llamado desde un sitio o desde otro 01:46:57

entonces en estos casos, y ya os digo 01:46:59

con una funcionalidad que se identifica 01:47:01

bien, pues puede pegar a hacer 01:47:03

un método 01:47:05

este método, como es 01:47:07

de uso para dentro de la clase agenda 01:47:09

lo podemos definir como private 01:47:11

no devuelve nada y bueno 01:47:13

pues hace este, está imprimido por 01:47:15

pantalla estos tres, estos tres mensajitos que teníamos antes dentro del código. Entonces, si le 01:47:17

damos aquí, fijaros, pues nada, el comportamiento sigue siendo el mismo, pero llamamos al menú de 01:47:23

diferentes sitios. ¿Veis? Y aquí, esta es la llamada al menú desde un sitio y esta es la llamada desde otro, 01:47:29

desde dentro del while y anterior al while. Y nada, pues esto, esta era la tarea 4. Al final he acelerado 01:47:37

un poquillo para poder terminarla, pero bueno, hemos ido despacito intentando contar, haciendo un 01:47:49

repaso a todo lo que es la parte de teoría. 01:47:54

¿Tenéis alguna 01:47:57

pregunta? ¿Alguna prueba que queréis que hagamos al código? 01:47:58

¿O alguna cosa que haya 01:48:01

quedado por ahí pendiente? ¿Qué se os ocurra? 01:48:02

Sí, dime. 01:48:09

¿Un try-catch? 01:48:26

Sí, no sé muy bien 01:48:39

por qué, la verdad. 01:48:40

Te lo pediría. 01:48:42

Luego 01:48:45

echo un ojo de nuevo 01:48:45

a tu tarea, a ver si me hago la idea 01:48:48

de por qué puede ser. 01:48:50

Porque, sí. 01:48:52

sé 01:48:54

sé donde, vale 01:48:58

pues lo echo un ojo y a ver si me hago la idea 01:49:01

y os puedo decir, te puedo decir 01:49:04

bueno, siempre 01:49:06

siempre solemos preguntar 01:49:30

un pequeño algoritmo, no 01:49:32

muy complicado 01:49:34

pero sí, un pequeño algoritmo y claro pues 01:49:35

un poquillo, pero me fijo en las estructuras 01:49:38

de todas formas, es cierto 01:49:40

que no se puede probar, pero 01:49:43

tampoco miramos el código 01:49:44

como si tuviera que compilar, ¿sabes? 01:49:46

hombre, que se vea que es Java, que tiene sentido 01:49:48

pero bueno, pues si se escapa alguna cosilla 01:49:50

nos fijamos más 01:49:53

en la funcionalidad más que 01:49:54

en la sintaxis en ese caso, estricta 01:49:56

claro, yo que sé, pues 01:49:59

los wilds son como son, ¿no? 01:50:00

pero bueno, que si se ha escapado 01:50:02

una llave en algún sitio, pues 01:50:05

no está mal 01:50:06

bueno, pues nada, si no tenéis 01:50:07

más cosas, por aquí vamos cerrando 01:50:17

la semana que viene ya empezamos 01:50:19

a hablar sobre contenidos del 01:50:21

tema 6 y hasta el tema 6 01:50:23

lo tenemos, tenemos el examen 01:50:25

del próximo, luego en febrero 01:50:28

lo del tema 6 01:50:30

en realidad durante este tiempo 01:50:32

lo hemos venido también trabajando 01:50:34

no tiene grandes cosas nuevas 01:50:35

bueno, pues volver a repasar 01:50:38

y volver a hablar sobre 01:50:40

conceptos que tenemos ahí en Java 01:50:41

pero será un poco volver a repetir 01:50:43

con excepción de lo que sí que aparece 01:50:45

nuevo, que son las expresiones regulares 01:50:48

y es por eso que en la siguiente 01:50:49

tutoría, a no ser que me dirijáis 01:50:52

por otro lado, o tengáis especiales 01:50:54

dudas de cosas, pues sí que 01:50:56

trabajaremos un poco las expresiones 01:50:58

regulares la semana que viene 01:51:00

Bueno, pues nada, voy a cerrar por aquí ya la 01:51:01

grabación 01:51:08

2025-01-27-Programacion - Contenido educativo

Del mismo autor…

NAVIDADES EN EL CEIP SANTA TERESA

2ª Sesión T3.- Polinomios 04-12-2025

ANIMALS OF THE JUNGLE

Taller de los sentidos

20 NOVIEMBRE DERECHOS DE LA INFANCIA

Cuarto viaje en el tiempo

Sesión 3 Unidad 2(4-12-25)