If there is, it will be buried somewhere in the Java.lang.reflect
package.

You can't really write it, since someone might just decide to call
ClassLoader#defineClass("An+1", ...); just after your
findAllSubClassesofA() returns.

The short answer is that the reflection APIs do not provide a way to get the
subclasses of a given class. (Unlike the superclasses and superinterfaces of
a given class, the subclasses do not have to be loaded when a class is
loaded. So, at the time you make the query, the VM might not even be aware
of /any/ subclasses of A.)

You might want to hardcode the expected response in your
findAllSubClassesofA() method.

You could attempt to find (or recreate) the classpath that you're operating
on, and iterate over the .class files you find this way, querying each one
to see if it meets your requirements. (This is painful, though possible, to
do.) Be aware that this approach won't find subclasses of A that don't exist
on the classpath. (Ex, it is possible to dynamically generate at runtime a
subclass of A.) It presumes that there's a way to iterate over items on the
classpath -- this isn't always true. Even if it is true, it's quite slow and
hard to get right. (I've done something like it in the past.)

If (and ONLY if) you control all subclasses of A, you can have them
register themselves with A when loaded:

class A {
 private static final Set<Class<? extends A>> subclasses = ...;

 protected static registerSubclass (Class<? extends A> clazz) {
   assert (clazz != null);
   subclasses.add (clazz);
 }

 public static Iterable<Class<? extends A>> getSubclasses () {
   return Collections.unmodifiableSet (subclasses);
 }
}

class A1 {
 static { // happens when A1 is loaded
   registerSubclass (A1.class);
 }
}

However, the results of A.getSubclasses () will be different at different
points in execution, as subclasses are loaded.

If you don't control derivation from A, this doesn't work, and nothing
else actually does.  You may want to stop wanting that and find another
solution to your problem.

-Owen

As others have indicated, you can't do exactly what you want.

However, if you control class A, you can find all subclasses for which
at least one instance has been created.

Keep a static Set of subclass names. In A's constructor, check whether
the current object's class name is "A" (possibly qualified with package
name), or any String in the Set. If not, insert the name in the Set.
findAllSubClassesofA returns the Set's toArray() result.

All this stuff gets very awkward. Could you tell us what you are trying
to achieve at the next level up? Why do you want the array of subclass
names? There may be an easier solution to your real problem.

Patricia