UW–Madison CS 300: Programming II
CS 300 (officially COMP SCI 300) is UW–Madison's object-oriented programming course in Java — classes, inheritance, interfaces, exceptions, recursion, and intro data structures like array lists and linked lists — and one of the largest courses on campus, since it gates the CS major and serves data science, engineering, and statistics students besides.
Fennie is independent and not affiliated with University of Wisconsin–Madison. This is an unofficial study guide.
Build my CS 300 study planWhat makes it hard
The jump from writing procedures to designing classes is the real shift: inheritance, polymorphism, and reference semantics demand a mental model of objects in memory that CS 200 never required. The pace is brisk because it's a gateway, exams test writing and tracing object-oriented code by hand, and recursion arrives as the unit that separates the room.
What you'll cover
- • Classes, objects, and encapsulation
- • Inheritance and polymorphism
- • Interfaces and abstract classes
- • Exceptions and I/O
- • Recursion
- • Array lists and linked lists
The CS 300 study guide
How to study for UW–Madison CS 300, step by step.
- 1
Build the objects-in-memory mental model early
Draw what references point to for every example — which variable holds which object, what changes when you assign. Reference semantics power half the exam's tricky questions, and the diagram habit is how the model forms.
- 2
Write small class hierarchies from scratch
Inheritance and interfaces only click when you design with them. Weekly from-scratch exercises — a base class, two subclasses, an interface — beat rereading lecture examples by a wide margin.
- 3
Give recursion patient, spaced practice
It's the unit that splits the room. Learn to trust the recursive call inductively rather than tracing every frame, and practice across structures — numbers, strings, lists — over multiple weeks.
- 4
Hand-write code under exam conditions before each test
CS 300 exams demand producing and tracing Java on paper. Simulate it: a blank page, a problem, no IDE. The gap between editor fluency and paper fluency is where grades drop.
- 5
Schedule the climb with Fennie
Upload your CS 300 syllabus and Fennie's Daily Plan spaces object-oriented and recursion practice across the semester, paced to program deadlines and exams, with quizzes built from your actual course content. Free to start.
Start my CS 300 plan free
How Fennie helps with CS 300
Fennie's Daily Plans space CS 300's two real climbs — the object model and recursion — across weeks of practice instead of pre-exam cramming, paced to program deadlines. Chat traces what your references actually point to and what each recursive call does, building the in-your-head execution skill the paper exams test.
FAQ
Is CS 300 at UW–Madison hard?
It's the CS major's gateway and grades like one: brisk pace, object-oriented design, and recursion, with exams requiring hand-written Java. Students who practice writing class hierarchies and recursion steadily handle it; students who pattern-match assignments meet a wall at exam time.
Can I take CS 300 without CS 200?
Yes, with prior programming background — many students enter via AP credit or self-taught experience and satisfy the prerequisite through placement. You need real comfort with loops, methods, and arrays in some language; the course rebuilds syntax but not programming fundamentals.
What grade do I need in CS 300 for the CS major?
Requirements have shifted over the years, so check the current declaration criteria with CS advising. Practically: CS 400 and everything after assume 300's material completely, so aim for mastery regardless of the threshold.
Pass CS 300 with a plan, not a cram
Upload your CS 300 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore UW–Madison courses
CS 200 — Programming I
CS 200 (officially COMP SCI 200) is UW–Madison's first programming course, taught in Java — variables, control flow, methods, arrays, and an introduction to objects — serving intended CS majors, data science students, and a large population just adding programming skills. It assumes no prior experience.
CS 400 — Programming III
CS 400 (officially COMP SCI 400) completes UW–Madison's programming sequence: data structures and their implementations — balanced search trees, hash tables, graphs — plus software development practices like version control, testing, and team projects, all in Java.
CS 240 — Introduction to Discrete Mathematics
CS 240 (officially COMP SCI 240) is UW–Madison's discrete math course for the CS major — logic, proofs, induction, sets, functions, counting, recurrences, and graphs — the mathematical foundation that CS 577 and the theory electives build on.
CS 252 — Introduction to Computer Engineering
CS 252 (cross-listed COMP SCI/E C E 252) introduces how computers work from the bottom up: transistors and gates, combinational and sequential logic, basic computer organization, and machine and assembly programming on the LC-3 — the first systems course in the CS and computer engineering tracks.