Java Non-Primitive Data Types

Welcome to The Coding College, where we simplify complex coding concepts! In this guide, we’ll explore non-primitive data types in Java, their characteristics, and examples to help you understand their practical applications.

What Are Non-Primitive Data Types?

Non-primitive data types (also known as reference types) are more complex than primitive types. These include:

• Strings
• Arrays
• Classes
• Interfaces
• Enums

Non-primitive data types:

• Are created by programmers (custom types).
• Store references (memory addresses), not values directly.
• Have methods for operations.
• Default to null when uninitialized.

Key Non-Primitive Data Types in Java

1. String

A String represents a sequence of characters enclosed in double quotes.

Example:

public class StringExample {
    public static void main(String[] args) {
        String message = "Hello, Java!";
        System.out.println("Message: " + message);
        System.out.println("Length: " + message.length());
        System.out.println("Uppercase: " + message.toUpperCase());
    }
}

Output:

Message: Hello, Java!  
Length: 12  
Uppercase: HELLO, JAVA!

2. Array

An Array is a collection of elements of the same type stored in contiguous memory locations.

Example:

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        System.out.println("First number: " + numbers[0]);
        System.out.println("Array length: " + numbers.length);

        System.out.print("Array elements: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}

Output:

First number: 10  
Array length: 5  
Array elements: 10 20 30 40 50

3. Classes

A Class is a blueprint for creating objects. It encapsulates data and behavior.

Example:

class Student {
    String name;
    int age;

    void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class ClassExample {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "John";
        student.age = 20;
        student.displayInfo();
    }
}

Output:

Name: John  
Age: 20

4. Interfaces

An Interface defines a contract that classes must follow.

Example:

interface Animal {
    void sound();
}

class Dog implements Animal {
    public void sound() {
        System.out.println("Bark!");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();
    }
}

Output:

Bark!

5. Enums

An Enum is a special type to define constants.

Example:

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.FRIDAY;
        System.out.println("Today is: " + today);
    }
}

Output:

Today is: FRIDAY

Differences Between Primitive and Non-Primitive Data Types

Use Cases

• Strings: Manipulating text (e.g., user input, messages).
• Arrays: Storing multiple values in a single variable.
• Classes: Defining objects with attributes and behaviors.
• Interfaces: Implementing functionality contracts.
• Enums: Defining constant sets (e.g., days of the week).

Practice Exercises

1. Write a program to store and print the names of 5 students using an array.
2. Create a class to represent a Book with attributes title and author, and a method to display details.
3. Define an interface Vehicle with a method drive(), and implement it in a class Car.
4. Use an Enum to represent the months of the year, and print a message for your birth month.

Conclusion

Non-primitive data types in Java provide powerful tools for creating and managing complex data structures and behaviors. Mastering these concepts is essential for developing robust and scalable Java applications.

For more tutorials and resources, visit The Coding College and continue your programming journey with confidence! 🚀