Question

为什么我不能使用引用输入到第一个构造函数的switch case语句来创建第二个构造函数？它显示错误“构造函数调用必须是使用此构造函数的构造函数中的第一个语句”。因此，似乎我必须为第二个中的每个case语句重新键入第一个构造函数的赋值。

public class Card {
        public static final String CLUBS = "Clubs";
        public static final String DIAMONDS = "Diamonds";
        public static final String HEARTS = "Hearts";
        public static final String SPADES = "Spades";
        public static final int ACE = 1;
        public static final int JACK = 11;
        public static final int QUEEN = 12;
        public static final int KING = 13;

        public Card(int rank, String suit) {
            this.rank = rank;
            this.suit = suit;
        }

        public Card(String rank, String suit) {
            if (!isCorrectSuit(suit)) throw new IllegalArgumentException("incorrect suit");
            switch(rank) {
            case ACE: this(1, suit);
            case JACK: this(11, suit);
            case QUEEN: this(12, suit);
            case KING : this(13, suit);
            default: throw new IllegalArgumentException("incorrect rank");
            }
        }



        private boolean isCorrectSuit(String suit) {
            return (suit.equals(CLUBS) || suit.equals(DIAMONDS) || suit.equals(HEARTS) || suit.equals(SPADES));
        }

        private boolean isCorrectRank(int rank) {
            return rank == 1 || rank == 11 || rank == 12 || rank == 13;
        }

        private int rank;
        private String suit;    

    }

Answer 1

您可能正在寻找一种静态工厂方法，其中this(...)可以替换为new Card(...)：

class Card {
    ...

    private Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public static Card of(String rank, String suit) {
        if (!isCorrectSuit(suit)) {
            throw new IllegalArgumentException("incorrect suit");
        }

        final Card card;
        switch (Integer.valueOf(rank)) {
            case ACE:
                card = new Card(1, suit);
                break;
            case JACK:
                card = new Card(11, suit);
                break;
            case QUEEN:
                card = new Card(12, suit);
                break;
            case KING:
                card = new Card(13, suit);
                break;
            default: {
                throw new IllegalArgumentException("incorrect rank");
            }
        }
        return card;
    }
}

这四个实例可以预定义，您无需再次创建它们。

我想知道为什么你没有对rank值采用相同的方法：

public Card(int rank, String suit) {
    if (!isCorrectSuit(suit)) {
        throw new IllegalArgumentException("incorrect suit");
    }

    if (!isCorrectRank(rank)) {
        throw new IllegalArgumentException("incorrect rank");
    }

    this.rank = rank;
    this.suit = suit;
}

public Card(String rank, String suit) {
    this(Integer.valueOf(rank), suit);
}

请注意，您有2个公共构造函数，其中只有一个具有一种验证。我可以创建new Card(2, "Unknown")并且不会有例外。

其他考虑的选择可能是：

编写枚举而不是原始值
编写一组值，用isCorrectX

Set#contains

Answer 2

如果你想在类中调用另一个构造函数，你可以通过this(args)关键字用足够的参数调用它。

目前还不完全清楚你要使用哪种构造函数，但我认为这更有可能：

  public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public static Card create(String rank, String suit) {

        if (!isCorrectSuit(suit)) throw new IllegalArgumentException("incorrect suit");
        switch(rank) {
        case ACE: new Card(1, suit); break;
        case JACK: new Card(11, suit); break;
        case QUEEN: new Card(12, suit); break;
        case KING : new Card(13, suit); break;
        default: throw new IllegalArgumentException("incorrect rank");
        }
    }

你有一个静态方法，可以让你创建一个Card类型的对象。

Answer 3

只需添加一个将String转换为int

的静态例程

构造函数调用必须是使用此

3 个答案: