Data Types

In Java, data types are fundamental building blocks used to define variables and methods. They specify the type of data that a variable can hold or a method can return. Java offers two main categories of data types: primitive data types and reference data types. Let’s delve into each category, explore their variations, and provide examples to illustrate their usage.

Primitive Data Types

Primitive data types represent basic values and are not objects. They are stored directly in memory and are more memory-efficient compared to reference data types. Java provides eight primitive data types, each catering to different types of values:

• byte: The byte data type stores 8-bit signed integers. It has a range of -128 to 127.

         Example:

         byte age = 25;

• short: The short data type stores 16-bit signed integers. Its range is -32,768 to 32,767.

        Example:

         short population = 30000;

• int: The int data type stores 32-bit signed integers. It covers a range of approximately -2.1 billion to 2.1 billion.

         Example:

          int quantity = 1000;

• long: The long data type stores 64-bit signed integers. It has a wider range than int.

         Example:

         long bigNumber = 12345678900L;

          // Note the 'L' suffix

• float: The float data type represents single-precision 32-bit floating-point numbers. It is suitable for approximate values.

         Example:

          float pi = 3.14159f;

           // Note the 'f' suffix

• double: The double data type stores double-precision 64-bit floating-point numbers. It offers higher precision than float.

         Example:

          double salary = 50000.75;

• char: The char data type stores a single 16-bit Unicode character. It represents characters and symbols.

         Example:

          char grade = 'A';

• boolean: The Boolean data type represents a binary value, either true or false.

         Example:

          boolean isRaining = true;

Reference Data Types

Reference data types are used to create objects and are stored as references in memory. They include classes, interfaces, arrays, and enumerated types. Unlike primitive types, reference types can have methods and fields.

• String The String class is used to represent a sequence of characters. It’s not a primitive type, but a reference type.

         Example:

         String message = "Hello, Java!";

• Arrays Arrays are collections of elements of the same data type. They have a fixed size, defined during initialization.

         Example:

         int[] numbers = {1, 2, 3, 4, 5};

• Classes and Objects Classes define blueprints for creating objects. Objects are instances of classes, encapsulating data and behavior.

class Person {
    String name;
    int age;
}

Person person1 = new Person();
person1.name = "Chakrapani";
person1.age = 21;

• Enumerated Types (enum) Enumerations are special reference types that represent a fixed set of constants.

         Example:

             enum Day {

                        SUNDAY,

                        MONDAY,

                         TUESDAY,

                         WEDNESDAY,

                        THURSDAY,

                         FRIDAY,

                         SATURDAY

            }

            Day today = Day.FRIDAY;

• Interfaces Interfaces define contracts that classes must adhere to. They contain method declarations but no implementations.

// Define an interface
interface Person {
    void introduce();
}
// Implement the interface for a Programmer
class Programmer implements Person {
    String name;

    public Programmer(String name) {
        this.name = name;
    }

    @Override
    public void introduce() {
        System.out.println("Hello, I'm " + name + ", a programmer.");
    }
}
public class Main {
    public static void main(String[] args) {
        Programmer programmer = new Programmer("Prince Mahesh");
        programmer.introduce();
        // Inspirational quotation for programmers
        String quotation = "Coding is the art of turning logic into reality.";
        System.out.println(quotation);
    }
}

Java’s data types provide the foundation for building applications that process and manipulate various kinds of data. Understanding these data types is essential for effective programming and ensures that your code is accurate, efficient, and maintainable.