Java 如何在此框架中正确使用继承

我有一个抽象类ChildNode

public abstract class ChildNode {
    public abstract boolean activate()
    public abstract void execute();
}

和一个抽象类ParrentNode

public abstract class ParentNode extends ChildNode {
    public ArrayList<ChildNode> nodes;
    public void execute(){
        for ( ChildNode node : nodes) {
            if (node.activate()) {
                node.execute();
                break;
            }
        }
    }
}

公共抽象类ParentNode扩展了ChildNode{
公共阵列列表节点；
public void execute（）{
用于（子节点：节点）{
if（node.activate（））{
node.execute（）；
打破
}
}
}
}

然后我会运行这个

ArrayList<ParentNode> masterNodeArray = null;
//add and create a bunch of nodes implementing different activate methods for both Child/Parent Nodes, and execute methods for child nodes
for (ParentNode node : masterNodeArray) {
        if (node.activate()) {
            node.execute();
            break;
        }
}

ArrayList masterNodeArray=null；
//添加并创建一组节点，为子节点/父节点实现不同的激活方法，并为子节点执行方法
用于（父节点：masterNodeArray）{
if（node.activate（））{
node.execute（）；
打破
}
}

---

我的问题是，我希望父节点和子节点能够成为

ParentNode

->

节点

数组的一部分。因此，当它在

ParentNode

中的execute函数中循环通过

节点

数组时，它将处理数组中的父节点和子节点。因此，如果它到达一个ParentNode，它将作为ParentNode处理，运行预定义的execute函数，并且知道如果它被执行，它还有一个

nodes

成员要循环，如果它到达一个ChildNode，它将运行定义的execute/activate方法

如果你正在制作一个机器人，它就是这个样子。。像这样做

public interface Action {
    boolean active()
    boolean execute();
}

public abstract class Controller implements Action {
    public List<Action> nodes;
    public void execute(){
        for (Action node : nodes) {
            if (node.activate()) {
                node.execute();
                break;
            }
        }
    }
}


public class Operator {
    public List<Controller> nodes;
    public void execute(){
        for (Controller node : nodes) {
            if (node.activate()) {
                node.execute();
                break;
            }
        }
    }
}

公共接口操作{
布尔活动（）
布尔执行（）；
}
公共抽象类控制器实现操作{
公共列表节点；
public void execute（）{
用于（操作节点：节点）{
if（node.activate（））{
node.execute（）；
打破
}
}
}
}
公共类运算符{
公共列表节点；
public void execute（）{
用于（控制器节点：节点）{
if（node.activate（））{
node.execute（）；
打破
}
}
}
}

您的问题是

中断了
循环，以执行
子节点列表中的所有
子节点

public abstract class ChildNode {
    private boolean activated = true;

    public final boolean isActivated() {
        return activated;
    }

    public final void setActivated(boolean activated) {
        this.activated = activated;
    }

    public abstract void execute();
}

public class ParentNode extends ChildNode {
    private List<ChildNode> children = new ArrayList<>();

    @Override public final void execute() {
        for (ChildNode node : children) {
            if (node.isActivated()) {
                node.execute();
                // DON'T BREAK HERE
            }
        }
    }

    public final List<ChildNode> getChildren() {
        return children;
    }
}

public class ConcreteChildNode extends ChildNode {

    private final String name;

    public ConcreteChildNode(String name) {
        this.name = name;
    }

    @Override public void execute() {
        System.out.println("ConcreteChildNode-" + name);
    }
}

public class Test {
    public static void main(String[] args) throws IOException {

        ParentNode parent1 = new ParentNode();
        parent1.getChildren().add(new ConcreteChildNode("1"));
        parent1.getChildren().add(new ConcreteChildNode("2"));

        ParentNode parent2 = new ParentNode();
        parent2.getChildren().add(new ConcreteChildNode("3-1"));
        parent2.getChildren().add(new ConcreteChildNode("3-2"));

        parent1.getChildren().add(parent2);

        parent1.getChildren().add(new ConcreteChildNode("4"));

        parent1.execute();

        // prints
        // ConcreteChildNode-1
        // ConcreteChildNode-2
        // ConcreteChildNode-3-1
        // ConcreteChildNode-3-2
        // ConcreteChildNode-4
    }
}

公共抽象类ChildNode{
私有布尔激活=真；
公共最终布尔值已激活（）{
返回激活；
}
公共最终作废集激活（布尔激活）{
这个.激活的=激活的；
}
公共抽象void execute（）；
}
公共类ParentNode扩展了ChildNode{
private List children=new ArrayList（）；
@重写公共最终作废执行（）{
用于（子节点：子节点）{
if（node.isActivated（））{
node.execute（）；
//不要在这里破门而入
}
}
}
公共最终列表getChildren（）{
返回儿童；
}
}
公共类ConcreteChildNode扩展了ChildNode{
私有最终字符串名；
公共子节点（字符串名称）{
this.name=名称；
}
@重写公共void execute（）{
System.out.println（“ConcreteChildNode-”+名称）；
}
}
公开课考试{
公共静态void main（字符串[]args）引发IOException{
ParentNode parent1=新的ParentNode（）；
parent1.getChildren（）.add（新的ConcreteChildNode（“1”））；
parent1.getChildren（）.add（新的ConcreteChildNode（“2”））；
ParentNode parent2=新的ParentNode（）；
parent2.getChildren（）.add（新的ConcreteChildNode（“3-1”））；
parent2.getChildren（）.add（新的ConcreteChildNode（“3-2”））；
parent1.getChildren（）.add（parent2）；
parent1.getChildren（）.add（新的ConcreteChildNode（“4”））；
parent1.execute（）；
//印刷品
//子节点-1
//子节点-2
//第3-1节
//第3-2节
//子节点-4
}
}
问题是？通常孩子们parents@jacksons5j这仍然不是一个问题。@jacksons5j您的代码应该按照您在最后一段中所解释的那样运行，是什么让您认为它不是？另外，我会在
ParentNode
中设置
execute（）
final
，这样一个具体的
ParentNode
就不会覆盖它，并阻止它在其所有
ChildNode
上运行all
execute
。@boobalangnanasekaran谢谢，不过我刚刚发现他的问题与继承无关。他在循环中执行父节点的子节点。