Hogyan elérni Objektumtulajdonságok objektumon belül módszer?

Személy szerint úgy érzem, fontos, hogy ne változzanak. Ha get és set metódusok, használja őket. Az egyetlen alkalom, amikor is hozzáférhet a területen közvetlenül, amikor a tartozék egy csomó fölött. Lehet úgy érzed puffadás a kódot feleslegesen, de ez természetesen menteni egy csomó fejfájást a jövőben. A klasszikus példa:

Később, akkor a vágy, hogy változtatni az ezen a területen dolgozik. Lehet, hogy ki kell számítani on-the-fly, vagy talán szeretne használni egy másik típusát a hátlap boltban. Ha elérésével tulajdonságok közvetlenül, a változás, mint ami tönkreteheti borzasztó sok kódot egy dagad foop.

Én elég meglepett, hogy mennyire egyhangú az érzés, hogy gettersés alkotóinak finom és jó. Javaslom, hogy a gyújtóbombákban cikket Allen Holub „ get és szetterek Evil ”. Nyújtott, a cím sokk érték, de a szerző a témával kapcsolatban.

Lényegében ha gettersés settersminden egyes saját területén, akkor így ezeken a területeken olyan jó, mint az állami. Ön lenne nagyon szorongatott típusának megváltoztatásához saját területén nélkül tovagyűrűző hatásai minden osztályban, hogy felhívja, hogy getter.

Sőt, a szigorúan OO szempontból tárgyak legyen válaszolási (módszerek), amely megfelel a (remélhetőleg) egyetlen felelősséget. A túlnyomó többsége getters, és settersnem sok értelme az őket alkotó objektumok Pen.dispenseInkOnto(Surface)Több értelme van, mint nekem Pen.getColor().

Get és set metódusok is ösztönzi a felhasználókat, az osztály, hogy kérje az objektum valamilyen adatot, hajtson végre egy számítást, majd állítsa be egy másik értéket a tárgy, ismertebb nevén az eljárási programozás. Jobb lenne, ha arra szolgált, hogy egyszerűen elmondja a tárgy van, amit akartál az első helyen; más néven a Information Expert idióma.

Get és alkotóinak, azonban szükségesek rossz határán a rétegek - UI, perzisztencia, és így tovább. Korlátozott hozzáférés az osztály belső felépítéséről, mint a C ++ barátja kulcsszó, Java csomag védett hozzáférés, .NET belső hozzáférés, valamint a Friend Class minta segítségével csökkentheti a láthatóságát gettersés alkotóinak, hogy csak azok, akiknek szükségük van rájuk.

Ez attól függ, hogy a tulajdonság. Tegyük fel például, hogy van egy diák objektum, amelynek neve tulajdonság. Lehet használni a Get módszer, hogy húzza a nevet az adatbázisból, ha még nem töltöttük le már. Így csökkentik a felesleges hívások az adatbázishoz.

Most tegyük fel, hogy van egy saját integer számláló a tárgy, ami számít, hogy hányszor a név már hívott. Érdemes lehet, hogy nem használja a GET metódus belsejéből a tárgy, mert feltehetően egy érvénytelen szám.

PHP kínál számtalan módon lehet kezelni ezt, beleértve a mágikus módszerek __getés __set, de én inkább explicit get és set metódusok. Ennek okai:

1. Validation lehet elhelyezni alkotóinak (és getter, hogy az ügyben)
2. Intellisense működik explicit módszerek
3. Nem kérdés, hogy egy tulajdonság csak olvasható, csak írható vagy írható-olvasható
4. Visszakeresése virtuális ingatlan (azaz a számított értékek) ugyanúgy néz ki, mint a rendszeres tulajdonságok
5. Könnyedén meg egy objektum tulajdonság, ami soha nem határozta bárhol, amely azután nem dokumentált

Én csak megy a vízbe itt?

Talán ;)

Egy másik megközelítés, hogy kihasználja a személyes / védett módszer, hogy ténylegesen a szerzés (caching / db / etc), és egy nyilvános wrapper az, hogy növeli a száma:

PHP:

public function getName() {
    $this->incrementNameCalled();
    return $this->_getName();
}

protected function _getName() {
    return $this->name;
}

majd belül maga a tárgy:

PHP:

$name = $this->_getName();

Így továbbra is használhatja, hogy az első érv valami másra (mint küld egy zászlót, hogy vagy nem használt gyorsítótárban tárolt adatokat itt talán).

Azt kell, hogy hiányzik a lényeg itt, miért használja a getter belsejében egy objektum eléréséhez tulajdonsága, hogy az objektum?

Figyelembe ezt annak megkötésére a getter kell hívni egy getter, amely hívjanak getter.

Tehát azt mondanám, hogy belsejében egy objektum módszer hozzáférési ingatlan közvetlenül, főleg ha azt nézzük, amelyben egy másik módszer, hogy a tárgy (ami csak elérni az ingatlant közvetlenül amúgy majd vissza) csak egy értelmetlen, pazarló gyakorlat (vagy félreértettem a kérdést ).

Azt mondanám, hogy jobb a hozzáférési metódusok belül is az objektumot. Itt vannak a pontok, jutott eszembe azonnal:

1) Meg kell tenni a fenntartása érdekében összhang hozzáférések kívül készült tárgyat.

2) Egyes esetekben ezek a hozzáférési metódusok többet tehetne, mint elérni a területen; tudták csinálni néhány további feldolgozás (ritka bár). Ha ez az eset áll fenn, a hozzáférés területén közvetlenül akkor kimaradnak, hogy további feldolgozás és a programot is félrecsúszik, ha a feldolgozás mindig meg kell tenni azokban hozzáférések

A puritán OO módja az, hogy elkerüljük mind, és kövesse a Demeter törvénye segítségével Mondja Ne Kérdezd megközelítés.

Ahelyett, hogy az érték az objektum tulajdonság, amely szorosan párok két osztályt használja az objektumot paraméterként pl

  doSomethingWithProperty() {
     doSomethingWith( this.property ) ;
  }

Amennyiben az ingatlan volt a natív típus, pl int használjon hozzáférési módszer neve azt problémás területet nem a programozási tartomány.

  doSomethingWithProperty( this.daysPerWeek() ) ;

Ez lehetővé teszi, hogy fenntartsák tokozás, és bármilyen körülmények között vagy függő állandók. Ön is használja a szetter módszert tart fenn előfeltételek vagy függő állandók azonban nem esnek abba a csapdába, megnevezve azokat alkotóinak, menjen vissza a Hollywood elve elnevezésére, ha a idióma.

Ha a „vegytiszta” az, hogy „a legtöbb beágyazás”, akkor azt általában nyilvánítja az én mezőket magán, majd a this.field belül az osztály, hanem az összes többi osztályok, beleértve alosztályok, hozzáférés például állapotot a getter.

Attól függ. Ez több, a stílus kérdése, mint bármi más, és nincs nehéz szabályt.

Ha nem fogom szerkeszteni az ingatlan fogom használni get_property()nyilvános eljárás, kivéve, ha ez egy különleges alkalom, például egy MySQLi belüli objektum egy másik objektumot, amely esetben én csak az állami tulajdon és hivatkoznak rá, mint $obj->object_property.

Bent a tárgy ez mindig a $ this-> Ingatlan nekem.

Egyéni mezők nyilvános vagy védett tulajdonságokkal. Hozzáférés az értékeket meg kell átmenni a tulajdonságokat, és fel kell másolni egy helyi változót, ha azokat a többször használható a módszer. Akkor és csak akkor, ha a többi alkalmazás, így teljesen csípett, ringatta ki, és egyébként optimalizálva, ahol betekintés értékeket megy keresztül assosciated ingatlan vált a szűk (És ez soha nem történhet meg, azt garantálom) kell még kezdődik hogy úgy hagyta semmi más, mint az ingatlan megérintik a hátlap változók közvetlenül.

.NET fejlesztők használhatják az automatikus tulajdonságok érvényesíteni ezt, mert akkor nem is látja a hátlap változókat a tervezés során.

Azt találtuk, használja alkotóinak / getter tette a kód könnyebben olvasható. Én is, mint a kontroll ad, ha más osztályokba módszereket használja, és ha tudom megváltoztatni az adatokat az ingatlan tárolja.

Azt is rossz, mert én vagyok autodidakta, de soha nem a felhasználó nyilvános tulajdonságokat én Java osztályok, azok mindig magán vagy védett úgy, hogy külső kódot kell elérni a getter / alkotóinak. Még mindig jobb, karbantartási / módosítás célra. És benne osztály kódját ... Ha getter eljárás triviális használom az ingatlant közvetlenül, de én mindig a szetter módszerek, mert könnyen hozzá kódot tűzesetek, ha akarja.

Szeretem a következőképpen válaszoljon cmcculloh , de úgy tűnik, a legtöbb helyes a válasz szerint Greg Hurlman . Használja getter / alkotóinak minden alkalommal, ha elkezdte használni őket a getgo és / vagy használnak velük dolgozni.

Mellesleg, én személy szerint úgy találják, hogy a getter / alkotóinak teszi a kód könnyebben olvasható és a hibakeresés a későbbiekben.

Nos, úgy tűnik, a C # 3.0 tulajdonságok alapértelmezett megvalósítása, a döntés meghozatala az Ön számára; Be kell állítani a tulajdonság segítségével (esetleg magán) tulajdon szetter.

Én személy szerint csak az egyéni tag-hátra, amikor nem így okozna a tárgy esik egy kevesebb, mint kívánatos állapot, például, ha inicializálása vagy ha caching / lusta rakodási van szó.

Amint az néhány megjegyzést: Néha kell, néha nem. A nagy része a privát változók, hogy meg tudja-e látni az összes helyet használják őket, ha valamit változtatni. Ha a getter / setter csinál valamit, amire szükség van, használja azt. Ha ez nem számít, akkor dönt.

Az ellenkező esetben lehetne tenni, hogy ha a getter / setter és valaki megváltoztatja a getter / setter meg kell elemezni minden helyen a getter és setter használják belsőleg, hogy ha elrontja valamit.