If you're calling a method that really doesn't depend on the underlying
object, just make the method static and don't bother with the object at
all:  Person.sayHello().

If the method might depend on the object, you have to get an object of
the right type.  You can't just cast any object to any type; i.e., there
is no Java equivalent of C-style casts, or of C++ reinterpret_cast.

Chances are good that if you feel the need to add new methods to
existing objects, you can get what you want by wrapping the objects in a
new type.  This also has the advantage that when you no longer need the
extra functionality, you can unwrap the objects, so the extra complexity
is limited to (e.g.) the parsing stage of your compiler, or the
loadUserPreferences step of your application, or whatever.  For example,
if you feel the need to call a Person method on a String, try making
Person an interface, and move the functionality into a wrapper class
that knows about Strings.

public interface Person {
    public void sayHello();
}

public class PersonableWrapper<T> implements Person {

    private T wrappedObject;

    public PersonableWrapper(T objectToWrap) {
        this.wrappedObject = objectToWrap;
    }

    public void sayHello() {
        System.out.println(wrappedObject.toString() + ":  Hello!");
    }
}

public class Main {

    private static void workWithPerson(Person person) {
        person.sayHello();
    }

    public static void main(String[] args){

        Integer i = new Integer(42);
        String s = "six times nine";

        workWithPerson(new PersonableWrapper<Integer>(i));
        workWithPerson(new PersonableWrapper<String>(s));
        workWithPerson(new PersonableWrapper<String>("goodGuy"));
    }
}

   It is desirable that the above attempt at casting generate a
compile-time error. Given that Person and String are not related via
inheritance, there is no way for this cast to succeed, and rather let you
find out at runtime, the compiler is able to detect this and tell you so at
compile time.

   - Oliver