Design flaw in overloading? Problem with visitor pattern

Question

I have been trying some implementations of the Visitor pattern in Java and have encountered a problem with overloaded methods in Java. It seems that the caller (client) of a overloaded method decides what implementation of that method is chosen. I find that strange from an OO / encapsulation point of view and it gets me into problems when using Visitor. This code shows my problem:
// a class with overloaded methods
public class OverLoadingTest {
     public void print(String s) {
          System.out.println("This looks like a String to me:");
          System.out.println("\"" + s + "\"");
     public void print(Object o) {
          System.out.println("This looks like an Object to me:");
          System.out.println("\"" + o + "\"");
//a client for that class
public class OverLoadingTestClient {
     public void test() {
          OverLoadingTest test = new OverLoadingTest();
          Object o1 = "String in an Object reference";
          String s1 = "String in a String reference";
          test.print(o1);
          test.print(s1);
     public static void main(String[] args) {
          new OverLoadingTestClient().test();
//And the output is:
This looks like an Object to me:
"String in an Object reference"
This looks like a String to me:
"String in a String reference"
//The output I would have expeced (wanted):
This looks like a String to me: //it is a String!
"String in an Object reference"
This looks like a String to me:
"String in a String reference"
Why is this? Is there a work around?

Answer 1

The specific method is decided on in compile time and by the client of that method, not the provider. I'd expect the client to just invoke the method and let the privider figure out what implementation to choose. Whatever the client thinks that he is providing as argument types.
I am implementing a slightly different version compared to http://ootips.org/visitor-pattern.html. I find implementing "v.visit(this);" for every subclass of the Visisted superclass strange. Why an abstract method "accept(Visitor v);" when all subclasses will iplement it in the same way ("v.visit(this);")?
Daan