Member variable
From Wikipedia the free encyclopedia
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]
For Examples[edit]
C++[edit]
class Foo { int bar; // Member variable public: void setBar(const int newBar) { bar = newBar; } }; int main () { Foo rect; // Local variable return 0; } Java[edit]
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[edit]
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[edit]
(defclass foo () (bar)) (defvar f (make-instance 'foo)) (setf (slot-value f 'bar) 100) (print (slot-value f 'bar)) Ruby[edit]
/* 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[edit]
<?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[edit]
--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) See also[edit]
References[edit]
- ^ 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.