Java 当直接从对象调用而不是作为参数传入时，表达式将产生默认情况

我一辈子都搞不懂为什么这个switch语句会这样，而且似乎找不到答案

我有一个带有两个静态创建方法的Games类：

public final class Games {
public static final int THIRTEEN = 1;
public static final int HEARTS = 2;

public static CardGame create(final int gameId, final GameConnection connection, 
                              final GameSettings settings, List<Card> cards) {
    switch(gameId) {
        case THIRTEEN:
            return new ThirteenCardGame(connection, (ThirteenGameSettings) settings, cards);
        case HEARTS:
            return new HeartsCardGame(connection, (HeartsGameSettings) settings, cards);
        default:
            return null;
    }
}

public static CardGame create(final Deal deal, final GameConnection connection, 
                              final GameSettings settings) {
    switch(deal.getGameId()) {
        case THIRTEEN:
            ThirteenDeal thirteenDeal = (ThirteenDeal)deal;
            return new ThirteenCardGame(connection, (ThirteenGameSettings) settings, thirteenDeal.getCards());
        case HEARTS:
            return new HeartsCardGame(connection, (HeartsGameSettings) settings, deal.getCards());
        default:
            return null;
    }
}
}

我得到与第二种方法相同的结果（默认情况）。有人能告诉我发生了什么事吗

我还应该指出，在调用之前，使用Libgdx序列化程序对Deal对象进行序列化，如下所示：

mJson = json.toJson(object);

并以相同的方式反序列化：

Json json = new Json();
return json.fromJson(Deal.class, serializedObjectString);

---

虽然我已经检查并验证了

Deal的值，但是getGameId（）

是序列化之前的值，它是

1

ThirteenDeal.getGameId（）

和

HeartsDeal.getGameId（）

分别没有返回1和2

该代码没有任何其他问题wrt开关情况。开关箱功能工作正常

编辑： 代码

import java.util.List;

public final class Games {
    public static final int THIRTEEN = 1;
    public static final int HEARTS = 2;
    public static void main(String[] args) {
        create(1, null, null, null);
        create(2, null, null, null);
        create(new ThirteenDeal(), null, null);
        create(new HeartsDeal(), null, null);
        create(-1, null, null, null);
        create(new Deal(), null, null);
    }
    public static CardGame create(final int gameId,
            final GameConnection connection, final GameSettings settings,
            List<Card> cards) {
        switch (gameId) {
        case THIRTEEN:
            System.out.println("Method Type 1, GameId=[" + gameId + "] - THIRTEEN");
            return new ThirteenCardGame(connection,
                    (ThirteenGameSettings) settings, cards);
        case HEARTS:
            System.out.println("Method Type 1, GameId=[" + gameId + "] - HEARTS");
            return new HeartsCardGame(connection,
                    (HeartsGameSettings) settings, cards);
        default:
            System.out.println("Method Type 1, GameId=[" + gameId + "] - (DEFAULT)");
            return null;
        }
    }

    public static CardGame create(final Deal deal,
            final GameConnection connection, final GameSettings settings) {
        switch (deal.getGameId()) {
        case THIRTEEN:
            System.out.println("Method Type 2, GameId=[" + deal.getGameId() + "] - THIRTEEN");
            ThirteenDeal thirteenDeal = (ThirteenDeal) deal;
            return new ThirteenCardGame(connection,
                    (ThirteenGameSettings) settings, thirteenDeal.getCards());
        case HEARTS:
            System.out.println("Method Type 2, GameId=[" + deal.getGameId() + "] - HEARTS");
            return new HeartsCardGame(connection,
                    (HeartsGameSettings) settings, deal.getCards());
        default:
            System.out.println("Method Type 2, GameId=[" + deal.getGameId() + "] - (DEFAULT)");
            return null;
        }
    }
    /*
     * Deal Objects. Deal returns -1, ThirteenDeal returns 1 and HeartsDeal returns 2 
     */
    private static class Deal {
        public int getGameId() {
            return -1;
        }
        public Object getCards() {
            return null;
        }
    }
    private static class ThirteenDeal extends Deal {
        public List<Card> getCards() {
            return null;
        }
        public int getGameId() {
            return 1;
        }
    }
    private static class HeartsDeal extends Deal {
        public List<Card> getCards() {
            return null;
        }
        public int getGameId() {
            return 2;
        }
    }
    /*
     * Dummy stubs for the sake of compilation
     */
    private static class CardGame {
    }
    private static class Card {
    }
    private static class GameConnection {
    }
    private static class ThirteenGameSettings extends GameSettings {
    }
    private static class HeartsGameSettings extends GameSettings {
    }
    private static class ThirteenCardGame extends CardGame {
        public ThirteenCardGame(GameConnection connection,
                ThirteenGameSettings settings, List<Card> cards) {
        }
    }
    private static class HeartsCardGame extends CardGame {
        public HeartsCardGame(GameConnection connection,
                HeartsGameSettings settings, Object cards) {
        }
    }
    private static class GameSettings {
    }
}

如果Deal.getGameId（）的计算结果为1，则它无法转到

默认值

。正如其他人所建议的，请在switch子句之前打印该值。如果您怀疑该值可能在另一个线程中被更改，那么，在局部变量中获取

deal.getGameId（）

，并在switch类中使用该值

如果没有任何效果，请在第二种方法中修改下面的代码，

开关（deal.getGameId（））{

到

---

然后，检查输出。

显示getGameId（）方法和调用第二个版本的代码。如果有疑问，请打印出来。查看在switch语句之前实际返回的内容。

Deal.getGameId（）

只是一个简单的getter，它返回一个由同样简单的setter设置的成员变量集。我已经打印了它，每次它都返回

1

。有些事情并不像你想象的那样。在每种情况下，在switch语句之前打印你正在切换的值。但这是一个糟糕的对象模型。游戏应该创建交易，而不是e另一方面。诚然，我没有尝试过

HeartsDeal.getGameId（）

案例，但它应该与

ThirteenDeal.getGameId（）

案例没有任何关系。好的，我将用代码更新，我的意思是。您可以检查构造和输出以查看问题。

import java.util.List;

public final class Games {
    public static final int THIRTEEN = 1;
    public static final int HEARTS = 2;
    public static void main(String[] args) {
        create(1, null, null, null);
        create(2, null, null, null);
        create(new ThirteenDeal(), null, null);
        create(new HeartsDeal(), null, null);
        create(-1, null, null, null);
        create(new Deal(), null, null);
    }
    public static CardGame create(final int gameId,
            final GameConnection connection, final GameSettings settings,
            List<Card> cards) {
        switch (gameId) {
        case THIRTEEN:
            System.out.println("Method Type 1, GameId=[" + gameId + "] - THIRTEEN");
            return new ThirteenCardGame(connection,
                    (ThirteenGameSettings) settings, cards);
        case HEARTS:
            System.out.println("Method Type 1, GameId=[" + gameId + "] - HEARTS");
            return new HeartsCardGame(connection,
                    (HeartsGameSettings) settings, cards);
        default:
            System.out.println("Method Type 1, GameId=[" + gameId + "] - (DEFAULT)");
            return null;
        }
    }

    public static CardGame create(final Deal deal,
            final GameConnection connection, final GameSettings settings) {
        switch (deal.getGameId()) {
        case THIRTEEN:
            System.out.println("Method Type 2, GameId=[" + deal.getGameId() + "] - THIRTEEN");
            ThirteenDeal thirteenDeal = (ThirteenDeal) deal;
            return new ThirteenCardGame(connection,
                    (ThirteenGameSettings) settings, thirteenDeal.getCards());
        case HEARTS:
            System.out.println("Method Type 2, GameId=[" + deal.getGameId() + "] - HEARTS");
            return new HeartsCardGame(connection,
                    (HeartsGameSettings) settings, deal.getCards());
        default:
            System.out.println("Method Type 2, GameId=[" + deal.getGameId() + "] - (DEFAULT)");
            return null;
        }
    }
    /*
     * Deal Objects. Deal returns -1, ThirteenDeal returns 1 and HeartsDeal returns 2 
     */
    private static class Deal {
        public int getGameId() {
            return -1;
        }
        public Object getCards() {
            return null;
        }
    }
    private static class ThirteenDeal extends Deal {
        public List<Card> getCards() {
            return null;
        }
        public int getGameId() {
            return 1;
        }
    }
    private static class HeartsDeal extends Deal {
        public List<Card> getCards() {
            return null;
        }
        public int getGameId() {
            return 2;
        }
    }
    /*
     * Dummy stubs for the sake of compilation
     */
    private static class CardGame {
    }
    private static class Card {
    }
    private static class GameConnection {
    }
    private static class ThirteenGameSettings extends GameSettings {
    }
    private static class HeartsGameSettings extends GameSettings {
    }
    private static class ThirteenCardGame extends CardGame {
        public ThirteenCardGame(GameConnection connection,
                ThirteenGameSettings settings, List<Card> cards) {
        }
    }
    private static class HeartsCardGame extends CardGame {
        public HeartsCardGame(GameConnection connection,
                HeartsGameSettings settings, Object cards) {
        }
    }
    private static class GameSettings {
    }
}

Method Type 1, GameId=[1] - THIRTEEN
Method Type 1, GameId=[2] - HEARTS
Method Type 2, GameId=[1] - THIRTEEN
Method Type 2, GameId=[2] - HEARTS
Method Type 1, GameId=[-1] - (DEFAULT)
Method Type 2, GameId=[-1] - (DEFAULT)

int gameId = deal.getGameId();
System.out.println("deal.getGameId()=" + gameId);
switch(gameId) {