Member variable

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.
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)
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 #=> false
p.has_manners? #=> false
PHP.
<?php
class Example
 /**
 * Example instance member variable.
 * Member variables may be public, protected or private.
 * @var int
 public int $foo;
 /**
 * Example static member variable.
 * @var bool
 protected static int $bar;
 /**
 * Example constructor method.
 * @param int $foo
 public function __construct(int $foo)
 // Sets foo.
 $this->foo = $foo;
// Create a new Example object.
// Set the "foo" member variable to 5.
$example = new Example(5);
// Overwrite the "foo" member variable to 10.
$example->foo = 10;
// Prints 10.
echo $example->foo;
Lua.
--region example
--- @class example_c
--- @field foo number Example "member variable".
--- Creates an object from example.
--- @return example_c
function example_c.new(foo)
 -- The first table argument is our object's member variables.
 -- In a Lua object is a metatable and its member variables are table key-value pairs.
 return setmetatable({
 foo = foo
 }, example_mt)
end
--endregion
-- Create an example object.
-- Set the "foo" member variable to 5.
local example = example_c.new(5)
-- Overwrite the "foo" member variable to 10.
example.foo = 10
-- Prints 10.
print(example.foo)