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.
Well, that’s interesting to know that Psilotum nudum are known as whisk ferns. Psilotum nudum is the commoner species of the two. While the P. flaccidum is a rare species and is found in the tropical islands. Both the species are usually epiphytic in habit and grow upon tree ferns. These species may also be terrestrial and grow in humus or in the crevices of the rocks.
View the detailed Guide of Psilotum nudum: Detailed Study Of Psilotum Nudum (Whisk Fern), Classification, Anatomy, Reproduction