Hola, bienvenidos a este nuevo video. Lo que toca ahora es codificar el resto de los métodos que declaraste en tu tarjeta de responsabilidades. Como nos marca aquí que el catálogo no está guardado, antes de hacerlo vamos a compilar y ver que, en efecto, todo lo que llevamos está bien. Y listo, cerramos "Disco.java". Comenzamos a codificar el resto de los métodos. Lo primero que haremos son los métodos de acceso que me dan acceso a todos los atributos privados de la clase. Entonces, vamos a ver cuáles son los atributos privados, y los tenemos extendidos por muchas líneas, pero están a partir de la línea 46. Nuestros atributos son el catálogo, el número de discos, las fechas de inicio de transmisiones, el histórico de transmisiones y el número de histórico. Al final de lo que llevamos programado, vamos a dar un método de acceso para cada uno de nuestros atributos. Hay que hacer un método "get" para cada uno de ellos. En la tarjeta de responsabilidades, esta vez no pusimos los métodos de acceso. Sabes que tienen que regresar algo del mismo tipo que el atributo, no tienen parámetros y, simplemente, tienen un "return" con el nombre del atributo. Empezamos con el primer atributo que es catálogo. El método se llama "getCatalogo", no tiene parámetros, es de acceso público y regresa lo mismo que tiene el catálogo, y el catálogo tiene un arreglo de una dimensión de discos. El cuerpo del método nos dice que debemos regresar simplemente el catálogo. Y cerramos la llave. Por supuesto que le tenemos que poner toda su documentación de Javadoc, "regresa el catálogo de discos", incluyendo aquellas posiciones que no tienen discos, "regresa un arreglo con el catálogo de discos", y cerramos el comentario de Javadoc. El siguiente método que tenemos que hacer es el que da acceso al número de discos. Como número de discos se llama "numDiscos", el método se llama "getNumDiscos". Lo que tiene en el cuerpo de su método es, simplemente, que regresa "numDiscos". Terminamos el método con la llave que lo cierra. Otra vez su comentario de Javadoc que es lo que ya describimos, "regresa el número de discos registrados en el catálogo de discos". Por lo tanto, la etiqueta "return" nos dice, precisamente, que es el número de discos registrados en el catálogo. Recuerden que todos los comentarios de Javadoc deben terminar con un punto. Terminamos el comentario de Javadoc y tenemos ya el método. El siguiente método "getFechas" que es, justamente, el que nos regresa las fechas. Vamos a escribir su comentario de Javadoc, "regresa a un arreglo de dos dimensiones" donde en cada dimensión registra las fechas de inicio para cada transmisión de un disco dado, terminamos con un punto. Como todo método, "return" tiene su etiqueta donde ponemos que regresa el arreglo con las fechas de préstamo para cada disco. Terminamos el comentario de Javadoc y continuamos. El método es de acceso público, va a regresar un arreglo de dos dimensiones, el arreglo es de tipo "GregorianCalendar", se llama "get" y, como lo que va a regresar es el arreglo "fechas", le ponemos "getFechas". No tiene ningún parámetro y, simplemente, regresa el arreglo "fechas". Terminamos con un punto y coma y cerramos el bloque de este método. Programas ahora el método que se refiere al histórico, este método debe regresar el arreglo histórico de transmisiones iniciadas y terminadas para cada disco. Hay una pareja de renglones con fechas de inicio y terminación para cada disco, por lo que el arreglo es de tres dimensiones. Regresa el arreglo que dijimos, por lo tanto, tiene una etiqueta "return", y lo que regresa es el histórico de todos los discos. Terminamos el comentario de Javadoc y programamos el método, es de acceso público, es un arreglo de tres dimensiones, cada dimensión tiene fechas, por lo que el tipo del arreglo es "GregorianCalendar". Se llama "getHistórico" ya que el arreglo se llama "histórico", no tiene parámetros y todo lo que tiene en su bloque es que regresa el arreglo histórico. Terminamos con este método. Por último, haremos el atributo "numHistóricos", haremos primero el comentario para Javadoc, "regresa el arreglo que contiene para cada disco", "el número de registros en el arreglo histórico". Como es un método de acceso, tiene la etiqueta "return" y lo que regresa es el número de registros en "histórico". Terminamos el comentario y seguimos. El método es de acceso público, regresa un arreglo de una sola dimensión, el tipo del arreglo es entero ya que guarda números, se llama "getNumHist" porque así se llama el atributo, no tiene parámetros y lo que hace es, simplemente, regresar el arreglo "numHist". Con esto terminamos ya los métodos de acceso que tenemos. Ya tenemos un método por cada atributo, entonces, vamos a pasar ahora a los métodos de actualización. Esto es un poquito complicado porque yo no puedo cambiar el tamaño de uno de los arreglos sin considerar el tamaño de los otros. En realidad, el único atributo que puedes actualizar es el arreglo que corresponde al catálogo y, de esa forma, reiniciar todo el resto de los arreglos. Dependiendo de cómo quede ese arreglo, procedes a sincronizar los otros arreglos. Siguiendo las reglas que tienes para los métodos de actualización, tienes el siguiente encabezado, el método es público, no regresa nada, se llama "setCatálogo" y lo que tiene que recibir es un arreglo del mismo tipo del arreglo que tiene el catálogo, que es de tipo Disco y es de una sola dimensión, y le vamos a poner como nombre "nuevos". Termina con esto los parámetros y vamos ahora a iniciar el bloque del método. Si se establece un catálogo nuevo, se deben eliminar todas las referencias que existan a elementos anteriores del catálogo. Esto es similar a la construcción de un catálogo nuevo, excepto que no te dan el tamaño total. Este tamaño se obtiene del argumento que uses al invocar este método. Tienes dos diferencias importantes respecto al tercer constructor. La primera, es que todos los arreglos en el objeto existen, por lo que tienes alguna referencia válida a ellos. Y, la segunda, es que el arreglo que viene como parámetro te da el tamaño total, pero no sabes cuántos discos trae ya construidos. Lo primero que hay que hacer, es establecer el nuevo catálogo en el mismo atributo que ya tienes. El algoritmo para establecer nuevos valores a los atributos del objeto es el siguiente, calculas el tamaño del nuevo catálogo, aunque si la referencia a "nuevos" es nula, el tamaño es cero. Por lo tanto, declaras una variable local, "cuantos", que va a ser igual si "nuevos" es una referencia nula, entonces el tamaño va a ser cero. De otra manera, el tamaño va a ser el tamaño que traiga "nuevos.length". Acuérdate que es un atributo, no un método. Ahora, si "cuantos" es "cero", entonces vamos a borrar simplemente todo lo que tenemos. Por lo tanto, si "cuantos" quedó calculado en "cero", quiere decir que borramos todos los atributos, lo cual nos va a representar varios problemas. Hacemos el catálogo igual a "null", hacemos "fechas" igual a "null", hacemos el "histórico" igual a "null" para indicar que no tenemos absolutamente nada en todo el sistema. En "numDiscos", como es un entero, lo hacemos igual a "cero", y "numHist" también, como es un arreglo, lo hacemos igual a "null". Volvamos a la línea 196 para corregir "catálogo" ya que pusimos que tiene valor "cero" y, en realidad, es igual. Listo, volvamos adonde estábamos. Pero, también deseamos salir del método entonces, la manera como salimos es con un "return". Como el método no regresa nada, no necesito poner una expresión, esto es en el caso de que no tenga yo ningún arreglo en el disco. Entonces, aquí ponemos si es que "nuevos" es "null". Sigues en el método si la referencia no es nula, puesto que no se va a ejecutar ese bloque que acabamos de hacer. Si la referencia no fue nula, tenemos que reconstruir todos los arreglos al tamaño de "nuevos". Por lo tanto, llegas acá si la referencia no es "null" y procedemos a reconstruir los arreglos. Entonces, el primer arreglo que queremos la reinicializar es el catálogo y le damos el mismo tamaño que tiene "nuevos" y que guardamos en "cuantos", ya sabemos que no es "cero". En el caso del arreglo "fechas" lo mismo, lo que podemos hacer es construirlo del mismo tamaño que "catálogo". En este caso, el tipo del arreglo es de "GregorianCalendar", es de dos dimensiones pero, en la primera dimensión, sabemos ya perfectamente que es también de tamaño "cuantos". El tercer arreglo que tenemos que reinicializar es el arreglo "histórico", que se va a construir también nuevo. El contenido es "GregorianCalendar", es de tres dimensiones, la primera dimensión tiene tamaño "cuantos", la segunda dimensión tiene tamaño "dos" y la tercera dimensión no sabemos, porque depende de cada disco. Después, volvemos a inicializar el que tiene el número de "históricos" que es un "int" y lo inicializamos, también, con tamaño de "cuantos". A continuación, tenemos que inicializar el contador de discos, pero queremos copiar los discos que están vivos. Entonces, quieres copiar los discos que están vivos y, en este momento, el catálogo tiene todas sus referencias en "null". Iniciamos "numDiscos" en "cero" y vamos a hacer un "for" para copiar los elementos del arreglo "Disco". Entonces, para cada elemento, el "for" va a ir contando los elementos de "nuevos" con una "i" desde "cero". Va a copiar los discos mientras la "i" sea menor que "cuantos" y va a incrementarse la "i" en cada vuelta. Veamos ahora qué contiene el bloque del "if". Lo primero que tenemos que verificar es que el i-ésimo disco exista. Entonces, preguntamos si "nuevos" de "i" es igual a "null", quiere decir que el disco no existe. Lo que vamos a hacer es, simplemente, salimos de la iteración y regresamos al encabezado del "for". Si estamos aquí, quiere decir que sí existe el i-ésimo disco, por lo tanto, lo tenemos que copiar a "catálogo". Entonces, "catálogo" en la dirección registrada en "numDiscos" es igual al i-ésimo disco que está en la posición de "nuevos". Como es distinto de "null", podemos obtener el número de permitidas, declaramos una variable "numPerm" que es igual a "nuevos" de "i" punto "getPermitidas". Como ya tenemos el número de permitidas en el disco, podemos inicializar la segunda dimensión de "fechas" y la tercera dimensión de "históricos". Entonces, le ponemos al disco que estamos registrando ahorita que no tiene ninguna transmisión activa. Si la tenía es muy difícil saberlo porque estamos reconstruyendo, también, los arreglos de fechas y de histórico. Queremos, mejor, empezar con discos libres. Construye los renglones para el arreglo "fechas". Entonces "fechas" de la posición "numDiscos", que es un renglón, es igual a "new" de "GregorianCalendar", y el número de posiciones que tiene "fechas" es, precisamente, el número de transmisiones permitidas. Para el histórico, tenemos que reconstruir los dos renglones, "histórico" de "numDiscos" en la posición "cero" es igual a "new". También se trata de fechas, por lo tanto también tiene "GregorianCalendar", y el número de posiciones que le ponemos es dos veces el número de permitidas. A continuación, vamos a hacer el segundo renglón de "histórico". Este segundo renglón de "histórico" en la posición "Discos" y el renglón "uno" también es igual, y vamos a copiar porque es exactamente lo mismo que acá arriba. Copiamos hasta el final de la línea y lo pegamos. Ya quedaron nuestros arreglos. Finalmente, como ya registramos un disco, incrementamos el contador de discos con el auto incremento. Con esto terminamos el "for" y con esto terminamos "setCatalogo". Pongamos el comentario de Javadoc para este método porque es público, entonces decimos lo que hace. Copia el catálogo en el parámetro, si no es una referencia nula ésta es la descripción breve. Vamos, también, a hacer una descripción más extensa. Si "nuevos" es una referencia nula, borramos todos los arreglos asociados. Para cada disco que existe en el catálogo, se inicializan los arreglos asociados y se anota cuántos discos hay. No se copia en las referencias nulas, ni se cuentan para que no haya huecos en el arreglo, ya que estamos considerando que todos los discos vienen uno después del otro. Vienen con un parámetro, por lo que tenemos la etiqueta de "param" que se llama "nuevos" y que es el arreglo con el que se va a inicializar el catálogo y todos los arreglos asociados. Termina el comentario de Javadoc y ya tenemos programado el método. Regresas a la tarjeta de responsabilidades, puesto que ya no vamos a hacer más métodos de consulta porque ningún atributo puede ser modificado de manera aislada del catálogo, y tienes la descripción del método que agrega un disco al catálogo que dice que recibe como entrada un disco, regresa como salida un "booleano" de si pudo, o no, agregar el disco. Puede ya no haber lugar en el catálogo de discos y se llama "addCatalogo". En la documentación de Javadoc escribes lo siguiente, "Este método va a agregar un disco al catálogo si es que hay lugar", "recibe como parámetro un disco que es nuevo y que es el disco a agregar", y "regresa como valor "falso" si el disco es nulo o no hay lugar y "verdadero" si se pudo agregar". Entonces, el método es de acceso público, regresa una "booleana", se llama "addCatalogo", tiene como entrada un disco que se llama "nuevo" y está implementado de la siguiente manera. Primero, verificas que puedes agregar un disco, o sea, que haya lugar y que el disco exista. Primero verifica si "nuevo" es igual a "null", no vaya a ser que trates de sacar algo de un disco que no existe, o bien, "numDiscos" es mayor o igual que el tamaño del catálogo, o sea, ya tengo tantos discos como puede aceptar el catálogo. Entonces, como dijimos en la documentación, vamos a regresar "falso". Es decir, que no agrego nada al catálogo, y no necesito la llave puesto que tengo un solo enunciado. En el comentario, llegamos acá si "nuevo" existe y hay lugar. Lo primero que haces es registrar el disco en el catálogo, la posición en la que está "numDiscos". Simplemente, copias el disco nuevo, obtienes el número de transmisiones permitidas para el disco, otra vez declaras una variable "numPerm" y le pides al disco nuevo que te dé el número de transmisiones permitidas. Una vez que tienes eso, podemos copiar el método anterior y pegamos aquí. La indentación es un poco distinta, entonces lo alineamos todo como debe estar. Por último, incrementamos el número de discos. Finalmente, sales del método regresando "true" porque sí pudiste dar de alta el disco y lo cierras, le ponemos que es el final de "addCatalogo". Veamos ahora el método que da la transmisión de un disco. Vamos a escribir el comentario de Javadoc de acuerdo a lo que dice la tarjeta de responsabilidades. Nos dice que registra la transmisión del disco elegido a una cierta hora, avisa si pudo o no dar la transmisión, dice que tiene como entrada la posición del disco, esto es un entero. Entonces, registramos una etiqueta "param" que se va a llamar "cualDisco" y que indica la posición en el catálogo del disco. También el comentario nos indica que regresa verdadero o falso, dependiendo si pudo o no dar la transmisión. Terminamos ya la documentación de Javadoc y empezamos con la codificación del método. El método es público, regresa un valor "booleano", sí o no, se llama "daTransmision" y tiene como parámetro un entero que me dice de cuál disco es del que voy a dar una transmisión. Lo primero que hay que hacer, nuevamente, es verificar que la posición que me dieron del disco es válida. Entonces, pregunto si "cualDisco" es mayor o igual que "numDiscos", quiere decir que el disco no existe en el catálogo, o bien "cualDisco" es menor que "cero", en cuyo caso me están dando un número del todo inválido. Si esto es así, no puedo dar de alta la transmisión y regreso "falso". Después verificas que la referencia en esa posición no sea nula. Por lo tanto, preguntamos, si catálogo de "cualDisco" es nula, vamos a salir del método regresando "falso". También debes verificar que el disco en esa posición tenga transmisiones disponibles. Entonces, vamos a declarar "numDato" que va a ser igual a "catalogo" de "cualDisco", y le pedimos que nos dé su número de transmisiones activas. Ese número es, también, la posición en la que vas a registrar esta transmisión, funciona igual que "numDiscos". Recuerda que todo este proceso va a ser interactuando con un usuario que te va a pedir, desde la terminal, las distintas opciones. Verificas que haya transmisiones disponibles para que, si no las hay, avises al usuario y salgas del método. Por lo tanto, preguntas si "numDato" que obtuviste es mayor o igual que el número de transmisiones disponibles en la posición en la que estamos, que está dada por "cualDisco", y le pedimos a ese disco que nos dé sus transmisiones permitidas. Si "numDato", que es "Activas", es mayor o igual que el número de permitidas, le vamos a escribir al usuario un mensaje que le deje saber que ya no hay transmisiones. Al disco queremos pegarle el nombre, entonces sacamos el disco de la posición solicitada, sacamos el nombre, y le pegamos también el mensaje de que "ya no tiene transmisiones disponibles", cerramos las comillas y cerramos el "printline". Y, como queremos más de un enunciado porque nos falta todavía salir del método, abrimos un bloque e, inmediatamente, después del mensaje regresamos "falso" y cerramos el bloque del "if". Si llegamos a este punto, quiere decir que sí podemos dar de alta el disco. Por lo tanto, si no has salido del método, puedes dar una transmisión de ese disco. Para ello, obtienes la hora y fecha en que se está dando la transmisión. Entonces, en una variable de tipo "GregorianCalendar" que se llama "ahora" vas a construir un "new GregorianCalendar" sin parámetros lo cual, como ya vimos antes, te da el momento en el que están realizando esa asignación. A continuación, en "fechas" en la posición paralela al catálogo, que es "cualDisco", y en la posición "numDato" que es, precisamente, el de "Activas", vas a poner el "GregorianCalendar" que acabas de construir. Le pides al disco que está en la posición "cualDisco" que te dé una transmisión con el nuevo método que agregamos al catálogo, o sea, que le pasamos como argumento precisamente "ahora". Y, lo que haces es que, como este método te regresa una cadena, puedes imprimirla de esta forma, "System.out.println", cerramos el "printline" y cerramos el método. Finalmente, avisas, regresas el valor de verdadero de que pudiste dar la transmisión y termina el método "daTransmision". Vamos a compilar para ver que todo vaya bien. Marca un error en la línea 230, nos dice que está escondido un carácter ilegal. Entonces, lo que vamos a hacer es repetir con cuidado el enunciado "histórico". Compilamos y tenemos ahora un error en la línea 249 que es lo que acabamos de escribir. Revisamos nuevamente y volvemos a escribir, y ahora sí se corrige el error. En el siguiente video continuaremos con los siguientes métodos de esta clase. Te espero.