From e6dc10f98ab2eec9259958fb0362d0c4c5334ec0 Mon Sep 17 00:00:00 2001
From: Soup <39444003+magicalsoup@users.noreply.github.com>
Date: Sun, 14 Apr 2019 11:01:07 -0400
Subject: [PATCH] fixed formating
---
.../ICS3U1/Final_Exam_Study_Sheet.md | 1717 ++++++++---------
1 file changed, 858 insertions(+), 859 deletions(-)
diff --git a/Grade 9/Computer Science/ICS3U1/Final_Exam_Study_Sheet.md b/Grade 9/Computer Science/ICS3U1/Final_Exam_Study_Sheet.md
index 5033690..d9a7076 100644
--- a/Grade 9/Computer Science/ICS3U1/Final_Exam_Study_Sheet.md
+++ b/Grade 9/Computer Science/ICS3U1/Final_Exam_Study_Sheet.md
@@ -1,961 +1,960 @@
# Computer Science Review Sheet
-> ## Exam Layout
->> |Part|Description|Marks|
->> |:---|:----------|:----|
->> |```A```|**True / False**|10|
->> |```B```|**Multiple Choice**
- All java code learnt, selection, loops, methods, Arrays, methods, strings|38|
->> |```C```|**Short & Long Answers**
- Compare and contrast short code, methods, problem solving|20|
->> |```Total```||68|
+## Exam Layout
+ |Part|Description|Marks|
+ |:---|:----------|:----|
+ |```A```|**True / False**|10|
+ |```B```|**Multiple Choice**
- All java code learnt, selection, loops, methods, Arrays, methods, strings|38|
+ |```C```|**Short & Long Answers**
- Compare and contrast short code, methods, problem solving|20|
+ |```Total```||68|
# Unit 1: Intro To Programming
-> ```Comments```: are used to explain and clarify program ocde for human reader
+- ```Comments```: are used to explain and clarify program ocde for human reader
-> |Operator|Uses|Description|
-> |:-------|:---|:----------|
-> |+|a + b|Addition|
-> |-|a- b|Subtraction|
-> |*|a * b|Multiplication|
-> |/|a / b|Division|
-> |%|a % b|Mod, the Remainder|
+ |Operator|Uses|Description|
+ |:-------|:---|:----------|
+ |+|a + b|Addition|
+ |-|a- b|Subtraction|
+ |*|a * b|Multiplication|
+ |/|a / b|Division|
+ |%|a % b|Mod, the Remainder|
-> **BEDMAS** rules still apply
+- **BEDMAS** rules still apply
-> ## Strings
+## Strings
->> **```String:```** means a group of many characters
->> **```String Concatenation```**: means that two strings are combined into one using the "r" sign
+- **```String:```** means a group of many characters
+- **```String Concatenation```**: means that two strings are combined into one using the "r" sign
-> ## Variables
-> - Holder for data
-> - We can use words instead of just a single letter
-> - can store more than just numbers
-> - a place in memory (RAM: random access memory) where it can be stored or referred to
-> - Name, type, value
+## Variables
+ - Holder for data
+ - We can use words instead of just a single letter
+ - can store more than just numbers
+ - a place in memory (RAM: random access memory) where it can be stored or referred to
+ - Name, type, value
->> To declare a variable
->> 1. Name
->> 2. Data Type
+## To declare a variable
+ 1. Name
+ 2. Data Type
->> A variable is the name of a reserved memory location
->> A varaible name is called an identifier
->> Reserved words cannot be used as an identifier
+- A variable is the name of a reserved memory location
+- A varaible name is called an identifier
+- Reserved words cannot be used as an identifier
-> ## Java Primitives
+## Java Primitives
-> Variables can be created for any of the data types listed
-> The chart shows examples of how to create a new variable for each primitive
+- Variables can be created for any of the data types listed
+- The chart shows examples of how to create a new variable for each primitive
-> |Type|Range|Size|Variable|Declaration|
-> |:---|:----|:---|:-------|:----------|
-> |byte|-128 to 127|8 bits|bits_8|byte bits_8;|
-> |short|-32768 to 32767|16 bits|TALL|short TALL;|
-> |int|-2 billion to 2 billion|32-bits|sum|int sum;|
-> |long|-9 quintillion to 9 quintillion(huge)|64 bits|mile|long mile;|
-> |float|-3.4e+/-38 to 3.4e+/-38|32 bits|pi|float pi;|
-> |double|-1.7e+/-308 to 1.7+/-308|64 bits|stuff|double stuff;|
-> |char|Single (unicode) characters|16 bits|letter|char letter;|
+ |Type|Range|Size|Variable|Declaration|
+ |:---|:----|:---|:-------|:----------|
+ |byte|-128 to 127|8 bits|bits_8|byte bits_8;|
+ |short|-32768 to 32767|16 bits|TALL|short TALL;|
+ |int|-2 billion to 2 billion|32-bits|sum|int sum;|
+ |long|-9 quintillion to 9 quintillion(huge)|64 bits|mile|long mile;|
+ |float|-3.4e+/-38 to 3.4e+/-38|32 bits|pi|float pi;|
+ |double|-1.7e+/-308 to 1.7+/-308|64 bits|stuff|double stuff;|
+ |char|Single (unicode) characters|16 bits|letter|char letter;|
-> ## Operations
+## Operations
->> |Operation|Notation|Equivalent|Result Type|
->> |:--------|:-------|:---------|:----------|
->> |equals|a == b||boolean|
->> |addition|a + b||number|
->> |subtraction|a - b||number|
->> |multiplication|a * b||number|
->> |division|a / b||number|
->> |less|a < b||boolean|
->> |less or equal|a > b|a <= b||boolean|
->> |more|a >= b|not (a < b)|boolean|
->> |more or equal|a >= b|not(a == b)|boolean|
->> |negation|-b|0 - b|number|
+ |Operation|Notation|Equivalent|Result Type|
+ |:--------|:-------|:---------|:----------|
+ |equals|a == b||boolean|
+ |addition|a + b||number|
+ |subtraction|a - b||number|
+ |multiplication|a * b||number|
+ |division|a / b||number|
+ |less|a < b||boolean|
+ |less or equal|a > b|a <= b||boolean|
+ |more|a >= b|not (a < b)|boolean|
+ |more or equal|a >= b|not(a == b)|boolean|
+ |negation|-b|0 - b|number|
-> ## Sample Code
->> ``` java
->> class AddTip{
->> public static void main(String[]args){
->> double amount; // variable declaration,
->> // can store a double(real number)
->> // no value assigned to it yet
->> // variable name is identifier
->> double pi = 3.1415926;
->> amount = 19.95; // variable amount has been assigned value of 19.95
->> amount = amount + 3.00; // takes current vaue of amount(19.95) and add 3.00 to it
->> // then assigns the new value to amount(22.95)
->> System.out.print("We will pay $");
->> System.out.print(amount);
->> System.out.print(" for the pizza delivery");
->> // prints amount
->> }
->> }
->> ```
+## Sample Code
+ ``` java
+ class AddTip{
+ public static void main(String[]args){
+ double amount; // variable declaration,
+ // can store a double(real number)
+ // no value assigned to it yet
+ // variable name is identifier
+ double pi = 3.1415926;
+ amount = 19.95; // variable amount has been assigned value of 19.95
+ amount = amount + 3.00; // takes current vaue of amount(19.95) and add 3.00 to it
+ // then assigns the new value to amount(22.95)
+ System.out.print("We will pay $");
+ System.out.print(amount);
+ System.out.print(" for the pizza delivery");
+ // prints amount
+ }
+ }
+ ```
+
+## Java Data Types
-> ## Java Data Types
->> ### Java primitive types
->>> boolean
+### Java primitive types
+- boolean
->>> number:
->>> - integer
->>> - byte
->>> - short
->>> - int
->>> - long
->>> - char
->>> - floating-point
->>> - float
->>> - double
+- number:
+ - integer
+ - byte
+ - short
+ - int
+ - long
+ - char
+ - floating-point
+ - float
+ - double
->>> **Remember** ```String``` is not a primitive type
+- **Remember** ```String``` is not a primitive type
->> ```equals(String)``` - Method compares the current string to another string and returns true if the two contain the same value, false if different
+- ```equals(String)``` - Method compares the current string to another string and returns true if the two contain the same value, false if different
->> ```substring(int, int)``` - takes two values - an int for the first character and an int for the last character (exclusive)
+- ```substring(int, int)``` - takes two values - an int for the first character and an int for the last character (exclusive)
- substring(1, 10) returns the substring from index 1 to index ```9```
- returns that part of the string
->> ### Strings
->> - String - a set of individual characters
->> - string start at zero - zero indexing
->> - an array of characters
-
->> - Char(acter) - hold the same type of information as a string - but only one character
->> - use single quotes rather than double quotes
->> - many different methods that can be used with char
->> - uses less memory than a string
-
->>> ```java
->>> String name = "Ms Andrighetti";
->>> String firstThree, lastEleven;
->>> firstThree = name.substring(0, 3);
->>> lastEleven = name.substring(4, 15);
->>> System.out.println(firstThree);
->>> System.out.println(lastEleven);
->>> ```
-
->> - first character is index 0 because zero-indexed
->> - substring specifies the first characters you want and the last character you don't want
->> - if you try to access a point beyond the end of the String, you will get an error
-
->> - ```length()``` - tells you how many character are in a string
->> - length gives you the length of string not last index of the string
->>> ```java
->>> String word = "Hello";
->>> int length = word.length();
->>> System.out.println(length);
->>> ```
-
->> ### Boolean Expressions
->> - can only have 2 possible value(true or false)
->> - compare must be compatible type
-
->>> |Symbol|Meaning|
->>> |:-----|:------|
->>> |==|equal to|
->>> |!=|not equal to|
->>> |>|greater than|
->>> |<|less than|
->>> |>=|greater than or equal to|
->>> |<=|less than or equal to|
-
->> ```Modulus operator (%)```: returns the remainder of 2 numbers
->> ```String```: stores characters / text
->> ```String comparison```: different from primitive type comparison
->> - cannot use ```==``` sign
->> - use boolean expression ```object1.equals(object2)```
-
-> ## Reading Input (Scanner Class)
-
->> ```import``` scanner class to use it
->> use
->> ```java
->> import java.util.Scanner;
->> ```
-> - to tell compiler to include scanner class in the .class file
-> - line at very top of file
-> - create scanner using
->> ```java
->> Scanner myScanner = new Scanner(System.in);
->> ```
-
->> |To read this...|...Make this method call|
->> |:--------------|:-----------------------|
->> |a number with no decimal point in it|nextInt()|
->> |a number with a decimal point in it|nextDouble()|
->> |a word(ending in a blank space, for example)|next()|
->> |a line(or what remains of a line after you've already read some data from the line)|nextLine()|
->> |a single character(such as a letter, a digit or a punctuation character|next.charAt(0)|
-
-> ## Output
-> - using standard output system:
-
->> ```java
->> System.out.println()
->> ```
-
-> - this outputs to the console
-
-> ## Selection statements
-> - allow java to make a decision
-> - depending on decision, program will function differently each time it is run
-
->> ```java
->> if(condition){
->> //then perform some commands
->> // outcome
->> }
->>```
-
->> ### Example:
-
->>> ```java
->>> int age = 17;
->>> if(age >= 16){
->>> // execute if condition
->>> System.out.println("You are " + age);
->>> System.out.println("You can learn to drive");
->>> } // skips if condition not met
->>>```
-
->> ### ```=``` vs ```==```
->> - ```=```: assignment
->> - ```==```: comparison
-
->> ### if.... else if.... else
-
->>> ```java
->>> if(condition){
->>> statement1;
->>> } else{
->>> statement2;
->>> // -----------------------
->>> }
->>> if(num > 10){
->>> System.out.println("Your number is greater than 10");
->>> } else{
->>> System.out.println("Your number is less than or equal to 10");
->>> }
->>> ```
-
->> - used when program needs to choose from a variety of situations
->> - use else if to specify another condition
->> - helps to control the flow of your program
->> - helps make decision when 3 or more conditions must be considered
->> - makes program more efficient
-
->>> ```java
->>> if(age >= 16){
->>> System.out.println("You can drive");
->>> }else if(age == 15){
->>> System.out.println("You can drive next year");
->>> }
->>> ```
->>> - else if statement is additonal part of if statement
->>> - can be multiple else if statement in a single if construct
->>> - one if statement can only run one outcome
-
->> else - used to specify outcome that will be run if one other conditions are met
->> debugging - the process of finding out and correcting erros in a program
-
-> ## Types of Errors
-
->> ```Compile-Time-Errors``` - Complier checks syntax
->> - syntax error - how you write your statements(your grammar)
->> - Spelling mistakes
->> - Punctuation errors
->> - Missing brackets, curly brackets, key words
->> - Incompatible types of data
->> - .class file not created
-
->> ```Logical Error``` - Hardest to detect/solve
->> - compiles and runs correctly but incorrect results
->> - wrong formula
->> - wrong approach taken
-
->> ```Run-time Error``` - occur during program execution
->> - causes program to terminate abnnormally
->> - try dividing by zero
-
-
-> ## Logical Statements
->> True/False
->> 3 basic logical operator
->> ```OR/AND/NOT```
-
->> **```AND```**: when all values are true
->> **```OR```**: when at least one value is true
->> **```NOT```**: flips the value of a statement
-
->> ### Truth Table
->> - Used to study logic by computer scientists
-
->>> | X | Y |X OR Y|X AND Y|
->>> |:--|:--|:-----|:------|
->>> |T|T|T|T|
->>> |T|F|T|F|
->>> |F|T|T|F|
->>> |F|F|F|F|
-
->> operator precendence - evaluate left to right
->> 1. AND( & & ) - checks first statement, if it is true, check the second one
->> 2. OR( | | ) - checks the first statement and second statement
->> 3. NOT( ! ) - reverses the statement
-
-> ## Loops
-
->> Allows coders to repeat code
->> Exit condition in loop
-
->> ```java
->> while(condition){
->> // do something
->> }
->> ```
-
->> ### While Loops
->> - consists of a condition statement that are executed while the condition is true
->> - types of conditions used in a while statement are the same as in the ```if statement```
->> - while the condition is true, repeat the statements in the loop
-
->>> ```java
->>> while(num <= 10){
->>> System.out.println("Enter a number higher than 10.");
->>> num = scan.nextInt();
->>> }
->>> ```
-
->> - the program continues repeating until the num is greater than 10
->> - there may be times when you may want to specify more than one condition
->> - no limit to the number of conditions, but should limit to 2 or 3
->> - can combine conditions(logical statements) using ```&&``` and ```||``` conditional operators
-
->>> ```java
->>> while(num >= 1 && num <= 10){ // runs until num is between 1 and 10
->>> num = myScanner.nextInt();
->>> }
->>> ```
-
->> Incrementing By One
->> ``` java
->> mynumber = mynumber + 1;
->> // is the same as:
->> mynumber += 1;
->> // is the same as:
->> mynumber++;
->>
->> ```
-
->> Why counter: To keep track of how many times a loop has executed
-
->> ```java
->> int counter = 0;
->> int guess = 0;
->> while(guess != 7){
->> System.out.println("Guess a number between 1 and 10");
->> guess = scan.nextInt();
->> counter++;
->> }
->> System.out.println("It took you " + counter + " tries!");
->> ```
-
-
->> ### For Loops
->> - include three distinct statements separated by semicolon
->> - first statement declares the counter variable
->> - second statement specifies exit condition
->> - third statement increments the counter variable after each iteration of the loop
->> - counter variable only exists within loop
-
->>> ```while``` and ```for``` loop: - may not need to run if condition is false
-
->>> ```java
->>> for(int i = 0; i < 10; i++){ // this loop runs 10 times
->>> // do stuff here
->>> }
->>> ```
-
->> ### Accumulator
->> - variables that add any value to a sum or total
->> - realize the need for the variable
->> - declare the variable
->> - initialize it (give it a start value, usually 0)
->> - accumulate the value in a loop (add the value to the variable)
-
->> ### Do while Loop
-
->>> They must run minimum once
->>> After running once, it checks the continue condition at the end of the iteration
-
->>> ```java
->>> do {
->>> // do stuff here
->>> }while(condition);
->>> ```
-
->>> Example
-
->>> ```java
->>> public static void main(String[]args){
->>> Scanner sc = new Scanner(System.in);
->>> int total = 0, value;
->>> do {
->>> System.out.println("Enter values to sum and 0 to quit");
->>> value = input.nextInt();
->>> total = total + value;
->>> }while(value != 0);
->>> System.out.println("Your total is: " + total);
->>> }
->>> ```
-
-> ### Random Number Generation
->> ### Method 1
-
->> ```java
->> import java.util.Random;
->> public class {
->> public static void main(String[]args){
->> Random randGen = new Random();
->> int randNumber = randGen.nextInt(100) + 1;
->> }
->> }
->> ```
-
->> ### Method 2
-
->> using Math class
-
->> ```java
->> int myRandNumber = (int) (Math.random() * 100) + 1;
->> ```
-
-> ## Reading From Files
->> ### Why read from files?
->> - speed
->> - less errors
->> - easier to read, individual cases
->> - get data from sources other than the keyboard
->> - changing info is easy (only on the file)
->> - more efficient (less time to test)
->> - large data can be entered quickly (less room for error)
->> - at the ```testing stage```, data can be carefully chosen to test the program
-
->> ### Intializing
->>> ```java
->>> Scanner fsc = new Scanner("myfile.txt");
->>> ```
-
->> ### Example Program
->>> ```java
->>> import java.io.File;
->>> import java.util.Scanner;
->>> public class ReadData {
->>> public static void main(String[]args) throws IOException{
->>> File file = new File("summerschool.txt");
->>> Scanner input = new Scanner(file);
->>> while(input.hasNext()) {
->>> String firstName = input.next();
->>> double avg = input.nextDouble();
->>> System.out.println(firstName + " " + avg);
->>> }
->>> input.close();
->>> }
->>> }
->>> ```
-
->> ### Why write from files? (store to disk)
->> - you can save it for future use
->> - print hard copy results and distribute it
->> - write to a retrievable medium
->> - store the info
->> - make it more available to others
->> - large data can be collected, stored, formatted acoording to needs
-
->> ```java
->> import java.io.PrintWriter; // can be used to create a file and write
->> // for example
->> output.println("hello world!"); output.printf("hello world!\n"); output.print("hello world!");
->> ```
-
->> ### Intializing
-
->>> ```java
->>> PrintWriter output = new PrintWriter("mytextfile.txt");
->>> ```
-
->> ### Example Program
-
->>> ``` java
->>> import java.io.File;
->>> import java.io.PrintWriter;
->>> public class PrintWriterExample {
->>> public static void main(String[]args) throws IOException {
->>> File myFile = new File("secretmessage.txt");
->>> PrintWriter output = new PrintWriter(myFile);
->>> output.println("hello");
->>> output.println("world!");
->>> out.close();
->>> }
->>> }
->>> ```
+### Strings
+ - String - a set of individual characters
+ - string start at zero - zero indexing
+ - an array of characters
+
+ - Char(acter) - hold the same type of information as a string - but only one character
+ - use single quotes rather than double quotes
+ - many different methods that can be used with char
+ - uses less memory than a string
+
+ ```java
+ String name = "Ms Andrighetti";
+ String firstThree, lastEleven;
+ firstThree = name.substring(0, 3);
+ lastEleven = name.substring(4, 15);
+ System.out.println(firstThree);
+ System.out.println(lastEleven);
+ ```
+
+- first character is index 0 because zero-indexed
+- substring specifies the first characters you want and the last character you don't want
+- if you try to access a point beyond the end of the String, you will get an error
+
+ - ```length()``` - tells you how many character are in a string
+ - length gives you the length of string not last index of the string
+ ```java
+ String word = "Hello";
+ int length = word.length();
+ System.out.println(length);
+ ```
+
+### Boolean Expressions
+ - can only have 2 possible value(true or false)
+ - compare must be compatible type
+
+ |Symbol|Meaning|
+ |:-----|:------|
+ |==|equal to|
+ |!=|not equal to|
+ |>|greater than|
+ |<|less than|
+ |>=|greater than or equal to|
+ |<=|less than or equal to|
+
+- ```Modulus operator (%)```: returns the remainder of 2 numbers
+- ```String```: stores characters / text
+- ```String comparison```: different from primitive type comparison
+ - cannot use ```==``` sign
+ - use boolean expression ```object1.equals(object2)```
+
+## Reading Input (Scanner Class)
+
+- ```import``` scanner class to use it
+- use
+```java
+import java.util.Scanner;
+```
+- to tell compiler to include scanner class in the .class file
+- line at very top of file
+- create scanner using
+```java
+Scanner myScanner = new Scanner(System.in);
+```
+
+ |To read this...|...Make this method call|
+ |:--------------|:-----------------------|
+ |a number with no decimal point in it|```nextInt()```|
+ |a number with a decimal point in it|```nextDouble()```|
+ |a word(ending in a blank space, for example)|```next()```|
+ |a line(or what remains of a line after you've already read some data from the line)|```nextLine()```|
+ |a single character(such as a letter, a digit or a punctuation character|```next.charAt(0)```|
+
+## Output
+ - using standard output system:
+
+ ```java
+ System.out.println()
+ ```
+ - this outputs to the console
+
+## Selection statements
+ - allow java to make a decision
+ - depending on decision, program will function differently each time it is run
+
+ ```java
+ if(condition){
+ //then perform some commands
+ // outcome
+ }
+```
+
+### Example:
+
+ ```java
+ int age = 17;
+ if(age >= 16){
+ // execute if condition
+ System.out.println("You are " + age);
+ System.out.println("You can learn to drive");
+ } // skips if condition not met
+```
+
+### ```=``` vs ```==```
+ - ```=```: assignment
+ - ```==```: comparison
+
+### if.... else if.... else
+
+ ```java
+ if(condition){
+ // statement1
+ } else{
+ // statement2
+ }
+
+ // -----------------------
+
+ if(num > 10){
+ System.out.println("Your number is greater than 10");
+ } else{
+ System.out.println("Your number is less than or equal to 10");
+ }
+ ```
+
+ - used when program needs to choose from a variety of situations
+ - use else if to specify another condition
+ - helps to control the flow of your program
+ - helps make decision when 3 or more conditions must be considered
+ - makes program more efficient
+
+```java
+ if(age >= 16){
+ System.out.println("You can drive");
+ } else if(age == 15){
+ System.out.println("You can drive next year");
+ }
+ ```
+ - else if statement is additonal part of if statement
+ - can be multiple else if statement in a single if construct
+ - one if statement can only run one outcome
+
+- else - used to specify outcome that will be run if one other conditions are met
+- debugging - the process of finding out and correcting erros in a program
+
+## Types of Errors
+
+### ```Compile-Time-Errors``` - Complier checks syntax
+- syntax error - how you write your statements(your grammar)
+ - Spelling mistakes
+ - Punctuation errors
+ - Missing brackets, curly brackets, key words
+ - Incompatible types of data
+ - ```.class``` file not created
+
+### ```Logical Error``` - Hardest to detect/solve
+ - compiles and runs correctly but incorrect results
+ - wrong formula
+ - wrong approach taken
+
+### ```Run-time Error``` - occur during program execution
+ - causes program to terminate abnnormally
+ - try dividing by zero
+
+
+## Logical Statements
+- True/False
+- 3 basic logical operator
+- ```OR/AND/NOT```
+
+- **```AND```**: when all values are true
+- **```OR```**: when at least one value is true
+- **```NOT```**: flips the value of a statement
+
+### Truth Table
+ - Used to study logic by computer scientists
+
+ | X | Y |X OR Y|X AND Y|
+ |:--|:--|:-----|:------|
+ |T|T|T|T|
+ |T|F|T|F|
+ |F|T|T|F|
+ |F|F|F|F|
+
+- operator precendence - evaluate left to right
+ 1. AND( & & ) - checks first statement, if it is true, check the second one
+ 2. OR( | | ) - checks the first statement and second statement
+ 3. NOT( ! ) - reverses the statement
+
+## Loops
+
+- Allows coders to repeat code
+- Exit condition in loop
+
+```java
+ while(condition){
+ // do something
+ }
+ ```
+
+### While Loops
+ - consists of a condition statement that are executed while the condition is true
+ - types of conditions used in a while statement are the same as in the ```if statement```
+ - while the condition is true, repeat the statements in the loop
+
+ ```java
+ while(num <= 10){
+ System.out.println("Enter a number higher than 10.");
+ num = scan.nextInt();
+ }
+ ```
+
+ - the program continues repeating until the num is greater than 10
+ - there may be times when you may want to specify more than one condition
+ - no limit to the number of conditions, but should limit to 2 or 3
+ - can combine conditions(logical statements) using ```&&``` and ```||``` conditional operators
+
+ ```java
+ while(num >= 1 && num <= 10){ // runs until num is between 1 and 10
+ num = myScanner.nextInt();
+ }
+ ```
+
+- Incrementing By One
+ ``` java
+ mynumber = mynumber + 1;
+ // is the same as:
+ mynumber += 1;
+ // is the same as:
+ mynumber++;
+ ```
+- Why counter: To keep track of how many times a loop has executed
+
+ ```java
+ int counter = 0;
+ int guess = 0;
+ while(guess != 7){
+ System.out.println("Guess a number between 1 and 10");
+ guess = scan.nextInt();
+ counter++;
+ }
+ System.out.println("It took you " + counter + " tries!");
+ ```
+
+
+### For Loops
+ - include three distinct statements separated by semicolon
+ - first statement declares the counter variable
+ - second statement specifies exit condition
+ - third statement increments the counter variable after each iteration of the loop
+ - counter variable only exists within loop
+
+ - ```while``` and ```for``` loop: - may not need to run if condition is false
+
+ ```java
+ for(int i = 0; i < 10; i++){ // this loop runs 10 times
+ // do stuff here
+ }
+ ```
+
+### Accumulator
+ - variables that add any value to a sum or total
+ - realize the need for the variable
+ - declare the variable
+ - initialize it (give it a start value, usually 0)
+ - accumulate the value in a loop (add the value to the variable)
+
+### Do while Loop
+
+- They must run minimum once
+- After running once, it checks the continue condition at the end of the iteration
+
+ ```java
+ do {
+ // do stuff here
+ } while(condition);
+ ```
+
+- #### Example
+
+ ```java
+ public static void main(String[]args){
+ Scanner sc = new Scanner(System.in);
+ int total = 0, value;
+ do {
+ System.out.println("Enter values to sum and 0 to quit");
+ value = input.nextInt();
+ total = total + value;
+ }while(value != 0);
+ System.out.println("Your total is: " + total);
+ }
+ ```
+
+### Random Number Generation
+
+### Method 1
+
+ ```java
+ import java.util.Random;
+ public class {
+ public static void main(String[]args){
+ Random randGen = new Random();
+ int randNumber = randGen.nextInt(100) + 1;
+ }
+ }
+ ```
+
+### Method 2
+
+- using Math class
+
+ ```java
+ int myRandNumber = (int) (Math.random() * 100) + 1;
+ ```
+
+## Reading From Files
+
+### Why read from files?
+ - speed
+ - less errors
+ - easier to read, individual cases
+ - get data from sources other than the keyboard
+ - changing info is easy (only on the file)
+ - more efficient (less time to test)
+ - large data can be entered quickly (less room for error)
+ - at the ```testing stage```, data can be carefully chosen to test the program
+
+### Intializing
+ ```java
+ Scanner fsc = new Scanner("myfile.txt");
+ ```
+
+### Example Program
+ ```java
+ import java.io.File;
+ import java.util.Scanner;
+ public class ReadData {
+ public static void main(String[]args) throws IOException{
+ File file = new File("summerschool.txt");
+ Scanner input = new Scanner(file);
+ while(input.hasNext()) {
+ String firstName = input.next();
+ double avg = input.nextDouble();
+ System.out.println(firstName + " " + avg);
+ }
+ input.close();
+ }
+ }
+ ```
+
+### Why write from files? (store to disk)
+ - you can save it for future use
+ - print hard copy results and distribute it
+ - write to a retrievable medium
+ - store the info
+ - make it more available to others
+ - large data can be collected, stored, formatted acoording to needs
+
+ ```java
+ import java.io.PrintWriter; // can be used to create a file and write
+ // for example
+ output.println("hello world!"); output.printf("hello world!\n"); output.print("hello world!");
+ ```
+
+### Intializing
+
+ ```java
+ PrintWriter output = new PrintWriter("mytextfile.txt");
+ ```
+
+### Example Program
+
+ ``` java
+ import java.io.File;
+ import java.io.PrintWriter;
+ public class PrintWriterExample {
+ public static void main(String[]args) throws IOException {
+ File myFile = new File("secretmessage.txt");
+ PrintWriter output = new PrintWriter(myFile);
+ output.println("hello");
+ output.println("world!");
+ out.close();
+ }
+ }
+ ```
# Unit 2: Arrays
-> ```Arrays```: a data structure that allow you to hold multiple pieces of data, in a single object
-> - hold a predetermined number of elements
-> - must be same type
-> ``` java
-> int, String, char, boolean, double, complex types
-> ```
-> - [] - square brackets means index
-> - arrays always start at 0 index
-> - must be assigned a fixed size
-> - use counted loop with array to do things
+- ```Arrays```: a data structure that allow you to hold multiple pieces of data, in a single object
+ - hold a predetermined number of elements
+ - must be same type
+ ``` java
+ int, String, char, boolean, double, complex types
+ ```
+ - [] - square brackets means index
+ - arrays always start at 0 index
+ - must be assigned a fixed size
+ - use counted loop with array to do things
-> ## Example:
+### Example:
->> ```java
->> // declare an array of 5 integer
->> int [] numArray = new int[5];
->> // set the 0 index of numArray to 123
->> numArray[0] = 123;
->> // get the array size
->> int arraySize = numArray.length;
->> ```
+ ```java
+ // declare an array of 5 integer
+ int [] numArray = new int[5];
+ // set the 0 index of numArray to 123
+ numArray[0] = 123;
+ // get the array size
+ int arraySize = numArray.length;
+ ```
-> ### Mid - program initialization of arrays
-> - can declare the array at the beginning ant set size
-> - All variable and arrays must be declared at the beginning of the program for proper conventions
->> ```java
->> // declare variables and array
->> String[] names;
->> int numValues;
->> System.out.println("How many names?");
->> numValues = scan.nextInt();
->> // initialize array
->> names = new String[numValues];
->> ```
+## Mid - program initialization of arrays
+ - can declare the array at the beginning ant set size
+ - All variable and arrays must be declared at the beginning of the program for proper conventions
+ ```java
+ // declare variables and array
+ String[] names;
+ int numValues;
+ System.out.println("How many names?");
+ numValues = scan.nextInt();
+ // initialize array
+ names = new String[numValues];
+ ```
-> ## Display
-> - Simply iterate throughout the array and just print out all the elements
-> - A ```for``` loop or ```while``` loop can be used
-> - Simple display code
+## Display
+ - Simply iterate throughout the array and just print out all the elements
+ - A ```for``` loop or ```while``` loop can be used
+ - Simple display code
->> ```java
->> System.out.print("The elements in the array are: ");
->> for(int i = 0; i < array.length; i++){
->> System.out.print(array[i] + " ");
->> }
->> System.out.println();
->> ```
+ ```java
+ System.out.print("The elements in the array are: ");
+ for(int i = 0; i < array.length; i++){
+ System.out.print(array[i] + " ");
+ }
+ System.out.println();
+ ```
-> ## Search
+## Search
-> - To iterate through in array, or to search an element
-> - Just loop through the array until you find the element
-> - Use ```length``` to iterate through the entire array
-> - Use appropriate comparators like ```==``` and ```.equals()```
-> - Simple search code
+ - To iterate through in array, or to search an element
+ - Just loop through the array until you find the element
+ - Use ```length``` to iterate through the entire array
+ - Use appropriate comparators like ```==``` and ```.equals()```
+ - Simple search code
->> ```java
->> int element = 12;
->> for(int i = 0; i < array.length; i++){
->> if(array[i] == element){
->> System.out.println("Element found at index: " + i);
->> break;
->> }
->> }
->> ```
+ ```java
+ int element = 12;
+ for(int i = 0; i < array.length; i++){
+ if(array[i] == element){
+ System.out.println("Element found at index: " + i);
+ break;
+ }
+ }
+ ```
-> ## Finding The Average
+## Finding The Average
-> - Sum all the elements of the list and divide by the number of elements
-> - Simple average finding code
+ - Sum all the elements of the list and divide by the number of elements
+ - Simple average finding code
->> ```java
->> int sum = 0;
->> for(int i = 0; i < array.length; i++){
->> sum += array[i];
->> }
->> double average = sum / array.length;
->> System.out.println("The average is: " + average);
->> ```
+ ```java
+ int sum = 0;
+ for(int i = 0; i < array.length; i++){
+ sum += array[i];
+ }
+ double average = sum / array.length;
+ System.out.println("The average is: " + average);
+ ```
-> ## Finding Min / Max
+## Finding Min / Max
->> ### Finding the Min
->> - Algorithm
+### Finding the Min
+ - Algorithm
->>> ```
->>> set the min to the first element, we assume its the minimum
->>> go through each element in the array, if we find an element that is smaller than the current min
->>> change the current min to it, we can use either Math.min() or the < operator
->>> after iterating through the entire list, the min will be the smallest number
->>> ```
+ ```
+ set the min to the first element, we assume its the minimum
+ go through each element in the array, if we find an element that is smaller than the current min
+ change the current min to it, we can use either Math.min() or the < operator
+ after iterating through the entire list, the min will be the smallest number
+ ```
->> - Code
->>> ```java
->>> int min = array[0];
->>> for(int i = 0; i < array.length; i++){
->>> if(array[i] < min){
->>> min = array[i];
->>> }
->>> }
->>> System.out.println("Smallest value is: " + min);
->>> ```
+ - Code
+ ```java
+ int min = array[0];
+ for(int i = 0; i < array.length; i++){
+ if(array[i] < min){
+ min = array[i];
+ }
+ }
+ System.out.println("Smallest value is: " + min);
+ ```
->> ### Finding the Max
->> - Algortihm
+### Finding the Max
+ - Algortihm
->>> ```
->>> set the max to the first element, we assume its the maximum
->>> go through each element in the array, if we find an element that is bigger than the current max
->>> change the current max to it, we can use either 'Math.max()' or the '>' operator
->>> after iterating through the entire list, the min will be the biggest number
->>> ```
+ ```
+ set the max to the first element, we assume its the maximum
+ go through each element in the array, if we find an element that is bigger than the current max
+ change the current max to it, we can use either 'Math.max()' or the '>' operator
+ after iterating through the entire list, the min will be the biggest number
+ ```
->> - Code
->>> ```java
->>> int max = array[0];
->>> for(int i = 0; i < array.length; i++){
->>> if(array[i] > max){
->>> max = array[i];
->>> }
->>> }
->>> System.out.println("Biggest value is: " + max);
->>> ```
+ - Code
+ ```java
+ int max = array[0];
+ for(int i = 0; i < array.length; i++){
+ if(array[i] > max){
+ max = array[i];
+ }
+ }
+ System.out.println("Biggest value is: " + max);
+ ```
# Unit 3: Sorting
- ```sorting```: the process of arranging a list of items into a well-defined order
- final list rearrangement of the original list
-> ## Bubble Sort
-> - when x numbers in array, loop x - 1 times
-> - The bubble sort algorithm works by swapping adjacent pairs in the list until all adjacent pairs are sorted in order, at which the entire list is sorted
-> - by making passes through the array, each pass moves from left to right
-> - the first pass compares element 1 and element 2 and swaps them if they are out of order, then compares element 2 and element 3 and swaps them if they are out of order, and so on
-> - the largest element is moved to the right
-> - for a length of n, there are n - 1 passes
+## Bubble Sort
+ - when x numbers in array, loop x - 1 times
+ - The bubble sort algorithm works by swapping adjacent pairs in the list until all adjacent pairs are sorted in order, at which the entire list is sorted
+ - by making passes through the array, each pass moves from left to right
+ - the first pass compares element 1 and element 2 and swaps them if they are out of order, then compares element 2 and element 3 and swaps them if they are out of order, and so on
+ - the largest element is moved to the right
+ - for a length of n, there are n - 1 passes
->> |Pass 1|Pass 2|Pass 3|Pass 4|
->> |:-----|:-----|:-----|:-----|
->> |```3 6``` 5 4 2|```3 5``` 4 2 6|```3 4``` 2 5 6|```3 2``` 4 5 6|
->> |3 ```6 5``` 4 2|3 ```5 4``` 2 6|3 ```4 2``` 5 6|2 3 4 5 6|
->> |3 5 ```6 4``` 2|3 4 ```5 2``` 6|3 2 4 5 6|
->> |3 5 4 ```6 2```|3 4 2 5 6|
->> |3 5 4 2 6|
+ |Pass 1|Pass 2|Pass 3|Pass 4|
+ |:-----|:-----|:-----|:-----|
+ |```3 6``` 5 4 2|```3 5``` 4 2 6|```3 4``` 2 5 6|```3 2``` 4 5 6|
+ |3 ```6 5``` 4 2|3 ```5 4``` 2 6|3 ```4 2``` 5 6|2 3 4 5 6|
+ |3 5 ```6 4``` 2|3 4 ```5 2``` 6|3 2 4 5 6|
+ |3 5 4 ```6 2```|3 4 2 5 6|
+ |3 5 4 2 6|
->> |Number of Elements|Number of Passes|Number of Comparisons|
->> |:-----------------|:---------------|:--------------------|
->> |4|3|6|
->> |5|4|10|
->> |6|5|15|
->> |7|6|21|
->> |8|7|28|
->> |9|8|36|
->> |10|9|45|
->> |```n```|```n - 1```|```n * (n - 1) / 2```|
+ |Number of Elements|Number of Passes|Number of Comparisons|
+ |:-----------------|:---------------|:--------------------|
+ |4|3|6|
+ |5|4|10|
+ |6|5|15|
+ |7|6|21|
+ |8|7|28|
+ |9|8|36|
+ |10|9|45|
+ |```n```|```n - 1```|```n * (n - 1) / 2```|
-> ## Algorithm
+## Algorithm
->> ```
->> repeat the following n -1 times
->> for each element in the array, starting at the first element
->> compare items in current positions with the element in the next position
->> if item in current position is greater than item in next position then
->> swap the 2 items using the following steps
->> temp = current list item
->> current list item = next list item
->> next list item = temp
->> ```
+ ```
+ repeat the following n -1 times
+ for each element in the array, starting at the first element
+ compare items in current positions with the element in the next position
+ if item in current position is greater than item in next position then
+ swap the 2 items using the following steps
+ temp = current list item
+ current list item = next list item
+ next list item = temp
+ ```
-> ## Code
+## Code
->> ```java
->> // array called list
->> for (int i = 0; i < list.length - 1; i++){
->> for(int j = 0; j < list.length - 1 - i; j++){
->> if(list[j] > list[j + 1]){
->> int temp = list[j];
->> list[j] = list[j + 1];
->> list[j + 1] = temp;
->> }
->> }
->> }
->> ```
+ ```java
+ // array called list
+ for (int i = 0; i < list.length - 1; i++){
+ for(int j = 0; j < list.length - 1 - i; j++){
+ if(list[j] > list[j + 1]){
+ int temp = list[j];
+ list[j] = list[j + 1];
+ list[j + 1] = temp;
+ }
+ }
+ }
+ ```
-> ```CompareTo(String)```
-> - result is a ```negative integer``` if this String object lexicographically(alphabetically) precedes the argument string
-> - result is a ```positive integer``` if this string object
-> - result is ```zero``` if the string are equal
+## ```CompareTo(String)```
+ - result is a ```negative integer``` if this String object lexicographically(alphabetically) precedes the argument string
+ - result is a ```positive integer``` if this string object
+ - result is ```zero``` if the string are equal
# Unit 4: Methods
-> ```methods``` - subprograms in java
-> - a group of programming statements that are given a name
-> two types of methods
-> - ```function-type methods``` - calculates and returns a value
-> - ```procedure-type methods``` - executes some commands and has a void return type
+- ```methods``` - subprograms in java
+ - a group of programming statements that are given a name
+- two types of methods
+ - ```function-type methods``` - calculates and returns a value
+ - ```procedure-type methods``` - executes some commands and has a void return type
-> ## Why Methods
-> - allows for code to be reused throughout a program
-> - more efficient and neatly organized programs
-> - allow for easy modification later on
+## Why Methods
+ - allows for code to be reused throughout a program
+ - more efficient and neatly organized programs
+ - allow for easy modification later on
-> ## Examples:
->> ```java
->> public static int square(int number){
->> return number * number;
->> }
->>
->> public static void printHelloWorld(){
->> System.out.println("Hello World!");
->> }
->> ```
+### Examples:
+ ```java
+ public static int square(int number){
+ return number * number;
+ }
->> int - return - type
->> square - method name
->> int number - formal parameter
+ public static void printHelloWorld(){
+ System.out.println("Hello World!");
+ }
+ ```
-> ## Built in methods
+- int - return type
+- square - method name
+- int number - formal parameter
->> |Method|Description|
->> |:-----|:----------|
->> |```Math.abs(x)```| returns the absolute value of the paramter x|
->> |```Math.random()```|returns a pseudorandom value uniformally distributed between 0 and 1|
->> |```Math.round(x)```|returns the value of x rounded according to the usual arithmetic rules|
->> |```Math.ceil(x)```|returns the value of x rounded up to the nearest integer|
->> |```Math.floor(x)```|returns the value of x rounded down to the nearest integer|
->> |```Math.max(x, y)```|returns the greatest of values x and y|
->> |```Math.min(x, y)```|returns the smallest of values x and y|
->> |```Math.sqrt(x)```|returns the value of the square root of x|
->> |```Math.pow(x, y)```|returns the value if x raised to the power of y|
->> |```Math.PI```|returns the double value of the mathemetical π|
->> |```.charAt(x)```|returns the character at index x|
->> |```.substring(st, ed)```|returns the string beginning at st and ending at ed(exclusive)|
->> |```.toLower()```|returns the lower-cased version of the string|
->> |```.toUpper()```|returns the upper-cased version of the string|
->> |```.split(regex)```|splits the string at index(s) where the ```regex``` appears and returns an array of strings|
->> |```isCharacter(x)```|checks if x is an character|
+## Built in methods
-> ## More on Methods
->> - ```signature``` - method name and parameter
->> - if method is to be used outside the class in which it is defined, it must be declared as a public in the class
->> - call or invoke a method to use it
->> - ```formal parameter``` - the names of the parameter accepted in the signature
->> - ```actual parameter``` - the values passed into a method
->> - if no parameters, empty set of parentheses are used
->> - ```java
->> c.readInt();
->> ```
+ |Method|Description|
+ |:-----|:----------|
+ |```Math.abs(x)```| returns the absolute value of the paramter x|
+ |```Math.random()```|returns a pseudorandom value uniformally distributed between 0 and 1|
+ |```Math.round(x)```|returns the value of x rounded according to the usual arithmetic rules|
+ |```Math.ceil(x)```|returns the value of x rounded up to the nearest integer|
+ |```Math.floor(x)```|returns the value of x rounded down to the nearest integer|
+ |```Math.max(x, y)```|returns the greatest of values x and y|
+ |```Math.min(x, y)```|returns the smallest of values x and y|
+ |```Math.sqrt(x)```|returns the value of the square root of x|
+ |```Math.pow(x, y)```|returns the value if x raised to the power of y|
+ |```Math.PI```|returns the double value of the mathemetical π|
+ |```.charAt(x)```|returns the character at index x|
+ |```.substring(st, ed)```|returns the string beginning at st and ending at ed(exclusive)|
+ |```.toLower()```|returns the lower-cased version of the string|
+ |```.toUpper()```|returns the upper-cased version of the string|
+ |```.split(regex)```|splits the string at index(s) where the ```regex``` appears and returns an array of strings|
+ |```isCharacter(x)```|checks if x is an character|
-> ## Return Type Methods
-> - public static ```return type``` ```method name```(parameters)
-> - Example:
->> ```java
->> public static int square(int num1){
->> // do stuff here
->> }
->> ```
+## More on Methods
+ - ```signature``` - method name and parameter
+ - if method is to be used outside the class in which it is defined, it must be declared as a public in the class
+ - call or invoke a method to use it
+ - ```formal parameter``` - the names of the parameter accepted in the signature
+ - ```actual parameter``` - the values passed into a method
+ - if no parameters, empty set of parentheses are used
+ - ```java
+ c.readInt();
+ ```
-> ## Void Type Methods
-> - public static void ```method name```(parameters)
-> - Example:
->> ```java
->> public static void drawPicture(){
->> // do stuff here
->> }
->>
->> public static void draw4Circles(int x1, int y1, int x2, int y2){
->> // do stuff here
->> }
->> ```
+## Return Type Methods
+ - public static ```return type``` ```method name```(parameters)
+ - Example:
+ ```java
+ public static int square(int num1){
+ // do stuff here
+ }
+ ```
-> ## Java language - Strongly typed
-> - meaning you are not allowed to assign a value to a variable that is consistent with its declare type
+## Void Type Methods
+- public static void ```method name```(parameters)
-> **```Scope of variable```** - the part of the program over which the variable can be accessed or referenced
-> - referes to the ```accessibility``` of a variable
-> - variables cannot be accessed before they are declared
+### Example:
+ ```java
+ public static void drawPicture(){
+ // do stuff here
+ }
+
+ public static void draw4Circles(int x1, int y1, int x2, int y2){
+ // do stuff here
+ }
+ ```
-> Variables can be declared in several different places
-> - class bodies (referred to as global or class level variables)
-> - as parameters to methods(in method signature)
-> - in a method body
-> - in a statement block (like a loop or a while loop)
+### Java language - Strongly typed
+ - meaning you are not allowed to assign a value to a variable that is consistent with its declare type
->> ```java
->> public class VariableExample{
->> static Scanner myScanner = new Scanner(System.in);
->>
->> public static void main(String[]args){
->> // main method
->> }
->> }
->> ```
+- **```Scope of variable```** - the part of the program over which the variable can be accessed or referenced
+ - referes to the ```accessibility``` of a variable
+ - variables cannot be accessed before they are declared
-> - Description of Example
-> - variable myScanner is declared outside of the main method in the class level
-> - the variable is considered to be a global variable that can be accessed anywhere in the class
-> - for now, global variables should have the keyword ```static``` preceding the declaration
+- Variables can be declared in several different places
+ - class bodies (referred to as global or class level variables)
+ - as parameters to methods(in method signature)
+ - in a method body
+ - in a statement block (like a loop or a while loop)
-> - In methods
-> - a method may declare local variable in the body of the method for use onlyin that method
-> - variable may also be declared in the parameter list - only can be accessed in the method
+ ```java
+ public class VariableExample{
+ static Scanner myScanner = new Scanner(System.in);
->> ```java
->> public static int thirdPower(double number){
->> int cube; // local variable
->> cube = number * number * number;
->> return cube;
->> }
->>
->> public static double thirdPower(double number){
->> double cube;
->> cube = number * number * number;
->> return cube;
->> }
->> ```
+ public static void main(String[]args){
+ // main method
+ }
+ }
+ ```
-> - variable cube in thirdpower is local to that method
-> - local variables cannot be accessed from outside of the method
+ - Description of Example
+ - variable myScanner is declared outside of the main method in the class level
+ - the variable is considered to be a global variable that can be accessed anywhere in the class
+ - for now, global variables should have the keyword ```static``` preceding the declaration
-> - In blocks of code
-> - variables defined in a block are only accessible from within the block
-> - the scope of the variable is the block in which it is defined
+ - In methods
+ - a method may declare local variable in the body of the method for use onlyin that method
+ - variable may also be declared in the parameter list - only can be accessed in the method
->> ```java
->> for(int x = 0; x < 5; x++){
->> System.out.println(x);
->> }
->> ```
->> - the variable x can only be accessed in the for loop
+ ```java
+ public static int thirdPower(double number){
+ int cube; // local variable
+ cube = number * number * number;
+ return cube;
+ }
-> ## Method void return type
-> - return type void means that a method will not return a value
-> - the method can still have parameter when the return type is void
+ public static double thirdPower(double number){
+ double cube;
+ cube = number * number * number;
+ return cube;
+ }
+ ```
-> ## Naming conventions
-> - method names should indicate an action
-> - verbs make good methods names
-> - methods names should begin with a lowercase letter and then an uppercase letter should begin with each word within the name
-> - method names may not contain spaces
+ - variable cube in thirdpower is local to that method
+ - local variables cannot be accessed from outside of the method
-> ## Pass By Value
+ - In blocks of code
+ - variables defined in a block are only accessible from within the block
+ - the scope of the variable is the block in which it is defined
->> ```java
->> public static void drawBar(int length){
->> for(int i = 0; i < length; i++){
->> System.out.print("* ");
->> }
->> System.out.println();
->> }
->> ```
+ ```java
+ for(int x = 0; x < 5; x++){
+ System.out.println(x);
+ }
+ ```
+ - the variable x can only be accessed in the for loop
-> - means that when a method is called, a ```copy``` of the value of each argument is passed to the method
-> - this copy can be changed inside the method, however such a change will have no effect on the actual argument
-> - copies of the actual parameter values from main are sent to the methods, where they become ```foramal parameters```. When the method is finished, the copies are discarded. The actual ```paramter``` values remain unchanged. Notice that nothing is returned in the above method and how values ```a``` and ```b``` are not changed in the main method when passed in the method below
+## Method void return type
+ - return type void means that a method will not return a value
+ - the method can still have parameter when the return type is void
->> ```java
->> public static void main(String[]args){
->> int a = 0, b = 10;
->> System.out.println("The starting value of a and b are: " + a + " and " + b);
->> change(a, b);
->> System.out.println("The values of a and b are: " a + " and " + b);
->> }
->> public static void change(int a, int b){
->> a = 999;
->> b = 21;
->> }
->> ```
+## Naming conventions
+ - method names should indicate an action
+ - verbs make good methods names
+ - methods names should begin with a lowercase letter and then an uppercase letter should begin with each word within the name
+ - method names may not contain spaces
-> ## Pass by reference
+## Pass By Value
-> - occurs when an object is passed to a method, its memory address location (its ```reference```) is used
-> - ```Arrays``` behave like objects, their memory location is passed to the method
-> - that means that when an array is manipulated in the method that we are actually ```changing``` the array
-> - be cautious when sending an array in the method as it will change the data in the original array
+ ```java
+ public static void drawBar(int length){
+ for(int i = 0; i < length; i++){
+ System.out.print("* ");
+ }
+ System.out.println();
+ }
+ ```
->> ```java
->> public static void main(String[]args){
->> int array[] = new int[4];
->> a[0] = 1000;
->> a[1] = 2000;
->> a[2] = 3000;
->> a[3] = 4000;
->> System.out.print("The values of the array are: ");
->> for(int i = 0; i < a.length; i++){
->> System.out.print(a[i] + " ");
->> }
->> System.out.println();
->> System.out.println();
->>
->> change(array);
->>
->> System.out.print("The values of the array are: ");
->> for(int i = 0; i < a.lengh; i++){
->> System.out.print(a[i] + " ");
->> }
->> System.out.println();
->> }
->> public static void change(int array[]){
->> array[0] = 1;
->> array[1] = 2;
->> array[2] = 3;
->> array[3] = 4;
->> }
->> ```
+ - means that when a method is called, a ```copy``` of the value of each argument is passed to the method
+ - this copy can be changed inside the method, however such a change will have no effect on the actual argument
+ - copies of the actual parameter values from main are sent to the methods, where they become ```foramal parameters```. When the method is finished, the copies are discarded. The actual ```paramter``` values remain unchanged. Notice that nothing is returned in the above method and how values ```a``` and ```b``` are not changed in the main method when passed in the method below
+
+ ```java
+ public static void main(String[]args){
+ int a = 0, b = 10;
+ System.out.println("The starting value of a and b are: " + a + " and " + b);
+ change(a, b);
+ System.out.println("The values of a and b are: " a + " and " + b);
+ }
+ public static void change(int a, int b){
+ a = 999;
+ b = 21;
+ }
+```
+
+## Pass by reference
+
+ - occurs when an object is passed to a method, its memory address location (its ```reference```) is used
+ - ```Arrays``` behave like objects, their memory location is passed to the method
+ - that means that when an array is manipulated in the method that we are actually ```changing``` the array
+ - be cautious when sending an array in the method as it will change the data in the original array
+
+ ```java
+ public static void main(String[]args){
+ int array[] = new int[4];
+ a[0] = 1000;
+ a[1] = 2000;
+ a[2] = 3000;
+ a[3] = 4000;
+ System.out.print("The values of the array are: ");
+ for(int i = 0; i < a.length; i++){
+ System.out.print(a[i] + " ");
+ }
+ System.out.println();
+ System.out.println();
+
+ change(array);
+
+ System.out.print("The values of the array are: ");
+ for(int i = 0; i < a.lengh; i++){
+ System.out.print(a[i] + " ");
+ }
+ System.out.println();
+ }
+ public static void change(int array[]){
+ array[0] = 1;
+ array[1] = 2;
+ array[2] = 3;
+ array[3] = 4;
+ }
+ ```
# Unit 5: Software Design Process
-> ## 5 Steps
+## 5 Steps
->> |Step #|Description|
->> |:-----|:----------|
->> |Analysis|Also called ```problem solving```, its the process of ```breaking problems down into smaller more manageable parts```|
->> |Design|In this stage, an ```algorithm``` which is a set of instructions defined to solve the problem|
->> |Implementaion|Also referred to as ```coding```. Where you express the algorithm in a ```programming language```|
->> |Testing|Invlovles the running of the program will a full range of data. Valid data: ```the data the user should be inputting.``` Invalid data: ```incorrect or unexpected data```|
->> |Maintenance|```Maintaining a program over time so that any changes are needed are incorporated```|
+ |Step #|Description|
+ |:-----|:----------|
+ |Analysis|Also called ```problem solving```, its the process of ```breaking problems down into smaller more manageable parts```|
+ |Design|In this stage, an ```algorithm``` which is a set of instructions defined to solve the problem|
+ |Implementaion|Also referred to as ```coding```. Where you express the algorithm in a ```programming language```|
+ |Testing|Invlovles the running of the program will a full range of data. Valid data: ```the data the user should be inputting.``` Invalid data: ```incorrect or unexpected data```|
+ |Maintenance|```Maintaining a program over time so that any changes are needed are incorporated```|
-> **```valid data```**: the data the user should be inputting
-> **```invalid data```**: ```incorrect``` or ```unexpected``` data
-> **```algorithm```**: a set of ```insturction``` defined to ```solve``` the problem
-> **```Well designed program```**: a program that ```reliably``` solves the problem it was created to solve
-> **```Waterfall Model```**: A flow chart, each phase must be completed before the next one
+- **```valid data```**: the data the user should be inputting
+- **```invalid data```**: ```incorrect``` or ```unexpected``` data
+- **```algorithm```**: a set of ```insturction``` defined to ```solve``` the problem
+- **```Well designed program```**: a program that ```reliably``` solves the problem it was created to solve
+- **```Waterfall Model```**: A flow chart, each phase must be completed before the next one
-> ## Programmers
-> - Programmers have the abilites to:
-> - 1. Solve Problems
-> - 2. Organize information
-> - 3. Design Solutions
-> - 4. Express instructions in a logical sequence
-> - 5. Input them into a computer
+## Programmers
+ - Programmers have the abilites to:
+ 1. Solve Problems
+ 2. Organize information
+ 3. Design Solutions
+ 4. Express instructions in a logical sequence
+ 5. Input them into a computer
-> - My Points for abilities and characteristics:
-> - 1. Communicate, collabration
-> - 2. Present their solution
-> - 3. Work as a team
+- My Points for abilities and characteristics:
+ 1. Communicate, collabration
+ 2. Present their solution
+ 3. Work as a team
# Unit 6: Problem Solving
-> ## Code Correction
-> - ```;``` semicolons
-> - Accessing outside of specified range of a ```string``` or ```array```
-> - Missing or extra brackets ```{}```, ```()```, ```[]```
-> - Undeclared variables, scope of an variable
-> - Wrong method calls
-> - incorrect syntax
+## Code Correction
+ - ```;``` semicolons
+ - Accessing outside of specified range of a ```string``` or ```array```
+ - Missing or extra brackets ```{}```, ```()```, ```[]```
+ - Undeclared variables, scope of an variable
+ - Wrong method calls
+ - incorrect syntax
-> ## Problem solving
-> - **Debugging**
-> - Printing out code
-> - Rubber ducking your code
+## Problem solving
+ - **Debugging**
+ - Printing out code
+ - Rubber ducking your code
# Credits
-> Creator, Editor: --> magicalsoup (ME)!
-> Helper, Information Provider(s): --> Matthew Wong, Samantha Ouyang
-
-
-
-
+- Creator, Editor: --> magicalsoup (ME)!
+- Helper, Information Provider(s): --> Matthew Wong, Samantha Ouyang