几年前我就这样做了。最可靠的方法(即使用官方Java api，没有外部依赖)是编写一个自定义doclet来生成一个可以在运行时读取的列表。

你可以像这样从命令行运行它:

javadoc -d build -doclet com.example.ObjectListDoclet -sourcepath java/src -subpackages com.example

或者像这样从ant运行它:

<javadoc sourcepath="${src}" packagenames="*" >
  <doclet name="com.example.ObjectListDoclet" path="${build}"/>
</javadoc>

下面是基本代码:

public final class ObjectListDoclet {
    public static final String TOP_CLASS_NAME =  "com.example.MyClass";        

    /** Doclet entry point. */
    public static boolean start(RootDoc root) throws Exception {
        try {
            ClassDoc topClassDoc = root.classNamed(TOP_CLASS_NAME);
            for (ClassDoc classDoc : root.classes()) {
                if (classDoc.subclassOf(topClassDoc)) {
                    System.out.println(classDoc);
                }
            }
            return true;
        }
        catch (Exception ex) {
            ex.printStackTrace();
            return false;
        }
    }
}

为了简单起见，我删除了命令行参数解析，并将其写入System。Out而不是file。

不要忘记，为类生成的Javadoc将包括一个已知子类列表(对于接口，包括已知实现类)。

你可以使用org。然后，创建一个reflections类的对象。使用此对象，您可以获得给定类的所有子类的列表。 https://www.javadoc.io/doc/org.reflections/reflections/0.9.10/org/reflections/Reflections.html

    Reflections reflections = new Reflections("my.project.prefix");
    System.out.println(reflections.getSubTypesOf(A.class)));

根据您的特定需求，在某些情况下，Java的服务加载器机制可能实现您想要的结果。

简而言之，它允许开发人员通过将一个类列在JAR/WAR文件的META-INF/services目录中的一个文件中，显式地声明一个类是另一个类的子类(或实现了一些接口)。然后可以使用java.util.ServiceLoader类发现它，当给出class对象时，它将生成该类的所有声明子类的实例(或者，如果class表示接口，则生成实现该接口的所有类)。

这种方法的主要优点是不需要手动扫描整个类路径中的子类——所有的发现逻辑都包含在ServiceLoader类中，它只加载在META-INF/services目录中显式声明的类(而不是类路径中的每个类)。

然而，也有一些缺点:

It won't find all subclasses, only those that are explicitly declared. As such, if you need to truly find all subclasses, this approach may be insufficient. It requires the developer to explicitly declare the class under the META-INF/services directory. This is an additional burden on the developer, and can be error-prone. The ServiceLoader.iterator() generates subclass instances, not their Class objects. This causes two issues: You don't get any say on how the subclasses are constructed - the no-arg constructor is used to create the instances. As such, the subclasses must have a default constructor, or must explicity declare a no-arg constructor.

显然，Java 9将解决其中一些缺点(特别是关于子类实例化的缺点)。

一个例子

假设你对查找实现接口com.example.的类感兴趣。

package com.example;

public interface Example {
    public String getStr();
}

com.example.ExampleImpl类实现了该接口:

package com.example;

public class ExampleImpl implements Example {
    public String getStr() {
        return "ExampleImpl's string.";
    }
}

通过创建文件META-INF/services/com.example，可以声明类ExampleImpl是Example的实现。包含文本com.example.ExampleImpl的示例。

然后，您可以获得Example的每个实现的实例(包括ExampleImpl的实例)，如下所示:

ServiceLoader<Example> loader = ServiceLoader.load(Example.class)
for (Example example : loader) {
    System.out.println(example.getStr());
}

// Prints "ExampleImpl's string.", plus whatever is returned
// by other declared implementations of com.example.Example.

还要注意的是，这当然只能找到当前类路径中存在的所有子类。想必这对于你目前所看到的是可以的，而且你也有可能考虑过这一点，但如果你在任何时候发布了一个非最终类(对于不同程度的“狂野”)，那么其他人已经编写了他们自己的子类，而你不知道这是完全可行的。

Thus if you happened to be wanting to see all subclasses because you want to make a change and are going to see how it affects subclasses' behaviour - then bear in mind the subclasses that you can't see. Ideally all of your non-private methods, and the class itself should be well-documented; make changes according to this documentation without changing the semantics of methods/non-private fields and your changes should be backwards-compatible, for any subclass that followed your definition of the superclass at least.

我只是写了一个简单的演示来使用org.reflections.Reflections来获取抽象类的子类:

https://github.com/xmeng1/ReflectionsDemo