Java 以实例说明后增量

我对下面的表达有点困惑。这是：

char a = 'D';
int b = 5;
System.out.println(a++/b+--a*b++);

我正试图通过以下方式解决这个问题：

（'D'/b+-a*b++）

在幕后，

a='E'

'D'/b++'D'*b++

'D'/b+'D'*5

幕后

b

值增加到6，

b=6

'D'/6+'D'*5

11+'D'*5

11+345

因为“D”值在ASCII中是69

356

---

但是编译器给出的输出是353。我在这里做的错误是什么？

你计算的是

(a++ / b) + (--a * b++)

在这种情况下，

--a

取消

a++

：除法之后

a

具有值

E

，但在乘法之前，它再次具有值

D

。后增量和预减量相互抵消。因此

/

和

*

的第一个操作数都是

'D'

，即

68

。后期增量

b++

对表达式没有影响。你也是

(68 / 5) + (68 * 5)

这是使用整数舍入的

353

编辑：详细情况如下：

char a = 'D';
int b = 5;

int divisonResult = a / b;

// a++ and --a cancel each other.
a++; // The incrementation of a happens after the divison.
--a; // The decrementation of a happens before the multiplication.

// Now a is back to 'D'.
int multiplicationResult = a * b;

b++; // This has no effect since b takes no part in the last step:

int additionResult = divisonResult + multiplicationResult;

---

你计算的是

(a++ / b) + (--a * b++)

在这种情况下，

--a

取消

a++

：除法之后

a

具有值

E

，但在乘法之前，它再次具有值

D

。后增量和预减量相互抵消。因此

/

和

*

的第一个操作数都是

'D'

，即

68

。后期增量

b++

对表达式没有影响。你也是

(68 / 5) + (68 * 5)

这是使用整数舍入的

353

编辑：详细情况如下：

char a = 'D';
int b = 5;

int divisonResult = a / b;

// a++ and --a cancel each other.
a++; // The incrementation of a happens after the divison.
--a; // The decrementation of a happens before the multiplication.

// Now a is back to 'D'.
int multiplicationResult = a * b;

b++; // This has no effect since b takes no part in the last step:

int additionResult = divisonResult + multiplicationResult;

---

正如Lurz Horn指出的，我在旧答案中犯了一个错误，我的测试通过了，因为错误小于1，并且被整数截断。所以我很快编辑了我的测试，现在我正在使用双打

它确实也让我感兴趣，所以我以单元测试的形式一步一步地把它拆开。最后一个测试最好地展示了编译器的工作方式

  @Test
  public void test1() throws Exception {
    char a = 'D';
    double b = 5;

    double result = a++ / b + --a * b++;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test2() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a++ / b;
    double result = aDividedB + --a * b++;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test3() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    double result = aDividedB + --a * b++;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test4() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    double aTimesB = --a * b++;
    double result = aDividedB + aTimesB;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test5() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    a--;
    double aTimesB = a * b++;
    double result = aDividedB + aTimesB;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test6() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    a--;
    double aTimesB = a * b;
    b++;
    double result = aDividedB + aTimesB;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

---

正如Lurz Horn指出的，我在旧答案中犯了一个错误，我的测试通过了，因为错误小于1，并且被整数截断。所以我很快编辑了我的测试，现在我正在使用双打

它确实也让我感兴趣，所以我以单元测试的形式一步一步地把它拆开。最后一个测试最好地展示了编译器的工作方式

  @Test
  public void test1() throws Exception {
    char a = 'D';
    double b = 5;

    double result = a++ / b + --a * b++;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test2() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a++ / b;
    double result = aDividedB + --a * b++;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test3() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    double result = aDividedB + --a * b++;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test4() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    double aTimesB = --a * b++;
    double result = aDividedB + aTimesB;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test5() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    a--;
    double aTimesB = a * b++;
    double result = aDividedB + aTimesB;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

  @Test
  public void test6() throws Exception {
    char a = 'D';
    double b = 5;

    double aDividedB = a / b;
    a++;
    a--;
    double aTimesB = a * b;
    b++;
    double result = aDividedB + aTimesB;

    assertThat(result, is(closeTo(353.6, 0.001)));
  }

---

为什么不将其分为多个步骤来提高可读性和可维护性？下一个继承这段代码的程序员将花一个小时在谷歌上搜索“运算符优先级”，试图弄清楚它的作用。为什么不把它分成多个步骤来提高可读性和可维护性呢？下一个继承这段代码的程序员将花一个小时在谷歌上搜索“运算符优先级”，试图弄清楚它的作用。