是否有可能在Java中模拟Javascript风格的原型？

Question

I'd like to know whether it's possible to simulate Javascript prototypes in Java. Is it possible to associate a list of variables with a function in Java? I want to create something similar to Javascript prototypes, if that's even possible.

So here's an example (in Javascript):

    var s = doStuff.prototype;
s.isImplemented = false;
function doStuff(){
    //this function has not yet been implemented
}

var s = functionIsImplemented.prototype;
s.isImplemented = true;
function functionIsImplemented(theFunction){
    //this function returns true if the function has been identified as "implemented"
    if(theFunction.prototype.isImplemented == true){
        return true;
    }
    return false;
}
alert(functionIsImplemented(doStuff)); //this should print "false"
alert(functionIsImplemented(functionIsImplemented)); //this should print "true"​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

Is there any way to do the equivalent of this in Java?

Answer 1

Yes, it's certainly possible, and can be very useful for some situations.

Typically you would do the following:

• Create a class that contains a Map of properties. This becomes your "Base Object" class for all your prototypes. K is probably String, V is probably Object
• Create getters and setters for your properties
• Optionally add other utility methods, for example checking if a function is implemented basically means checking of the property map contains a specific key
• Implement prototype-based inheritance by either cloning the property map of another object or (more complex) keeping a reference back to the original object
• Use function objects of some sort to allow the storage of arbitrary code within properties

It's not as elegant as if you do this directly in a dynamic language, but it works and gets you the same benefits (runtime flexibility, avoid constraints of rigid OOP, fast proptotyping etc.).

It also has the same downsides - loss of static type checking and some performance overhead being the main ones.

As an example, the open source game I wrote ( Tyrant ) uses this approach for all the in-game objects.