In object-oriented programming, a member variable (sometimes called a member field) is a variable that is associated with a specific object, and accessible for all its methods (member functions). In class-based programming languages, these are distinguished into two types: class variables (also called static member variables), where only one copy of the variable is shared with all instances of the class; and instance variables, where each instance of the class has its own independent copy of the variable. For Examples C++ class Foo { int bar; // Member variable public: void setBar(const int newBar) { bar = newBar; } }; int main () { Foo rect; // Local variable return 0; } Java public class Program { public static void main(String[] args) { // This is a local variable. Its lifespan // is determined by lexical scope. Foo foo; } } public class Foo { /* This is a member variable - a new instance of this variable will be created for each new instance of Foo. The lifespan of this variable is equal to the lifespan of "this" instance of Foo */ int bar; } Python class Foo: def __init__(self): self._bar = 0 @property def bar(self): return self._bar @bar.setter def bar(self, new_bar): self._bar = new_bar f = Foo() f.bar = 100 print(f.bar) Common Lisp (defclass foo () (bar)) (defvar f (make-instance 'foo)) (setf (slot-value f 'bar) 100) (print (slot-value f 'bar)) Ruby /* Ruby has three member variable types: class, class instance, and instance. */ class Dog # The class variable is defined within the class body with two at-signs # and describes data about all Dogs *and* their derived Dog breeds (if any) @@sniffs = true end mutt = Dog.new mutt.class.sniffs #=> true class Poodle < Dog # The "class instance variable" is defined within the class body with a single at-sign # and describes data about only the Poodle class. It makes no claim about its parent class # or any possible subclass derived from Poodle @sheds = false # When a new Poodle instance is created, by default it is untrained. The 'trained' variable # is local to the initialize method and is used to set the instance variable @trained # An instance variable is defined within an instance method and is a member of the Poodle instance def initialize(trained = false) @trained = trained end def has_manners? @trained end end p = Poodle.new p.class.sheds #=>