1. Introduction
Java data types define the kind of value a variable can hold and how much memory it occupies. Java data types are broadly divided into two categories: primitive types, which are predefined by the language and store simple values directly, and reference (non-primitive) types, which store the address of an object in memory, such as String, arrays, and classes.
Cricket analogy: Think of a scorecard's numeric fields (runs, overs) as primitives holding raw values directly, while a Team object like Mumbai Indians is a reference pointing to a roster of players stored elsewhere.
Unlike some languages, Java's primitive type sizes are fixed and platform-independent — an int is always 4 bytes whether the program runs on Windows, Linux, or macOS. This is a key part of Java's 'write once, run anywhere' philosophy.
Cricket analogy: Just as an ODI is always 50 overs whether played in Mumbai or Melbourne, Java's int is always 4 bytes whether it runs on Windows or Linux, guaranteeing consistent behavior everywhere.
2. Syntax
2.1 Integer Types
byte b = 100; // 1 byte, -128 to 127
short s = 20000; // 2 bytes, -32,768 to 32,767
int i = 100000; // 4 bytes, -2,147,483,648 to 2,147,483,647
long l = 100000L; // 8 bytes, ~-9.2x10^18 to 9.2x10^18 (needs L suffix)2.2 Floating-Point Types
float f = 3.14f; // 4 bytes, ~6-7 decimal digits precision (needs f suffix)
double d = 3.14159; // 8 bytes, ~15 decimal digits precision (default for decimals)2.3 Character and Boolean
char c = 'A'; // 2 bytes, single UTF-16 character, 0 to 65,535
boolean flag = true; // JVM-dependent size, conceptually 1 bit (true/false only)3. Explanation
Java has exactly 8 primitive data types: byte (1 byte), short (2 bytes), int (4 bytes), long (8 bytes), float (4 bytes), double (8 bytes), char (2 bytes, UTF-16 encoded), and boolean (JVM-dependent, conceptually 1 bit but typically implemented as 1 byte in memory). These are the only built-in types that are not objects; everything else in Java — String, arrays, wrapper classes, user-defined classes — is a reference type.
Cricket analogy: Like the fixed fielding positions on a cricket field (slip, gully, cover, and others), Java has exactly 8 primitive types (byte, short, int, long, float, double, char, boolean), each with a fixed memory size.
Reference types do not store the actual data in the variable itself; instead, the variable stores a reference (memory address) pointing to an object on the heap. The default value of any reference type is null, whereas primitives default to 0, 0.0, or false depending on the type.
Cricket analogy: A scoreboard showing 'Not Out' for a batsman who hasn't played yet is like an unassigned reference type defaulting to null, whereas the runs tally defaults to 0 like a primitive.
Exam favorite table — memorize exact byte sizes and ranges: byte=1B(-128 to 127), short=2B(-32,768 to 32,767), int=4B(-2^31 to 2^31-1), long=8B(-2^63 to 2^63-1), float=4B, double=8B, char=2B(0 to 65,535, unsigned), boolean=conceptually 1 bit.
Common mistake: char in Java is 2 bytes (UTF-16), not 1 byte like in C/C++. Also, long literals need an 'L' suffix and float literals need an 'f' suffix, otherwise the compiler treats them as int and double respectively, which can cause a compile error.
4. Example
public class DataTypesDemo {
public static void main(String[] args) {
byte b = 127;
short s = 32000;
int i = 2147483647;
long l = 9223372036854775807L;
float f = 3.14f;
double d = 3.14159265358979;
char c = 'J';
boolean flag = true;
System.out.println("byte: " + b + ", size: " + Byte.BYTES + " bytes");
System.out.println("short: " + s + ", size: " + Short.BYTES + " bytes");
System.out.println("int: " + i + ", size: " + Integer.BYTES + " bytes");
System.out.println("long: " + l + ", size: " + Long.BYTES + " bytes");
System.out.println("float: " + f + ", size: " + Float.BYTES + " bytes");
System.out.println("double: " + d + ", size: " + Double.BYTES + " bytes");
System.out.println("char: " + c + ", size: " + Character.BYTES + " bytes");
System.out.println("boolean: " + flag);
}
}5. Output
byte: 127, size: 1 bytes
short: 32000, size: 2 bytes
int: 2147483647, size: 4 bytes
long: 9223372036854775807, size: 8 bytes
float: 3.14, size: 4 bytes
double: 3.14159265358979, size: 8 bytes
char: J, size: 2 bytes
boolean: true6. Key Takeaways
- Java has exactly 8 primitive types: byte, short, int, long, float, double, char, boolean.
- Primitive sizes are fixed and platform-independent (int is always 4 bytes).
- char is 2 bytes in Java because it uses UTF-16 encoding, unlike C/C++'s 1-byte char.
- Reference types (String, arrays, objects) store an address, default to null, not a raw value.
- long literals need an 'L' suffix and float literals need an 'f' suffix.
- double is the default type for decimal literals in Java.
Practice what you learned
1. How many primitive data types does Java have?
2. What is the size of a char in Java?
3. Which suffix is required for a long literal that exceeds the int range?
4. What is the default value of a reference type variable if not initialized?
5. What is the range of a byte in Java?
Was this page helpful?
You May Also Like
Variables in Java
Learn what variables are in Java, how to declare and initialize them, naming rules, and the difference between local, instance, and static variables.
Type Casting in Java
Understand widening (implicit) and narrowing (explicit) type casting in Java, plus autoboxing and unboxing between primitives and wrapper classes.
Strings in Java
Understand Java's String class, its immutability, the string constant pool, and why == should never be used to compare string content.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics