如何遍历超类List集合并访问子类属性？避免向下转型与instanceof

嘿，这个问题其实是面向对象设计里很经典的「摆脱类型判断」场景，完全可以用多态特性或者设计模式来优雅解决，不用那些破坏开闭原则的instanceof和向下转型操作。下面给你两种实用的方案：

方案一：利用多态，让子类承担处理逻辑 #

这是最直接的方式，核心思路是把针对子类的操作逻辑封装到子类自己内部，通过父类定义的抽象方法来触发多态调用。

代码示例 #

首先改造父类A，添加一个抽象的处理方法：

public abstract class A {
    private int x;

    // getter、setter省略
    public abstract void process();
}

然后子类B和C各自实现这个方法，处理自己的独特属性：

public class B extends A {
    private int y;

    // getter、setter省略
    @Override
    public void process() {
        // 这里处理B类独有的逻辑，比如操作y
        System.out.println("处理B类的y属性：" + getY());
    }
}

public class C extends A {
    private int z;

    // getter、setter省略
    @Override
    public void process() {
        // 这里处理C类独有的逻辑，比如操作z
        System.out.println("处理C类的z属性：" + getZ());
    }
}

最后遍历集合时，直接调用每个元素的process()方法即可：

List<A> list = Arrays.asList(new B(), new C());
for (A item : list) {
    item.process();
}

这种方案的好处是简单直观，逻辑和子类绑定，符合开闭原则——新增子类时只需要实现process()方法，不用修改遍历的代码。

方案二：访问者模式（Visitor Pattern） #

如果你的处理逻辑和子类本身是分离的（比如需要对同一组子类做多种不同的操作），访问者模式会更合适。它能把操作逻辑从子类中抽离出来，集中到访问者类里。

代码示例 #

首先定义访问者接口，针对每个子类声明对应的访问方法：

public interface Visitor {
    void visit(B b);
    void visit(C c);
}

然后改造父类A，添加一个accept方法，用于接收访问者：

public abstract class A {
    private int x;

    // getter、setter省略
    public abstract void accept(Visitor visitor);
}

子类B和C实现accept方法，主动调用访问者的对应方法：

public class B extends A {
    private int y;

    // getter、setter省略
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class C extends A {
    private int z;

    // getter、setter省略
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

接下来创建具体的访问者实现，编写处理逻辑：

public class PropertyPrinterVisitor implements Visitor {
    @Override
    public void visit(B b) {
        System.out.println("B类的x：" + b.getX() + "，y：" + b.getY());
    }

    @Override
    public void visit(C c) {
        System.out.println("C类的x：" + c.getX() + "，z：" + c.getZ());
    }
}

最后遍历集合时，让每个元素接收访问者：

List<A> list = Arrays.asList(new B(), new C());
Visitor printer = new PropertyPrinterVisitor();
for (A item : list) {
    item.accept(printer);
}

这种方案的优势是操作逻辑与子类解耦，如果需要新增一种操作，只需要新增一个Visitor实现，不用修改子类代码。不过它也有局限性——如果后续要新增子类，需要修改Visitor接口和所有实现类，违反开闭原则，所以适合子类类型相对固定的场景。

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