Java Variables & DataType

Variables are used to store data, and they act as containers to hold different types of values. Each variable has a specific data type, which determines the type of value it can store and the operations that can be performed on it.

Java supports various data types for variables, including primitive data types and reference data types. Here's an overview of Java variables and their characteristics:

Primitive Data Types: 

Primitive data types represent simple data values and are not objects. They are predefined by the language and include:

1. byte:

   • Size: 8 bits

   • Range: -128 to 127

   • Used to store small integer values, such as ASCII codes, file handling, etc.

2. short:

   • Size: 16 bits

   • Range: -32,768 to 32,767

   • Used to store small integer values, but larger than the byte data type.

3. int:

   • Size: 32 bits

   • Range: -2^31 to 2^31 - 1

   • Used for storing integer values in most cases. It is the most commonly used data type for integers.

4. long:

   • Size: 64 bits

   • Range: -2^63 to 2^63 - 1

   • Used for storing larger integer values that go beyond the range of int.

5. float:

   • Size: 32 bits

   • Range: Approximately ±3.4e-38 to ±3.4e38

   • Used to store single-precision floating-point numbers, suitable for most floating-point calculations.

6. double:

   • Size: 64 bits

   • Range: Approximately ±1.7e-308 to ±1.7e308

   • Used to store double-precision floating-point numbers, providing greater precision than float.

7. char:

   • Size: 16 bits

   • Range: 0 to 65,535

   • Represents a single 16-bit Unicode character.

8. boolean:

   • Size: Not strictly defined (typically JVM-dependent)

   • Represents a true or false value.

   • Can take the value true or false.

1. • 
     

2. Example:

int age = 30;

double pi = 3.14159;

char grade = 'A';

boolean isStudent = true;

Reference Data Types: Reference data types are used to store references (memory addresses) to objects. They don't hold the actual data but point to the memory location where the object is stored. These data types include:

• Classes: Objects created from user-defined classes.

• Arrays: Objects that can store multiple elements of the same type.

Example:

String name = "John";

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

Variable Declaration and Initialization: Variables must be declared before they are used. Declaration involves specifying the data type and the name of the variable. Initialization means giving the variable an initial value.

int count; // Declaration

count = 10; // Initialization

double price = 19.99; // Declaration and Initialization in one line

Variable Naming Rules:

1. • Variable names must begin with a letter, underscore (_), or dollar sign ($).

   • They can include letters, digits, underscores, and dollar signs.

   • Java is case-sensitive, so "age" and "Age" are considered different variables.

   • Variable names cannot be Java keywords (e.g., "int," "double," "class," etc.).

Remember that Java is a statically-typed language, meaning the data type of a variable is determined at compile-time, and the type cannot change during runtime. Also, variables should be initialized before being used to avoid compiler errors.

Example 1 of how to declare and use variables of primitive data types in Java:

public class PrimitiveDataTypesExample {

    public static void main(String[] args) {

        // Declaration and initialization of primitive variables

        byte age = 30;

        short salary = 30000;

        int quantity = 10;

        long population = 7827000000L; // L is used to indicate a long literal

        float pi = 3.14159f; // f is used to indicate a float literal

        double distance = 12345.6789;

        char grade = 'A';

        boolean isJavaFun = true;

        // Using the variables

        System.out.println("Age: " + age);

        System.out.println("Salary: " + salary);

        System.out.println("Quantity: " + quantity);

        System.out.println("Population: " + population);

        System.out.println("Pi: " + pi);

        System.out.println("Distance: " + distance);

        System.out.println("Grade: " + grade);

        System.out.println("Is Java fun? " + isJavaFun);

    }

}

Keep in mind that Java is a strongly-typed language, meaning variables must be declared with their specific data types, and type compatibility is strictly enforced during compilation.

Example 2

public class PrimitiveDataTypesExample {

    public static void main(String[] args) {

        // Integer data types

        byte age = 30;

        short salary = 30000;

        int quantity = 10;

        long population = 7827000000L; // L is used to indicate a long literal

        // Floating-point data types

        float pi = 3.14159f; // f is used to indicate a float literal

        double distance = 12345.6789;

        // Character data type

        char grade = 'A';

        // Boolean data type

        boolean isJavaFun = true;

        // Printing the variables

        System.out.println("Age: " + age);

        System.out.println("Salary: " + salary);

        System.out.println("Quantity: " + quantity);

        System.out.println("Population: " + population);

        System.out.println("Pi: " + pi);

        System.out.println("Distance: " + distance);

        System.out.println("Grade: " + grade);

        System.out.println("Is Java fun? " + isJavaFun);

    }

}

Output:

Age: 30

Salary: 30000

Quantity: 10

Population: 7827000000

Pi: 3.14159

Distance: 12345.6789

Grade: A

Is Java fun? true

In this example, we have declared variables of different primitive data types: byte, short, int, long, float, double, char, and boolean. We have initialized these variables with specific values, and then we printed their values using the System.out.println() method.