基本上，“断言为真”会通过，“断言为假”会失败。让我们看看这是如何工作的:

public static void main(String[] args)
{
    String s1 = "Hello";
    assert checkInteger(s1);
}

private static boolean checkInteger(String s)
{
    try {
        Integer.parseInt(s);
        return true;
    }
    catch(Exception e)
    {
        return false;
    }
}

除了这里提供的所有很棒的答案之外，官方Java SE 7编程指南还提供了关于使用assert的非常简洁的手册;通过几个准确的例子，说明了何时使用断言是一个好主意(重要的是，也是坏主意)，以及它与抛出异常有何不同。

Link

让我们假设您要编写一个控制核电站的程序。很明显，即使是最微小的错误也可能导致灾难性的结果，因此您的代码必须是无bug的(为了论证，假设JVM是无bug的)。

Java不是一种可验证的语言，这意味着:你不能计算出你的操作结果会是完美的。这样做的主要原因是指针:它们可以指向任何地方，也可以指向任何地方，因此它们不能被计算为这个确切的值，至少在合理的代码范围内不能。对于这个问题，没有办法证明您的代码在整体上是正确的。但你能做的是证明你至少能在bug发生时找到它。

此思想基于契约式设计(Design-by-Contract, DbC)范式:首先定义(具有数学精度)您的方法应该做什么，然后在实际执行期间通过测试来验证这一点。例子:

// Calculates the sum of a (int) + b (int) and returns the result (int).
int sum(int a, int b) {
  return a + b;
}

虽然这很明显可以正常工作，但大多数程序员不会看到其中隐藏的bug(提示:Ariane V因为类似的bug而崩溃)。现在DbC定义您必须始终检查函数的输入和输出，以验证它是否正确工作。Java可以通过断言来做到这一点:

// Calculates the sum of a (int) + b (int) and returns the result (int).
int sum(int a, int b) {
    assert (Integer.MAX_VALUE - a >= b) : "Value of " + a + " + " + b + " is too large to add.";
  final int result = a + b;
    assert (result - a == b) : "Sum of " + a + " + " + b + " returned wrong sum " + result;
  return result;
}

如果这个函数现在失败了，您会注意到它。你会知道你的代码中有问题，你知道它在哪里，你知道是什么引起的(类似于异常)。更重要的是:当它发生时停止正确执行，以防止任何进一步的代码使用错误的值，并可能对它所控制的任何东西造成损害。

Java异常是一个类似的概念，但它们不能验证所有内容。如果需要更多的检查(以降低执行速度为代价)，则需要使用断言。这样做会使代码膨胀，但最终可以在短得惊人的开发时间内交付产品(越早修复bug，成本就越低)。此外，如果代码中有任何错误，您将检测到它。不可能出现漏洞并在以后引起问题。

这仍然不能保证代码没有错误，但它比通常的程序更接近于这一点。

总结一下(不仅仅是Java，很多语言都是如此):

“assert”主要被软件开发人员在调试过程中用作调试辅助。断言消息永远不会出现。许多语言提供了一个编译时选项，该选项将导致所有“断言”被忽略，用于生成“生产”代码。

"exceptions" are a handy way to handle all kinds of error conditions, whether or not they represent logic errors, because, if you run into an error-condition such that you cannot continue, you can simply "throw them up into the air," from wherever you are, expecting someone else out there to be ready to "catch" them. Control is transferred in one step, straight from the code that threw the exception, straight to the catcher's mitt. (And the catcher can see the complete backtrace of calls that had taken place.)

此外，该子例程的调用者不必检查子例程是否成功:“如果我们现在在这里，它一定成功了，因为否则它会抛出异常，我们现在就不会在这里!”这种简单的策略使得代码设计和调试变得非常非常容易。

异常方便地允许致命错误条件保持原样:“规则的异常”。而且，对于它们来说，由代码路径来处理，这也是“规则的例外……“高飞球!”

断言是可以被关闭的检查。它们很少被使用。为什么?

它们不能用于检查公共方法参数，因为您无法控制它们。 它们不应该用于简单的检查，如result != null，因为这样的检查非常快，几乎没有什么可以保存。

那么，还剩下什么呢?昂贵的条件检查是真实的。像rb树这样的数据结构的不变量就是一个很好的例子。实际上，在JDK8的ConcurrentHashMap中，对于TreeNodes有一些这样有意义的断言。

您确实不希望在生产环境中启用它们，因为它们很容易控制运行时间。 您可能希望在测试期间打开或关闭它们。 在处理代码时一定要打开它们。

有时候，支票不是很贵，但与此同时，你很确定，它会通过。在我的代码中，有例如，

assert Sets.newHashSet(userIds).size() == userIds.size();

我很确定我刚刚创建的列表有独特的元素，但我想记录并再次检查它。

断言允许检测代码中的缺陷。您可以打开断言进行测试和调试，而在程序处于生产状态时关闭断言。

既然你知道它是真的，为什么还要坚持呢?只有当一切都正常工作时，这才是正确的。如果程序有一个缺陷，它实际上可能不是真的。在过程早期检测到这一点可以让您知道哪里出了问题。

assert语句包含此语句以及可选的String消息。

assert语句的语法有两种形式:

assert boolean_expression;
assert boolean_expression: error_message;

下面是一些基本规则，它们控制着断言应该在哪里使用，不应该在哪里使用。断言应该用于:

验证私有方法的输入参数。不是公共方法。当传递坏参数时，公共方法应该抛出常规异常。 在程序的任何地方来确保一个事实的有效性，而这个事实几乎肯定是正确的。

例如，如果你确定它只会是1或2，你可以使用这样的断言:

...
if (i == 1)    {
    ...
}
else if (i == 2)    {
    ...
} else {
    assert false : "cannot happen. i is " + i;
}
...

在任何方法结束时验证后置条件。这意味着，在执行业务逻辑之后，您可以使用断言来确保变量或结果的内部状态与您所期望的一致。例如，打开套接字或文件的方法可以在末尾使用断言来确保确实打开了套接字或文件。

断言不应该用于:

验证公共方法的输入参数。由于断言可能并不总是被执行，因此应该使用常规异常机制。 对用户输入的内容验证约束。同上。 不应用于副作用。

例如，这不是一个正确的用法，因为断言在这里被用于调用doSomething()方法的副作用。

public boolean doSomething() {
...    
}
public void someMethod() {       
assert doSomething(); 
}

唯一可以证明这一点的情况是，当你试图找出断言是否在你的代码中启用时:

boolean enabled = false;    
assert enabled = true;    
if (enabled) {
    System.out.println("Assertions are enabled");
} else {
    System.out.println("Assertions are disabled");
}