Best way to perform the same task wih arrays of different Objects

Question

Hello all.
This isn't an XPath question, it's a much lower-level Java Object question, but it involves XPath. I hope that doesn't distract from the question, or confuse anything.
I have 4-5 different types of Objects (call them A, B, C, etc.) that each contain an array of other Objects (call them a[], b[], c[], etc.)
a, b, c, etc., each have an Xpath object and and XPathExpression. When I create each XPath object I assign it a NamespaceContext object which contains the namespaces needed for that XPath.
When I create, for example, an A object, I pass is constructor an array of a and an array of Namespaces. With each a object I need to:
1. create a NamespaceContext object
2. go through all the Namespace objects and if its route matches,
(if Namespace.route == a.getRoute() )
3. add that Namespace to the NamespaceContext Object,
4. assign the NamespaceContext to the XPath object, and finally
5. create the a object, passing it the XPath object
My problem / question is: I also have to do the same thing with B and b[], C and c[], etc. It's not that long of a process, not that much code, but all the same, I was wondering what the best way to write this code once would be, and have it work for all the different types of Objects.
In other words, I'd like to write a mehod, call it assignNamespaces(), that accepts an array of Objects(a[], b[], c[], etc.) and an array of Namespaces, creates the XPath Object for each a, b, c, etc., and that creates and returns an array of a[],b[],c[], etc., sending the XPath Object as a parameter.
That way when I create for example an A Object, I call:
class A
ObjectsWithXpath[] objectsWithXPath;
this..objectsWithXPath = assignNamespaces(objectsWithXPath,namespaces);
Should the assgnNamespaces() method simply use Class.forName() to see what type of Object it is and do a cast accordingly, or is there some other, more elegant way of doing this?
I hope I've explained myself, and haven't bored you ...
Thanks in advance,
Bob

Answer 1

Thanks for your reply!
I poked around a bit looking into Factory classes. I've used them a million times but never actually made one. At any rate, they seem like a good idea when you have a bunch of different classes that are similar but not equal.
In my case my classes ONLY have the XPathExpression in common. Which means that I'd have to make a base abstract class with a bunch of methods of which only a percentage are defined by any class that extends it. In other words, if I had 3 classes -- a, b and c -- that extend the base abstract class, and each had 5 getters and setters, the base abstract class would have 15 methods, 5 only used by a, 5 only used by b and 5 only used by c.
It seemed a bit ugly to me. Besides, I only have 3 classes. I decided to factor out the inner loop, which is about 70% of the code, stick it in a utility class, and call it from there. I am repeating some code still, but it isn't that bad, and it saves me having to define an interface, an abstract class, a Factory class, etc.
It ain't perfect, but then nothing ever is.
Thanks for all the help! Viva the Java community!
Bob