Lambda the Ultimate

Simple question: Any way I can get from a class to its subclasses?

In Java, specifically, a superclass is never cognizant of it's subclasses.

In the normal scheme of things this is, of course, a Good Thing. OCP and all that.

I just think that reflection breaks enough access checks, and information hiding, that this should also be possible...

| myCollection |

"immediate subclasses"
myCollection := String subclasses.

"all subclasses"
myCollection := String allSubclasses.

"immediate superclass"
myCollection := String superclass.

"all superclasses"
myCollection := String allSuperclasses.

The beauty of Smalltalk is that the image acts as a repository for objects - being sort of a object database. The image holds all the information for the defined classes and can be accessed via the main Smalltalk dictionary object which holds both a collection of all the metaclass definitions and any and all objects which have been instantiated. Beyond just asking about the hierarchy, you can even do stuff like count the number of instances of a particular object type (how many strings are loaded in memory?).

From the Java perspective (indeed from most languages that don't have the concept of the Smalltalk image), the question is a bit more difficult. The only thing that you possibly reflect on is the the classes and objects which have been loaded and instantiated up to that point in time. We could, theoretically, have the JVM return all subclasses which have been loaded into the JVM up to that point in time. Even when the JVM garbage collects objects, it has a tendency to retain the class definition in memory for a much longer period of time - making it possible to know the subclass, even if all the instances have gone through GC.

But, for some reason, Java is not friendly to the notion of reflecting on the classes which have been loaded by the classloader and reversing out the class hierarchy. The Security model tends to try to hide such things from user level classes. The only way to get around the security is to write your own class loader and then save off the class information as you go and then expose that information to whatever classes you want to give access.

So, yes, it is possible to extract and save off the information with a custom classloader, but the standard classloader (nor the default reflection methods) does not provide that facility.

Another alternative which IBM uses in the VAJ tool is to save off class metadata as part of the development environment. That is, you may not be able to get runtime reflection, but the development tool can provide that information to you for inspection. Indeed, the inspection tools for VAJ are very much based upon the inspection tools built into Visual Age for Smalltalk (much of VAJ is actually written in Smalltalk and runs on top of a Smalltalk VM).

And even then, I think you'd only be able to get subclasses that had already been referenced(?).

Reflection in Java is ugly and tedious.

Reflection in Java is ugly and tedious.

I came to pretty much the same conclusion.

Any suggestions for better reflection support in a mainstream language, aside from Smalltalk?

I suspect CLOS (Common Lisp's Object System) might be eaier to use (than Java) - I've never used reflection, but the index to AMOP (Kiczales et al) lists methods that return super and sub classes, and getting slot names is fairly simple. Dynamic typing probably helps a lot.

Common Lisp is always a good candidate for "does any language do...?" questions!

I haven't really used it, but reflection is quite connected to meta-object-proctocols (MOPs), and the classic here is indeed the CLOS book/implementation.

I haven't read the book, just keep seeing references to it... Guess I have to go find it. Is it worth the trouble, or is the book just a spec?

Well, I was disappointed - I never finished it. I guess I was hoping for something more general, which was a bit silly, as it really is an advanced book about MOPs. The first third/half is a general discussion with code on MOP design and the second half/two-thirds is a detailed spec for CLOS. If you want to know about CLOS it's probably very good (although I think it covers a subset of the final ANSI standard). But it's not a great programming book that is also about CLOS...

In other words, if you want to spend you're time arguing with Erik, you might need it. But if you don't know who Erik is, I wouldn't bother ;-)

(I hope that comment still aplies - I've not read c.l.lisp lately!)

In fact I am more interested in the discussion of the MOP design, than I am interested in CLOS. At least at the moment.

Any better references?