Learn Java, Angular, SQL with Coding Exercises & Career Tips

java-variable

Exercises Interview question Video Tutorial Discussion

Variables are fundamental elements in any programming language, and Java is no exception. In Java, a variable acts as a named storage location in your computer’s memory, designed to hold data that your program can use, modify, or update as it runs. Think of a variable as a labeled container: you can put something inside (store a value), take it out (retrieve the value), or replace it with something new (update the value).

Every variable in Java has a specific data type, which determines what kind of data it can store-such as numbers, text, or boolean values. Before you can use a variable, you must declare it by specifying its data type and name, so the Java compiler knows how much memory to allocate and how to treat the data. You can also initialize a variable by assigning it a value, either at the time of declaration or later in your code.

What is a Variable ?

A variable is a container that holds data. It allows you to store, modify, and retrieve values in memory during the execution of a program.

Key Points

Named Memory Location: Each variable has a unique name (identifier) and stores a value in memory.

Declaration: You must declare a variable before using it by specifying its data type and name.

Initialization: You can assign a value to a variable at the time of declaration or later in your code.

Declaring and Initializing Variables

Declaration

To declare a variable in Java, specify the data type followed by the variable name:

datatype variableName;

Example:

int a;      // Declares an integer variable named 'a'

Initialization

Assign a value to a variable using the assignment operator (=):

variableName = value;

Example:

a = 12;     // Assigns the value 12 to variable 'a'

Declaration and Initialization Together

You can declare and initialize a variable in a single line:

int a = 20;
String s = "Hello";

Types of Variables in Java

Java supports three main types of variables, each with its own scope and lifetime:

1. Instance Variable

Where: Declared inside a class but outside any method, constructor, or block.

Scope: Each object (instance) of the class has its own copy.

Default Value: Gets a default value if not initialized (e.g., 0 for int, null for objects).

Lifetime: Exists as long as the object exists.

Example:

package quipohouse;
public class InstanceVariable {
    int var = 10; // Instance variable

    public static void main(String[] args) {
        InstanceVariable c = new InstanceVariable();
        System.out.println(c.var); // Output: 10
    }
}

2. Local Variable

Where: Declared inside a method, constructor, or block.

Scope: Only accessible within that method or block.

Default Value: No default value; must be initialized before use.

Lifetime: Exists only while the method or block is executing.

Example:

package quipohouse;
public class LocalVariable {

    public static void main(String[] args) {
        int var2 = 12; // Local variable
        System.out.println(var2); // Output: 12
    }
}

3. Static Variable ( Class Variable )

Where: Declared inside a class using the static keyword, but outside any method.

Scope: Shared among all instances (objects) of the class; only one copy exists.

Access: Can be accessed directly by the class name.

Default Value: Gets a default value if not initialized.

Lifetime: Exists for the entire duration of the program.

Example:

package quipohouse;
public class StaticVariable {
    static int var; // Static variable

    public static void main(String[] args) {
        System.out.println(StaticVariable.var); // Output: 0
        System.out.println(var);                // Output: 0
    }
}

Reference Table: Types of Variables

Type	Where Declared	Scope	Default Value	Lifetime	Access Example
Instance	Inside class, outside methods	Each object	Yes	As long as object exists	object.var
Local	Inside method or block	Within method/block	No	While method/block runs	var
Static	Inside class, with static	Shared by all objects	Yes	Entire program	ClassName.var

Variables are fundamental to Java programming. By understanding how to declare, initialize, and use different types of variables, you lay the groundwork for all future coding in Java. Practice declaring each type and observe their behavior in different scopes-this is the first step toward mastering Java.

Tips: Always use meaningful variable names and initialize your local variables before use to avoid compiler errors.