diff --git a/public/java-fundamentals/ErrorExample1.png b/public/java-fundamentals/ErrorExample1.png new file mode 100644 index 0000000..631a522 Binary files /dev/null and b/public/java-fundamentals/ErrorExample1.png differ diff --git a/public/java-fundamentals/ErrorExample2.png b/public/java-fundamentals/ErrorExample2.png new file mode 100644 index 0000000..67d8072 Binary files /dev/null and b/public/java-fundamentals/ErrorExample2.png differ diff --git a/src/config/sidebarConfig.ts b/src/config/sidebarConfig.ts index 9642d0b..70542af 100644 --- a/src/config/sidebarConfig.ts +++ b/src/config/sidebarConfig.ts @@ -65,6 +65,18 @@ export const sidebarSections: Record = { }, ], + // Intro To Java section + '/intro-to-java': [ + { + label: 'Intro to Java', + items: [ + { label: 'Stage Overview', slug: 'intro-to-java/stage-overview' }, + { label: 'Java fundamentals', slug: 'intro-to-java/java-fundamentals' }, + { label: 'Operators', slug: 'intro-to-java/operators' }, + ], + }, + ], + // Resources section (content lives at /resources but navbar says "Other Resources") // '/resources': [ // { diff --git a/src/content/docs/index.mdx b/src/content/docs/index.mdx index 97f97a0..775c380 100644 --- a/src/content/docs/index.mdx +++ b/src/content/docs/index.mdx @@ -17,6 +17,18 @@ hero: import HomeCard from '../../components/HomeCard.astro';
+ + -
diff --git a/src/content/docs/intro-to-java/java-fundamentals.mdx b/src/content/docs/intro-to-java/java-fundamentals.mdx new file mode 100644 index 0000000..000c77e --- /dev/null +++ b/src/content/docs/intro-to-java/java-fundamentals.mdx @@ -0,0 +1,89 @@ +--- +title: Java Fundamentals +description: An Intro to print statements and variables +prev: intro-to-java/java-fundamentals +next: intro-to-java/operators +--- +import Aside from '../../../components/Aside.astro'; +import ContentFigure from '../../../components/ContentFigure.astro'; + +## Syntax +As you start programming, you might make a mistake or make a typo. When that happens, your code will have a red line under it. This is because Java has rules called syntax. Syntax is a set of rules that have to be followed so that the computer can understand and run your code. It’s important to pay attention to the syntax! +If your code has a red line under it, first check whether the syntax is correct. This can be done by researching online or by comparing your code with examples. + +You can also learn what’s wrong with your code when you put the cursor over the section of the code with the red line and read what the error message is. +Error messages will not tell you exactly what's wrong with your code. If you’re unsure on what the error message means, you can look it up to get additional context. + + + + + +## Variables +Variables are containers that are used to store information in a program. This could be a variable that holds the temperature or a variable that holds the speed of the motor. + +The syntax of a variable is has following: +```java +Datatype name = value; +``` +Data types refer to the type of value that our variable has. It helps tell our program more information about our variables such as what type of information it holds and how it can be used. +Data types can include numbers, characters or a string of words. Some examples of data types that are commonly used in FRC programming are: +* Int: integers or numbers that are positive or negative. Int only allows numbers without decimals. Example: 12 +* Double: Double: numbers that are positive or negative. Unlike int, double allows numbers with or without decimals. Example: 34.1 +* Boolean: either True or False. +* String: holds a sequence of characters. Example: “Hello World” +* Char: holds a Single character. Example: 'A' + +The name of your variable can be whatever you want. However, it should be easy to read and make sense to others who may be reading your code. +There are also some rules with variable names. The name of the variable can not include spaces. Instead you can write variables with camel case (frontLeftDrive) and snake case (front_Left_Drive). +Variable names can not start with a number. However, they can have a number at the end of the name. + + + +In Java, semi-colons (;) are similar to a period in a sentence. It is what tells the compiler when a line of code ends. Semi-colons are used commonly in programming and aren’t only for creating variables. We will see more examples of this later in the course. + +In FRC, variables can be used to hold information about the robot and its different mechanisms. The example below shows 3 variables that were used for a climber mechanism, CLIMBERID is an integer that holds the motor controller ID number which is 51. UP_POSITION is a double that holds the value -33.5 and DOWN_POSITION is a double that holds the value 0. +```java +int CLIMBERID = 51; +double UP_POSITION = -33.5; +double DOWN_POSITION = 0; +``` + + +## Print statements +When programming, it can be useful to display information. This can be helpful for making programs that display information to the user or trying to see what speed that a motor is running. +In Java, we can print information to a terminal using a print statement. A print statement in Java looks like: +```java +System.out.print(“hello!”); +``` +What the print statement does is take information inside the parentheses, in the above example, it’s “hello!”, and prints it out to the terminal screen. When using a print statement, the text that we want to print out goes inside the parentheses and is in quotes. However, if we are printing out the value of a variable, then we do not need quotes, as shown below. +```java +int number = 4; +System.out.print(number); // prints out the value 4 +``` + +## Comments +When programming, we use comments to write notes that explain what the code does. This helps make the code more readable for others because if they are unsure of what your code does, they can read your comments. Comments are not run by the compiler, which also means that you can use comments to prevent code from running. +In Java, there are two types of comments. Single-line Comments and Multi-line Comments. + +### Single-line Comments +Single-line comments are // and you add them to the front of your text or line of code. For example, the code below leaves a note of “this prints out Hello World. +```java +// This prints Hello World +System.out.print("Hello World"); +``` +You will also see comments placed at the end of code like the following +```java +System.out.print("Hello World"); // This prints Hello World +``` +Both examples accomplish the same tasks and there is no difference. If you put your comments above or next to code is up to you and what makes the most sense for your code. + +### Multi-line Comments +Multi-line Comments start with /* and end with */ The text or code that is in between the two will turn into comments. Multi-line Comments are commonly used when you have many lines of text or need to turn a large amount of code into a comment. +For example, this is a comment with two lines of text +```java +/* This prints Hello World +This is another line */ +System.out.print("Hello World"); +``` \ No newline at end of file diff --git a/src/content/docs/intro-to-java/operators.mdx b/src/content/docs/intro-to-java/operators.mdx new file mode 100644 index 0000000..fbb32c7 --- /dev/null +++ b/src/content/docs/intro-to-java/operators.mdx @@ -0,0 +1,285 @@ +--- +title: Operators +description: An Intro to operators and how they are used to change variables +prev: intro-to-java/java-fundamentals +next: false +--- + +import Aside from '../../../components/Aside.astro'; + +In Java, we use operators to perform to change or compare the values of variables. There are different types of operators, which are: +* Arithmetic Operators +* Assignment Operators +* Comparison Operators +* Logical Operators + +These types of operators are often used in programming. They can be used to update a robot arm's setpoint, where we want the mechanism to be, or to change the value of a variable in a loop. Operators are important to know when programming your robot + +## Arithmetic Operators +Arithmetic operators are used to perform basic math on variables. These include: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorDescriptionCompatible Data TypesExample
+Addition: Adds two values together int, doublea + b
-Subtraction: Subtracts one value from the otherint, doublea - b
*Multiplication: Multiplies two values togetherint, doublea * b
/Division: Divides one value from the otherint, doublea / b
%Remainder: Returns the remainder of two numbers after divisionint, doublea / b
++Increment: add 1 to a varibleint, doublea++
--Decrement: subtracts 1 to a varibleint, doublea--
+ +Operators can be used when creating variables or when changing a variable later in code. In the example below, we have three variables whose values are set using different operators. Without running the code, what value would each variable hold? +```java +int answer1 = 2 + 4; +int answer2 = 6 / 3; +int answer3 = 10 - 3; +``` +
+ Answer +
+

+ * answer1 is 6 because 2 + 4 = 6 + * answer2 is 2 because 6 / 3 = 2 + * answer3 is 7 because 10 - 3 = 7 +

+
+
+ +Operators can also be used to change a variable later in code. In the example below, we have an integer variable named Number that is set to 6. Using the multiplication operator, the value is adjusted inside the print statement. Without running the code, what is the value of Number? +```java +int Number = 6; + +System.out.print(answer * 2); +``` +
+ Answer +
+

Number's new value is 12. This is because Number holds the value 6. When multiplied by 2, 6 becomes 12, which is the new value of Number

+
+
+ + + +The ++ and -- operators are often used to change the value of the code as well. They help with incrementing and decrementing values and are used in conditionals (which are covered in a later stage). +For now, we can use the operators to change variables without using conditionals. +Like mentioned before, ++ increments the value of a variable by adding 1 and -- decrements the value of a variable by subtracting 1. + +In the example below, we have two varibles. +```java +int x = 6; +int y = 7; + +System.out.println(++x); +System.out.println(--y); +``` +In the first print statement, we have ++x. This means it takes the value of x and increments it by 1 which gives us 7 because 6 + 1 is 7. +In the second print statement, we have --y. This means that it takes the value of y, decrements it by 1 which gives us 6 since 7 - 1 is 6. + + +## Assignment Operators +Assignment operators are used when assigning or updating the values in a variable. These include: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorDescriptionExample
{'='}Assigns a value to a variablea = 2
{'+='}Addition: Takes the current value of the variable, adds the stated amount then assigns the result to the variable. It's the same as x = x + y a += 3
{'-='}Subtraction: Takes the current value of the variable, subtracts the stated amount then assigns the result to the variable. It's the same as x = x - y a {'-='} 4
{'*='}Multiplication: Takes the current value of the variable, multiplies the stated amount then assigns the result to the variable. It's the same as x = x * ya {'*='} 5
{'/='}Division: Takes the current value of the variable, divides the stated amount then assigns the result to the variable. It's the same as x = x / ya {'/='} 6
+ +Assignment Operators are similar to Arithmetic Operators, they are shorthand. Using the shorthand version can help make code easier to read. It prevents having to write the variable name twice which can also be helpful in preventing code issues. + +In the example below, we have variables A which is set to 10, and variable B which is set to 5. Since += adds 1, A will hold the value of 11. Similarly, B will now hold the value of 4 + +```java +int A = 10; +int B = 5; +A += 1; +B -= 1; + +System.out.println(A); // prints 11 +System.out.println(B); // prints 4 +``` + +## Comparison Operators +Comparison operators are symbols that tell the program how to compare values. They can be used to help make decisions, which is an important part of programming. Comparison operators are a main part of conditionals, which are discussed later in this stage. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorDescriptionExample
{'=='}Equals to: Checks if one value is the same values as the othera == b
{'!='}Not Equal: Checks if one value is NOT equal to the othera != b
{'>'}Greater than: Checks if one value is greater than the othera {'>'} b
{'<'}Less than: Checks if one value is less than the othera {'<'} b
{'>='}Greater than or equal too: Checks if one value is greater than or equal to the othera {'>='} b
{'<='}Less than or equal too: Checks if one value is less than or equal to the othera {'<='} b
+ +Comparison Operators help programs make decisions because they can return if the value of a comparison is true or false. If you remember from the previous section, these are booleans! + +Comparison operators are very similar to what you see in math problems. In this example, we have two variables: A and B. A is set to 2, and B is set to 4. The print statement compares the two variables using the greater than sign. In the example below, it returns false because 2 is not greater than 4. +```java +int A = 2; +int B = 4; +System.out.print(A > B); +``` + +## Logical Operators +Logical operators are symbols that let a program make decisions by combining true or false statements. They are also used when making decisions in a program and are also used in conditionals. + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorDescriptionExample
{'&&'}and: true if both statments are truetrue && true // this is true
{'||'}Or: true if at least one statement is truetrue || false // this is true
{'!'}Not: reverses. If true, then false. If false then true !true // this changes to false
+ +In the example below we have 2 variables: AnswerOne and AnswerTwo. We know AnswerOne is true and AnswerTwo is false. Using that information and without running the code, what should the print statements print out? +```java +boolean AnswerOne = 5 > 3; // True +boolean AnswerTwo = 9 < 2; // False + +System.out.println(AnswerOne && AnswerTwo); +System.out.println(AnswerOne || AnswerTwo); +System.out.println(!AnswerOne); +``` +
+ Answer +
+

+ * false. && returns true if both statements are true. AnswerTwo is false, therefore the operator will return false + * true. || returns true if one of the statements are true. AnswerOne is true, therefore the the operator will return true + * false. ! reverses the outcome. AnswerOne is true, adding ! will reverse it and return false +

+
+
\ No newline at end of file diff --git a/src/content/docs/intro-to-java/stage-overview.mdx b/src/content/docs/intro-to-java/stage-overview.mdx new file mode 100644 index 0000000..72ecff8 --- /dev/null +++ b/src/content/docs/intro-to-java/stage-overview.mdx @@ -0,0 +1,20 @@ +--- +title: Stage Overview +description: An Intro to what Java is and the topics that will be covered in this stage +prev: false +next: intro-to-java/java-fundamentals +--- + +Learning the basics of Java is the most important step in learning FRC programming because it builds the foundation. In Java, objects are used to create motor +controllers that allow a robot to run a motor, variables are used to assign a speed to the motor, and much more. There is a lot to learn when learning Java. However, +FRCSoftware will go over the basics needed to program a robot. + +Each section will have different activities and exercises to help build up a good understanding of the basics of Java. If you’re new to programming, it is highly +recommended to go through each step in order. This will help ensure that you don’t miss any important information. + +This stage will cover the following topics +* Java Fundamentals +* Operators + + +