म्यूटेटर विधि

कंप्यूटर विज्ञान में, एक म्यूटेटर विधि एक चर में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली विधि है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। अक्सर एक सेटर के साथ एक गेट्टर (एक साथ एक्सेसर्स के रूप में भी जाना जाता है) होता है, जो निजी सदस्य चर का मान लौटाता है।

एनकैप्सुलेशन के सिद्धांत को ध्यान में रखते हुए, म्यूटेटर विधि का उपयोग अक्सर ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में किया जाता है। इस सिद्धांत के अनुसार, एक वर्ग के सदस्य चर (प्रोग्रामिंग) को छिपाने और उन्हें अन्य कोड से बचाने के लिए निजी बनाया जाता है, और इसे केवल एक सार्वजनिक सदस्य फ़ंक्शन (म्यूटेटर विधि) द्वारा संशोधित किया जा सकता है, जो पैरामीटर के रूप में वांछित नया मान लेता है, वैकल्पिक रूप से मान्य करता है यह, और निजी सदस्य चर को संशोधित करता है। म्यूटेटर विधियों की तुलना असाइनमेंट ऑपरेटर ओवरलोडिंग से की जा सकती है लेकिन वे आम तौर पर ऑब्जेक्ट पदानुक्रम के विभिन्न स्तरों पर दिखाई देते हैं।

गैर-ऑब्जेक्ट-उन्मुख वातावरण में म्यूटेटर विधियों का भी उपयोग किया जा सकता है। इस स्थिति में, संशोधित किए जाने वाले वेरिएबल का एक सूचक (कंप्यूटर प्रोग्रामिंग) नए मान के साथ, म्यूटेटर को दिया जाता है। इस परिदृश्य में, संकलक कोड को म्यूटेटर विधि को बायपास करने और चर को सीधे बदलने से प्रतिबंधित नहीं कर सकता है। यह सुनिश्चित करने की जिम्मेदारी सॉफ्टवेयर डेवलपर की है कि वेरिएबल केवल म्यूटेटर विधि के माध्यम से संशोधित किया गया है और सीधे संशोधित नहीं किया गया है।

प्रोग्रामिंग भाषाओं में जो उनका समर्थन करते हैं, गुण (प्रोग्रामिंग) इनकैप्सुलेशन की उपयोगिता को छोड़े बिना एक सुविधाजनक विकल्प प्रदान करते हैं। नीचे दिए गए उदाहरणों में, एक पूरी तरह से कार्यान्वित म्यूटेटर विधि भी इनपुट डेटा को मान्य कर सकती है या किसी घटना को ट्रिगर करने जैसी आगे की कार्रवाई कर सकती है।

निहितार्थ
म्यूटेटर और एक्सेसर विधियों, या संपत्ति ब्लॉकों को परिभाषित करने का विकल्प, उदाहरण चर को निजी के अलावा कुछ दृश्यता देना है और इसे सीधे वस्तुओं के बाहर से एक्सेस करना है। म्यूटेटर और एक्सेसर्स का उपयोग करके एक्सेस अधिकारों के अधिक बेहतर नियंत्रण को परिभाषित किया जा सकता है। उदाहरण के लिए, एक पैरामीटर को केवल एक एक्सेसर को परिभाषित करके केवल पढ़ने के लिए बनाया जा सकता है, लेकिन एक म्यूटेटर नहीं। दो विधियों की दृश्यता भिन्न हो सकती है; एक्सेसर के सार्वजनिक होने के लिए यह अक्सर उपयोगी होता है जबकि म्यूटेटर संरक्षित, पैकेज-निजी या आंतरिक रहता है।

वह ब्लॉक (प्रोग्रामिंग) जहां म्यूटेटर परिभाषित किया गया है, आने वाले डेटा के सत्यापन या प्रीप्रोसेसिंग का अवसर प्रदान करता है। यदि सभी बाहरी पहुंच को म्यूटेटर के माध्यम से आने की गारंटी दी जाती है, तो इन चरणों को बायपास नहीं किया जा सकता है। उदाहरण के लिए, यदि किसी दिनांक को अलग-अलग निजी,   और   के चर द्वारा दर्शाया जाता है, तो आने वाली तिथियों को   म्यूटेटर द्वारा विभाजित किया जा सकता है, जबकि निरंतरता के लिए समान निजी उदाहरण चर को   और   द्वारा एक्सेस किया जाता है। सभी मामलों में 1 - 12 के बाहर के महीने के मूल्यों को उसी कोड द्वारा अस्वीकार किया जा सकता है।

एक्सेसर्स इसके विपरीत आंतरिक चर से उपयोगी डेटा अभ्यावेदन के संश्लेषण की अनुमति देते हैं जबकि उनकी संरचना को बाहरी मॉड्यूल से अलग और छिपा हुआ रखते हैं। एक मौद्रिक  एक्सेसर एक छिपे हुए   पैरामीटर द्वारा परिभाषित दशमलव स्थानों की संख्या के साथ एक संख्यात्मक चर से एक स्ट्रिंग बना सकता है।

आधुनिक प्रोग्रामिंग भाषाएं अक्सर एक ही पंक्ति में म्यूटेटर और एक्सेसर्स के लिए बॉयलरप्लेट कोड उत्पन्न करने की क्षमता प्रदान करती हैं - उदाहरण के लिए C#'s और रूबी का   इन मामलों में, सत्यापन, प्रीप्रोसेसिंग या संश्लेषण के लिए कोई कोड ब्लॉक नहीं बनाया जाता है। ये सरलीकृत एक्सेसर्स अभी भी सरल सार्वजनिक उदाहरण चर पर एनकैप्सुलेशन के लाभ को बरकरार रखते हैं, लेकिन यह सामान्य है कि जैसे-जैसे सिस्टम डिजाइन प्रगति करता है, सॉफ्टवेयर बनाए रखा जाता है और आवश्यकताएं बदलती हैं, डेटा की मांग अधिक परिष्कृत हो जाती है। कई स्वचालित म्यूटेटर और एक्सेसर्स अंततः कोड के अलग-अलग ब्लॉकों द्वारा प्रतिस्थापित किए जाते हैं। कार्यान्वयन के शुरुआती दिनों में उन्हें स्वचालित रूप से बनाने का लाभ यह है कि वर्ग का सार्वजनिक इंटरफ़ेस समान रहता है चाहे अधिक परिष्कार जोड़ा जाए या नहीं, यदि कोई व्यापक रिफैक्टरिंग की आवश्यकता नहीं है।

कक्षा के अंदर से म्यूटेटर और एक्सेसर्स वाले पैरामीटर का हेरफेर जहां उन्हें परिभाषित किया जाता है, उन्हें अक्सर कुछ अतिरिक्त विचार की आवश्यकता होती है। कार्यान्वयन के शुरुआती दिनों में, जब इन ब्लॉकों में बहुत कम या कोई अतिरिक्त कोड नहीं होता है, तो इससे कोई फर्क नहीं पड़ता कि निजी इंस्टेंस चर को सीधे एक्सेस किया गया है या नहीं। सत्यापन के रूप में, क्रॉस-वैलिडेशन (सांख्यिकी) | क्रॉस-वैलिडेशन, डेटा इंटीग्रिटी चेक, प्रीप्रोसेसिंग या अन्य परिष्कार जोड़ा जाता है, सूक्ष्म सॉफ्टवेयर बग प्रकट हो सकता है जहां कुछ आंतरिक पहुंच नए कोड का उपयोग करती है जबकि अन्य स्थानों पर इसे बायपास किया जाता है।

इसमें शामिल अतिरिक्त चरणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं, हालाँकि ऐसे कार्य अक्सर इनलाइन फ़ंक्शन होते हैं जो फ़ंक्शन कॉल के ओवरहेड को समाप्त कर देते हैं।

सभा
<वाक्यविन्यास प्रकाश लैंग = nasm> छात्र संरचना उम्र डीडी? छात्र समाप्त  <वाक्यविन्यास प्रकाश लैंग = nasm> कोड स्टूडेंट_गेट_एज प्रो ऑब्जेक्ट:DWORD मूव ईबीएक्स, ऑब्जेक्ट मूव ईएक्स, स्टूडेंट.एज[ईबीएक्स] गीला करना स्टूडेंट_गेट_एज एंडप

स्टूडेंट_सेट_एज प्रो ऑब्जेक्ट: DWORD, आयु: DWORD मूव ईबीएक्स, ऑब्जेक्ट मूव ईएक्स, उम्र मूव स्टूडेंट.एज [ईबीएक्स], ईएक्स गीला करना छात्र_सेट_आयु अंत 

सी
फ़ाइल छात्र में। एच: <वाक्यविन्यास लैंग = सी>
 * 1) ifndef _STUDENT_H
 * 2) STUDENT_H को परिभाषित करें

संरचना छात्र; / * अपारदर्शी संरचना * / टाइपपीफ संरचना छात्र छात्र;

छात्र * छात्र_ नया (अंतर आयु, चार * नाम); शून्य छात्र_डिलीट (छात्र * एस);

शून्य छात्र_सेट_एज (छात्र * एस, इंट आयु); इंट स्टूडेंट_गेट_एज (स्टूडेंट * एस); चार * छात्र_गेट_नाम (छात्र * एस);


 * 1) अगर अंत

फ़ाइल छात्र.सी में: <वाक्यविन्यास लैंग = सी>
 * 1) शामिल 
 * 2) शामिल 
 * 3) छात्र शामिल करें

संरचना छात्र { अंतर आयु; नौकरानी का नाम; };

छात्र * छात्र_ नया (पूर्णांक आयु, चार * नाम) { छात्र * एस = मॉलोक (आकार (छात्र)); एस-> नाम = strdup (नाम); s->उम्र = आयु; वापसी एस; }

शून्य छात्र_हटाएं (छात्र *) { मुक्त (एस-> नाम); मुफ़्त (ओं); }

शून्य छात्र_सेट_उम्र (छात्र *s, अंतर उम्र) { s->उम्र = आयु; }

इंट स्टूडेंट_गेट_एज (स्टूडेंट * एस) { वापसी एस-> उम्र; }

चार * छात्र_गेट_नाम (छात्र * एस) { वापसी एस-> नाम; } 

फ़ाइल main.c में: <वाक्यविन्यास लैंग = सी>
 * 1) शामिल 
 * 2) छात्र शामिल करें

पूर्णांक मुख्य (शून्य) { छात्र *s = छात्र_नया (19, मौरिस); चार * नाम = छात्र_नाम_नाम; int old_age = छात्र_get_age(s); प्रिंटफ (% s की वृद्धावस्था =% i \ n, नाम, Old_age); छात्र_सेट_उम्र (एस, 21); int new_age = छात्र_प्राप्त_उम्र; प्रिंटफ (% s की नई आयु =% i \ n, नाम, new_age); छात्र_हटाएं; वापसी 0; } 

फ़ाइल मेकफ़ाइल में: <वाक्यविन्यास लैंग = मेकफाइल> सब: out.txt; बिल्ली $< out.txt: मुख्य; ./$< > $@ मुख्य: main.o छात्र.o main.o छात्र.o: छात्र.एच साफ: ;$(RM) *.o out.txt main 

सी ++
फ़ाइल छात्र में। एच: <वाक्यविन्यास लैंग = सीपीपी>
 * 1) ifndef STUDENT_H
 * 2) छात्र_एच को परिभाषित करें


 * 1) शामिल <स्ट्रिंग>

कक्षा छात्र { जनता: छात्र (स्थिरांक एसटीडी :: स्ट्रिंग और नाम);

स्थिरांक एसटीडी :: स्ट्रिंग और नाम स्थिरांक; शून्य नाम (स्थिरांक एसटीडी :: स्ट्रिंग और नाम);

निजी: एसटीडी :: स्ट्रिंग नाम_; };

 फ़ाइल में छात्र.सीपीपी: <वाक्यविन्यास लैंग = सीपीपी>
 * 1) अगर अंत
 * 1) शामिल छात्र। एच

छात्र :: छात्र (स्थिरांक एसटीडी :: स्ट्रिंग और नाम): नाम_ (नाम) { }

स्थिरांक एसटीडी :: स्ट्रिंग और छात्र :: नाम स्थिरांक { वापसी का नाम_; }

शून्य छात्र :: नाम (स्थिरांक एसटीडी :: स्ट्रिंग और नाम) { नाम_ = नाम; } 

सी#
यह उदाहरण C Sharp (प्रोग्रामिंग लैंग्वेज)|C# प्रॉपर्टी के विचार (प्रोग्रामिंग)#C# को दिखाता है, जो एक विशेष प्रकार के क्लास (कंप्यूटर साइंस) सदस्य हैं। जावा के विपरीत, कोई स्पष्ट तरीके परिभाषित नहीं हैं; एक सार्वजनिक 'संपत्ति' में क्रियाओं को संभालने के लिए तर्क होता है। बिल्ट-इन (अघोषित) वेरिएबल के उपयोग पर ध्यान दें.

<वाक्यविन्यास प्रकाश लैंग = csharp> सार्वजनिक वर्ग छात्र {   निजी स्ट्रिंग नाम;

/// <सारांश> /// छात्र का नाम प्राप्त या सेट करता है ///  सार्वजनिक स्ट्रिंग नाम {       प्राप्त करें {वापसी का नाम; } सेट {नाम = मान; } } } 

बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर घोषित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है.

<वाक्यविन्यास प्रकाश लैंग = csharp> सार्वजनिक वर्ग छात्र {   सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; तय करना; } } 

संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित चर अब कक्षा के अंदर से उपलब्ध नहीं है। परिणामस्वरूप, द  संपत्ति का हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को a से प्रतिबंधित किया जा सकता है  विशिष्ट पहुँच संशोधक। <वाक्यविन्यास प्रकाश लैंग = csharp> सार्वजनिक वर्ग छात्र {   सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; निजी सेट; } } 

सामान्य लिस्प
कॉमन लिस्प ऑब्जेक्ट सिस्टम में, क्लास परिभाषाओं के भीतर स्लॉट स्पेसिफिकेशंस इनमें से किसी को भी निर्दिष्ट कर सकते हैं,   और   पाठक विधियों, सेटर विधियों और एक्सेसर विधियों (एक पाठक विधि और संबंधित   तरीका)। के उपयोग के साथ स्लॉट हमेशा उनके नाम के माध्यम से सीधे पहुंच योग्य होते हैं   और  , और स्लॉट एक्सेसर विकल्प उपयोग करने वाली विशेष विधियों को परिभाषित करते हैं. सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं  विकल्प। निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है: <वाक्यविन्यास प्रकाश लैंग = लिस्प> (डिफक्लास छात्र  ((नाम: initarg: नाम: initform: एक्सेसर छात्र-नाम); छात्र-नाम सेट करने योग्य है (जन्मतिथि :initarg :जन्मतिथि :initform 0 :पाठक छात्र-जन्मतिथि) (संख्या:initarg:संख्या:initform 0:पाठक छात्र-संख्या:लेखक सेट-छात्र-संख्या))

(defmethod छात्र-आयु ((स्वयं छात्र)) (- (प्राप्त-सार्वभौमिक-समय) (विद्यार्थी-जन्मतिथि स्वयं)))
 * एक परिकलित संपत्ति प्राप्तकर्ता का उदाहरण (यह केवल एक विधि है)

(defmethod (सेटफ स्टूडेंट-एज) (न्यू-एज (सेल्फ स्टूडेंट)) (साथ-स्लॉट्स (जन्मतिथि) स्व (सेटफ जन्मतिथि (- (गेट-यूनिवर्सल-टाइम) न्यू-एज)) नया जमाना))
 * परिकलित प्रॉपर्टी सेटर के भीतर डायरेक्ट स्लॉट एक्सेस का उदाहरण

(defmethod सेट-छात्र-संख्या: पहले (नया-नंबर (स्वयं छात्र)) ;; आप यह भी जांच सकते हैं कि नए नंबर वाला छात्र पहले से मौजूद है या नहीं।  (चेक-टाइप न्यू-नंबर (पूर्णांक 1 *))) 
 * स्लॉट एक्सेसिंग विकल्प विधियों को उत्पन्न करते हैं, इस प्रकार आगे की विधि परिभाषाओं की अनुमति देते हैं

डी
डी (प्रोग्रामिंग भाषा) एक गेट्टर और सेटर फंक्शन सिंटैक्स का समर्थन करता है। भाषा गेट्टर और सेटर वर्ग/संरचना विधियों के संस्करण 2 में होना चाहिए  गुण। <वाक्यविन्यास प्रकाश लैंग = डी> कक्षा छात्र { निजी चार [] नाम_; // गेट्टर @ संपत्ति चार [] नाम { इसे वापस करें। नाम_; }   // सेटर @ संपत्ति चार [] नाम (चार [] नाम_इन) { इसे वापस करें। नाम_ = नाम_इन; } } </वाक्यविन्यास हाइलाइट> ए  उदाहरण इस तरह इस्तेमाल किया जा सकता है: <वाक्यविन्यास प्रकाश लैंग = डी> ऑटो छात्र = नया छात्र; छात्र.नाम = डेविड; // छात्र.नाम के समान प्रभाव (डेविड) ऑटो छात्र_नाम = छात्र.नाम; // छात्र के समान प्रभाव। नाम </वाक्यविन्यास हाइलाइट>

डेल्फी
यह डेल्फी भाषा में एक साधारण वर्ग है जो एक निजी क्षेत्र तक पहुँचने के लिए सार्वजनिक संपत्ति की अवधारणा को दर्शाता है।

<वाक्यविन्यास लैंग = डेल्फी> इंटरफेस

प्रकार टीस्टूडेंट = क्लास सख्त निजी FName: स्ट्रिंग; प्रक्रिया सेटनाम (स्थिरांक मान: स्ट्रिंग); जनता /// <सारांश> /// छात्र का नाम प्राप्त करें या सेट करें। /// </ सारांश> संपत्ति का नाम: स्ट्रिंग पढ़ें FName लिखें SetName; अंत;

// ...

कार्यान्वयन

प्रक्रिया TStudent.SetName (स्थिरांक मान: स्ट्रिंग); शुरू एफनाम := मान; अंत;

अंत। </वाक्यविन्यास हाइलाइट>

जावा
एक सरल वर्ग (कंप्यूटर विज्ञान) के इस उदाहरण में एक छात्र का प्रतिनिधित्व करते हुए केवल नाम संग्रहीत किया गया है, कोई देख सकता है कि चर (प्रोग्रामिंग) नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और सेटर और गेट्टर सार्वजनिक हैं, अर्थात् और तरीके। <वाक्यविन्यास प्रकाश लैंग = जावा> पब्लिक क्लास स्टूडेंट { निजी स्ट्रिंग नाम;

सार्वजनिक स्ट्रिंग getName { वापसी का नाम; }   सार्वजनिक शून्य सेटनाम (स्ट्रिंग नया नाम) { नाम = नया नाम; } }

जावास्क्रिप्ट
इस उदाहरण में कंस्ट्रक्टर-फ़ंक्शन  केवल संग्रहीत नाम वाले छात्र का प्रतिनिधित्व करने वाली वस्तुओं को बनाने के लिए उपयोग किया जाता है। <वाक्यविन्यास लैंग = जावास्क्रिप्ट> समारोह छात्र (नाम) { वर _नाम = नाम;

यह getName = फ़ंक्शन { वापसी नाम; };

यह सेटनाम = फ़ंक्शन (मान) { _नाम = मूल्य; }; } </वाक्यविन्यास हाइलाइट> या (वेब ​​ब्राउज़र में एक्सेसर्स को परिभाषित करने के लिए बहिष्कृत तरीके का उपयोग करके): <वाक्यविन्यास लैंग = जावास्क्रिप्ट> कार्य छात्र (नाम) { वर _नाम = नाम; this.__defineGetter__('name', function {       वापसी नाम;    }); this.__defineSetter__('name', function(value) {       _नाम = मूल्य;    }); } </वाक्यविन्यास हाइलाइट> या (वंशानुक्रम और ES6 एक्सेसर सिंटैक्स के लिए प्रोटोटाइप का उपयोग करके): <वाक्यविन्यास लैंग = जावास्क्रिप्ट> कार्य छात्र (नाम) { यह._नाम = नाम; }

छात्र.प्रोटोटाइप = { नाम प्राप्त करें { इसे वापस करो._नाम; },   सेट नाम (मान) { यह._नाम = मूल्य; } }; </वाक्यविन्यास हाइलाइट> या (प्रोटोटाइप का उपयोग किए बिना): <वाक्यविन्यास लैंग = जावास्क्रिप्ट> वार छात्र = { नाम प्राप्त करें { इसे वापस करो._नाम; },   सेट नाम (मान) { यह._नाम = मूल्य; } }; </वाक्यविन्यास हाइलाइट> या (डिफाइनप्रॉपर्टी का उपयोग करके): <वाक्यविन्यास लैंग = जावास्क्रिप्ट> कार्य छात्र (नाम) { यह._नाम = नाम; } Object.defineProperty(Student.prototype, 'name', {   प्राप्त करें: फ़ंक्शन  {        इसे वापस करो._नाम;    },    सेट करें: फ़ंक्शन (मान) {        यह._नाम = मूल्य;    } }); </वाक्यविन्यास हाइलाइट>

एक्शनस्क्रिप्ट 3.0
<वाक्यविन्यास लैंग = क्रियालेख> पैकेट {   सार्वजनिक वर्ग छात्र {       निजी संस्करण _नाम: स्ट्रिंग;

सार्वजनिक कार्य नाम प्राप्त करें : String {           वापसी नाम; }

सार्वजनिक फ़ंक्शन सेट नाम (मान: स्ट्रिंग): शून्य {           _नाम = मूल्य; }   } } </वाक्यविन्यास हाइलाइट>

उद्देश्य-सी
उबंटू संस्करण इतिहास # 1204 | उबंटू 12.04 पर जीएनयूस्टेप पर काम करने वाले मैनुअल संदर्भ गिनती के साथ पारंपरिक ऑब्जेक्टिव-सी 1.0 सिंटैक्स का उपयोग करना: <वाक्यविन्यास हाइलाइट लैंग = ओबीजेसी> @इंटरफेस छात्र: एनएसओब्जेक्ट {   एनएसएसटींग *_नाम; }

- (एनएसएसटींग *) नाम; - (शून्य) सेटनाम: (एनएसएसटींग *) नाम;

@अंत

@ कार्यान्वयन छात्र

- (एनएसएसटींग *) नाम {   वापसी नाम; }

- (शून्य) सेटनाम: (एनएसएसटींग *) नाम {   [_नाम रिलीज]; _नाम = [नाम बनाए रखें]; }

@अंत </वाक्यविन्यास हाइलाइट> Mac OS X 10.6, iOS 4 और Xcode 3.2 में उपयोग किए गए नए Objective-C 2.0 सिंटैक्स का उपयोग करते हुए, ऊपर बताए अनुसार समान कोड जनरेट करना: <वाक्यविन्यास हाइलाइट लैंग = ओबीजेसी> @इंटरफेस छात्र: एनएसओब्जेक्ट

@ संपत्ति (गैर-परमाणु, बनाए रखें) एनएसएसटींग * नाम;

@अंत

@ कार्यान्वयन छात्र

@synthesize नाम = _name;

@अंत </वाक्यविन्यास हाइलाइट> और OS X 10.8 और iOS 6 से शुरू करते हुए, Xcode 4.4 और ऊपर का उपयोग करते हुए, सिंटैक्स को और भी सरल बनाया जा सकता है: <वाक्यविन्यास हाइलाइट लैंग = ओबीजेसी> @इंटरफेस छात्र: एनएसओब्जेक्ट

@ संपत्ति (गैर-परमाणु, मजबूत) एनएसएसटींग * नाम;

@अंत

@ कार्यान्वयन छात्र

// यहां कुछ नहीं जाता है और यह ठीक है।

@अंत </वाक्यविन्यास हाइलाइट>

पर्ल
<वाक्यविन्यास प्रकाश लैंग = पर्ल> पैकेज छात्र;

उप नया { आशीर्वाद {}, शिफ्ट; }

उप सेट_नाम { मेरा $ स्व = शिफ्ट; $self->{name} = $_[0]; }

उप get_name { मेरा $ स्व = शिफ्ट; वापसी $ स्वयं-> {नाम}; }

1; </वाक्यविन्यास हाइलाइट>

या, कक्षा :: एक्सेसर का उपयोग करना <वाक्यविन्यास प्रकाश लैंग = पर्ल> पैकेज छात्र; आधार क्यूडब्ल्यू (कक्षा :: एक्सेसर) का उपयोग करें; __पैकेज__->का पालन_सर्वश्रेष्ठ_अभ्यास;

छात्र-> mk_accessors (qw (नाम));

1; </वाक्यविन्यास हाइलाइट>

या, मूस (पर्ल) का उपयोग करना: <वाक्यविन्यास प्रकाश लैंग = पर्ल> पैकेज छात्र; मूस का प्रयोग करें;

है 'नाम' => (is => 'rw', isa => 'Str', रीडर => 'get_name', लेखक => 'set_name');
 * 1) मूस विशेषता नाम का उपयोग सेटर और गेट्टर, पाठक और लेखक गुणों के रूप में करता है
 * 2) हमें इसे ओवरराइड करने की अनुमति दें और हमारे अपने नाम प्रदान करें, इस मामले में get_name और set_name

1; </वाक्यविन्यास हाइलाइट>

पीएचपी
PHP जादू के तरीकों को परिभाषित करती है और  वस्तुओं के गुणों के लिए। एक सरल वर्ग (कंप्यूटर विज्ञान) के इस उदाहरण में एक छात्र का प्रतिनिधित्व करने वाला केवल नाम संग्रहीत है, कोई देख सकता है कि चर (प्रोग्रामिंग) नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और सेटर और गेट्टर सार्वजनिक है, अर्थात्  और   तरीके। <वाक्यविन्यास लैंग = php> वर्ग छात्र {   निजी स्ट्रिंग $ नाम;

/**    * @return स्ट्रिंग नाम। */   सार्वजनिक समारोह getName : स्ट्रिंग {       वापसी $ यह-> नाम; }

/**    * @ अपरम स्ट्रिंग $ नया नाम सेट करने के लिए नाम। */   सार्वजनिक फ़ंक्शन सेटनाम (स्ट्रिंग $ नया नाम): शून्य {       $ यह-> नाम = $ नया नाम; } }

पायथन
यह उदाहरण एक चर, एक गेट्टर और एक सेटर के साथ एक पायथन वर्ग का उपयोग करता है।

<वाक्यविन्यास लैंग = अजगर> कक्षा छात्र: # प्रारंभकर्ता def __init__(स्वयं, नाम: str) -> कोई नहीं: # छात्र का नाम धारण करने के लिए एक उदाहरण चर स्व._नाम = नाम

# गेट्टर विधि @संपत्ति डीईएफ़ नाम (स्वयं): स्व._नाम वापस करें

# सेटर विधि @ नाम.सेटर डीईएफ़ नाम (स्वयं, new_name): स्व._नाम = नया_नाम </वाक्यविन्यास हाइलाइट> <वाक्यविन्यास लैंग = पिकॉन> >>> बॉब = छात्र (बॉब) >>> बॉब.नाम बीओबी >>> बॉब.नाम = ऐलिस >>> बॉब.नाम ऐलिस >>> बॉब._नाम = चार्ली # सेटर को बायपास करें >>> बॉब._नाम # गेट्टर को बायपास करें चार्ली </वाक्यविन्यास हाइलाइट>

रैकेट
रैकेट (प्रोग्रामिंग भाषा) में, ऑब्जेक्ट सिस्टम कोड को व्यवस्थित करने का एक तरीका है जो मॉड्यूल और यूनिट के अतिरिक्त आता है। बाकी भाषा की तरह, ऑब्जेक्ट सिस्टम में प्रथम श्रेणी के मान हैं और वस्तुओं और विधियों तक पहुंच को नियंत्रित करने के लिए लेक्सिकल स्कोप का उपयोग किया जाता है।

<वाक्यविन्यास प्रकाश लैंग = रैकेट> (छात्र% परिभाषित करें (वर्ग वस्तु% (इनिट-फ़ील्ड नाम) (परिभाषित/सार्वजनिक (गेट-नाम) नाम) (परिभाषित/सार्वजनिक (सेट-नाम! नया-नाम) (सेट! नाम नया-नाम)) (सुपर-न्यू)))
 * 1) लैंग रैकेट

(एस परिभाषित करें (नया छात्र% [एलिस नाम])) (एस गेट-नाम भेजें); => ऐलिस (एस सेट-नाम भेजें! बॉब) (एस गेट-नाम भेजें); => बॉब </वाक्यविन्यास हाइलाइट>

संरचनात्मक परिभाषाएँ नए प्रकार के मूल्यों को परिभाषित करने का एक वैकल्पिक तरीका है, जब स्पष्ट रूप से आवश्यक होने पर म्यूटेटर मौजूद होते हैं: <वाक्यविन्यास प्रकाश लैंग = रैकेट> (संरचना छात्र (नाम) #: परिवर्तनशील) (एस परिभाषित करें (छात्र ऐलिस)) (सेट-छात्र-नाम! एस बॉब) (छात्र-नाम एस); => बॉब </वाक्यविन्यास हाइलाइट>
 * 1) लैंग रैकेट

रूबी
रूबी (प्रोग्रामिंग भाषा) में, अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित किया जा सकता है, या मेटाप्रोग्रामिंग निर्माण  या   कक्षा में एक निजी चर घोषित करने के लिए और क्रमशः पढ़ने-योग्य या पढ़ने-लिखने के लिए सार्वजनिक पहुंच प्रदान करने के लिए दोनों का उपयोग किया जा सकता है।

अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित करने से डेटा के पूर्व-प्रसंस्करण या सत्यापन के लिए जगह बनती है <वाक्यविन्यास लैंग = रूबी> वर्ग छात्र डीईएफ़ नाम @नाम अंत

डीईएफ़ नाम = (मान) @ नाम = मूल्य अंत अंत </वाक्यविन्यास हाइलाइट>

निहित करने के लिए केवल-पढ़ने के लिए सरल सार्वजनिक पहुँच  चर <वाक्यविन्यास लैंग = रूबी> वर्ग छात्र attr_reader : नाम अंत </वाक्यविन्यास हाइलाइट>

निहित करने के लिए पढ़ें-लिखें सरल सार्वजनिक पहुँच  चर <वाक्यविन्यास लैंग = रूबी> वर्ग छात्र attr_accessor : नाम अंत </वाक्यविन्यास हाइलाइट>

जंग
<वाक्यविन्यास प्रकाश लैंग = जंग> संरचना छात्र { नाम: स्ट्रिंग, }

इम्प्ल छात्र { एफएन नाम (और स्वयं) -> और स्ट्रिंग { &self.name }

fn set_name(&म्यूट स्व, नाम: स्ट्रिंग) { स्व.नाम = नाम } } </वाक्यविन्यास हाइलाइट>

स्मालटॉक
<वाक्यविन्यास लैंग = स्मॉलटॉक> आयु: एक संख्या यदि 0 से अधिक और 150 से कम है तो रिसीवर की आयु एक संख्या के रूप में सेट करें (बीच की संख्या: 0 और: 150) ifTrue: [आयु := एक संख्या] </वाक्यविन्यास हाइलाइट>

तेज
<वाक्यविन्यास प्रकाश लैंग = तेज> कक्षा छात्र { निजी संस्करण _नाम: स्ट्रिंग =

वर नाम: स्ट्रिंग { पाना { स्व._नाम वापस करें }       तय करना { स्व._नाम = नया मूल्य }   } } </वाक्यविन्यास हाइलाइट>

विजुअल बेसिक .NET
यह उदाहरण कक्षाओं में उपयोग किए जाने वाले गुणों के VB.NET विचार को दिखाता है। C# के समान, इसका एक स्पष्ट उपयोग है  और   तरीके।

<वाक्यविन्यास लैंग = वीबी>

पब्लिक क्लास स्टूडेंट

निजी _नाम स्ट्रिंग के रूप में

सार्वजनिक संपत्ति का नाम पाना रिटर्न _नाम अंत प्राप्त करें सेट करें (बायवैल वैल्यू) _नाम = मूल्य अंत सेट संपत्ति समाप्त करें

अंत वर्ग

</वाक्यविन्यास हाइलाइट>

VB.NET 2010 में, Get और Set सिंटैक्स का उपयोग किए बिना एक संपत्ति बनाने के लिए ऑटो इम्प्लीमेंटेड गुणों का उपयोग किया जा सकता है। ध्यान दें कि एक छुपा चर संकलक द्वारा बनाया गया है, जिसे कहा जाता है, संपत्ति के साथ मेल खाने के लिए. नामित वर्ग के भीतर एक अन्य चर का उपयोग करना  एक त्रुटि में परिणाम होगा। अंतर्निहित चर के लिए विशेषाधिकार प्राप्त पहुँच कक्षा के भीतर से उपलब्ध है।

<वाक्यविन्यास लैंग = वीबी>

पब्लिक क्लास स्टूडेंट सार्वजनिक संपत्ति का नाम स्ट्रिंग के रूप में अंत वर्ग

</वाक्यविन्यास हाइलाइट>

यह भी देखें

 * संपत्ति (प्रोग्रामिंग)
 * अनुक्रमणिका (प्रोग्रामिंग)
 * अपरिवर्तनीय वस्तु