java中0和0.有什么区别？

Question

I don't actually have the specific code, but me and a friend had exactly the same code except he used 0. and I used just 0 . Mine compiled, but his didn't until he removed the dot. But now, I've initialised a variable double x = 0. by accident, forgot to delete the dot, and it compiled! Why?

Answer 1

Making a guess here, you/your friend probably had a datatype that doesn't allow floating points, like int and long

Datatypes like float and double will allow you to set a .

Answer 2

Any number with a decimal point is considered a double literal (formally, a floating-point literal ). In that scenario, you would use it as you would a double.

The grammar that calls this out is thus, with optional parts demarcated in brackets:

Digits . [Digits] [ExponentPart] [FloatTypeSuffix]

Just like you wouldn't be able to do this...

int num = 10.6;

...you aren't able to do this...

int num = 10.;

...because that's a double .

Answer 3

Let's write an example program.

class A {
    public static void main(String args[]) {
        int a = 1;
        int b = 2.;
        double c = 3;
        double d = 4.;
    }
}

Three of these assignments are fine, but one triggers a compilation error:

A.java:4: error: possible loss of precision
        int b = 2.;
                ^
  required: int
  found:    double
1 error

So what's going on? 1 and 3 are integer constants; 2. and 4. are floating point constants. Integer values are automatically converted to floating point when you try to use an integer in a context that requires a floating point value. That's possible because all integer values can be represented in a floating point type¹.

On the other hand, int b = 2. is invalid, because in general floating point values cannot be represented in an integer type. For example the value 2.1 cannot be represented as an int (or indeed any other integer type). Java does not automatically convert values in a way that changes them, so it rejects any attempt to assign a floating point value to an integer variable. More generally, Java rejects any attempt to use a floating point value when an integer is expected. Java's rules are based on types, not on specific values, so there is no exception even for the case of 2. where the value could be intepreted as fitting an integer type².

You can force a conversion by using a cast. When a floating point value is cast to an integer type, it is rounded towards zero (ie positive values are rounded down, negative values are rounded up).

int b = (int)2.;

¹ _{In the case of int and double , all int values can be represented exactly by a double . This does not apply to some other combinations of integer and floating point types: for example, some large values of type long cannot be represented exactly by a value of type double ; but they can be represented approximately, and that's good enough because floating point values are approximations in the first place.}
² _{But actually the value does not fit: 2.0 means “approximately 2” (because all floating point values are approximations), whereas 2 means “the integer 2 (exactly)”.}

Answer 4

As @Turing85 commented, 0 is an integer and 0.(zero dot) is a double). Most likely your friend was using an integer variable to store double value. For example

int zeroInteger = 0.;

Won't work, as (0.) is a double literal, it can not be assigned to an integer variable, at least not without explicit typecasting.

double zeroDouble = 0.;

This should work as the variable is of double type.

Any character sequence that represents a value but not stored in a variable is called a literal. Following are some valid Java literals:

1. "hello"
2. 1234, 0x12, 012, 1234L
3. 2.3, 1E11, 2.3D

Since Java supports multiple data types for Integer (byte, short, int, long) and Floating point (float, double) numbers it has to decide up front which type to assign to a literal value.

In case of integer literal default data type is integer and in case of floating point number default data type is double .

Since default data type of the floating point literal is double, Java would give an error if we try to assign it to a float variable.

float myFloat = 2.3;

This would give an error. Correct way of doing it would be to typecast the literal to float or just append "f" or "F" to it.

float myFloat = 2.3f; // or 2.3F

Above is the correct way.

Same goes for the integer literal too. If we try to assign an integer literal to a byte or short variable Java would produce an error. However here it does something intelligent by actually checking if the assigned value is outside the range of the variable then only it produces error. For example.

byte someByte = 127;// is ok
byte someByte = 128; // is not ok