From Wiki
Jump to navigationJump to search
  • 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)


  • A literal integer is always implicitly 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.
  • All the higher order bits are truncated - for e.g. int is 32 bits and byte is 8 bits - so top 24 bits will be chopped off.
byte by =  128;	//Compiler error

byte by = (byte) 128; //OK with explicit cast
System.out.println(by); //Prints -128 after spill over.
  • 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
  • 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;
  • 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.
  • There is no implicit cast for non-literals, however if the variable is marked as final, then the compiler will add the narrowing final cast since the variable is a constant.
final int i1 = 20;
short s = i1;

int i2 = 20;
short s = i2; //NOT OK, i2 is not final.
  • Watch out! the compiler does NOT do the convenience cast for floating point numbers
float f = 2;  //This is legal. 2 is an int which fits in a float. (Widening)
float f = 2.0; //Illegal. 2.0 is a double which by default won't fit in a float. (Narrowing, but no auto cast by the compiler)

  • IMPORTANT : For compound assignment operators involving smaller than int sized operators ( +=, -=, *=, /=) the compiler puts in an implicit cast.
  • If the assignment results in a greater value than the type can hold, it will spill over - there wont be any error.
byte a = 5;
byte b = 10;

byte c = a + b; //WONT WORK AS ABOVE !
a *= b; //OK ! 
System.out.println(a); //Prints 50;

Char Int Compatibility

  • Under the hood a char is a 2-byte unsigned integer
  • A char's int value is a code which corresponds to a unicode character.
  • A char can be assigned int values without any cast.
  • Mathematical operations and incr/decr can be performed on a char.
  • The below method prints the entire alphabet. Note char is initialized to 65, the code for 'A'.
public static void main(String[] args) {
		char c = 65;
		for(int i=0; i < 26; i++) {