zuai-logo
zuai-logo
  2. AP Computer Science A
FlashcardFlashcardStudy GuideStudy Guide
Question BankQuestion BankGlossaryGlossary

Compound Assignment Operators

Emily Wilson

Emily Wilson

14 min read

Next Topic - Casting and Ranges of Variables

Listen to this study note

Study Guide Overview

This AP Computer Science A study guide covers primitive types and operators, control flow (if, for, while loops, boolean expressions), the String class (methods, concatenation), classes and objects (constructors, methods, inheritance, polymorphism), arrays (basics, traversing), ArrayLists (methods, traversing), 2D arrays, and recursion. It includes practice questions and emphasizes code tracing, exam tips, and common mistakes to avoid.

#AP Computer Science A: Ultimate Study Guide 🚀

Hey there, future AP Computer Science A rockstar! This guide is designed to be your best friend the night before the exam. We'll break down the key concepts, offer memory aids, and give you the confidence you need to ace this test. Let's do this! 💪

#1. Primitive Types and Operators

#1.1. Data Types

  • int: Whole numbers (e.g., -3, 0, 42). 💡
  • double: Decimal numbers (e.g., -3.14, 0.0, 2.718). 💡
  • boolean: true or false. 💡
Key Concept

Remember: int and double are numeric types, while boolean is for logical values. These are your building blocks!

#1.2. Arithmetic Operators

  • + (addition), - (subtraction), * (multiplication), / (division), % (modulo - remainder). 💡
  • Integer division truncates (e.g., 5 / 2 is 2).
  • Modulo gives the remainder (e.g., 5 % 2 is 1).
Memory Aid

PEMDAS (Parentheses, Exponents, Multiplication and Division, Addition and Subtraction) is your best friend for order of operations. Remember it!

#1.3. Compound Assignment Operators

  • +=, -=, *=, /=, %= combine an operation and assignment.
  • x += 5 is the same as x = x + 5. Super handy! 💡

#1.4. Increment and Decrement Operators

  • ++ increments by 1, -- decrements by 1. * Post-increment (x++): Returns the original value of x, then increments.
  • Pre-increment (++x): Increments x, then returns the new value.
Exam Tip

For the AP exam, you'll mostly see the post-increment (x++) and post-decrement (x--) operators. Focus on how they change the value after the current statement.

#1.5. Code Tracing

  • Follow code line by line, tracking variable changes. Use trace tables if it helps!

  • Pay close attention to how compound assignment and increment/decrement operators modify variables.

Practice Question
json
{
  "mcq": [
    {
      "question": "What is the value of `x` after the following code executes? `int x = 5; x += 3; x--;`",
      "options": ["6", "7", "8", "9"],
      "answer": "7"
    },
    {
      "question": "What is the value of `y` after the following code executes? `int y = 10; y /= 2; y %= 3;`",
      "options": ["0", "1", "2", "3"],
      "answer": "2"
    }
  ],
  "frq": {
    "question": "Consider the following code segment:\n```
java\nint a = 12;\nint b = 5;\nint c = 0;\na -= b;\nb *= 2;\nc = a % b;\na += c;\nb = a - b;\nc *= b;\n```
\n\n(a) What are the final values of a, b, and c? Show your work by tracing the code.",
    "answer": "(a) \n* a -= b; // a = 12 - 5 = 7\n* b *= 2; // b = 5 * 2 = 10\n* c = a % b; // c = 7 % 10 = 7\n* a += c; // a = 7 + 7 = 14\n* b = a - b; // b = 14 - 10 = 4\n* c *= b; // c = 7 * 4 = 28\n\nFinal values: a = 14, b = 4, c = 28\n",
    "scoring": {
      "a": "1 point for correct value of a, 1 point for showing work",
      "b": "1 point for correct value of b, 1 point for showing work",
      "c": "1 point for correct value of c, 1 point for showing work"
     }
   }
}

#2. Control Flow

#2.1. if Statements

  • Execute code blocks based on conditions.
  • if (condition) { /* code */ }
  • if (condition) { /* code */ } else { /* code */ }
  • if (condition1) { /* code */ } else if (condition2) { /* code */ } else { /* code */ }

#2.2. for Loops

  • Repeat code a specific number of times.
  • for (initialization; condition; update) { /* code */ }
  • Example: for (int i = 0; i < 10; i++) { /* code */ }

#2.3. while Loops

  • Repeat code while a condition is true.
  • while (condition) { /* code */ }
  • Be careful of infinite loops! ⚠️

#2.4. Boolean Expressions

  • Combine conditions using && (AND), || (OR), ! (NOT).
  • true && true is true, true && false is false.
  • true || false is true, false || false is false.
  • !true is false, !false is true.
Memory Aid

Remember AND only returns true if both conditions are true. OR returns true if at least one condition is true. NOT reverses the boolean value.

Common Mistake

Be careful with the difference between = (assignment) and == (equality check) in conditions. Using = in an if statement will cause a compilation error.

#2.5. Short-Circuit Evaluation

  • For &&, if the first condition is false, the second isn't evaluated.

  • For ||, if the first condition is true, the second isn't evaluated.

Practice Question
json
{
  "mcq": [
    {
      "question": "What will be printed by the following code? `int x = 5; if (x > 3) { System.out.print(\"A\"); } else { System.out.print(\"B\"); }`",
      "options": ["A", "B", "AB", "Nothing"],
      "answer": "A"
    },
    {
      "question": "How many times will the following loop execute? `for (int i = 0; i < 7; i += 2) { System.out.print(i); }`",
      "options": ["3", "4", "7", "8"],
      "answer": "4"
    }
   ],
  "frq": {
    "question": "Write a method `countEven` that takes an integer array `arr` and returns the number of even numbers in the array. For example, if `arr` is `{1, 2, 3, 4, 5, 6}`, the method should return `3`.",
    "answer": "```
java\npublic int countEven(int[] arr) {\n    int count = 0;\n    for (int num : arr) {\n        if (num % 2 == 0) {\n            count++;\n        }\n    }\n    return count;\n}\n```
",
    "scoring": {
      "initialization": "1 point for initializing the count variable",
      "loop": "1 point for correct `for` or `while` loop structure",
      "conditional": "1 point for correct conditional statement to check for even numbers",
      "increment": "1 point for incrementing the count correctly",
      "return": "1 point for returning the correct count"
    }
  }
}

#3. String Class

#3.1. String Basics

  • Strings are sequences of characters.
  • Created using double quotes: String str = "Hello";
  • Strings are immutable (cannot be changed after creation).

#3.2. String Methods

  • length(): Returns the number of characters.
  • substring(int start, int end): Returns a substring from start (inclusive) to end (exclusive).
  • indexOf(String str): Returns the index of the first occurrence of str.
  • equals(String other): Checks if two strings have the same content (case-sensitive).
  • compareTo(String other): Compares two strings lexicographically (dictionary order).
Quick Fact

Remember: Strings are objects, so you must use .equals() to compare their content, not ==.

#3.3. String Concatenation

  • Use + to combine strings.

  • Example: String message = "Hello, " + name + "!";

Practice Question
json
{
  "mcq": [
    {
      "question": "What is the output of the following code? `String s = \"Computer\"; System.out.println(s.substring(2, 5));`",
      "options": ["mpu", "omp", "put", "mput"],
      "answer": "mpu"
    },
    {
      "question": "Which of the following correctly compares two strings `str1` and `str2` for equality?",
      "options": ["str1 == str2", "str1.equals(str2)", "str1.compareTo(str2) == 0", "str1.equalsIgnoreCase(str2)"],
      "answer": "str1.equals(str2)"
    }
  ],
  "frq": {
    "question": "Write a method `reverseString` that takes a String `str` and returns its reversed version. For example, if `str` is \"hello\", the method should return \"olleh\".",
    "answer": "```
java\npublic String reverseString(String str) {\n    String reversed = \"";\n    for (int i = str.length() - 1; i >= 0; i--) {\n        reversed += str.charAt(i);\n    }\n    return reversed;\n}\n```
",
    "scoring": {
      "initialization": "1 point for initializing the reversed string",
      "loop": "1 point for correct `for` loop structure (going backwards)",
      "character_access": "1 point for accessing the characters correctly",
      "concatenation": "1 point for concatenating the characters to the reversed string",
      "return": "1 point for returning the reversed string"
    }
  }
}

#4. Classes and Objects

#4.1. Classes

  • Blueprints for creating objects.
  • Contain data (fields/instance variables) and behavior (methods).
  • Example:

java public class Dog { private String name; private int age;

    public Dog(String name, int age) { ... }
    public void bark() { ... }
}
```

#4.2. Objects

  • Instances of a class.
  • Created using the new keyword: Dog myDog = new Dog("Buddy", 3);

#4.3. Instance Variables

  • Data associated with each object.
  • Declared inside the class but outside any method.
  • Use private for encapsulation (data hiding).

#4.4. Constructors

  • Special methods used to initialize objects.
  • Have the same name as the class.
  • No return type (not even void).

#4.5. Methods

  • Define the behavior of objects.
  • Can have parameters and return values.
  • Example: public void bark() { System.out.println("Woof!"); }

#4.6. this Keyword

  • Refers to the current object.
  • Used to distinguish between instance variables and parameters with the same name.
Key Concept

Classes are like cookie cutters, and objects are the cookies. Each object has its own set of instance variables.

Practice Question
json
{
  "mcq": [
    {
      "question": "Which keyword is used to create an object of a class?",
      "options": ["class", "object", "new", "instance"],
      "answer": "new"
    },
    {
      "question": "What is the purpose of a constructor?",
      "options": ["To create a class", "To initialize an object", "To define methods", "To declare variables"],
      "answer": "To initialize an object"
    }
  ],
  "frq": {
    "question": "Create a class `Rectangle` with the following:\n    *   Instance variables: `width` (int) and `height` (int)\n    *   Constructor: Takes `width` and `height` as parameters and initializes the instance variables.\n    *   Method: `getArea()` that returns the area of the rectangle.",
    "answer": "```
java\npublic class Rectangle {\n    private int width;\n    private int height;\n\n    public Rectangle(int width, int height) {\n        this.width = width;\n        this.height = height;\n    }\n\n    public int getArea() {\n        return width * height;\n    }\n}\n```
",
    "scoring": {
      "instance_variables": "1 point for declaring instance variables correctly",
      "constructor": "1 point for creating a constructor that initializes the instance variables",
      "getArea_method": "1 point for creating the `getArea` method",
      "return_value": "1 point for returning the correct area",
      "encapsulation": "1 point for using private instance variables"
    }
  }
}

#5. Arrays

#5.1. Array Basics

  • Ordered collections of elements of the same type.
  • Fixed size (cannot be changed after creation).
  • Created using new: int[] numbers = new int[5];
  • Access elements using index (starting from 0): numbers[0] = 10;

#5.2. Array Length

  • Use array.length to get the number of elements in an array (not a method, no parenthesis).

#5.3. Traversing Arrays

  • Use for loops to iterate through array elements.
  • Example: for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); }

#5.4. Enhanced for Loop

  • Simplified way to traverse arrays or collections.
  • for (type element : array) { /* code */ }
  • Example: for (int num : numbers) { System.out.println(num); }
Common Mistake

Array indices start from 0, not 1. Accessing an index out of bounds will cause an ArrayIndexOutOfBoundsException.

Practice Question
json
{
  "mcq": [
    {
      "question": "What is the index of the first element in an array?",
      "options": ["0", "1", "-1", "array.length"],
      "answer": "0"
    },
    {
      "question": "What is the output of the following code? `int[] arr = {1, 2, 3}; System.out.println(arr.length);`",
      "options": ["2", "3", "4", "Error"],
      "answer": "3"
    }
  ],
  "frq": {
    "question": "Write a method `sumArray` that takes an integer array `arr` and returns the sum of all elements in the array.",
    "answer": "```
java\npublic int sumArray(int[] arr) {\n    int sum = 0;\n    for (int num : arr) {\n        sum += num;\n    }\n    return sum;\n}\n```
",
    "scoring": {
      "initialization": "1 point for initializing the sum variable",
      "loop": "1 point for correct `for` loop structure",
      "summation": "1 point for adding the elements correctly",
      "return": "1 point for returning the correct sum"
    }
  }
}

#6. ArrayList

#6.1. ArrayList Basics

  • Dynamic, resizable arrays.
  • Part of the java.util package: import java.util.ArrayList;
  • Created using new: ArrayList<Integer> numbers = new ArrayList<>();

#6.2. ArrayList Methods

  • add(element): Adds an element to the end.
  • add(index, element): Inserts an element at a specific index.
  • get(index): Returns the element at a specific index.
  • set(index, element): Replaces the element at a specific index.
  • remove(index): Removes the element at a specific index.
  • size(): Returns the number of elements.

#6.3. Traversing ArrayLists

  • Use for loops or enhanced for loops, similar to arrays.

ArrayList is a very important topic. Make sure you know how to add, remove, and access elements.

Practice Question
json
{
  "mcq": [
    {
      "question": "Which method is used to add an element to the end of an ArrayList?",
      "options": ["add()", "insert()", "append()", "push()"],
      "answer": "add()"
    },
    {
      "question": "What is the output of the following code? `ArrayList<String> list = new ArrayList<>(); list.add(\"A\"); list.add(\"B\"); System.out.println(list.size());`",
      "options": ["0", "1", "2", "Error"],
      "answer": "2"
    }
  ],
  "frq": {
    "question": "Write a method `removeEven` that takes an ArrayList of Integers and removes all even numbers from the list.",
    "answer": "```
java\npublic void removeEven(ArrayList<Integer> list) {\n    for (int i = 0; i < list.size(); i++) {\n        if (list.get(i) % 2 == 0) {\n            list.remove(i);\n            i--; // Adjust index after removal\n        }\n    }\n}\n```
",
    "scoring": {
      "loop": "1 point for correct `for` loop structure",
      "conditional": "1 point for correct conditional statement to check for even numbers",
      "removal": "1 point for removing the element correctly",
      "index_adjustment": "1 point for adjusting the index after removal",
      "void_return": "1 point for not returning anything"
    }
  }
}

#7. 2D Arrays

#7.1. 2D Array Basics

  • Arrays of arrays, representing tables or grids.
  • Created using new: int[][] matrix = new int[3][4];
  • Access elements using two indices: matrix[row][col] = 10;

#7.2. Traversing 2D Arrays

  • Use nested for loops to iterate through rows and columns.
  • Example:

java for (int row = 0; row < matrix.length; row++) { for (int col = 0; col < matrix[row].length; col++) { System.out.print(matrix[row][col] + " "); } System.out.println(); } ```

Exam Tip

Remember: matrix.length gives the number of rows, and matrix[row].length gives the number of columns in a specific row.

Practice Question
json
{
  "mcq": [
    {
      "question": "How do you access the element in the second row and third column of a 2D array named `matrix`?",
      "options": ["matrix[1][2]", "matrix[2][1]", "matrix[2, 3]", "matrix[3, 2]"],
      "answer": "matrix[1][2]"
    },
    {
      "question": "What does `matrix.length` represent for a 2D array named `matrix`?",
      "options": ["Number of columns", "Number of rows", "Total number of elements", "Length of the first row"],
      "answer": "Number of rows"
    }
  ],
  "frq": {
    "question": "Write a method `sum2DArray` that takes a 2D array of integers and returns the sum of all elements in the array.",
    "answer": "```
java\npublic int sum2DArray(int[][] matrix) {\n    int sum = 0;\n    for (int row = 0; row < matrix.length; row++) {\n        for (int col = 0; col < matrix[row].length; col++) {\n            sum += matrix[row][col];\n        }\n    }\n    return sum;\n}\n```
",
    "scoring": {
      "initialization": "1 point for initializing the sum variable",
      "outer_loop": "1 point for correct outer `for` loop structure",
      "inner_loop": "1 point for correct inner `for` loop structure",
      "summation": "1 point for adding the elements correctly",
      "return": "1 point for returning the correct sum"
    }
  }
}

#8. Inheritance and Polymorphism

#8.1. Inheritance

  • Allows a class (subclass/child) to inherit properties and methods from another class (superclass/parent).
  • Use the extends keyword: public class Dog extends Animal { ... }
  • Promotes code reuse and establishes an IS-A relationship.

#8.2. super Keyword

  • Used to call the constructor or methods of the superclass.
  • Example: super(name, age);

#8.3. Method Overriding

  • Subclass provides its own implementation of a method that is already defined in the superclass.
  • Use the @Override annotation.

#8.4. Polymorphism

  • Ability of an object to take on many forms.
  • Achieved through inheritance and method overriding.
  • Example: Animal myAnimal = new Dog(); myAnimal.makeSound(); (calls the makeSound method of the Dog class).
Memory Aid

Think of inheritance as a family tree. The child inherits traits from the parent. Polymorphism means "many forms," like a shape that can be a circle, square, or triangle.

Practice Question
json
{
  "mcq": [
    {
      "question": "Which keyword is used to indicate that a class inherits from another class?",
      "options": ["implements", "inherits", "extends", "includes"],
      "answer": "extends"
    },
    {
      "question": "What is method overriding?",
      "options": ["Creating a new method", "Hiding a method", "Providing a new implementation of an inherited method", "Calling a superclass method"],
      "answer": "Providing a new implementation of an inherited method"
    }
  ],
  "frq": {
    "question": "Create a class `Animal` with the following:\n    *   Instance variable: `name` (String)\n    *   Constructor: Takes `name` as a parameter and initializes the instance variable.\n    *   Method: `makeSound()` that prints \"Generic animal sound\".\n    Create a subclass `Dog` that extends `Animal` with the following:\n    *   Constructor: Takes `name` as a parameter and calls the superclass constructor.\n    *   Overrides the `makeSound()` method to print \"Woof!\".",
    "answer": "```
java\nclass Animal {\n    private String name;\n    public Animal(String name) {\n        this.name = name;\n    }\n    public void makeSound() {\n        System.out.println(\"Generic animal sound\");\n    }\n}\n\nclass Dog extends Animal {\n    public Dog(String name) {\n        super(name);\n    }\n    @Override\n    public void makeSound() {\n        System.out.println(\"Woof!\");\n    }\n}\n```
",
    "scoring": {
      "animal_class": "1 point for creating the `Animal` class with correct instance variable and constructor",
      "animal_makeSound": "1 point for creating the `makeSound` method in `Animal` class",
      "dog_class": "1 point for creating the `Dog` class that extends `Animal`",
      "dog_constructor": "1 point for creating the `Dog` constructor that calls the superclass constructor",
      "dog_override": "1 point for correctly overriding the `makeSound` method in `Dog` class"
    }
  }
}

#9. Recursion

#9.1. Recursive Methods

  • Methods that call themselves.
  • Must have a base case (to stop the recursion) and a recursive step.

#9.2. Example: Factorial

java
public int factorial(int n) {
    if (n == 0) {
        return 1; // Base case
    } else {
        return n * factorial(n - 1); // Recursive step
    }
}

#9.3. Example: Fibonacci

java
public int fibonacci(int n) {
    if (n <= 1) {
        return n; // Base case
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2); // Recursive step
    }
}
Common Mistake

Forgetting the base case or having an incorrect base case will lead to infinite recursion and a StackOverflowError.

Practice Question
json
{
  "mcq": [
    {
      "question": "What is a base case in a recursive method?",
      "options": ["The recursive call", "The condition that stops the recursion", "The method's return type", "The method's parameters"],
      "answer": "The condition that stops the recursion"
    },
    {
      "question": "What happens if a recursive method does not have a base case?",
      "options": ["It will run faster", "It will cause a StackOverflowError", "It will return 0", "It will return null"],
      "answer": "It will cause a StackOverflowError"
    }
  ],
  "frq": {
    "question": "Write a recursive method `sumDigits` that takes an integer `n` and returns the sum of its digits. For example, if `n` is `123`, the method should return `6`.",
    "answer": "```
java\npublic int sumDigits(int n) {\n    if (n < 10) {\n        return n; // Base case\n    } else {\n        return n % 10 + sumDigits(n / 10); // Recursive step\n    }\n}\n```
",
    "scoring": {
      "base_case": "1 point for correct base case",
      "recursive_call": "1 point for correct recursive call",
      "modulus": "1 point for using modulus operator correctly",
      "division": "1 point for using division operator correctly",
      "return": "1 point for returning the correct sum"
    }
  }
}

#Final Exam Focus 🎯

#High-Priority Topics

  • Primitive Types and Operators: Essential for all code.
  • Control Flow: if, for, while are fundamental.
  • String Class: Common in many problems.
  • Classes and Objects: Core to object-oriented programming.
  • Arrays and ArrayLists: Data structures you'll use frequently.
  • Inheritance and Polymorphism: Key for advanced topics.
  • Recursion: Appears in some FRQs.

#Common Question Types

  • Multiple Choice: Testing knowledge of concepts and code tracing.
  • Free Response: Writing methods, classes, and algorithms.

#Last-Minute Tips

  • Time Management: Don't spend too long on one question. Move on and come back if needed.
  • Code Tracing: Practice tracing code carefully, especially with loops and conditional statements.
  • Read Carefully: Pay attention to the details in the question. Understand what the problem is asking before you start coding.
  • Practice, Practice, Practice: The more you practice, the more confident you'll feel.

#You've Got This! 🎉

Remember, you've come a long way. Take a deep breath, stay calm, and trust your preparation. You're ready to rock this exam! Go get 'em! 🚀

Explore more resources

FlashcardFlashcard

Flashcard

Continute to Flashcard

Question BankQuestion Bank

Question Bank

Continute to Question Bank

Mock ExamMock Exam

Mock Exam

Continute to Mock Exam

Feedback stars icon

How are we doing?

Give us your feedback and let us know how we can improve

Previous Topic - Expressions and Assignment StatementsNext Topic - Casting and Ranges of Variables

Question 1 of 11

What is the value of x after the code int x = 10; x += 5; executes? ➕

5

10

15

20