4

I have been told to develop my code according to the following code example:

Class Dogs{
   List<Dog> listOfDogs = new ArrayList<Dog>();
   // Setters, getters...
}

Class Dog{
   // Attributes and methods
}

The question is: why is it better to implement a Dogs class as a container for the ArrayList of Dog objects, instead of just referring to a simple ArrayList. Is this considered encapsulation?

PsiX
  • 1,661
  • 1
  • 17
  • 35
capovawi
  • 377
  • 8
  • 21
  • 2
    This strongly depends on what you want to express. In a contract you may want to have explicit collections of your classes, in a normal program you do not need such. In the end you should really ask the one that told you that why he thinks that this would be better. – Mare Infinitus May 13 '14 at 13:09
  • You may get some insight from the top answer to this question: http://stackoverflow.com/questions/21692193/why-not-inherit-from-listt The question itself is a little different but there's a lot of overlap in the concepts – Ben Aaronson May 13 '14 at 13:20

7 Answers7

4

I see no reason to make a separate Dogs class, unless there are other operations to be performed on Dogs as a group besides the standard collections operations of adding, removing, and accessing members. For example, if there was a releaseTheHounds() method or a callEveryoneForDinner() method, etc.

HOWEVER, it may be that what you were told was that you are supposed to use a List type to declare listOfDogs, rather than ArrayList. That is, this:

List listOfDogs = new ArrayList<Dog>();

Instead of this:

ArrayList listOfDogs = new ArrayList<Dog>();

You are doing this already and it is a good practice. Here, the "encapsulation" is the hiding of ArrayList as the implementor of the List interface. This makes it easy to switch to another implementation easily (e.g. TreeList) without having to change any code that accesses listOfDogs.

Last but not least, you really should declare it this way:

List<Dog> listOfDogs = new ArrayList<Dog>();

Then you are ensuring that the List holds Dog instances and nothing else.

sparc_spread
  • 10,643
  • 11
  • 45
  • 59
  • Edited. My question refers to the use of classes as simple containers, but appreciate you comment. I would say your point deals with the concept of polymorphism, instead of encapsulation ;) – capovawi May 13 '14 at 14:32
4

I can see why someone asked you to do this although just like the other answers suggest, this is too broad of a question to answer correctly. Depends on the scenario.

Now the justification here could be that when you have a container for a Dog objects you get to control how these objects are created, accessed and changed. If you just have a List lying around you can't really control proper access or Add/Delete operations to it. However if you have a Dogs class. You can return readonly lists, don't allow addition of dogs that are of certain breed, etc. It can basically be a controller class for all that has to do with dogs.

Class Dogs
{
  List listofDogs = new ArrayList<Dog>();

  public void AddDog(Dog newDog)
  {
     //check if valid
  }

  public List<Dog> getDogs()
  {
    //return readonly dogs collection
  }
}
Farhad Alizadeh Noori
  • 2,276
  • 17
  • 22
  • 1
    The returning of read-only lists is important for concurrency. I should have mentioned that in my own answer. +1 to you! – sparc_spread May 13 '14 at 13:23
  • Exactly. More control over the list. Or in other words, you get the possibility to improve or set a new API for such collection of objects. – capovawi May 13 '14 at 14:34
4

Basically, creating a Dogs class provides you with additional layer of indirection.

This means that all your other code will reference (i.e. use) only the Dogs class, but not the internal list. This, in turn, means that whenever you decide to switch from using list to, say, using plain arrays internally (or to change Dogs's implementation in any other way, for that matter), you can readily do so.

That's a motivation for it. As for the question of it being 'better', that depends strongly on whether you can limit usage of the internal container by a stable Dogs's API. If you can, creating a Dogs class is justified. Otherwise, it's simpler and easier to just go ahead and use List.

One example of the aforementioned 'stable API' is an application of the Visitor pattern. In this case, the Dogs class shall have a single visit() method accepting a visitor argument. A visitor 'knows' how to process a Dog, but is completely unaware of the Dogs internal structure. Which is a good thing.

shakurov
  • 2,358
  • 24
  • 27
  • Got it. I see two basic advantages: hide implementation details (now ArrayList, maybe Set in the future) and implement "customized" methods (for example, a method that checks if a Dog meets the requirements to be addd to the list). – capovawi May 13 '14 at 14:28
  • Yup, that's my understanding of it, too. BTW, another useful category of 'customized' methods is 'bulk' methods that process all (or a meaningfull subset of) items at once. – shakurov May 13 '14 at 14:41
1

it makes serialization to webforms somewhat easier with the mvc frameworks i have used

NimChimpsky
  • 46,453
  • 60
  • 198
  • 311
1

It depends on your problem and the operations that you want to do on that array list .you may want to extend some operations of the ArrayList or add new one that will be applied to all array list items for instance a method to sort this list in desc order .

M.Khouli
  • 3,992
  • 1
  • 23
  • 26
0

I believe they might have wanted you to work on something that resembles 'The object pool pattern'. The Object Pool Design Pattern is a creational design pattern that can improve performance when working with classes that are slow to instantiate. Rather than constructing new objects, reusable objects are retrieved from, and released to, a pool as required.

In this case, Dogs would be the Pool, Dog would be the PooledObject, and any class that uses an object of the PooledObject type would be the client.

stripthesoul
  • 362
  • 1
  • 8
  • Why would the pool need to be its own class in this case, rather than just an `ArrayList`? – Ben Aaronson May 13 '14 at 13:18
  • When the pool is in its own class, you can create support properties that for example hold the time at which the object was first created, lock objects, clean up and release back to pool, etc – stripthesoul May 13 '14 at 13:23
  • 1
    Right. I think that more general concept is more what this is getting at- the ability to group data and functionality together. What you're desribing is just one of many, many situations in which that's useful – Ben Aaronson May 13 '14 at 13:29
0

We use such implementation when we have a set of method that is typical for a set of objects. So that we focus not on a particular choice of representation but on the shared operations and properties. For example, stack uses this pattern, the operations typically available on a stack are the following: push, remove, determine whether the stack is empty, etc.. and instead of Dog it uses Object; so you can stack any object.

Now you can add object other than Dog, and they will share the same methods.

ms2r
  • 170
  • 3
  • 17