Easy Differences between Local Variable and Class Variable

Class Variables and Local Variables are two types of variables you can define in an object oriented programming language. These are identifiers defined to store values as required for the business logic.

The following are 5 differences between a class variable and a local variable.

What is a Local Variable?

A local variable is typically used inside a method, constructor, or a block and has only local scope. Thus, this variable can be used only within the scope of a block. The best benefit of having a local variable is that other methods in the class wont be even aware of that variable.

Local variables have temporary lifetime, they are automatically removed from the memory when the execution of the block of code where these variables are defined completes.

Any other member methods or blocks cannot access a local variable. They are strictly scoped within the block they are defined it.

Generally we can create a local variable using a specific data type (string/int/char ..) followed by the variable name identifier.

Modern programming languages also support creating local variables using var keyword, where the data type of the variable is resolved automatically based on the value assigned.

void DoSomething() {
    int someLocalVariableOfTypeInt;
    var someLocalVariableOfVarResolvedAsInt = 0;
}

Since local variables are created inside blocks such as methods or functions, they are memory allocated inside a Stack, where function call information is stored. As the function is executed, the variables along with the function call information is removed from the memory.

What is an Instance Variable?

Instance variables are also called Class Variables. These are declared within a class, but outside a method. Every object of that class will create its own copy of the variable while using it. Thus, any changes made to the variable wont reflect in any other instances of that class and will be bound to that particular instance only.

Class variables have extended lifetime and are available until the program is executed or the class is unloaded from the memory.

These are accessible to all other member methods and also other components which create an instance of the class.

Generally we create a class variable using a specific access specifier (public/private/protected), followed by a modifier (static/const..), a data type (int/string/char..) and the variable name identifier with an optional value assignment.

class SomeComponent {
   
   private readonly int _someInstanceVariableAccessibleWithinClass = 0;
  
   void DoSomething() {
     int someLocalVariable = _someInstanceVariableAccessibleWithinClass += 5;
   }
}

Since class variables are created within a class scope, they are memory allocated in a Heap where other dynamically allocated objects are stored. These are available in the heap until the program is executed and need to be removed from memory using a Garbage Collection

Local Variables vs Instance Variables – Summarized

In summary, the following are the 5 differences between a local variable and a class variable –