Reasoning about reflection, your thoughts

Question

Hello all,
I would like to have your opinion about the following. To keep things simple, I'll explain my thoughts by referring to the interface java.util.List and the reverse(List) function in java.util.Collections.
Imagine you have some implementation of List (lets call this class SomeList), which can reverse the elements it holds on a quicker/better/more elegant/etc. way than the algorithm in Collections.reverse(). For example, SomeList can be built as a simply pointer-list, such that reversing the elements is simple a matter of swapping the head and tail-pointer.
In order to use the power of SomeList when it comes to reversing the elements, whitout having to move the reverse()-function from java.util.Collections to java.util.List (so Somelist can have it's own reverse() function, and ArrayList can use the general algorithm in AbstractList) (*), I thought about implementing java.util.Collections.reverse(List) as following:
public class Collections
  public static void reverse(List l)
     1) use reflection to check if the inputlist, l, has a function Collections_reverse();
     2)   if l has this function, call l.Collections_reverse()
     3)   if l hasn't this function, run the standard algorithm (the one currently in Collections.reverse()
}What do you think of this approach? By checking if the given input has a better implementation of the current function, users can override algorithms, even if these algorithms won't be called directly on the class itself. Is this a good use of reflection? Is this all possible? (this might be an odd question, but I don't have much experience with reflection)
(*) Indeed, I can simple move the reverse(List) function from java.util.Collections to java.util.List, but that doesn't look a good idea to me, since this would also be a reason to move java.util.Collections.sort(List), java.util.Collections.shuffle(List), etc. which will result in an enormous, overloaded, non-simple List-interface at the end.
thanks a lot for your ideas,
Peter

Answer 1

Yeah, marker interfaces are related, however I did intend something different. What I want is to override functions from another class, and to call the overrided function by reflection. I'll give a simple example:
Assume you have an interface:
interface CollectionInterface<T>
     public boolean add(T o);
     public boolean remove(T o);
     public Iterator<T> iterator();
}Also you have a class with static funcions. For example:
class AlgorithmsOnCollections
     public static <T> int count(CollectionInterface<T> c, int dummy)
}Countinig the elements in a CollectionInterface is very easy: simply count the elements returned by the iterator:
class AlgorithmsOnCollections
     public static <T> int count(CollectionInterface<T> c)
          Iterator<T> it = c.iterator();
          int count = 0;
          while (it.hasNext())
               it.next();
               ++count;
          return count;
}However, most collections will have a private member size, which will be incremented/decremented on every add/remove call. AlgorithmsOnCollections has ofcourse no access to it. Therefor I thought about implementing count() as followed:
class AlgorithmsOnCollections
     public static <T> int count(CollectionInterface<T> c, int dummy)
          Method method = null;
          try
               method = c.getClass().getMethod("AlgorithmsOnCollections_count", int.class);
               return (Integer) method.invoke(c, dummy);
          catch (NoSuchMethodException e) // run standard, general-purpose algorithm
               Iterator<T> it = c.iterator();
               int count = 0;
               while (it.hasNext())
                    it.next();
                    ++count;
               return count;
          catch (IllegalAccessException e)
               throw new RuntimeException();
          catch (InvocationTargetException e)
               throw new RuntimeException();
}Subclasses/implementations of CollectionInterface can decide to 'have' (I'd rather not call it 'implement', since the function isn't in the interface - thats the whole point) the function AlgorithmsOnCollections_count(). If they have it, it will be called by AlgorithmsOnCollections.count(). If they don't have it, the elements will be counted by the iterator.
What do you think of this? Note that the example is very simple (there is no reason to place simple functions like count() in an external class).
Here is a fully working example:
import java.lang.reflect.*;
import java.util.*;
interface CollectionInterface<T>
     public boolean add(T o);
     public boolean remove(T o);
     public Iterator<T> iterator();
class SomeCollection1<T> implements CollectionInterface<T>
     private List<T> elements = new ArrayList<T>();
     public boolean add(T e) { return elements.add(e); }
     public boolean remove(T e) { return elements.remove(e); }
     public Iterator<T> iterator() { return elements.iterator(); }
     public int AlgorithmsOnCollections_count(int dummy) // !! not in CollectionInterface !!
          System.out.println("SomeCollection.count() called!");
          return elements.size();
class SomeCollection2<T> implements CollectionInterface<T>
     private List<T> elements = new ArrayList<T>();
     public boolean add(T e) { return elements.add(e); }
     public boolean remove(T e) { return elements.remove(e); }
     public Iterator<T> iterator() { return elements.iterator(); }
class AlgorithmsOnCollections
     public static <T> int count(CollectionInterface<T> c, int dummy)
          Method method = null;
          try
               method = c.getClass().getMethod("AlgorithmsOnCollections_count", int.class);
               return (Integer) method.invoke(c, dummy);
          catch (NoSuchMethodException e) // run standard, general-purpose algorithm
               Iterator<T> it = c.iterator();
               int count = 0;
               while (it.hasNext())
                    it.next();
                    ++count;
               return count;
          catch (IllegalAccessException e)
               throw new RuntimeException();
          catch (InvocationTargetException e)
               throw new RuntimeException();
public class Reflection
     public static void main(String[] args)
          CollectionInterface<Integer> c1 = new SomeCollection1<Integer>();
          CollectionInterface<Integer> c2 = new SomeCollection2<Integer>();
          c1.add(new Integer(10));
          c1.add(new Integer(4320));
          c2.add(new Integer(43));
          c2.add(new Integer(23));
          c2.add(new Integer(169));
          System.out.println(AlgorithmsOnCollections.count(c1, 75));
          System.out.println(AlgorithmsOnCollections.count(c2, 42));
}The output is:
SomeCollection.count() called!
2
3
Please let me you know your thoughts! Thanks,
Peter