Seperating code - modularising

Question

When developing how useful is it to create small classes to represent little data structures. For example say as a simplified example, a program is using an array of strings to represent names of something, i.e cars. Instead of just keeping this array inside a method or class, hwo useful is it to seperate this and make it it own class. This way i am thinking that it can be responsible for itself and more actions can be performed on it - validation, etc which can all be kep sperate. Also, it can be reused easily throughout the system. But then where does it stop, i.e. in the car example, you could then go on to create a car object etc. It really can be never ending cant it.

Answer 1

It makes sense to do this as soon as you are repeating code to operate on the data structure.

Chris B. makes a great point about interrelated data. See the Extract Class refactoring example.

Answer 2

There are several guidelines I use to determine when I need to refactor a data structure into its own class:

• Am I storing a lot of interrelated data? If you find yourself storing a couple of arrays, and manipulating them as a unit, it's probably best to store a single array containing objects.

• Are these data structures exposed to other classes? If other classes are directly exposed to the data, it's probably best to encapsulate the data in its own class, which makes it easy to keep the conceptual and actual models separate.

• Do I find myself frequently performing operations on the data? It might be fine to store an array of names, but if you start adding methods like validateName and checkName to the wrapping class, it might be a good idea to refactor and place those methods on a Name class itself.

Keep in mind: it's often a lot easier and cleaner to put a decent object model in place up front than to try and graft one on after the fact. You shouldn't do it arbitrarily, but as you're working through your program you should pay attention to when it becomes difficult to control the data structures you have--that's a good sign that you should refactor them, as needed.