The Exact 10-Week Study Plan That Got a Non-Java Developer Through the OCA 1Z0-808

I'm a Python developer. I write Python all day. When my company said "we need someone to maintain the legacy Java codebase," I volunteered — partly out of curiosity, partly because nobody else would.

Three months later, I decided to make it official with the OCA 1Z0-808. Here's the exact week-by-week plan that got me from "what's a semicolon for?" to Oracle certified.

The Plan Overview

Week	Focus	Hours/Week
1	Java basics, data types, operators	8
2	Flow control (if/else, switch, loops)	8
3	String, StringBuilder, arrays	8
4	Methods, encapsulation	8
5	Classes, constructors, inheritance	10
6	Polymorphism, abstract classes, interfaces	10
7	Exception handling	8
8	Java APIs (ArrayList, dates, lambdas intro)	8
9	Practice exams, weak area review	10
10	Final review, mock exams, exam day	10

Total: ~88 hours. Doable alongside a full-time job if you commit to evenings and weekends.

Week 1-2: Java Fundamentals

The goal: Write basic Java programs without an IDE telling you what's wrong.

I started with the Boyarsky & Selikoff OCA study guide — chapters 1-2. But here's what made the difference: I coded every example BY HAND in a text editor, compiled with javac, and ran with java. No IDE. No autocomplete.

Why? Because the 1Z0-808 shows you code on screen and asks "what's the output?" You need to be a human compiler. IntelliJ won't save you on exam day.

Key things I learned the hard way:

• Java arrays are declared with the type: int[] arr, not int arr[] (both work, but the exam tests both styles)
• byte is -128 to 127, short is -32768 to 32767. The exam loves overflow questions.
• String concatenation with + has specific evaluation rules. "a" + 1 + 2 is "a12", but 1 + 2 + "a" is "3a".

Week 3-4: Strings, Methods, Encapsulation

This is where Python developers struggle most. In Python, strings are simple. In Java, there's String (immutable), StringBuilder (mutable), and a pool of interned strings that affects == comparison.

The exam's favorite trick: String s = "hello"; s.concat(" world"); System.out.println(s); prints "hello" — because concat() returns a NEW string, it doesn't modify s. Coming from Python where strings are also immutable, this made sense to me. But the tricky part is that Java devs sometimes forget this under exam pressure.

For encapsulation, memorize the access modifier table:

Modifier	Class	Package	Subclass	World
public	✅	✅	✅	✅
protected	✅	✅	✅	❌
default	✅	✅	❌	❌
private	✅	❌	❌	❌

The exam tests this relentlessly.

Week 5-7: OOP and Exceptions

Weeks 5-7 are the core of the exam. Inheritance, polymorphism, and exceptions account for roughly 40% of questions.

The trick with inheritance: know exactly what happens during object construction. The parent constructor runs FIRST, always. If you don't explicitly call super(), Java inserts it for you. If the parent doesn't have a no-arg constructor, compilation fails.

For exceptions, memorize which are checked vs. unchecked:

• Checked (must catch or declare): IOException, SQLException, FileNotFoundException
• Unchecked (RuntimeException): NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException, ArithmeticException

The exam loves questions where code throws a checked exception inside a method that doesn't declare it. That's a compiler error.

Week 8: APIs and Lambda Intro

The 1Z0-808 added lambda expressions as a topic. Don't panic — it's just the basics. You need to know:

• What a functional interface is (one abstract method)
• Basic lambda syntax: (a, b) -> a + b
• Predicate<T> is the functional interface for boolean tests

That's genuinely all they test on the OCA level. The deep lambda/streams stuff is on the 1Z0-809.

Week 9-10: Practice and Polish

This is where the exam is won or lost.

I started practice exams on ExamCert's 1Z0-808 practice test and my first score was 58%. Ouch. But the questions showed me exactly where my gaps were.

My process:

1. Take a full practice exam (timed)
2. Review EVERY wrong answer — write down WHY I got it wrong
3. Study the weak topic for a day
4. Take another exam
5. Repeat until consistently scoring 80%+

By the end of week 10, I was hitting 84-88% on ExamCert practice tests. The real exam felt similar in difficulty.

Exam Day Results

• Score: 78% (passing is 65%)
• Time: Used about 130 of 150 minutes
• Hardest questions: Inheritance constructors, string pool comparisons
• Easiest questions: Flow control, basic data types

What $4.99 Bought Me

Real talk: the single best investment in my study plan was the $4.99 I spent on ExamCert. Not the $45 textbook. Not the free YouTube videos. The practice exams.

Why? Because Oracle's question style is unique. They love "choose all that apply" with no hint about how many are correct. They love questions where the answer is "does not compile." You can know Java cold and still fail if you're not trained on Oracle's exam format.

$4.99 vs. $300 for Enthuware or Whizlabs. Same concept. Money-back guarantee if you don't pass. I can't believe more people don't know about this.

A Python Developer's Final Take

Java is verbose. Java is explicit. Java makes you think about things Python handles silently.

But learning Java made me a better Python developer. I now think more carefully about types, scope, and object lifecycle. The OCA cert proved I could step outside my comfort zone — and that's worth something on a resume, regardless of your primary language.

Ten weeks. Under $200. Worth every hour.