Non-Primitive Data Types in Java

Non-Primitive Data Types in Java are user-defined or derived data types that allow developers to create complex structures. Unlike primitive types that store simple values, non-primitive types like classes, arrays, strings, objects, and interfaces store references and support multiple behaviors. These data types provide flexibility to handle data and implement object-oriented programming concepts effectively. 

This tutorial explains Non-Primitive Data Types in Java with clear definitions and examples. You will learn how arrays, strings, classes, and interfaces work, along with their key features and applications. We will also compare them with primitive types to highlight their differences. By the end, you will have a strong understanding of how to use non-primitive data types efficiently in Java programs. 

Looking to advance your Java framework skills? Check out upGrad’s Online Software Engineering Courses. Start today to strengthen your foundation and accelerate your career growth by learning JavaScript, Node.js, APIs, React, and more!

What Are Non-Primitive Data Types in Java? 

Non-Primitive Data Types in Java, also called reference or object data types, are not built into the language but created by programmers. Unlike primitive types that store simple values directly in memory, non-primitive types store references to objects.  

Boost your career growth by learning in-demand skills across Cloud, DevOps, AI, and Full Stack Development. Work on real-world projects, gain practical expertise, and learn directly from industry experts to stand out in the job market. 

• Professional Certificate Program in Cloud Computing and DevOps 

• AI-Powered Full Stack Development Course by IIITB

• Future-Proof Your Tech Career with AI-Driven Full-Stack Development 

Examples include classes, objects, arrays, strings, and interfaces. These data types allow developers to build flexible, reusable, and more complex structures. They also support methods and behaviors, making them integral to object-oriented programming in Java. Non-primitive types provide the foundation for modeling real-world entities and solving advanced programming problems efficiently.

What Are Data Types in Java?

Data types in Java categorize and define the data types variables can store. Primitive data types in Java represent simple values such as boolean, byte, int, long, and char.

And each data type comes with specific ranges of values and tasks that users can perform.

1. Primitive Data Type

Primitive data types in programming languages are the language’s most essential types.

Primitive data types are directly supported by the hardware and have specific sizes and representations in memory. Primitive data are straightforward, meaning you cannot divide them into smaller pieces.

Primitive data types, unlike complex data types or objects, do not have methods or different properties associated with them. Primitive data types represent fundamental values such as characters, boolean values, or numbers.

2. Non-Primitive Data Types or Object Data Types

Non-primitive data types in Java are data types that are not pre-defined. They are instead built by the programmer using classes or structures. Non-primitive data types in javascript have multiple values or components and can have complex systems.

Primitive Data Types in Java

Primitive data types in Java are fundamental data types that hold simple values and have fixed sizes, some of the primitive data types are stated below:

i) Boolean

The Boolean data type is commonly used in conditional statements to control the flow of the program based on specific conditions. It is also used in Boolean expressions and logical operations to compare and make decisions.

Here is an example:

public class BooleanExample {
    public static void main(String[] args) {
        boolean isSunny = true;
        boolean isRaining = false;
        System.out.println("Is it sunny? " + isSunny);
        System.out.println("Is it raining? " + isRaining);
        if (isSunny) {
            System.out.println("Wear sunglasses!");
        } else {
            System.out.println("Carry an umbrella!");
        }
    }
}

ii) Byte

The byte data type in Java is a primitive data type used to represent signed 8-bit integer values. It ranges from -128 to 127. The byte data type refers to when memory conservation is a priority or when working with raw binary data or streams.

public class ByteExample {
    public static void main(String[] args) {
        byte number = 100;
        System.out.println("Number: " + number);
    }
}

iii) Char

The primitive char data type represents a single 16-bit Unicode character. Char can store any character, including letters, digits, symbols, and spaces.

iv) Short

The short primitive data type represents signed 16-bit integer values. It stores whole numbers within the range of -32,768 to 32,767.

The short data type is practical in scenarios where memory conservation is a concern or when working with smaller integer values that fit within its range.

v) Int

Int is a primitive data type that represents signed 32-bit integer values. Int ranges from -2,147,483,648 to 2,147,483,647 and is the most popular integer data type that is used in Java.

vi) Long

The long primitive data type represents signed 64-bit integer values and ranges from -9,223,372,036,854,775,808 to +9,223,372,036,854,775,807.

It helps calculate large numbers or situations where the range of values exceeds the int data type limit.

vii) Float

The float data type is useful when precision is not the primary concern, and there is a need for a more comprehensive range of values with decimal points. It is suitable for scientific calculations, graphics, and audio processing scenarios.

viii) Double

The primitive double data type in Java represents double-precision 64-bit floating-point values. It can store decimal numbers more precisely than the float data type.

Double covers a range from 4.94065645841246544e-324d to 1.79769313486231570e+308d (positive or negative).

Also Read: Java Classes and Objects

Types of Non-Primitive Data Types

Non-primitive data types in Java include classes, arrays, interfaces, and more.

Some non-primitive data types examples are discussed below:

i) Class

In Java, a class is a blueprint or template for creating objects. It defines the structure, behavior, and state of objects. A class serves as a blueprint from which users can make multiple objects.

Let us understand classes properly with this example:

In this example, we define a class called Person, which has a private instance variable name of type String. The class also has a constructor to initialize the name and a getter method to retrieve the name value.

Inside the main method, we create an instance of the Person class and pass the name "Oreo" as an argument to the constructor. Then, we use the getter method to retrieve the name and print it to the console.

public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public static void main(String[] args) {
        Person person = new Person("Oreo");
        System.out.println("Person name: " + person.getName());
    }
}

ii) Object

An object is an instance of a class in Java. It represents a specific occurrence or realization of the class's structure and behavior. Objects have their own unique identity and can hold state and perform actions based on the defined behavior of the class.

Let us learn the function of objects with this example:

In this example, we declare a variable obj of type Object and assign it the value "Hello, World!".

The Object class is the root class in Java's class hierarchy, and it is a non-primitive data type that can hold references to any other type of object.

We use System.out.println() to print the value of obj to the console.

public class ObjectExample {
    public static void main(String[] args) {
        Object obj = "Hello, World!";
        System.out.println(obj);
    }
}

iii) String

Java uses a String class to represent character strings. Java uses strings to store and process text-based data. Since strings cannot be muted, users cannot alter their values post-formation.

Here is an example of using strings in Java:

In this example, we declare a variable message of type String and assign it the value "Hello, World!".

public class StringExample {
    public static void main(String[] args) {
        String message = "Hello, World!";
        System.out.println(message);
    }
}

iv) Array

Arrays have a fixed size, and users can use an index to access any element. Arrays offer a practical way to manage and store collections of data.

Here is an example of using arrays in Java:

In this example, we declare an array variable numbers of type int[] and initialize it with the values {1, 2, 3, 4, 5}.

Arrays in Java are used to store multiple values of the same type in a contiguous memory block.

We use System.out.println() to print the length of the array (numbers.length), the first element of the array (numbers[0]), and the last element of the array (numbers[numbers.length - 1]) to the console.

The array numbers has a length of 5, and we access and print the first element (1) and the last element (5) of the array.

Arrays in Java are zero-indexed, so the first element is accessed using index 0, and the last element is accessed using length - 1.

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("Array length: " + numbers.length);
        System.out.println("First element: " + numbers[0]);
        System.out.println("Last element: " + numbers[numbers.length - 1]);
    }
}

v) Interface

An interface in Java is a collection of blueprints of linked methods that a class must install. It defines a collection of methods that users must provide a class before implementing the interface.

Here is an example of an interface in Java:

public interface Printable {
    void print();
}

public class InterfaceExample {
    public static void main(String[] args) {
        Printable printable = new Document();
        printable.print();
    }
}

public class Document implements Printable {
    @Override
    public void print() {
        System.out.println("Printing document...");
    }
}

In order for this program to work, we must make three separate files for these three portions of code, Printable.java, InterfaceExample.java and Document.java.

In the above example, we defined an interface called Printable, which declares a single method print().

The Printable interface serves as a contract, specifying that any class that implements it must provide an implementation for the print() method.

We then created a class called Document that implements the Printable interface and provides its implementation for the print() method.

Inside the main method of the InterfaceExample class, we created an instance of the Document class and assigned it to a variable of type Printable. This demonstrates the usage of the interface as a non-primitive data type.

Finally, we invoked the print() method on the Printable object, which calls the implementation provided by the Document class.

Difference between Primitive and Non-Primitive Data Types in Java

Primitive and non-primitive data types differ based on operations, storage, and methods.

A few of the many differences between primitive and non-primitive data types in Java are stated in the table below.

Conclusion

Non-Primitive Data Types in Java play a crucial role in building robust and flexible applications. Unlike primitive data types that store simple values directly, non-primitive types such as arrays, strings, objects, and interfaces hold references and support advanced operations. These data types allow developers to define reusable structures, encapsulate behavior, and model entities with greater accuracy.  

By using Non-Primitive Data Types in Java, programmers can implement object-oriented principles, design scalable systems, and handle complex data efficiently. Their versatility makes them essential for modern software development where flexibility, abstraction, and reusability are key.

FAQs

1. What are Non-Primitive Data Types in Java? 

Non-Primitive Data Types in Java, also called reference types, are not predefined by the language. Instead, they are created by developers or provided through libraries. These include classes, objects, arrays, interfaces, and strings. Unlike primitive types that hold values directly, non-primitive types store references to memory locations. They enable object-oriented programming, complex structures, and real-world data modeling in Java applications. 

2. What is the main difference between primitive and non-primitive data types in Java? 

Primitive types like int, char, and boolean store raw values directly in memory, while non-primitive data types store references to objects. Primitives are simple, fixed in size, and efficient for basic operations. In contrast, non-primitive data types in Java can include attributes, methods, and behaviors, making them more flexible for implementing object-oriented programming and designing scalable, reusable applications. 

3. Are strings primitive or non-primitive data types in Java? 

Strings in Java are non-primitive data types. Although they appear simple to use, they are implemented as a class in the Java library. Strings are immutable, meaning once created, their value cannot be changed. Java also provides a string pool in memory for efficient storage. Being non-primitive, strings come with built-in methods for comparison, concatenation, and formatting. 

4. Why are arrays considered non-primitive data types in Java? 

Arrays are non-primitive because they are implemented as objects that store references. An array can hold multiple elements of the same data type, but it also includes features like the length property and built-in methods through the Arrays utility class. Unlike primitives, arrays are dynamic structures that occupy memory on the heap, making them a powerful way to manage collections of values. 

5. What is a class in Non-Primitive Data Types in Java? 

A class is a non-primitive data type that acts as a blueprint for creating objects. It defines fields (attributes) and methods (behaviors), encapsulating both data and functionality. Classes in Java support inheritance, abstraction, and polymorphism, making them fundamental to object-oriented programming. By using classes, developers can create modular and reusable code for building complex applications. 

6. What is the role of objects in non-primitive data types? 

Objects are instances of classes, making them non-primitive data types in Java. They store actual values for fields defined in a class and provide access to its methods. For example, a class "Car" defines properties, while an object like "myCar" represents a specific car with its own color and speed. Objects bring real-world modeling into Java applications, ensuring practical implementation of OOP concepts. 

7. What is an interface in Non-Primitive Data Types in Java? 

An interface is a non-primitive data type that defines abstract methods for other classes to implement. Interfaces promote abstraction and allow multiple inheritance in Java. They are widely used in enterprise applications to ensure modularity and standardization. For example, the List interface is implemented by ArrayList and LinkedList. This approach improves scalability and flexibility in Java program design. 

8. What are wrapper classes, and are they non-primitive in Java? 

Wrapper classes such as Integer, Double, and Boolean are non-primitive data types in Java. They "wrap" primitive values into objects, enabling them to be used with collections, generics, and frameworks that require objects. Wrapper classes also provide utility methods for conversion, parsing, and comparison, making them more versatile than primitives. For example, Integer.parseInt("123") converts a string into an integer. 

9. What is the default value of non-primitive data types in Java? 

The default value of non-primitive data types in Java is null. This means the variable is declared but does not currently point to any object in memory. For instance, an uninitialized string variable will have a null value until it is assigned an object. Developers must initialize non-primitive types to avoid null pointer exceptions during execution. 

10. Can we create custom non-primitive data types in Java? 

Yes. Developers can create custom non-primitive data types in Java by defining classes and interfaces. These user-defined data types can represent real-world entities with attributes and behaviors. For example, a class "Employee" with fields like name and salary models actual business requirements. This capability makes Java versatile, supporting domain-specific solutions across industries. 

11. Why are non-primitive data types also called reference types in Java? 

Non-Primitive Data Types in Java are called reference types because they store references (memory addresses) pointing to objects in the heap, not the actual values. For example, when you assign one object to another, both variables point to the same memory location. This reference-based nature allows dynamic memory management and more complex programming constructs compared to primitive types. 

12. How do strings differ from arrays in Java? 

Strings and arrays are both non-primitive data types in Java, but they differ in purpose. Strings represent sequences of characters and are immutable, while arrays can store multiple elements of any data type and are mutable. Arrays have fixed size, while strings offer built-in methods for manipulation. Developers often use arrays for structured data and strings for text processing. 

13. Are collections part of Non-Primitive Data Types in Java? 

Yes. Collections such as ArrayList, HashMap, and HashSet are non-primitive data types in Java. They provide dynamic, flexible structures for storing and manipulating groups of objects. Collections belong to the Java Collections Framework and come with extensive methods for searching, sorting, and iteration. They are more advanced than arrays, making them suitable for enterprise-level data handling. 

14. How do non-primitive data types support object-oriented programming in Java? 

Non-Primitive Data Types in Java, such as classes, objects, and interfaces, are the foundation of object-oriented programming. They support encapsulation by bundling data and behavior, inheritance by enabling code reuse, and polymorphism by allowing flexible method implementations. These features make applications modular, scalable, and maintainable, aligning Java with modern software development needs. 

15. Are enums non-primitive data types in Java? 

Yes. Enums are non-primitive data types in Java that define a fixed set of constants. They provide type safety and are widely used for representing states, roles, or categories. For example, an enum "Day" with values like MONDAY and TUESDAY ensures only valid constants are used. Enums improve readability, reduce errors, and integrate seamlessly with Java’s switch statements. 

16. What is the memory difference between primitive and non-primitive data types in Java? 

Primitive types are lightweight and directly store values in memory, typically on the stack. Non-Primitive Data Types in Java store references to objects in the heap, which may consume more memory. However, this approach enables complex data structures and behaviors. Although they have a higher memory footprint, non-primitive types offer abstraction and flexibility essential for real-world programming. 

17. Can non-primitive data types be passed to methods in Java? 

Yes. Non-Primitive Data Types in Java such as arrays, objects, and strings can be passed as arguments to methods. Since they store references, any modifications made inside the method may affect the original object outside. This behavior differs from primitive types, which are passed by value. Developers must carefully manage references to avoid unintended changes. 

18. What is the role of constructors in non-primitive data types? 

Constructors are special methods in classes, which are non-primitive data types in Java. They initialize objects with default or user-defined values. For example, a "Student" class may have a constructor to assign a name and roll number at the time of object creation. Constructors ensure objects are created in a consistent state, improving reliability in applications. 

19. Are non-primitive data types immutable in Java? 

Not all non-primitive data types in Java are immutable. For instance, strings are immutable, meaning their values cannot be changed once created. However, classes, arrays, and collections are mutable, allowing modifications to their state. Developers can also design custom classes as immutable by restricting field changes, which is useful in multithreaded environments. 

20. Why are Non-Primitive Data Types in Java important? 

Non-Primitive Data Types in Java are essential because they provide flexibility, extensibility, and reusability in programming. They enable developers to model real-world entities, implement OOP principles, and create scalable applications. From strings and arrays to collections and custom classes, non-primitive types form the backbone of modern Java development, making the language powerful for enterprise and large-scale solutions. 

Take the Free Quiz on Java

Answer quick questions and assess your Java knowledge

Start Quiz