It's finally time. You've mastered creating classes, excel at arrays and ArrayLists, and dance around every control structure type. Now, you're ready for the AP CSA test! The first part of the test is the 

. Here are the distributions of the units on the multiple choice section:

There are two tips that are very useful for AP CSA Multiple Choice Questions:

Tracing the code means following the code line by line, iteration by iteration to see what happens in the program. While doing this, take note of the values of variables so that you don't lose track of what is happening by annotating, writing these values down on your test booklet. Although this may take some time, you have over 2 minutes a question, and this should be more than enough time to trace the code as you go.

Process of elimination is one of the most useful tools for AP CSA. You can get rid of many answer choices by paying attention to the types and classes of the methods and objects in question. Sometimes the answer choices will have types or logic that will make no sense which will allow us to cross them out and eliminate them! For example, you will be able to eliminate A, C, and D because they don't make sense, leaving us with only B and E! Now, instead of having a 20% of guessing the correct answer, you now have a 50% chance of doing so! This is a significant increase! Sometimes, you may even be able to narrow it down to one answer, and this will be your correct answer!

The Multiple Choice from the Course and Exam Description

Below are the multiple-choice example questions from the 

College Board Course and Exam Description

Here, we are going to evaluate the expression in the print statement step-by-step

Since we are printing an indexOf method result, the answer will be an integer, so we can eliminate D and E. Now we just trace the code as follows:

Line 1: gets the first 2 letters of word1 and saves it as str1

Line 2: gets the last letter of word2 and saves it as str2

Line 3: makes a new string result by putting str2 at the beginning and str1 after

Line 4: Finds where str2 is in result, because it is at the beginning, the integer that is printed is 

The Math.random() method returns a random number that is greater than or equal to 0.0 and less than 1. There are 36 integers between 25 and 60 inclusive is 36, which we multiply by Math.random() in the line of code to give this range. This eliminates choices A, B, C, and E. From process of elimination, that leaves us with choice D.

This method sorts Large and Mid-Size vehicles correctly because their if-statement conditionals correctly distinguish these types, but for all other categories, since their volume is less than 120 for the second if-statement conditional, this method will incorrectly classify them as Mid-Size. The only choice that are in the correct classifications is E.

This statement is true when either a is true (a) AND the inverse of (b OR a) (!(b || a)) is true. Let's do a truth table to represent this as follows:

Recall that for the OR operator, only one of the two values on each side has to be true and for the AND operator, both sides have to evaluate to true. From the truth table, we can see that the final expression always evaluates to false with all possible inputs. Thus the correct answer is B.

To answer this question, we trace the code and annotate as shown below.

val = 48, div = 6, 48 % 2 == 0, 6 > 0, 48 % 6 == 0
"48 " is printed
val = 24, div = 5, 24 % 2 == 0, 5 > 0, 24 % 5 != 0
val = 12, div = 4, 12 % 2 == 0, 4 > 0, 12 % 4 == 0
"48 12 " is printed
val = 6, div = 3, 6 % 2 == 0, 3 > 0, 6 % 3 == 0


For the result to be used in another class, we need public access, and to even use the integer, we need the method to return an int. The only choice that achieves this is C.

The error here is in the loop header where the Boolean expression is. The way it is right now, it allows i = animals.length, which will throw an ArrayIndexOutOfBounds exception since the last index is animals.length - 1. The fix to this is to remove the equality, which matches A.

I will not work because k is not incremented, creating an infinite loop. II works as the loop header is correct so that the loop actually traverses through the array and the array values are actually updated. III will not work because even though n is updated, Java is pass-by-value, so the array value is not updated. Only II works, so the answer is A.

This will require some code tracing. Here, I have written the code line by line with the contents of the array after each line. On the actual test on the test booklet, I would make an array and add elements as we go as well as cross out removed elements and add arrows to elements added in the middle of the array.

After Line 2: ["one"]
After Line 3: ["one", "two"] 
After Line 4: ["three", "one", "two"]
After Line 5: ["three", "one", "four"]
After Line 6: ["three", "one", "four", "five"]
After Line 7: 

["three", "four", "five"]
The correct answer is D.

So what happens to the list? When there is an even element, the item that would be next would now be in the previous index, but since 

 is incremented, the method skips that next item, which corresponds with E. Here is an example of what would happen:

// Suppose we have an ArrayList myList = [1, 2, 3, 5] and let's call 
// removeEvens on this ArrayList. 
// When i = 0, the element myList.get(0) = 1 is not even, so the array is 
// untouched.
// When i = 1, the element myList.get(1) = 2 is even, so the 2 is removed
// and all the elements will shift to the left, so myList is now [1, 3, 5]
// When i = 2, the element myList.get(2) = 5, but we have skipped 3 because
// it is now at index 1 but i is looking for the new element at index 2!

points.length = 4, points[0].length = 5;
row = 0
col = 4, 4 >= 0, "15 " printed
col = 3, 3 >= 0, "15 14 " printed
col = 2, 2 >= 0, "15 14 13 " printed
col = 1, 1 >= 0, "15 14 13 12 " printed
col = 0, 1 >= 0, 

 printed
col = -1, -1 < 0, NEW LINE
row = 1
col = 4, 4 >= 1, "25 " printed
col = 3, 3 >= 1, "25 24 " printed
col = 2, 2 >= 1, "25 24 23 " printed
col = 1, 1 >= 1, 

 printed
col = 0, 0 < 1, NEW LINE
By process of elimination, 

This question requires some more code tracing.

sum = 0
x = {1, 2, 3, 4} (x.length - 1 will always be 3)
y = 0, sum = 1, y = 1, sum = 3, y = 2, sum = 6, y = 3, 3 !< 3
We now move to a new row and repeat.
The method adds every number in the 2D array except from the last
column, which will turn out to be 54, 

The static type of t is Thing1, while the dynamic type of t is Thing2. Since calc() is not a static method, the Thing2 version of calc() is used. Now we code trace.

IN THING2 CALC:
n = 2 -> 4
super.calc() -> use the calc method in the parent class, which is Thing1
THING1 CALC IS CALLED, IN THING1 CALC:
n = 4 -> 12, "12" is printed
BACK IN THING2:
n = 4, 

The recursive code mystery1 with its call to itself adds 5 to the sum if n is greater than 1, and then adds 1 when n = 1, which is the base case. Remember that we can To achieve this with the looped code, mystery2, we need to initialize total to be 1, which is A.

You've finished the multiple-choice section of the exam, and after a short break, it's time for the second half of the test: the FRQ section. The FRQ section has 

, the same amount of time as the multiple-choice portion.

The AP CSA test has 4 FRQs, each of which is different in style. Here's a little bit about them:

AP Computer Science A Exam

AP CSA Exam Prep 2020 | Reviews + Free Study Help | Fiveable

AP Computer Science A

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs

First Unit

AP Computer Science A Exam Guide

These are common String methods that you should understand in order to do the FRQs and answer multiple-choice questions on the AP Computer Science A Exam. 

In order to demonstrate these methods, we will use these Strings:

String a = "apple";
String b = "Bob is a high school student who likes apples";
String c = "apple";

Strings are not Java primitives, so you cannot compare their values using 

. To compare Strings to each other, you have to use the 

 method. This method returns a boolean that tells 

you whether the two Strings are equal to one another.

a.equals("apple"); // This returns "true"
a.equals(c); // This returns "true"
b.equals(a); // This returns "false"

This method compares two strings to see which one "comes first".  A negative value means that the String in the front comes "before" the String in the back. A positive value means that the String in the front comes "after" the String in the back.

For the most part, the "order" that the 

 method uses is alphabetical order, except all of the capital letters come before the lower case letters.

If the first letter in both Strings are identical, the computer will compare the next two letters, going until the end. If all of the letters in the front are identical but one String is shorter, the shorter String comes "before" the longer one. If the two Strings are completely identical, this method will return 0.

a.compareTo(c); // This returns 0
b.compareTo(a); // This returns a negative number (capital B comes before a)
a.compareTo("appl"); // This returns a positive number ("appl" is shorter)

Tip: Remember to write out the steps as you trace code so that it's easier to understand. The 

method can be confusing, but you can ensure that you won't get lost by writing out what letters are being compared. Once you know which String comes "first", you can figure out if the method returns a positive or negative value (or 0).

If you want to find where a certain letter or phrase is, you use the 

method. This method will return the index of where this letter or phrase first starts. (Don't forget that spaces between words count as indexes too.)

If the letter or phrase doesn't show up in the String, the method returns -1.

Remember: Since Strings start at index 0, the second letter is at index 1, the third letter is at index 2, and so on.

a.indexOf('p'); // This returns 1
b.indexOf("high school"); // This returns 9
a.indexOf("cat"); // This returns -1
b.indexOf("dent"); // This returns 24

Keep this in mind: Even if the phrase you check for does not appear independently in the String, it can still be detected. For example, the computer will find the index of "moth" if you run it on "smother" because the letter combination is there, even though the words have totally different meanings.

To find out how long a String is, you use the

 method, which returns an integer that tells you how long the String is.

a.length(); // This returns 5
b.length(); // This returns 45
c.length(); // This returns 5

To access just one part of a String, you use the 

 method. The first number you put in tells the computer which index to start at (the letter at this index is included). The last number you put in tells the computer which index to stop the substring at (the letter at this index is not included).

If you leave the last index empty, the substring will start at the index you give and continue to the end of the String. Make sure to know the last example; while it may seem counter-intuitive, the substring starting at the string's length does return an empty String.

a.substring(2,4); // This returns "pl"
b.substring(5,24); // This returns "s a high school stu"
c.substring(1); // This returns "pple"
a.substring(a.length());// This returns an empty String.

Important note: These methods can be "stacked" together


You can call multiple String methods in a row, like this:

a.substring(0,1).equals(b.substring(7,8)); // This returns true
b.substring(5,24).compareTo(c); // This returns a positive number

Even though you can chain these methods together, it is best not to do this because you might make a mistake and it's harder to read. Try to do it this way:

String d = a.substring(0,1);  // d = "a"

String e = b.substring(7,8);  // e = "a"

d.equals(e) // This returns true ("a" equals "a")

String f = b.substring(5,24); // f = "s a high school stu"
f.compareTo(c); // This returns a positive number ("s" comes after "a")

You can't edit a String after you set it, but you can add onto it this way:

String temp = ""; // temp = ""
temp += "cat"; // temp = "cat"
temp += "s"; // temp = "cats"

 and replacing it with what used to be in 

 and concatenating a new String. Remember that 

String Methods

When you use boolean operators like && or || to compare statements, the computer takes short-cuts to be more efficient. These short-cuts result in "short-circuiting", where the computer doesn't evaluate all of the statements.

Since a statement involving && is only true is both of the statements are true, the computer doesn't evaluate the second part of the conditional if the first part is false. This helps it save time by avoiding unnecessary calculations.

int x = 10;
int y = 8;

if (x<7 && y==8)
{
   System.out.println("Works");
}

else
{
   System.out.println("Failed");
}

 is not less than 7, the computer didn't even check if 

 was equal to 8, as the statement would evaluate to false either way because the first part was false.

This becomes important in situations like the one below:

int a = 8;
int b = 0;

if (a>10 && a/b==3)
{
   System.out.println("Works");
}

else
{
   System.out.println("Failed");
}

A multiple choice question on the AP Computer Science A Exam may ask you what the outcome of executing this code would be. One of the choices will likely be that there will be a "divide by 0" error. However, this is the incorrect option.

Why is that the incorrect option? Due to short-circuiting, the computer running this code won't even try to run 

 is not greater than 10, it will immediately deem the entire statement false and move to the else statement. Thus, the output of this code would be "Failed".

Since a statement involving || is true is even one of the statements is true, the computer won't evaluate the second part if the first part is true. Once again, this helps save time by avoiding unnecessary calculations.

This is important in situations like the one below:

int x = 8;
int y = 10;

if (x<10 || x/0==8)
{
   System.out.println("True");
}

else
{
   System.out.println("False");
}

, it will immediately deem the entire statement true and run the code inside the 

. Thus, the output of this code would be "True".

Short-circuiting occurs because the computer takes short cuts in testing boolean statements

If the first part of a statement using && is false, the second part isn't tested

If the first part of a statement using || is true, the second part isn't tested

AP Computer Science A: Short Circuiting

Once you recognize the frequent symbols used in Java, you'll be a pro at understanding what's happening in the code!

 compares the value on the left and the value on the right

 gives you the remainder when the value on the left is divided by the right

for (int i=0; i<5; i++)
{
   System.out.print(i);
}

​
What is printed as a result of executing this code?

 increases in value to 5, but 5 is not less than 5, so the computer exits the 

Since the code uses "print", all of the numbers are printed on the same line

for (int i=0; i<5; i+=1)
{
   if (i%2 == 0)
   {
      System.out.print(i);
   }
​
   else if (i!=3)
   {
      System.out.println(i*2);
   }
 
   else
   {
      System.out.print("Three");
   }
}

Since 0%2 equals 0 (since the remainder when 0 is divided by 2 is 0), the first 

 is true and the code inside executes, printing "0"

Since 1%2 is not equal to 0, the computer checks the 

1 is not equal to 3, so the computer prints 1*2, or "2"

Since the code says "println", the computer prints the "2" next to the "0", then 

int count = 1;
while (count<5)
{
   count*=2;
}
System.out.println(count);

Since 1 is less than 5, the computer enters the 

and count is doubled, making count equal to 2

Since 2 is still less than 5, the computer re-enters the 

 and count is doubled again, making count equal to 4

Since 4 is still less than 5, the computer re-enters the 

Now that 8 is not less than 5, the computer moves on and prints count, or "8"

public int addNums (int x, int y)
{
   return x+y;
}

​
What does the method return with after the method call addNums (5,10)?

for (int y=5; y>0; y--)
{
   for (int x=0; x<5; x++)
   {
      System.out.print(y);
   }
   System.out.println();
}

​
What is the output when you execute this code?

First of all, don't panic when you see this snippet, it's easy to solve if you follow it step-by-step and write every step down. 🙌

 is finished, the computer exits that loop and moves on to "System.out.println()", which causes the computer to skip a line

Since there's nothing inside the parentheses, nothing is printed

 now equals 4. Repeat the same process as above for 

 equals 4, then 3, then 2, then 1. The code stops running after that because 

 ends up being 0 and does not meet the condition that 

 is greater than 0, causing the computer to exit all of the loops.

As you trace the code, write down what variables the computer has stored and what is being printed (and how it is printed)

Understand the common symbols used in Java

Pay careful attention to what is happening to the variables (and write down any changes) because a wrong value will lead you to the wrong answer

Pay attention to "print" vs. "println" because they lead to very different outputs

How to Read Code in Java

public class Cats
{
   public int countNumFeet (int numCats)
   {
        return 4*numCats;
   }
​
   // There may be instance variables, constructors, and other methods not
   // shown.
}

That's right! 👏 It's "public int countNumFeet (int numCats)"! 🐱

The keyword "public" means that this method can be accessed from other classes.

It can be replaced by the word "private" to give you:

Putting "private" means that the method can only be accessed within the "Cats" class

The keyword "int" tells you what this method returns when it is called.

In this case, it returns an integer value after it is called

It can be replaced by "double", "boolean", "String", or the name of a class if the method returns an object

If the word "void" is there instead of the other options, this means the method doesn't return anything

The word "countNumFeet" is the name of the method.

This can be replaced with anything without changing what the method does

It's best if you make the name of the method something that lets people easily know what it's doing

The "int numCats" tells you what is being passed into this method.

In the example, an integer called "numCats" is being passed in

You can have a method that has nothing being passed in:

You can also have a method that has multiple parameters passed in:

public int countNumFeet (int numCats, int numEars, boolean isAngry)

Method headings may also include the phrases "static" or "abstract", but this will be discussed in later articles. 
​

#1) Write the header for a method that can only be accessed within the class it's declared in. This method takes in a String called "text" and doesn't return anything. Call your method "example1".  (Scroll down for the answer)

#2) Write the header for a method that can be accessed from other classes. This method takes nothing in and returns a boolean. Call your method "example2". (Scroll down for the answer)

#3) Write the header for a method that can be accessed from other classes. This method takes in a boolean "testPassed" and an integer "score". It returns a String. Call your method "example3". (Scroll down for the answer)

#3) public String example3 (boolean testPassed, int score)

You can write a method header with just a few simple steps.

Choose what parameters to pass into the method

That's it! You're ready to start writing your own method headers! 👏

How to Write Method Headers

An interface is like an abstract class, but 

 while only one abstract class can be inherited. Like abstract classes, you use interfaces when there are several classes that will have similar methods available. 

Even though you don't declare them abstract, all methods in an interface are abstract.

You can't do "Interface a = new Interface();". 🚫

In an interface, you define methods and variables that the child classes will inherit.

Inside an interface, all methods are abstract methods. 

An abstract method must be left with no body

 (no braces, just put a semicolon after the method header)

An abstract method is basically a promise that the method will exist and be implemented in a child class

Any regular class derived from your interface has to implement the abstract methods (you have to give the method a body)

public interface EatInterface 
{
   public void hungry(int x);
}

public interface DrinkInterface
{
   public String thirsty(boolean isDehydrated);
}

As you can see,  interfaces are usually just filled with method headers that end with a semicolon.

Why use an interface in this situation? 🤷‍♂️


There are certain types of food that you can both eat and drink (like ramen). By using interfaces, you can inherit functions related to eating from one interface and other functions related to drinking from another interface.

If you implement interfaces, the code will not compile until you give a body to the abstract methods (this is the same as an abstract class)

public class Ramen implements EatInterface, DrinkInterface
{
   public void hungry(int x)
   {
      System.out.println("Keep Eating");
   }

   public String thirsty(boolean isDehydrated)
   {
      return "More water";
   }

   // There may be instance variables, constructors, and other methods not
   // shown.
}

Note that the class "implements" the interface 

A class can extend a parent class and implement interfaces; if there was a class called Noodle, you could do:

public class Ramen extends Noodle, implements EatInterface, DrinkInterface
{
   // There may be instance variables, constructors, and other methods not
   // shown.
}

A class can inherit many interfaces (this is different from abstract classes)

All methods in an interface are abstract (this is different from abstract classes)

Variables (also called fields) in an interface are static and final variables (these variables belong to the class and cannot be changed)

Interfaces can be used to contain constants (like Physics constants)

An interface is like an abstract class except all methods are abstract

Blogs

AP Computer Science A

all

study guides

blogs

browse by units

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs

Blogs

AP Computer Science A

all

study guides

blogs

browse by units

Free Reviews﻿

Unit 1: Primitive Types﻿

Unit 2: Using Objects﻿

Unit 3: Boolean Expressions and if Statements﻿

Unit 4: Iteration﻿

Unit 5: Writing Classes﻿

Unit 6: Array﻿

Unit 7: ArrayList﻿

Unit 8: 2D Array﻿

Unit 9: Inheritance﻿

Unit 10: Recursion﻿

Blogs﻿

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs