Java 构造函数与类'；什么是主要方法？

并且不理解代码中不同断言部分背后的原因

为什么rankToString assert方法在类的主方法中，而isvaliding方法在类的构造函数中

public class Card {
private final int rank;
private final int suit;

// Kinds of suits
public final static int DIAMONDS = 1;
public final static int CLUBS    = 2;
public final static int HEARTS   = 3;
public final static int SPADES   = 4;

// Kinds of ranks
public final static int ACE   = 1;
public final static int DEUCE = 2;
public final static int THREE = 3;
public final static int FOUR  = 4;
public final static int FIVE  = 5;
public final static int SIX   = 6;
public final static int SEVEN = 7;
public final static int EIGHT = 8;
public final static int NINE  = 9;
public final static int TEN   = 10;
public final static int JACK  = 11;
public final static int QUEEN = 12;
public final static int KING  = 13;

public Card(int rank, int suit) {
    assert isValidRank(rank);
    assert isValidSuit(suit);
    this.rank = rank;
    this.suit = suit;
}

public int getSuit() {
    return suit;
}

public int getRank() {
    return rank;
}

public static boolean isValidRank(int rank) {
    return ACE <= rank && rank <= KING;
}

public static boolean isValidSuit(int suit) {
    return DIAMONDS <= suit && suit <= SPADES;
}

public static String rankToString(int rank) {
    switch (rank) {
    case ACE:
        return "Ace";
    case DEUCE:
        return "Deuce";
    case THREE:
        return "Three";
    case FOUR:
        return "Four";
    case FIVE:
        return "Five";
    case SIX:
        return "Six";
    case SEVEN:
        return "Seven";
    case EIGHT:
        return "Eight";
    case NINE:
        return "Nine";
    case TEN:
        return "Ten";
    case JACK:
        return "Jack";
    case QUEEN:
        return "Queen";
    case KING:
        return "King";
    default:
        //Handle an illegal argument.  There are generally two
        //ways to handle invalid arguments, throwing an exception
        //(see the section on Handling Exceptions) or return null
        return null;
    }    
}

public static String suitToString(int suit) {
    switch (suit) {
    case DIAMONDS:
        return "Diamonds";
    case CLUBS:
        return "Clubs";
    case HEARTS:
        return "Hearts";
    case SPADES:
        return "Spades";
    default:
        return null;
    }    
}

public static void main(String[] args) {

    // must run program with -ea flag (java -ea ..) to
    // use assert statements
    assert rankToString(ACE) == "Ace";
    assert rankToString(DEUCE) == "Deuce";
    assert rankToString(THREE) == "Three";
    assert rankToString(FOUR) == "Four";
    assert rankToString(FIVE) == "Five";
    assert rankToString(SIX) == "Six";
    assert rankToString(SEVEN) == "Seven";
    assert rankToString(EIGHT) == "Eight";
    assert rankToString(NINE) == "Nine";
    assert rankToString(TEN) == "Ten";
    assert rankToString(JACK) == "Jack";
    assert rankToString(QUEEN) == "Queen";
    assert rankToString(KING) == "King";

    assert suitToString(DIAMONDS) == "Diamonds";
    assert suitToString(CLUBS) == "Clubs";
    assert suitToString(HEARTS) == "Hearts";
    assert suitToString(SPADES) == "Spades";

    }
}

公共类卡{
私人最终整数等级；
私人最终诉讼；
//西服种类
公共最终静态整数钻石=1；
公共最终静态积分俱乐部=2；
公共最终静态int=3；
公共最终静态整数黑桃=4；
//各种级别
公共最终静态int ACE=1；
公共最终静态整数倍=2；
公共最终静态int 3=3；
公共最终静态int 4=4；
公共最终静态int 5=5；
公共最终静态int 6=6；
公共最终静态int 7=7；
公共最终静态整数8=8；
公共最终静态int 9=9；
公共最终静态int 10=10；
公共最终静态int插孔=11；
公共最终静态整数=12；
公共最终静态int KING=13；
公共卡（国际等级，国际套装）{
断言有效性（等级）；
主张有效诉讼（诉讼）；
这个.等级=等级；
这套衣服；
}
公共int getSuit（）{
反诉；
}
public int getRank（）{
返回等级；
}
公共静态布尔值（整数秩）{
return ACE
assert
是一个java关键字，用于测试某些条件（并强制执行其有效性）。此处使用的格式是
assert
您将看到，在这两种情况下，
assert
后面的表达式的计算结果都是
boolean

您可以在中阅读更多信息。
方法中的
assert
s测试关于静态最终字段的断言，构造函数中的
assert
s测试关于非静态最终字段的断言。因为关于静态字段的断言不应该在每次创建对象时都进行测试，而非静态字段需要例如，将断言放在那里是有意义的

但是，我建议编写jUnit测试，而不是使用
assert
s


你会找到一份工作的

jUnit的一些好处：

您不必将测试与代码混合使用，这会使代码更具可读性
您可以在不改变代码行为的情况下测试函数调用序列等（例如，如果不在代码中添加try-catch块，则很难测试断言中是否抛出异常）
大多数IDE都为jUnit提供了一个很好的用户界面
检查断言时，您可以更好地进行控制。例如，您可以创建2张
卡
s，而无需在构造函数中检查断言两次
我还没有了解jUnit测试。使用断言有什么错？它会导致性能问题吗？断言是一种类似C的东西，除了涉足Java的C程序员之外，没有人真正使用它。它们是用于测试的，不应该留在生产代码中。jUnit的好处在于它将测试代码与m生产代码。你可能不会在学校里学习JUnit，因为学校不会教像那样的实用东西。但你绝对应该自学它。这段代码的另一个线索是由一个涉猎Java的C程序员编写的：他们在使用枚举时使用int。他们正在使用e equality operator.Sheesh！他们在这里侥幸逃脱，因为他们在比较字符串文字，但这没有解释，很容易让您误入歧途。返回null表示错误是非常糟糕的做法。这一定是Sun和Oracle从未更新过的古老教程。