Java Data Types

Learning outcome: Distinguish primitive and reference types, separate types from variables and objects, choose suitable data types, and understand default values.

Java is a statically typed language. Every variable has a declared type, and the compiler checks that values are used in ways compatible with those types.

Types that programmers can write in ordinary variable declarations fall into two main groups:

1. Primitive types, which store simple values directly.
2. Reference types, which store references to objects.

The Eight Primitive Types

Java has exactly eight primitive types.

In simple terms: A primitive holds the value itself, the way a matchbox holds a match. There are exactly eight kinds of box, and their sizes are fixed by the language rather than by the machine.

The Java language does not define an exact storage size for boolean. It defines only the allowed values: true and false.

Choosing a Suitable Type

Use this practical guide:

BigDecimal is the class java.math.BigDecimal. Construct exact decimal values from text, for example new BigDecimal("99.99"), rather than from an already approximate double value.

Example:

byte smallCounter = 100;
int age = 19;
long worldPopulation = 8_100_000_000L;
float piApprox = 3.14f;
double temperature = 36.75;
char grade = 'A';
boolean passed = true;

Reference Types

According to the Java Language Specification, Java SE 17, Section 4.3, Java has four kinds of reference types: class types, interface types, type variables, and array types. These are categories; names such as Student, Book, and Account are merely examples of user-defined class types. An enum declaration creates a specialised class type rather than a fifth reference-type category. Java also defines a special, unnamed null type for the null literal; programmers cannot declare a variable using that type.

In simple terms: A reference variable does not hold the object; it holds directions to it. Copying the variable copies the directions, not the house.

A reference variable conceptually stores a reference to an object or array rather than storing that object's contents inside the variable.

int count = 5;                 // primitive value
String name = "Aarav";         // reference to a String object
int[] scores = {80, 90, 95};   // reference to an array object

The four reference-type categories are:

User-Defined Classes Are Class Types

A class declaration introduces a new class type. Therefore, each of Student, Book, Account, Course, and the many other class names that programmers may declare can be a reference type. Student has no special status; it is used below only as one example.

class Student {
    String name;
}

class StudentReferenceDemo {
    public static void main(String[] args) {
        Student learner = new Student();
        learner.name = "Asha";
    }
}

These terms refer to different things:

The category is class type, not “Student type.” Student is one possible declared class type. Calling the object itself a “reference type” would also be imprecise: the class is the type, the variable holds a reference, and the object is an instance.

The default value for a reference field is null, which means the variable does not currently refer to an object. null is not an object and cannot be assigned to a primitive variable.

Arrays are reference types. They are covered in a dedicated topic that includes declaration, traversal, multidimensional arrays, and jagged arrays.

Primitive vs Reference Behaviour

Primitive assignment copies the value.

In simple terms: Assigning a primitive photocopies the value, so changing one copy leaves the other untouched. Assigning a reference hands over a second key to the same room.

int a = 10;
int b = a;
b = 20;

System.out.println(a);   // 10
System.out.println(b);   // 20

Reference assignment copies the reference, not the object.

int[] first = {10, 20};
int[] second = first;

second[0] = 99;

System.out.println(first[0]);  // 99

Both first and second refer to the same array object.

Default Values

Default values apply to fields: instance variables and static variables declared in a class. They do not apply to local variables declared inside a method.

In simple terms: Fields arrive like a form with the blanks pre-filled as zero. Local variables get no such courtesy, which is why the compiler refuses to read one before you have written to it.

public class DefaultsDemo {
    int count;              // field: defaults to 0
    boolean active;         // field: defaults to false
    String name;            // field: defaults to null

    public void show() {
        int localCount;
        // System.out.println(localCount); // error: not initialised
    }
}

Worked Example

public class DataTypesDemo {
    public static void main(String[] args) {
        byte b = 100;
        int count = 50000;
        long worldPopulation = 8_100_000_000L;
        float pi = 3.14f;
        double temperature = 36.75;
        char grade = 'A';
        boolean passed = true;

        System.out.println("byte    : " + b);
        System.out.println("int     : " + count);
        System.out.println("long    : " + worldPopulation);
        System.out.println("float   : " + pi);
        System.out.println("double  : " + temperature);
        System.out.println("char    : " + grade);
        System.out.println("boolean : " + passed);
    }
}

Output:

byte    : 100
int     : 50000
long    : 8100000000
float   : 3.14
double  : 36.75
char    : A
boolean : true

Common Mistakes

Practice

Problem 1: Choose Types

Choose suitable Java types for:

1. A student's age.
2. A product price that must be represented exactly.
3. A college name.
4. A pass/fail flag.
5. A single grade letter.
6. The world population.

Problem 2: Predict Defaults

What are the field defaults?

public class Student {
    int rollNo;
    double percentage;
    boolean placed;
    String name;
}

Problem 3: Primitive or Reference

Classify each type:

int
String
double
int[]
boolean
Scanner

Quick Check

Summary

Primitive variables hold primitive values; reference variables refer to objects or arrays. Java's four reference-type categories are class types, interface types, type variables, and array types. Declaring any class introduces a class type, while using new creates an object of that type. Fields receive default values, but local variables must be initialised before use. Choosing the right type makes programs clearer, safer, and easier to maintain.