Question

我正在为学校的进步设计一个基于文本的冒险游戏。我将每个“级别”设置为一个类，并将每个可探索区域（节点）设置为相应类中的方法。

让我感到困惑的是从一个节点移动到另一个节点的代码。因为每个节点最多连接四个其他节点，所以我必须在每种方法中重复一个非常相似的代码块。

我更喜欢在每个节点的开头包含一系列方法，如下所示：

public static void zero()
{
    ... adjacentNodes[] = {one(), two(), three(), four()};
}

然后将该数组发送到泛型方法，让它将播放器发送到正确的节点：

public static void move(...[] adjacentNodes, int index)
{
    adjacentNodes[index];
}

我简化了我的代码，但这是一般的想法。这可能吗？

Answer 1

无论何时考虑指向函数的指针，都可以使用适配器模式（或变体）转换为Java。它会是这样的：

public class Node {
    ...
    public void goNorth() { ... }
    public void goSouth() { ... }
    public void goEast() { ... }
    public void goWest() { ... }

    interface MoveAction {
        void move();
    }

    private MoveAction[] moveActions = new MoveAction[] {
        new MoveAction() { public void move() { goNorth(); } },
        new MoveAction() { public void move() { goSouth(); } },
        new MoveAction() { public void move() { goEast(); } },
        new MoveAction() { public void move() { goWest(); } },
    };

    public void move(int index) {
        moveActions[index].move();
    }
}

Answer 2

让你的节点成为所有符合相同界面的对象，然后你就能够可靠地调用他们的方法。

Answer 3

由于Java没有将方法的概念作为第一类实体，因此只能使用反射，这很痛苦，容易出错。

最佳近似可能是将级别设置为枚举，并按方法实现每个实例：

public enum Level1 implements Explorable{
    ROOM1 {
        public void explore() {
            // fight monster
        }
    }, ROOM2 {
        public void explore() {
            // solve riddle
        }
    }, ROOM3 {
        public void explore() {
            // rescue maiden
        }
    };

}

public interface Explorable{
    public abstract void explore();    
}

public static void move(Explorable[] adjacentNodes, int index)
{
    adjacentNodes[index].explore();
}

但是，这有点滥用枚举概念。我不会将它用于一个严肃的项目。

Answer 4

您的设计存在根本缺陷。正常的OO设计会使每个“级别”成为一个对象（类'级别'或类似的东西）。每个'可探索区域'也将是一个对象，包含在关卡对象中 - 可能是ExplorableArea类。 “可探索区域”可以是不同类型，在这种情况下，您可以使它们成为ExplorableArea的不同子类。

Answer 5

尝试思考没有反思的解决方案。例如，它可以是enums。

Answer 6

我用一种可能的方法来晚了，现在你可以用 java.util.function (link) 来解决这类问题。

从字面上回答问题，无论其正确性或适用性如何，这里有一个可能的版本：

public static void zero()
{
    Function<World, World> one = (World start) -> RoomWithMonster.in(start);
    Function<World, World> two = (World start) -> EmptyRoom.in(start);
    Function<World, World> three = (World start) -> RoomWithMonster.in(start);
    Function<World, World> four = (World start) -> Treasure.in(start);

    List<Function<World, World>> adjacentNodes = List.of(one, two, three, four);
    return adjacentNodes;
}


public static void move(List<Function<World, World>> possibleNodes, int index)
{
    World beginning = World.start();
    World end = possibleNodes.get(index).apply(beginning);
}

这种方法更喜欢不变性并添加一个小 World 类来抽象出游戏的状态，但仍然保留您想要的问题。

注意：幸运的是现在反射评论已经过时了！

Answer 7

您可以使用Reflection类创建方法数组。 http://java.sun.com/developer/technicalArticles/ALT/Reflection/

Java - 创建方法数组

7 个答案: