Question: A hypothetical scenario:

I've got a project whose source compliance level is specified to 1.5.
Now I compile this project with two different JDKs: At first with JDK 6 Update 7 and then with JDK 6 Update 20.

Do these two different JDKs produce different Java byte code, although they only differ in their Update version?

Answer: 
The compiler of for example JDK 6 Update 7 might output slightly different bytecode than the compiler of JDK 6 Update 20, but since it's both Java 6, the class files will be fully compatible - you will be able to run code compiled with Update 20 on Update 7 without any problems.

Between major Java versions (for example Java 5 vs. Java 6) there might be changes so that code compiled on the newer version will not run on the older version. For example, for Java 7 there is most likely going to be a new instruction, [invokedynamic](http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html). Class files that contain that instruction will not be runnable on older Java versions.

Such large changes are however never done between update versions.
As usually is for different compilers, it is also in the Java case: the result must be the same but the way it is reached can be (from the bytecodes point of view) different., e.g. because of optimizations or alike. The JVM is stack based V machine; the following is an imaginary example (I don't know jvm mnemonics for the instructions opcodes)

```
push 10
push 20
add
```

```
push 19
push 1
add
push 10
add
```

These produce same result, but generated bytecodes are different (the first is slightly optimized, the second is "totally" not optimized; a third option could be `push 30` since we are adding known (likely at compiletime) constants). This is a simple case, but more complex case can be easily built.