Objects First With Java Exercise Solutions

Working Through Objects First With Java Exercise Solutions

I spent a couple of weekends going through the exercises in Objects First With Java by Sue Sentance and David Barnes. The book is solid for learning object-oriented thinking from the ground up, but the exercise solutions aren't exactly easy to find in one place. What follows is a practical walkthrough of what I learned while working through them, along with some of the more frustrating edge cases I hit. The official companion site at objectsfirst.co.uk used to host downloadable resources, but links have rot over time. The most reliable approach is checking the book's GitHub repositories - there are multiple forks that contain exercise implementations. Some students also share solutions on forums, though quality varies widely. I'd recommend verifying any third-party code against your own run of the exercises rather than copying blindly. The exercises progress from simple class design to more complex inheritance hierarchies. Chapter 1 starts with basic class structure - designing a BerlinTurtle or similar creature. By chapter 5 you're dealing with composition patterns and polymorphism. The jump from chapter 4 to chapter 6 is particularly steep if you haven't internalized the earlier material.

The core methodology behind the book's approach

Objects First differs from typical Java textbooks because it deliberately delays primitives and syntax conventions. You don't touch int or System.out.println until chapter 3. Instead, you build programs entirely through custom classes from day one. This means writing things like: Dog bark = new Dog(); And the turtle world feels almost like working in Smalltalk or Eiffel. The tradeoff is that early chapters feel glacially slow for students who already understand basic programming concepts. But the payoff comes later when you genuinely understand why encapsulation matters instead of just memorizing accessor method templates.

One thing the book handles well is the distinction between attributes and behavior. Students frequently conflate these in their first attempts at class design. The exercises force you to decide whether something like a dog's name is a field or a computed property, which builds better design instincts than tutorial projects ever do.

Common pitfalls I ran into

The inheritance exercises in chapter 8 are where most students struggle. The book introduces Bark and Gambler subclasses without enough scaffolding for people new to polymorphism. I spent three hours debugging a compilation error in exercise 8.3 that turned out to be a missing super() call in the constructor chain. The compiler error message pointed at the wrong line entirely. Another issue is the turtle graphics assignments. Students often try to implement movement logic inside the Turtle class methods rather than creating separate Maze or Navigator controller objects. The book nudges toward this pattern but doesn't make it explicit enough. I found myself rewriting entire movement strategies multiple times before grasping the separation of concerns. The file handling exercises around chapter 12 present a different class of problems. Reading and parsing custom formats works fine until you encounter Unicode characters or malformed input. The book's sample files are pristine, which gives students a false sense of security about real-world file processing.

Advanced patterns worth studying

By chapter 15, the book introduces observable patterns and event-driven design through the turtle world. This is where Objects First really earns its reputation. The TurtleWorld class becomes a proper domain model instead of just a graphics wrapper. Students who push through these exercises develop stronger architectural intuition than most bootcamp graduates. The composite pattern implementation in the exercise solutions teaches delegation in a way that Java tutorials rarely do. You actually feel the difference between is-a and has-a relationships when implementing nested Room and Building hierarchies. This foundation pays off immediately when reading enterprise codebases that rely heavily on composition.

Limitations and alternatives

The book has real gaps in modern Java coverage. There's nothing on generics beyond basic examples, no discussion of streams or lambdas, and the exception handling treatment feels dated. If you're learning Java for current employment, you'll need supplementary material on Java 8+ features regardless of how thoroughly you work through these exercises. The turtle graphics API itself creates dependency issues that don't translate to real Java projects. Working with Bark and Gambler subclasses trains you for academic exercises but not for the standard library patterns you'll encounter professionally. I'd recommend pairing this book with something like Head First Java or a modern Spring tutorial once you finish the core material. The exercise difficulty curve is also uneven. Some assignments feel complete while others trail off without clear success criteria. The solution verification process requires running your code against the book's test suites, which aren't always included in downloaded packages. Budget extra time for this validation step rather than assuming completion after finishing the coding portions.