diff --git a/examples/stage0/snippets/src/Loops.java b/examples/stage0/snippets/src/Loops.java new file mode 100644 index 00000000..38933259 --- /dev/null +++ b/examples/stage0/snippets/src/Loops.java @@ -0,0 +1,79 @@ +/* + * Copyright 2026 FRCSoftware + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +class Drivetrain { + public void setThrottle(double speed) {} +} + +boolean condition = false; +Drivetrain drivetrain = new Drivetrain(); + +void main() { + // [whileSyntax] + while (condition) { + // code to run when condition is true + } + // [/whileSyntax] + + { + // [whileExample] + int i = 0; + while (i < 6) { + System.out.println(i); // prints 0, 1, 2, 3, 4, 5 + i++; + } + // [/whileExample] + } + + // [whileExample2] + int autoTimer = 0; + while (autoTimer <= 15){ + System.out.println("AutoMode is happening"); + autoTimer++; + } + // [/whileExample2] + + + { + // [ForExample1] + int i = 0; + while (i < 6) { + System.out.println("Hi!"); + i++; + } + // [/ForExample1] + } + + // [ForExample2] + for (int i = 0; i < 6; i++) { + System.out.println("Hi!"); + } + //[/ForExample2] + + // + // [forExample] + for (int i = 0; i < 5; i++){ + System.out.println(i); // prints 0, 1, 2, 3, 4 + } + // [/forExample] + + if (false) { + // [Infinite1] + int timer = 0; + while (timer < 7){ + drivetrain.setThrottle(1); // sets drive motors to full speed + } + // [/Infinite1] + } + + // [Infinite2] + int timer = 0; + while (timer < 7){ + drivetrain.setThrottle(1); // sets drive motors to full speed + timer++; // increments timer by 1 + } + // [/Infinite2] +} \ No newline at end of file diff --git a/public/learning-course/stage0/loops/WhileLoop.webp b/public/learning-course/stage0/loops/WhileLoop.webp new file mode 100644 index 00000000..74e485d0 Binary files /dev/null and b/public/learning-course/stage0/loops/WhileLoop.webp differ diff --git a/src/config/sidebarConfig.ts b/src/config/sidebarConfig.ts index c6569f82..4fd8dd85 100644 --- a/src/config/sidebarConfig.ts +++ b/src/config/sidebarConfig.ts @@ -69,10 +69,10 @@ export const sidebarSections: Record = { label: 'Conditionals', slug: 'learning-course/stage0/conditionals', }, - // { - // label: 'Loops', - // slug: 'learning-course/stage0/loops', - // }, + { + label: 'Loops', + slug: 'learning-course/stage0/loops', + }, { label: 'Classes, Fields, and Methods', slug: 'learning-course/stage0/classes-methods', diff --git a/src/content/docs/learning-course/stage0/loops.mdx b/src/content/docs/learning-course/stage0/loops.mdx new file mode 100644 index 00000000..53dda21a --- /dev/null +++ b/src/content/docs/learning-course/stage0/loops.mdx @@ -0,0 +1,181 @@ +--- +title: Loops +description: An Intro loops in Java +prev: learning-course/stage0/conditionals +next: learning-course/stage0/classes-methods +codeRegionSources: + default: stage0/snippets/src/Loops.java +--- + +Oftentimes we want to do the same action multiple times in a row. +For instance, if you know your grades are about to be released, you might repeatedly check them until they come out. +In Java we can use loops to do this. + +In this lesson, we're going to cover two main types of loops: **while** loops and **for** loops. + + + +Conditionals and loops may seem similar but they have different purposes. +Conditionals are used to make decisions based on whether the condition is true or false. +Loops are used to repeat code until the condition is met. +This can be thought of conditionals make decisions, and loops are for repeating. + +## while + +`while` loops are the most simple type of loops. +If you have used block coding before, this is similar to the repeat block. +If you have taken an CS class, you might already be familiar with a `while` loop. + +The syntax of a `while` loops is as shown: + +```java #whileSyntax + +``` + +You might notice that a `while` loop looks very similar to the `if` conditional, which was discussed in the previous lesson. +This is because the `while` loop and `if` statement are both based around checking a condition, and then performing an action depending on whether the condition is true or false. +A `while` loop includes: + +- the `while` keyword to declare that we're making a `while` loop +- `( )` to hold the condition that is either true or false. + Example: (5 > 1) is a condition and it is true because 5 is greater than 1 +- `{` to denote the opening of the loop's code block +- `}` to denote the end of the loop's code block + +The following flowchart `demonstrates` how a while loop works: + + + +Like the `if` conditional, the `while` loop will run its code block if the condition is true. +Unlike the `if` conditional, however, when the code block is done, the `while` loop will evaluate its condition again. +If the condition is still true, the code block will run again. +This will repeat until the condition is false. +Also unlike the `if` conditional, a `while` loop (or any other type of loop) can't have any `else` statements attached. +This means that if the condition is false when the loop is first encountered, the entire thing is skipped. + +Let's look at an example: + +```java #whileExample + +``` + +In the example, there is an `int` called `i` which holds the value 0. The `while` loop has the condition `i < 6`. +First, the compiler checks if the condition is true. +We know that 0 is less than 6 so the `while` code block runs and the value of `i`, which is currently 0, is printed to the terminal. +The value of `i` is also updated because of `i++` and it changes to 1. +Now the condition checks if 1 is less than 6. We know that it is true, so the value of `i` gets printed and the value of `i` is increased by 1. +This repeats and eventually `i`'s value becomes 6. +Now, when the condition is evaluated, it's `false`, as 6 is not less than 6, so the loop is complete. + + + +Lets look at an another example! +In the example below we have: + +```java #whileExample2 + +``` + +Without running the code, what do you think happens? + +`autoTimer` is set to 0. The `while` loop's condition is `autoTimer <= 15`. +0 is less than 15 so the code enters the `while` code block, and prints outs `Auto is happening`. +`autoTimer++` is run which increases `autoTimer`'s value by one. +The code goes back to the condition, 1 is less than 15, so the code enters the `while` code block again, printing out `Auto is happening`. +Like before, `autoTimer++` runs which increases `autoTimer` by one again making the value be 2. This repeats until `autoTimer` is 16. When that happens the condition is false and the `while` loop is skipped. + +## for + +With the power of while loops, we're able to repeat a block of code any number of times, like so: + +```java #ForExample1 + +``` + +This loop depends on 3 important statements: +`int i = 0;`, `i < 6`, and `i++`. +For loops allow us to inline these statements: + +```java #ForExample2 + +``` + +Using the previous, we can see that the `for` loop syntax includes: + +- the `for` keyword to declare that we're making a `for` loop +- `()`to hold the three statements which allow the loop to run +- `{` to denote the opening of the loop's code block +- `}` to denote the ending of the loop's code block + +The three statements are + +- **initialization**: creates a variable that sets the starting point of the loop. + This is the `int i = 0;` seen in the previous example. +- **condition**: a condition, which uses the variable, that is checked before each iteration. + This is `i < 6;`. + If the condition is true, the code inside the loop runs +- **update**: updates the variable created in initialization after each iteration. + Lastly, that's `i++`; + +Let's look at another example: + +```java #forExample + +``` + +In this example, we create a variable `i` that is set to 0. When `i` is less than 5, the `for` code block runs, printing the value of `i` which is 0. +Then it goes back to the update statement which is `i++`, `i` has increased by 1 and `i`'s value is now 1. +We check the condition, 1 is less than 5, so `for` code block runs, the new value of `i` is printed, `i` is updated and this repeats until `i` is no longer less than 5. +When `i` is no longer less than 5, the `for` loop is skipped. + +## Be Careful about Infinite Loops + +It is important to make sure that the condition can become false. +If the condition is always true, the loop will always run causing an infinite loop. +Infinite loops can be prevented by ensuring that the value inside the condition changes by incrementing or decrementing. + + + +```java #Infinite1 + +``` + +In this example, we want our drive train to run for 7 seconds. +We have our variable called `timer` which is set to 0. +0 is less than 7 so the code inside runs and the robot drives forward at full speed. +However, `timer`'s value never changes. +This means `timer` will always be 0. 0 is less than 7 so the loop will continuously run and the robot never stops driving! + +To fix this, we would make sure to increment the timer value as shown below. + +```java #Infinite2 + +``` + +`timer` now increments by 1 each time the loop is run, and the robot will stop driving after 7 seconds. + +## Loops Exercise + +