Skip to main content
Fennie
HomeGet Started
ASU
Computer Science
3 credits

ASU CSE 205: Object-Oriented Programming and Data Structures

CSE 205 follows CSE 110, deepening Java with object-oriented design — inheritance, polymorphism, interfaces — plus core data structures like lists, stacks, queues, and recursion. It's the course that determines whether students continue smoothly into the CS major's core.

Fennie is independent and not affiliated with Arizona State University. This is an unofficial study guide.

Build my CSE 205 study plan

What makes it hard

The jump from 110 is real: programs get longer, and the conceptual load shifts from syntax to design. Recursion and polymorphism are the two famous walls, and exams test tracing of inheritance hierarchies that punish surface-level understanding. Project deadlines stack with exam weeks, so time management failures look like ability failures.

What you'll cover

  • • Classes, inheritance, and polymorphism
  • • Interfaces and abstract classes
  • • Exception handling
  • • Lists, stacks, and queues
  • • Recursion
  • • Algorithm basics and Big-O intuition

The CSE 205 study guide

How to study for ASU CSE 205, step by step.

  1. 1

    Start every project the day it drops

    CSE 205 programs are long enough that deadline-night starts fail structurally. An early start turns debugging into a multi-day process instead of a panic, and keeps project weeks from colliding with exams.

  2. 2

    Draw inheritance hierarchies before coding them

    Sketch which class extends what, which methods override, and what a polymorphic call resolves to. Exams test tracing these hierarchies, and the diagram habit is what makes tracing reliable.

  3. 3

    Practice recursion weeks before the exam needs it

    Recursion is one of the course's two famous walls and it doesn't yield to cramming. Trace small recursive functions by hand until you can predict the call stack, then write your own.

  4. 4

    Predict output before running anything

    For every example and assignment, write down what you expect the program to print, then check. The gap between your prediction and reality is exactly where exam points hide.

  5. 5

    Keep Big-O intuition attached to code you write

    When you finish a method, note its runtime. The habit costs seconds and makes the algorithm-analysis questions feel like review instead of new material.

  6. 6

    Give the hard topics runway with Fennie

    Upload the CSE 205 syllabus and Fennie's Daily Plan paces project work across days and schedules recursion and polymorphism practice well before exams, with quizzes drawn from your actual course content. It's free to start.

    Start my CSE 205 plan free

How Fennie helps with CSE 205

Fennie's Daily Plans pace CSE 205's projects so design and debugging happen across days rather than deadline nights, with recursion practice scheduled well before it appears on an exam. Chat through inheritance and polymorphism with traced examples until you can predict program output cold — the exact skill the exams test.

FAQ

Is CSE 205 harder than CSE 110?

Yes — it's the bigger filter of the two. Programs are longer, recursion and polymorphism demand deeper understanding, and exams test code tracing that memorization can't fake. Strong CSE 110 habits carry over; weak ones get exposed.

How do I pass CSE 205 at ASU?

Start projects the day they're released and practice tracing code by hand, especially recursion and inheritance examples. Most exam points come from predicting what code does, which is a hand-skill built through repetition.

What comes after CSE 205?

For CS majors, CSE 205 feeds the core sequence — data structures and algorithms territory and beyond. It's the foundation course for everything after it, which is why getting genuinely comfortable with its material matters more than the grade.

Pass CSE 205 with a plan, not a cram

Upload your CSE 205 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 ASU courses

CSE 110 — Principles of Programming

CSE 110 is ASU's first programming course, teaching problem solving and structured programming in Java — variables, control flow, methods, arrays, and intro object-oriented concepts. It's the gateway for CS, software engineering, and informatics majors, and one of the most-taken courses on ASU Online.

CSE 230 — Computer Organization and Assembly Language Programming

CSE 230 takes ASU CS majors below the high-level language for the first time — number representation, MIPS assembly programming, how the processor actually executes instructions, and the basics of datapath and pipelining. It's a core requirement that shows students what their Java from CSE 110 and 205 compiles down to.

CSE 240 — Introduction to Programming Languages

CSE 240 surveys programming-language paradigms after the Java sequence — C and C++ for imperative programming with pointers and manual memory, Scheme for functional programming, and Prolog for logic programming. It's a core CS requirement designed to break students out of the one-language thinking CSE 110 and 205 built.