Learn Java, Angular, SQL with Coding Exercises & Career Tips

Data Types

Exercises Interview question Video Tutorial Discussion

Programming data types define the kind of data a variable can hold. They determine what operations you can perform on the data and how it is stored in memory. Choosing the right data type is crucial for writing efficient and reliable Java programs.

In Java, data types are divided into two main categories:

Primitive Data Types

Reference (Non-Primitive) Data Types

Primitive Data Types

Primitive data types are the most basic data types in Java. They are predefined by the language and named by reserved keywords. Primitives directly store their values in memory, making them fast and memory-efficient.

There are eight primitive data types in Java:

Data Type	Size	Default Value	Range / Values	Example
boolean	~1 byte	false	true or false	boolean flag = true;
byte	1 byte	0	-128 to 127	byte b = 100;
short	2 bytes	0	-32,768 to 32,767	short s = 1000;
int	4 bytes	0	-2,147,483,648 to 2,147,483,647	int age = 25;
long	8 bytes	0L	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	long l = 100000L;
float	4 bytes	0.0f	Up to 7 decimal digits	float f = 3.14f;
double	8 bytes	0.0d	Up to 15 decimal digits	double d = 19.99;
char	2 bytes	'\u0000'	Unicode characters ( 0 to 65,535 )	char grade = 'A';

Key Points:

Primitive types store actual values directly in memory.

They are lightweight, memory-efficient, and fast to access.

Primitives do not have methods or behaviors attached to them.

Reference Data Types

Reference (or non-primitive) data types store references (memory addresses) to objects, not the actual data itself. These are used for storing more complex data structures and objects.

Common Reference Types in Java:

Class Objects: Instances of classes (e.g., String, Scanner).

Arrays: Collections of values of the same data type.

Interfaces: Contracts that classes can implement.

Enumerations: Special types for collections of constants.

Key Points:

Reference variables store the address of the object in heap memory, not the object itself.

They can be assigned null, indicating they don’t refer to any object.

Reference types have methods and behaviors (e.g., String.length(), ArrayList.add()).

Primitive Vs. Reference Data Types

Feature	Primitive Data Types	Reference Data Types
Definition	Predefined by Java	Created from classes / arrays
Storage	Stores actual value	Stores reference (address)
Memory Location	Stack	Heap
Default Value	0, 0.0, false, '\u0000' (never null)	null
Methods	No	Yes
Example	int age = 25;	String name = "John";
Use Case	Simple values ( numbers, chars, etc. )	Complex data ( objects, arrays )

Example:

public class DataTypesExample {
    public static void main(String[] args) {
        // Primitive data types
        int age = 25;
        char grade = 'A';
        boolean isJavaFun = true;
        double price = 19.99;

        // Reference data types
        String name = "John";
        int[] scores = {90, 85, 88};

        // Output
        System.out.println("Age: " + age);
        System.out.println("Grade: " + grade);
        System.out.println("Is Java Fun: " + isJavaFun);
        System.out.println("Price: " + price);
        System.out.println("Name: " + name);
        System.out.print("Scores: ");
        for (int score : scores) {
            System.out.print(score + " ");
        }
    }
}

Output:

Age: 25
Grade: A
Is Java Fun: true
Price: 19.99
Name: John
Scores: 90 85 88

Here, int, char, boolean, and double are primitive types.

String and int[] (array) are reference types.

When to Use Each Type

Primitive types: Use for simple, fixed-size values (numbers, characters, booleans), especially when performance and memory efficiency matter.

Reference types: Use for objects, collections, and when you need methods or behaviors attached to your data.

Understanding the difference between primitive and reference data types is fundamental to Java programming. Primitives are simple, fast, and memory-efficient, while reference types allow you to work with complex objects and data structures. Knowing when and how to use each type will help you write clear, efficient, and robust Java code.