Re: Newbie: ArrayList.indexOf help
Kurt wrote:
So this gets me to thinking about the appropriate getter/setter/etc
methods that an
an object with an ArrayList of other objects should provide publicly.
Daniele had some really good points, the most important of which is that
it should be your design that dictates what methods are provided by a
class. You can learn best practices by studying other code (like what
methods an ArrayList makes available) but in the end all designs are
different. What ArrayList does may not be suitable for you.
My rough list would be;
1. Method to ADD a new ArrayList element
2. Method to DELETE an ArrayList element
3. Method to FIND any of the specific Instance variables of the stored
objects.
This is good. ArrayList provides add(), remove() and find() which do
similar things. You might try using those names if your methods do the
same things as ArrayList, as other programmers might find it easier to
remember.
*** My Brain says this is wrong and should be part of the getters/
setters of the
Setters and getters work too. It's all in the design.
There's also no one "right way" to do things. Both a List clone and
getters and setters would work, it's just how you want to do things.
4. Method to UPDATE any of the specific instance variables of the
stored objects.
This is ok too, and has the advantage that it can provide
synchronization if required.
*** Again my brain thinks this belongs in the child object.
As Daniele said, it's not normal to provide access to instance fields.
In fact, it's considered bad. While your design works, Daniele and I
are both looking at that part and going "wth?" Make the fields private,
provide setters and getters. This is almost always the best way to go.
I struggle with the encapsulation of objects and best practices are
appreciated.
One thing you might consider is to provide access to your List as an
unmodifiable Collection (or List). That way, you don't really provide
access to the List, just a view of it.
class Customer
{
private String _sCustomerName;
private ArrayList<Center> _aCenters = new ArrayList<Center>();
public List<Center> getUnmodifiableCenterList() {
return Collections.unmodifiableList( _aCenters );
}
// ....
}
Now the user has access to all of the Collections and List methods, and
you don't have to provide them. There's still concurrency issues here,
but the user can clone or copy the list themselves if the wish to make
changes. It's a reasonable compromise. If your program does need
synchronization, you'll almost certainly have to provide a synchronized
method which makes a defensive copy however.
Also as Daniele said, follow the Java naming conventions. It's not
normal to put underscores in instance field names, and the whole
Hungarian thing is passe. Don't do it.