Bucle For

En este momento todos los miembros de esta clase son estaticos por que estan siendo compartidos con el metodo main y este necesita metodos estaticos por ser el punto de entrada de la app cuando se aborde la POO veras que al tener una clase normal no es necesario colocar static gracias a la instanciacion de los objetos

Excelente, solo que no se esta verificando la condicion si esta oh no encendida la lampara, pero genial la explicación

Practicando bucle for

El **While **se suele llamar “bucle de condición”, es decir, el programador no sabe cuantas veces se va a ejecutar el bucle y este simplemente continuará cuando acabe la condición impuesta en el bucle.

Por otro lado el **For **se trata de un bucle de control con el que el desarrollador repite el bucle un determinado número de veces en el que el desarrollador sabe cuantas o al menos aproximadamente cuantas veces se va a ejecutar.

Un clásico:

import java.util.Scanner;

public class BucleFor {

  public static void main(String[] args) {
    int lineas = 0;

    System.out.println("\n\t Indica el número de líneas del dibujo:");

    Scanner sc = new Scanner(System.in);
    lineas = Integer.valueOf(sc.nextLine());

    System.out.println("\n\t DIBUJO:");

    imprimirDibujo(lineas);
  }

  public static void imprimirDibujo(int n) {

    for (int i = n; i >= 0; i--) {
      for (int j = 1; j <= i; j++) {
        System.out.print("*");
      }
      System.out.print("\n");
    }
  }
}

El bucle for nos permite controlar la cantidad de veces que queremos que se ejecute nuestro código.

¡Hola!
Este seria el código que verifica constantemente que la luz este encendida 😃

for (int i = 1; i<= 10 && isTurnOnLight; i++){
            System.out.println(isTurnOnLight);
            printlSOS();
        }

✨ Puedes transformar o migrar un ciclo while a un ciclo for.

static boolean isTurnOnLight=false;
public static void main(String[] args) {
isTurnofLight();
for (int i=1;i<=10;i++){
printsos();
}
}
public static void printsos(){
System.out.println("…_…");
}
public static boolean isTurnofLight(){
//operador ternario—Los operadores ternarios son otra forma de
//evaluar condiciones, así como los condicionales IF y ELSE`:
isTurnOnLight=(isTurnOnLight)? false:true;
return isTurnOnLight;
}
}

Genial!!

El bucle for es útil cuando tienes una cantidad conocida de iteraciones. Por ejemplo, si quieres imprimir los números del 1 al 10, puedes usar un bucle for:

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

Por otro lado, el bucle while es útil cuando no sabes con certeza cuántas iteraciones serán necesarias. Por ejemplo, si quieres leer una entrada del usuario hasta que ingrese “salir”, puedes usar un bucle while:

Scanner scanner = new Scanner(System.in);
String input = "";
while (!input.equals("salir")) {
    System.out.print("Ingrese una entrada: ");
    input = scanner.nextLine();
}

En este ejemplo, el bucle while se ejecutará mientras la entrada del usuario no sea “salir”. Cada vez que el bucle se ejecuta, se lee una entrada del usuario y se almacena en la variable input. La condición !input.equals(“salir”) determina si el bucle debe continuar o no.

En resumen, usa un bucle for cuando conozcas con certeza la cantidad de iteraciones y quieras controlar cuidadosamente el proceso de iteración, y usa un bucle while cuando no sepas con certeza cuántas iteraciones serán necesarias y necesites evaluar una condición en cada iteración.

Hay 3 formas de usar un for, tradicional, for each y con break

El comando break es una instrucción de control de flujo en Java que se utiliza para salir de un bucle o de una estructura de control condicional.

En un bucle, como un for o un while, el comando break detendrá la ejecución del bucle en el momento en que se encuentre y continuará la ejecución del código después del bucle.

No se por que me gusta mucho el ciclo for

No sabia lo sel fori. me encanta porque he aprendido mucho ne pocas clases

El ciclo o bucle For y el bucle while pueden funcionar para resolver el mismo interrogante la diferencia esta en que usamos **For **cuando sabemos la cantidad de iteraciones que se desean ejecutar.

Otro clásico es hacer la tabla de multiplicar de un número, así:

int numero;
        Scanner sc = new Scanner(System.in);
        System.out.println("Digite el número: "); numero = Integer.valueOf(sc.nextLine());

        for (int i = 0; i <= 10; i++) {

            System.out.println(numero + " X " + i + "=" + (numero*i));

        }

Este es uno de los ciclos más utilizados en especial al leer arreglos o vectores, mi recomendación es que recuerden que existen otros ciclos, ya que me ha sucedido que al crear una aplicación cuando pienso en ciclos solo se me viene a la mente el ciclo for hasta ver que otros me son más eficientes no lo cambio.

jajajaja cuando la profe da spoiler de un tema :V 😂
Apuntes de clases

static boolean isTurnOnLight = false;

public static void main(String[] args) {
    turnOnOffLight();

    for (int i = 1; i <= 10; i++) {
        printSOS();
        
    }
}

public static void printSOS(){
    System.out.println(". . . _ _ _ . . .");
}

public static boolean turnOnOffLight(){
    isTurnOnLight = (isTurnOnLight)?false:true;
    return isTurnOnLight;
}

Aqui si esta validando si esta encendido o apagado:

public class ForLoop {
    //Variable Global
    static boolean isTurnOnLight = false;

    public static void main(String[] args) {


        for (int i = 0; i < 10 ; i++) {

            if(turnOnOffLight()) {
                printSOS();
            }
        }
    }

    //Imprime el mensaje de SOS
    public static void printSOS(){
        System.out.println("...___... ");
    }
    //Cambia el estado
    public static boolean turnOnOffLight(){
        isTurnOnLight = !isTurnOnLight;
        return isTurnOnLight;
    }
}

geniaaaal

En la universidad te enseñan el for en diagramas de flujo que complicado que era. y En código es mucho mas fácil su conceptualizacion .

public class ForLoop {
    static boolean isTurnOnLight = false;
    /**
     * Descripción: Función que emite diez señales de SOS usando un bucle For
     */
    public static void main(String[] args) {
    turnOnOffLight();
        for (int i = 1; i <= 10; i++) {
            printSOS();
        }
    }
    /**
     * Descripción: Señal SOS
     */
    public static void printSOS(){
        System.out.println(". . . _ _ _ . . .");
    }
    /**
     * Descripción: Operador ternario que valida si la linterna está encendida
     * @return isTurnOnLight
     */
    public static boolean turnOnOffLight(){
        isTurnOnLight = (isTurnOnLight) ? false : true;
        return isTurnOnLight;
    }
}

excelente ya casi terminamos los comandos basicos que usan todos los lenguajes de programación

El ciclo for redujo mucho el bucle.

Segundo bucle:
for( inicialización; condición; incremento){
}
eje
for(int i = 0; i < 10; i++){
System.out.println(“Repetición”);
}

Mis apuntes. Hice una modificacion para que al final aparezca el conteo de veces que se imprimió el mensaje de SOS:

public class _015_ForLoop {
    static boolean isTurnOnLight=false;
    public static void printSOS(){
        System.out.println(". . . _ _ _ . . .");
    }

    public static boolean turnOffOnLight() {
        isTurnOnLight = (isTurnOnLight) ? false : true;
        return isTurnOnLight;
    }

    public static void main(String[] args) {
        turnOffOnLight();
        int contador=0;
        for(int x=1;x<=10;x++){
            printSOS();
            contador=x;
        }
        System.out.println(contador);
    }
}

public class ForLoop {
    static boolean isTurnOnLight = false;

    public static void printSOS() {
        System.out.println(". . . _ _ _ . . .");
    }
    public static boolean turnOnOffLight(){
        //Operador ternario
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }

    public static void main(String[] args) {
        turnOnOffLight();

        for (int i = 0; i < 10; i++) {
            printSOS();
        }
    }
}

muy corto para aprender for

Curiosidades del for en Java:

El bucle for es un bucle controlado por contador. Esto significa que se sabe con antelación cuántas veces se ejecutará el bucle. Esto lo hace diferente de otros tipos de bucles, como el bucle while, que es un bucle controlado por condición y puede ejecutarse un número desconocido de veces.

La expresión inicial del bucle for se ejecuta antes de la primera iteración del bucle. Esto significa que es posible inicializar variables o ejecutar otras operaciones antes de comenzar a iterar.

La expresión de actualización del bucle for se ejecuta al final de cada iteración. Esto significa que es posible incrementar o decrementar contadores o realizar otras operaciones después de cada iteración.

Es posible usar más de una variable contadora en un bucle for. Esto puede ser útil cuando se necesita iterar a través de dos o más dimensiones.

Gracias por la explicacion.

Mi código de la clase:

public class ForLoop {
    
    static boolean isTurnOnLight = false;
    
    public static void main(String[] args) {
        turnOnOffLight();
        for (int i = 1; i <= 10; i++) {
            printSOS();           
        }
    }
    public static void printSOS() {
        System.out.println(". . . _ _ _ . . .");    
}
    public static boolean turnOnOffLight(){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    } 
}

Creo que al hacerlo de la forma que la profesora enseño, se esta dejando de lado la variable global que creamos por que el bucle solo esta usando el método que imprime el mensaje.

Se puede agregar un if que evalue la variable como en el bucle while.

if (isTurnOnLight) {
	for (int i = 1; i <= 10; i++) {
                printSOS();
	}
}

Ciclo For

<public class ForLoop {
    static boolean isTurnOnLight = false;

    public static void main(String[] args) {

        turnOnOffLight();

        for (int i = 1; i <= 10 ; i++) {
            printSOS();
        }

    }
    public static void printSOS(){
        System.out.println("...___...");
    }
    public static boolean turnOnOffLight (){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}> 

Muy bien explicado

Buena clase.

Comparto mi codigo de esta clase
…
public class forLoop
{
static boolean isTurnTheLight = false;

//MAIN
public static void main(String[] args)
{
    turnOnOffTheLight();
    for (int i = 1; i <=10 ; i++) {
        printSOS();
    }
}

public static void printSOS ()
{
    System.out.println(". . . _ _ _ . . .");
}

public static boolean turnOnOffTheLight()
{
    isTurnTheLight = (isTurnTheLight) ? false : true;
    return isTurnTheLight;
}

}
…

//Les comparto mi linea de codigo que hace enseña en número cada vez que se envío el mensaje morse

public class ForLoop {
static boolean isTunrOnLight = false;

public static void main(String[] args) {
    int z=1;
    turnOnOffLight();
    for (int i = 1; i <= 10 ; i++) {
        System.out.println(z);
        printSOS();
        z++;
    }
}
public static void printSOS(){
    System.out.println(". . . _ _ _ . . .");
}

public static boolean turnOnOffLight(){
    isTunrOnLight = (isTunrOnLight)?false:true;
    return isTunrOnLight;
}

}

Les dejo mi solucion.

public class ForLoop {

    static boolean isTurnLight = false;
    public static void main(String[] args) {
        turnOffLight();
        for(int i = 0; i <= 10; i++){
            printSOS();
        }
    }

    public static void printSOS() {
        System.out.println("...__...");
    }

    public static boolean turnOffLight() {
        isTurnLight = (isTurnLight) ? false : true;
        return isTurnLight;
    }
}

super claro y simple

Se simplifica todo el código con el For!

ciclo o sentencia for
Tiene tres secciones separadas por ;(Punto y Coma) en la primera sección de define e inicializa una variable, a menudo se conoce como variable de control , en la segunda sección se especifica una condición lógica, que frecuentemente estará en función de esta variable , en la tercera sección se define el incremento o razón de cambio de la variable de control.
Sintaxis

class ForDemo {
    public static void main(String[] args){
         for(int i=1; i<11; i++){
              System.out.println("Count is: " + i);
         }
    }
}

Super 😃

public class For {

    static boolean isTurnOnLight = false;

    public static void main(String[] args) {
        turnOnOffLight();
        for(int aux = 0;aux<=10;aux++){
            printSOS();
        }
    }
    public static void printSOS(){
        System.out.println(". . . _ _ _ . . .");
    }
    /**
     * Descripcion: mediante un operador ternera decide el valor de isTurnOnLight
     * @return regresa verdadero o falso según sea el caso.
     * */
    public static boolean turnOnOffLight(){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}

Interesante el fori, no sabía de este comando.

esto mismo me preguntaba por qué no se hacía en el anterior ejemplo xd

Perfecto 😃

Excelente presentación del Bucle For

Gracias por enseñarnos como funciona un bucle For.
Se podría simplificar el código del ejemplo así:

public class ForLoop {
    public static void main(String[] args) {
        for (int i = 1; i < 10 ; i++) {
            printSOS();
        }
    }

    public static void printSOS(){
        System.out.println(". . . _ _ _ . . .");
    }
}

Ahora que sabemos los tipos de ciclos en java queda de nuestra parte escoger cual es el mejor para cada caso, porque cada uno tiene su caso de uso ideal, siempre se podra adaptar cualquiera de estos ciclos a nuestras necesidades pero tenemos que hacer que nuestro codigo sea lo mas simple y legible posible.

forever for

//MI codigo @Omar Alban
`publicclassForLoop {
    static boolean isTurnOnLight = false;

    publicstaticvoidmain(String[] args) {

        turnOnOffLight();
        for(int i=1;i<=10;i++) {
            printSOS();
        }

    }
    publicstaticvoidprintSOS(){
        System.out.println(". . . _ _ _ . . .");
    }

    //Verifica si esta prendido o apagado la luz
    publicstatic boolean turnOnOffLight(){

        isTurnOnLight = (isTurnOnLight)?false:true;
/**
        if(isTurnOnLight){  //Si esta prendido lo apago
            isTurnOnLight=false;
        }else{              //Si no esta prendido lo prende con "true"
            isTurnOnLight=true;
        }*/
        return isTurnOnLight;
    }
}```

`

Excelente 😃

public class ForLoop {
    static  boolean isTurnOnLight = false;
    public static void main(String[] args) {
        turnOnOffLight();
        for (int j = 1; j <=10 ; j++) {
            printSOS();
        }
    }
    public static void printSOS(){
        System.out.println("...___...");
    }
    public static boolean turnOnOffLight(){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}

Bucle For
.
Bucle for: es una estructura repetitiva para ejecutar un mismo segmento de código una cantidad de veces deseada; debes de saber su valor de inicialización, su condición y su incremento.
.

Tambien se puede agregar la condición de isTurnOnLight al interior de for

public class ForLoop {
    static boolean isTurnOnLight = false;

    public static void main(String[] args) {

        turnOnOffLight();

        for (int j = 0; j <= 10 && isTurnOnLight; j++ ) {
            printSOS();
        }
    }
    public static void printSOS(){
        System.out.println("...---...");
    }
    public static boolean turnOnOffLight(){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}```

Genial.

public class ForLoop {

    static boolean isTurnOnLight = false;

    public static void main(String[] args) {

        isTurnOffLight();
        for (int i = 1; i <= 10; i++) {
            printSOS();
        }
    }

    public static void printSOS(){
        System.out.println("...___...");
    }

    public static boolean isTurnOffLight(){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}```

public class WhileLoop {


    static boolean isTurnOnLight = false;

    public static void main(String[] args) {

        isTurnOffLight();
        int i = 1 ;

        for (int j = 1; j <=10; j++) {
            printSOS();

        }


        while(isTurnOnLight && i<=10){
            printSOS();

            i++;
        }

    }

    public static void printSOS()
    {
        System.out.println(". . . _ _ _ . . .");
    }

    public static boolean isTurnOffLight(){
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}

Muy claro.

Mucho mas facil.

public class foorLoop {
    static boolean isTurnOnLight = false;
    public static void main(String[] args) {
        turnOnOffLight();
        for (int i = 1; i <= 10 ; i++) {
            printSOS();
        }
    }```

Le agregue un sleep para que se pueda ver mejor las repeticiones.

public class ForLoop {

    static boolean isTurnOnLight = false;

    public static void printSOS() throws InterruptedException {
        System.out.println(". . . _ _ _ . . .");
        Thread.sleep(300);
    }

    public static boolean turnOnOffLight() {
        /* Operador ternario */
        isTurnOnLight = (isTurnOnLight) ? false : true;
        return isTurnOnLight;
    }

    public static void main(String[] args) throws InterruptedException {
        /* Foor Loop */
        for (int i = 0; i <= 10; i++) {
            printSOS();
        }
    }
}

Usa while si no sabes cuantas veces debes de repetir la instrucción y for si lo sabes.

Todo muy claro. Gracias

El ciclo for unifica el contador que se veía en la clase anterior.

public class ForLoop {

    static  boolean isTurnOnLight = false;

    public static void main(String[] args) {

        TurnOnOFFLight();

        for (int i = 1; i <= 10; i++) {
            PrintSOS();
        }

    }

    public  static  void PrintSOS(){
        System.out.println(" ...___...");
    }

    public  static  boolean TurnOnOFFLight(){
        //operador terniario, esta sintaxis  se usa para cambiar el valor de la variable.
        isTurnOnLight = (isTurnOnLight)?false:true;
        return isTurnOnLight;
    }
}

Muy buenoo.

for(i=1; i<=10; i++){
printSOS();
}

i=1 => inicio
i<= 10 => fin hasta que punto
i ++ => incremento de cuanto en cuanto