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

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

用纯Java扫描类并不容易。

spring框架提供了一个名为ClassPathScanningCandidateComponentProvider的类，它可以满足您的需要。下面的示例将在包org.example.package中找到MyClass的所有子类

ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
provider.addIncludeFilter(new AssignableTypeFilter(MyClass.class));

// scan in org.example.package
Set<BeanDefinition> components = provider.findCandidateComponents("org/example/package");
for (BeanDefinition component : components)
{
    Class cls = Class.forName(component.getBeanClassName());
    // use class cls found
}

该方法还有一个额外的好处，就是使用字节码分析器来查找候选类，这意味着它不会加载所扫描的所有类。

记住其他答案中提到的限制，你也可以以以下方式使用openpojo的PojoClassFactory(在Maven上可用):

for(PojoClass pojoClass : PojoClassFactory.enumerateClassesByExtendingType(packageRoot, Superclass.class, null)) {
    System.out.println(pojoClass.getClazz());
}

packageRoot是你想要搜索的包的根字符串。“com。mycompany”或者只是“com”)，超类是你的超类型(这也适用于接口)。

我知道我在这个派对上晚了几年，但我遇到这个问题是为了解决同样的问题。如果您正在编写Eclipse Plugin(从而利用它们的缓存等)，您可以通过编程方式使用Eclipse的内部搜索来查找实现接口的类。这是我(非常粗糙的)第一次剪:

  protected void listImplementingClasses( String iface ) throws CoreException
  {
    final IJavaProject project = <get your project here>;
    try
    {
      final IType ifaceType = project.findType( iface );
      final SearchPattern ifacePattern = SearchPattern.createPattern( ifaceType, IJavaSearchConstants.IMPLEMENTORS );
      final IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
      final SearchEngine searchEngine = new SearchEngine();
      final LinkedList<SearchMatch> results = new LinkedList<SearchMatch>();
      searchEngine.search( ifacePattern, 
      new SearchParticipant[]{ SearchEngine.getDefaultSearchParticipant() }, scope, new SearchRequestor() {

        @Override
        public void acceptSearchMatch( SearchMatch match ) throws CoreException
        {
          results.add( match );
        }

      }, new IProgressMonitor() {

        @Override
        public void beginTask( String name, int totalWork )
        {
        }

        @Override
        public void done()
        {
          System.out.println( results );
        }

        @Override
        public void internalWorked( double work )
        {
        }

        @Override
        public boolean isCanceled()
        {
          return false;
        }

        @Override
        public void setCanceled( boolean value )
        {
        }

        @Override
        public void setTaskName( String name )
        {
        }

        @Override
        public void subTask( String name )
        {
        }

        @Override
        public void worked( int work )
        {
        }

      });

    } catch( JavaModelException e )
    {
      e.printStackTrace();
    }
  }

到目前为止，我看到的第一个问题是，我只捕获直接实现接口的类，而不是它们的所有子类——但一点递归不会伤害任何人。

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

https://github.com/xmeng1/ReflectionsDemo