Non-primitive data type

Java programming language has two types of data types

Primitive data types (predefined data types)
Non-primitive data types

In this section, we will understand the non-primitive data types, their uses and implementation in Java.

Non-primitive data types:

Data types define the type of data that is stored in the variable. The type specifies the kind of data (different sizes and values).

Unlike primitive data types, these are not predefined. These are user-defined data types created by programmers. These data types are used to store multiple values.

For example, consider an array(TBD) that stores a group of values. Class is also a primitive type that stores different methods and variables. Therefore, these are also called as advanced data types in Java.

Whenever a non-primitive data type is defined, it refers a memory location where the data is stored in heap memory i.e., it refers to the memory location where an object is placed. Therefore, a non-primitive data type variable is also called referenced data type or simply object reference variable.

An object reference variable lives on the stack memory and the object to which it points always lives on the heap memory. The stack holds a pointer to the object on the heap.

In Java programming, all non-primitive data types are simply called objects that are created by instantiating a class.

Key points:

The default value of any reference variable is null.
`
Whenever we are passing a non-primitive data type to a method, we are passing the address of that object where the data is stored.

Types of Non-primitive data types

There are five types of non-primitive data types in Java. They are as follows:

1.Class
2.Object
3.String(TBD)
4.Array(TBD)
4.Interface(TBD)

**

1. Class and objects:**

A class in Java is a user defined data type i.e. it is created by the user. It acts a template to the data which consists of member variables and methods.

An object is the variable of the class, which can access the elements of class i.e. methods and variables.

Example:

In the following example, we are creating a class containing the variables and methods ( add() and sub() ). Here, we are accessing the methods using the object of the Class obj.

`
ClassExample.java

public class ClassExample {  

        // defining the variables of class  
        int a = 20;  
        int b = 10;  
        int c;  

        // defining the methods of class  
        public void add () {  
            int c = a + b;  
            System.out.println("Addition of numbers is: " + c);  
        }  

        public void sub () {  
            int c = a - b;  
            System.out.println("Subtraction of numbers is: " + c);  
        }  

    // main method  
    public static void main (String[] args) {  
        // creating the object of class  
        ClassExample obj = new ClassExample();  

        // calling the methods  
        obj.add();  
        obj.sub();  
    }  
}  

`
Difference between Primitive and Non-primitive Data types in Java:

`
*In Java, the primitive data types are system defined however we have to create and define the non-primitive data types.

*In primitive data type, variables can store only one value at a time. However in non-primitive data types, either multiple values of the same type or different type or both can be stored.

*All the data for primitive type variables are stored on the stack whereas, for reference types, the stack holds a pointer to the object on the heap.

*A primitive type starts with a lowercase letter, while non-primitive types start with an uppercase letter.

*The size of a primitive type depends on the data type, while non-primitive types have all the same size.

Reference:https://www.javatpoint.com/non-primitive-data-types-in-java

The above is the detailed content of Non-primitive data type. For more information, please follow other related articles on the PHP Chinese website!