Difference Between Local, Instance, and Static Variables in Java

Variables are crucial parts that store data in the realm of Java programming. Static variables and local instance variables are the two most prevalent forms of variables. Although they both have the function of storing data, they differ in terms of features and applications. In this section, we will discuss the differences between local, instance, and static variable.

Local Instance Variables

Local instance variables are linked to a specific class instance and are also called instance variables. They are declared inside classes, but outside of any constructors, methods, and blocks. These variables are created and linked to class objects that are instantiated.

Car.java

public class Car {
    // Local instance variables
    String brand;
    int year;
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }
    public void display () {
        System.out.print("Brand: " + brand);
	System.out.println();
        System.out.print("Year: " + year);
    }
    public static void main(String[] args) {
        Car c1 = new Car("Toyota", 2022);
        Car c2 = new Car("Honda", 2017);
        c1.display ();
        c2.display ();
    }
}

Output:

Brand: Toyota
Year: 2022
Brand: Honda
Year: 2017

Explanation

Year and brand are local instance variables in this case. These variables are specific to each instance of the Car class (car1 and car2) and may have distinct values.

Instance Variables

Instance variables are variables defined inside a class that are not included in any constructor, method, or block. They are sometimes referred to as member variables or object variables. These variables are connected to the class's instances or objects.

Person.java

public class Person {
    // Instance variables
    String name;
    int age;
    // Parameterized Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //  Display person's information
    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
    public static void main(String[] args) {
        // Creating two objects with different instance variable values
        Person p1 = new Person("Ram", 25);
        Person p2 = new Person("Ravi", 30);
        // Accessing and displaying the instance variables for each object
        System.out.println("Person 1:");
        p1.display();
        System.out.println("\nPerson 2:");
        p2.display();
    }
}

Output:

Person 1:
Name: Ram
Age: 25

Person 2:
Name: Ravi
Age: 30

Explanation

The instance variables' name and age are set to distinct values when two Person objects, p1 and p2, are created in the main() method. Every object has its displayInfo() method called on it, which outputs the name and age values correspondingly. The names and ages of both people are consequently shown to you in the output.

Static Variables

In contrast, static variables are linked to the class itself and not to a particular instance of the class. They exist apart from all other objects and are specified with the static keyword. A static variable is shared by all instances of the class and exists only in one copy for the whole class.

Value.java

public class Value{
    // Static variable
    static int cnt = 0;
    public Value() {
        cnt++;
    }
    public static void main(String[] args) {
        Value c1 = new Value();
        Value c2 = new Value();
        System.out.println("Count  variable Value: " + Value.count);
    }
}

Output:

Count variable Value: 2

Local Vs. Instance Vs. Static Variables

Aspect	Local Variables	Instance Variables	Static Variables
Declaration	Local variables are those that are defined inside a method.	Local variables are those that are defined inside a method.	Local variables are those that are defined inside a method.
Scope	The local variable's scope is restricted to the procedure in which it is defined.	The local variable's scope is restricted to the procedure in which it is defined.	The local variable's scope is restricted to the procedure in which it is defined.
Lifetime	The method call begins the lifespan of a local variable.	The method call begins the lifespan of a local variable.	The method call begins the lifespan of a local variable.
Accessibility to Objects	Every class object has access to the local variable.	Every class object has access to the local variable.	Every class object has access to the local variable.
Purpose	used to hold variables necessary for a certain procedure.	used to hold variables necessary for a certain procedure.	used to hold variables necessary for a certain procedure.

Conclusion

In conclusion, static variables are shared by all instances of a class, whereas local instance variables are unique to each instance. Which option we choose will rely on the particular needs of Java program. For your Java programmes to use variables effectively and efficiently, we must be aware of their differences.

Next TopicDifference Between Multithreading and Multiprocessing in Java

← prev next →