[MÚSICA] [AUDIO_EN_BLANCO] Hola. Bienvenidos a este nuevo video. Seguimos adelante con la codificación de los métodos del catálogo de discos. La tarjeta de responsabilidades dice que tenemos un método que se llama muestra activas, y la documentación de Javadoc, que es conveniente hacerla antes de codificar el método, nos dice que el método muestra las transmisiones activas de un disco determinado. Tiene un solo parámetro que se llama cualDisco, y es la posición que ocupa el disco elegido en el catálogo. Nos va a dar como salida una cadena con las transmisiones activas. Como you codificaste el método daCalendario, nos servirá para este caso. El método se llama muestra activas, solo se diferencia del método que muestra los discos en el género. Aquí es activas porque las transmisiones son las. Antes fue activos porque los discos son los. Tiene como parámetro un entero que es la posición que nos dice cuál disco queremos mostrar. Regresa una cadena, y dado que es de los servicios que da el catálogo, es público. No es de la clase porque le estoy dando solo la posición del disco, y tiene que usar el catálogo para hacer su trabajo. Debes verificar que el catálogo exista. Preguntamos si el catálogo es null, o bien, preguntamos si hay discos, o si el disco que me están pidiendo está más allá del tamaño del catálogo. Recuerda que se evalúa en cortocircuito. Si el catálogo es null, you tiene el resultado de toda la condicional. Por lo tanto, you no necesita verificarlo de más. Si cualDisco es menor que cero, quiere decir que estoy dando una posición negativa para el catálogo, y si cualDisco es mayor que el tamaño del catálogo, también si esto o esto es verdadero, you no sigue adelante. Si llega aquí a evaluar esta condición, quiere decir que todas las demás fueron falsas. Entonces, puedo preguntar si el catálogo de cualDisco es igual a null, si existe el disco que me están pidiendo. Si no hubiera checado antes de eso, podía yo haber pedido catálogo de menos cinco, por ejemplo, y hubiera abortado el programa dado un error en el índice. Entonces, si cualquiera de esas condiciones es verdadera, vamos a imprimir un mensaje al usuario en la consola diciendo que el disco no existe en el catálogo, y regresamos nulo para que el sistema se dé cuenta que no tiene que hacer nada con lo que regresó, y terminamos con el if. En una variable que se llamará cuantas de tipo entero, el número de posiciones activas. Como vamos a estar usando este valor después, esto lo hacemos para no tener que estar continuamente llamando. Entonces, le pediremos al disco, que está en la posición, que nos dé cuántas transmisiones tiene activas. Si es menor o igual que cero, vamos a imprimir un mensaje en la consola de que este disco no tiene transmisiones activas. Regresamos nulo y terminamos este if. Si llegamos aquí, quiere decir que cuantas es mayor que cero, que el disco existe, y que todo está bien. Empezaremos a acumular en la cadena qué es lo que quieres escribir. Lo primero que vamos a escribir mostrar el disco que elegiste, y le pides que muestre el disco. Le das como encabezado el letrero de transmisiones activas. Recuerda que dentro de muestraDisco en el Disco, va a haber los cambios de línea adecuados. Como aquí me está alineando esto con esto, vemos que coloqué un punto y coma donde no debía. Lo borramos, agregamos un cambio de línea, recorremos las transmisiones activas para ese disco. Utilizamos un for y una i, después recorremos mientras que la i sea menor que cuantas, y pasamos al siguiente disco en cada iteración. Empezamos con el bloque de esta iteración. Fechas de cuál disco y de i me va a mostrar la fecha de cada transmisión. Agregamos cada una de las transmisiones a la cadena. Primero, verificamos que la fecha sea válida en este disco. Preguntamos si es que fechas en el renglón, cualDisco en la columna i no es igual a null. A cadena le agregamos la transmisión de ese disco. Empezamos por la posición de la transmisión, que es la posición i, y la ponemos entre corchetes. Le agregamos un tabulador, y luego, usamos el método de daCalendario de fechas de cualDisco, y terminamos con un cambio de línea. Si la referencia es nula, entonces, es un else. Lo que haremos es que a cadena le vamos a agregar que la fecha no está registrada, y terminamos el for i. Nuevamente, le agregamos un caracter de fin de línea, y terminamos la cadena. Una vez que recorrimos todas las fechas de ese disco, regresamos la cadena y termina el método. Le colocamos el comentario del método que está terminado. Lo que me dice la tarjeta de responsabilidades es que tengo que tener un método que termina una transmisión. Primero, veremos el comentario de Javadoc. Este método debe terminar una transmisión activa, y la coloca en el histórico de transmisiones para ese disco. Recibe como parámetro primero la posición del disco en el catálogo, cuya transmisión se desea terminar, y un segundo parámetro que es la consola a través de la cual se hace la comunicación. Regresa una variable booleana, que si pudo terminar la transmisión true; o no, false. Este método se llama terminaTrans. Tiene dos parámetros. El primero es un entero que le dice cuál disco, y el segundo es un escáner que es una consola. Regresa una booleana, y es de tipo público. Como sí vas a usar el catálogo, no puedo ser un método de la clase, y es un método de objeto. Empecemos a codificar el método. Otra vez preguntamos si el número de disco que nos están dando es válido. Si cualDisco es menor que cero, porque cero es una posición válida, o bien, cualDisco es mayor o igual que numDiscos. Es decir, la posición es más que el número de discos registrados. O bien, el catálogo en la posición cualDisco no tiene nada. Con esto, estamos verificando que el disco sea válido. Escribimos en la consola aquel disco. Ponemos el valor de cualDisco, y le vamos a agregar no existe, y salimos del método regresando falso. Si llegamos acá, es porque el número de disco es válido. Por lo tanto, lo que tenemos que hacer es preguntar si la consola es válida también. Si la consola es nula, lo que haremos es escribir el mensaje de que no tenemos una consola válida. Nuevamente, regresamos el valor falso porque no hemos podido dar de baja la transmisión o porque la transmisión que nos piden dar de baja no existe. Identificas al disco elegido mostrándolo en la pantalla para que el usuario elija el disco eligiendo la posición de la transmisión que quiere verificar. A este disco, que es la posición cualDisco de catálogo, le pedimos que muestre el disco, y le tenemos que pasar un encabezado que nos diga el número de disco y le ponemos un espacio en blanco. Terminas la llamada de muestraDisco, y también, la de println. Después, vas a escribir cuáles son las transmisiones activas que tienes para que elija el usuario por número. Ahora, vas a usar el método muestra activas de cualDisco. Empiezas una cadena a la que le vas a asignar el resultado de muestra activas de cualDisco. Muestra activa regresa a null si no pudo encontrar ninguna transmisión activa. Por lo tanto, vamos a preguntar si cadena es null, lo que diría que no hay transmisiones activas. Entonces, le damos el mensaje al usuario de que este disco no tiene transmisiones activas, y regresas falso. Terminas el if. Si estamos aquí, quiere decir que cadena tiene algo distinto que null. Vamos a mostrar las transmisiones activas en pantalla que están en cadena. Como vamos a usar el número de transmisiones activas, lo guardamos en una variable de tipo entero que se llama numActivas. Le pedimos al disco que está en la posición cualDisco del catálogo que nos de el número de transmisiones activas. Para pedirle al usuario qué transmisión quiere, vamos a usar el método pideNum que tiene cuatro parámetros. Es un método de la clase, es público. La idea de este método es que le dé al usuario un mensaje de qué tipo de número quiere, y a continuación, le damos el mínimo y máximo número que puede tener. El método regresa a un entero, que es la posición de la transmisión a terminar. El primer parámetro es la consola. El segundo es una cadena, que es el mensaje. El tercer parámetro es un entero que es el mínimo que puede tener el entero, que me dé. Y el cuarto es una cadena que es el máximo que me puede dar. Le pondré que regresa un cero para poder compilar. you teniendo el encabezado, lo puedo usar en el método que estamos construyendo. Vamos a guardar el número de transmisión y le asignamos el valor que regrese pideNum. Lo primero que le tenemos que pasar es la consola que le pasaron a este método. Lo siguiente que le tenemos que pasar es la cadena que queremos y le decimos que elija el número de transmisión a terminar. Le pegamos la cadena a terminar, dejamos un blanco y las posiciones válidas van de cero a numActivas menos uno. Compilamos y me dice que falta el return pero no me preocupa aún eso, por lo demás está bien. El método pideNum va a regresar menos uno si es que no está el número que se le pidió entre el mínimo y el máximo, preguntamos si cualtrans es igual a menos uno. Quiere decir que el número de transmisión es inválido. Lo que haremos es decir que esta transmisión no existe y a continuación regresamos falso. Cerramos el if. Si llegamos acá quiere decir que el número de transmisión es válido. Vamos a obtener la fecha de inicio, la que está guardada, y la fecha de fin es ahorita. Por lo tanto declaras un gregorian calendar que nos dice cuándo empezó la transmisión y asignas ahí el valor que está en fechas de cualDisco, columna cualTrans. Declaras otra variable de tipo gregorian calendar que es fecha fin y le asignas un gregorian calendar construido en este momento. Colocas en el histórico de fechas estas dos fechas, tienes que preguntar dónde. Y donde es precisamente en el arreglo numHist que elegimos, que en el renglón de cualDisco tiene guardada la siguiente posición de histórico para ese disco. Obtenemos esa posición y en histórico de cualDisco escogemos el renglón cero y donde nos dice la siguiente posición a llenar ahí ponemos lo que es inicio. En el mismo arreglo, la misma posición de cualDisco solo que ahora es el renglón uno pero también es la columna donde asignamos el valor de fecha fin. Incrementamos el número de históricos que llevamos hechos para ese disco. Así que lo auto incrementamos con más, más. Avisas al usuario que la transmisión se terminó y le dices a qué hora se termina. Cierras el println. Nota cómo están organizados los valores en el arreglo fechas. Tenemos que eliminar un registro intermedio para que sigan estando consecutivas las fechas y que el número de transmisiones activas me dé cuántas fechas consecutivas hay. Para que sigan estando consecutivas tenemos que recorrer todo lo que está más allá del arreglo un lugar a la izquierda. Después vas a programar un método auxiliar que recorra una celda a la izquierda a los datos. El encabezado de este método es un método de la clase puesto que le vamos a pasar el arreglo. Regresa un valor booleano si es que pudo o no eliminar la celda. Se llama eliminaCelda, recibe como parámetro cosas que son objetos. Los arreglos que son objetos. Un arreglo de una dimensión y un entero que le dice cuál es la que tiene que recorrer. Colocamos return true para que pueda compilar bien. Vamos a usar este encabezado para eliminar la transmisión que queremos eliminar. Si regresa a falso no lo puedo regresar si regresa a verdadero sí lo puedo eliminar. Compilamos y todo bien. Nos falta que los métodos eliminaCelda y pideNum hagan algo. Vamos a programar el método eliminaCelda. Lo que haremos es preguntar si podemos eliminar la celda del renglón que corresponde a cualDisco y pasamos eso como un arreglo y una dimensión. Le decimos cuál transmisión es la que queremos eliminar. Lo que queremos es decrementar el número de transmisiones activas del disco. Al disco que está en la posición cualDisco le pedimos que termine su transmisión. Esta es una llamada método por lo tanto le ponemos sus paréntesis. Eso hará que activas de ese disco se decremente en uno por lo que you no tenemos que hacer nada más. Borramos esto porque es un solo enunciado y no necesitamos las llaves. Si eso no fue cierto quiere decir que eliminas celda regreso falso, salimos del método regresando falso. Si no ha salido por ningún lado el método quiere decir que todo lo pudo hacer bien y regresa a verdadero como final del método. Vamos ahora a codificar el método elimina celda para que no esté vacío. Antes de empezar a codificar el método vamos a dar una descripción de Java doc de lo que tiene que hacer el método. El método elimina la celda solicitada si es que esta existe en el arreglo pasado como parámetro. Este arreglo tiene que ser de una dimensión. Después de llamar a este método desde algún otro se tienen que hacer los decrementos necesarios al arreglo involucrado. El método tiene dos parámetros. El primero es un arreglo de una dimensión del que se va a eliminar la celda recorriendo las que se encuentran a su derecha. El segundo es cual el índice del elemento que se desea eliminar. Regresa como valor si pudo, en cuyo caso true o si no pudo false hacer la eliminación. Terminamos el comentario. Vamos a entrar al método. Lo primero que tenemos que hacer es preguntar si la referencia que nos están pasando para el arreglo es válida. Si es nula la referencia no es válida y lo que hacemos es mandar un mensaje. Escribimos a la pantalla que el arreglo que nos están pasando no existe y regresamos falso puesto que no pudimos hacer ninguna eliminación. Termina aquí el if. Si llegamos aquí quiere decir que el arreglo no es nulo. Entonces verificamos si la posición del arreglo es válida. Preguntamos si el valor que nos estén dando es menor que cero o bien cual es mayor o igual que el tamaño del arreglo. Si cualquiera de estas dos cosas sucede nuevamente escribimos un mensaje al usuario diciéndole que la posición a eliminar no existe y como no pudimos eliminar regresamos falso. Si llegamos aquí quiere decir que la posición y el arreglo son válidos. Procedemos a recorrer a la izquierda todos los métodos. Empezamos en el siguiente al método y lo movemos a su posición anterior. Haremos una iteración Recorremos el arreglo con una i que va a empezar en cual más uno. Si la posición está al final del arreglo no va a cumplir que la i sea menor que el tamaño del arreglo. Vamos a seguir dentro de la iteración mientras que la posición sea menor que arreglo punto length. Y además la posición en el arreglo que estamos viendo sea distinta de null. Lo que queremos hacer es que en cuento nos encontremos un registro que es null como estamos suponiendo que son distintos de null que están consecutivas todas las posiciones válidas también vamos a parar en cuanto encontremos el primero igual a null o cuando terminemos con el arreglo. La actualización de cada iteración consiste del auto-incremento. Como empezamos una i más uno lo que tenemos que hacer es arreglo de i menos uno que es precisamente cual. La primera vez que entramos es igual a arreglo de i que es el siguiente elemento en el arreglo. Sabemos que i vale al menos uno. Pues suponiendo que es la posición cero le estamos sumando uno al valor inicial de la iteración. Al siguiente you lo copiamos para que el último quede valiendo null y termine el foro. Regresamos true y termina el método elimina celda. Compilamos y nos marca caracteres ilegales. Repetimos la línea para saber cuáles no aceptó. Compilamos y nos marca error en fechas, es que era con minúsculas. Compilamos y nos marca todo bien. Nos vemos en el siguiente video en el cual veremos el método que muestra el. [MÚSICA] [MÚSICA] [MÚSICA]