Primitive Assignments in Java

While studying to upgrade my Sun Certified Java Programmer status from version 1.4 to version 6, I came across what appears to be an anomaly in the Java compiler. In Java, a literal integer (like 8) is always implicitly an int, i.e. a 32-bit value. A byte is only 8 bits. However, the following narrowing assignment is legal. No explicit cast is required.

     byte b = 30;

The compiler automatically narrows the literal 30 to a byte. It can do this because 30 is a compile-time constant that is within the range of a byte. Now, recall that a floating point literal (like 43.4) is implicitly a double, i.e. a 64-bit value; but a float is only 32 bits. Consider the following code:

     float f = 43.4;

You might think that this is legal because 43.4 is a compile-time constant that is well within the range of a float. If the compiler obliges us by implicitly casting an int constant to a byte, why shouldn't it do the same for double to float assignments? However, the compiler does no such thing. The above code does not compile. The literal value has to be either explicitly cast to a float, or have an f (or F) appended to it to make it a float literal. Thus, the following assignments are all legal and compile successfully:

     float f = (float) 43.4;
     float f1 = 43.4f;
     float f2 = 43.4F;

Why is the compiler so finicky about floating points? I have not been able to think of an answer. Can you?