Tagváltozó
 |
Ezzel a szócikkel kapcsolatban felmerült kifogás(ok):
|
Az objektumorientált programozásban a tagváltozó (néha tagmezőnek is hívják) egy meghatározott objektumhoz kapcsolódó változó, amely annak összes metódusa számára (tagfüggvény) elérhető.
Az osztályalapú programozási nyelvekben két kategória létezik: osztályváltozók és példányváltozók. Az osztályváltozóknál (statikus tagváltozónak is hívják) csak egy változópéldány létezik, amely meg van osztva az összes példánnyal. A példányváltozóknál az osztály minden példányának saját független változó példánya van.
Példák
[szerkesztés]C++
[szerkesztés]class Foo {
int bar; // Tagváltozó.
public:
void setBar(const int newBar) {
bar = newBar;
}
};
int main () {
Foo rect; // Helyi változó.
return 0;
}
Java
[szerkesztés]public class Program
{
public static void main(String[] args)
{
// Ez egy helyi változó. Az élettartamát
// a lexikális hatáskör határozza meg.
Foo foo;
}
}
public class Foo
{
/* Ez egy tagváltozó – Foo minden osztálypéldányához
egy új példány jön létre a változóból. A változó
élettartama megegyezik a "this" Foo példány
élettartamával.
*/
int bar;
}
Python
[szerkesztés]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
[szerkesztés](defclass foo () (bar))
(defvar f (make-instance 'foo))
(setf (slot-value f 'bar) 100)
(print (slot-value f 'bar))
Ruby
[szerkesztés]/*
A Ruby-nak három tagváltozó típusa van: osztályváltozó,
osztálypéldányváltozó és példányváltozó.
*/
class Kutya
# Az osztályváltozó az osztály törzsében van definiálva két kukacjellel
# és leírja a Kutya osztályt és annak származtatott osztályait (ha van
ilyen)
@@szaglászik = true
end
keverék = Kutya.new
keverék.class.szaglászik #=> true
class Uszkár < Kutya
# Az osztaly példányváltozó az osztály törzsében van meghatározva egy
# kukacjellel és csak az Uszkár osztályról tartalmaz információt. Nem
# állít semmit a szülőosztályáról sem a származtatott osztályairól
# állítást.
@vedlik = false
# Az új Uszkár példány még nincs betanítva amikor létrejön. A ‘betanított’
# változó az inicializáló metódusban helyi változó és beállítja az @trained
# példányváltozót. A Példányváltozó a példánymetódusban van definiálva és
# az Uszkár példánynak egy tagja.
def initialize(betanított = false)
@betanított = betanított
end
def be_van_tanítva?
@betanított
end
end
p = Uszkár.new
p.class.vedlik #=> false
p.be_van_tanítva? #=> false
PHP
[szerkesztés]<?php
class Példa
{
/**
* Példa példányváltozó.
*
* Tagváltozók lehetnek: public, protected vagy private.
*
* @var int
*/
public int $foo;
/**
* Példa statikus tagváltozó.
*
* @var bool
*/
protected static int $bar;
/**
* Példa konstruktor metódus.
*
* @param int $foo
*/
public function __construct(int $foo)
{
// Beállítja foo-t.
$this->foo = $foo;
}
}
// Létrehoz egy új Example objektumot.
// Beállítja a "foo" tagváltozót 5-re.
$példa = new Példa(5);
// Felülírja a "foo" tagváltozót 10-re.
$példa->foo = 10;
// Kiír 10-et.
echo $példa->foo;
Lua
[szerkesztés]--region példa
--- @class példa_c
--- @field foo szám Példa "tagváltozó".
local példa_c = {}
local példa_mt = {__index = példa_c}
--- Objektumot hoz létre példából.
--- @return példa_c
function példa_c.new(foo)
-- Az első táblázat argumentum az objektum tagváltozója.
-- A Lua objektumokban metatáblák vannak kulcs-érték pár tagváltozókkal.
return setmetatable({
foo = foo
}, példa_mt)
end
--endregion
-- Létrehoz egy példa objektumot.
-- Beállítja "foo" tagváltozót 5-re.
local példa = példa_c.new(5)
-- Átírja "foo" tagváltozót 10-re.
példa.foo = 10
-- Kiír 10-et.
print(példa.foo)
Jegyzetek
[szerkesztés]Fordítás
[szerkesztés]Ez a szócikk részben vagy egészben a Member variable című angol Wikipédia-szócikk ezen változatának fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.