നിങ്ങൾക്ക് ചില ക്ലാസ് രീതികൾ സ്റ്റാറ്റിക് രീതികളായി പ്രഖ്യാപിക്കാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ സ്റ്റാറ്റിക് കീവേഡ് ഉപയോഗിക്കണം. സ്റ്റാറ്റിക് രീതികൾ ഈ പരാമീറ്റർ സ്വീകരിക്കുന്നില്ല. സ്റ്റാറ്റിക് രീതികൾ ഉപയോഗിക്കുന്നതിന് നിരവധി നിയന്ത്രണങ്ങളുണ്ട്.
സ്റ്റാറ്റിക് രീതികൾക്ക് ഒരു ക്ലാസിലെ സ്റ്റാറ്റിക് അംഗങ്ങളെ മാത്രമേ നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയൂ.
ഒരു സ്റ്റാറ്റിക് രീതി ഒരു വെർച്വൽ രീതിയായി പ്രഖ്യാപിക്കാൻ കഴിയില്ല.
സ്റ്റാറ്റിക് ക്ലാസ് മെത്തേഡായി നിങ്ങൾക്ക് ഒരേ പേരും ഒരേ പാരാമീറ്ററുകളും ഉള്ള നോൺ-സ്റ്റാറ്റിക് രീതി നിർവ്വചിക്കാൻ കഴിയില്ല.
സ്റ്റാറ്റിക് രീതികൾക്ക് രസകരമായ ഒരു സവിശേഷതയുണ്ട് - ക്ലാസിൻ്റെ ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാതെ തന്നെ നിങ്ങൾക്ക് അവരെ വിളിക്കാം. ഒരു പ്രോഗ്രാമിൽ നിന്ന് ഒരു സ്റ്റാറ്റിക് രീതി വിളിക്കാൻ, നിങ്ങൾ അത് വ്യക്തമാക്കണം പൂർണ്ണമായ പേര്, ക്ലാസ്സിൻ്റെ പേര് ഉൾപ്പെടെ.
സ്റ്റാറ്റിക് GetPi രീതി നിർവചിക്കുന്ന സർക്കിൾ ക്ലാസ് ചുവടെയുണ്ട്. fPi ക്ലാസിലെ ഒരു സ്റ്റാറ്റിക് അംഗത്തിൻ്റെ മൂല്യം ലഭിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.
സ്റ്റാറ്റിക് ശൂന്യമായ GetPi()
സ്റ്റാറ്റിക് ഫ്ലോട്ട് fPi;
ഫ്ലോട്ട് സർക്കിൾ:: fPi = 3.1415;
നിങ്ങൾക്ക് GetPi രീതിയെ ഇതുപോലെ വിളിക്കാം:
fNumber = സർക്കിൾ ::GetPi();
ഒരു സർക്കിൾ ഒബ്ജക്റ്റ് സൃഷ്‌ടിച്ചിട്ടില്ലെന്നത് ശ്രദ്ധിക്കുക.
ക്ലാസ് ഒബ്‌ജക്‌റ്റുകളിലെ സാധാരണ അംഗങ്ങൾ
തന്നിരിക്കുന്ന ക്ലാസിലെ എല്ലാ ഒബ്‌ജക്‌റ്റുകൾക്കും ചിലപ്പോൾ ഇത് സൗകര്യപ്രദമാണ് പൊതു ഘടകങ്ങൾപങ്കിട്ട ഡാറ്റ. ഇതുമൂലം, നിങ്ങൾക്ക് ആഗോള വേരിയബിളുകളുടെ എണ്ണം ഗണ്യമായി കുറയ്ക്കാനും പ്രോഗ്രാമിൻ്റെ ഘടന മെച്ചപ്പെടുത്താനും കഴിയും.
പങ്കിട്ട ക്ലാസ് ഡാറ്റ അംഗങ്ങളെ സ്റ്റാറ്റിക് കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിക്കണം. ക്ലാസിലെ എല്ലാ പൊതു ഘടകങ്ങളും പ്രോഗ്രാം വാചകത്തിൽ നിർവചിച്ചിരിക്കണം, അവയ്ക്കായി റാമിൽ ഇടം റിസർവ് ചെയ്യണം:
(പൊതുവായത്: int xLeftTop, xRightBottom; int yLeftTop, yRightBottom; സ്റ്റാറ്റിക് ചാർ ശീർഷകം; അസാധുവായ SetTitle(char*); );char Cwindow::title = "വിൻഡോ തലക്കെട്ട്";
Cwindow ക്ലാസിലെ ഓരോ ഒബ്‌ജക്റ്റിനും തനത് കോർഡിനേറ്റുകൾ ഉണ്ടായിരിക്കും, അത് xLeftTop, xRightBottom, yLeftTop, yRightBottom ഡാറ്റ ഘടകങ്ങളാൽ നിർണ്ണയിക്കപ്പെടുന്നു, കൂടാതെ ടൈറ്റിൽ ഡാറ്റ എലമെൻ്റ് സംഭരിച്ചിരിക്കുന്ന അതേ ശീർഷകവും.
സാധാരണ ഡാറ്റ അംഗങ്ങൾ അവരുടെ ക്ലാസിൻ്റെ പരിധിയിലാണ്. ക്ലാസിൽ നിന്നുള്ള മറ്റ് ഡാറ്റ പോലെ തന്നെ ക്ലാസ് രീതികൾക്ക് പങ്കിട്ട അംഗങ്ങളെ ആക്സസ് ചെയ്യാൻ കഴിയും:
അസാധുവായ SetTitle(char* sSource)
(strcpy(ശീർഷകം, ഉറവിടം); )
ഒരു പ്രോഗ്രാമിൽ നിന്ന് പൊതു ഘടകങ്ങൾ ആക്സസ് ചെയ്യുന്നതിന്, നിങ്ങൾ അവ പൊതുവായി പ്രഖ്യാപിക്കണം. അത്തരമൊരു വേരിയബിളിലേക്ക് പ്രവേശിക്കുന്നതിന്, നിങ്ങൾ അതിൻ്റെ പേരിന് മുമ്പായി ക്ലാസ് നാമവും :: ഓപ്പറേറ്ററും നൽകണം.
printf(Cwindow::title);
സൗഹൃദ പ്രവർത്തനങ്ങളും സൗഹൃദ ക്ലാസുകളും
പ്രോഗ്രാമിൽ നിന്നും മറ്റ് ക്ലാസുകളിൽ നിന്നുമുള്ള ക്ലാസ് ഘടകങ്ങളിലേക്കുള്ള ആക്സസ് പരിമിതമാണ്. പൊതു കീവേഡിന് ശേഷം നിർവചിച്ചതോ പ്രഖ്യാപിച്ചതോ ആയ ക്ലാസ് അംഗങ്ങളെ മാത്രമേ നിങ്ങൾക്ക് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയൂ. എന്നിരുന്നാലും, ചില സന്ദർഭങ്ങളിൽ, ക്ലാസിന് പുറത്തുള്ള ഒരു ഫംഗ്ഷൻ നിർവചിക്കേണ്ടത് ആവശ്യമാണ് അല്ലെങ്കിൽ സ്വകാര്യവും പരിരക്ഷിതവുമായി പ്രഖ്യാപിച്ച ഘടകങ്ങൾ ഉൾപ്പെടെ, ക്ലാസിലെ എല്ലാ ഘടകങ്ങളും നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയുന്ന മറ്റൊരു ക്ലാസിൻ്റെ രീതികൾ.
സൗഹൃദ സവിശേഷതകൾ
C++-ൽ, ഫ്രണ്ട് കീവേഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ക്ലാസിനായി സുഹൃത്ത് ഫംഗ്ഷൻ എന്ന് വിളിക്കപ്പെടുന്നതിനെ നിർവ്വചിക്കാം. ഒരു സുഹൃത്തിൻ്റെ പ്രവർത്തനത്തിൻ്റെ പ്രഖ്യാപനം മാത്രമേ ക്ലാസിൽ അടങ്ങിയിട്ടുള്ളൂ. അതിൻ്റെ നിർവചനം ക്ലാസിന് പുറത്താണ് സ്ഥിതി ചെയ്യുന്നത്. നിങ്ങൾക്ക് ക്ലാസിലെ ഏത് വിഭാഗത്തിലും ഒരു സുഹൃത്തിൻ്റെ പ്രവർത്തനം പ്രഖ്യാപിക്കാൻ കഴിയും - പൊതു, സ്വകാര്യ, അല്ലെങ്കിൽ പരിരക്ഷ.
ഒരു ചങ്ങാതി ഫംഗ്ഷൻ ക്ലാസിലെ അംഗമല്ല, എന്നാൽ സ്വകാര്യവും പരിരക്ഷണവും ഉൾപ്പെടെ അതിലെ എല്ലാ അംഗങ്ങളെയും ആക്സസ് ചെയ്യാൻ കഴിയും. ഒരേ ഫംഗ്ഷൻ രണ്ടോ അതിലധികമോ ക്ലാസുകളോട് സൗഹൃദപരമായിരിക്കും.
ഇനിപ്പറയുന്ന ഉദാഹരണം പോയിൻ്റ് ക്ലാസുമായി സൗഹൃദപരമായ ഒരു ക്ലിയർ ഫംഗ്ഷൻ നിർവചിക്കുന്നു. സ്വകാര്യമായി പ്രഖ്യാപിക്കപ്പെട്ട ഡാറ്റ അംഗങ്ങളുടെ m_x, m_y എന്നിവയുടെ മൂല്യം മാറ്റാൻ Clear എന്ന ഫ്രണ്ട്ലി ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:
// പോയിൻ്റ് ക്ലാസ്
// ക്ലിയർ ഫംഗ്ഷൻ പോയിൻ്റ് ക്ലാസിനോട് സൗഹൃദമാണെന്ന് പ്രഖ്യാപിച്ചു
സുഹൃത്ത് ശൂന്യമായ പോയിൻ്റ്:: ക്ലിയർ(പോയിൻ്റ്*);
// ക്ലാസ് ഇൻ്റർഫേസ്...
//==========================================================
// പ്രവർത്തനം വ്യക്തമാണ്
ശൂന്യമായ മായ്ക്കുക (പോയിൻ്റ്* ptrPoint)
// ആക്സസ് ക്ലാസ് ഘടകങ്ങൾ സ്വകാര്യമായി പ്രഖ്യാപിച്ചു
ptrPoint->m_x = 0;
ptrPoint->m_y = 0;
//==========================================================
// പ്രധാന പ്രവർത്തനം
പോയിൻ്റ് പോയിൻ്റ് ടെസ്റ്റ് പോയിൻ്റ്;
// ഒരു സൗഹൃദ ചടങ്ങ് വിളിക്കുക
മായ്ക്കുക(&pointTestPoint);
സുഹൃത്ത് കീവേഡിൻ്റെ സഹായത്തോടെ, നിങ്ങൾക്ക് ഒരു ക്ലാസിലെ ചില രീതികൾ മറ്റൊരു ക്ലാസിൻ്റെ സുഹൃത്തുക്കളായി പ്രഖ്യാപിക്കാം. അത്തരം രീതികൾക്ക് ഒരു ക്ലാസിലെ എല്ലാ ഘടകങ്ങളും ആക്സസ് ചെയ്യാൻ കഴിയും, സ്വകാര്യമായി പ്രഖ്യാപിക്കപ്പെട്ടവയും പരിരക്ഷിക്കുന്നവയും, അവ മറ്റൊരു ക്ലാസിൻ്റെ ഭാഗമാണെങ്കിലും.
ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ഞങ്ങൾ രണ്ട് ക്ലാസുകൾ നിർവചിക്കുന്നു - വരിയും പോയിൻ്റും. പോയിൻ്റ് ക്ലാസിൽ ഞങ്ങൾ സെറ്റ് രീതി നിർവചിക്കുകയും ലൈൻ ക്ലാസിൽ അത് സൗഹൃദമായി പ്രഖ്യാപിക്കുകയും ചെയ്യുന്നു. ഫ്രണ്ട്ലി സെറ്റ് രീതിക്ക് ലൈൻ ക്ലാസിലെ എല്ലാ ഘടകങ്ങളും ആക്സസ് ചെയ്യാൻ കഴിയും:
// ലൈൻ ക്ലാസിൻ്റെ പ്രീ-ഡിക്ലറേഷൻ
//==========================================================
// പോയിൻ്റ് ക്ലാസ്
// പോയിൻ്റ് ക്ലാസിൻ്റെ രീതി സജ്ജമാക്കുക
ശൂന്യമായ സെറ്റ് (ലൈൻ*);
//==========================================================
// ക്ലാസ് ലൈൻ
// പോയിൻ്റ് ക്ലാസിൻ്റെ സെറ്റ് രീതി സൗഹൃദമാണെന്ന് പ്രഖ്യാപിച്ചു
// ക്ലാസ് പോയിൻ്റ്
സുഹൃത്ത് ശൂന്യമായ പോയിൻ്റ് ::സെറ്റ്(ലൈൻ*);
int start_x, start_y;
int end_x, end_y;
//==========================================================
// പ്രവർത്തനം വ്യക്തമാണ്
ശൂന്യമായ പോയിൻ്റ്::സെറ്റ്(ലൈൻ* ptrLine)
// ലൈൻ ക്ലാസിൻ്റെ ആക്സസ് ഘടകങ്ങൾ, ആയി പ്രഖ്യാപിച്ചു
ptrLine->begin_x = 0;
ptrLine->begin_y = 0;
//==========================================================
// പ്രധാന പ്രവർത്തനം
പോയിൻ്റ് പോയിൻ്റ് ടെസ്റ്റ് പോയിൻ്റ്;
ലൈൻ ലൈൻ ടെസ്റ്റ് പോയിൻ്റ്;
// ഒരു സൗഹൃദ രീതി വിളിക്കുക
pointTestPoint.Set(&lineTestPoint);
അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 04/19/2018
സാധാരണ രീതികൾക്കും ഫീൽഡുകൾക്കും പുറമേ, ഒരു ക്ലാസിന് സ്റ്റാറ്റിക് ഫീൽഡുകൾ, രീതികൾ, സ്ഥിരാങ്കങ്ങൾ, ഇനീഷ്യലൈസറുകൾ എന്നിവ ഉണ്ടായിരിക്കാം. ഉദാഹരണത്തിന്, പ്രോഗ്രാമിൻ്റെ പ്രധാന ക്ലാസിന് ഒരു മെത്തേഡ് മെയിൻ ഉണ്ട്, അത് സ്റ്റാറ്റിക് ആണ്:
പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്) ( )
സ്റ്റാറ്റിക് വേരിയബിളുകൾ, സ്ഥിരാങ്കങ്ങൾ, രീതികൾ, ഇനീഷ്യലൈസറുകൾ എന്നിവ പ്രഖ്യാപിക്കുന്നതിന്, അവയുടെ പ്രഖ്യാപനത്തിന് മുമ്പായി കീ വ്യക്തമാക്കുക വാക്ക് സ്റ്റാറ്റിക്.
സ്റ്റാറ്റിക് ഫീൽഡുകൾ
ക്ലാസ് ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുമ്പോൾ, ഓരോ ഒബ്‌ജക്റ്റിനും നോൺ-സ്റ്റാറ്റിക് റെഗുലർ ഫീൽഡുകളുടെ സ്വന്തം പകർപ്പ് ഉണ്ടായിരിക്കും. സ്റ്റാറ്റിക് ഫീൽഡുകൾ മുഴുവൻ ക്ലാസിനും സാധാരണമാണ്. അതിനാൽ ക്ലാസ് ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാതെ അവ ഉപയോഗിക്കാൻ കഴിയും.
ഉദാഹരണത്തിന്, നമുക്ക് ഒരു സ്റ്റാറ്റിക് വേരിയബിൾ സൃഷ്ടിക്കാം:
പബ്ലിക് ക്ലാസ് പ്രോഗ്രാം(പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ പ്രധാനം(സ്ട്രിംഗ് ആർഗ്സ്) (പേഴ്സൺ ടോം = പുതിയ വ്യക്തി(); വ്യക്തി ബോബ് = പുതിയ വ്യക്തി(); tom.displayId(); // Id = 1 bob.displayId(); // Id = 2 System.out.println(Person.counter); // 3 // മാറ്റം Person.counter = 8 ; കൌണ്ടർ=1; വ്യക്തി())( ഐഡി = കൌണ്ടർ++; ) പൊതു ശൂന്യ ഡിസ്പ്ലേ Id())( System.out.printf("Id: %d \n", id); )
പേഴ്സൺ ക്ലാസിൽ ഒരു സ്റ്റാറ്റിക് വേരിയബിൾ കൗണ്ടർ അടങ്ങിയിരിക്കുന്നു, അത് കൺസ്ട്രക്റ്ററിൽ വർദ്ധിപ്പിക്കുകയും അതിൻ്റെ മൂല്യം ഐഡി വേരിയബിളിന് നൽകുകയും ചെയ്യുന്നു. അതായത്, ഓരോ പുതിയ വ്യക്തി ഒബ്ജക്റ്റും സൃഷ്ടിക്കുമ്പോൾ, ഈ വേരിയബിൾ വർദ്ധിക്കും, അതിനാൽ ഓരോ പുതിയ വ്യക്തി ഒബ്‌ജക്റ്റിനും മുമ്പത്തേതിനേക്കാൾ 1 വലിയ ഐഡി ഫീൽഡ് മൂല്യം ഉണ്ടായിരിക്കും.
കൌണ്ടർ വേരിയബിൾ സ്റ്റാറ്റിക് ആയതിനാൽ, നമുക്ക് അത് പ്രോഗ്രാമിൽ ക്ലാസ് നാമത്തിൽ പരാമർശിക്കാം:
System.out.println(Person.counter); // മൂല്യം നേടുക Person.counter = 8; // മൂല്യം മാറ്റുക
പ്രോഗ്രാമിൻ്റെ കൺസോൾ ഔട്ട്പുട്ട്:
ഐഡി = 1 ഐഡി = 2 3 ഐഡി = 8
സ്റ്റാറ്റിക് സ്ഥിരാങ്കങ്ങൾ
സ്റ്റാറ്റിക് എന്നത് മുഴുവൻ ക്ലാസിനും പൊതുവായുള്ള സ്ഥിരാങ്കങ്ങളാണ്.
പബ്ലിക് ക്ലാസ് പ്രോഗ്രാം( പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്) ( ഇരട്ട ആരം = 60; System.out.printf("Radisu: %f \n", radius); // 60 System.out.printf("ഏരിയ: %f \n", Math.PI * ആരം); // 188.4 ) ) ക്ലാസ് കണക്ക്( പൊതു സ്റ്റാറ്റിക് ഫൈനൽഇരട്ട PI = 3.14; )
മുമ്പത്തെ എല്ലാ വിഷയങ്ങളിലും, സ്റ്റാറ്റിക് സ്ഥിരാങ്കങ്ങൾ ഇതിനകം സജീവമായി ഉപയോഗിച്ചിട്ടുണ്ട് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. പ്രത്യേകിച്ചും, പദപ്രയോഗത്തിൽ:
System.out.println("ഹലോ");
ഔട്ട് എന്നത് സിസ്റ്റം ക്ലാസ്സിൻ്റെ ഒരു സ്റ്റാറ്റിക് കോൺസ്റ്റൻ്റ് പ്രതിനിധീകരിക്കുന്നു. അതിനാൽ, സിസ്റ്റം ക്ലാസിൻ്റെ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാതെ തന്നെ ഇത് ആക്സസ് ചെയ്യപ്പെടുന്നു.
സ്റ്റാറ്റിക് ഇനീഷ്യലൈസറുകൾ
സ്റ്റാറ്റിക് ഇനീഷ്യലൈസറുകൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് സ്റ്റാറ്റിക് വേരിയബിളുകൾ ആരംഭിക്കുന്നതിനോ അല്ലെങ്കിൽ ആദ്യത്തെ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ ചെയ്യുന്ന പ്രവർത്തനങ്ങൾ ചെയ്യുന്നതിനോ ആണ്. ഉദാഹരണത്തിന്, നമുക്ക് ഒരു സ്റ്റാറ്റിക് ഇനീഷ്യലൈസർ നിർവചിക്കാം:
പബ്ലിക് ക്ലാസ് പ്രോഗ്രാം(പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്) (പേഴ്സൺ ടോം = പുതിയ വ്യക്തി(); വ്യക്തി ബോബ് = പുതിയ വ്യക്തി(); tom.displayId(); // Id = 105 bob.displayId(); // Id = 106). "); ) പൊതു ശൂന്യമായ ഡിസ്പ്ലേ ഐഡി())( System.out.printf("Id: %d \n", id); ) )
ഒരു സ്റ്റാറ്റിക് ഇനീഷ്യലൈസർ ഒരു റെഗുലർ ഇനീഷ്യലൈസർ ആയി നിർവചിച്ചിരിക്കുന്നു, അതിന് മുമ്പുള്ളത് മാത്രം കീവേഡ്നിശ്ചലമായ. IN ഈ സാഹചര്യത്തിൽസ്റ്റാറ്റിക് ഇനീഷ്യലൈസറിൽ ഞങ്ങൾ സ്റ്റാറ്റിക് ഫീൽഡ് കൗണ്ടറിൻ്റെ പ്രാരംഭ മൂല്യം സജ്ജമാക്കുകയും കൺസോളിലേക്ക് ഒരു സന്ദേശം പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യുന്നു.
പ്രോഗ്രാമിൽ തന്നെ, പേഴ്സൺ ക്ലാസിൻ്റെ രണ്ട് ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കപ്പെടുന്നു. അതിനാൽ, കൺസോൾ ഔട്ട്പുട്ട് ഇതുപോലെ കാണപ്പെടും:
സ്റ്റാറ്റിക് ഇനീഷ്യലൈസർ കൺസ്ട്രക്റ്റർ കൺസ്ട്രക്റ്റർ ഐഡി: 105 ഐഡി: 106
ഫസ്റ്റ് ക്ലാസ് ഒബ്ജക്റ്റ് സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ് മാത്രമാണ് സ്റ്റാറ്റിക് ഇനീഷ്യലൈസർ വിളിക്കുന്നത് എന്നത് പരിഗണിക്കേണ്ടതാണ്.
സ്റ്റാറ്റിക് രീതികൾ
സ്റ്റാറ്റിക് രീതികൾ മുഴുവൻ ക്ലാസിനും മൊത്തത്തിൽ ബാധകമാണ്. ഉദാഹരണത്തിന്, മുകളിലുള്ള ഉദാഹരണത്തിൽ, സ്റ്റാറ്റിക് വേരിയബിൾ കൌണ്ടർ ബാഹ്യമായി ആക്സസ് ചെയ്യാവുന്നതാണ്, കൂടാതെ പേഴ്സൺ ക്ലാസിന് പുറത്ത് നമുക്ക് അതിൻ്റെ മൂല്യം മാറ്റാം. നമുക്ക് അത് പുറത്ത് നിന്ന് മാറ്റാൻ പറ്റാത്തതും എന്നാൽ വായിക്കാവുന്നതും ആക്കാം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഒരു സ്റ്റാറ്റിക് രീതി ഉപയോഗിക്കുന്നു:
പബ്ലിക് ക്ലാസ് പ്രോഗ്രാം(പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യ പ്രധാനം(സ്ട്രിംഗ് ആർഗ്സ്) (Person.displayCounter(); // കൗണ്ടർ: 1 വ്യക്തി ടോം = പുതിയ വ്യക്തി(); വ്യക്തി ബോബ് = പുതിയ വ്യക്തി(); Person.displayCounter(); // കൗണ്ടർ: 3 ) ) ക്ലാസ് വ്യക്തി(പ്രൈവറ്റ് ഇൻറ്റ് ഐഡി; പ്രൈവറ്റ് സ്റ്റാറ്റിക് ഇൻറ്റ് കൌണ്ടർ = 1; വ്യക്തി())( ഐഡി = കൌണ്ടർ++; ) // സ്റ്റാറ്റിക് രീതി പൊതു സ്റ്റാറ്റിക് ശൂന്യ ഡിസ്പ്ലേകൗണ്ടർ())( System.out.printf("കൗണ്ടർ: %d \n ", കൌണ്ടർ); ) പൊതു ശൂന്യമായ displayId())( System.out.printf("Id: %d \n", id); ) )
ഇപ്പോൾ സ്റ്റാറ്റിക് വേരിയബിൾ പുറത്ത് നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയില്ല, അത് സ്വകാര്യമാണ്. സ്റ്റാറ്റിക് രീതി ഡിസ്പ്ലേകൗണ്ടർ ഉപയോഗിച്ച് അതിൻ്റെ മൂല്യം പ്രദർശിപ്പിക്കും. ഒരു സ്റ്റാറ്റിക് രീതി ആക്സസ് ചെയ്യുന്നതിന്, ക്ലാസ്സിൻ്റെ പേര് ഉപയോഗിക്കുക: Person.displayCounter() .
സ്റ്റാറ്റിക് രീതികൾ ഉപയോഗിക്കുമ്പോൾ, ഞങ്ങൾ നിയന്ത്രണങ്ങൾ കണക്കിലെടുക്കണം: സ്റ്റാറ്റിക് രീതികളിൽ, നമുക്ക് മറ്റ് സ്റ്റാറ്റിക് രീതികൾ മാത്രമേ വിളിക്കാൻ കഴിയൂ, കൂടാതെ സ്റ്റാറ്റിക് വേരിയബിളുകൾ മാത്രം ഉപയോഗിക്കാനും കഴിയും.
പൊതുവേ, രീതികൾ ഒബ്ജക്റ്റിൻ്റെ അവസ്ഥയെ ബാധിക്കാത്തപ്പോൾ സ്റ്റാറ്റിക് ആയി നിർവചിക്കപ്പെടുന്നു, അതായത്, അതിൻ്റെ നോൺ-സ്റ്റാറ്റിക് ഫീൽഡുകളെയും സ്ഥിരാങ്കങ്ങളെയും, കൂടാതെ രീതിയെ വിളിക്കാൻ ക്ലാസിൻ്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കുന്നതിൽ അർത്ഥമില്ല. ഉദാഹരണത്തിന്:
പബ്ലിക് ക്ലാസ് പ്രോഗ്രാം(പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യ പ്രധാനം(സ്ട്രിംഗ് ആർഗ്സ്) ( System.out.println(Operation.sum(45, 23)); // 68 System.out.println(Operation.subtract(45, 23)); // 22 System.out.println(Operation.multiply(4, 23)); // 92 ) ക്ലാസ് ഓപ്പറേഷൻ( സ്റ്റാറ്റിക് ഇൻറ്റ് സം(int x, int y)(റിട്ടേൺ x + y; ) സ്റ്റാറ്റിക് ഇൻറ്റ് സബ്‌ട്രാക്റ്റ് (int x, int y) )( റിട്ടേൺ x - y; ) സ്റ്റാറ്റിക് ഇൻറ്റ് ഗുണനം (int x, int y)( റിട്ടേൺ x * y; ) )
ഈ സാഹചര്യത്തിൽ, തുക, കുറയ്ക്കൽ, ഗുണനം എന്നീ രീതികൾക്കായി, ഓപ്പറേഷൻ ക്ലാസിൻ്റെ ഏത് ഉദാഹരണമാണ് ഉപയോഗിച്ചതെന്നത് പ്രശ്നമല്ല. ഈ രീതികൾ ക്ലാസിൻ്റെ അവസ്ഥയെ ബാധിക്കാതെ, പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് മാത്രം പ്രവർത്തിക്കുന്നു. അതിനാൽ, അവയെ സ്റ്റാറ്റിക് എന്ന് നിർവചിക്കാം.
രീതി പരാമീറ്ററുകളുടെ വേരിയബിൾ എണ്ണം
ചില സമയങ്ങളിൽ ഒരു രീതിയിലേക്ക് കൈമാറുന്ന ആർഗ്യുമെൻ്റുകളുടെ എണ്ണം റൺടൈം വരെ അറിയില്ല. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു ഗ്രാഫിൽ ഒരു രേഖ വരയ്ക്കുന്ന ഒരു ക്ലാസ് ആവശ്യമാണ്, x-, y-കോർഡിനേറ്റുകളുടെ ഒരു ക്രമം നൽകിയിരിക്കുന്നു. ഈ ക്ലാസിൽ ഒരൊറ്റ ആർഗ്യുമെൻ്റ് എടുക്കുന്ന ഒരു രീതി അടങ്ങിയിരിക്കണം - ഒരു തരം ഒബ്ജക്റ്റ് പോയിൻ്റ്, x, y കോർഡിനേറ്റുകളുടെ മൂല്യങ്ങളെ പ്രതിനിധീകരിക്കുന്നു. ഈ രീതി എല്ലാ തരത്തിലുള്ള ഒബ്ജക്റ്റും സംരക്ഷിക്കണം പോയിൻ്റ്ഒരു ലിങ്ക് ചെയ്ത ലിസ്റ്റിലോ അറേ ഘടകങ്ങളിലോ കോളിംഗ് പ്രോഗ്രാം പ്രിൻ്റ് ചെയ്യേണ്ട പോയിൻ്റുകളുടെ മുഴുവൻ ക്രമവും കമാൻഡ് ചെയ്യുന്നതുവരെ. എന്നിരുന്നാലും, ഈ പരിഹാരം വളരെ ഫലപ്രദമാകണമെന്നില്ല, കാരണം ഇതിന് സാന്നിധ്യം ആവശ്യമാണ് ലിങ്ക് ചെയ്ത പട്ടിക. പക്ഷേ അത് ഉപയോഗിക്കാമായിരുന്നു ഒരേയൊരു രീതി - ഡ്രോലൈൻആർക്കൊക്കെ ഈ ലിസ്റ്റ് ആവശ്യമില്ല . വേരിയബിൾ ആർഗ്യുമെൻ്റ് രീതി ഉപയോഗിച്ച് ഈ പ്രശ്നം ഫലപ്രദമായി പരിഹരിക്കുന്നു.
ഈ രീതി സജ്ജമാക്കാൻ കഴിയും വേരിയബിൾ നമ്പർകീവേഡ് വഴിയുള്ള വാദങ്ങൾ പരമങ്ങൾഒരു ശ്രേണിയുടെ രൂപത്തിൽ. നമുക്ക് ഒരു ഉദാഹരണ ക്ലാസ് നോക്കാം ചാർട്ട്, C#-ൽ എഴുതിയിരിക്കുന്നു, ഒരു കോൾ സ്വീകരിക്കാനും ഔട്ട്പുട്ട് ചെയ്യാനും ഉപയോക്താവിനെ അനുവദിക്കുന്നു അനിയന്ത്രിതമായ നമ്പർവസ്തുക്കൾ പോയിൻ്റ്:
സിസ്റ്റം ഉപയോഗിച്ച്;
ക്ലാസ് പോയിൻ്റ് //പോയിൻ്റ് ക്ലാസ്
പൊതു പോയിൻ്റ് (int x, int y) ( this.x = x; this.y = y; )
പൊതു int x; പബ്ലിക് ഇൻറ്റ് വൈ;
ക്ലാസ് ചാർട്ട് //ഡ്രോയർ ക്ലാസ്
പൊതു ശൂന്യമായ ഡ്രോലൈൻ (ഗ്രാഫിക്സ് g, പാരാംസ് പോയിൻ്റ് p)
Console.WriteLine("\nഈ രീതി നിങ്ങളെ ഒരു വര വരയ്ക്കാൻ അനുവദിക്കുന്നു " +
"വഴി അടുത്ത പോയിൻ്റുകൾ:");
വേണ്ടി (int i = 0; i< p.GetLength(0); i++)
( Console.WriteLine("(0), (1)". p[i].x, p[i].y); )
ക്ലാസ് ചാർട്ട് ആപ്പ്
പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ()
പോയിൻ്റ് p1 = പുതിയ പോയിൻ്റ്(5,10);
പോയിൻ്റ് p2 = പുതിയ പോയിൻ്റ്(5, 15);
പോയിൻ്റ് p3 = പുതിയ പോയിൻ്റ്(5, 20);
ചാർട്ട് ചാർട്ട് = പുതിയ ചാർട്ട്();
chart.DrawLine(p1, p2, p3);
രീതി ഡ്രോലൈൻ C# കംപൈലറോട് പറയുന്നത്, അതിന് തരം ഒബ്‌ജക്‌റ്റുകളുടെ വേരിയബിൾ എണ്ണം സ്വീകരിക്കാനാകുമെന്നാണ് പോയിൻ്റ്.തുടർന്ന് റൺടൈമിൽ രീതി ഒരു ലളിതമായ ലൂപ്പ് ഉപയോഗിക്കുന്നു വേണ്ടിഎല്ലാ വസ്തുക്കളിലൂടെയും കടന്നുപോകാൻ പോയിൻ്റ്കൂടാതെ എല്ലാ പോയിൻ്റുകളും പ്രദർശിപ്പിക്കുന്നു.
ഒരു സ്റ്റാറ്റിക് രീതി എന്നത് ക്ലാസിൽ നിലനിൽക്കുന്ന ഒരു രീതിയാണ്, അല്ലാതെ അതിൻ്റെ വ്യക്തിഗത സന്ദർഭങ്ങളിലല്ല. മറ്റ് സ്റ്റാറ്റിക് അംഗങ്ങളെ പോലെ, സ്റ്റാറ്റിക് രീതികളുടെ പ്രധാന നേട്ടം, അവ ക്ലാസിൻ്റെ കോൺക്രീറ്റ് സംഭവങ്ങൾക്ക് പുറത്ത്, തടസ്സമില്ലാതെ സ്ഥിതിചെയ്യുന്നു എന്നതാണ്. ആഗോള ഇടംഅപേക്ഷകൾ. അതേ സമയം, അവർ OOP യുടെ തത്വങ്ങൾ ലംഘിക്കുന്നില്ല, കാരണം അവ ഒരു പ്രത്യേക ക്ലാസുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.
ഒരു രീതി സ്റ്റാറ്റിക് ആയി നിർവചിക്കാൻ കീവേഡ് നിങ്ങളെ അനുവദിക്കുന്നു നിശ്ചലമായ.തുടർന്ന് ഉപയോക്താവ് വാക്യഘടന ഉപയോഗിക്കുന്നു ക്ലാസ്. രീതി.ക്ലാസിലെ ഒരു ഉദാഹരണം ഉപയോക്താവിന് റഫറൻസ് ഉണ്ടെങ്കിൽപ്പോലും ഈ വാക്യഘടന ആവശ്യമാണ്.
സ്റ്റാറ്റിക് ( നിശ്ചലമായ) രീതികൾ, അല്ലെങ്കിൽ ക്ലാസ് രീതികൾ, വസ്തുവിൻ്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കാതെ തന്നെ വിളിക്കാം. ഈ രീതിയാണ് ഉപയോഗിക്കുന്നത് പ്രധാന.
പൊതു ക്ലാസ് സാമ്പിൾ
പബ്ലിക് സ്റ്റാറ്റിക് ഇൻ്റ് എ;
പബ്ലിക് ഇൻറ്റ് ബി;
പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ DoubleA() ( a *= 2; )
പൊതു ശൂന്യമായ SetB() (b = a;)
പൊതു ക്ലാസ് അപേക്ഷ
പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ()
സാമ്പിൾ sc1 = പുതിയ സാമ്പിൾ(), sc2 = പുതിയ സാമ്പിൾ();
സാമ്പിൾ.എ = 1;
sc1.SetB();
സാമ്പിൾ.എ = 2;
sc2.SetB();
Console.WriteLine("sc1.b = (0), sc2.b = (1)", sc1.b, sc2.b);
സ്റ്റാറ്റിക് രീതികളെക്കുറിച്ചുള്ള അവസാന പോയിൻ്റ് ഒരു സ്റ്റാറ്റിക് മെത്തേഡിൽ നിന്ന് ഏത് ക്ലാസ് അംഗങ്ങളെ ആക്സസ് ചെയ്യാൻ കഴിയുമെന്ന് നിർണ്ണയിക്കുന്ന നിയമമാണ്. നിങ്ങൾക്ക് ഊഹിക്കാൻ കഴിയുന്നതുപോലെ, ഒരു സ്റ്റാറ്റിക് രീതിക്ക് ഏത് വിളിക്കാനും കഴിയും സ്റ്റാറ്റിക് അംഗംഒരു ക്ലാസിനുള്ളിൽ, എന്നാൽ ഒരു ഇൻസ്റ്റൻസ് അംഗത്തെ ആക്സസ് ചെയ്യാൻ കഴിയില്ല.
തുടർന്ന് ക്ലാസ് നാമത്തിലൂടെയും സ്കോപ്പ് റെസലൂഷൻ ഓപ്പറേറ്ററിലൂടെയും നമുക്ക് അവ നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും. എന്നാൽ സ്റ്റാറ്റിക് അംഗ വേരിയബിളുകൾ സ്വകാര്യമാണെങ്കിൽ? ഇനിപ്പറയുന്ന കോഡ് പരിഗണിക്കുക:
ഈ സാഹചര്യത്തിൽ, ഈ അംഗം സ്വകാര്യമായതിനാൽ പ്രധാന() ൽ നിന്ന് നമുക്ക് ഒന്നും നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയില്ല::s_value. സാധാരണഗതിയിൽ, ഒരു ക്ലാസിലെ സ്വകാര്യ അംഗങ്ങളെ പൊതു രീതികളിലൂടെയാണ് ആക്സസ് ചെയ്യുന്നത്. നമുക്ക് സൃഷ്ടിക്കാൻ കഴിയുമെങ്കിലും സാധാരണ രീതി s_value ആക്സസ് ചെയ്യാൻ, എന്നാൽ ഈ രീതി ഉപയോഗിക്കുന്നതിന് ഞങ്ങൾ ഈ ക്ലാസിൻ്റെ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കേണ്ടതുണ്ട്! ഒരു മികച്ച ഓപ്ഷൻ ഉണ്ട് - നമുക്ക് രീതി സ്റ്റാറ്റിക് ആക്കാം.
സ്റ്റാറ്റിക് അംഗ വേരിയബിളുകൾ പോലെ, സ്റ്റാറ്റിക് രീതികൾ ഏതെങ്കിലും ഒരു ക്ലാസ് ഒബ്ജക്റ്റുമായി ബന്ധിപ്പിച്ചിട്ടില്ല. മുകളിലുള്ള ഉദാഹരണം ഇതാ, പക്ഷേ കൂടെ സ്റ്റാറ്റിക് രീതി:
ക്ലാസ് എന്തും (സ്വകാര്യം: സ്റ്റാറ്റിക് ഇൻറ്റ് s_value; പൊതു: സ്റ്റാറ്റിക് ഇൻറ്റ് ഗെറ്റ്വാല്യൂ() (റിട്ടേൺ s_value; ) // സ്റ്റാറ്റിക് രീതി ); int Anything ::s_value = 3; int main() എന്ന ക്ലാസ്സിൻ്റെ സ്റ്റാറ്റിക് അംഗ വേരിയബിളിൻ്റെ // നിർവചനം (std::cout<< Anything::getValue() << "\n"; }
സ്റ്റാറ്റിക് രീതികൾ ഒരു നിർദ്ദിഷ്ട ഒബ്ജക്റ്റുമായി ബന്ധിപ്പിച്ചിട്ടില്ലാത്തതിനാൽ, അവയെ ക്ലാസ് നാമത്തിലൂടെയും സ്കോപ്പ് റെസലൂഷൻ ഓപ്പറേറ്ററിലൂടെയും നേരിട്ട് വിളിക്കാം, കൂടാതെ അവ ക്ലാസ് ഒബ്‌ജക്റ്റുകളിലൂടെയും വിളിക്കാം (എന്നാൽ ഇത് ശുപാർശ ചെയ്യുന്നില്ല).
സ്റ്റാറ്റിക് രീതികൾക്ക് ഈ * പോയിൻ്റർ ഇല്ല
സ്റ്റാറ്റിക് രീതികൾക്ക് രണ്ട് രസകരമായ സവിശേഷതകളുണ്ട്. ആദ്യം, സ്റ്റാറ്റിക് രീതികൾ ഒരു വസ്തുവുമായി ബന്ധിപ്പിച്ചിട്ടില്ലാത്തതിനാൽ, അവയ്ക്ക് ഇല്ല ! ഇത് യുക്തിസഹമാണ്, കാരണം ഈ പോയിൻ്റർ എല്ലായ്പ്പോഴും രീതി പ്രവർത്തിക്കുന്ന ഒബ്ജക്റ്റിലേക്ക് വിരൽ ചൂണ്ടുന്നു. ഒരു ഒബ്‌ജക്‌റ്റിലൂടെ സ്റ്റാറ്റിക് രീതികൾ പ്രവർത്തിച്ചേക്കില്ല, അതിനാൽ ഈ പോയിൻ്റർ ആവശ്യമില്ല.
രണ്ടാമതായി, സ്റ്റാറ്റിക് രീതികൾക്ക് മറ്റ് സ്റ്റാറ്റിക് അംഗങ്ങളെ നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും (വേരിയബിളുകൾ അല്ലെങ്കിൽ ഫംഗ്ഷനുകൾ), എന്നാൽ നോൺ-സ്റ്റാറ്റിക് അംഗങ്ങളെ ആക്സസ് ചെയ്യാൻ കഴിയില്ല. കാരണം, നോൺ-സ്റ്റാറ്റിക് അംഗങ്ങൾ ക്ലാസ് ഒബ്‌ജക്റ്റിൽ പെടുന്നു, പക്ഷേ സ്റ്റാറ്റിക് രീതികൾ അങ്ങനെയല്ല!
മറ്റൊരു ഉദാഹരണം
ക്ലാസ് ബോഡിക്ക് പുറത്ത് സ്റ്റാറ്റിക് രീതികൾ നിർവചിക്കാം. ഇത് സാധാരണ രീതികൾ പോലെ തന്നെ പ്രവർത്തിക്കുന്നു. ഉദാഹരണത്തിന്:
ക്ലാസ് ഐഡിജെനറേറ്റർ (പ്രൈവറ്റ്: സ്റ്റാറ്റിക് ഇൻറ്റ് s_nextID; // ഒരു സ്റ്റാറ്റിക് അംഗ വേരിയബിളിൻ്റെ പ്രഖ്യാപനം പബ്ലിക്: സ്റ്റാറ്റിക് ഇൻറ്റ് getNextID(); // സ്റ്റാറ്റിക് രീതിയുടെ പ്രഖ്യാപനം ); // സ്റ്റാറ്റിക് അംഗ വേരിയബിളിൻ്റെ നിർവചനം ക്ലാസ് ബോഡിക്ക് പുറത്താണ്. ഞങ്ങൾ ഇവിടെ സ്റ്റാറ്റിക് കീവേഡ് ഉപയോഗിക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക // 1 int IDGenerator::s_nextID = 1-ൽ ഐഡികൾ സൃഷ്ടിക്കാൻ ആരംഭിക്കുക; // സ്റ്റാറ്റിക് രീതിയുടെ നിർവചനം ക്ലാസ് ബോഡിക്ക് പുറത്താണ്. ഞങ്ങൾ ഇവിടെ സ്റ്റാറ്റിക് കീവേഡ് int IDGenerator::getNextID() (റിട്ടേൺ s_nextID++; ) int main() ( (int count=0; count) ഉപയോഗിക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക< 4; ++count) std::cout << "The next ID is: " << IDGenerator::getNextID() << "\n"; return 0; }
ക്ലാസ് IDGenerator സ്വകാര്യം: സ്റ്റാറ്റിക് ഇൻറ്റ് s_nextID ; // സ്റ്റാറ്റിക് അംഗ വേരിയബിളിൻ്റെ പ്രഖ്യാപനം പൊതു: സ്റ്റാറ്റിക് ഇൻറ്റ് getNextID(); // ഒരു സ്റ്റാറ്റിക് രീതിയുടെ പ്രഖ്യാപനം // 1 മുതൽ ഐഡി സൃഷ്ടിക്കാൻ ആരംഭിക്കുക int IDGenerator::s_nextID = 1; int IDGenerator ::getNextID() (റിട്ടേൺ s_nextID++;) int main() ഇതിനായി (int count = 0 ; count< 4 ; ++ count ) std::cout<< "The next ID is: " << IDGenerator :: getNextID () << "\n" ; തിരികെ 0; |
ഫലം:
അടുത്ത ഐഡി ഇതാണ്: 1
അടുത്ത ഐഡി ഇതാണ്: 2
അടുത്ത ഐഡി ഇതാണ്: 3
അടുത്ത ഐഡി ഇതാണ്: 4
ഈ ക്ലാസിൻ്റെ എല്ലാ വേരിയബിളുകളും ഫംഗ്ഷനുകളും സ്റ്റാറ്റിക് ആയതിനാൽ, ഈ ക്ലാസിൽ പ്രവർത്തിക്കാൻ ഞങ്ങൾ ഒരു ഒബ്ജക്റ്റ് സൃഷ്‌ടിക്കേണ്ടതില്ല. അടുത്ത ഐഡൻ്റിഫയറിൻ്റെ മൂല്യം സംഭരിക്കാൻ ഒരു സ്റ്റാറ്റിക് അംഗ വേരിയബിൾ ഉപയോഗിക്കുന്നു, ഐഡൻ്റിഫയർ തിരികെ നൽകാനും അത് വർദ്ധിപ്പിക്കാനും ഒരു സ്റ്റാറ്റിക് രീതി ഉപയോഗിക്കുന്നു.
എല്ലാ സ്റ്റാറ്റിക് അംഗങ്ങളുമുള്ള ക്ലാസുകളെക്കുറിച്ചുള്ള മുന്നറിയിപ്പ്
എല്ലാ സ്റ്റാറ്റിക് അംഗങ്ങളുമായും ക്ലാസുകൾ എഴുതുമ്പോൾ ശ്രദ്ധിക്കുക. അത്തരം "പൂർണമായും സ്റ്റാറ്റിക് ക്ലാസുകൾ" ഉപയോഗപ്രദമാകുമെങ്കിലും, അവയ്ക്ക് അവയുടെ പോരായ്മകളും ഉണ്ട്.
ഒന്നാമതായി, എല്ലാ സ്റ്റാറ്റിക് അംഗങ്ങളും ഒരു തവണ മാത്രമേ സൃഷ്ടിക്കപ്പെട്ടിട്ടുള്ളൂ എന്നതിനാൽ, "പൂർണമായും സ്റ്റാറ്റിക് ക്ലാസ്സിൻ്റെ" ഒന്നിലധികം പകർപ്പുകൾ ഉണ്ടാകില്ല (ക്ലാസ് ക്ലോണിംഗ് കൂടാതെ അതിൻ്റെ പേര് മാറ്റാതെ). ഉദാഹരണത്തിന്, നമുക്ക് രണ്ട് സ്വതന്ത്ര IDGenerator ഒബ്ജക്റ്റുകൾ ആവശ്യമുണ്ടെങ്കിൽ, "പൂർണ്ണമായും സ്റ്റാറ്റിക്" ക്ലാസിലൂടെ ഇത് സാധ്യമാകില്ല.
രണ്ടാമതായി, ഗ്ലോബൽ വേരിയബിളുകൾ അപകടകരമാണെന്ന് പാഠത്തിൽ നിന്ന് ഞങ്ങൾക്കറിയാം, കാരണം ഏത് കോഡിനും അവയുടെ മൂല്യങ്ങൾ മാറ്റാൻ കഴിയും കൂടാതെ ബന്ധമില്ലാത്തതായി തോന്നുന്ന മറ്റ് കോഡുകളുടെ (കൂടുതൽ വിശദാംശങ്ങൾ) മാറ്റും. "പൂർണമായും സ്റ്റാറ്റിക്" ക്ലാസുകൾക്കും ഇത് ബാധകമാണ്. എല്ലാ അംഗങ്ങളും ക്ലാസിൽ ഉൾപ്പെടുന്നതിനാൽ (അതിൻ്റെ ഒബ്‌ജക്‌റ്റുകളല്ല), ക്ലാസുകൾക്ക് ആഗോള വ്യാപ്തി ഉള്ളതിനാൽ, "പൂർണമായും സ്റ്റാറ്റിക് ക്ലാസിൽ" ഞങ്ങൾ ആഗോള ഫംഗ്ഷനുകളും വേരിയബിളുകളും അവരുടെ എല്ലാ മൈനസുകളോടും കൂടി പ്രഖ്യാപിക്കുന്നു.
C++ സ്റ്റാറ്റിക് കൺസ്ട്രക്റ്ററുകളെ പിന്തുണയ്ക്കുന്നില്ല
നിങ്ങൾക്ക് ഒരു സാധാരണ അംഗ വേരിയബിൾ വഴി ആരംഭിക്കാൻ കഴിയുമെങ്കിൽ, യുക്തിപരമായി നിങ്ങൾക്ക് സ്റ്റാറ്റിക് കൺസ്ട്രക്റ്റർ വഴി സ്റ്റാറ്റിക് അംഗ വേരിയബിളുകൾ ആരംഭിക്കാൻ കഴിയും. ചില ആധുനിക ഭാഷകൾ ഈ ആവശ്യത്തിനായി സ്റ്റാറ്റിക് കൺസ്ട്രക്റ്ററുകളെ പിന്തുണയ്ക്കുമ്പോൾ, C++, നിർഭാഗ്യവശാൽ, അവയിലൊന്നല്ല.
നിങ്ങളുടെ സ്റ്റാറ്റിക് വേരിയബിൾ നേരിട്ട് ആരംഭിക്കാൻ കഴിയുമെങ്കിൽ, ഒരു കൺസ്ട്രക്‌ടറിൻ്റെ ആവശ്യമില്ല: അത് സ്വകാര്യമാണെങ്കിൽപ്പോലും നിങ്ങൾക്ക് ഒരു സ്റ്റാറ്റിക് അംഗ വേരിയബിൾ നിർവചിക്കാം. മുകളിലെ ഉദാഹരണത്തിൽ s_nextID ഉപയോഗിച്ച് ഞങ്ങൾ ഇത് ചെയ്യുന്നു. മറ്റൊരു ഉദാഹരണം ഇതാ:
ക്ലാസ് എന്തോ (പബ്ലിക്: സ്റ്റാറ്റിക് എസ്ടിഡി:: വെക്റ്റർ
ക്ലാസ് എന്തോ പൊതു: സ്റ്റാറ്റിക് എസ്ടിഡി:: വെക്റ്റർ< char >s_mychars ; std:: വെക്റ്റർ< char >എന്തോ :: s_mychars = ( "o" , "a" , "u" , "i" , "e" ) ; // ഒരു സ്റ്റാറ്റിക് അംഗ വേരിയബിൾ നിർവചിക്കുക |
നിങ്ങളുടെ സ്റ്റാറ്റിക് അംഗ വേരിയബിൾ ആരംഭിക്കുന്നതിന് കോഡ് (ലൂപ്പ് പോലുള്ളവ) എക്സിക്യൂട്ട് ചെയ്യേണ്ടതുണ്ടെങ്കിൽ, അത് ചെയ്യുന്നതിന് കുറച്ച് വ്യത്യസ്ത മാർഗങ്ങളുണ്ട്. അടുത്ത രീതി ഏറ്റവും മികച്ചതാണ്. ഇത് അൽപ്പം സങ്കീർണ്ണമായിരിക്കാമെങ്കിലും (ഇപ്പോൾ) നിങ്ങൾക്കത് ഒരിക്കലും ആവശ്യമില്ലെങ്കിലും, നിങ്ങൾക്ക് വേണമെങ്കിൽ ഈ ട്യൂട്ടോറിയലിൻ്റെ ബാക്കി ഭാഗം സുരക്ഷിതമായി ഒഴിവാക്കാം.
#ഉൾപ്പെടുത്തുക
#ഉൾപ്പെടുത്തുക #ഉൾപ്പെടുത്തുക ക്ലാസ് എന്തോ സ്വകാര്യം: സ്റ്റാറ്റിക് എസ്ടിഡി:: വെക്റ്റർ< char >s_mychars ; പൊതു: എന്തോ::s_mychars; // ഞങ്ങളുടെ സ്റ്റാറ്റിക് അംഗ വേരിയബിൾ നിർവചിക്കുക സംതിംഗ്::_നെസ്റ്റഡ് സംതിംഗ്::s_initializer; // ഞങ്ങളുടെ സ്റ്റാറ്റിക് s_initializer നിർവചിക്കുക, അത് s_mychars int main() ആരംഭിക്കാൻ _nested കൺസ്ട്രക്‌ടറിനെ വിളിക്കും (എന്തെങ്കിലും::getSomething(); 0 തിരികെ നൽകുക; ) ക്ലാസ്_നെസ്റ്റഡ് പൊതു: // _nested എന്ന് പേരുള്ള ഒരു നെസ്റ്റഡ് ക്ലാസ് നിർവ്വചിക്കുക നെസ്റ്റഡ്() // _നെസ്റ്റഡ് കൺസ്ട്രക്റ്റർ ഞങ്ങളുടെ സ്റ്റാറ്റിക് അംഗ വേരിയബിൾ ആരംഭിക്കുന്നു s_mychars. push_back("o"); s_mychars. push_back("a"); s_mychars. push_back("u"); s_mychars. push_back("i"); s_mychars. push_back("e"); സ്റ്റാറ്റിക് ഇതായിരിക്കാം: നമുക്ക് ആദ്യം സ്റ്റാറ്റിക് വേരിയബിളുകളും സ്റ്റാറ്റിക് രീതികളും നോക്കാം.ജാവയിലെ സ്റ്റാറ്റിക് വേരിയബിൾ എന്താണ്?
<ഒരു സ്റ്റാറ്റിക് വേരിയബിൾ ക്ലാസ് നാമം ഉപയോഗിച്ച് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും, കൂടാതെ ഒരു വസ്തുവും ആവശ്യമില്ല ക്ലാസ്-നാമം>.ജാവയിലെ സ്റ്റാറ്റിക് രീതി എന്താണ്?
<ഒരു സ്റ്റാറ്റിക് വേരിയബിൾ ക്ലാസ് നാമം ഉപയോഗിച്ച് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും, കൂടാതെ ഒരു വസ്തുവും ആവശ്യമില്ല കുറിപ്പ്:പ്രധാന രീതി സ്ഥിരതയുള്ളതാണ്, കാരണം ഏതെങ്കിലും തൽക്ഷണം നടക്കുന്നതിന് മുമ്പ് ഒരു ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് അത് ആക്സസ് ചെയ്യാനാകണം. ചില വ്യായാമങ്ങൾ ചെയ്തുകൊണ്ട് സ്റ്റാറ്റിക് കീവേഡുകളുടെ സൂക്ഷ്മതകൾ പഠിക്കാം! ഉദാഹരണം: സ്റ്റാറ്റിക് വേരിയബിളുകളും രീതികളും എങ്ങനെ വിളിക്കാം ഘട്ടം 1)ഇനിപ്പറയുന്ന കോഡ് എഡിറ്ററിലേക്ക് പകർത്തുക പബ്ലിക് ക്ലാസ് ഡെമോ(പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ പ്രധാനം(സ്ട്രിംഗ് ആർഗ്സ്)(വിദ്യാർത്ഥി s1 = പുതിയ വിദ്യാർത്ഥി(); s1.showData(); വിദ്യാർത്ഥി s2 = പുതിയ വിദ്യാർത്ഥി(); s2.showData(); //Student.b++; //s1 .showData(); ) ക്ലാസ് സ്റ്റുഡൻ്റ് ( int a; //പൂജ്യം സ്റ്റാറ്റിക് ഇൻറ്റ് ബി; //ക്ലാസ് ലോഡുചെയ്യുമ്പോൾ മാത്രം പൂജ്യത്തിലേക്ക് ആരംഭിക്കുന്നു. വിദ്യാർത്ഥി())( //കൺസ്ട്രക്ടർ ഇൻക്രിമെൻ്റിംഗ് സ്റ്റാറ്റിക് വേരിയബിൾ b ബി++ ; ))( //a++; //) ) ഘട്ടം 2)കോഡ് സംരക്ഷിച്ച് സമാഹരിക്കുക. കോഡ് ഇതായി പ്രവർത്തിപ്പിക്കുക ജാവ ഡെമോ. ഘട്ടം 3)പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ട് ഷോ താഴെ ഇനിപ്പറയുന്ന ഡയഗ്രം കാണിക്കുന്നു, റഫറൻസ് വേരിയബിളുകളും ഒബ്‌ജക്‌റ്റുകളും എങ്ങനെ സൃഷ്‌ടിക്കുന്നുവെന്നും വ്യത്യസ്ത സന്ദർഭങ്ങൾ ഉപയോഗിച്ച് സ്റ്റാറ്റിക് വേരിയബിളുകൾ ആക്‌സസ്സുചെയ്യുന്നുവെന്നും.
ഘട്ടം 4)വാക്യഘടന ഉപയോഗിച്ച് ക്ലാസിന് പുറത്ത് നിന്ന് ഒരു സ്റ്റാറ്റിക് വേരിയബിൾ ആക്സസ് ചെയ്യാൻ കഴിയും ClassName.Variable_Name. അൺകമൻ്റ് ലൈൻ #7 & 8. സംരക്ഷിക്കുക, സമാഹരിക്കുക, പ്രവർത്തിപ്പിക്കുക. ഔട്ട്പുട്ട് നിരീക്ഷിക്കുക. a = 0 മൂല്യത്തിൻ്റെ മൂല്യം b = 1 a യുടെ = 0 മൂല്യം b = 2 a യുടെ മൂല്യം = 0 മൂല്യം b = 3 ഘട്ടം 5)അൺകമൻ്റ് ലൈൻ 25,26 & 27. സംരക്ഷിക്കുക, സമാഹരിക്കുക, പ്രവർത്തിപ്പിക്കുക. ഘട്ടം 6)പിശക് = ? ഇൻസ്റ്റൻസ് വേരിയബിൾ ആക്സസ് ചെയ്യാൻ സാധ്യമല്ലാത്തതിനാലാണിത്. എ"ജാവ സ്റ്റാറ്റിക് ക്ലാസ് രീതിയിൽ നിന്ന്" വർദ്ധനവ്". ജാവ സ്റ്റാറ്റിക് ബ്ലോക്ക്സ്റ്റാറ്റിക് ബ്ലോക്ക് എന്നത് ഒരു ജാവ ക്ലാസിനുള്ളിലെ സ്റ്റേറ്റ്‌മെൻ്റിൻ്റെ ഒരു ബ്ലോക്കാണ്, അത് ഒരു ക്ലാസ് ആദ്യമായി JVM-ലേക്ക് ലോഡ് ചെയ്യുമ്പോൾ അത് എക്സിക്യൂട്ട് ചെയ്യും. ക്ലാസ് ടെസ്റ്റ് ( സ്റ്റാറ്റിക് ( //കോഡ് ഇവിടെ പോകുന്നു ) ) എ സ്റ്റാറ്റിക് ബ്ലോക്ക് സ്റ്റാറ്റിക് ഡാറ്റ അംഗങ്ങളെ ആരംഭിക്കാൻ സഹായിക്കുന്നു, കൺസ്‌ട്രക്‌ടർമാർ ഇൻസ്റ്റൻസ് അംഗങ്ങളെ സമാരംഭിക്കാൻ സഹായിക്കുന്നതുപോലെ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നുസോണി എക്സ്പീരിയ നിർമ്മിക്കുന്ന രാജ്യം?മുദ്രാവാക്യം: make.belive പല ലോകപ്രശസ്ത കമ്പനികളുടെയും ഉത്ഭവത്തിൽ രണ്ട് പേരായിരുന്നു, അവരിൽ ഒരാൾ കഴിവുള്ള എഞ്ചിനീയർ, മറ്റൊരാൾ...
|
