如何简便且优雅地遍历给定Class<?>对象的所有父类及接口？

嘿，这个需求我刚好折腾过，给你分享一个简洁又优雅的实现方案——用**广度优先搜索（BFS）**来遍历类的继承和接口实现层级，同时通过集合去重避免重复收集相同的类型。

核心逻辑是用队列维护待遍历的类型，用有序集合记录已处理过的类型（既保证顺序又去重）。每次取出队列中的一个类型，就把它的父类和未处理过的接口加入队列，直到队列为空，就能完整收集所有层级的类和接口。

import java.util.*;

public class ClassHierarchyTraverser {

    public static Set<Class<?>> getAllHierarchyClasses(Class<?> startClass) {
        // LinkedHashSet 保证插入顺序（广度优先顺序）同时去重
        Set<Class<?>> hierarchy = new LinkedHashSet<>();
        Queue<Class<?>> queue = new LinkedList<>();

        if (startClass == null) {
            return hierarchy;
        }

        // 初始化队列和结果集合
        queue.add(startClass);
        hierarchy.add(startClass);

        while (!queue.isEmpty()) {
            Class<?> currentType = queue.poll();

            // 处理父类：如果父类存在且未被收集过，加入队列和集合
            Class<?> superClass = currentType.getSuperclass();
            if (superClass != null && !hierarchy.contains(superClass)) {
                // 可选：如果不需要收集Object类，加上 !Object.class.equals(superClass)
                hierarchy.add(superClass);
                queue.add(superClass);
            }

            // 处理所有接口：遍历当前类型实现的接口，未收集过的加入队列和集合
            for (Class<?> iface : currentType.getInterfaces()) {
                if (!hierarchy.contains(iface)) {
                    hierarchy.add(iface);
                    queue.add(iface);
                }
            }
        }

        return hierarchy;
    }

    // 模拟题目中的类结构并测试
    public static void main(String[] args) {
        Set<Class<?>> hierarchy = getAllHierarchyClasses(C0.class);
        System.out.println("广度优先遍历的类层级结构：");
        for (Class<?> clazz : hierarchy) {
            String typeLabel = clazz.isInterface() ? "接口" : "类";
            System.out.printf("%s (%s)%n", clazz.getSimpleName(), typeLabel);
        }
    }

    // 模拟题目中的类与接口关系
    interface I0 {}
    interface I1 {}
    interface I2 {}
    interface I3 {}
    class C2 implements I3 {}
    class C1 extends C2 implements I1, I2 {}
    class C0 extends C1 implements I0 {}
}

• LinkedHashSet的作用：既解决了重复收集问题（比如多个类实现同一接口），又能严格保持广度优先的遍历顺序，完美匹配你的需求。
• 队列的BFS逻辑：每次从队首取出一个类型，先处理它的父类，再处理所有接口，确保先遍历完当前层级的所有类型，再深入下一层级。
• 灵活扩展：如果不需要收集Object类，只需要在添加父类的判断里加上!Object.class.equals(superClass)；如果需要区分类和接口，可以把结果拆成两个集合分别存储。

运行测试代码后，会得到严格遵循广度优先的输出：

广度优先遍历的类层级结构：
C0 (类)
C1 (类)
I0 (接口)
C2 (类)
I1 (接口)
I2 (接口)
I3 (接口)
Object (类)

如果去掉Object类的收集，输出就会少最后一行。

内容的提问来源于stack exchange，提问作者Georg Plaz