Primitives

• Default type of an integer literal is int.
• Long can be specified by adding l or L
• Octal prefix with 0
• Hex prefix with 0x or 0X

• Floating point literals default type is double.

float pi = 3.14; // This will be a compiler error, because 3.14 is a fp literal which is double by default
double pi = 3.14; //OK
float pi = 3.14f; //OK

• Double can also be explicitly by adding the suffix d or D
• Float is denoted by suffix f or F

• Integers are stored in 2 complements's notation
• Leftmost bit is the sign bit, the remaining bits are used to store the value

• Consider Byte:
  • Byte - 1 byte = 8 bits.
  • Leftmost bit is to store the sign. So 7 bits are available for the value, so 2^7 = 128 values
  • Negative range is -128 to -1 (128 numbers)
  • Positive range is 0 to 127 (128 numbers, 0 is stored as a positive number)
  • So a byte's range is -2^7 to (2^7 - 1) - A total of 256 numbers;

• Character's take up 2 bytes
• they are stored as unsigned 16-bit integers. This means they will represent a total of 2^16 positive values (0 to 65535 (2^16-1) )
• contrast with short which also uses 2 bytes. But it's max positive range is 2^15 -1. (Since 1 bit is to used to represent the sign)

Assignments

• A literal integer is always implicitly an int.
• IMPORTANT : the result of an expression involving anything int-sized or smaller is always an int. e.g. an operation involving two bytes will be an int.
• Example

byte a = 10;
byte b = 20;
byte c = a + b; //WONT work : a+b will be an int
byte c = (byte) a + b; //EXPLICIT cast required

• However as a convenience, compiler automatically inserts a cast when int literals are assigned to narrower types like byte or short

byte c = 10; //Is OK although 10 is an int.

• The compiler will issue an error when it can see that literal value is too large for the variable.
• This can be fixed by explict casting, however if the value is too large - no runtime error will occur - the value will simply "spill" over.

byte by =  257;	//Compiler error

byte by = (byte) 257; //OK with explicit cast
System.out.println(by); //Prints 1 because byte max is 256

• An implicit cast will happen when a widening conversion is being performed.
• So a byte being assigned to int, or an int assigned to a long is OK

• Watch out!

float f = 2;  //This is legal. 2 is an int which fits in a float.
float f = 2.0; //Illegal. 2.0 is a double which by default won't fit in a float.

• An explicit cast is required for narrowing conversions. e.g. float to an int, or a long to an int.

long lon1 = 100;

int int1 = (int) lon1;