Oracle Resources¶

Oracle Java Foundations (1Z0-811) — Deep Dive Topic Reference¶

Each section is the best placement in the AP CSA pacing guide, explains the concept in full, and provides classroom-ready examples with common exam traps highlighted.

TABLE OF CONTENTS¶

JVM & JRE — Platform Architecture
The this Keyword — Nuances & Traps
OOP Principles — Encapsulation, Inheritance, Polymorphism, Abstraction
Packages & the CLASSPATH
Access Modifiers & Visibility
Throwable Hierarchy & Exception Handling
“Swallowing” — Empty Catch Blocks
Comparing — == vs .equals() vs compareTo()
Visibility Scope vs. Lifespan (Storage) Scope

1. JVM & JRE¶

📍 Best Placement in CSA Curriculum¶

Unit 1, Week 1 — immediately after “Why Java?” before writing the first program. Students need this mental model before they compile anything.

Concept Overview¶

  You write:        HelloWorld.java      ← Human-readable source code
  javac compiles:   HelloWorld.class     ← Bytecode (platform-NEUTRAL)
  JVM executes:     bytecode → native    ← Platform-SPECIFIC translation

Component	What It Is	What It Does	Analogy
JDK (Java Development Kit)	Developer toolkit	Includes `javac` compiler, debugger, `javadoc`	The full workshop
JRE (Java Runtime Environment)	Runtime only	Includes JVM + standard libraries (no compiler)	The engine to run the car
JVM (Java Virtual Machine)	Software interpreter	Translates bytecode to native machine code at runtime	A universal translator

Key Exam Nuances¶

1. “Write once, run anywhere” — but HOW? The .class bytecode is platform-neutral. The JVM is platform-specific (there is a different JVM for Windows, Mac, Linux). The JVM is what makes Java portable, not the source code.

// HelloWorld.java compiles to HelloWorld.class (same on ALL platforms)
// The JVM on Windows reads that .class file differently than the JVM on Linux
// BUT the bytecode itself never changes — that's the portability

2. JRE contains the JVM — the JDK contains the JRE

JDK ⊃ JRE ⊃ JVM

To RUN a Java program: you need a JRE (or JDK)
To COMPILE a Java program: you need a JDK
End users only need the JRE

3. Memory management — Java vs C++ The exam tests: “Does Java allow direct memory management (like C++ pointers)?”

No. Memory is managed entirely by the JVM’s garbage collector. Programmers cannot access memory addresses directly.

4. The String Pool lives in JVM memory

String s1 = "hello";           // JVM checks pool → creates 1 object in pool
String s2 = "hello";           // JVM finds "hello" in pool → NO new object created
String s3 = new String("hello"); // Forces NEW object in heap (bypasses pool)

System.out.println(s1 == s2);  // true  (same pool reference)
System.out.println(s1 == s3);  // false (s3 is a different heap object)
System.out.println(s1.equals(s3)); // true (same content)

⚠️ Exam Trap: new String("hello") creates TWO objects — one in the pool (due to the literal) and one in the heap (due to new).

5. Execution flow diagram

HelloWorld.java
      ↓  javac (compiler in JDK)
HelloWorld.class  ← bytecode, not native code
      ↓  java command triggers JVM
   JVM loads class
      ↓  Just-In-Time (JIT) compiler
   Native machine code executes
      ↓
   Output to console

✅ Practice Question¶

Q: You compiled HelloWorld.java on a Windows machine and got HelloWorld.class.
   Can you run HelloWorld.class on a Mac?

A: Yes — IF a JRE (or JDK) is installed on the Mac. The .class bytecode is
   platform-neutral. The Mac's JVM translates it to Mac native code at runtime.

2. The `this` Keyword¶

📍 Best Placement in CSA Curriculum¶

Unit 3, Week 12 (3.9) — taught alongside constructors and instance variables. Revisit during Inheritance (Week 17) when super is introduced as a contrast.

Concept Overview¶

this is a reference to the current object — the instance whose method or constructor is currently executing.

Use Case 1 — Disambiguate field from parameter (most common)¶

public class Dog {
    private String name;   // instance variable
    private int age;

    // WITHOUT this — BROKEN (parameter shadows the field)
    public Dog(String name, int age) {
        name = name;   // ← assigns parameter to itself! field is never set
        age = age;     // ← same problem
    }
}

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

    // WITH this — CORRECT
    public Dog(String name, int age) {
        this.name = name;   // this.name = field, name = parameter
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;   // same pattern in setters
    }
}

Use Case 2 — Constructor chaining with `this()`¶

public class Rectangle {
    private int width;
    private int height;
    private String color;

    // Full constructor
    public Rectangle(int width, int height, String color) {
        this.width = width;
        this.height = height;
        this.color = color;
    }

    // Delegates to full constructor — avoids duplicating logic
    public Rectangle(int width, int height) {
        this(width, height, "black");   // ← this() calls another constructor
    }

    // Single-arg delegates too
    public Rectangle(int size) {
        this(size, size);               // calls the 2-arg constructor above
    }
}

⚠️ Exam Trap #1: this() must be the first statement in a constructor. The following will NOT compile:
public Rectangle(int size) {
    System.out.println("Creating square"); // ← COMPILE ERROR — this() must be first
    this(size, size);
}

⚠️ Exam Trap #2: this() cannot be used in a regular method — ONLY in constructors.
public void reset() {
    this(0, 0, "black");  // ← COMPILE ERROR — not a constructor
}

Use Case 3 — Passing the current object as an argument¶

public class Button {
    private String label;

    public Button(String label) {
        this.label = label;
    }

    public void click() {
        EventSystem.register(this);  // passes THIS button to the event system
    }
}

`this` vs `super` — Key Contrast for Inheritance Week¶

Keyword	Refers to	Used in
`this`	Current object / current class constructor	Methods & constructors
`super`	Parent class / parent class constructor	Methods & constructors
`this()`	Another constructor in the SAME class	Constructors only (must be first line)
`super()`	Constructor of the PARENT class	Constructors only (must be first line)

⚠️ Exam Trap: You CANNOT use both this() AND super() in the same constructor. Each must be the first line — so only one can exist.

3. OOP Principles¶

📍 Best Placement in CSA Curriculum¶

Encapsulation → Unit 3, Week 12 (with 3.1–3.5)
Inheritance & Polymorphism → Inheritance unit, Weeks 16–18
Abstraction → briefly in Unit 1.7 (Objects concept) and revisited in Inheritance

The Four Pillars¶

3A. Encapsulation¶

“Bundle data and the methods that operate on it; hide the internals.”

public class BankAccount {
    private double balance;    // ← PRIVATE — hidden from outside

    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        }
    }

    // Controlled access via public methods
    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) balance -= amount;
        else System.out.println("Insufficient funds");
    }
}

// Outside the class:
BankAccount acct = new BankAccount(500);
// acct.balance = -9999;   ← COMPILE ERROR — private field protected!
acct.withdraw(100);         // ← must go through the validated method
System.out.println(acct.getBalance()); // 400.0

Why it matters on the exam: Questions about private vs public fields often test whether you understand that access through getters/setters allows validation that direct field access does not.

3B. Inheritance¶

“A subclass acquires the non-private fields and methods of its superclass.”

// Superclass
public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() { return name; }

    public String speak() {
        return "...";
    }
}

// Subclass
public class Dog extends Animal {
    private String breed;

    public Dog(String name, String breed) {
        super(name);           // ← MUST call parent constructor first
        this.breed = breed;
    }

    @Override
    public String speak() {
        return "Woof!";        // ← overrides Animal's speak()
    }

    public String getBreed() { return breed; }
}

// Usage
Animal a = new Dog("Rex", "Lab");  // polymorphism — Animal reference, Dog object
System.out.println(a.speak());     // "Woof!" — Dog's version called (dynamic dispatch)
System.out.println(a.getName());   // "Rex" — inherited from Animal

⚠️ Exam Trap: Subclasses do NOT inherit private members — they exist in the object but are invisible to the subclass. Access them through inherited public or protected getters.

3C. Polymorphism¶

“One interface, many forms — the correct method is chosen at runtime.”

Animal[] zoo = {
    new Dog("Rex", "Lab"),
    new Cat("Whiskers"),
    new Animal("Generic")
};

for (Animal a : zoo) {
    System.out.println(a.getName() + " says: " + a.speak());
    // Output depends on the ACTUAL type at runtime, not the declared type
}
// Rex says: Woof!
// Whiskers says: Meow!
// Generic says: ...

Compile-time vs Runtime type:

Animal a = new Dog("Rex", "Lab");
// Compile-time type: Animal  (what the compiler sees)
// Runtime type:      Dog     (what actually runs)

a.speak();       // ✔ calls Dog.speak() — runtime type wins for OVERRIDDEN methods
a.getBreed();    // ✘ COMPILE ERROR — Animal doesn't know about getBreed()
                 //   must cast: ((Dog) a).getBreed()

3D. Abstraction¶

“Expose what an object does, not how it does it.”

This is enforced through private fields + public methods (encapsulation) and through abstract classes/interfaces (beyond AP CSA scope but on Oracle exam).

// Users of BankAccount don't need to know HOW balance is stored
// They just know: deposit(), withdraw(), getBalance() exist
// That's abstraction in practice

4. Packages & CLASSPATH¶

📍 Best Placement in CSA Curriculum¶

Unit 1, Week 2 (1.3) alongside import statements, and revisit briefly in Unit 3, Week 12 when students write their own classes.

Concept Overview¶

A package is a namespace that organizes related classes, similar to folders on a hard drive.

src/
  com/
    school/
      Student.java          ← package com.school;
      Teacher.java          ← package com.school;
    math/
      Calculator.java       ← package com.math;

Declaring a Package¶

// File: com/school/Student.java
package com.school;         // ← MUST be the first non-comment line

public class Student {
    private String name;
    private int grade;

    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
    // ...
}

Importing a Package¶

// Three ways to use a class from another package:

// Option 1 — fully qualified name (no import needed, but verbose)
com.school.Student s = new com.school.Student("Ana", 11);

// Option 2 — import specific class
import com.school.Student;
Student s = new Student("Ana", 11);

// Option 3 — import entire package (wildcard)
import com.school.*;
Student s = new Student("Ana", 11);
Teacher t = new Teacher("Ms. Smith");

⚠️ Exam Trap #1: import does NOT import sub-packages. import com.school.* does NOT import com.school.honors.HonorsStudent. Sub-packages must be imported separately.

⚠️ Exam Trap #2: java.lang is automatically imported — you never need to write import java.lang.String or import java.lang.Math.

⚠️ Exam Trap #3: package statement must come BEFORE import statements:

package com.school;    // 1st: package declaration
import java.util.*;    // 2nd: imports
public class Student { // 3rd: class definition

The CLASSPATH¶

The CLASSPATH tells the JVM where to look for .class files.

// Running from command line:
java -classpath /home/student/classes com.school.Student

// Or with environment variable:
CLASSPATH=/home/student/classes
java com.school.Student

On the exam: Know that if a class cannot be found, the JVM throws a ClassNotFoundException or NoClassDefFoundError at runtime. This is a CLASSPATH problem, not a code problem.

`java.lang` vs `java.util` — What’s Automatically Available¶

Always Available (java.lang)	Must Import (java.util)
`String`, `Math`, `Integer`, `Double`	`ArrayList`, `Scanner`
`Object`, `System`, `StringBuilder`	`Random`, `Arrays`
All wrapper classes	`HashMap`, `List`

5. Access Modifiers & Visibility¶

📍 Best Placement in CSA Curriculum¶

Unit 3, Weeks 12–14 (3.1, 3.4, 3.8) — taught progressively as fields, then methods, then scope are introduced.

The Four Access Levels¶

Modifier	Same Class	Same Package	Subclass	Anywhere
`private`	✔	✘	✘	✘
(default / package-private)	✔	✔	✘	✘
`protected`	✔	✔	✔	✘
`public`	✔	✔	✔	✔

AP CSA focuses on private and public. The Oracle exam adds protected and default (no modifier).

Examples Across All Four Levels¶

package com.school;

public class Student {
    public    String schoolName = "Lincoln High";  // anyone can access
    protected String studentId  = "S-1042";        // subclasses + same package
              String nickname    = "Ace";           // default: same package only
    private   double gpa         = 3.8;             // this class ONLY

    public double getGpa() { return gpa; }          // public getter for private field
}

package com.school;

public class HonorStudent extends Student {
    public void printInfo() {
        System.out.println(schoolName);   // ✔ public
        System.out.println(studentId);    // ✔ protected — accessible in subclass
        System.out.println(nickname);     // ✔ default — same package
        // System.out.println(gpa);       // ✘ COMPILE ERROR — private
        System.out.println(getGpa());     // ✔ uses the public method instead
    }
}

package com.athletics;       // DIFFERENT package

import com.school.Student;

public class Coach {
    public void check(Student s) {
        System.out.println(s.schoolName);  // ✔ public
        // System.out.println(s.studentId); // ✘ protected — different package, not subclass
        // System.out.println(s.nickname);  // ✘ default — different package
        // System.out.println(s.gpa);       // ✘ private
    }
}

Applying to Methods — Same Rules¶

public class Calculator {
    // private helper — implementation detail, not exposed
    private double validateInput(double x) {
        return Math.abs(x);
    }

    // public API — what callers use
    public double squareRoot(double x) {
        return Math.sqrt(validateInput(x));
    }
}

⚠️ Exam Trap: A class itself can only be public or default (no modifier). You cannot declare a top-level class as private or protected.

⚠️ Exam Trap: private members are NOT inherited. They exist in the subclass object’s memory, but the subclass code cannot reference them directly — even with super.

6. Throwable Hierarchy & Exception Handling¶

📍 Best Placement in CSA Curriculum¶

Unit 2, Week 10 (2.12 Debugging) — introduce the hierarchy and checked vs. unchecked. Revisit in Unit 4, Week 25 (File I/O) where checked exceptions (IOException) become unavoidable.

The Throwable Hierarchy¶

java.lang.Throwable
├── java.lang.Error               ← JVM-level, do NOT catch
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── VirtualMachineError
└── java.lang.Exception           ← application-level, handle these
    ├── IOException               ← CHECKED (must declare or catch)
    │   └── FileNotFoundException
    ├── SQLException              ← CHECKED
    ├── RuntimeException          ← UNCHECKED (don't have to catch)
    │   ├── ArithmeticException       (divide by zero)
    │   ├── NullPointerException      (null reference)
    │   ├── ArrayIndexOutOfBoundsException
    │   ├── ClassCastException
    │   ├── NumberFormatException     (Integer.parseInt("abc"))
    │   └── IllegalArgumentException
    └── ...

Checked vs. Unchecked¶

	Checked	Unchecked
Parent class	`Exception` (not RuntimeException)	`RuntimeException` or `Error`
Must handle?	Yes — compile error if not	No — optional
Typical cause	External resource issues	Programming bugs
Examples	`IOException`, `FileNotFoundException`	`NPE`, `ArrayIndexOutOfBounds`

// UNCHECKED — ArithmeticException — no try/catch required (but good practice)
int result = 10 / 0;    // throws ArithmeticException at runtime

// CHECKED — FileNotFoundException — MUST handle or declare
import java.io.*;
// This will NOT compile without try/catch or throws declaration:
FileReader fr = new FileReader("data.txt");   // ← checked exception!

try / catch / finally Mechanics¶

public class ExceptionDemo {
    public static void main(String[] args) {

        try {
            System.out.println("1 - try starts");
            int x = 5 / 0;                           // ArithmeticException thrown here
            System.out.println("2 - never reached");
        }
        catch (ArithmeticException e) {
            System.out.println("3 - caught ArithmeticException: " + e.getMessage());
        }
        catch (RuntimeException e) {
            System.out.println("4 - never reached — ArithmeticException caught above");
        }
        finally {
            System.out.println("5 - finally ALWAYS runs");
        }

        System.out.println("6 - after try/catch/finally");
    }
}
// Output:
// 1 - try starts
// 3 - caught ArithmeticException: / by zero
// 5 - finally ALWAYS runs
// 6 - after try/catch/finally

⚠️ Exam Trap #1: finally ALWAYS executes — even if a catch block executes return. The only exception is System.exit().

⚠️ Exam Trap #2: Catch blocks must go from MOST specific to LEAST specific. If a parent exception type is caught first, child types can never be reached → compile error.
catch (Exception e)           { }   // ← WRONG ORDER
catch (ArithmeticException e) { }   // ← COMPILE ERROR: already caught above

⚠️ Exam Trap #3: throws in a method signature = declaration (checked exceptions). throw in a method body = actually throwing an exception.
public void readFile(String path) throws IOException {   // declaration
    throw new IOException("File not found");             // throwing
}

`e.getMessage()` vs `e.toString()` vs `e.printStackTrace()`¶

try {
    int[] arr = new int[3];
    arr[10] = 5;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println(e.getMessage());      // "Index 10 out of bounds for length 3"
    System.out.println(e.toString());         // "java.lang.ArrayIndexOutOfBoundsException: Index 10..."
    e.printStackTrace();                      // full stack trace to stderr
}

7. “Swallowing” — Empty Catch Blocks¶

📍 Best Placement in CSA Curriculum¶

Unit 2, Week 10 (2.12 Debugging) — taught as an antipattern immediately after introducing try/catch.

What It Is¶

An empty catch block silently discards an exception. The program continues as if nothing went wrong — but something did.

// ❌ SWALLOWING — this is the antipattern
try {
    int result = Integer.parseInt(userInput);
    process(result);
} catch (NumberFormatException e) {
    // nothing here — exception is "swallowed"
}
// Program continues, result was never set — silent corruption

Why It’s Dangerous¶

// Real classroom example — grade calculator
public static double parseGrade(String input) {
    try {
        return Double.parseDouble(input);
    } catch (NumberFormatException e) {
        // swallowed — returns 0.0 by default
    }
    return 0.0;  // student gets a 0 with no warning or explanation
}

// Called with:
double grade = parseGrade("A+");   // should throw, instead silently returns 0.0
System.out.println("Grade: " + grade);   // Grade: 0.0 — bug invisible to user

What to Do Instead¶

// ✔ Option 1 — Log the error
catch (NumberFormatException e) {
    System.out.println("Invalid input: " + e.getMessage());
}

// ✔ Option 2 — Rethrow as a different exception
catch (NumberFormatException e) {
    throw new IllegalArgumentException("Grade must be a number, got: " + input, e);
}

// ✔ Option 3 — Handle with a default + notification
catch (NumberFormatException e) {
    System.out.println("Could not parse '" + input + "', defaulting to 0.");
    return 0.0;
}

// ✔ Option 4 — Add a comment explaining WHY it's intentionally empty (very rare)
catch (InterruptedException e) {
    // Restore interrupt status — intentional; see Thread.currentThread().interrupt()
    Thread.currentThread().interrupt();
}

Exam Nuance — What Does the Code ACTUALLY Do?¶

// What is the output?
public class Test {
    public static void main(String[] args) {
        int k = 0;
        try {
            System.out.println("1");
            int i = 5 / k;               // ArithmeticException thrown
            System.out.println("2");     // never reached
        } catch (ArithmeticException e) {
            System.out.println("3");     // caught here — empty block version below
        } catch (RuntimeException e) {
            System.out.println("4");
        } finally {
            System.out.println("5");
        }
        System.out.println("6");
    }
}
// Output: 1, 3, 5, 6
// If catch (ArithmeticException e) were EMPTY (swallowed): output would be 1, 5, 6
// — the exception is silently gone but "2" was still skipped

8. Comparing¶

📍 Best Placement in CSA Curriculum¶

== for primitives → Unit 1, Week 2 (1.2 Variables & Expressions)
== vs .equals() for objects → Unit 2, Week 8 (2.7 Comparing Objects)
.compareTo() → Unit 2, Week 8 + Unit 4 (Sorting)
String pool nuances → Unit 1, Week 5 (1.9 String Objects) and revisit in Unit 2

Three Tools, Three Purposes¶

Tool	Works on	Tests
`==`	Primitives & references	Value equality (primitives) OR same memory address (objects)
`.equals()`	Objects	Logical/content equality (as defined by the class)
`.compareTo()`	`Comparable` objects (String, Integer, etc.)	Ordering: negative, zero, positive

Comparing Primitives — `==` is correct¶

int a = 5;
int b = 5;
System.out.println(a == b);   // true — comparing VALUES directly

Comparing Objects — `==` tests REFERENCE, not content¶

String s1 = new String("hello");
String s2 = new String("hello");

System.out.println(s1 == s2);       // FALSE — different objects in heap
System.out.println(s1.equals(s2));  // TRUE — same content

Heap memory:
  s1 ──→ [hello]   ← object at address 0x100
  s2 ──→ [hello]   ← object at address 0x200

  s1 == s2 asks: is 0x100 == 0x200? → false
  s1.equals(s2) asks: is "hello" == "hello"? → true

String Pool Trap (from the Exam)¶

String a = "hello";               // interned in pool
String b = "hello";               // reuses same pool object
String c = new String("hello");   // NEW heap object (bypasses pool)

System.out.println(a == b);       // TRUE  — both point to pool object
System.out.println(a == c);       // FALSE — c is a different heap object
System.out.println(a.equals(c));  // TRUE  — content is same

⚠️ Exam Trap: == on String literals from the pool often returns true — but this is an implementation detail. ALWAYS use .equals() for String content comparison.

`.compareTo()` — Ordering¶

// Returns:  negative  if this < other
//           0         if this == other
//           positive  if this > other

String s1 = "apple";
String s2 = "banana";
String s3 = "apple";

System.out.println(s1.compareTo(s2));   // negative (a < b alphabetically)
System.out.println(s2.compareTo(s1));   // positive
System.out.println(s1.compareTo(s3));   // 0 (equal)

// With integers (wrapper class)
Integer x = 5;
Integer y = 10;
System.out.println(x.compareTo(y));     // negative (5 < 10)

Comparing `null` — A Common Bug¶

String s = null;

// ❌ NullPointerException — s is null, can't call a method on null
if (s.equals("hello")) { ... }

// ✔ Safe — null check first
if ("hello".equals(s)) { ... }   // "hello" is never null

// ✔ Also safe
if (s != null && s.equals("hello")) { ... }

Wrapper Class Integer Caching — Sneaky Trap¶

Integer a = 127;
Integer b = 127;
System.out.println(a == b);   // TRUE — JVM caches integers -128 to 127

Integer x = 128;
Integer y = 128;
System.out.println(x == y);   // FALSE — outside cache range, different objects
System.out.println(x.equals(y)); // TRUE — always use .equals() for Integer objects

⚠️ This is a well-known Oracle exam trap. The safe rule: always use .equals() or .compareTo() for Integer, Double, and other wrapper objects.

9. Visibility Scope vs. Lifespan Scope¶

📍 Best Placement in CSA Curriculum¶

Unit 3, Week 14 (3.8 Scope & Access) — core topic. Revisit briefly in Unit 2, Weeks 8–10 when loop variables are first introduced.

Two Different Questions¶

Question	Concept	The Answer
“Can I read/write this variable here?”	Visibility Scope	Determined by where the variable was declared (block, method, class)
“How long does this variable live in memory?”	Lifespan (Storage) Scope	Determined by the variable’s type (local, instance, static)

Visibility Scope — Four Levels¶

public class ScopeDemo {

    // ── CLASS SCOPE (static) ─────────────────────────────────
    private static int studentCount = 0;     // visible to ALL instances
    //                                          lifespan: from class load until program ends

    // ── INSTANCE SCOPE ───────────────────────────────────────
    private String name;                      // one per object instance
    private int grade;                        //   lifespan: from new() until garbage collected

    // ── METHOD / PARAMETER SCOPE ─────────────────────────────
    public void setGrade(int grade) {         // parameter 'grade' — method scope
        this.grade = grade;                   // 'this.grade' = instance var, 'grade' = param
    }

    public double calculateGpa() {
        double gpa = 0.0;                     // local variable — method scope
        //            lifespan: created when method is called, destroyed when it returns

        // ── BLOCK SCOPE ──────────────────────────────────────
        if (grade >= 90) {
            String honor = "Dean's List";     // block scope — only visible inside this if
            gpa = 4.0;
        }
        // System.out.println(honor);         // ✘ COMPILE ERROR — 'honor' out of scope

        return gpa;
    }
}

Lifespan / Storage Scope — The Three Categories¶

1. Local Variables — shortest life¶

public void calculate() {
    int x = 10;      // created when method is called
    int y = 20;      // created when method is called
    // ...
}                    // x and y are DESTROYED here — eligible for garbage collection
// x and y no longer exist in memory

⚠️ Exam Trap: Local variables are NOT initialized automatically. Using one before assignment is a compile error.
int x;
System.out.println(x);   // ✘ COMPILE ERROR: variable x might not have been initialized

2. Instance Variables — medium life¶

public class Counter {
    private int count;    // auto-initialized to 0 (instance vars get default values)

    public void increment() { count++; }
    public int getCount() { return count; }
}

Counter c1 = new Counter();   // c1.count created in heap
Counter c2 = new Counter();   // c2.count created in heap — SEPARATE from c1.count
c1.increment();
System.out.println(c1.getCount()); // 1
System.out.println(c2.getCount()); // 0 — independent
// When c1 and c2 go out of scope and GC runs, their count fields are destroyed

✅ Instance variables are automatically initialized:

int, long, short, byte → 0

double, float → 0.0

boolean → false

char → '\u0000'

Object references → null

3. Static Variables — longest life¶

public class Counter {
    private static int totalCount = 0;    // ONE copy shared by ALL Counter objects
    private int myCount = 0;              // one copy PER object

    public void increment() {
        myCount++;        // only this object's counter
        totalCount++;     // shared counter — ALL objects see the same value
    }

    public static int getTotalCount() { return totalCount; }
    public int getMyCount() { return myCount; }
}

Counter a = new Counter();
Counter b = new Counter();
a.increment();
a.increment();
b.increment();

System.out.println(a.getMyCount());          // 2
System.out.println(b.getMyCount());          // 1
System.out.println(Counter.getTotalCount()); // 3 — sum of all increments ever
// Static variable lives until the program ends

Variable Shadowing — The Common Bug¶

public class Shadowing {
    private int value = 100;    // instance variable

    public void demonstrate() {
        int value = 200;        // local variable SHADOWS the instance variable
        System.out.println(value);        // 200 — local wins
        System.out.println(this.value);   // 100 — this. accesses instance variable
    }

    public static void shadowStatic() {
        int studentCount = 99;  // local shadows the static field
        System.out.println(studentCount);            // 99 — local
        System.out.println(ScopeDemo.studentCount);  // actual static (if accessible)
    }
}

Loop Variable Scope — Exam Trap¶

// for-loop variable is scoped to the loop
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}
// System.out.println(i);   // ✘ COMPILE ERROR — i doesn't exist here

// while-loop variable declared outside = accessible after
int j = 0;
while (j < 5) {
    j++;
}
System.out.println(j);   // ✔ prints 5 — j still in scope

CURRICULUM INTEGRATION SUMMARY¶

Topic	Primary Placement	Secondary Placement
JVM & JRE architecture	Unit 1, Week 1	Revisit with File I/O (Unit 4, Wk 25)
String pool (JVM memory)	Unit 1, Week 5 (Strings)	Unit 2, Week 8 (Comparing Objects)
`this` disambiguation	Unit 3, Week 12 (Constructors)
`this()` constructor chaining	Unit 3, Week 12 (Constructors)
`this` vs `super`	Inheritance, Week 17
OOP — Encapsulation	Unit 3, Week 12
OOP — Inheritance & Polymorphism	Inheritance, Weeks 16–18
Packages & import	Unit 1, Week 2	Unit 3, Week 12
`java.lang` auto-import	Unit 1, Week 2
Access modifiers (public/private)	Unit 3, Week 12
Access modifiers (protected/default)	Inheritance, Week 16
Throwable hierarchy	Unit 2, Week 10	Unit 4, Week 25 (checked I/O exceptions)
Checked vs unchecked exceptions	Unit 2, Week 10	Unit 4, Week 25
`finally` always runs	Unit 2, Week 10
Catch order (specific → general)	Unit 2, Week 10
Swallowing / empty catch	Unit 2, Week 10
`==` vs `.equals()`	Unit 1, Week 2 (primitives) → Unit 2, Week 8 (objects)
`.compareTo()`	Unit 2, Week 8	Unit 4 (sorting, Week 26)
Integer caching trap (127)	Unit 2, Week 8
null safety when comparing	Unit 2, Week 8
Visibility scope (block/method/class)	Unit 3, Week 14 (3.8)
Lifespan scope (local/instance/static)	Unit 3, Week 14 (3.8)
Variable shadowing	Unit 3, Week 14 (3.8)
Default initialization values	Unit 3, Week 12
Loop variable scope	Unit 2, Week 9 (for loops)

Oracle 1Z0-811 Exam Details: education.oracle.com/java-foundations/pexam_1Z0-811 Sample questions sourced from: enthuware.com/oca-ocp-java-certification-resources/270-java-foundations-exam-sample-questions

Project Header

Place this at the top of the main Class file containing your program’s main() method, place an `external’ block comment containing the following content.

/*=============================================================================
 |   Assignment:  Program #[n]:  [Assignment Title]
 |       Author:  [Your Name (Your E-mail Address)]
 |
 |       Course:  Computer Science A
 |   Instructor:  [title, first-initial of the given name, Surname (Ex. Dr. J. Smith) ] 
 |     Due Date:  [Due Date and Time]
 |
 |  Description:  [Describe the program's goal, IN DETAIL.]
 |
 |     Language:  Java version 8
 | Ex. Packages:  [List names and sources of all external packages
 |                required by this program.]
 |                
 | Deficiencies:  [If you know of any problems with the code, provide
 |                details here, otherwise clearly state that you know
 |                of no unsatisfied requirements and no logic errors.]
 *===========================================================================*/

Oracle Resources¶

Oracle Java Foundations (1Z0-811) — Deep Dive Topic Reference¶

TABLE OF CONTENTS¶

1. JVM & JRE¶

📍 Best Placement in CSA Curriculum¶

Concept Overview¶

Key Exam Nuances¶

✅ Practice Question¶

2. The this Keyword¶

📍 Best Placement in CSA Curriculum¶

Concept Overview¶

Use Case 1 — Disambiguate field from parameter (most common)¶

Use Case 2 — Constructor chaining with this()¶

Use Case 3 — Passing the current object as an argument¶

this vs super — Key Contrast for Inheritance Week¶

3. OOP Principles¶

📍 Best Placement in CSA Curriculum¶

The Four Pillars¶

3A. Encapsulation¶

3B. Inheritance¶

3C. Polymorphism¶

3D. Abstraction¶

4. Packages & CLASSPATH¶

📍 Best Placement in CSA Curriculum¶

Concept Overview¶

Declaring a Package¶

Importing a Package¶

The CLASSPATH¶

java.lang vs java.util — What’s Automatically Available¶

5. Access Modifiers & Visibility¶

📍 Best Placement in CSA Curriculum¶

The Four Access Levels¶

Examples Across All Four Levels¶

Applying to Methods — Same Rules¶

6. Throwable Hierarchy & Exception Handling¶

📍 Best Placement in CSA Curriculum¶

The Throwable Hierarchy¶

Checked vs. Unchecked¶

try / catch / finally Mechanics¶

e.getMessage() vs e.toString() vs e.printStackTrace()¶

7. “Swallowing” — Empty Catch Blocks¶

📍 Best Placement in CSA Curriculum¶

What It Is¶

Why It’s Dangerous¶

What to Do Instead¶

Exam Nuance — What Does the Code ACTUALLY Do?¶

8. Comparing¶

📍 Best Placement in CSA Curriculum¶

Three Tools, Three Purposes¶

Comparing Primitives — == is correct¶

Comparing Objects — == tests REFERENCE, not content¶

String Pool Trap (from the Exam)¶

.compareTo() — Ordering¶

Comparing null — A Common Bug¶

Wrapper Class Integer Caching — Sneaky Trap¶

9. Visibility Scope vs. Lifespan Scope¶

📍 Best Placement in CSA Curriculum¶

Two Different Questions¶

Visibility Scope — Four Levels¶

Lifespan / Storage Scope — The Three Categories¶

1. Local Variables — shortest life¶

2. Instance Variables — medium life¶

3. Static Variables — longest life¶

Variable Shadowing — The Common Bug¶

Loop Variable Scope — Exam Trap¶

CURRICULUM INTEGRATION SUMMARY¶

2. The `this` Keyword¶

Use Case 2 — Constructor chaining with `this()`¶

`this` vs `super` — Key Contrast for Inheritance Week¶

`java.lang` vs `java.util` — What’s Automatically Available¶

`e.getMessage()` vs `e.toString()` vs `e.printStackTrace()`¶

Comparing Primitives — `==` is correct¶

Comparing Objects — `==` tests REFERENCE, not content¶

`.compareTo()` — Ordering¶

Comparing `null` — A Common Bug¶