Inheritance with unknown descendents

Question

Let's say I have a labyrinth with AI characters, where the users define the characters. Each user provide the classes for their individual characters. All the characters/classes extend some class/type C which has method control().

I want to do call each user's control() method, but I don't know how many users there will be or what classes they will provide. How do I resolve this problem?

EDIT: I wanted to convey that I do not know how many subclasses there are, or what their names are. Therefore, I am not able to place those subclasses in the code statically.

EDIT 2: Is there a way of doing this WITHOUT using reflection? I am aware that reflection solves the problem, but I hoped there was a cleaner implementation.

EDIT 3: It completely necessary to have the users create the different classes, as the point of the program is to test competing AIs.

btw, I am writing this in Java.

Answer 1

The whole thing about inheritance is that you don't need to know the exact type. If you have a reference to an object that is of type C or a subclass of C, you can call your "control()" method on them and it will call the right method, i.e. the one implemented by the child class.

Not knowing how many users means you'll have to use a list or something and loop over it.

public class AIGame {
public static void main(String[] args) {
    List<AICharacter> characters = new ArrayList<AICharacter>();
    characters.add( new ReallySmartAICharacter() );
    characters.add( new ReallyDumbAICharacter() );
    for ( AICharacter c : characters ) {
        c.control();
    }
    }
}

interface AICharacter {
    public void control();
}

class ReallySmartAICharacter implements AICharacter {
    @Override
    public void control() {
        // TODO do something clever here        
    }   
}

class ReallyDumbAICharacter implements AICharacter {
    @Override
    public void control() {
        // TODO do something stupid here        
    }
}

Answer 2

First of all, you need to decide if the different characters' behavior is really going to be as differentiated as to need Java code to implement the particular behaviors. Perhaps the behavior can be expressed with a single class and only modified by setting different values for parameters such as speed, health, attack strength etc. In this case you would get rid of the inheritance problem altogether and use a single class while users would only provide different configurations.

Now, if you really need very custom behavior and load custom Java classes, I see two main solutions.

First is the standard one. It uses just a tiny bit of reflection. You define an interface, for example:

public interface C {
    void control(); //Params skipped for brevity
}

Now, your users create classes which implement this interface. The only problem is how to create an instance of the player's class. Once you have it, you call its control() or other methods via the interface. First, users need to make this class loadable. Thiscan be done through the network or in other complex ways but the simplest is that they put their .class or .jar file in their classpath when they run your application. Now all you need is to create an instance of the class. Assuming you specify the requirement that the class have a zero-argument constructor (you can define a method in your interface to load some configuration and perform initialization later on), you would be doing something like:

C gameCharacter = (C)Class.forName("your.fully.qualified.ClassName").newInstance();

Apart from error handling, that's all the reflection you need. You can now call all methods of interface C on your gameCharacter object - without knowing who or how wrote it and what exactly the methods do.

The other solution would be to use Groovy or another similar language to compile and run code on the fly. In this case you don't need the custom JAR in the classpath and you can even get around the need to know the name of the class to be loaded. Your user can provide the Java code of control() method in the form of text, and you can have a stub class whose control() method only compiles and executes the Groovy code the user provided. This may be more convenient, but requires the custom character code to be provided to you as source code, not compiled JAR, which may be a problem for some users. Also, this solution is more convenient if the implementations are going to be short and self-contained while the separate JAR and loading via reflection is better if the loaded code is more complex, uses helper classes apart from the main class etc.

Answer 3

If all the characters extend some common class, for convenience let's call it Character, then you can use polymorphism to dynamically call each of the control() methods.

In other words, if each subclass of Character overrides control(), then all you need to do is call it normally and Java will figure out which control() method to call.

e.g.

Character[] characters = new Character[2];
characters[0] = new Man(); // Man is a subclass of Character
characters[1] = new Woman(); // same with Woman

character[0].control(); // <- this will call the control() method as defined in Man

The mechanism for this is called late (or dynamic) binding, which you can read more about here: http://en.wikipedia.org/wiki/Late_binding

If the subclasses are not known at compile-time (i.e. they are specified at run-time), then you will need to use reflection to load them.

To keep track of each user, use a dynamically sized List type like a LinkedList or ArrayList. This way you don't need to know how many users there are beforehand.