Question

最近我一直在阅读很多关于使用static的帖子。我读了很多关于static被滥用的内容。我想确定我在这个Manager类中正确使用它：

public class SignManager
{
    private static HashMap<String, List<GameSign>> signsBySection   = new HashMap<>();
    private static HashMap<String, List<GameServer>> serversBySection = new HashMap<>();
    private static HashMap<String, GameServer>serverNames = new HashMap<>();
    private static HashMap<Sign, GameSign> gameSignBySign = new HashMap<>();
    private static List<GameServer> availableServers = new ArrayList<>();
    private static List<GameServer> displayedServers = new ArrayList<>();

    public static void addSign(String section, Sign sign)
    {
        List<GameSign> signs = signsBySection.get(section);

        if(signs == null)
            signsBySection.put(section, signs = new ArrayList<>());

        GameSign gameSign = new GameSign(section, sign.getLocation());

        signs.add(gameSign);
        gameSignBySign.put(sign, gameSign);
    }

    public static void addServers(String section, List<String> range)
    {
        List<GameServer> servers = SignManager.serversBySection.get(section);

        if(servers == null)
            SignManager.serversBySection.put(section, servers = new ArrayList<>());

        for(String s : range)
        {
            GameServer server = new GameServer(s);

            servers.add(server);
            serverNames.put(s, server);
        }
    }

    public static void setAvailable(GameServer server)
    {
        availableServers.add(server);
    }

    public static void replaceDisplayed(GameServer old, GameServer newServer)
    {
        removeDisplayed(old);
        displayedServers.add(newServer);
    }

    public static void removeDisplayed(GameServer server)
    {
        displayedServers.remove(server);

        if(server != null)
            server.setSign(null);
    }

    public static boolean isDisplayed(GameServer server)
    {
        return displayedServers.contains(server);
    }

    public static boolean isAvailable(GameServer server)
    {
        return availableServers.contains(server);
    }

    public static void tick()
    {
        for(GameSign sign : getAllGameSigns())
            sign.tick();

        GameSign.addDot();
    }

    public static GameServer getGameServer(String name)
    {
        return serverNames.get(name);
    }

    public static GameServer getNextAvailableServer()
    {
        if(availableServers.size() == 0)
            return null;

        GameServer server = availableServers.get(0);
        availableServers.remove(0);
        return server;
    }

    public static GameSign getGameSign(Sign sign)
    {
        return gameSignBySign.get(sign);
    }

    public static Set<Map.Entry<String, List<GameSign>>> getSignsBySection()
    {
        return signsBySection.entrySet();
    }

    public static Collection<GameServer> getAllServers()
    {
        return serverNames.values();
    }

    public static Collection<GameSign> getAllGameSigns()
    {
        return gameSignBySign.values();
    }
}

我还读到如果班级有州，那就不应该是static。那么使用static地图是否表示该类具有状态，我是否正确使用static？

提前致谢。

Answer 1

从表面上看，我会说你不正确使用静态。该类维护受addServers和addSign方法影响的状态。状态是静态维护的，这意味着如果您有两个不同的SignManager对象实例，则两者将共享相同的状态。这可能是你想要的 - 它可能不是。

如果是你想要的东西，那么使用Singleton模式提供了一种更常用的方法来实现这一点。如果它不是你想要的，那么你应该考虑将静态变量更改为实例变量（并对方法签名进行相应的更改）

Answer 2

如果您按上述方式制作了所有内容static，它将使您的代码更加紧密耦合。您可以从此类中删除所有static个关键字，并在其他组件中使用它的实例，您的代码仍然是正确的。

现在，如果你想对你的类进行不同的实现（或者出于某种原因有多个实例），你不必改变那么多，只需将类的新实现注入组件中使用它。

为不使用static调用的类编写单元测试也更容易。

这篇文章可能有助于更好地阐明为什么最好避免它们...... http://www.devtrends.co.uk/blog/how-not-to-do-dependency-injection-the-static-or-singleton-container

我正确使用静电吗？

2 个答案: