Invoke not known method in not known class.

Question

Everybody,
I am confusing about loading, invoking a little-known class, method. 'Little-known' means, when
designing we don't know the existence of that class, method. The application'll know names of
class, method which are inputted by user (Those classes exist when the user input).
For example: look at 'Little-known' class: FutureClass. It has method notKnownMethod as below
package notnow
public class FutureClass extends now.KnownClass {
  public void notKnownMethod() {
}and the application main class MainApp.
  public class MainApp {
    public static void main(String[] args) {
      // these variable will be inputted by users
      // this is what we not known
      String className = "notnow.FutureClass";
      String methodName = "notKnownMethod";
      try {
        // create instance of the class
        // use the name inputted bye user
        Class futureClass = Class.forName("notnow.FutureClass");
        // get method in that class
        Method futureMethod = futureClass.getMethod("notKnownMethod", null);
        // and then invoke it -- Error dialog appears:
        // Prompt:  "Java Virtual Machine Launcher"
        // Content: "Fatal excption occurred. Program will exit"
        // with exception throw: java.lang.IllegalArgumentException: object is not an instance of  
        // declaring class. Point to next row.
        futureMethod.invoke(new now.KnownClass(), null);
        //futureMethod.invoke(new notnow.FutureClass(), null); -- No Error
        // but we don't know name of the class till user input it.
      }catch (Exception e) {}
  }You may think it's reflection, but reflection uses the known object in the invoke method(like the tutorial http://java.sun.com/docs/books/tutorial/reflect/object/invoke.html ). So how to invoke a method of a class known in the future (bussiness rule or update) ?
Please help me out of this problem.
Thanks for advance
Liwh

Answer 1

Take a closer look at the tutorial.
To use a non-static method from the class, you must have an instance of the class. That means either calling one of the class' constructors or using the newInstance method to invoke the default no-args constructor.
Object instance = futureClass.newInstance();
futureMethod.invoke(instance, null);I will let you play with calling methods whose argument list you don't know...
And if you know all you FutureClasses will extend a particular CurrentClass, make CurrentClass abstract with a few abstract methods that you would use in FutureClass... It will make life a lot easier:
public abstract class CurrentClass {
  //All the other stuff
  public abstract void runPrimaryMethod();
//Then in FutureClass
public class FutureClass extends CurrentClass {
  //Other Stuff
  public void notKnownMethod () {
    //Stuff
  public void runPrimaryMethod() {
    notKnownMethod();
//Then in main body
    CurrentClass instance = (CurrentClass)futureClas.newInstance();
    instance.runPrimaryMethid();Interfaces are also good for this.