An instance variable is a piece of data in object-oriented programming that has its own unique value for every object in which it resides. Instance variables may also be called instance members, non-static fields, and data members. They are an important part of most objects, holding specific pieces of data that the object uses for calculation.
For example, if there exists two objects, A and B, where object A has an instance variable called "blah," and object B also has an instance variable called "blah," the two "blah" variables are distinct entities. Each variable is associated with the object that encapsulates it. The full name of the variable "blah" associated with object A is "A.blah," while the full name of the variable "blah" associated with object B is "B.blah." Each if these variables can have its own value. If objects A and B are of the same type, and another object of that type, C, is created, and object C will also have an instance variable "blah," which can have its own unique value.
Instance variables are often confused with static variables, but the two are significantly different. In contrast to instance variables, of which every object of a particular type has its own, static variables have only one value, and this value is the same for every object of the appropriate type. Static variables are often called class variables, which are not the same as instance variables.
Depending on the visibility properties assigned to them, instance variables may be visible only inside a particular object, to an object and its subclasses, or to the object in which it resides as well as any other objects. That final type of visibility, called public visibility, is often considered bad practice for instance variables, because it is easy to violate encapsulation principles in object-oriented programming. Despite this taboo, there are times in which public instance variables are useful. For example, many standard classes in Java have public instance variables, which at times allows for easy modification of properties.
The visibility of an instance variable also comes into play with inheritance. If one class inherits from another, this does not immediately give both classes access to each other's instance variables. Private instance variables in the superclass and subclass remain restricted to only those classes, so a private variable in the subclass cannot be seen by the superclass, and vice versa. The only instance variables that both the superclass and subclass can see is protected variables in the superclass.