y = 2 [3] * [4] 4;

y = 2*4 = 8;

in [] is value after incrementation to show how this goes.

This sort of code is not really Java.  I would fire anyone who wrote
like this.  This is the stuff for the unmaintainable code essay.

http://mindprod.com/jgloss/unmain.html

There are several ways to solve this problem.  One is to read the JLS
on pre and post increment.  see http://mindprod.com/jgloss/jls.html
Basically post increment samples the value the increments.
Preincrement increments the value then samples.

Another way is to examine the byte code to see how it compiled.

public class PlusPlus
  {

  /**
   * test harness
   *
   * @param args not used
   */
  public static void main ( String[] args )
     {
     int x=2;
     int y = x++*++x;
     System.out.println( y );
     }
  }

I disassembled with Javap which comes with the JDK.

javap.exe -classpath . -c -private -s -verbose PlusPlus

The Byte code looks like this:

  0:   iconst_2
  1:   istore_1
  2:   iload_1
  3:   iinc    1, 1
  6:   iinc    1, 1
  9:   iload_1
  10:  imul
  11:  istore_2

The byte code is pretty pedestrian, not in the least optimised. It is
postfix stack based. Here is an approximation to what it does in
simple Java.

int  temp1=2;
int calc1 = temp1;
temp1++;
temp1++;
calc2 = temp1;
calc3 = calc1*calc2;
int temp2 = calc3;

So in English what is happening is this:

// Be very careful reusing a pre or post increment variable in an
expression.
int x = 2;
int y = x++ * ++x;  // result is y = 8;

// it works as if you had coded:
int x = 2;
int a = x++;   // a=2; x=3;
int b = ++x;   // b=4; x=4
int y = a * b; // y = 8

The key to understanding is the postincrement is done immediately
after sampling, not after the whole expression is computed.

Another way to solve this problem would be to read the precedence
entry in the Java glossary at:
http://mindprod.com/jgloss/precedence.html