Types of Variables in Java

In Java, variables are containers that hold values. A variable name represents the memory location name. Each variable consists of three elements: data type, variable name, and value. A variable may have a scope (private, protected), but it depends on the requirement.

• Data Type: It defines what type of data a variable can hold.
• Variable Name: It uniquely identifies a variable.
• Value: The data assigned to the variable.

Example: int price=90;

Basically, there are three types of variables in Java.

1. Local Variable
2. Instance Variable
3. Static Variable

1. Local Variables

Local variables are defined inside blocks, constructors, or methods. When control leaves these variables, they are destroyed. Upon entering the method, constructor, or block, these variables are generated.

Local variables need to be initialized before use because they do not have default values.

Key Features of Local Variables

1. Scope: Limited to the method, constructor, or block where they are defined
2. Lifetime: They exist only during the execution of the method or block in which they are declared.
3. Initialization: Local variables must be initialized before they are used, as they do not have default values.
4. Modifiers: They cannot have access modifiers like public, private, or protected. However, they can be marked as final.

Example of Local Variable

Output:

 10 

2. Instance Variables

An instance variable is a variable that is declared inside a class but outside the body of the method or constructor, or block. It is called an instance variable because its value is instance-specific and is not shared among instances.

These variables are specific to an object of the class. It means that each object has its own copy of the instance variable. It is not declared as static.

Key Features of Instance Variables

1. Scope: They belong to an object of the class and can be accessed through that object.
2. Default Values: They are initialized with default values (for example, 0 for integers, null for objects) if not explicitly initialized.
3. Lifetime: Instance variables are created when the object is created and destroyed when the object is destroyed.
4. Accessibility: Can be accessed using object references (for example, objectName.variableName) and their visibility is determined by access modifiers like public, private, or protected.

Example Instance Variables

Output:

 Employee's Name is: Andrew Age: 19 

3. Static Variable

A variable that is declared as static is called a static variable. It cannot be local. You can create a single copy of the static variable and share it among all the instances of the class. Memory allocation for static variables happens only once when the class is loaded in the memory.

Key Features of Static Variables

1. Scope: Static variables are accessible by all instances of the class. They are shared across objects, meaning all objects reference the same memory location.
2. Lifetime: They are initialized only once, at the time of class loading, and exist for the duration of the program.
3. Default Values: Similar to instance variables, static variables are initialized with default values if not explicitly assigned.
4. Access: They can be accessed directly using the class name (e.g., ClassName.variableName) or through objects, though accessing via the class name is preferred.
5. Modifiers: They can be combined with other modifiers like final, private, or public.

Example of Static Variables

Output:

 Employee-1 salary is: 24000 Employee-2 salary is: 24000