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

In this review, we will over the class and Exam. In addition we will go over Java Basics, IDEs and Primitive Types

Introduction to AP CSA and Unit 1 Review


All information in Java can be stored in variables and can take the form of primitive data types or combinations made from these primitive data types.

Welcome to AP Computer Science A, or AP CSA for short! In this course, you will learn the basics of Java, a programming language that is widely used today. In these guides, you will not only learn how to code but also how to code well.


Unit 1 in AP CSA is named "Primitive Types," and they are the building blocks of the rest of Java. The types you have to know in this class are the boolean, float, and double, although there are others. However, it is not the only thing you'll learn in this unit. You'll also learn why we use Java, and you'll make basic programs as well! In making these basic programs, you'll get a little taste of classes, which are the big overarching concept tying this course together!

When we program, a lot can be represented mathematically, with comparison, equality, and arithmetic. Using this, it is easier from start to finish to trace programs with this intuition to figure out what the output is.
We'll also build programs from a specification, with instructions with what to do. From this, we'll also learn about basic input and output. There will be errors when we first learn to program, and thus we'll need to get acquainted with some of the more common errors that will occur when programming.

Almost all the technology we use today, from everything on your computer to your smartwatch to your television, is made possible by programming. Programming is what makes these devices respond to your actions and commands.
What is programming anyway? In short, it is giving a device instructions to respond to different actions and run. There's a lot more complexity to this involving computer hardware, but that is beyond the scope of this course.
In essence, our computer is "run" using bits of 0s and 1s, which represent on and off electrical signals. Some programming languages, such as Assembly, interact almost directly with those bits. However, Assembly is inconvenient to program in and is incredibly hard to read.

 that are easier to code in and understand was born. First came languages like Pascal and FORTRAN, then C, C#, and C++, common mainstays in the programming world. The most popular programming languages of Javascript, Python, and the focus of this course: Java, have only come about recently.

These newer languages are much easier to understand and look like everyday English to an extent. For machines to understand this code, however, the program must be converted into machine code, which is what computers understand. As you progress, you'll learn that Each language has a different way of doing this.



What Is Java, How Does It Work, and Why Do We Use It?

 is one of the high-level programming languages mentioned earlier. It is also the second most used programming language in the world, behind Python. There are several reasons that Java is so popular, and here's a list from Cay Horstmann's *Core Java *****based on the original Java developers' claims:

Before we start programming, we have to actually set up our coding environment. To do this, we use an 

. Your teacher will usually have a preference, but if they don't, any of these will work perfectly fine. A few well-known ones for Java include:

However, in these guides, code will either be embedded directly onto the site or be from 

, an online IDE that takes advantage of remote compilers so that your computer's RAM isn't overwhelmed.


The white half is the code editor, where you enter your code that is compiled and later executed. The blue half is the console, which shows the output of the program and any errors that occur. On the left of the screen is the file explorer (not visible above), and this is where your different code files (which are your Java classes, which we’ll discuss later) are located on your computer.

Below is the first program many students learning Java will see. There seems to be a lot going on, but here, we'll break it down!

public class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}


Do you see the indentation? Indentation isn't needed but it can make your code much easier to read! I recommend proper indentation when coding by either using a tab or 2 spaces. Just remember to be consistent!

> javac -classpath .:/run_dir/junit-4.12.jar:target/dependency/* -d . Main.java
> java -classpath .:/run_dir/junit-4.12.jar:target/dependency/* Main
Hello world!


There is a lot that's going on in these snippets, and we'll learn these more in-depth in later units. In the console, we first see javac, which is the Java compiler compiling 

, and then a java command executing the Main bytecode. The third line (and beyond, depending on the program) has the result of the code. In future instances, we won't show the first two lines.

Meanwhile, on the code, let's decode it line by line! The java files are always in the name 

, and in this case, the file in question is 

 means that it can be accessed from any other class.
The {} denotes the contents inside the class and the 

 after it—in other programming languages, they are called functions—with the method header in line 2. Every program, no matter how many classes there are, must have a main method in only one of the classes. The main method is "the master switch," the method that determines what other methods are called. The 

 means that we don't need an instance of the "Main" class (we'll learn more about instantiations and objects in Unit 2). The 

 signifies that the method does not return anything directly to another function. Then, the method name is next, and any 

 in parentheses. In this case, the parameters (String[] args) is an 

 of strings named args (we'll learn more about arrays in Unit 6).
The third line is what does some work. The 

 prints Hello world!, and sets the cursor to a new line if there is anything else to print. Note the semicolon after the line; this is necessary as it shows the end of an action. If it isn't there, the compiler returns a syntax error.
"Hello world!" is what is known in Java as a 

a string for short. A string is an object in Java that sets up a template for strings. Any time there is a statement enclosed in double-quotes, that is a string.

System.out.println() vs System.out.print()

There are two ways to print text to the consoles that we'll use in this course. They are both methods of the System.out object, which is a part of the System class.
System.out.println() prints whatever is in the parentheses to the console and sets the cursor on a new line. On the other hand, System.out.print() prints whatever is in the parentheses, but doesn't set the cursor on a new line.

public class Main {
  public static void main(String[] args) {
    System.out.print("Hi! ");
    System.out.println("Hello!");
    System.out.println("Bye!");
  }
}


In Java, everything is either one of several 

 or combinations of these primitive data types (collections and objects). These combinations of primitive data types are called 

. For this class, you have to know these three:

—Stores an integer number from -2,147,483,648 to 2,147,483,647. The highest integer value is called 

. Entering an integer outside this range results in an 

 and automatically converts it to Integer.MAX_VALUE if it’s too high and Integer.MIN_VALUE if it’s too low.

—Stores a decimal number with high precision (15 decimal places). If you give more decimal places than 15, the decimal will be truncated.


Each of the primitive data types comes with its own set of defined operations. These are future topics within the course. With these three primitive types and their operations, we can do many mathematical and logical operations.

There are also other primitive types that are not needed for this course. They are the byte (for small integers), the short (for integers that are slightly larger than a byte), the long (for very large integers), the float (for decimals with half the precision of a double), and the char (for characters).

A string object is an array of chars, so when you make a string, you make an array of different chars combined into one string.

 are one way to store data in Java and are used again and again in method parameters and different operations as well. To initialize (make) a variable, we do this:

(scope) dataType variableName = dataValue



The special capitalization is called Camel Casing, where the first word is lowercase while the rest are capitalized and combined into one word. Variable and method names use Camel Casing. Class names use a different approach called Pascal Casing, where all words are capitalized.


Variable names must follow these rules. The variable name can begin with a letter, underscore (_), or a dollar sign ($). The rest of the characters in the variable name can be letters and numbers. Under standard conventions, variable names are only letters (note that variable names are case sensitive). However, some names cannot be used as they are used for something else in Java (


When naming your variable, using descriptive variable names are preferred instead of a random name like "d" or "sksksksksksk"." "i" and "j" are allowed variable names that have a specific purpose, but we will cover this later.

Also, notice how each variable has its data type. This is called a 

, where variables can change partway through.


Examples of legal and illegal variable names:

Good names: iceCreamFlavor, carMake, name
Legal, but not preferred: $ball, j, var4
Illegal: nf 23f, &jjjjd, 2fdjjkdk


Here is an example of initializing variables of all of the data types. The equal sign is the assignment operator that assigns/gives a value to the variable.

int daysInWeek = 7;
private String name = "Bob";
protected double tax = 0.0775;
public boolean goalMet = false;


. If there are no scope or access modifiers, this is called 

, which means the variable is accessible by all classes in that 

 (also known as a folder in your computer).

 is where a variable, class, or method is only available to that own class. We already talked about 

 when talking about the main method in 1.1. Finally, 

 with methods, variables, and classes is available to all classes in that package and any subclass as well (we will talk about subclasses in unit 9).


We can also declare the variable without initializing it like this:

private String name;
private int age;
private double gpa;


, which means that they never change. We use the 

 modifier to show this and name the variable in all capitals. Here is how we denote them in Java:

At some point in your AP CSA experience, you are going to have to do input. In Java, there are many ways to do input and you can see them 

import java.util.Scanner;

public class ScannerTest {
  public static void main(str[] args) {
    Scanner input =  new Scanner(System.in);
    System.out.print("Enter an integer: ");
    public int sampleInputInt = input.nextInt();
    System.out.print("Enter a double: ");
    public double sampleInputDouble = input.nextDouble();
    System.out.print("Enter a boolean: ");
    public boolean sampleInputBoolean = input.nextBoolean();
    System.out.print("Enter a String: ");
    public String sampleInputString = input.nextLine();
    System.out.print("The string you entered was ");
    System.out.println(sampleInputString);
    System.out.print("The integer you entered was ");
    System.out.println(sampleInputInt);
    System.out.print("The double you entered was ");
    System.out.println(sampleInputDouble);
    System.out.print("The boolean you entered was ");
    System.out.println(sampleInputBoolean);
    input.close();
  }
}



To use the import shown above, you have to follow the following steps:


You can see the scanner method receives data in the snippet above. If you enter the wrong data type, the program will crash, and you have an 

. In the final print statement, you can see that we put a variable in the parameter, and it will print the value saved in the variable. After, we close the scanner object before we end the program. Here is an example of the console output with user input in italics.


Enter an integer: *7*
Enter a double: *3.14159*
Enter a boolean: *true*
Enter a String: *Hi.*
The string you entered was Hi.
The integer you entered was 7
The double you entered was 3.14159
The boolean you entered was true


Note that we can put non-String types into the print statement and converts these to a string. You will learn how in future units.

Variables and Primitive Data Types

1.3: Expressions and Assignment Statements

Now, we can start working more with these data types. In this section, we're going to focus on the two numeric types: int and double.

For addition, subtraction, and multiplication, equations can be input as you would input them into your calculator. Variables are used to assign the answers to the correct equation.

int a = 1 + 2;
double b = 1.0 + 3.5;
int c = 3 - 5;
double d = 24 * 1.0


, can be used to change the value of the variable or other expressions. It evaluates the expression first and stores the final value in the variable.

If an operation has two integers, then the result is an integer. If an operation has at least one double, then the result is a double.

There is also a 

, the program reports the integer remainder of 

 is positive. We will only talk about modulo with positive values of 

 because once a is negative, the math becomes much more complicated. A few examples are below:

int a = 4 % 2;
int b = 10 % 3;
int c = 3 % 5;



a = 0 (4 = 2 * 2 + **0**)
b = 1 (10 = 3 * 3 + **1**)
c = 3 (3 = 0 * 5 + **3**)


Things get a bit more complicated with division. Remember that operations with two integers return an integer, and if there is at least one double, it returns a double. Here is an example of each:

 returns only the whole number quotient, while the 

 returns the actual quotient as a decimal.

Java follows the regular order of operations that you learned in algebra, with the inclusion of modulo with multiplication and division. Here is a table of the order of operations with operators from highest to lowest precedence:


Here is some practice with order of operations. Remember the difference between double division and integer division. Find the value of each variable in the following:

int a = 3 + 4 / 3 * (4-1);
double b = (3 * 5 / 2) / (2.0 + 8);
int c = 4 % 3 + 2 * 5 / 4; 
int d = (3 * 5 / 2) / (2 + 8);


a = 3 + 4 / 3 * (4 - 1) = 3 + 4 / 3 * 3 = 3 + 1 * 3 = 3 + 3 = **6**
b = (3 * 5 / 2) / (2.0 + 8) = (15 / 2) / (10.0) = (7) / (10.0) = **0.7**
c = 4 % 3 + 2 * 5 / 4 = 1 + 2 * 5 / 4 = 1 + 10 / 4 = 1 + 2 = **3**
d = (3 * 5 / 2) / (2 + 8) = (15 / 2) / (10) = (7) / (10) = **0**


Expressions and Assignment Statements

Sometimes, you will encounter situations where you need to perform the following operation:

int integerOne = 6;
integerOne = integerOne * 2;


This is a bit clunky with the repetition of integerOne in line two. We can condense this with this statement:

, which multiplies the current value of integerOne by 2 and sets that as the new value of integerOne. Other arithmetic operators also have compound assignment operators as well, with addition, subtraction, division, and modulo having 

There are special operators for the two following operations in the following snippet well:

pre-increment/pre-decrement (++i or - -i) or post-increment/post-decrement (i++ or i- -) operator

. You only need to know the post-variant in this course, but it is useful to know the difference between the two. Here is an example demonstrating the difference between them:

int integerOne = 2;
integerOne++;
System.out.println(integerOne);
++integerOne;
System.out.println(integerOne);
System.out.println(integerOne++);
System.out.println(++integerOne);


By itself, there is no difference between the pre-increment and post-increment operators, but it's evident when you use it in a method such as the println method. For this statement, I will write a 

 the code, which means to follow it line-by-line.

Value of integerOne after line 1: 2
Value of integerOne after line 2: 3
Value of integerOne after line 3: 3
Value of integerOne after line 4: 4
Value of integerOne after line 5: 4
Value of integerOne before printing on line 6: 4
Value of integerOne after line 6: 5 (post-increment increments after the method)
Value of integerOne before printing on line 7: 6
Value of integerOne after line 7: 6 (pre-increment increments before the method)


Compound Assignment Operators

The range of variables in AP CSA refers to the range of integers, which we covered in 1.2!

Sometimes, we need to use integers in a double calculation and doubles in an integer calculation. Thus, we need a way to do this.

If you said 3.0, then you are correct! Since the type of 

 (converted) to a double, thus the .0 ending is added.

 Casting changes between primitive data types. See the example below:

This one is a little more complicated. What is the value of this?

In this example, the program refuses to compile! The result of this equation is 3.0, which is a double, but the type of 

 is an integer. Converting a double to an integer will result in a loss of precision, aka the decimal place (see the discussion of significant digits in our AP Chem Unit 1 Study Guide to learn more).
To use this equation correctly, we need to manually do a cast. The cast doesn’t round the decimal to the nearest integer, but instead simply 

 (cuts off) the decimal and leaves the integer part untouched.
However, casting only casts the first number following the cast, regardless of type, so you need to be careful with where you place your casts to avoid an incorrect calculation or a program error! Here is an example of an incorrect cast followed by two correct casts.

int c = (int) 1 + 2.0; 
int d = 1 + (int) 2.0;
int e = (int) (1 + 2.0);


What happens is that only the first one will fail to compile while the other two will give a value of 3 stored into the variable. The cast converts the next number into an integer regardless of the type and not the whole expression. If you want to cast the whole expression, enclose it in parentheses.

One of the applications of using a cast is rounding to the nearest integer. Since casting doubles to integers simply truncates the decimal, we need to modify the original input in order to achieve true rounding.

With truncation, casting any positive decimal will convert the decimal to the rounded down integer. However, we want decimals less than 0.5 to round down and the rest to round up. To do this, we add 0.5 to the double before casting like so:

Examples:
a = 1.3 which would normally round to 1:
   (int) (1.3 + 0.5)
 = (int) (1.8)
 = **1**
a = 1.8 which would normally round to 2:
   (int) (1.8 + 0.5)
 = (int) (2.3)
 = **2**
a = 1.5 which would normally round to 2:
   (int) (1.5 + 0.5)
 = (int) (2)
 = **2**
a = 1 which would normally round to 1:
   (int) (1 + 0.5)
 = (int) (1.5)
 = **1**



, casting any negative decimal will covert the decimal to the rounded-up integer. However, we want decimals less than 0.5 to round up and the rest to round down. In the same opposite nature, we subtract 0.5 to the double before casting like so:

Examples:
a = -1.3 which would normally round to -1:
   (int) (-1.3 - 0.5)
 = (int) (-1.8)
 = **-1**
a = -1.8 which would normally round to -2:
   (int) (-1.8 - 0.5)
 = (int) (-2.3)
 = -**2**
a = -1.5 which would normally round to -2:
   (int) (-1.5 - 0.5)
 = (int) (-2)
 = -**2**
a = -1 which would normally round to -1:
   (int) (-1 - 0.5)
 = (int) (-1.5)
 = -**1**



Join our community

Unit 1: Primitive Types

AP Computer Science A

all

videos

study guides

browse by units

Free Reviews