Java Intro Pocket Guide

Data Structures
what's a data structure? What's an Array? What's an ArrayList? What's a LinkedList?	A data structure is a feature that supports storing and processing data and maintaining relationships between data. An array in Java is a data structure that stores a fixed number of items the same type or class, either all primitives or all objects. A 2D array is an array of arrays. An ArrayList instance is a data structure that can be added to dynamically. ArrayLists can only store objects, not primitives. A LinkedList instance is a data structure that can be added to dynamically. LinkedLists store objects called nodes. Nodes include a pointer to the next element (single linked list) or both a pointer to the next element and a pointer to the previous element (double linked list).
Arrays
Is an array an instance? How is an array declared? How are array elements accessed? Is it easy to sequence through an array? What key algorithms are used with arrays	An array is an object itself and has to be both declared and instantiated to make space for the number of items. An array in Java is of fixed size. Array elements are accessed using square brackets and an index, or subscript, arrayName[index] index starts at 0 as arrays are zero-based. The index is valid between 0 and 1 less than the number of elements in the array. An invalid index results in an out of bounds error. You can use loops to traverse an array, for loop, enhanced for loop, while loop. There are standard array algorithms, for searching, sorting, finding max/min/average. Some useful algorithms: Linear Search Binary Search Finding the average value Finding the min or max value Insert Sort Select Sort See link, Array Algorithms below, check code & efficiency. The number of elements in an array is given by arrayName.length; This is the length property, be careful not to include the parentheses, (). You can declare an array of primitive types, like ints, int[] numbers; This does not allocate space in memory to store the array, or specify how many elements the array will hold. So, the array should be newed up as well. numbers = new int[5]; This can be done with one line of code. int[] numbers = new int[5]; An array of objects, like SoccerPlayer[] team = new SoccerPlayer[11]; ... can be created in the same way. In a situation where the size of the array and variables of the array are already known, array literals (initializer list) can be used. Here is an example. int[] codes = new int[]{ 101,222,373,444,555}; Note, the length determines the length of the new array.You can drop the 'new int[]'' part in recent versions of Java. Given array of ints, players for (int index = 0; index < arr.length; index++) { System.out.println(arr[index]); } for (int index = 0; index < team.length; index++) { System.out.println(team[index].getName()); } Given array of ints, players for (int item : arr) { System.out.println(item); } for (SoccerPlayer player : team) { System.out.println(player.getName()); } Given array of ints, players, int[] arr = {1,2,3,4,5,6,7,8,9}; int index = 0; while (index < arr.length) { System.out.println(arr[index]); index++; } int index = 0; while (index < team.length) { System.out.println(team[index].getName()); index++; }
ArrayLists
How are ArrayLists different from arrays? Is an ArrayList an instance? How is an ArrayList object declared? What methods are used for ArrayLists? How are elements accessed? Is it easy to sequence through an ArrayList instance? What key algorithms are used with ArrayLists	ArrayList instances dynamically grow (you can add more elements) and shrink (you can remove elements). So, ArrayLists are flexible and are not of fixed size, like Arrays. An ArrayList instance has a core Array - whenever a new item is added or removed, a new array is created behind the scenes. ArrayList instances can only store references, not primitives. So, if required to store doubles, ints or booleans, the wrapper classes are used. The ArrayList class is imported into a Java application. The class, ArrayList, is newed up/instantiated to create an ArrayList object. Methods commonly used are get, set, remove, add. Elements are accessed by using the get method and a valid index. for, while, enhanced for loops (and more) are used to traverse or sequence through an ArrayList instance. Standard algorithms are used to process elements in an ArrayList instance. So, what's the difference between Array and ArrayList?
LinkedLists
How is LinkedList different from ArrayList? Is a LinkedList an instance? How is a LinkedList declared? What methods are used for LinkedLists? How are elements accessed? Is it easy to sequence through a LinkedList ? Why would you use a LinkedList?	Linked Lists dynamically grow (you can add more elements) and shrink (you can remove elements), just like ArrayLists. LinkedLists differ from ArrayLists in that they are not based on arrays. They store data inside nodes, which can be set up in 2 ways : as a single linked list with just a pointer to the next node, ...or as a double linked list, which uses pointers to both the next and the previous node.This is the data structure demonstrated in the Java LinkedList class. The LinkedList class is imported into a Java application. The class, LinkedList, is newed up/instantiated to create a reference to the first node in the list. LinkedList methods commonly used mirror ArrayList, and include some targeted methods for increased efficiency. Elements are accessed by using the get method and a valid index. for, while, enhanced for loops (and more) are used to traverse or sequence through a LinkedList. So, what's the difference between ArrayList and LinkedList? Why use one instead of the other?
2D Arrays
How is a 2D Array object declared? How are elements accessed? Is it easy to sequence through a 2D Array instance? Can 2D arrays have out of bounds errors? What's Row Major Order? What's Column Major Order?	A 2D array is an array of arrays, and has rows and columns similar to a matrix. Here, the number of elements in a row, is the same for each row. ------------------- \| 😀 \| 😀 \| 😀 \| ------------------- \| 😀 \| 😀 \| 😀 \| ------------------- \| 😀 \| 😀 \| 😀 \| ------------------- 2D arrays have to be newed up before being used, specifying the exact number of rows and columns. A 2D Array is declared using Java syntax, with double brackets, [][], and a specification of the type/class being stored. SoccerPlayer[][] teams = new SoccerPlayer[3][3]; // 3 rows, 3 columns 2D Array numbers holds 3 rows and 3 columns of primitives, 2D array players holds instances of class SoccerPlayer. int[][] numbers = new int[3][3]; SoccerPlayer[][] players = new SoccerPlayer[3][3]; 2D Array instances can be declared and initialized using Object Initialization Syntax, with an initializer list. Important! Remember to new up the 2D array, or use an initializer list before accessing an element! 2D arrays are accessed using row and column. int[][] numbers = { {1,2,3}, {4,5, 6}, {7,8,9} }; numbers[1][2] is in red, this element is on row 1 and column 2. Valid index values for rows in a 2D array are from 0 to the length of the array, less one. Valid index values for columns in a 2D array are from 0 to the length of a row, less one. See best practices for getting the last element in the 2D array. Row-Major Order and Column-Major Order describe how the 2D array is read, either across rows or down columns. 2D arrays are traversed using nested loops, for, while, enhanced for, using Row major Order or Column Major Order.

Primitive data types, reference types

How do primitive data types and reference types differ?

Primitives represent values, of known storage requirement. A reference is the beginning memory address of data stored in computer memory.

Know the bit requirements for primitive data types - boolean, int, double

Arrange the data types in order of least amount of storage: double, boolean, int

booleans occupy a byte (8 bits) or less, ints occupy 32 bits and doubles take up 64 bits

Be aware of the Wrapper classes and how to use them

Associate the primitive with the correct wrapper class.
Describe auto-boxing and un-boxing as these terms relate to primitives and references.

Primitive	Wrapper Class
int	Integer
double	Double
boolean	Boolean

Integer num1 = new Integer(7);
num1 = 3; // Auto-boxing, Java 'boxes' the int
int num2 = num1; // Un-boxing, Java gets value of Integer instance

Assigning a value to a String instance
How are String instances initialized?	String instances are objects, their value is a memory address or reference. The content of that memory address is the content of the string instance. You can new up (instantiate) a String instance or you can assign a string literal. String firstName = "Jane"; String lastName = new String("Blake");
Comparing Strings
What is the correct way to compare strings?	Strings are objects, their value is a memory address. The content of that memory address is the content of the string instance. Always use the equals method to compare strings. String name1 = "Jane"; String name2 = new String("Jane"); if (name1.equals(name2)) System.out.println("Same name!");
Immutability implications
Can strings be changed? What happens when a string is passed into a method and then modified?	Strings are immutable, they never change after they have been initialized. Instead, a new string instance is created. String name = "Jane"; // this might be at memory address 0x24B76A73 name = name + " Newport"; // new instance, maybe memory address 0x712BD7333 Given method, public int changer(String name, int age) { name += "<Last Name>"; age += 1; } In the runner code, String pName = "<First Name>"; int pAge = 21; changer(pName, pAge); Java is Pass By Value which means that only the value of a variable is passed to a method or function. In the case of references, Java is termed Pass By Object Reference. When a reference is passed to a method, the method can access the parts of the object. However, because strings are immutable, when a string instance is modified, a new string is created. This means that the value of the string in the calling code does not reflect any changes when the method returns. So, pName is still set to "<First Name>". In the example, after method changer is called, pAge does not change either and is still set to 21.

Class
What is a class? What are class analogies?	A class is a software template for creating a software model, called an object. Think of an achitectural blueprint as a class, and the house built from this, as an object.
Object Oriented Programming
How does a Class relate to OOP? What is OOP?	Object Oriented Programming (OOP) is a software engineering paradigm that uses data models called objects, as the basis of the application. Objects are created from templates called classes. The 4 tenets of object oriented programming are Abstraction - part of the design prcess in identifying classes Polymorphism - how different objects respond in differentiated ways to the same request Inheritance - the ability for one class, the subclass, to use the code base of another class, the superclass Encapsulation - keeping data and logic subsumed within a class
The structure of a class
How is a class declared? What is an attribute? What's a method?	A class is a software template for creating a data model called an object, or for acting as a repository for code that can be called by using the class name. A class is typically declared public so as to be visible to client code. A class defines properties called attributes. These properties are called instance variables if they apply to the instance created on instantiation. They are called class variables if they apply to the class. A class defines methods - these are blocks of code given a label and a return type/class, as well as an optional list of data passed into the code block - parameters. A method describes what the object can do, and can apply to an instance (instance method) or class (class method). Constructors, accessors and mutators are special methods. public class SoccerPlayer { <Attributes> <Constructors> <Accessors & Mutators> <other methods> }
Attributes and how they are accessed
Are attributes protected? How are attribute values seen?	In this example, the class is SoccerPlayer, and the attributes are shown. public class SoccerPlayer { // These properties can only be accessed directly // from inside the SoccerPlayer class private String name; private String position; private String club; The attributes (also called properties) defined are name, position and club. These are declared private by convention. This is so that they can only be accessed directly from within the object itself. From outside, calling code uses getters and setters (accessors and mutators). // Setters public void setName(String playerName) { name = playerName; } …. // Getters public String getName() { return name; } …… An instance method is called on the object or instance, and an instance variable's value is tied to the specific object. Important! An instance has to exist before an instance method can be called. SoccerPlayer player = new SoccerPlayer(); player.setName("Harry Kane"); Variable, player, is an instance of SoccerPlayer. Attribute, name, has been set to "Harry Kane".
Static attributes and methods
What is a static variable? What is a static method?	A class, or static, method is called on the class, and a static variable's value is retained because it is associated with a class. (using the class name). The keyword, static, is used to indicate that the attribute or the method is bound to the class. public static int numberOfPlayers; // Static Method public static void playerRequirements() { System.out.println("Players must be 18 years or older."); } This method can be called using just the class name, SoccerPlayer.playerRequirements(); The static variable can be accessed and incremented each time a constructor is called, and the number of players created can be tallied. SoccerPlayer.numberOfPlayers += 1; The class is instantiated or newed up, into an object or istance. Constructors are special methods responsible for creating an instance from a class.
Constructors
What's a constructor? Can constructors be overloaded? What happens if no constructor is declared?	A constructor is a special method that is instrumental in instantiating (newing up) an instance from a class. If no constructor is declared, then Java allows for the defualt or empty constructor to be used. SoccerPlayer player = new SoccerPlayer(); Once a constructor is declared, then the empty constructor must be added to the constructor declarations. public SoccerPlayer() { // empty constructor } // Parameterized constructor public SoccerPlayer(String name, double age, String position, String club) { this.name = name; this.age = age; this.position = position; this.club = club; }

Creating Objects
How are objects created? What is the role of the constructor?	Objects (also called instances) are newed up (instantiated) from a class definition, like SoccerPlayer, below. public class SoccerPlayer { ..... } SoccerPlayer player = new SoccerPlayer(); SoccerPlayer player2 = new SoccerPlayer("Harry Kane", 27, "Striker", "Tottenham Hotspurs"); The constructor is involved in this process, which creates space in memory for storing the new object.
Comparing Objects
How can you tell if objects are the same? What's an alias? When are objects aliases of each other?	Objects are references to locations in computer memory, that contain information. SoccerPlayer player = new SoccerPlayer(); player.setName("Harry Kane"); player.setAge(27); player.setPosition("Striker"); player.setClub("Tottenham Hotspurs"); // Using a different constructor, SoccerPlayer player2 = new SoccerPlayer("Harry Kane", 27, "Striker", "Tottenham Hotspurs"); It looks like both players have the same information, but they do point to different memory locations. So, a comparison with the equality operaor will yield false. In order to compare the content, an equals method is needed. public boolean equals(SoccerPlayer player) { if (this.name.equals(player.getName()) && this.age == player.getAge() && this.position.equals(player.getPosition()) && this.club.equals(player.getClub())) return true; else return false; } After an assignment, things change, player = player2; Now, player and player2 point to the same memory location and they really are the same in every way, memory address and content. The equality operator, ==, returns true! if (player == player2) System.out.print("Aliases!!!!");

Inheritance
What is inheritance? How is inheritance useful? Can a class inherit from more than one other? Is inheritance part of OOP?	A class is a software template for creating a software model, called an object. Inheritance allows the reuse of the code from a class, called the parent class or superclass, as the basis for another class, called the child class or subclass. Reuse of code and logic already developed in a parent class results in less lines of code and easier maintenance. In Java, a class can only inherit from one other class, we say it doesn't support multiple inheritance. Inheritance is one of the 4 tenets of Object Oriented Programming!
The Mechanics of Inheritance
How is inheritance done in Java? What is overriding?	A class is designated as a subclass of another class, with the keyword, . A subclass can rewrite a method with the same signature as in the superclass. When this method is called on an instance of the subclass, the method belonging to the subclass is called. The superclass' method is overridden by the method in the subclass.
Polymorphism
What's Polymorphism? What's the link between inheritance and polymorphism?	Polymorphism is defined as the ability of different objects (related via inheritance) to respond to the same request in different ways. A subclass can override a method defined in the superclass, and thus respond in a different way to an instance of the superclass.
Class Cast Exceptions
What's a Class cast Exception?	A class cast exception occurs when an object is instantiated using a subclass, but cast to the parent class.

Structure of a method
What's a method? What's a method header? What does 'return' mean? Do methods always return stuff?	Methods are blocks of code, given a name, and an optional set of values to be passed in to the method from the calling code. Methods also specify what, if any, information is to be passed back from the method to the calling code. This comprises the method header. Methods are associated with a class or an object and are called in this context, as opposed to a free standing function. <(optional)accessibility modifier> <return type> <method name> (<parameter list >(optional)) { < Body of the method > <return value;>(based on return type) } If return type is int, then an int should be returned to the calling code. If the return type is specified as void, then no return value is expected. public double distanceToTopOfGoal(double distanceFromGoal) { double distance = Math.sqrt(Math.pow(distanceFromGoal, 2) + Math.pow(GOAL_HEIGHT_IN_FT - 0.3, 2)); return distance; } Above, the method is called distanceToTopOfGoal, it returns a double value to the calling code, and is accessible from client code because of the public accessibility modifier. A value, distanceFromGoal, which is of type double, is passed into the method.
Parameters
What are formal parameters? What are actual parameters? Does the order of the parameters matter?	In the method definition, formal parameters are the values that are specified as the values expected to be passed in, in the call. The method below, isProlificScorer, is defined in a class called SoccerClub, and is an instance method. public String isProlificScorer(int goals, String playerName) { if (goals > MAX) { return playerName + " is a prolific scorer!"; else return playername + " should keep practicing!"; } goals and playername are formal parameters. In the call, actual parameters give values to the formal parameters. SoccerClub club = new SoccerClub(); club.isProlificScorer(27, "Harry Kane"); In the method, goals has a value of 27, and playerName is set to "Harry Kane". The parameters are positional, which means that calling the method with, club.isProlificScorer("Harry Kane", 27); ... would result in an error!
Passing variables to methods
Are variables changed by methods? What does 'pass by value' mean? What does 'pass by object reference' mean?	Java is 'pass by value'. This means that only the value of variable is passed to a method, so the variable's value remains unchanged in the calling code. However, Java is also 'pass by object reference'. This means that an object's reference (memory address) is passed to a method, and that the content of the object can be accessed and modified because of this. SoccerPlayer player = new SoccerPlayer(); player.setName("Harry Kane"); int clubLeaguePosition = 5; Given method, public int changer(SoccerPlayer player, int position) { player.setName(player.getName() + " XXX "); position += 1; } In the runner code, changer(player, clubLeaguePosition); Java is Pass By Value which means that only the value of a variable is passed to a method or function => variable, position, is still set to 1 - it has not changed. In the case of references, Java is termed Pass By Object Reference. player's name attribute has been changed and is now "Harry Kane XXX "
static method, instance method
What's a static method? What's an instance method?	Static methods are also known as class methods because they are bound to the class, not the object. Static methods are declared with key word, static. public class SoccerClub { ... public static soccerMotto() {...} } SoccerClub.soccerMotto(); Instance methods need an instance of the class! public class SoccerClub { ... public static soccerMotto() {...} } SoccerClub.soccerMotto(); public listPlayers() {...} SoccerClub club = new SoccerClub(); club.listPlayers();

What is Boolean logic?

What is Boolean Logic?
Is there a boolean data type?

Boolean logic is a branch of mathematics devleoped by mathematician George Boole, in the 1800s.

Primitive data type, boolean, and wrapper class, Boolean, represent boolean values of true or false only.

boolean isReady = false;
Boolean isComplete = new Boolean(true);
Boolean isHere = true; // Auto-boxing

The boolean data type has associated storage of a byte or less.

Basic Boolean operators

What Boolean operators are important?

There are more Boolean operators, but the 3 basic Boolean operators are AND, OR and NOT. The other operators are composed of these three.

AND	&&
OR	\|\|
NOT	!

Boolean expressions

What are simple Boolean expressions?
What are compound Boolean expressions?

Boolean expressions evaluate to either true or false. Compound Boolean expressions are Boolean expressions that are joined by Boolean operators, and also evaluate to true or false.

int val1 = 3;
int val2 = 3;
boolean areEqual = (val1 == val2);
serviced = true;
sanitized = false;
boolean roomReady = serviced && sanitized;

Truth tables

What is a truth table?
How do truth tables help evaluate Boolean expressions?

Truth tables show the result of evaluating a Boolean expression with 2 (or more) operands. Here are truth tables for the three basic boolean operations - AND, OR, NOT.

Given Boolean variables isA and isB,
isA && isB is true only when both isA and isB are true, false otherwise.
isA || isB is false only when both isA and isB are false.

isA and isB are set to false and true respectively

isA && isB is false
isA || isB is true
!(isA) is true, because isA is false.

Logic gates

What digital logic gates represent Boolean operations?

Logic gates represent Boolean operations in circuit diagrams.

AND

OR

NOT

These gates can be viewed in the same way as truth tables, with operands and an output.

Simplifying Boolean exressions

Can Boolean expressions be short-circuited?
What is De Morgan's Law?
How is De Morgan's Law useful?

Compound Boolean expression may not have to be fully evaluated, they may be short-circuited. If the first expression in an AND operation is false, then stop right there - the expression is false. If the first expression in an OR is true, the same principal applies, as the expression must be true.
int goals = 7;
int goalScoringThreshold = 15;

if (goals > goalScoringThreshold) && ...... // Java stops here as the expression must be false

if (goals < goalScoringThreshold) || ..... // Java stops here as the ex[ression must be true]

De Morgan's law provides a strategy to simplify Boolean expressions.

Given Boolean variables a and b, comprising Boolean expressions,

!(a && b) <=> !a || !b

!(a || b) <=> !a && !b

De Morgan's law can be applied to more complex expressions. This helps to simplify the evaluation and determine the outcome.

! ( ( a || !b) && (a && b) )

Apply the negate to the sub-expressions, and switch the && to an ||

!( a || !b ) || !(a && b )

Now distribute the negate across each of the sub-expressions

(!a && b) || (!a || b)

This is true if b is true.

If statement
What are If statements used for?	If statements, conditionals support making decisions based on the value of a Boolean expression, or condition.
One way selection statment
Why would a one way selection statement be used?	A one way selection statement is used when action should be taken based on a Boolean expression's truth, and no action otherwise. int goals = 4; int goalScoringThreshold = 15; if (goals > goalScoringThreshold) { System.out.println("Goal scoring range exceeds expectations!"); }
Two way selection statment
Why would a two way selection statement be used?	A two way selection statement is used when action should be taken based on a Boolean expression's truth, and another action should be taken based on the expression being false. int goals = 4; int goalScoringThreshold = 15; if (goals > goalScoringThreshold) { System.out.println("Goal scoring range exceeds expectations!"); } else { System.out.println("Player may need more training!"); }
Multi way selection statment
Why would a multi-way way selection statement be used? Why is it better to use if/else if../else instead of a sequence of if statements?	A multi way selection statement is used when different actions should be taken based on a Boolean expression's truth, such as the value of a discrete quantity, like goals scored by a soccer player this season. int goals = 4; int goalScoringThreshold = 15; if (goals > goalScoringThreshold) { System.out.println("Scoring range exceeds expectations!"); } else if (goals > 10) { System.out.println("Scoring within range!"); } else if (goals > 5) { System.out.println("Scoring acceptable, outside range!"); } else { System.out.println("Scoring unacceptable, training!"); }
Sequence of ifs
Why is it better to use if/else if../else instead of a sequence of if statements?	When one of the conditions is true, the code associated with the condition is executed. After a branch executes, control flows away from the if statement. Where the value of a variable has not changed, it is inefficient to use a sequence of singleton if statements. This is because a condition that is true has already been found. There is no point in evaluating all the other possibities. int goals = 4; int goalScoringThreshold = 15; if (goals > goalScoringThreshold) { System.out.println("Goal scoring exceeds expectations!"); } if ((goals > 10) && (goals <= 15)) System.out.println("Goal scoring within range!"); } if (goals < 5) { System.out.println("Goal scoring unacceptable, training!"); }

Intent of loops

What's the purpose of a loop?
What does iteration mean?
What terms are associated with a loop?
When are loops required?

Loops are structures that support repetitive execution of a sequence of commands, like adding compound interest to a bank account, or printing the times tables.

Loops are useful when a set of commands should be repeated, either infinitely or a set number of times.

A common term used to represent looping is iteration, as in, a loop might iterate or repeat x amount of times. The body of the loop describes code that is executed each time through the loop. A special variable called a loop variable, sentry variable or control variable guards access to the loop by virtue of being used in a loop condition. The loop condition determines access to and continued execution of the loop - when the loop condition is no longer true, the loop exits.

while (condition is true)
statements in body of loop

While loop

How is a while loop structured?
When does a while loop become an infinite loop?
How many times does a while loop execute?

A while loop is a type of loop characterized by key word, while , a loop condition and statements in the body of the loop, executed each time the loop iterates.
int itemNumber = 1;
while (itemNumber < MAX_ITEMS) {
   System.out.println("Processing item number " + itemNumber);
   processItem(itemNumber);
   itemNumber++;
}

int itemNumber = 1;	Optional loop initialization
while (itemNumber < MAX_ITEMS)	key word, while, loop condition. Note sentry variable, itemNumber
System.out.println("...""); processItem(itemNumber); itemNumber++;	Statements in the body of the loop. Note increment of itemNumber

The while loop executes until the loop condition is false. If MAX_ITEMS is 10, then the loop executes for values of itemNumber of 1,2,3,4,5,6,7,8,9. This is 9 times in total.

If the loop variable, itemNumber, is not incremented in the body of the loop, then the loop will be an infinite loop because the loop condition, which is that itemNumber be less than MAX_ITEMS, is always true.

For loop

How is a for loop structured?
When does a for loop become an infinite loop?
How many times does a for loop execute? Is it necessary to include all parts of the for loop?

The for loop is characterized by key word, for, an optional initialization part, a loop condition, and an optional loop statement.

for (int itemNumber = 1; itemNumber < MAX_ITEMS; itemNumber++) {
System.out.println("Processing item number " + itemNumber);
processItem(itemNumber);
}

for (int itemNumber = 1; itemNumber < MAX_ITEMS; itemNumber++)	key word, for, optional initialization of loop variable, itemNumber, loop condition and optional loop statement with increment of the loop variable, itemNumber.
System.out.println("..."); processItem(itemNumber);	Statements in the body of the loop.

The initialization part can be done prior to the for loop, and the loop statement can be left out. The loop could be written
int itemNumber = 1;
for ( ; itemNumber < MAX_ITEMS;) {
processItem(itemNumber);
itemNumber++;
}

The for loop runs as long as the loop condition is true. If MAX_ITEMS has a value of 10, the loop iterates through values for itemNumber of 1,2,3,4,5,6,7,8,9. This is a total of 9 iterations.

Nested Conditionals
What are nested conditionals? What's the purpose of a nested conditional? Can a nested conditional be represented as a compound condition? When are nested conditionals required?	Nested conditionals are conditionals inside other conditionals. Nested ifs, or nested conditionals, represent a compound condition, like, ascertaining first if a soccer player is a goal keeper, and then figuring out if the player should be on the junior team or the senior team, based on age. Given SoccerPlayer object, player, if (player.isGoalKeeper()){ if (player.getAge() >= 21) { System.out.println("Put player " + player.getName()) + " on the senior team as a goal keeper"); } else { System.out.println("Put player " + player.getName()) + " on the junior team as a goal keeper"); } } else { System.out.println("Player is not a goal keeper"); } This could also be done by using a compound condition, if ((player.isGoalKeeper()) && (player.getAge() >= 21)) { System.out.println("Put player " + player.getName()) + " on the senior team as a goal keeper"); } else if ((player.isGoalKeeper()) { System.out.println("Put player " + player.getName()) + " on the junior team as a goal keeper"); } else { System.out.println("Player is not a goal keeper"); } Nested conditions can be used in staggerred evaluations, like the one presented above. Typically, a compound condition or a series of compound conditions can be used in the place of a nested if.
Nested loop
What is a nested loop? When is a nested loop required?	A nested loop is a loop within another loop. A nested loop is required for processing a set of data in an inner loop for each value in an outer loop. An example would be processing blood work in a hospital for each patient in a ward full of patients with a common ailment and all patients requiring a set number of tests. int patientNumber = 1; while (patientNumber < MAX_PATIENTS) { int testNumber = 1; while (testNumber <= TESTS_REQUIRED_COUNT) processTest(patientNumber, testNumber); testNumber++; } } A nested while loop can be mirrored with a nested for loop, and for loops can exist inside while loops and vice versa. for (patientNumber = 1; patientNumber < MAX_PATIENTS; patientNumber++) { for (testNumber = 1; testNumber <= TESTS_REQUIRED_COUNT; testNumber++) processTest(patientNumber, testNumber); testNumber++; } }
Nested loop execution
How many times does a nested loop run? Can a nested loop be an infinite loop?	A nested loop runs for all sentry variable values in the outer loop, and for each value of the outer loop's sentry variable, for all values of the inner loop's sentry variable. The times tables is a good way to see this. for (int factor1 = 1; factor1 < 13; factor1++) { for (int factor2 = 1; factor2 < 13; factor2++) { System.out.println(factor1 + " x " + factor2 + " = " + (factor1*factor2)) } } This produces, 1 x 1 = 1 to 12 x 12 = 144 For each of the 12 values, 1,2,3,4,5,6,7,8,9,10,11,12, in the outer loop, the inner loop also runs 12 times. The body of the inner loop is executed 12 by 12 times in total, which is 144. A nested loop can easily become an infinite loop if either the outer loop condition does not ever become false, or if the inner loop condition does not ever become false.

Swapping primitive variable values
How do primitive type variable assignments cause values to change? Does the order of assignments matter?	Assignments between variables cause changes in the current values of the variables. int val1 = 9; int val2 = 7; int val3 = 3; val1 = val2; val3 = val1; val1 is assigned the value of val2, which is 7. val3 is then assigned the value of val1, which has changed from 9 to 7. This means that val1, val2 and val3 all have a value of 7. The order of the assignments is important for the final result.
Swapping references
What happens when references are reassigned? Are aliases created when references are reassigned? How do object attributes change after objects are reassigned? Does the order of assignments matter?	References are memory addresses, and we see them in using objects. When one 'object' is assigned to another, references are changed and objects point to different locations in memory. Assume class SoccerPlayer, with a constructor that takes the player name as a parameter. SoccerPlayer player1 = new SoccerPlayer("Harry Kane"); SoccerPlayer player2 = new SoccerPlayer("Jamie Vardy"); SoccerPlayer player3 = new SoccerPlayer("Moussa Sissoko"); player1 = player2; player2 = player3; player3 = player1; Above, player1, player2 and player3 have been newed up as instances of class SoccerPlayer. The content of name parameter is transferred to instance variable, name, and getter getName() has been defined. After the first assignment, player1 = player2, player1 points to the memory location that player2's information starts at. At this point, player1 and player2 are aliases of each other. player1.getname() andplayer2.getName() both return "Moussa Sissoko" After the second assignment, player2 = player3, the reference for player2 is set to point at the starting memory location for player3's data. Now, player2.getname() returns "Jamie Vardy", and player3.getName() also returns "Jamie Vardy". Finally, after the third assignment, player3 = player1, player3 now shares a reference with player1, player1 and player3 end up as aliases of each other. After the assignments, player1's name is "Jamie Vardy", player2's name is "Moussa Sissoko" and player3's name is "Jamie Vardy". The order of these assignments determines the end result.

Recursion
What is recursion? Why is recursion useful? Any alternative to recursion?	Recursion is seen when a method (or a function) calls itself, like a recursive solution to Factorial. It is a way to break a problem down into smaller parts of the same problem ... There are times when a recursive algorithm works well, and times when recursion is less efficient.
The Mechanics of Recursion
What's a base case? What's a recursive case?	The base case is the last issue to be handled by the recursive solution. This is the condition that exits the recursive process. If it is not created, the recursive solution will recurse infinitely. The recursive case is the part of the solution that calls the method or function recursively, typically using parameters with different values. Recursive solutions must have a base and recursive case.
Loops Versus Recursion
Any alternative to recursion?	The use of loops can provide a solution to a coding issue, anything that can be coded as a recursive solution can also be coded using loops.
Recursion & The Stack
What part of memory does recursion use? Is recursion efficient? What's a Stack Overflow Exception?	Recursion works on an area of memory called the stack(popup). Each time a recursive call is made, data is added to the stack - which increases memory usage. This is not an issue for fewer calls, but once many calls are made the increase in the use of the stack may impact the efficiency of the solution.(popup) A Stack Overflow exception happens when a recursive solution does not have a valid base case. The stack is added to in an infinte loop.

Intro To CS, Java Pocket Guide

Starter Vocabulary

Data Structures: Array, 2D Array, ArrayList, LinkedList

Casting A Wider Net

Wouldn't Change a String

OOP: Very Classy

OOP: I, Dissent Object

OOP: Inheritance

Method In The Madness

Digital Logic

Conditionals

Loops

Nested Structures

Swapping Values

Recursion

Key Questions

Key Algorithms

Key Vocabulary

Casting an int to a double
Casting an int to a double is a particular type of conversion - what type is it? What are the implications of casting a double to an int?	Casting from an int to a double is a widening conversion, because int can store less than double. int num1 = 7; double num1 = (double)num1; // Widening conversion A narrowing conversion occurs when a double is cast to an int, as this means that some information might be lost. Any fractional part will be truncated. double num2 = 7.777; int num3 = (int)num2; Now, the value of num3 is 7.