Explain the difference between instance variable and a class variable

Instance variables and class variables (also known as static variables) are two types of variables in Java, and they have distinct characteristics and purposes. Here’s a detailed comparison:
Instance Variables
Definition: Instance variables are non-static variables defined within a class but outside any method. They are unique to each instance (object) of the class.
Memory Allocation: Each instance of the class has its own copy of instance variables, which are stored in the heap memory along with the object.
Scope: They can be accessed by all methods within the class and are specific to the object.
Default Values: Instance variables have default values (e.g., 0 for numeric types, false for boolean, null for object references) when an object is created.
Usage: They represent the state or attributes of an object. Each object can have different values for these variables.
Example:
class Car {
   String color; // Instance variable
   void displayColor() {
       System.out.println(color);
   }
}
 
 
Class Variables
Definition: Class variables are declared with the static keyword within a class. They are shared among all instances of the class.
Memory Allocation: Class variables are allocated memory once when the class is loaded, and there is only one copy for the entire class, regardless of how many objects are created.
Scope: They can be accessed directly using the class name or through instances of the class, but typically accessed using the class name for clarity.
Default Values: Like instance variables, class variables also have default values based on their data type.
Usage: They represent shared data or properties that are common to all instances. They can be used for counting instances, sharing constants, etc.
Example:
 
class Car {
   static int count = 0; // Class variable
   Car() {
       count++; // Increment the class variable when a new object is created
   }
   static void displayCount() {
       System.out.println("Number of cars: " + count);
   }
}
 
 
Summary of Differences
Feature
Instance Variable
Class Variable
Declaration
Not static
Static
Memory Allocation
Unique for each instance
Shared among all instances
Scope
Instance-specific
Class-wide
Default Values
Yes (type-specific)
Yes (type-specific)
Access
Through object references
Through class name or instance
Purpose
Represents object state/attributes
Represents shared class properties
Understanding these differences helps in designing classes effectively and utilizing the correct type of variable based on the requirements of your program.