ജാവ പ്രോഗ്രാമിങ്ങ്/അദ്ധ്യായം 2
അടിസ്ഥാന ഘടകങ്ങൾ തിരുത്തുക
മറ്റേതൊരു ഭാഷയേയും പോലെ, ജാവയും പല അടിസ്ഥാനഘടകങ്ങൾ ചേർന്നാണ് നിർമ്മിക്കപ്പെട്ടിട്ടുള്ളത്. സംസാരഭാഷയേപ്പോലെ തന്നെ കമ്പ്യൂട്ടർ ഭാഷയ്ക്കും നിയതമായ ഒരു വ്യാകരണവും എഴുത്തു ശൈലിയും ഉണ്ട്. ഓരോ ഭാഷയ്ക്കും ഇത് വ്യത്യസ്ഥമാണെന്നിരിക്കിലും, ചില കാര്യങ്ങൾ പൊതുവായി കാണാം. ജാവ പ്രോഗ്രാമിങ്ങ് ഭാഷയെ കൂടുതലറിയാൻ ഇത് സഹായകമാകും. ഈ ഭാഷയിൽ പ്രോഗ്രാമെഴുതുമ്പോൾ ഉപയോഗിക്കേണ്ടിവരുന്ന പ്രധാന ഘടകങ്ങൾ ഇവയാണ്:
1. കീവേഡുകൾ (Key words) 2. വേരിയബിളുകൾ (Variables) 3. ഓപ്പറേറ്ററുകൾ (Operatoprs) 4. എക്സ്പ്രഷനുകൾ (Expressions) 5. സ്റ്റേറ്റ്മെന്റുകൾ (Statements) 6. ബ്ലോക്കുകൾ (Blocks) 7. കണ്ട്രോൾ ഫ്ലോ സ്റ്റേറ്റ്മെന്റുകൾ (Control Flow Statements)
ഇനിയുള്ള ചില ഭാഗങ്ങളിൽ നമുക്കിതിന്റെ വിശദാംശങ്ങൾ കാണാം.
കീവേഡുകൾ തിരുത്തുക
ജാവയിൽ ഭാഷയുടെ ഉപയോഗത്തിനായി മാത്രം മാറ്റി വെച്ചിരിക്കുന്ന ഒരു കൂട്ടം വാക്കുകളാണ് കീവേഡുകൾ. ജാവയിൽ നിലവിൽ അൻപതു വാക്കുകളാണ് ഇങ്ങനെ മാറ്റി വെച്ചിരിക്കുന്നത്. ഈ വാക്കുകൾ വേരിയബിളുകളായി ഉപയോഗിക്കാതിരിക്കാൻ പ്രത്യേകം ശ്രദ്ധിക്കണം. ഇവയിൽ പലതിന്റേയും ഉപയോഗം നമുക്കു വഴിയേ കാണാം.
| ഡിക്ലറേഷൻ | ഫ്ലോനിയന്ത്രണം |
|---|---|
| abstract | continue |
| new | for |
| implements | goto |
| extends | do |
| final | if |
| volatile | break |
| static | case |
| transient | switch |
| const | default |
| interface | finally |
| class | return |
| while | |
| else |
| മറ്റുവാക്കുകൾ | ഡാറ്റാടൈപ്പുകൾ |
|---|---|
| assert (1.4 മുതൽ) | boolean |
| package | byte |
| synchronized | enum (ജാവ 5 മുതൽ |
| this | char |
| throw | long |
| import | float |
| throws | int |
| instanceof | short |
| catch | double |
| try | void |
| strictfp (1.4 മുതൽ) | |
| native | |
| super |
| ആക്സസ് മോഡിഫയറുകൾ |
|---|
| protected |
| private |
| public |
(goto, const എന്നിവ കീവേഡാണെങ്കിലും തൽക്കാലം ഉപയോഗത്തിലില്ല)
വേരിയബിൾ തിരുത്തുക
എന്താണ് വേരിയബിൾ? പ്രോഗ്രാമിന്റെ പ്രവർത്തനചക്രത്തിനിടയിൽ മാറ്റം വരുത്താവുന്ന അല്ലെങ്കിൽ മാറ്റം വരാവുന്ന ഒരു വിലയെ സൂക്ഷിക്കാൻ പ്രോഗ്രാം ഉപയോഗിക്കുന്ന ഒരു സങ്കേതമാണ് വേരിയബിൾ. സാങ്കേതികമായി പറഞ്ഞാൽ ഒരു വേരിയബിൾ എന്നത്, കമ്പ്യൂട്ടറിന്റെ മെമ്മറിയിൽ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം നാം ഓടിക്കുന്ന പ്രോഗ്രാമിനായി നീക്കി വെച്ചിരിക്കുന്ന സ്ഥലത്ത് പ്രോഗ്രാമിലെ ഇപ്പോൾ ഓടുന്ന ഭാഗത്തിന്റെ ഒരു നിർദ്ദിഷ്ട ഉപയോഗത്തിനായി മാറ്റി വെച്ചിരിക്കുന്ന മെമ്മറി ലൊക്കേഷന്റെ അഡ്രസ്സിനെ സൂചിപ്പിക്കുന്ന ഒരു നാമമാണ്. ഉദാഹരണത്തിന്, നമുക്ക് രണ്ട് സംഖ്യകൾ തമ്മിൽ കൂട്ടണമെന്നിരിക്കട്ടെ. തമ്മിൽ കൂട്ടാനുള്ള രണ്ടു സംഖ്യകളേയും നമുക്ക് എവിടെയെങ്കിലും സൂക്ഷിക്കണമല്ലോ? ഇതിനായി നാം നമ്മുടെ പ്രോഗ്രാമിൽ രണ്ട് വേരിയബിളുകൾ നിർമ്മിക്കാനുള്ള നിർദ്ദേശം ഇങ്ങനെ നൽകും:
int a, b;
നമ്മുടെ പ്രോഗ്രാം ഓടുന്ന സമയത്ത് ഈ നിർദ്ദേശങ്ങൾ കണ്ടാൽ ഉടനെ കമ്പ്യൂട്ടർ ഈ പ്രോഗ്രാമിനായി നീക്കി വെച്ചിരിക്കുന്ന മെമ്മറിയിൽ നിന്നും രണ്ട് ഇന്റിജർ വില സൂക്ഷിക്കാനാവശ്യമായ അത്രയും മെമ്മറി ലൊക്കേഷനുകൾ ഇതിനായി മാറ്റി വെയ്ക്ക്കും. ഇതിൽ ഒന്നിന്റെ അഡ്രസ് 'a' എന്ന നാമത്തോടും മറ്റേതിന്റേതിനെ 'b' എന്ന നാമത്തോടും ചേർത്തുവായിക്കാൻ പാകത്തിനു സൂക്ഷിക്കുന്നു. പിന്നീട് നമ്മുടെ പ്രോഗ്രാം എപ്പോഴൊക്കെ ആ വേരിയബിൾ നാമങ്ങൾ ഉപയോഗിക്കുന്നുവോ അപ്പോഴെല്ലാം ആ പേരിനോട് ബന്ധപ്പെട്ട മെമ്മറി ലൊക്കേഷനുകളിൽ ഇരിക്കുന്ന വിലയെടുത്ത് ഉപയോഗിക്കണമെന്ന് പ്രോഗ്രാമിനറിയാം.
ഒരു വേരിയബിൾ പേരിൽ നിന്നും മെമ്മറിയിലേക്ക് എത്താനുള്ള വഴിഏകദേശം ഇങ്ങനെ വരച്ചു കാട്ടാം. ഇടതുവശത്തുള്ള ത് ലുക്കപ്പ് ടേബിളും വലതുവശത്തുള്ളത് മെമ്മറിയും ആണെന്നു കരുതുക
ജാവയിൽ വേരിയബിൾ, ഫീൽഡ് എന്നീ വാക്കുകൾ ഏകദേശം ഒരേ കാര്യം സൂചിപ്പിക്കാനാണ് ഉപയോഗിക്കുന്നത്. നമ്മുടെ പ്രോഗ്രാമിങ്ങ് ആവശ്യങ്ങൾക്കായി പലതരം ഡാറ്റാ ടൈപ്പുകൾ ജാവയിലുണ്ട്. int (ഇന്റിജർ) പൂർണ്ണ സംഖ്യകളെ സൂചിപ്പിക്കുന്നുവെങ്കിൽ float (ഫ്ലോട്ട്) ദശാംശസംഖ്യകളെ സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. char (ക്യാരക്ടർ) ഒരു അക്ഷരത്തെ സൂചിപ്പിക്കുന്നെങ്കിൽ (Strig) സ്ടിങ്ങ് ഒരു കൂട്ടം അക്ഷരങ്ങളെ സൂചിപ്പിക്കുന്നു. മറ്റു പ്രോഗ്രാമിങ്ങ് ഭാഷകളേപ്പോലെത്തന്നെ, ഇവയെ ബേസിക് (അല്ലെങ്കിൽ ഫണ്ടമെന്റൽ)ഡാറ്റാടൈപ്പുകളെന്നും ഡിറൈവ്ഡ് ഡാറ്റാടൈപ്പുകളെന്നും തരം തിരിക്കാവുന്നതാണ്. പ്രാധമികാവശ്യത്തിനുള്ള ഇന്റിജർ, ക്യാർ, ഫ്ലോട്ട് തുടങ്ങിയവയാണ് ബേസിക് ഡാറ്റാടൈപ്പിൽ പെടുന്നവ. നമ്മൾ ഇവയെല്ലാം ഉൾക്കൊള്ളിച്ചു കൊണ്ട് നിർമ്മിച്ച ഒരു ക്ലാസീന്റെ ഒബ്ജക്റ്റ് നിർമ്മിച്ചാൽ അതിനെ ഡിറൈവ്ഡ് ആയി കണക്കാക്കാം.
ജാവയിലെ വേരിയബിളുകളെ നാലായി തരം തിരിക്കാം
1. ഇൻസ്റ്റൻസ് വേരിയബിൾ (സ്റ്റാറ്റിക്ക് അല്ലാത്തത്) തിരുത്തുക
സ്റ്റാറ്റിക്ക് അല്ലാത്ത ഒബ്ജക്റ്റുകളും അതിലെ ഫീൽഡുകളും ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ എന്ന വിഭാഗത്തിൽ പെടും. ഇത് ആ ഒബ്ജക്റ്റിന്റെ തത്സമയ രൂപം സൂക്ഷിക്കുന്നതിന് ഉപയോഗിക്കുന്നു. ഒരേ ക്ലാസിന്റെ രണ്ട് ഒബ്ജക്റ്റുകളും അതിലെ ഫീൽഡുകളും പരസ്പരം ബന്ധമുള്ളതാവുന്നില്ലല്ലോ. ഇത്തരം വേരിയബിളുകളാണ് ഇൻസ്റ്റൻസ് വേരിയബിൾ. സ്റ്റാറ്റിക്ക് എന്ന കീവേഡ് ഉപയോഗിക്കാതെയാണ് ഇത് നിർ‌വചിക്കേണ്ടത്
2. ക്ലാസ് വേരിയബിൾ (സ്റ്റാറ്റിക്ക്) തിരുത്തുക
ക്ലാസ് വേരിയബിളുകൾ നാം സ്റ്റാറ്റിക്ക് കീവേഡ് ഉപയോഗിച്ച് നിർ‌വചിക്കും. ഇത് ഓടുമ്പോൾ ക്ലാസിലെ എല്ലാ ഒബ്ജക്റ്റുകൾക്കും ഉപയോഗിക്കാവുന്ന ഒരേയൊരു ഫീൽഡ് മാത്രം മെമ്മറിയിൽ ഉണ്ടാക്കും. ഒരു ക്ലാസിന് ഒരു ക്ലാസ് ടീച്ചർ എന്നതു പോലെയാണ് ഇവിടെ വേരിയബിൾ നിർമ്മിക്കപ്പെടുന്നത്. വലിയ പ്രോഗ്രാമുകൾ എഴുതുമ്പോൾ വളരെ സൂക്ഷിച്ചുമാത്രം ഉപയോഗിക്കേണ്ട ഒന്നാണിത്.
3. ലോക്കൽ വേരിയബിൾ തിരുത്തുക
ഒരു മെത്തേഡിനകത്ത് താൽക്കാലികാവശ്യത്തിന് നിർ‌വചിക്കപ്പെടുന്നതും, മെത്തേഡിനു പുറത്ത് നിലനിൽപ്പില്ലാത്തതുമായ വേരിയബിളുകളാണ് ലോക്കൽ വേരിയബിളുകൾ. നമ്മുടെ രണ്ട് സംഖ്യ കൂട്ടുന്ന ഉദാഹരണത്തിൽ, ആ രണ്ട് സംഖ്യകൾ താൽക്കാലികമായി എടുത്തു വെക്കുന്ന വെക്കാൻ ഉപയോഗിക്കുന്ന വേരിയബിളുകൾ ഇതിന് ഉദാഹരണമാണ്.
4. പരാമീറ്ററുകൾ തിരുത്തുക
മെത്തേഡുകൾക്കും കൺസ്ട്രക്ടറുകൾക്കും പരാമീറ്ററായി നൽകുന്നവയാണ് പരാമീറ്റർ എന്ന വിഭാഗത്തിൽ പെടുന്നത്. മെയിൻ മെത്തേഡിന് പരാമീറ്ററായി നൽകുന്ന args ഇതിനൊരു ഉദാഹരണമാണ്.
വേരിയബിളുകൾക്ക് പേരിടുമ്പോൾ ചിലകാര്യങ്ങൾ ശ്രദ്ധിക്കുക:
- ആദ്യക്ഷരം അക്ഷരങ്ങൾ, അണ്ടർസ്കോറ് അല്ലെങ്കിൽ $ ചിഹ്നം എന്നിവയിൽ ഒന്നാകണം. ബാക്കി എന്ത് അക്ഷരവുമാകാം. എങ്കിലും പൊതുവേ അണ്ടർസ്കോർ, $ എന്നിവ ഒഴിവാക്കാറാണ് പതിവ്‌
- കേസ് സെൻസിറ്റീവാണ് വേരിയബിളുകൾ.
- ഒരു നല്ല ശീലമനുസരിച്ച് ഒറ്റ വാക്കേഉള്ളൂ എങ്കിൽ എല്ലാം ചെറിയ അക്ഷരം (ഉദാ: salary) മാത്രം ഉപയോഗിക്കുക. ഒന്നിലേറെ ഉണ്ടെങ്കിൽ ആദ്യത്തെ അക്ഷരം ചെറുതായും, തുടർന്നു വരുന്ന വാക്കുകളുടെ ആദ്യക്ഷരം കാപ്പിറ്റലുമാക്കുക (ഉദാ: myLongVariable)
- വേരിയബിൾ വില പ്രോഗ്രാമിനിടയിൽ ഒരിക്കലും മാറാൻ സാധ്യതയില്ലെങ്കിൽ മുഴുവൻ അപ്പർകേസ് ഉപയോഗിക്കാം (ഉദാ: float PI=3.14;). ഒന്നിലേറെ വാക്കുകൾ ചേർന്നാണ് വേരിയബിളിന് പേരിടുന്നതെങ്കിൽ തിരിക്കാൻ അണ്ടർസ്കോറ് ഉപയോഗിക്കാം. ഉദാഹരണം: I_WILL_NOT_CHANGE_VALUE
ഓപ്പറേറ്ററുകൾ തിരുത്തുക
വേരിയബിളുകൾ എങ്ങിനെ ഉണ്ടാ‍ക്കാമെന്ന് നാം കണ്ടു കഴിഞ്ഞല്ലോ. ഇനി വേരിയബിളിനകത്ത് സൂക്ഷിച്ചിരിക്കുന്ന വിലയെ നമുക്കാവശ്യമുള്ള രീതിയിൽ ഉപയോഗിക്കാനും മാറ്റം വരുത്താനും എന്ത് ചെയ്യണമെന്ന് നമുക്ക് നോക്കാം. ഇവിടെയാണ് വിവിധതരം ഓപ്പറേറ്ററുകൾ നമ്മുടെ സഹായത്തിനെത്തുന്നത്. ഒന്നോ, രണ്ടോ, മൂന്നോ വേരിയബിളുകൾ ഉപയോഗിക്കാവുന്ന നാൽപ്പതിലധികം ഓപ്പറേറ്ററുകൾ ജാവയിലുണ്ട്. ഉദാഹരണത്തിന് രണ്ട് സംഖ്യകൾ തമ്മിൽ കൂട്ടാൻ +, ഒന്ന് മറ്റേതിനേക്കാൾ ചെറുതാണോ എന്നു കണ്ടെത്താൻ <, ഒരു സംഖ്യയുടെ കൂടെ ഒന്നു കൂട്ടി അതേ വേരിയബിളിൽ സൂക്ഷിക്കാൻ ++ എന്നിങ്ങനെ.
ഓപ്പറേറ്റർ മുൻ‌ഗണനാക്രമം (Operator Precedence) അനുസരിച്ചുള്ള പട്ടികയാണ് താഴെക്കൊടുത്തിരിക്കുന്നത്. ഏറ്റവും മുകളിലെ ഓപ്പറേറ്ററുകൾക്ക് കൂടുതലും താഴേക്കു പോകും തോറും കുറഞ്ഞുമിരിക്കും.
ഓപ്പറേറ്റർ മുൻ‌ഗണന തിരുത്തുക
| ടൈപ്പ് | ഓപ്പറേറ്റർ | |
|---|---|---|
| പോസ്റ്റ്ഫിക്സ് | ++, -- | |
| യൂണറി | ++, --, +, -, ~, ! | |
| ഗുണനം | *, /, % | |
| സങ്കലനം | +, - | |
| ഷിഫ്റ്റ് | <<, >>, >>>, | |
| റിലേഷനൽ | <, >, <=, >=, instanceof | |
| സമത്വം | ==, !=, | |
| ബിറ്റ്‌വൈസ് ആൻഡ് | & | |
| ബിറ്റ്‌വൈസ് എക്സ്ക്ലുസീവ് ഓർ | ^ | |
| ബിറ്റ്‌വൈസ് ഇങ്ക്ലുസിവ് ഓർ | ||
| ലോജിക്കൽ ആൻഡ് | && | |
| ലോജിക്കൽ ഓർ | ||
| ടെർണറി | ? : | |
| അസ്സൈൻ‌മെന്റ് | =, <<=, >>=, >>>= |
ഇവയേപ്പറ്റി കൂടുതലും ഇവയുടെ ഉപയോഗങ്ങളും നമുക്കു വഴിയേ കാണാം.
എക്സ്പ്രഷനുകൾ തിരുത്തുക
എഴുതപ്പെടുന്ന ഭാഷയുടെ നിയമങ്ങൾ അനുസരിക്കുന്ന, ഒരു വില കണക്കാക്കാൻ വേണ്ടി ഉപയോഗിക്കുന്ന, പല വേരിയബിളുകളും ഓപ്പറേറ്ററുകളും കൂടിച്ചേർന്നുണ്ടാകുന്ന ഒരു വാക്യമാണ് എക്സ്പ്രഷൻ. ഉദാഹരണത്തിന് y=a+b*x-1/d അല്ലെങ്കിൽ String str="Hello!";. ഒരേ എക്സ്പ്രഷനകത്ത് ഒന്നിലധികം ഓപ്പറേറ്ററുകളും വേരിയബിളുകളും വരാം. ഈ സന്ദർഭത്തിൽ ഓപ്പറേറ്ററുകളുടെ മുൻ‌ഗണനാക്രമം അനുസരിച്ചാണ് ഈ വാക്യത്തിന്റെ വില നിശ്ചയിക്കപ്പെടുക. ഈ ഉദാഹരണത്തിൽ ഗുണന, ഹരണ ചിഹ്നങ്ങൾക്ക് ജാവയിൽ സങ്കലന, വ്യവകലന ചിഹ്നങ്ങളേ അപേക്ഷിച്ച് മുൻ‌ഗണ കൊടുക്കപ്പെടുന്നു. ഇതിനാൽ റൺ‌ടൈമിൽ ഈ എക്സ്പ്രഷനെ ഇടത്തു നിന്നും വലത്തോട്ട് വിശകലനം ചെയ്ത് b*x, 1/d എന്നിവ ആദ്യം കണക്കാക്കും. അതിനു ശേഷം a+(b*x ന്റെ വില)കണക്കാക്കി 1/d യുടെ വില അതിൽ നിന്നും കുറക്കും. ഇതിന്റെ അവസാന വില y എന്ന വേരിയബിളിലേക്ക് സൂക്ഷിക്കും. ഇനി, എനിക്ക് ഇതേ എക്സ്പ്രഷനെ y=(a+b)*(x-1)/d എന്ന് മാറ്റിയെഴുതാം. ഇപ്പോൾ നാം ഓപ്പറേറ്റർ മുൻ‌ഗണനാക്രമത്തിനെ മറികടന്ന് വിലകാണുന്ന രീതിയെ മാറ്റിയെടുക്കുകയാണ് ചെയ്തിരിക്കുന്നത്. ബ്രാക്കറ്റിട്ടാൽ വിശകലനസമയത്ത് ആ ക്രിയ ആദ്യം ചെയ്യപ്പെടും. ഈ ഉദാഹരണത്തിൽ ഇപ്പോൾ (a+b), (x-1) എന്നിവയാണ് ആദ്യം ചെയ്യപ്പെടുക. പിന്നീട് (a+b)*(x-1) ഉം അതേത്തുടർന്ന് (a+b)*(x-1)/d യും കണക്കാക്കപ്പെടും. ബ്രാക്കറ്റുകൾക്കകത്ത് ബ്രാക്കറ്റുകൾ വന്നാൽ ഏറ്റവും ഉള്ളിലെ ബ്രാക്കറ്റായിരിക്കും ആദ്യം കണക്കാക്കപ്പെടുക. ഉദാഹരണത്തിന്, y=(a+b)*((x-1)/d) എന്നെഴുതിയാൽ ആദ്യം (x-1), പിന്നെ (a+b), ((x-1)/d) എന്നിവ, തുടർന്ന് (a+b)*((x-1)/d) എന്നിങ്ങനെ കണക്കാക്കപ്പെടും. എപ്പോഴും ബ്രാക്കറ്റുകളുപയോഗിച്ച് ഗ്രൂപ്പ് ചെയ്ത് എക്സ്പ്രഷനെഴുതുന്നതാണ് അഭികാമ്യം.
സ്റ്റേറ്റ്മെന്റുകൾ തിരുത്തുക
ഏതൊരു പൂർണ്ണമായ എക്സിക്യൂട്ട് ചെയ്യാവുന്ന കോഡിന്റെ യൂണിറ്റിനേയും ഒരു സ്റ്റേറ്റ്മെന്റായി കണക്കാക്കാം. ഉദാഹരണത്തിന് ഒരു ക്ലാസിന്റെ ഒബ്ജക്റ്റ് ഡിക്ലയർ ചെയ്യുന്നത് ഒരു സ്റ്റേറ്റ്മെന്റാണ്. ഇതൊരു ഡിക്ലറേഷൻ സ്റ്റേറ്റ്മെന്റ് ആണെന്നു പറയും. ഇതുപോലെ തന്നെ എക്സ്പ്രഷൻ സ്റ്റേറ്റ്മെന്റുകൾ, കണ്ട്രോൾ ഫ്ലോ സ്റ്റേറ്റ്മെന്റുകൾ എന്നിവയും ഉണ്ട്.
- MyClass obj= new MyClass();
- int i;
- i=0;
- System.out.println("Hello World!");
തുടങ്ങിയവ ചില ഉദാഹരണങ്ങളാണ്.
ബ്ലോക്കുകൾ തിരുത്തുക
ഒരു പറ്റം സ്റ്റേറ്റ്മെന്റുകളെ ബ്രേസുകൾക്കുള്ളിൽ ( {,} )ഗ്രൂപ്പ് ചെയ്യുന്നതിനെയാണ് ഒരു ബ്ലോക്ക് എന്നു വിളിക്കുന്നത്. ക്ലാസുകൾ, മെത്തേഡുകൾ തുടങ്ങിയവ ബ്രേസുകൾക്കകത്ത് സ്റ്റേറ്റ്മെന്റുകളെ അടുക്കി വെയ്ക്കുന്നത് കണ്ടിട്ടില്ലേ? ഉദാഹരണമായി താഴെ കൊടുത്തിരിക്കുന്ന ക്ലാസ് നോക്കുക:
class MyClass {
public static void main(String[] args) {
if (1==2) { // ഒരു ബ്ലോക്ക്
System.out.println("1==2");
} // ആദ്യത്തെ ബ്ലോക്ക് അവസാനിക്കുന്നു
else { // മറ്റൊരു ബ്ലോക്ക്
System.out.println("No, 1 not 2");
} // രണ്ടാമത്തെ ബ്ലോക്ക് അവസാനിക്കുന്നു
}
}
ബ്ലോക്കുകൾക്കകത്ത് വേരിയബിളുകൾ നിർ‌വചിക്കുമ്പോൾ സൂക്ഷിക്കുക: ആ വേരിയബിളുകൾ ബ്ലോക്കിനു പുറത്ത് നിലനിൽക്കുന്നവയല്ല. അതിനാൽ, ആ വേരിയബിളുകൾ ബ്ലോക്കിനു പുറത്ത് ലഭ്യമാവണമെങ്കിൽ പുറത്ത് നിർവചിക്കാൻ ശ്രദ്ധിക്കണം.
കണ്ട്രോൾ ഫ്ലോ സ്റ്റേറ്റ്മെന്റുകൾ തിരുത്തുക
നാം പ്രോഗ്രാമുകളെഴുതുമ്പോൾ പല ഘട്ടങ്ങളിലും നമുക്ക് എക്സിക്ക്യൂഷന്റെ ഗതി സാധാരണയായി സംഭവിക്കുന്ന മുകളിൽ നിന്നും താഴോട്ട് എന്ന രീതിയിൽ മാറ്റം വരുത്തേണ്ടി വരും. ഇതിനാണ് നാം കണ്ട്രോൾ ഫ്ലോ സ്റ്റേറ്റ്മെന്റുകൾ ഉപയോഗിക്കുന്നത്. അതാത് സമയത്തെ അവസ്ഥകൾക്കനുസൃതമായി തീരുമാനങ്ങൾ എടുക്കുകയും അതിനോടനുബന്ധിച്ച് ഒരു പ്രത്യേക ബ്ലോക്ക് കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക (if, if-else, switch), ഒരു കാര്യം പല വട്ടം ആവർത്തിക്കുക (for, while, do-while), വഴിതിരിച്ചു വിടുക (continue, break, return) എന്നിവയാണ് ജാവയിൽ ഉള്ള കണ്ട്രോൾ ഫ്ലോ സ്റ്റേറ്റ്മെന്റുകൾ.
ഈ ഉദാഹരണം നോക്കൂ -
if(a==b){
a+=b;
}
ഇതൊരു സാധാരണ ഇഫ് ബ്ലോക്കാണ്. a==b എന്ന ലോജിക്കൽ കണ്ടീഷൻ ട്രൂ ആവുന്ന അവസ്ഥയിൽ അത് ബ്ലോക്ക് എക്സിക്ക്യൂട്ട് ചെയ്യും. ഇവയെല്ലാം തന്നെ ലോജിക്കൽ കണ്ടീഷനാണ് പരിശോധിക്കുന്നത്.
if(a==b){
a+=b;
}else{
a*=b;
}
കഴിഞ്ഞ ഉദാഹരണത്തിൽ a==b സത്യമല്ലെങ്കിൽ പ്രോഗ്രാം ഒന്നും ചെയ്യാതെ ആ ബ്ലോക്കിനു ശേഷമുള്ള ആദ്യത്തെ സ്റ്റേറ്റ്മെന്റിലേക്കു പോകുമായിരുന്നു. ഇവിടെ അത് എൽ‌സ് ബ്ലോക്കിലെ കോഡ് എക്സിക്യൂട്ട് ചെയ്യും.
ഒരു പ്രിമിറ്റീവ് ഡാറ്റാടൈപ്പ് വേരിയബിളിന്റെ (char, int, byte, short) തത്സമയത്തെ വിലകൾ അനുസരിച്ച് തീരുമാനമെടുക്കാനുള്ള ഒരു ഉപാധിയാണ് സ്വിച്ച്. സാധാരണയായി ഉപയോഗിക്കുന്ന വിധം താഴെക്കൊടുക്കുന്നു.
switch(variable){
case 1:
//Code for this condition
break;
case 2:
//Code for this condition
break;
case 3:
//Code for this condition
break;
default:
//Code for this condition
break;
}
ഓരോ കേസ് ബ്ലോക്കിനകത്തേയും ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റുകൾ ശ്രദ്ധിക്കുക. സ്വിച്ച് സ്റ്റേറ്റ്മെന്റിൽ ഒരു കണ്ടീഷൻ ട്രൂ ആയാൽ താഴോട്ടുള്ളതെല്ലാൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ഇതൊഴിവാക്കാനാണ് ഓരോ കേസും ബ്രേക്കിൽ അവസാനിക്കുന്നത്. ഡീഫോൾട്ട് കണ്ടീഷൻ മറ്റൊന്നും സത്യമാവാത്ത അവസ്ഥയിലാണ് ഓടുക.
ഒരേ കാര്യം ഒന്നിലേറെ പ്രാവശ്യം ആവർത്തിക്കേണ്ടി വരുമ്പോൾ നാം ലൂപ്പിങ്ങ് സ്റ്റേറ്റ്മെന്റുകളെ ആശ്രയിക്കുന്നു. ഇതിനായി ജാവയിൽ ഉള്ളവ for, while, do-while എന്നിവയാണ്.
ചെയ്യുന്നകാര്യം ഒരു നിശ്ചിത തവണ ആവർത്തിക്കേണ്ട അവസരത്തിൽ ഫോർ ഉപ്യോഗിക്കാം: ഈ ലൂപ്പ് ശ്രദ്ധിക്കൂ.
for(int i=0;i<100;i++){
System.out.println(i);
}
ഇതിൽ ഫോർ ഡിക്ലറേഷനിൽ സെമി കോളൻ (;) വെച്ച് വേർ തിരിച്ചിട്ടുള്ള മൂന്ന് ഭാഗങ്ങൾ കാണാം. int i=0 എന്ന ആദ്യ ഭാഗം ഉപയോഗിക്കേണ്ട ഇന്റിജർ വേരിയബിൾ (കൌണ്ടർ വേരിയബിൾ) ഏതാണെന്നു പറഞ്ഞു തരുന്നു. i നേരത്തേ നിർ‌വചിച്ചിട്ടുണ്ടെങ്കിൽ i=0; എന്ന് മാത്രം കൊടുത്താൽ മതി. തുടക്കത്തിൽ തന്നെ ആ വിലയും നൽകിയിട്ടുണ്ടെങ്കിൽ വെറുതേ i; എന്ന് മാത്രം കൊടുക്കാം.
അതായത്,
for(int i=0;i<100;i++){}
അല്ലെങ്കിൽ
int i;
for(i=0;i<100;i++){}
അല്ലെങ്കിൽ
int i=0;
for(i;i<100;i++){}
എന്നെല്ലാം ഇത് എഴുതാം. അതിൽ രണ്ടാമത്തെ ഭാഗം ലൂപ്പ് ഓടാനുള്ള കണ്ടീഷനാണ്. ഇതിന് ടെർമിനേറ്റിങ്ങ് കണ്ടീഷൻ എന്നും പറയും. ഈ ഉദാഹരണത്തിൽ i<100 ആണ് കണ്ടീഷൻ. മൂന്നാമതുള്ള ഭാഗം വേരിയബിളിന്റെ വില മാറ്റാനുള്ള എക്സ്പ്രഷനാണ്. i എന്ന വേരിയബിളിന്റെ വില നൂറിൽ താഴെ നിൽക്കുന്നിടത്തോളം ലൂപ്പിന്റെ ബ്ലോക്കിനകത്തെ കോഡ് പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്തു കൊണ്ടിരിക്കും.
while, do-while ലൂപ്പുകൾ കൌണ്ടർ വേരിയബിൾ ഉപയോഗിക്കുന്നില്ല. പകരം ഒരു കണ്ടീഷണൽ എക്സ്പ്രഷന്റെ സത്യാവസ്ഥയ്ക്കനുസൃതമായി ലൂപ്പിനെ ആവർത്തിക്കുകയാണ് ഇവ ചെയ്യുന്നത്.
ഉദാഹരണത്തിന്:
while(a>b){
//Code block to be repeated here
a--;
}
അല്ലെങ്കിൽ
do{
a--;
}while(a>b)
രണ്ടും തമ്മിലുള്ള പ്രധാന വ്യത്യാസം while ലൂപ്പ് ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനു മുൻപ് കണ്ടീഷൻ പരിശോധിക്കും, എന്നാൽ do-while ലൂപ്പ് ഒരു പ്രാവശ്യം ഓടിയതിനു ശേഷം മാത്രമേ കണ്ടീഷൻ പരിശോധിക്കയുള്ളൂ എന്നതാണ്.
നിയന്ത്രണ ഗതി മാറ്റുന്നതിനുള്ള മറ്റ് കീവേഡുകളായ return, continue, break എന്നിവയാണ് മറ്റ് കണ്ട്രോൾ സ്റ്റേറ്റ്മെന്റുകൾ
return ഒരു മെത്തേഡിൽ നിന്നും തിരിച്ച് ആ മെത്തേഡ് വിളിച്ച കോഡ് ബ്ലോക്കിലേക്ക് നിയന്ത്രണം കൈ മാറാനുള്ള ഉപാധിയാണ്. നിയന്ത്രണത്തോടൊപ്പം വേരിയബിളുകളുടെ വിലയോ സ്റ്റാറ്റസ് കോഡുകളോ കൈമാറാൻ ഇവ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്
void myMethod(){
int i= add(a,b);
if(i==(-1)){
//One of the variables were less than zero. Do what we need to do
}else{
//Ok, we have value. Do what we need to do
{
}
int add(int a, int b){
if(a<0||b<0){
return -1; //Returning error because atleast one of them were negative
}
return a+b; //Returning sum
}
continue ലൂപ്പ് ബ്ലോക്കിന്റെ തുടക്കത്തിലേക്ക് നിയന്ത്രണം കൈമാറാനും break ലൂപ്പ് ബ്ലോക്ക് കഴിഞ്ഞുള്ള ആദ്യ സ്റ്റേറ്റ്മെന്റിലേക്ക് നിയന്ത്രണം കൈമാറാനുമാണ് ഉപയോഗിക്കുന്നത്. ഉദാഹരണത്തിന്:
int i;
for(i=0; i<1000; i++){
if (i==23||i==34){
continue; //Dont do anything, just skip them
}
if(i==89){
break; // Get out of this loop
}
}
i=add (i, 100); // This line is executed when i==89