在面向对象程序设计中，**成员变量**（有时称为**成员字段**）是与特定对象相关联的变量，并且特定对象的所有方法（成员函数）均能访问該變量。

例子
--

### 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 #=> 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".
local example\_c = {}
local example\_mt = {\_\_index = example\_c}

--- 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)

```

参考文献
----

1. ↑  Richard G. Baldwin.. Richard G Baldwin Programming Tutorials. 1999-03-10  [2011-08-12]. （原始内容存档于2022-04-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.