for (type variable : arrayname)

Figure 2: For Loop Traversing Array

data structure

arrayname[index]

Figure 4: A primitive array and an object array

int[ ] highScores = {99,98,98,88,68}; String[ ] names = {"Jamal", "Emily", "Destiny", "Mateo", "Sofia"};

initializer list

Note Array elements are initialized to default values like the following. 0 for elements of type int 0.0 for elements of type double false for elements of type boolean null for elements of type String

// create the array highScores = new int[5]; // declare and create array in 1 step! String[] names = new String[5];

// Declaration for an array of ints int[] scores;

Static variables and methods

Call by Value

some of the main reasons to use multiple methods in your programs: Organization and Reducing Complexity: organize your program into small sections of code by function to reduce its complexity. Divide a problem into subproblems to solve it a piece at a time. Reusing Code: avoid repetition of code. Reuse code by putting it in a method and calling it whenever needed. Maintainability and Debugging: smaller methods are easier to debug and understand than searching through a large main method.

Procedural Abstraction

Notice the difference between setters and getters in the following figure. Getters return an instance variable’s value and have the same return type as this variable and no parameters. Setters have a void return type and take a new value as a parameter to change the value of the instance variable. Figure 1: Comparison of setters and getters

// Setter method template public void setVarName(typeOfVar newValue) { varName = newValue; }

5.4.1. toString¶

You don’t need to write a getter for every instance variable in a class but if you want code outside the class to be able to get the value of one of your instance variables, you’ll need to write a getter that looks like the following. class ExampleTemplate { // Instance variable declaration private typeOfVar varName; // Accessor (getter) method template public typeOfVar getVarName() { return varName; } } Notice that the getter’s return type is the same as the type of the instance variable and all the body of the getter does is return the value of the variable using a return statement.

Unified Modeling Language (UML) for drawing these diagrams. For example, here is a UML class diagram for the Turtle class. The - in front of the attributes indicate that they are private, and the + in front of the methods indicate that they are public. Here is a tutorial on class diagrams that explains it in more detail if you are curious (Class diagrams are not on the AP CSA exam). If you want to draw your own, app.diagrams.net or Creately.com are good free online drawing tools for UML class diagrams.

Note Methods define what the object can do. They typically start with public then a type, then the name of the method followed by parentheses for optional parameters. Methods defined for an object can access and use its instance variables!

public class Person { // instance variables // constructors // methods }

Note The first character in a string is at index 0 and the last characters is at length -1.

Here is a list of common mistakes made with Strings. Thinking that substrings include the character at the last index when they don’t. Thinking that strings can change when they can’t. They are immutable. Trying to access part of a string that is not between index 0 and length -1. This will throw an IndexOutOfBoundsException. Trying to call a method like indexOf on a string reference that is null. You will get a null pointer exception. Using == to test if two strings are equal. This is actually a test to see if they refer to the same object. Usually you only want to know if they have the same characters in the same order. In that case you should use equals or compareTo instead. Treating upper and lower case characters the same in Java. If s1 = "Hi" and s2 = "hi" then s1.equals(s2) is false.

Figure 2: compareTo returns a negative or positive value or 0 based on alphabetical order

This method is inherited from the Object class, but is overridden which means that the String class has its own version of that method.

Note Two common patterns in for-loops are to count from 0 up to an number (using <) or count from 1 to the number including the number (using <=). Remember that if you start at 0 use <, and if you start at 1, use <=. The two loops below using these two patterns both run 10 times. The variable i (for index) is often used as a counter in for-loops. // These loops both run 10 times // If you start at 0, use < for(int i = 0; i < 10; i++) { System.out.println(i); } // If you start at 1, use <= for(int i = 1; i <= 10; i++) { System.out.println(i); }

for (initialize; test condition; change) { loop body }

Common Errors with Loops

Figure 5: A trace table showing the values of all of the variables each time through the loop. Iteration 0 means before the loop.

Figure 2: Comparing Snap! or Scratch Repeat Until Loop to Java while loop

// The statements in a while loop run zero or more times, // determined by how many times the condition is true while (condition) { statements; }

control structures

Note Only use == with primitive types like int or to test if two strings (or objects) refer to the same object. Use equals, not ==, with strings to test if they are equal letter by letter.

!(c == d) is equivalent to c != d !(c != d) is equivalent to c == d !(c < d) is equivalent to c >= d !(c > d) is equivalent to c <= d !(c <= d) is equivalent to c > d !(c >= d) is equivalent to c < d

else if (boolean expression) { statement2; }

In fact many experienced Java programmers always use curly braces, even when they are not technically required to avoid this kind of confusion.

If statements can be nested inside other if statements. Sometimes with nested ifs we find a dangling else that could potentially belong to either if statement. The rule is that the else clause will always be a part of the closest unmatched if statement in the same block of code, regardless of indentation.

// A single if/else statement if (boolean expression) Do statement; else Do other statement;

// A single if statement if (boolean expression) Do statement; // Or a single if with {} if (boolean expression) { Do statement; } // A block if statement: { } required if (boolean expression) { Do Statement1; Do Statement2; ... Do StatementN; }

>

Note Math.random() returns a random number between 0.0-0.99. (int)(Math.random()*range) + min moves the random number into a range starting from a minimum number. The range is the (max number - min number + 1). Here are some examples that move a random number into a specific range. // Math.random() returns a random number between 0.0-0.99. double rnd = Math.random(); // rnd1 is an integer in the range 0-9 (including 9). int rnd1 = (int)(Math.random()*10); // rnd2 is in the range 1-10 (including 10). The parentheses are necessary! int rnd2 = (int)(Math.random()*10) + 1; // rnd3 is in the range 5-10 (including 10). The range is 10-5+1 = 6. int rnd3 = (int)(Math.random()*6) + 5; // rnd4 is in the range -10 up to 9 (including 9). The range is doubled (9 - -10 + 1 = 20) and the minimum is -10. int rnd4 = (int)(Math.random()*20) - 10;

Easy enough—casting a double to an int will throw away any values after the decimal point. For example, // rnd is an integer in the range 0-9 (from 0 up to 10). int rnd = (int)(Math.random()*10);

These wrapper classes (defined in the java.lang package) are also useful because they have some special values (like the minimum and maximum values for the type) and methods that you can use.

Wrapper Classes

backslash escape sequence

Class names in Java, like String, begin with a capital letter. All primitive types: int, double, and boolean, begin with a lowercase letter. This is one easy way to tell the difference between primitive types and class types.

declared return type

Methods inside the same class can call each other using just methodName(), but to call non-static methods in another class or from a main method, you must first create an object of that class and then call its methods using object.methodName().

Methods inside the same class can call each other using just methodName(), but to call non-static methods in another class or from a main method, you must first create an object of that class and then call its methods using object.methodName().

Activity: CodeLens 2.3.1.2 (songviz1)

Execution in Java always begins in the main method in the current class.

Figure 1: A Student class showing instance variables, constructors, and methods

Procedural abstraction allows a programmer to use a method and not worry about the details of how it exactly works.

method signature (or method header), which is the method name followed by a parameter list

Figure 4: A Date class showing attributes and constructors

signatures

The code Turtle t1 = null; creates a variable t1 that refers to a Turtle object, but the null means that it doesn’t refer to an object yet. You could later create the object and set the object variable to refer to that new object (t1 = new Turtle(world1)). Or more commonly, you can declare an object variable and initialize it in the same line of code (Turtle t2 = new Turtle(world1);). World world1 = new World(); Turtle t1 = null; t1 = new Turtle(world1); // declare and initialize t2 Turtle t2 = new Turtle(world1);

object variable

one reason why programming languages have data types – to allow for error-checking.

// To create a new object and call a constructor write: // ClassName variableName = new ClassName(parameters); World habitat = new World(); // create a new World object Turtle t = new Turtle(habitat); // create a new Turtle object

class diagram that shows some of the attributes and methods in the class Turtle.

And just like the Java compiler will only let you do things with the values of int variables that make sense (like adding and multiplying them), it will only let you do things with values of a Turtle variable that make sense to do with turtles, namely accessing the instance variables and methods defined in the Turtle class. The following picture has lots of cats (objects of the type cat). They are all different, but they share the same attributes and behaviors that make up a cat. They are all instances of cat with different values for their attributes. Name some of the attributes and behaviors of the cats below. For example, the color (attribute) of the first cat is black (attribute value) and it is playing (behavior).

Separating the ammonia