Member variable

Print Print
Reading time 5:6

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.[1]



class Foo {
    int bar; // Member variable
    void setBar(const int newBar) { 
      bar = newBar;

int main () {
  Foo rect; // Local variable

  return 0;


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;


class Foo:
    def __init__(self):
        self._bar = 0

    def bar(self):
        return self._bar

    def bar(self, new_bar):
        self._bar = new_bar

f = Foo() = 100


  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


mutt =
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

  def has_manners?


p =
p.class.sheds #=> false
p.has_manners? #=> false



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;


--region example
--- @class example_c
--- @field foo number Example "member variable".
local example_c = {}
local example_mt = {__index = example_c}

--- Creates an object from example.
--- @return example_c
  -- 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)

-- Create an example object.
-- Set the "foo" member variable to 5.
local example =

-- Overwrite the "foo" member variable to 10. = 10

-- Prints 10.


  1. ^ Richard G. Baldwin (1999-03-10). "Q - What is a member variable?". Richard G Baldwin Programming Tutorials. Retrieved 2011-08-12. A member variable is a member of a class (class variable) or a member of an object instantiated from that class (instance variable). It must be declared within a class, but not within the body of a method of the class.

Edited: 2021-06-18 14:10:03