根据您的特定需求，在某些情况下，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.

您看到您的实现和Eclipse之间的区别的原因是您每次都扫描，而Eclipse(和其他工具)只扫描一次(大多数时候在项目加载期间)并创建索引。下次你请求数据时，它不再扫描，而是查看索引。

找到classpath中的所有类

public static List<String> getClasses() {
        URLClassLoader urlClassLoader = (URLClassLoader) Thread.currentThread().getContextClassLoader();
        List<String> classes = new ArrayList<>();
        for (URL url : urlClassLoader.getURLs()) {
            try {
                if (url.toURI().getScheme().equals("file")) {
                    File file = new File(url.toURI());
                    if (file.exists()) {
                        try {
                            if (file.isDirectory()) {
                                for (File listFile : FileUtils.listFiles(file, new String[]{"class"}, true)) {
                                    String classFile = listFile.getAbsolutePath().replace(file.getAbsolutePath(), "").replace(".class", "");
                                    if (classFile.startsWith(File.separator)) {
                                        classFile = classFile.substring(1);
                                    }
                                    classes.add(classFile.replace(File.separator, "."));
                                }
                            } else {
                                JarFile jarFile = new JarFile(file);
                                if (url.getFile().endsWith(".jar")) {
                                    Enumeration<JarEntry> entries = jarFile.entries();
                                    while (entries.hasMoreElements()) {
                                        JarEntry jarEntry = entries.nextElement();
                                        if (jarEntry.getName().endsWith(".class")) {
                                            classes.add(jarEntry.getName().replace(".class", "").replace("/", "."));
                                        }
                                    }
                                }
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
        }
        return classes;
    }

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

我需要将此作为一个测试用例，以查看是否向代码中添加了新的类。这就是我所做的

final static File rootFolder = new File(SuperClass.class.getProtectionDomain().getCodeSource().getLocation().getPath());
private static ArrayList<String> files = new ArrayList<String>();
listFilesForFolder(rootFolder); 

@Test(timeout = 1000)
public void testNumberOfSubclasses(){
    ArrayList<String> listSubclasses = new ArrayList<>(files);
    listSubclasses.removeIf(s -> !s.contains("Superclass.class"));
    for(String subclass : listSubclasses){
        System.out.println(subclass);
    }
    assertTrue("You did not create a new subclass!", listSubclasses.size() >1);     
}

public static void listFilesForFolder(final File folder) {
    for (final File fileEntry : folder.listFiles()) {
        if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry);
        } else {
            files.add(fileEntry.getName().toString());
        }
    }
}

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

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.