Getters සහ setters / accessors භාවිතා කරන්නේ ඇයි?

එම විචල්යයන් සඳහා පොදු ක්ෂේත්ර භාවිතා කිරීම වෙනුවට, ලබා ගන්නා සහ සැකසෙන - ලබා ගන්නන් සහ සැකසුම් භාවිතා කිරීමේ වාසිය කුමක්ද?

ලබා ගන්නන් සහ සැකසුම් කරන්නන් සරල ලබා ගැනීම / සැකසීමට වඩා වැඩි යමක් කරන්නේ නම්, මට මෙය ඉතා ඉක්මණින් හදුනාගත හැකිය, නමුත් කෙසේද යන්න පිළිබඳව මට 100% පැහැදිලි නැත:

public String foo;

ඊට වඩා නරක ය:

private String foo;
public void setFoo(String foo) { this.foo = foo; }
public String getFoo() { return foo; }

කලින් සඳහන් කළ බොයිලේරු කේතය අඩුය.

පංතියක ක්ෂේත්‍ර කෙලින්ම නිරාවරණය කරනවාට වඩා ප්‍රවේශයන් භාවිතා කිරීම ගැන සලකා බැලීමට ඇත්ත වශයෙන්ම බොහෝ හොඳ හේතු තිබේ - සංක්ෂිප්ත තර්කයෙන් ඔබ්බට ගොස් අනාගත වෙනස්කම් පහසු කිරීම.

මා දන්නා හේතු කිහිපයක් මෙන්න:

• දේපල ලබා ගැනීම හෝ සැකසීම හා සම්බන්ධ හැසිරීම් සංවර්‍ධනය කිරීම - මෙය අතිරේක ක්‍රියාකාරිත්වය (වලංගු කිරීම වැනි) පසුව වඩාත් පහසුවෙන් එකතු කිරීමට ඉඩ දෙයි.
• විකල්ප නිරූපණයක් භාවිතා කරමින් දේපලක් නිරාවරණය කරන අතරතුර දේපල අභ්‍යන්තර නිරූපණය සැඟවීම.
• ඔබගේ පොදු අතුරුමුහුණත වෙනස් වීමෙන් පරිවරණය කිරීම - පවතින පාරිභෝගිකයින්ට කිසිදු බලපෑමක් නොකර ක්‍රියාත්මක කිරීම වෙනස් වන අතරම පොදු අතුරු මුහුණත නියතව සිටීමට ඉඩ ලබා දේ.
• දේපලවල ආයු කාලය සහ මතක කළමනාකරණය (බැහැර කිරීම) අර්ථ නිරූපණය කිරීම - කළමනාකරණය නොකරන ලද මතක පරිසරවල (C ++ හෝ Objective-C වැනි) විශේෂයෙන් වැදගත් වේ.
• දේපළ ධාවන වේලාවේදී වෙනස් වන විට නිදොස් කිරීමේ මැදිහත්වීමේ ලක්ෂ්‍යයක් සැපයීම - දේපලක් යම් අගයකට වෙනස් කළ විට සහ කොතැනකද යන්න නිදොස් කිරීම සමහර භාෂාවලින් මෙය නොමැතිව තරමක් අපහසු විය හැකිය.
• දේපල ලබා ගන්නන්ට / සැකසුම් කරන්නන්ට එරෙහිව ක්‍රියාත්මක වීමට නිර්මාණය කර ඇති පුස්තකාල සමඟ වැඩිදියුණු කළ අන්තර් ක්‍රියාකාරිත්වය - සමච්චල් කිරීම, අනුක්‍රමිකකරණය සහ WPF මතකයට එයි.
• දේපල හැසිරෙන ආකාරය සහ නිරාවරණය වන ආකාරය පිළිබඳ අර්ථ නිරූපණය වෙනස් කිරීමට උරුමකරුවන්ට ඉඩ දීම.
• වටිනාකම්වලට වඩා ලැම්බඩා ප්‍රකාශන ලෙස ලබා ගන්නට / සැකසීමට ඉඩ දීම.
• Getters සහ setters හට විවිධ ප්‍රවේශ මට්ටම් වලට ඉඩ දිය හැකිය - නිදසුනක් ලෙස ලබා ගැනීම පොදු විය හැකි නමුත් කට්ටලය ආරක්ෂා කළ හැකිය.

මෙතැන් සිට සති 2 ක් (මාස, අවුරුදු) ඔබේ සැකකරුට වටිනාකම නියම කිරීමට වඩා වැඩි යමක් කළ යුතු බව ඔබ වටහා ගත් විට, දේපල වෙනත් පන්ති 238 ක සෘජුවම භාවිතා කර ඇති බව ඔබට වැටහෙනු ඇත :-)

ක්ෂේත්‍රය නැවත ලබා දීම සහ එයට පැවරීම හැර වෙන කිසිවක් නොකරන පොදු ක්ෂේත්‍රයක් ලබා ගන්නෙකු / සැකසුම් යුගලයකට වඩා නරක නැත. පළමුව, (බොහෝ භාෂාවල) ක්‍රියාකාරී වෙනසක් නොමැති බව පැහැදිලිය. ඕනෑම වෙනසක් නඩත්තු කිරීමේ හැකියාව හෝ කියවීමේ හැකියාව වැනි වෙනත් සාධකවල තිබිය යුතුය.

Getter / setter යුගල වල බොහෝ විට සඳහන් වාසියක් නොවේ. ඔබට ක්‍රියාත්මක කිරීම වෙනස් කළ හැකි බවට මෙම ප්‍රකාශය ඇති අතර ඔබේ සේවාදායකයින් නැවත සකස් කිරීම අවශ්‍ය නොවේ. පසුකාලීනව වලංගු කිරීම වැනි ක්‍රියාකාරීත්වයක් එක් කිරීමට සෙටර්ස් ඔබට ඉඩ දෙයි යැයි සිතිය හැකි අතර ඔබේ ගනුදෙනුකරුවන්ට ඒ ගැන දැන ගැනීමට පවා අවශ්‍ය නොවේ. කෙසේ වෙතත්, කට්ටලයකට වලංගු කිරීම එකතු කිරීම එහි පූර්ව කොන්දේසි වලට වෙනස් කිරීමකි, පෙර කොන්ත්‍රාත්තුව උල්ලං violation නය කිරීමකි , එය සරලවම කිවහොත්, “ඔබට ඕනෑම දෙයක් මෙහි තැබිය හැකිය, පසුව ඔබට එයම ලබා ගන්නාගෙන් ලබා ගත හැකිය”.

ඉතින්, දැන් ඔබ කොන්ත්රාත්තුව කඩ කළ නිසා, කේත රචනයේ සෑම ගොනුවක්ම වෙනස් කිරීම ඔබට කළ යුතු දෙයක් මිස වළක්වා නොගත යුතුය. ඔබ එය වළක්වා ගන්නේ නම්, ඔබ උපකල්පනය කරන්නේ සියලු කේතයන් එම ක්‍රම සඳහා වන කොන්ත්‍රාත්තුව වෙනස් යැයි උපකල්පනය කර ඇති බවයි.

එය කොන්ත්‍රාත්තුව නොවිය යුතුව තිබුනේ නම්, අතුරු මුහුණත මඟින් සේවාදායකයින්ට වස්තුව අවලංගු තත්වයට පත් කිරීමට ඉඩ ලබා දෙන ලදි. සංක්ෂිප්තකරණයට හරියටම ප්‍රතිවිරුද්ධ දෙය එයයි. එම ක්ෂේත්‍රය ආරම්භයේ සිටම කිසිවක් සැකසිය නොහැකි නම්, ආරම්භයේ සිටම එහි වලංගු භාවය නොතිබුණේ ඇයි?

මෙම තර්කය මෙම පාස්-හරහා ගෙටර් / සෙටර් යුගලවල වෙනත් යැයි කියනු ලබන වාසි සඳහා ද අදාළ වේ: ඔබ පසුව සැකසූ අගය වෙනස් කිරීමට තීරණය කරන්නේ නම්, ඔබ කොන්ත්රාත්තුව කඩ කරයි. ව්‍යුත්පන්න පංතියක පෙරනිමි ක්‍රියාකාරිත්වය ඔබ ඉක්මවා ගියහොත්, හානිකර නොවන වෙනස් කිරීම් කිහිපයකින් ඔබ්බට (ලොග් වීම හෝ නිරීක්ෂණය කළ නොහැකි වෙනත් හැසිරීම් වැනි), ඔබ මූලික පන්තියේ කොන්ත්‍රාත්තුව කඩ කරයි. එය OO හි එක් මූලධර්මයක් ලෙස සැලකෙන ලිස්කොව් ආදේශක මූලධර්මය උල්ලං is නය කිරීමකි.

පංතියකට සෑම ක්ෂේත්‍රයක් සඳහාම මෙම ගොළු ලබා ගන්නන් සහ සැකසුම් කරුවන් සිටී නම්, එය කිසිදු ආකාරයක වෙනස්කමක් නැති, කොන්ත්‍රාත්තුවක් නොමැති පන්තියකි . එය සැබවින්ම වස්තු-නැඹුරු නිර්මාණයක්ද? පංතියේ ඇති සියල්ලන්ම එම ලබා ගන්නන් සහ සැකසුම් කරුවන් නම්, එය ගොළු දත්ත දරන්නෙකු පමණක් වන අතර ගොළු දත්ත දරන්නන් ගොළු දත්ත දරන්නන් මෙන් විය යුතුය:

class Foo {
public:
    int DaysLeft;
    int ContestantNumber;
};

එවැනි පංතියකට පාස්-හරහා ගෙටර් / සෙටර් යුගල එකතු කිරීමෙන් කිසිදු වටිනාකමක් එක් නොවේ. වෙනත් පංති විසින් ක්ෂේත්‍ර දැනටමත් සපයන මෙහෙයුම් පමණක් නොව අර්ථවත් මෙහෙයුම් සැපයිය යුතුය. ප්‍රයෝජනවත් ආක්‍රමණ නිර්වචනය කර නඩත්තු කළ හැක්කේ එලෙසිනි.

සේවාදායකයා : "මෙම පන්තියේ වස්තුවක් සමඟ මට කුමක් කළ හැකිද?"
නිර්මාණකරු : "ඔබට විචල්යයන් කිහිපයක් කියවා ලිවිය හැකිය."
සේවාදායකයා : "ඔහ් ... නියමයි, මම හිතන්නේ?"

Getters සහ setters භාවිතා කිරීමට හේතු තිබේ, නමුත් එම හේතු නොපවතී නම්, ව්‍යාජ සංකේතාත්මක දෙවිවරුන්ගේ නාමයෙන් getter / setter යුගල සෑදීම හොඳ දෙයක් නොවේ. වලංගු කිරීම් හෝ වෙනස් අභ්‍යන්තර නිරූපණයන් වැනි ඔබට පසුව කළ හැකි විභව වෙනස්කම් ලෙස බොහෝ විට සඳහන් කර ඇති දේ ලබා ගන්නන් හෝ සැකසුම් කරන්නන් සෑදීමට වලංගු හේතු ඇතුළත් වේ. නැතහොත් සමහර විට වටිනාකම සේවාදායකයින්ට කියවිය හැකි නමුත් ලිවිය නොහැකි විය යුතුය (නිදසුනක් ලෙස ශබ්ද කෝෂයක ප්‍රමාණය කියවීම), එබැවින් සරල ලබා ගන්නෙකු හොඳ තේරීමක් වේ. නමුත් ඔබ තෝරාගැනීමේදී එම හේතු තිබිය යුතු අතර පසුව ඔබට අවශ්‍ය විය හැකි දෙයක් ලෙස පමණක් නොවේ. මෙය YAGNI හි උදාහරණයකි ( ඔබට එය අවශ්‍ය නොවේ ).

බොහෝ අය ලබා ගන්නන්ගේ සහ සැකසීමේ වාසි ගැන කතා කළත් මට අවශ්‍ය යක්ෂයාගේ උපදේශකයා ලෙසය. මේ මොහොතේ මම ඉතා විශාල වැඩසටහනක් නිදොස්කරණය කරමි, එහිදී ක්‍රමලේඛකයින් විසින් සෑම දෙයක්ම ලබා ගන්නන් සහ සැකසුම්කරුවන් බවට පත් කිරීමට තීරණය කරන ලදී. එය හොඳ යැයි පෙනේ, නමුත් එය ප්‍රතිලෝම ඉංජිනේරු බියකරු සිහිනයකි.

ඔබ කේත පේළි සිය ගණනක් බලා සිටින බව පවසන්න, ඔබට මෙය හමු වේ:

person.name = "Joe";

ඔබ එය සැකසීමක් තේරුම් ගන්නා තෙක් එය ඉතා සරලව කේත කැබැල්ලකි. දැන්, ඔබ එම සැකසුම අනුගමනය කරන අතර එය පුද්ගලයා ද වේ. පළමු නම, පුද්ගලයා ඔබේ මතක කාන්දු වීම සිදුවෙමින් පවතින තැන.

බැලූ බැල්මට දේශීය කේත කැබැල්ලක් අවබෝධ කර ගැනීම හොඳ කියවීමේ වැදගත් ගුණාංගයක් වන අතර එය ලබා ගන්නන් සහ කට්ටල බිඳීමට නැඹුරු වේ. මට හැකි විට ඒවා වළක්වා ගැනීමට මම උත්සාහ කරන්නේ එබැවිනි, මම ඒවා භාවිතා කරන විට ඔවුන් කරන දේ අවම කරන්න.

නිර්මල වස්තු-නැඹුරු ලෝකයක ලබා ගන්නන් සහ සැකසුම් කරන්නන් භයානක ප්‍රති-රටාවකි . මෙම ලිපිය කියවන්න: Getters / Setters. නපුර. කාල සීමාව . කෙටියෙන් කිවහොත්, දත්ත ව්‍යුහයන් ලෙස වස්තූන් ගැන සිතීමට ඔවුන් ක්‍රමලේඛකයින් දිරිමත් කරන අතර, මෙම ආකාරයේ චින්තනය පිරිසිදු ක්‍රියා පටිපාටියකි (COBOL හෝ C වැනි). වස්තු-නැඹුරු භාෂාවක දත්ත ව්‍යුහයන් නොමැත, නමුත් හැසිරීම හෙළි කරන වස්තූන් පමණි (ගුණාංග / ගුණාංග නොවේ!)

අලංකාර වස්තූන්ගේ 3.5 වන වගන්තියෙන් (වස්තු-නැඹුරු වැඩසටහන්කරණය පිළිබඳ මගේ පොත) ඔබට ඒවා ගැන වැඩි විස්තර සොයාගත හැකිය .

හේතු රාශියක් ඇත. මගේ ප්‍රියතම දෙය නම් ඔබට හැසිරීම වෙනස් කිරීමට හෝ විචල්‍යයක් මත සැකසිය හැකි දේ නියාමනය කිරීමට අවශ්‍ය වූ විටය. උදාහරණයක් ලෙස, ඔබට setSpeed ​​(int speed) ක්‍රමයක් ඇති බව කියමු. නමුත් ඔබට අවශ්‍ය වන්නේ උපරිම වේගය 100 ක් පමණක් සැකසිය හැකි බවයි. ඔබ එවැනි දෙයක් කරනු ඇත:

public void setSpeed(int speed) {
  if ( speed > 100 ) {
    this.speed = 100;
  } else {
    this.speed = speed;
  }
}

දැන් ඔබේ කේතයේ සෑම තැනකම ඔබ පොදු ක්ෂේත්‍රය භාවිතා කරමින් සිටියදී ඔබට ඉහත අවශ්‍යතාවය අවශ්‍ය බව ඔබ තේරුම් ගත්තා නම් කුමක් කළ යුතුද? ඔබගේ සැකසුම වෙනස් කිරීම වෙනුවට පොදු ක්ෂේත්‍රයේ සෑම භාවිතයක්ම විනෝදයෙන් දඩයම් කරන්න.

මගේ ශත 2 :)

ප්රවේශකරුවන්ගේ සහ විකෘති වල එක් වාසියක් නම් ඔබට වලංගුකරණය කළ හැකිය.

උදාහරණයක් ලෙස, fooපොදු නම් , මට එය පහසුවෙන් සැකසිය හැකි nullඅතර පසුව වෙනත් කෙනෙකුට වස්තුව පිළිබඳ ක්‍රමයක් ඇමතීමට උත්සාහ කළ හැකිය. නමුත් එය තවදුරටත් එහි නොමැත! setFooක්‍රමවේදයක් සමඟ , fooඑය කිසි විටෙකත් සකසා නැති බව මට සහතික කළ හැකිය null.

ප්‍රවේශ කරන්නන් සහ විකෘති කරන්නන් ද සංසරණය වීමට ඉඩ දෙයි - ඔබ එහි කට්ටලය වරක් අගය දැකීමට නොසිතන්නේ නම් (සමහර විට එය ඉදිකිරීම්කරු තුළ සකසා පසුව ක්‍රම මඟින් භාවිතා කරනු ලැබේ, නමුත් කිසි විටෙකත් වෙනස් කළ යුතු නොවේ), එය කිසිවෙකු කිසි විටෙකත් නොදකිනු ඇත. නමුත් ඔබට වෙනත් පංතිවලට එය බැලීමට හෝ වෙනස් කිරීමට ඉඩ දිය හැකි නම්, ඔබට නිසි ප්‍රවේශකය සහ / හෝ විකෘති ලබා දිය හැකිය.

ඔබේ භාෂාව මත රඳා පවතී. ඔබ "ජාවා" වෙනුවට මෙම "වස්තු-නැඹුරු" ටැග් කර ඇත, එබැවින් ChssPly76 හි පිළිතුර භාෂාව මත රඳා පවතින බව පෙන්වා දීමට කැමැත්තෙමි. නිදසුනක් ලෙස, පයිතන්හි, ලබා ගන්නන් සහ සැකසුම් භාවිතා කිරීමට හේතුවක් නැත. ඔබට හැසිරීම වෙනස් කිරීමට අවශ්‍ය නම්, ඔබට දේපලක් භාවිතා කළ හැකිය, එමඟින් මූලික ගුණාංග ප්‍රවේශය වටා ගැණුම්කරුවෙකු සහ සැකකරුවෙකු ඔතා ඇත. මේ වගේ දෙයක්:

 class Simple(object):
   def _get_value(self):
       return self._value -1

   def _set_value(self, new_value):
       self._value = new_value + 1

   def _del_value(self):
       self.old_values.append(self._value)
       del self._value

   value = property(_get_value, _set_value, _del_value)

හොඳයි, සමහර විට ඒවා ඔබේ විචල්‍යයන් / වස්තූන් සංයුක්ත කිරීම හා ආරක්ෂාව සඳහා අවශ්‍ය වුවද, අපට සැබෑ වස්තු දිශානත වැඩසටහනක් කේත කිරීමට අවශ්‍ය නම්, අපි ඇක්සෙසරයන් අභිබවා යාම නැවැත්විය යුතුය , සමහර විට අපි බොහෝ දුරට රඳා පවතී ඒවා ඇත්ත වශයෙන්ම අවශ්‍ය නොවන විට ඒවා විචල්‍යයන් පොදු ලෙස තැබුවහොත් එය බොහෝ දුරට සමාන වේ.

ස්තූතියි, එය ඇත්තෙන්ම මගේ චින්තනය පැහැදිලි කළේය. දැන් මෙහි (පාහේ) 10 (පාහේ) හොඳ හේතු ලබා ගන්නන් සහ සැකසුම් භාවිතා නොකිරීමට:

1. ඔබ සැකසීමට හා වටිනාකම ලබා ගැනීමට වඩා වැඩි යමක් කළ යුතු බව ඔබ වටහා ගත් විට, ඔබට ක්ෂේත්‍රය පුද්ගලීකරණය කළ හැකිය, එය ඔබ කෙලින්ම එයට ප්‍රවේශ වූයේ කොතැනට දැයි ක්ෂණිකව ඔබට කියනු ඇත.
   
2. ඔබ එහි සිදු කරන ඕනෑම වලංගු භාවයක් සන්දර්භයෙන් තොර විය හැකි අතර එය වලංගු කිරීම ප්‍රායෝගිකව කලාතුරකිනි.
   
3. ඔබට සකසා ඇති අගය වෙනස් කළ හැකිය - අමතන්නා ඔබට වටිනාකමක් ලබා දෙන විට එය නියත බියකරු සිහිනයකි.
   
4. ඔබට අභ්‍යන්තර නිරූපණය සැඟවිය හැක - අපූරුයි, එබැවින් ඔබ මෙම සියලු මෙහෙයුම් සමමිතික බව සහතික කර ගන්නවාද?
   
5. තහඩු යටතේ සිදුවන වෙනස්කම් වලින් ඔබ ඔබේ පොදු අතුරුමුහුණත පරිවරණය කර ඇත - ඔබ අතුරු මුහුණතක් නිර්මාණය කරමින් සිටියේ නම් සහ යම් දෙයකට access ජු ප්‍රවේශය හරි දැයි විශ්වාස නැත්නම්, ඔබ දිගටම සැලසුම් කළ යුතුව තිබුණි.
   
6. සමහර පුස්තකාල මෙය අපේක්ෂා කරයි, නමුත් බොහෝ නොවේ - පරාවර්තනය, අනුක්‍රමිකකරණය, විහිළු වස්තු සියල්ල පොදු ක්ෂේත්‍ර සමඟ හොඳින් ක්‍රියාත්මක වේ.
   
7. මෙම පංතියට උරුමකම් කියමින්, ඔබට පෙරනිමි ක්‍රියාකාරිත්වය අභිබවා යා හැකිය - වෙනත් වචන වලින් කිවහොත්, ක්‍රියාත්මක කිරීම සැඟවීම පමණක් නොව එය නොගැලපීම මඟින් ඔබට ඇමතුම්කරුවන් ව්‍යාකූල කළ හැකිය.
   

මම දැන් යන අන්තිම තුන (N / A හෝ D / C) ...

මම දන්නවා එය ටිකක් ප්‍රමාදයි, නමුත් මම හිතන්නේ කාර්ය සාධනය ගැන උනන්දුවක් දක්වන සමහර අය සිටිනවා.

මම පොඩි කාර්ය සාධන පරීක්ෂණයක් කළා. මම "අංක හෝල්ඩර්" පන්තියක් ලිව්වා, එය පූර්ණ සංඛ්‍යාවක් දරයි. ලබා ගැනීමේ ක්‍රමය භාවිතා කිරීමෙන් anInstance.getNumber()හෝ එම අංකයට කෙලින්ම ප්‍රවේශ වීමෙන් ඔබට එම පූර්ණ සංඛ්‍යාව කියවිය හැකිය anInstance.number. මගේ ක්‍රමලේඛය දෙයාකාරයෙන්ම අංකය 1,000,000,000 වාරයක් කියවයි. එම ක්‍රියාවලිය පස් වතාවක් පුනරාවර්තනය වන අතර කාලය මුද්‍රණය කෙරේ. මට පහත ප්‍රති result ලය ලැබී ඇත:

Time 1: 953ms, Time 2: 741ms
Time 1: 655ms, Time 2: 743ms
Time 1: 656ms, Time 2: 634ms
Time 1: 637ms, Time 2: 629ms
Time 1: 633ms, Time 2: 625ms

(වේලාව 1 යනු way ජු මාර්ගයයි, වේලාව 2 ලබා ගන්නා තැනැත්තා වේ)

ඔබට පෙනේ, ලබා ගන්නා තැනැත්තා සෑම විටම මඳක් වේගවත් ය. ඊට පස්සේ මම විවිධ චක්‍ර ගණනින් උත්සාහ කළා. මිලියනයක් වෙනුවට මම මිලියන 10 ක් සහ මිලියන 0.1 ක් භාවිතා කළෙමි. ප්රතිඵල:

චක්‍ර මිලියන 10 ක්:

Time 1: 6382ms, Time 2: 6351ms
Time 1: 6363ms, Time 2: 6351ms
Time 1: 6350ms, Time 2: 6363ms
Time 1: 6353ms, Time 2: 6357ms
Time 1: 6348ms, Time 2: 6354ms

චක්‍ර මිලියන 10 ක් සමඟ, කාලය බොහෝ දුරට සමාන වේ. මෙන්න චක්‍ර 100,000 (මිලියන 0.1):

Time 1: 77ms, Time 2: 73ms
Time 1: 94ms, Time 2: 65ms
Time 1: 67ms, Time 2: 63ms
Time 1: 65ms, Time 2: 65ms
Time 1: 66ms, Time 2: 63ms

එසේම විවිධ ප්‍රමාණයේ චක්‍ර සමඟ, ලබා ගන්නා තැනැත්තා සාමාන්‍ය ක්‍රමයට වඩා ටිකක් වේගවත් වේ. මෙය ඔබට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

ඔබගේ වර්තමාන භාරදීම සඳහා අවශ්‍ය නම් මිස ගෙටර්ස් සෙටර් භාවිතා නොකරන්න. අනාගතයේ කුමක් සිදුවේද යන්න ගැන ඕනෑවට වඩා නොසිතන්න.

සරල, පහසු යැයි සිතන්න, අවශ්‍ය විටදී සංකීර්ණත්වය එක් කරන්න.

ගැඹුරු තාක්‍ෂණික දැනුමක් ඇති ව්‍යාපාරික අයිතිකරුවන්ගේ නොදැනුවත්කමෙන් මම ප්‍රයෝජන නොගන්නේ එය නිවැරදි යැයි මා සිතන නිසා හෝ මම ප්‍රවේශයට කැමති නිසා ය.

මා සතුව දැවැන්ත පද්ධතියක් ඇත්තේ ප්‍රවේශක සැකසුම් කරුවන් නොමැතිව ප්‍රවේශ විකරණකාරක සහ n වලංගු කිරීම සඳහා ක්‍රම කිහිපයක් පමණි. ඔබට නියත වශයෙන්ම අවශ්‍ය නම්. ඕනෑම දෙයක් භාවිතා කරන්න.

අපි getters සහ setters භාවිතා කරමු:

• නැවත භාවිතා කිරීම සඳහා
• ක්‍රමලේඛනයේ පසුකාලීන අවස්ථා වලදී වලංගු කිරීම සිදු කිරීම

පුද්ගලික පන්ති සාමාජිකයින්ට ප්‍රවේශ වීම සඳහා පොදු අතුරු මුහුණත් වේ.

සංක්ෂිප්ත මන්ත්‍රය

සංවෘත මන්ත්‍රය නම් ක්ෂේත්‍ර පුද්ගලික හා ක්‍රමවේදයන් පොදු කිරීමයි.

ලබා ගැනීමේ ක්‍රම: අපට පුද්ගලික විචල්‍යයන් වෙත ප්‍රවේශය ලබා ගත හැකිය.

සැකසුම් ක්‍රම: අපට පුද්ගලික ක්ෂේත්‍ර වෙනස් කළ හැකිය.

ලබා ගන්නා සහ සැකසීමේ ක්‍රම නව ක්‍රියාකාරිත්වයක් එක් නොකළද, අපගේ මනස වෙනස් කර පසුව එම ක්‍රමය සකස් කර ගත හැකිය

• වඩා හොඳ;
• ආරක්ෂිත; සහ
• ඉක්මනින්.

වටිනාකමක් භාවිතා කළ හැකි ඕනෑම තැනක, එම අගය නැවත ලබා දෙන ක්‍රමයක් එකතු කළ හැකිය. වෙනුවට:

int x = 1000 - 500

භාවිත

int x = 1000 - class_name.getValue();

ගිහියන්ගේ අර්ථයෙන්

අපි මේ පිළිබඳ තොරතුරු ගබඩා කළ යුතු යැයි සිතමු Person. මෙය Personක්ෂේත්ර ඇත name, ageසහ sex. මෙය කිරීම සඳහා ක්රම නිර්මාණය කිරීමයි name, ageහා sex. දැන් අපි තවත් පුද්ගලයෙකු නිර්මාණය කිරීම අවශ්ය නම්, එය අවශ්ය සඳහා ක්රම නිර්මාණය කිරීම වේ name, age, sexයලිත්.

මෙය සිදු කරනවා වෙනුවට, අපට class(Person)ගෙටර් සහ සෙටර් ක්‍රම සමඟ බෝංචි සෑදිය හැකිය . ඉතින් හෙට අපට class(Person class)නව පුද්ගලයෙකු එකතු කිරීමට අවශ්‍ය සෑම විටම මෙම බෝංචි වල වස්තු නිර්මාණය කළ හැකිය (රූපය බලන්න). මේ අනුව අපි බෝංචි පන්තියේ ක්ෂේත්‍ර හා ක්‍රම නැවත භාවිතා කරන අතර එය වඩා හොඳය.

සංස්කරණය කරන්න: මම මෙම ප්‍රශ්නයට පිළිතුරු දුන්නේ ක්‍රමලේඛනය ඉගෙන ගන්නා පිරිසක් සිටින නිසාත්, බොහෝ පිළිතුරු ඉතා තාක්‍ෂණිකව දක්ෂ නිසාත්, ඔබ නවකයෙක් නම් ඔවුන් තේරුම් ගැනීමට පහසු නැත. අපි හැමෝම අලුතෙන් ආපු අය, ඒ නිසා මම හිතුවා මම වඩාත් නවක මිත්‍රශීලී පිළිතුරක් ලබා ගැනීමට උත්සාහ කරමි.

ප්‍රධාන ඒවා දෙක වන්නේ බහුමාපකය සහ වලංගුකරණයයි. එය මෝඩ දත්ත ව්‍යුහයක් වුවද.

මෙම සරල පංතිය අපට ඇතැයි කියමු:

public class Bottle {
  public int amountOfWaterMl;
  public int capacityMl;
}

එහි ඇති දියර ප්‍රමාණය සහ එහි ධාරිතාව (මිලිලීටර වලින්) රඳවා ගන්නා ඉතා සරල පන්තියකි.

මා කරන විට කුමක් සිදුවේද:

Bottle bot = new Bottle();
bot.amountOfWaterMl = 1500;
bot.capacityMl = 1000;

හොඳයි, ඔබ එය ක්‍රියාත්මක වේ යැයි බලාපොරොත්තු නොවනු ඇත, නේද? ඔබට යම් ආකාරයක සනීපාරක්ෂක පරීක්‍ෂණයක් කිරීමට අවශ්‍යයි. ඊටත් වඩා නරක දෙය නම්, මම කිසි විටෙකත් උපරිම ධාරිතාව නියම නොකළේ නම් කුමක් කළ යුතුද? ඔහ්, ආදරණීය, අපට ගැටලුවක් තිබේ.

නමුත් තවත් ගැටලුවක් තිබේ. බෝතල් එක් බහාලුමක් පමණක් නම් කුමක් කළ යුතුද? අප සතුව බහාලුම් කිහිපයක් තිබේ නම්, සියල්ලම ධාරිතාවයෙන් හා ද්‍රවයෙන් පුරවා තිබේ නම් කුමක් කළ යුතුද? අපට අතුරු මුහුණතක් සෑදිය හැකි නම්, අපගේ වැඩසටහනේ ඉතිරි අයට එම අතුරුමුහුණත පිළිගැනීමට ඉඩ දිය හැකි අතර බෝතල්, ජෙරිකන් සහ සියලු වර්ගවල දේවල් එකිනෙකට හුවමාරු වේ. එය වඩා හොඳ නොවේද? අතුරුමුහුණත් ඉල්ලුම් ක්‍රම බැවින් මෙයද හොඳ දෙයකි.

අපි අවසන් කරන්නේ මෙවැනි දෙයක් සමඟයි:

public interface LiquidContainer {
  public int getAmountMl();
  public void setAmountMl(int amountMl);
  public int getCapacityMl();
}

මහා! දැන් අපි බෝතලය මේකට වෙනස් කරමු:

public class Bottle extends LiquidContainer {
  private int capacityMl;
  private int amountFilledMl;

  public Bottle(int capacityMl, int amountFilledMl) {
    this.capacityMl = capacityMl;
    this.amountFilledMl = amountFilledMl;
    checkNotOverFlow();
  }

  public int getAmountMl() {
    return amountFilledMl;
  }

  public void setAmountMl(int amountMl) {
     this.amountFilled = amountMl;
     checkNotOverFlow();
  }
  public int getCapacityMl() {
    return capacityMl;
  }

  private void checkNotOverFlow() {
    if(amountOfWaterMl > capacityMl) {
      throw new BottleOverflowException();
    }
}

මම BottleOverflowException හි අර්ථ දැක්වීම පා er කයාට අභ්‍යාසයක් ලෙස තබමි.

දැන් මෙය කොතරම් ශක්තිමත්දැයි බලන්න. බෝතලය වෙනුවට LiquidContainer භාර ගැනීමෙන් අපට දැන් අපගේ කේතයේ ඇති ඕනෑම බහාලුමක් සමඟ කටයුතු කළ හැකිය. මෙම බෝතල් මේ ආකාරයේ දේවල් සමඟ කටයුතු කරන ආකාරය සියල්ල වෙනස් විය හැකිය. එය වෙනස් වූ විට ඒවායේ තත්වය තැටියට ලියන බෝතල් හෝ SQL දත්ත සමුදායන්හි ඉතිරි කරන බෝතල් හෝ GNU වෙනත් දේ දනී.

මේ සියල්ලටම විවිධ විකාර හැසිරවීමට විවිධ ක්‍රම තිබිය හැකිය. බෝතලය පරික්ෂා කර බැලූ විට එය පිරී ඉතිරී යන්නේ නම් එය ධාවන වේලාව විසි කරයි. නමුත් එය වැරදි දෙයක් විය හැකිය. (දෝෂ හැසිරවීම පිළිබඳ ප්‍රයෝජනවත් සාකච්ඡාවක් ඇත, නමුත් මම එය මෙහි අරමුණක් මත ඉතා සරළව තබමි. අදහස් දක්වන පුද්ගලයින් මෙම සරල ප්‍රවේශයේ අඩුපාඩු පෙන්වා දෙනු ඇත.;))

ඔව්, අපි ඉතා සරල අදහසකින් වඩා හොඳ පිළිතුරු ඉක්මනින් ලබා ගැනීමට යන බවක් පෙනේ.

ඔබට බෝතලයක ධාරිතාව වෙනස් කළ නොහැකි බව කරුණාවෙන් සලකන්න. එය දැන් ගල් ගසා ඇත. එය අවසාන වශයෙන් ප්‍රකාශ කිරීමෙන් ඔබට මෙය int එකකින් කළ හැකිය. නමුත් මෙය ලැයිස්තුවක් නම්, ඔබට එය හිස් කළ හැකිය, එයට අලුත් දේවල් එකතු කළ හැකිය. ඔබට ඇතුළත ස්පර්ශ කිරීමට ඇති ප්‍රවේශය සීමා කළ නොහැක.

සෑම කෙනෙකුම ආමන්ත්‍රණය නොකළ තුන්වන කාරණය ද තිබේ: ලබා ගන්නන් සහ සැකසුම් කරන්නන් ක්‍රම ඇමතුම් භාවිතා කරයි. ඒ කියන්නේ ඒවා අනෙක් සෑම තැනකම වගේ සාමාන්‍ය ක්‍රම වගේ. DTOs සහ දේවල් සඳහා අමුතු නිශ්චිත වාක්‍ය ඛණ්ඩයක් වෙනුවට, ඔබට සෑම තැනකම එකම දේ ඇත.

ජාවා නඩුව සඳහා මම මේ ගැන සිතමින් සෑහෙන කාලයක් ගත කළ අතර සැබෑ හේතු:

1. අතුරු මුහුණතට කේතය මිස ක්‍රියාත්මක කිරීම නොවේ
2. අතුරුමුහුණත් මඟින් ක්ෂේත්‍ර පමණක් නොව ක්‍රම පමණක් දක්වයි

වෙනත් වචන වලින් කිවහොත්, ඔබට අතුරු මුහුණතක් තුළ ක්ෂේත්‍රයක් නියම කළ හැකි එකම ක්‍රමය වන්නේ නව අගයක් ලිවීමේ ක්‍රමයක් සහ වත්මන් අගය කියවීමේ ක්‍රමයක් සැපයීමයි.

එම ක්‍රම වන්නේ කුප්‍රකට ගෙටරය සහ සැකසුමයි ....

කම්මැලි පැටවීම සඳහා එය ප්රයෝජනවත් විය හැකිය. සැක සහිත වස්තුව දත්ත ගබඩාවක ගබඩා කර ඇති බව පවසන්න, ඔබට එය අවශ්‍ය නම් මිස එය ලබා ගැනීමට ඔබට අවශ්‍ය නැත. වස්තුව ලබා ගන්නෙකු විසින් ලබා ගන්නේ නම්, යමෙකු එය ඉල්ලා සිටින තුරු අභ්‍යන්තර වස්තුව ශුන්‍ය විය හැකිය, එවිට ඔබට එය ලබා ගන්නා තැනැත්තාට පළමු ඇමතුමෙන් ලබා ගත හැකිය.

විවිධ වෙබ් සේවා ඇමතුම් කිහිපයකින් දත්ත පැටවීම සඳහා මට භාර දුන් ව්‍යාපෘතියක මූලික පිටු පන්තියක් මා සතුව තිබුනද එම වෙබ් සේවා ඇමතුම්වල දත්ත සෑම ළමා පිටුවකම සැමවිටම භාවිතා නොවීය. වෙබ් සේවා, සියලු ප්‍රතිලාභ සඳහා, “මන්දගාමී” යන්න පිළිබඳ නව නිර්වචන පුරෝගාමී කරන්න, එබැවින් ඔබට අවශ්‍ය නැතිනම් වෙබ් සේවා ඇමතුමක් ලබා ගැනීමට ඔබට අවශ්‍ය නැත.

මම පොදු ක්ෂේත්‍ර වලින් ලබා ගන්නන් වෙත ගියෙමි, දැන් ලබා ගන්නන් හැඹිලිය පරීක්ෂා කරයි, එය නොමැති නම් වෙබ් සේවාව අමතන්න. ඒ නිසා ටිකක් එතීමෙන්, වෙබ් සේවා ඇමතුම් විශාල ප්‍රමාණයක් වළක්වා ගන්නා ලදි.

ඒ නිසා සෑම ළමා පිටුවකම මට අවශ්‍ය දේ සොයා ගැනීමට උත්සාහ කරන්නා මාව ගලවා ගනී. මට එය අවශ්‍ය නම්, මම එය ලබා ගන්නා තැනැත්තාට කතා කරමි, එය දැනටමත් මා සතුව නොමැති නම් එය මා වෙනුවෙන් සොයා ගනී.

    protected YourType _yourName = null;
    public YourType YourName{
      get
      {
        if (_yourName == null)
        {
          _yourName = new YourType();
          return _yourName;
        }
      }
    }

මෙතෙක් පිළිතුරු වලින් මට මග හැරුණු එක් අංගයක්, ප්‍රවේශ පිරිවිතර:

• සාමාජිකයින් සඳහා ඔබට සැකසීම් සහ ලබා ගැනීම යන දෙකම සඳහා ඇත්තේ එක් ප්‍රවේශ පිරිවිතරයක් පමණි
• සැකසුම් කරුවන් සහ ලබා ගන්නන් සඳහා ඔබට එය මනාව සකස් කර වෙන වෙනම අර්ථ දැක්විය හැකිය

"ගුණාංග" (C ++, Java) සඳහා සහය නොදක්වන හෝ ගුණාංග (C #) වෙත ක්ෂේත්‍ර වෙනස් කිරීමේදී සේවාදායකයින් නැවත සකස් කිරීම අවශ්‍ය නොවන භාෂාවල, get / set ක්‍රම භාවිතා කිරීම වෙනස් කිරීම පහසුය. උදාහරණයක් ලෙස, setFoo ක්‍රමයකට වලංගු කිරීමේ තර්කනය එකතු කිරීම පන්තියක පොදු අතුරු මුහුණත වෙනස් කිරීම අවශ්‍ය නොවේ.

“තාත්වික” ගුණාංග සඳහා සහාය දක්වන භාෂාවල (පයිතන්, රූබි, සමහර විට ස්මාල්ටෝක්?) ක්‍රම ලබා ගැනීමට / සැකසීමට කිසිදු තේරුමක් නැත.

OO නිර්මාණයේ මූලික විදුහල්පතිවරයෙක්: එන්කැප්සියුලේෂන්!

එය ඔබට බොහෝ ප්‍රතිලාභ ලබා දෙන අතර, ඉන් එකක් වන්නේ තිරය පිටුපස සිටින තැනැත්තා / සැකසුම ක්‍රියාත්මක කිරීම වෙනස් කළ හැකි නමුත් දත්ත වර්ගය එලෙසම පවතින තාක් කල් එම වටිනාකමෙන් යුත් ඕනෑම පාරිභෝගිකයෙකු දිගටම වැඩ කරනු ඇත.

ඔබ කවදා හෝ ලබා ගන්නන් සහ සැකසුම් භාවිතා කළ යුතුය:

• ඔබ ගනුදෙනු කරන්නේ සංකල්පමය වශයෙන් ලක්ෂණයක් වන දෙයක් සමඟ ය, නමුත්:
  • ඔබේ භාෂාවට ගුණාංග නොමැත (හෝ Tcl හි විචල්‍ය හෝඩුවාවන් වැනි සමාන යාන්ත්‍රණයක්), හෝ
  • මෙම භාවිත අවස්ථාව සඳහා ඔබේ භාෂාවේ දේපල සහාය ප්‍රමාණවත් නොවේ, හෝ
  • ඔබේ භාෂාවේ (හෝ සමහර විට ඔබේ රාමුවේ) මුග්ධ සම්මුතීන් මෙම භාවිත අවස්ථාව සඳහා ලබා ගන්නන් හෝ සැකසුම් කරන්නන් දිරිමත් කරයි.

එබැවින් මෙය සාමාන්‍ය OO ප්‍රශ්නයකි. එය භාෂා විශේෂිත ප්‍රශ්නයක් වන අතර විවිධ භාෂාවන් සඳහා විවිධ පිළිතුරු ඇත (සහ විවිධ භාවිත අවස්ථා).

OO න්‍යාය දෘෂ්ටි කෝණයකින්, ලබා ගන්නන් සහ සැකසුම් කරන්නන් නිෂ් .ල ය. ඔබේ පන්තියේ අතුරුමුහුණත එය කරන්නේ කුමක්ද, එහි තත්වය කුමක්ද යන්න නොවේ. (එසේ නොවේ නම්, ඔබ වැරදි පංතියක් ලියා ඇත.) ඉතා සරල අවස්ථාවන්හිදී, පන්තියක් කරන දෙය සාධාරණ නම්, උදා: සෘජුකෝණාස්රාකාර ඛණ්ඩාංකවල ලක්ෂ්‍යයක් නිරූපණය කරන්න, * ගුණාංග අතුරු මුහුණතේ කොටසකි; getters සහ setters එය වළාකුළු. නමුත් ඉතා සරල අවස්ථාවන්හිදී, ගුණාංග හෝ ලබා ගන්නන් සහ සැකසුම්කරුවන් අතුරු මුහුණතේ කොටසක් නොවේ.

වෙනත් ක්‍රමයක් තබන්න: ඔබේ පන්තියේ පාරිභෝගිකයින් ඔබට spamලක්ෂණයක් ඇති බව නොදැන සිටිය යුතු යැයි ඔබ විශ්වාස කරන්නේ නම් , එය විලී-නිලි ලෙස වෙනස් කිරීමට හැකි වනු ඇත, එවිට ඔවුන්ට set_spamක්‍රමයක් ලබා දීම ඔබට කිරීමට අවශ්‍ය අන්තිම දෙයයි.

_{* එම සරල පන්තිය සඳහා වුවද, ඔබට අගයන් xසහ yඅගයන් සැකසීමට ඉඩ දීමට අවශ්‍ය නොවනු ඇත. මේ ඇත්තටම පන්ති නම්, ඒ වගේ ක්රම ඇති කළ යුතු නැහැ translate, rotateආදිය,? ඔබේ භාෂාවට වාර්තා / ව්‍යුහයන් / නම් කරන ලද ටුපල් නොමැති නිසා එය පංතියක් පමණක් නම්, මෙය ඇත්ත වශයෙන්ම OO පිළිබඳ ප්‍රශ්නයක් නොවේ…}

නමුත් කිසිවෙකු සාමාන්‍ය OO නිර්මාණය කරන්නේ නැත. ඔවුන් කරන්නේ නිශ්චිත භාෂාවකින් සැලසුම් කිරීම සහ ක්‍රියාත්මක කිරීමයි. සමහර භාෂාවලින්, ලබා ගන්නන් සහ සැකසුම් කරන්නන් නිෂ් .ල ය.

ඔබේ භාෂාවට ගුණාංග නොමැති නම්, සංකල්පමය වශයෙන් ලක්ෂණයක් වන නමුත් ඇත්ත වශයෙන්ම ගණනය කරන ලද හෝ වලංගු කරන ලද යමක් නිරූපණය කිරීමට ඇති එකම ක්‍රමය වන්නේ ලබා ගන්නන් සහ සැකසුම් කරුවන් ය.

ඔබේ භාෂාවට ගුණාංග තිබුණත්, ඒවා ප්‍රමාණවත් නොවන හෝ නුසුදුසු අවස්ථා තිබේ. නිදසුනක් ලෙස, උප කාණ්ඩවලට ගුණාංගයක අර්ථ නිරූපණය පාලනය කිරීමට ඔබට අවශ්‍ය නම්, ගතික ප්‍රවේශයක් නොමැති භාෂාවලින්, උප පංතියකට ගුණාංගයක් සඳහා ගණනය කළ දේපලක් ආදේශ කළ නොහැක.

"මගේ ක්‍රියාත්මක කිරීම පසුව වෙනස් කිරීමට මට අවශ්‍ය නම් කුමක් කළ යුතුද?" ප්‍රශ්නය (OP හි ප්‍රශ්නය සහ පිළිගත් පිළිතුර යන දෙකෙහිම විවිධ වචන වලින් කිහිප වතාවක් පුනරාවර්තනය වේ): එය සැබවින්ම පිරිසිදු ක්‍රියාත්මක කිරීමේ වෙනසක් නම්, සහ ඔබ ගුණාංගයකින් ආරම්භ කළහොත්, ඔබට එය අතුරු මුහුණතට බලපෑමක් නොකර දේපලකට වෙනස් කළ හැකිය. ඇත්ත වශයෙන්ම, ඔබේ භාෂාව එයට සහාය නොදක්වයි. ඉතින් මෙය නැවත නැවතත් එකම අවස්ථාවකි.

එසේම, ඔබ භාවිතා කරන භාෂාවේ (හෝ රාමුවේ) මුග්ධයන් අනුගමනය කිරීම වැදගත්ය. ඔබ C # හි ලස්සන රූබි විලාසිතාවේ කේතයක් ලියන්නේ නම්, ඔබ හැර වෙනත් ඕනෑම පළපුරුදු C # සංවර්ධකයෙකුට එය කියවීමේ අපහසුතාවයක් ඇති වන අතර එය නරක ය. සමහර භාෂාවන්ට ඔවුන්ගේ සම්මුතීන් වටා වෙනත් සංස්කෘතීන්ට වඩා ශක්තිමත් සංස්කෘතීන් ඇත.

මානව පා readers කයින්ගෙන් ඔබ්බට, ඔබ සම්මුතීන් අනුගමනය කරනු ඇතැයි අපේක්ෂා කරන පුස්තකාල සහ මෙවලම් ඇති අතර ඔබ එසේ නොකරන්නේ නම් ඔබේ ජීවිතය දුෂ්කර කරවයි. ObjC ගුණාංග හැර වෙනත් ඕනෑම දෙයකට අතුරු මුහුණත් සාදන්නාගේ විජට් සම්බන්ධ කිරීම හෝ ලබා ගන්නන් නොමැතිව සමහර ජාවා විහිළු පුස්තකාල භාවිතා කිරීම ඔබේ ජීවිතය වඩාත් දුෂ්කර කරයි. මෙවලම් ඔබට වැදගත් නම්, ඒවාට එරෙහිව සටන් නොකරන්න.

වස්තු දිශානතියේ සැලසුම් දෘෂ්ටි කෝණයෙන් බැලූ විට, විකල්ප දෙකම පංති සංසරණය දුර්වල කිරීමෙන් කේතය නඩත්තු කිරීමට හානි කළ හැකිය. සාකච්ඡාවක් සඳහා ඔබට මෙම විශිෂ්ට ලිපිය සොයා බැලිය හැකිය: http://typicalprogrammer.com/?p=23

Getter සහ setter ක්‍රම යනු ප්‍රවේශක ක්‍රම වේ, එයින් අදහස් කරන්නේ ඒවා සාමාන්‍යයෙන් පුද්ගලික පන්ති සාමාජිකයන් වෙනස් කිරීම සඳහා පොදු අතුරු මුහුණතක් බවයි. දේපලක් අර්ථ දැක්වීම සඳහා ඔබ ගෙටර් සහ සෙටර් ක්‍රම භාවිතා කරයි. ඔබ පන්තියේ ඇතුළත ක්‍රම ලෙස අර්ථ දැක්වුවද, ඔබ පන්තියට පිටින් ඇති ගුණාංග ලෙස ගෙටර් සහ සෙටර් ක්‍රම වෙත පිවිසෙයි. පංතියෙන් පිටත ඇති එම දේපල පන්තියේ දේපල නාමයට වඩා වෙනස් නමක් තිබිය හැකිය.

ගුණාංග මෙන් ඔබට ප්‍රවේශ විය හැකි නවීන ක්‍රියාකාරිත්වයකින් යුත් සාමාජිකයින් නිර්මාණය කිරීමට ඔබට ඉඩදීමේ හැකියාව වැනි ගෙටර් සහ සෙටර් ක්‍රම භාවිතා කිරීමෙන් යම් වාසි ඇත. කියවීමට පමණක් සහ ලිවීමට පමණක් ඇති ගුණාංග නිර්මාණය කිරීමටද ඒවා ඔබට ඉඩ දෙයි.

Getter සහ setter ක්‍රම ප්‍රයෝජනවත් වුවද, ඒවා ඕනෑවට වඩා භාවිතා නොකිරීමට ඔබ වගබලා ගත යුතුය. මන්දයත්, වෙනත් කාරණා අතර, ඇතැම් අවස්ථාවන්හිදී කේත නඩත්තු කිරීම වඩාත් අපහසු කළ හැකි බැවිනි. එසේම, ඔවුන් මහජන සාමාජිකයින් මෙන් ඔබේ පන්ති ක්‍රියාත්මක කිරීමට ප්‍රවේශය ලබා දේ. OOP පුහුණුව පන්තියක් තුළ ඇති දේපල වෙත access ජුව පිවිසීම අධෛර්යමත් කරයි.

ඔබ පන්ති ලියන විට, ඔබේ නිදර්ශන විචල්‍යයන්ගෙන් හැකි තරම් ප්‍රමාණයක් පුද්ගලික කර ගැනීමටත්, ඒ අනුව ගෙටර් සහ සෙටර් ක්‍රම එකතු කිරීමටත් ඔබ නිතරම උනන්දු කරනු ලැබේ. මෙයට හේතුව ඔබේ පන්ති තුළ ඇතැම් විචල්‍යයන් වෙනස් කිරීමට පරිශීලකයින්ට ඉඩ දීමට ඔබට අවශ්‍ය නොවන අවස්ථා කිහිපයකි. උදාහරණයක් ලෙස, ඔබට නිශ්චිත පන්තියක් සඳහා නිර්මාණය කරන ලද අවස්ථා ගණන නිරීක්ෂණය කරන පුද්ගලික ස්ථිතික ක්‍රමයක් තිබේ නම්, පරිශීලකයා කේතය භාවිතා කරමින් එම කවුන්ටරය වෙනස් කිරීමට ඔබට අවශ්‍ය නැත. එම විචල්‍යය හැඳින්වූ සෑම විටම එය වැඩි කළ යුත්තේ ඉදිකිරීම්කරු ප්‍රකාශය පමණි. මෙම තත්වය තුළ, ඔබට පුද්ගලික නිදර්ශන විචල්‍යයක් නිර්මාණය කර ප්‍රතිවිරුද්ධ විචල්‍යයට පමණක් ලබා ගැනීමේ ක්‍රමයකට ඉඩ දිය හැකිය, එයින් අදහස් කරන්නේ පරිශීලකයින්ට වත්මන් අගය ලබා ගත හැක්කේ ලබා ගැනීමේ ක්‍රමය භාවිතා කිරීමෙන් පමණක් වන අතර ඔවුන්ට නව අගයන් සැකසීමට නොහැකි වනු ඇත. සෙටර් ක්‍රමය භාවිතා කිරීම.

කේතය පරිණාමය වේ. ඔබට දත්ත සාමාජික ආරක්ෂාව අවශ්‍යprivate විටදී එය විශිෂ්ටයි . අවසානයේදී සියලුම පංති "මිනිප්‍රෝග්‍රෑම්" විය යුතු අතර එය මනාව නිර්වචනය කළ අතුරු මුහුණතක් ඇත .

බව, සඳහන් මෘදුකාංග සංවර්ධනය , ඔබ විසින් පළමු උත්සාහක මත යම් කාස්ට් යකඩ ප්රතිමාව දැවෙන කරන්නේ නම්, ලෙස පන්තියේ බව අවසාන පිටපත පහළ සැකසීම ගැන නොවේ. ඔබ එය සමඟ වැඩ කරන අතරතුර, කේතය මැටි වැනි ය. ඔබ එය සංවර්ධනය කරන විට සහ ඔබ විසඳන ගැටළු වසම ගැන වැඩිදුර ඉගෙන ගන්නා විට එය පරිණාමය වේ. සංවර්ධන පන්ති වලදී ඔවුන් එකිනෙකාට වඩා අන්තර්ක්‍රියා කළ හැකිය (ඔබ සාධක කිරීමට අදහස් කරන යැපීම), එකට ඒකාබද්ධ වීම හෝ වෙන්වීම. ඒ නිසා මම හිතන්නේ විවාදය ආගමික වශයෙන් ලිවීමට අකමැති පුද්ගලයින්ට තල්ලු කරයි

int getVar() const { return var ; }

එබැවින් ඔබට ඇත්තේ:

doSomething( obj->getVar() ) ;

වෙනුවට

doSomething( obj->var ) ;

getVar()දෘශ්‍යමය වශයෙන් is ෝෂාකාරී වනවා පමණක් නොව , gettingVar()එය ඇත්ත වශයෙන්ම වඩා සංකීර්ණ ක්‍රියාවලියක් වන මෙම මිත්‍යාව ලබා දෙයි . ඔබ (පංති ලේඛකයා ලෙස) සලකන varආකාරය ඔබේ පන්තියේ පරිශීලකයෙකුට පැස්ට්‍රු සැකසුම් කරුවෙකු සිටී නම් එය විශේෂයෙන් ව්‍යාකූල වේ - එවිට ඔබ අවධාරනය කරන දෙයක් “ආරක්ෂා කිරීම” සඳහා මෙම දොරටු සකස් කර ඇති බව පෙනේ, (පරිශුද්ධභාවය var) එහෙත් ඔබ කරන දේ ගැන සොයා බැලීමෙන් තොරව varකිසිවෙකුට පැමිණීමට සහ set varඔවුන්ට අවශ්‍ය ඕනෑම වටිනාකමක් ලබා ගැනීමට ඇති හැකියාව නිසා ඔබ ආරක්ෂා කිරීම පවා වටින්නේ නැත .

එබැවින් මම පහත පරිදි වැඩසටහන් කරමි ("කඩිනම්" ආකාරයේ ප්‍රවේශයක් උපකල්පනය කරමින් - එනම් මම කේතය ලියන විට එය කරන්නේ කුමක්දැයි හරියටම නොදැන / විස්තීරණ දිය ඇල්ල විලාසිතාවේ අතුරුමුහුණත් කට්ටලයක් සැලසුම් කිරීමට කාලය හෝ අත්දැකීම් නොමැත):

1) දත්ත සහ හැසිරීම සහිත මූලික වස්තු සඳහා සියලුම මහජන සාමාජිකයන් සමඟ ආරම්භ කරන්න. මගේ C ++ "උදාහරණ" කේතයේ සෑම තැනකම structවෙනුවට මා භාවිතා කරන බව ඔබ දකින්නේ මේ නිසාය class.

2) දත්ත සාමාජිකයෙකු සඳහා වස්තුවක අභ්‍යන්තර හැසිරීම ප්‍රමාණවත් තරම් සංකීර්ණ වූ විට, (නිදසුනක් ලෙස, එය std::listයම් ආකාරයක අනුපිළිවෙලකට අභ්‍යන්තරයක් තබා ගැනීමට කැමතියි ), ප්‍රවේශ වර්ගයේ කාර්යයන් ලියා ඇත. මම තනියම ක්‍රමලේඛනය කරන නිසා, මම සෑම විටම සාමාජිකයා privateඑකවරම සකසන්නේ නැත, නමුත් පන්තියේ පරිණාමයේ යම් තැනක සාමාජිකයා එක්කෝ protectedහෝ උසස් කරනු ලැබේ private.

3) සම්පූර්ණයෙන්ම මදුළු සහිත සහ ඔවුන්ගේ අභ්යන්තර ගැන දැඩි රීති ඇති බව ටියුශන් පන්ති (එනම් ඔවුන් තමන් කරන්නේ හරියටම මොකක්ද කියලා, ඔබ "මගුලක්ද" (තාක්ෂණික කාලීන කිරීමට නොවේ) එහි අභ්යන්තර සමඟ) ලබා දී ඇත classතනතුර, පෙරනිමි පෞද්ගලික සාමාජිකයන්, තෝරාගත් සාමාජිකයන් කිහිප දෙනෙකුට පමණක් අවසර ඇත public.

පංතියේ පරිණාමයේ මුල් අවධියේදී බොහෝ දත්ත සාමාජිකයින් සංක්‍රමණය වූ විට, එහා මෙහා ගෙන යන විට, එහි වාඩි වී සිටීම සහ ආගමික වශයෙන් ලියන්නන් / කට්ටල ලිවීම වළක්වා ගැනීමට මෙම ප්‍රවේශය මට ඉඩ සලසයි.

දේපල උරුමයක් නොමැති නම් ප්‍රවේශයන් භාවිතා කිරීම සලකා බැලීමට හොඳ හේතුවක් තිබේ. ඊළඟ උදාහරණය බලන්න:

public class TestPropertyOverride {
    public static class A {
        public int i = 0;

        public void add() {
            i++;
        }

        public int getI() {
            return i;
        }
    }

    public static class B extends A {
        public int i = 2;

        @Override
        public void add() {
            i = i + 2;
        }

        @Override
        public int getI() {
            return i;
        }
    }

    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.i);
        a.add();
        System.out.println(a.i);
        System.out.println(a.getI());
    }
}

ප්‍රතිදානය:

0
0
4

Getters හා ස්ථානගත වන්නන් වන වස්තු නැඹුරු ක්රමලේඛ මූලික අංග දෙකක් ක්රියාත්මක කිරීමට භාවිතා වේ:

1. සාරාංශය
2. සංසරණය

අපට සේවක පන්තියක් ඇතැයි සිතමු:

package com.highmark.productConfig.types;

public class Employee {

    private String firstName;
    private String middleName;
    private String lastName;

    public String getFirstName() {
      return firstName;
    }
    public void setFirstName(String firstName) {
       this.firstName = firstName;
    }
    public String getMiddleName() {
        return middleName;
    }
    public void setMiddleName(String middleName) {
         this.middleName = middleName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFullName(){
        return this.getFirstName() + this.getMiddleName() +  this.getLastName();
    }
 }

මෙහි සම්පූර්ණ නම ක්‍රියාත්මක කිරීමේ තොරතුරු පරිශීලකයාගෙන් සැඟවී ඇති අතර එය පොදු ලක්ෂණයක් මෙන් නොව පරිශීලකයාට කෙලින්ම ප්‍රවේශ විය නොහැක.

තවත් එක් භාවිතයක් (ගුණාංගවලට සහාය දක්වන භාෂාවලින්), මෙහෙයුමක් සුළුපටු නොවන බව සැකසුම්කරුවන්ට සහ ලබා ගන්නන්ට ඇඟවිය හැකිය. සාමාන්‍යයෙන්, ඔබට අවශ්‍ය වන්නේ දේපලක පරිගණකමය වශයෙන් මිල අධික කිසිවක් කිරීමෙන් වළකින්න.

ලබා ගන්නන්ගේ / සැකසුම් කරුවන්ගේ සාපේක්ෂව නවීන වාසියක් නම්, ටැග් කළ (සුචිගත කළ) කේත සංස්කාරක තුළ කේත පිරික්සීම පහසු කිරීමයි. උදා: සාමාජිකයෙකු පත් කරන්නේ කවුරුන්දැයි බැලීමට ඔබට අවශ්‍ය නම්, ඔබට ඇමතුමේ ධූරාවලිය විවෘත කළ හැකිය.

අනෙක් අතට, සාමාජිකයා පොදු නම්, මෙවලම් මඟින් සාමාජිකයාට කියවීමේ / ලිවීමේ ප්‍රවේශය පෙරීමට නොහැකි වේ. එබැවින් සාමාජිකයාගේ සියලු භාවිතයන් ඔබ විශ්වාස කළ යුතුය.

වස්තුවකට නැඹුරු භාෂාවක ක්‍රම සහ ඒවායේ ප්‍රවේශ විකරණකාරක එම වස්තුව සඳහා අතුරු මුහුණත ප්‍රකාශ කරයි. ඉදිකිරීම්කරු සහ ප්‍රවේශක සහ විකෘති ක්‍රම අතර සංවර්ධකයාට වස්තුවක අභ්‍යන්තර තත්වයට ප්‍රවේශය පාලනය කළ හැකිය. විචල්යයන් හුදෙක් ප්රසිද්ධ ලෙස ප්රකාශයට පත් කරන්නේ නම්, එම ප්රවේශය නියාමනය කිරීමට ක්රමයක් නොමැත. තවද අපි සෙටර් භාවිතා කරන විට අපට අවශ්‍ය ආදානය සඳහා පරිශීලකයා සීමා කළ හැකිය. එම විචල්‍යය සඳහා වන පෝෂණය නිසි නාලිකාවක් හරහා පැමිණෙන අතර නාලිකාව අප විසින් කලින් නියම කර ඇත. එබැවින් සෙටර් භාවිතා කිරීම ආරක්ෂිතයි.

මීට අමතරව, මෙය ඔබේ පන්තියට "අනාගත-සාධනය" කිරීමයි. විශේෂයෙන්, ක්ෂේත්‍රයක සිට දේපලකට වෙනස් කිරීම ABI විවේකයක් වන අතර, පසුව ඔබට "ක්ෂේත්‍රය සැකසීමට / ලබා ගැනීමට" වඩා වැඩි තර්කනයක් අවශ්‍ය යැයි ඔබ පසුව තීරණය කරන්නේ නම්, ඔබ ABI බිඳ දැමිය යුතුය, ඇත්ත වශයෙන්ම ඕනෑම දෙයකට ගැටලු ඇති කරයි ඔබේ පන්තියට එරෙහිව දැනටමත් සම්පාදනය කර ඇත.

ව්‍යාඛ්‍යාව පිළිබඳ අදහස විසි කිරීමට මම කැමතියි: tergetter සහ @setter. @Getter සමඟ, ඔබට obj = class.field කිරීමට හැකි විය යුතුය, නමුත් class.field = obj නොවේ. @Setter සමඟ, අනෙක් අතට. @Getter සහ @setter සමඟ ඔබට දෙකම කළ හැකිය. මෙමඟින් සංසරණය ආරක්ෂා වන අතර ධාවන වේලාවේදී සුළු ක්‍රම නොකියමින් කාලය අඩු කරයි.