[MÚSICA] Hola. Bienvenido a este nuevo video. Para ver iteraciones, vamos a hacerlo en un archivo separado para ilustrar algunas de ellas. Por lo tanto, vamos a abrir un nuevo archivo. A este archivo no le vamos a poner mayor comentario, porque es simplemente prueba de iteraciones. Entonces, no vamos a perder el tiempo con la documentación de Javadoc, no lo vamos a usar en ningún otro archivo. Lo vamos a hacer en una clase. Vamos a declarar una clase pública y que se llame simplemente como la lección en la que estamos, módulo 3, lección 2. Abrimos sus llaves y vamos a empezar por declarar un método que va a calcular los primeros n múltiplos de 3. El método lo hacemos público. Lo vamos a hacer de la clase para poderlo probar sin necesidad de construir objetos. No regresa nada, simplemente va a imprimir y se llama múltiplo de 3, mult3. Y tiene como parámetro un entero que es n, que me va a decir los primeros n múltiplos que queremos. Llamamos a n el parámetro formal de este método. Lo que va a hacer este método es simplemente va a hacer un for. Va a empezar declarando una variable i y le va a dar un valor inicial de 1. Esta es la inicialización del for. Lo siguiente que vamos a hacer es dar la expresión booleana, entonces vamos a hacer, mientras i sea menor o igual a n, el igual es para que incluya a n. Este es un comentario. Esto es la expresión booleana del for, que el for se va a ejecutar mientras sea cierta. Por último, tenemos qué va a hacer al final de cada ejecución del bloque. Lo que va a hacer es simplemente autoincrementar a la i. Con eso cerramos el encabezado del for. Y lo que vamos a hacer aquí es colocar el comentario de que esta es la actualización. Con esto vamos a hacer un solo enunciado, que es que escriba en la consola el valor de i multiplicado por 3. Pero además, le vamos a poner una cadena que es simplemente un tabulador para que separe los números que estamos imprimiendo. Cerramos el print. Y hay que notar que no estamos imprimiendo un cambio de línea porque estamos usando print. Para eso es el tabulador. Así todos los múltiplos quedarán en la misma línea. Al terminar con el for, cuyo cuerpo es simplemente un renglón, vamos a poner en comentario que este es simplemente el bloque del for. Entonces, al terminar, noten cómo está alineado con el for, porque no está dentro del for. Lo que vamos a hacer aquí es simplemente escribir un cambio de línea dándole al println una lista vacía. Una vez hecho esto, termina el método y solito lo alínea con el principio del método. Queremos probar nuestro método. Por lo tanto, vamos a escribir un método main, cuyo encabezado es public, static, void, main. Y tiene como parámetros un arreglo de cadenas que generalmente se les denomina args. Algunas personas les llaman entradas. Lo importante es usar el mismo nombre adentro de main si se usa. Y nosotros no lo estamos usando adentro. Entonces, lo que queremos hacer aquí es llamar a la función mult3. Como es una función estática, vamos a poner System.out .println y escribimos un encabezado para esta función. Ejecución de mult3. Después vamos a llamar a mult3 y lo llamamos, por ejemplo, con el valor 5. Terminamos main y terminamos la clase. Podemos guardar el archivo. Lo vamos a guardar otra vez. Nos da el nombre de la clase, nos parece bien. Cerramos el catálogo, porque si tratamos de compilar mod3, lección 2, va a tratar de compilar catálogo también y eso va a hacer que nos dé errores, porque lo estamos dejando incompleto. Entonces, lo que vamos a hacer es cerrar este archivo para que quede únicamente mod3, lección 2. Y ahora sí. Compilamos. Solo compilé el archivo que tiene cargado. Nos dice que la compilación está terminada y no hubo errores. Por lo tanto, ahora ejecutamos y vemos cómo nos da los primeros cinco múltiplos de tres, 3x1, 3x2, 3x4 y 3x5. Vamos a declarar ahora otro método mult3, pero que escriba cada múltiplo en su línea separada. Entonces, otra vez es un método público, static tampoco regresa nada. Se llama mult3B y también recibe como parámetro un entero n. Vamos a copiar el contenido del método mult3. Y nos movemos a continuación de la llave y lo copiamos. Nos movemos a continuación de la llave y pegamos. Lo único que queremos realmente modificar aquí es que en lugar de escribir en la misma línea, lo escriba en línea distinta. Sigue teniendo un enunciado en el bloque y you no necesitamos que escriba una línea separada, pero de todos modos lo vamos a hacer. En main, vamos a agregar que ahora nos escriba System.out .println y que avise que ahora se trata de la ejecución de mult3B. Y a continuación invocamos a mult3B con el mismo argumento, 5, para que veamos la diferencia. Nuevamente compilamos. Y le pedimos que ejecute. Vamos a ver cómo se ejecutó. Agrandamos la pantalla de la salida y vemos que mult3 puso todo en la misma línea, mientras que 3B hizo exactamente lo mismo, pero los puso en su propia línea. Regresamos a ver nuestra pantalla de nuestro programa. Si la declaración de la variable i la hiciéramos afuera del método, vamos a intentar a ver qué pasa en otro método que hace exactamente lo mismo, pero que trata de declarar. Escribimos public, static, void, mult3, que tiene un parámetro formal n. Y nuevamente vamos a copiar el método, porque lo que queremos es hacerle cambios leves. Entonces copiamos aquí. Lo volvemos a copiar al final de la línea. Queremos aquí declarar una i que esté afuera. Y declararla con un valor inicial de cero. Entonces, vamos a ver qué pasa si tratamos de compilar. En realidad, esta i de acá debería de ser distinta a esta i de acá, porque está dentro del bloque del for, pero lo que me dice es que la variable i you está definida en el método. Por lo tanto, podríamos eliminar int y no declararla en el for. Entonces, you compila perfectamente. Este valor de cero se sustituye por el de uno. Agregamos. I quedó con el valor y luego le pego la i, entonces compilamos. Otra vez vamos a copiar para no tener que escribir todo otra vez. Copiamos y la ejecución de la que estamos hablando es de mult3C. Y aquí invocamos a mult3C. Entonces vamos a compilar nuevamente y ejecutamos. Otra vez vamos a extender la pantalla de la ejecución. Entonces, aquí en la ejecución de mult3C me dice que la i quedó con el valor 6, porque 6 es el que hace que la i you no sea menor o igual que el argumento que le pasamos, que era 5. Cualquiera de los tres componentes de un for puede encontrarse fuera del encabezado del for. La inicialización se puede hacer antes del for. Podríamos aquí tener vacío el primer componente del for. Si la expresión condicional no aparece, entonces la condición es por omisión verdadera, true, lo que haría que el bloque se ejecutara por siempre. En este caso, la única forma de salir de la iteración sería mediante un enunciado condicional dentro del bloque que sacara la ejecución de la iteración. La actualización se puede colocar al final o principio del bloque del for en lugar de ponerla en el encabezado y tener una actualización vacía. Veamos un ejemplo donde se mueva a la inicialización y a la actualización fuera del encabezado del for. Entonces vamos a copiar aquí. Declaramos nuevamente. Marcamos todo el método mult3C desde arriba hasta donde se termine. Y lo copiamos. Marcamos todo el método public, static, mult3C desde el renglón anterior hasta donde termina. Lo copiamos y lo colocamos inmediatamente debajo de mult3C. Le cambiamos el encabezado a que sea mult3D. Si hacemos aquí la inicialización, pondríamos 1. Entonces, la inicialización está vacía. La condicional la vamos a dejar como estaba, pero vamos a dejar vacía la actualización. Noten que los puntos y comas de todos modos deben aparecer. Pero ahora, you se trata de un for que tiene un bloque más grande. Porque además de escribir lo que tiene que hacer, ahora es hacer la actualización de la i, entonces, aquí ponemos al final i++. Si lo pusiéramos al principio, empezaría a calcular en 2. Cerramos el bloque. Pero antes, vamos a reorganizar esto. Como se trata de un bloque, debe estar más anidado y cerramos el bloque del for. Esto de acá se ejecuta al final y se cierra el bloque del método. Esto debería estar lineado a la izquierda. Se está haciendo bolas por los puntos y coma. Ahora vamos a compilar. En efecto, compiló bien. Y vamos a agregar la ejecución de mult3D, y vamos a ver que hace exactamente lo mismo, nada más que cambiamos el encabezado para que sepamos quién se está ejecutando y cambiamos la invocación. Compilamos, corremos y vamos a ver la ejecución completa. Como pueden ver, mult3D hizo exactamente lo mismo que mult3C, a pesar de que el for no era exactamente el mismo. Regresamos a nuestro código. Si tenemos una expresión vacía, si aquí no pusiéramos ninguna expresión booleana por ejemplo, el método se ejecutaría por siempre. No hay ninguna razón para que el método dejara de ejecutarse. Se puede salir del bloque si hay algún enunciado condicional que tenga un break para salir de la iteración, o un return que también me hace salir del método. ¿Por qué digo un enunciado condicional? Porque si le pongo un break así nada más, la primera vez que entre, esa primera vez va a salir. Podemos tener un encabezado de un for que no tenga ninguno de los tres componentes, en este caso, el bloque de la iteración se repite indefinidamente y su ejecución dependerá de en qué consiste el bloque. Veamos antes otro ejemplo de iteraciones recorriendo un arreglo. Tienes un arreglo de números reales de dos dimensiones. En el primer renglón se encuentran las calificaciones. En el segundo renglón, los porcentajes que cada calificación aporta al promedio. Podemos verlo así. Vamos a borrar todo el contenido del método main para que no nos esté molestando, y vamos a declarar aquí, dentro de main, ese arreglo del que estamos hablando. Queremos un método que saque el promedio. Nuevamente lo vamos a declarar como estático, pero esta vez si nos regresa un Double, se llama promedio, y tiene como parámetro un arreglo de Double de dos dimensiones. Como dijimos antes, ese arreglo se llama num. Veamos en qué consiste el método. Tenemos que tener un acumulador que me diga de cuánto queda el promedio. Entonces, vamos a declarar un Double prom, y como vamos a ir acumulando ahí los valores que tenemos, lo tenemos que inicializar en cero. También tenemos un entero k, que me va a permitir recorrer el arreglo. Declaramos una variable que me dé el número de columnas o tamaño del primer renglón, para no tenerlo que invocar en cada vuelta del for, y este consiste del tamaño del primer renglón del arreglo. Vamos a hacer un for para recorrer el arreglo, y vamos a hacer la inicialización poniendo prom igual a cero. Luego, una coma, y k, la vamos a inicializar también en cero, porque las columnas empezarán en cero. Lo que queremos es que se ejecute el for mientras k sea menor que el tamaño que calculamos. Es aquí donde decía que como la expresión booleana se evalúa en cada vuelta, no quería en cada vuelta estar sacando el tamaño del arreglo. Y la actualización consiste en autoincrementar a la variable k. Veamos en qué consiste el for. Lo que queremos es que en cada vuelta con el valor de k, queremos multiplicar lo que está en el primer renglón del arreglo con lo que está en la k ésima columna del arreglo por su peso en la calificación. Entonces, es lo que está en el segundo renglón del arreglo, por lo que está en la misma columna. Queremos que eso quede guardado en lo que tenía prom, más, igual ese número que estamos calculando. Y es lo único que vamos a hacer en el for. Como tenemos que regresar ese promedio, lo que hacemos después del for es return prom y termina el método. Podríamos haber hecho todo en la parte de actualización porque podríamos poner esta expresión antes de que se ejecute, y poner aquí una coma igual que en el caso de la vez pasada. Y luego tener un enunciado vacío. Borramos por supuesto esto, y vemos que el método lo terminamos. Aquí me está poniendo la llave que cierra a la izquierda, por lo tanto, me falta quitar esta llave que cierra que puse por error. Y ahora sí, la llave se alinea con public, static, void. Entonces, si aquí en main declaramos un arreglo anónimo que se crea el vuelo, decimos, new double, decimos que es de dos dimensiones, e inmediatamente abrimos la llave que tiene a las dimensiones como you vimos antes. Entonces, vamos a poner aquí el primer renglón que consiste en las calificaciones. 8.75, 10, 4.25, 6.67, 8.3. Terminamos el primer renglón. Escribimos el segundo renglón que tiene que tener el mismo número de elementos. El primer elemento vale 25%, el segundo elemento vale 15%, el tercer elemento vale 30%, el cuarto elemento vale 20%, y el quinto elemento vale 10%. Cerramos este renglón y colocamos sus respectivos comentarios, calificaciones y estos son los porcentajes. Cerramos el arreglo. Ahora, como dije antes, este va a ser un arreglo que se va a construir en el momento de llamar al método. Podemos llamar al método como System.out.println, y decimos que queremos el promedio de este arreglo. Cerramos el paréntesis de la llamada a promedio y el último paréntesis de System.out. Y ponemos el punto y coma. Aquí cierra el método main. Vamos a compilar para ver si está todo bien. Al compilar se guarda el archivo y me marca algunos errores. Olvidamos colocar una llave al inicio de los porcentajes. La agregamos, compilamos de nuevo, y hay un error más que me está avisando que modifiqué este método, y se va a ejecutar para siempre, por lo tanto, nunca va a salir. Entonces, le regresamos la condición para que no se ejecute toda la vida. Compilamos, y listo. Te espero en el siguiente video. No te lo puedes perder. [MÚSICA] [MÚSICA] [MÚSICA]