blocks|key|3103609|text|简短的回答是否定的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3103610|长篇大论的答案是，子类可以以多种方式存在，这基本上使得无法明确地找到所有子类。|3103611|你不能在运行时这样做，但是你不能找到类，直到它们被加载，你怎么知道它们被加载了？您可以扫描每个JAR和类文件，但这并不确定。另外还有像URL类加载器这样的东西。|3103612|内部类(静态和非静态)是另一种需要考虑的情况。命名的内部类更容易找到。匿名内部类可能更难找到。|3103613|您还必须考虑到，如果一个类有子类，则可以在以后创建新的子类。|3103614|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

The short answer is no.

The long answer is that subclasses can come into existence in many ways, which basically makes it impossible to categorically find them all.

You can't do it at runtime but you can't find classes until they're loaded and how do you know they're loaded? You could scan every JAR and class file but that's not definitive. Plus there are things like URL class loaders.

Inner classes (static and non-static) are another case to consider. Named inner classes are easier to find. Anonymous inner classes are potentially much more difficult to find.

You also have to consider that if a class has subclasses then new subclasses can be created at a later point.

blocks|key|340310|text|如果您只从磁盘或URL加载类，那么您可以扫描类路径并“手动”查找子类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340311|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you only load classes from the disk or from URLs then you can scan the classpath and find subclasses "manually".

blocks|key|3103657|text|我试图通过这里的答案来推理，所以我可能是错的。对于一个类来说，拥有关于它的后代或子类的信息是没有意义的，因为任何时候都可能有人创建你的类的一个新的子类。然后，您必须重新编译您的类，以便每次都包含此新信息。这对于可扩展代码没有意义。类更有可能包含有关其祖先的信息。所以我能看到的唯一的解决方案就是迭代你的问题空间中的每个类并检查，但这对你来说很可能是一个可怕的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3103658|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I am trying to reason through the answer here so I am probably wrong. It would not make sense for a class to have information about its descendants or subclasses because at any point in time someone can create a new subclass of your class. Then you would have to recompile your class to include this new information every time. This does not make sense for extendable code. It is more likely for a class to contain information about its ancestors. So the only solution that I can see is for you to iterate over every class in your problem space and check but this is more than likely a horrible solution for you.

blocks|key|3316550|text|我总是可以为任何非最终类创建一个新的子类，将这个子类添加到类路径中，这样就会破坏您的意图。子类化是一个开放的命题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3316551|您所能做的最好的事情就是，对于给定的类路径，您知道子类是什么，为此，您必须扫描类路径中的每个类。|3316552|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I can always create a new subclass for any non-final class, add the subclass to the classpath, and defeat your intent. Subclassing is an open-ended proposition.

About the best you can do is say that for a given classpath, you know what the subclasses are, and to do that, you'd have to scan each class in the classpath.

blocks|key|3316580|text|使用反射是相当简单的。阅读这篇来自JavaWorld的文章|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3316581|http://www.javaworld.com/javaworld/javatips/jw-javatip113.html|offset|length|3316582|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1Q|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

It's fairly simple using reflection. Read this article from JavaWorld

<a href="http://www.javaworld.com/javaworld/javatips/jw-javatip113.html" rel="nofollow noreferrer">http://www.javaworld.com/javaworld/javatips/jw-javatip113.html</a>

blocks|key|3103744|text|唯一能做到这一点的方法是遍历类路径中可用包的包层次结构，通过反射检查每个类(这将很糟糕，因为您将有效地加载每个类，除非您将搜索限制到特定的包)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3103745|这种自动魔术行为的问题是，如果不运行应用程序，就很难对其进行量化，这是一个令人头疼的维护问题。我总是更喜欢使用注入路线(a-la+Spring)，通过某种配置来传递实例。|3103746|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The only way you'd be able to do it is walking the package hierarchy for the packages available in the classpath checking each class via reflection (and that's gonna suck because you'll effectively load every class, unless you restrict your search to certain packages). 

The trouble with this sort of auto-magical behavior is that it becomes hard to quantify the application without running it, which is a maintenance headache. I'd always prefer to go the injection route (a-la Spring) passing instances via some sort of configuration.

blocks|key|337907|text|是要枚举实现特定接口的类，还是枚举从某个基类派生的类？这是两个不同的问题。据我所知，这两者都很难实现，因为未来任何时候都可以在PC上创建/安装新的实现。这听起来像是您正在尝试创建一个工厂方法来实例化一个特定的实例，并且您不希望在代码中硬编码类名。通常，使用一个枚举实现接口的所有类的配置文件是可行的(也可以使用数据库)。当新的类实现接口时，您将它们添加到配置文件中，工厂应该选择新的类名。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|337908|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Do you want to enumerate classes that implement a particular interface or enumerate classes that derive from some base class? These are two different issues. Both as far as I know would be hard to implement since new implementations can be created/installed on a PC at any time in the future. It sounds like you are trying to create a factory method to instantiate a particular instance and you don't want to hard-code the class name in the code. Usually using a config file that enumerates all the classes that implement the interface is the way to go (or a database can be used). As new classes implement the interface, you add them to the config file and the factory should pick up the new class name.

blocks|key|335493|text|你应该使用ServiceLoader，它是一个内置的类。它能够在运行时迭代所有已知的服务(接口)实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|335494|如果由于某种原因你不想要它，你可以使用ClassLoader.getSystemResources()来迭代所有的资源；例如，如果你有6次文件/META-INF/com.interface，你会得到6次迭代。|335495|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/util/ServiceLoader.html^0|5|D|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

you should use Java <a href="http://java.sun.com/javase/6/docs/api/java/util/ServiceLoader.html" rel="noreferrer">ServiceLoader</a> that is a builtin class. It is capable of iterating at runtime over all know service (interface) implementations. 

If for some reason you don't want it, you can use ClassLoader.getSystemResources() to iterate over all resources; e.g. if you have 6 times the file /META-INF/com.interface you'll get 6 iterations.

<blockquote>
 Possible Duplicate: 
 <a href="https://stackoverflow.com/questions/492184/how-do-you-find-all-subclasses-of-a-given-class-in-java">How do you find all subclasses of a given class in Java?</a> 
</blockquote>

Hi,

I would like to get a list of classes that implement an interface in Java at runtime so I can do a lookup service without having to hard code it. Is there a simple way of doing this? I fear not.

Is it possible to get all the subclasses of a class?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

 可能重复：嗨,我想获得一个在运行时用Java实现接口的类的列表，这样我就可以不用硬编码就能做一个查找服务。有没有简单的方法可以做到这一点？恐怕不是。

问是否有可能获得一个类的所有子类？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否有可能获得一个类的所有子类？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否有可能获得一个类的所有子类？
EN