UMD CMSC 132: Object-Oriented Programming II
CMSC 132 continues UMD's Java sequence into data structures and design: inheritance, recursion, linked lists, trees, hash tables, and intro threads, with bigger autograded projects and the same handwritten-exam format as 131.
Fennie is independent and not affiliated with University of Maryland. This is an unofficial study guide.
What makes it hard
Recursion and linked structures are the famous walls: both require reasoning about references and call stacks abstractly, and trial-and-error coding stops working. The projects get long enough that late starts are unrecoverable, and 132's material is exactly what CMSC 216 and 250 assume on day one.
What you'll cover
- • Inheritance and polymorphism
- • Recursion
- • Linked lists, stacks, and queues
- • Trees and binary search trees
- • Hash tables
- • Intro threads and synchronization
The CMSC 132 study guide
How to study for UMD CMSC 132, step by step.
- 1
Enter with 131 genuinely solid
CMSC 132 assumes reference semantics, classes, and basic design fluently from day one. If any of it is shaky, rehab it in the first week. The course won't slow down to review.
- 2
Draw every linked-structure operation
Diagram what each reference points to before and after every insert, delete, and traversal. Exams test hand-execution of these operations, and drawing is how the mental model gets built.
- 3
Learn recursion inductively
Trust the recursive call to handle the smaller case while you reason about one frame. Tracing every call of every example burns students out; the inductive mental model is the actual breakthrough.
- 4
Start projects the day of release
Debugging recursion and linked structures takes calendar days, not heroic nights, and the autograder's hidden tests find what rushed code misses. Early starts are the whole strategy.
Today's CMSC 132 plan
What a Fennie Daily Plan looks like for CMSC 132. Yours is built from your syllabus and adapts every day to your deadlines and progress.
- Review: Intro threads and synchronizationReview · 25 min
Work back through the CMSC 132 material on intro threads and synchronization. In the app, Fennie builds this from your own notes and syllabus.
- Practice: Inheritance and polymorphismPractice · 20 min
Targeted problems on inheritance and polymorphism, the kind CMSC 132 actually tests.
- Quick quiz: RecursionQuiz · 10 min
Five generated questions to expose weak spots on recursion before the exam does.
- Preview: Linked lists, stacks, and queuesPreview · 10 min
A first pass over linked lists, stacks, and queues so the next session starts from familiar ground.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CMSC 132 at UMD hard?
It's the course where the CS major gets real: recursion and linked structures demand abstract reasoning, projects grow long, and exams test hand-implementation. Early project starts and consistent tracing practice get students through.
How do I prepare for CMSC 132?
Make CMSC 131's material genuinely fluent, especially references and object design, and practice basic recursion before the course needs it. During the semester, draw diagrams for every data-structure operation you study.
What comes after CMSC 132?
CMSC 216 (computer systems) and CMSC 250 (discrete structures), usually together, a demanding pair that assumes 132's programming maturity. How solidly you finish 132 is a good predictor of how that semester goes.
More UMD courses
CMSC 131: Object-Oriented Programming I
CMSC 131 is UMD's first programming course for CS majors, taught in Java: objects, control flow, methods, arrays, and intro design, with weekly projects graded by an autograder against test cases you can't see all of. It sets the tone for the entire CMSC sequence.
CMSC 216: Introduction to Computer Systems
CMSC 216 drops UMD CS majors below the Java abstraction: C programming, pointers, dynamic memory, the UNIX environment, and assembly-level concepts, with substantial autograded projects. It's taken alongside or near CMSC 250 in the sequence.
CMSC 250: Discrete Structures
CMSC 250 is UMD's discrete math course for CS majors: logic, proof techniques, induction, sets, functions, combinatorics, and probability basics. It's the course where computer science becomes mathematics for a semester.
CMSC 320: Introduction to Data Science
CMSC 320 is UMD's data science course: the Python data pipeline from collection and cleaning through exploratory analysis, visualization, basic machine learning, and communication of results, typically culminating in an open-ended final project.