FIU COP 3337: Programming II

COP 3337 is FIU's second programming course, deepening Java: inheritance, polymorphism, interfaces, exception handling, recursion, and an introduction to data structures. It's the bridge between writing programs that work and writing programs designed well, and it's a prerequisite for COP 3530 and CDA 3102.

Fennie is independent and not affiliated with Florida International University. This is an unofficial study guide.

Build my COP 3337 study plan

What makes it hard

The assignments stop being twenty-line exercises and become multi-class programs where design choices matter and are graded. Inheritance and polymorphism are the conceptual wall — students can recite the definitions long before they can predict which method actually runs — and exams target exactly that gap with tracing questions across class hierarchies.

What you'll cover

• Object-oriented design
• Inheritance and polymorphism
• Interfaces and abstract classes
• Exception handling
• Recursion
• Introduction to data structures (lists, stacks, queues)

The COP 3337 study guide

How to study for FIU COP 3337, step by step.

1
Trace polymorphism until it's boring
Which method runs when a superclass reference holds a subclass object? COP 3337 exams live on that question. Build small class hierarchies and predict the output until you stop being surprised.
2
Design before you code on every assignment
Multi-class assignments punish improvisation. Sketch the classes, their responsibilities, and their relationships on paper first — the grade increasingly rewards structure, not just output.
3
Start assignments the day they're posted
These aren't one-evening programs anymore. Starting early converts panic-debugging into design time, and it's the single biggest grade lever in the course.
4
Write recursion by hand weekly
Recursion shows up here and never leaves the curriculum. Trace calls on paper — stack frames, base cases, return values — until the pattern is mechanical before COP 3530 raises the stakes.
5
Pace the projects with Fennie
Upload your COP 3337 materials and Fennie's Daily Plan backward-schedules each multi-class assignment with design days built in, generating polymorphism-tracing quizzes from your actual course content. Free to start.
Start my COP 3337 plan free

How Fennie helps with COP 3337

Fennie's Daily Plans backward-schedule COP 3337's bigger assignments so design happens before deadline week, with steady review of inheritance and polymorphism — the exam's favorite traps. Chat through why the wrong method seems to run in a class hierarchy, and drill generated tracing questions before each test.

FAQ

Is COP 3337 harder than COP 2210?

Yes, and by design — the programs get bigger, the concepts get more abstract, and the grading starts caring about how your code is structured. Students who coasted through 2210 on syntax alone usually meet their first real wall at inheritance and polymorphism.

What comes after COP 3337 at FIU?

COP 3530 (Data Structures) and CDA 3102 (Computer Architecture) both list it as a prerequisite, alongside the discrete math requirement (COT 3100 or MAD 2104). It's the last course where the programming itself is the subject — after this, programming becomes the tool.

How do I do well on COP 3337 exams?

Practice tracing code across class hierarchies by hand — exams test whether you can predict polymorphic behavior, not whether you can recite definitions. Build tiny example programs that isolate one concept each, run them, and learn from every wrong prediction.

Pass COP 3337 with a plan, not a cram

Upload your COP 3337 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.

Get started free

More FIU courses

COP 2210 — Programming I

COP 2210 is FIU's first programming course, taught in Java — objects and classes, control flow, methods, arrays, strings, and file I/O. It's a 4-credit course with a required closed instructional lab, and it's the front door of the FIU computing majors, feeding directly into COP 3337.

COP 3530 — Data Structures

COP 3530 covers data organization and algorithm analysis — running time, abstract data types, linked lists, trees, sets, graphs, and sorting. It's the gateway to FIU's upper-division CS curriculum, and fittingly, the canonical data structures textbooks by Mark Allen Weiss were written by an FIU professor.

CDA 3102 — Computer Architecture

CDA 3102 covers the levels of organization in a computer: digital logic, machine and assembly language programming, and the design of memory, buses, the ALU, and the CPU, with virtual memory and I/O at the end. It's where FIU CS students find out what their Java has been running on all along.

COT 3100 — Discrete Structures

COT 3100 is the computer science department's discrete math course — logic, proof techniques, sets, functions, relations, counting, and graphs. FIU CS degree plans accept it interchangeably with MAD 2104, and one of the two is required before COP 3530 and CDA 3102.