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

Posted 2021-03-30

我有一个抽象类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;
            }
        }
    }
}

然后我会跑这个

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;
        }
}

我的问题是，我希望父节点和子节点能够成为ParentNode - > nodes数组的一部分。因此，当它在nodes中的execute函数中循环遍历ParentNode数组时，它将处理数组中的父节点和子节点。因此，如果它到达ParentNode，它将作为ParentNode处理它，运行预定义的执行函数并知道它有一个nodes成员循环，如果它被执行，如果它到达ChildNode，它将运行定义的执行/激活方法。

答案

你的问题是你在break循环中executeing所有ChildNodes在ParentNodes儿童名单中

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
    }
}

另一答案

如果你正在制作一个机器人，它就像它看起来像..这样做

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;
            }
        }
    }
}