如何删除静态变量但仍允许全局调用变量？

Question

我正在使用 LibGDX 与 Scene2D 和 Tiled 来创建一个 2d 游戏。我有一个 class 读取对象层并将它们加载到游戏中（我仍在决定是否将其制作成单例）。问题是在 class 中，所有内容都会更新，因为我喜欢将我的更新和渲染分成两个 class，我有一个 public static Stage stage 并且我想让它不是静态的.

thaat 的问题是我有一个 Mob class，其中包括玩家和怪物，我需要舞台 class 才能获得所有游戏中的对象并检查碰撞。

在我的 Mob class 中，我没有 think/want 将 Stage 作为参数添加到构造函数中，因为它是一个抽象 class，我必须为播放器 class 每次被调用。

如果需要任何其他信息，因为我知道你们不是巫师，我会尽快提供。我在这里使用三个 classes，TiledMapHelper class、WorldController class 和 Mob class。

下面是 class，它将我在 Tiled 上创建的关卡转换为我的游戏的可编码对象。静态 ArrayLists 将更改为一个组 class，该组将在阶段 class 中实现。舞台 Class 包含我游戏中的所有对象。

public class TiledMapHelper {
    public static final int TILE_WIDTH = 512;
    public static final int MAP_WIDTH = 39 * TILE_WIDTH;
    public static final int MAP_HEIGHT = 45 * TILE_WIDTH;`

    public static ArrayList<Platform> platforms;
    public static ArrayList<Wall> walls;
    public static ArrayList<Door> doors;
    public static ArrayList<Stair> stairs;
    public static ArrayList<Ladder> ladders;

    private TiledMap tiledMap;

    public TiledMapHelper(TiledMap tiledMap) {
        this.tiledMap = tiledMap;

        initWalls();
        initGates();
        initPlatforms();
    }

    public void initWalls() {
        walls = new ArrayList<Wall>();
        MapObjects layerObjects = tiledMap.getLayers().get("walls").getObjects();
        for (MapObject mapObject : layerObjects) {
            if (mapObject instanceof RectangleMapObject) {
                Rectangle rect = ((RectangleMapObject) mapObject).getRectangle();
                Wall wall = new Wall(rect.x, rect.y, rect.width, rect.height);
                walls.add(wall);
            }
        }
    }

    public void initGates() {
        doors = new ArrayList<Door>();
        stairs = new ArrayList<Stair>();
        ladders = new ArrayList<Ladder>();
        MapObjects layerObjects = tiledMap.getLayers().get("gates").getObjects();
        for (MapObject mapObject : layerObjects) {
            if (mapObject instanceof TiledMapTileMapObject) {
                if (mapObject.getName() == null)
                    continue;
                if (mapObject.getName().equals("Door")) {
                    int checkDoorType = Integer.parseInt((String) mapObject.getProperties().get("doorType"));
                    if (checkDoorType == 1) {
                        Door door = new Door(((TiledMapTileMapObject) mapObject).getX(),
                                ((TiledMapTileMapObject) mapObject).getY(), "door1C");
                        doors.add(door);
                    }
                    if (checkDoorType == 2) {
                        Door door = new Door(((TiledMapTileMapObject) mapObject).getX(),
                                ((TiledMapTileMapObject) mapObject).getY(), "door2C");
                        doors.add(door);
                    }
                }
            }
            if (mapObject instanceof RectangleMapObject) {
                Rectangle rect = ((RectangleMapObject) mapObject).getRectangle();
                if (mapObject.getName().equals("Stair")) {
                    String checkStairType = (String) mapObject.getProperties().get("isStair");
                    if (checkStairType.equals("upRight")) {
                        Stair stair = new Stair(rect.x, rect.y, rect.width, rect.height, "upRight");
                        stairs.add(stair);
                    }
                    if (checkStairType.equals("upLeft")) {
                        Stair stair = new Stair(rect.x, rect.y, rect.width, rect.height, "upLeft");
                        stairs.add(stair);
                    }
                    if (checkStairType.equals("downRight")) {
                        Stair stair = new Stair(rect.x, rect.y, rect.width, rect.height, "downRight");
                        stairs.add(stair);
                    }
                    if (checkStairType.equals("downLeft")) {
                        Stair stair = new Stair(rect.x, rect.y, rect.width, rect.height, "downLeft");
                        stairs.add(stair);
                    }
                }
                if (mapObject.getName().equals("Ladder")) {
                    String checkLadderType = (String) mapObject.getProperties().get("isLadder");
                    if (checkLadderType.equals("up")) {
                        Ladder ladder = new Ladder(rect.x, rect.y, rect.width, rect.height, "up");
                        ladders.add(ladder);
                    }
                    if (checkLadderType.equals("down")) {
                        Ladder ladder = new Ladder(rect.x, rect.y, rect.width, rect.height, "down");
                        ladders.add(ladder);
                    }
                }
            }
        }
    }

    public void initPlatforms() {
        platforms = new ArrayList<Platform>();
        MapObjects layerObjects = tiledMap.getLayers().get("platforms").getObjects();
        for (MapObject mapObject : layerObjects) {
            if (mapObject instanceof TiledMapTileMapObject) {
                if (mapObject != null) {
                    String checkPlatformType = (String) ((TiledMapTileMapObject) mapObject).getTile().getProperties().get("platformType");
                    if (checkPlatformType.equals("left")) {
                        Platform platform = new Platform(((TiledMapTileMapObject) mapObject).getX(),
                                ((TiledMapTileMapObject) mapObject).getY(), "left");
                        platforms.add(platform);
                    }
                    if (checkPlatformType.equals("middle")) {
                        Platform platform = new Platform(((TiledMapTileMapObject) mapObject).getX(),
                                ((TiledMapTileMapObject) mapObject).getY(), "middle");
                        platforms.add(platform);
                    }
                    if (checkPlatformType.equals("right")) {
                        Platform platform = new Platform(((TiledMapTileMapObject) mapObject).getX(),
                                ((TiledMapTileMapObject) mapObject).getY(), "right");
                        platforms.add(platform);
                    }
                }
            }
        }
    }
}

Answer 1

为它所在的 class 创建一个构造函数，并使用访问器方法来引用它

Answer 2

一个 Singleton 对象似乎可以解决您的问题，因为您可以将实例变量包装在静态方法调用之后。不过，我不确定您要解决什么问题。你能post你的代码吗？

编辑：单例 Stage 的基本结构如下所示：

public class Stage{

    //Stage's fields

    //keep the constructor private
    private Stage(){

    }

    //Stage's methods

    private static class StageHolder { 
       //private field of the one Stage object
       private static final Stage INSTANCE = new Singleton();
    }

    //public static message to access the one Stage
    public static Stage getInstance() {
       return StageHolder.INSTANCE;
    }
}

想法是将 Stage 的实例隐藏为私有静态字段，并在需要访问 Stage.

时使用 getInstance() 方法

Answer 3

Denfeet，我希望我说您已经知道一些解决问题的方法并且您正在寻求关于最佳方法的建议时没有冒昧。如果是这样的话，这个答案可能 "general tips" 比通常有用的多一些，但我只能全心全意地为您的项目推荐一个单例 main game class .是的，如果你尝试过，你可以避免它。问题是——它值得你花时间吗（尤其是当你想学习图书馆的时候）？一个静态的主游戏 class 会让你摆脱很多你在创建项目和学习时仍然会遇到的麻烦 libgdx - 而且你不会花很长时间来重写所有东西（我想我是说 - 从我的错误中吸取教训，节省我用艰难的方式解决这个问题的时间:-))。
年轻玩家唯一的大陷阱是 Android 处理静态实例的方式 - 在 Resume 上重新创建它们以避免它。编码愉快。

Answer 4

是否每个生物都有自己的特定阶段？

我认为舞台有一个createMob方法是可以的，它将获取配置生物并创建生物。您可以使 mob 构造函数具有 stage 参数，但无需在每次要创建 class.

时都传递 stage

例如：

abstract class Stage {
    public Mob createMob(MobConfiguration config) {
        ... // your mob creation method
        if (config.type == MobConfiguration.TYPE_PLAYER) {
            return new Player(this, config);
        }
    }
}
class Player extends Mob {
    public Player(Stage stage, MobConfiguration config) {
        // some initialization method
    }
}

或者您可以将 createMob 方法应用到拥有舞台的其他 class。

如何删除静态变量但仍允许全局调用变量？

How to remove static variable but allow a variable to still be globally called?

java

static

libgdx

scene2d

tiled