如何证明 '&&' 的优先级和'||'通过Java编码？

Question

我从某个地方知道逻辑 AND: && 在 Java 中比逻辑 OR: || 具有更高的优先级，但到目前为止我还没有找到任何线索这种优先级实际上是如何发挥作用的。如果我不知道两者的优先顺序会发生什么，我会犯什么错误？ 我尝试编写一些代码来证明 && 和 || 的优先级，但失败了，例如：

boolExp1 || boolExp2 && boolExp3 || boolExp4

无论优先级如何，上面的代码都会产生相同的结果&& 和 ||，即，

false || false && true || false

无论优先级如何，都会导致 false。

我想要一个可以证明 && 和 || 优先级的方法或函数。它应该根据 && 和 || 的优先级产生不同的结果。是否可以？

Answer 1

让我们以您的示例表达式为例：

boolExp1 || boolExp2 && boolExp3 || boolExp4

现在我们认为它的作用是：

boolExp1 || (boolExp2 && boolExp3) || boolExp4

对吗？

因此，让我们假设相反的情况为真，实际上是

(boolExp1 || boolExp2) && (boolExp3 || boolExp4)

boolExp1 等的哪些值会给我们不同的结果？

好吧，让我们假设：

boolExp1 = true
boolExp2 = false
boolExp3 = false
boolExp4 = false

在“&&具有更高的优先级”规则下，结果将是正确的。在“||具有更高优先级规则”下，结果将是错误的。然而，快速测试表明该表达式的计算结果为 true。

当然，这实际上并不能证明 &&优先级高于|| - 仅此||没有比 && 更高的优先级。我们可以考虑它们是否具有相等优先级 - 并以类似的方式用其他表达式进行测试...找到一个示例表达式和值，它们在不同的优先级规则下会给出不同的结果，并测试它们。

但最终，我更喜欢：

• 相信规范，除非我有具体疑问
• 使用括号来明确我的意图

我不会首先使用第一个表达式“按原样”...因为除非您实际上知道 优先规则（我怀疑许多 Java 开发人员不这样做 - 我不能发誓我会得到 && 和 || 正确的）你一无所知。最好把有任何疑问的地方说清楚。

Answer 2

如果 && 的优先级不高于 ||，则此表达式：

a || b && c

将按如下方式求值：

(a || b) && c

要验证是否是这种情况，
您可以生成 a、b 和 c 的所有组合，
并比较这两个表达式的结果，
查看它们是否始终相等，即：

1. 对于 a、b 和 c 的所有组合
2. 验证：(a || b && c) == ((a || b) && c)

示例代码：

for (int i = 0; i < 8; ++i) {
    boolean a = ((i >> 2) & 1) == 1;
    boolean b = ((i >> 1) & 1) == 1;
    boolean c = (i & 1) == 1;
    boolean x1 = (a || b && c);
    boolean x2 = ((a || b) && c);

    if (x1 != x2) {
        System.out.println(String.format("%s %s %s", a, b, c));
        System.out.println(String.format("   %s || %s  && %s => %s", a, b, c, x1));
        System.out.println(String.format("  (%s || %s) && %s => %s", a, b, c, x2));
    }
}

输出：

true false false
   真实 ||假&&假=>真的
  （真 || 假）&&假=>错误的
真 真 假
   真实 ||真&&假=>真的
  （真 || 真）&&假=>错误的

因此，&& 的优先级高于 ||。

Answer 3

我也有同样的问题，但答案实际上已经给了我。
这是我的示例：

true || true && false

相当于

true || (true && false)

所以通过这个示例，很容易看出 Java 中的逻辑 &&优先级高于||。

Answer 4

仅通过编写/运行示例无法证明编程语言的任何有用之处。据您所知，编译器可能会以不合逻辑、不一致或不确定的方式编译代码。

即使您假设确定性编译和确定性执行，编译/运行示例唯一能证明的是该特定示例表现出特定行为。您无法在逻辑上从一个示例推广到另一个示例，因为如果不参考规范，编译器只是一个黑匣子。 （您的下一个示例可能是以完全反直觉的方式处理的。）

理解编程语言的正确方法是阅读语言规范、一本好的教科书或一个好的教程。将其与编写代码结合起来以确认您的理解。

如果您仅仅依赖于阅读示例代码和编写测试程序，您很可能会产生误解，并养成很难改掉的坏习惯。

Answer 5

我正在查看java规范，看看他们是否为 && 和 || 定义了运算符优先级，

两者都被定义为左关联，并且没有定义运算符优先级。

请参阅。 15.7.3 比 s 稍低一些。 17.7,
&& 。 15.23,
|| s。 15.24

即 Java 定义：

boolExp1 || boolExp2 && boolExp3 || boolExp4

为：

((((boolExp1) || boolExp2) && boolExp3) || boolExp4)

Answer 6

一个简单的测试是：

boolean a = true || false && false;
boolean b = false && false || true;

if (a == b) { // different precedence
    if (a == true) {
        System.out.println("&& has higher precedence than ||");
    } else { // a == false
        System.out.println("|| has higher precedence than &&");
    }
} else { // a != b, same precedence
    if (a == true) { // and b == false
        System.out.println("&& and || have equal precedence, and are executed right to left.");
    } else { // a == false, b == true
        System.out.println("&& and || have equal precedence, and are executed left to right.");
    }
}

请注意，这考虑了 && 和 || 可能具有相同优先级的可能性，然后在这种情况下确定它们是否'从左到右或从右到左重新执行。

不幸的是，这并没有考虑到基于从内到外或从外到内的更改或优先级，或许多其他可能的操作顺序，更不用说它可能被恶意或损坏的编译器、恶意或损坏的计算机和宇宙所击败。射线。

不管怎样，要证明你的编译器/计算机/宇宙没有扰乱你真的很困难。因此除了测试之外还要检查语言规范。

Answer 7

public static void main(String[] args) {
    
    boolean res = b(false,1) || b(true,2) && b(false,3) || b(false,4);
    System.out.println(res);
}   
static boolean b(boolean b, int i){
    System.out.println(i);
    return b;
}
// 1 2 3 4 false

Answer 8

两者 &&和 ||具有相同的优先级，评估从左到右进行。让我用一个例子来解释一下。

public static void main(String[] args) {

    System.out.println("Result = " + (arg1() || arg2() && arg3() || arg4()));
}

private static boolean arg1() {
    System.out.println("arg1");
    return false;
}

private static boolean arg2() {
    System.out.println("arg2");
    return true;
}

private static boolean arg3() {
    System.out.println("arg3");
    return true;
}

private static boolean arg4() {
    System.out.println("arg4");
    return false;
}

其计算结果为：-

arg1
arg2
arg3
Result = true

但现在让我更改 arg3() 以返回 false

private static boolean arg3() {
    System.out.println("arg3");
    return false;
}

这会导致：-

arg1
arg2
arg3
arg4
Result = false

因此得出结论.. 评估从左到右进行，即

arg1 || arg2 && arg3 || arg4
   output    && arg3 || arg4
           output    || arg4
                   output 

希望这会有所帮助。