ജാവ പ്രോഗ്രാമിങ്ങ്/അദ്ധ്യായം 3

ക്ലാസുകൾ

ഈ അദ്ധ്യായത്തിൽ നമുക്കു ക്ലാസുകളേക്കുറിച്ച് കൂടുതൽ നോക്കാം. ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ആശയത്തിന്റെ പ്രധാന ആശയങ്ങൾ നാം നമ്മുടെ ക്ലാസുകളിലൂടെയാണ് നിർമ്മിക്കുന്നത്. പ്രൊസിജ്യറൽ പ്രോഗ്രാമിങ്ങിൽ നാം എന്തു ചെയ്യണം? എന്നതാണ് പ്രധാന ചോദ്യമെങ്കിൽ ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിങ്ങിൽ നമ്മുടെ കയ്യിലുള്ള ഡാറ്റ എന്താണ്? അതിനെ നാം എന്താണ് ചെയ്യേണ്ടത്? എന്നിവയാണ് പ്രധാനം. ക്ലാസുകൾ നമ്മുടെ ഡാറ്റയേയും ഡാറ്റയിൽ ഓപ്പറേറ്റ് ചെയ്യാനുള്ള മെത്തേഡുകളേയും ഒന്നിച്ച് ഒരു ചട്ടക്കൂടിൽ ഒതുക്കുന്നു. ക്ലാസ് ഡിക്ലയർ ചെയ്യുന്നതും ഉപയോഗിക്കുന്നതിന്റേയും ഒരുദാഹരണം നാം മുൻപ് കണ്ടതാണല്ലോ. പൊതുവേ ഒരു ക്ലാസ് ഡിക്ലയർ ചെയ്യുന്നതിന്റെ സിന്റാക്സ് താഴെപ്പറയുന്നവയാണ്.

class <ക്ലാസിന്റെ പേര്> {
//മെത്തേഡുകൾ, വേരിയബിളുകൾ, ഇന്നർ ക്ലാസുകൾ, കൺസ്ട്രക്ടർ തുടങ്ങിയവ
}

ക്ലാസിന്റെ പ്രധാന ഘടകങ്ങൾ

1. പാക്കേജ് ഡെഫനി‍ഷൻ

പാക്കേജ് എന്നാൽ ഒരു സംഘം ക്ലാസുകളെ ഒന്നിച്ചു തരം തിരിക്കുന്നതിന് ജാവയിലുള്ള വഴിയാണ്. പാക്കേജുകൾ ഒരു ക്ലാസും അതിനകത്തെ ഡാറ്റയും അതിനോടനുബന്ധിച്ചുള്ള മെത്തേഡുകളും ആക്സസ് മോഡിഫയറുകൾ അനുസരിച്ച് എവിടെയെല്ലാം ലഭ്യമാണെന്നതിനെ നിയന്ത്രിക്കാനും സഹായിക്കുന്നു. ഇതിന്റെ സിന്റാക്സ്

package < full.qualified.package.name >;

എന്നാണ്. ഉദാഹര‍ണത്തിന് package com.techvidya.util; എന്നത് നമ്മുടെ ഒരു യൂട്ടിലിറ്റീസ് പാക്കേജിനെ സൂചിപ്പിക്കാനുപയോഗിക്കാം. എല്ല്ലാ ചെറിയ യൂട്ടിലിറ്റി ക്ലാസുകളും ഇതിൽ ചേർത്താൽ ഉപയോഗിക്കാനെളുപ്പമല്ലേ?

2. ഇമ്പോർട്ട് സ്റ്റേറ്റ്മെന്റുകൾ

നമുക്ക് നമ്മുടെ ക്ലാസിൽ ഉപയോഗിക്കേണ്ട മറ്റ് ക്ലാസുകളെ ലഭ്യമാക്കാനാണ് ഇവ ഉപയോഗിക്കുന്നത്. ഉദാഹരണത്തിന്, നമ്മൾ ഒരു കാൽക്കുലേറ്റർ ക്ലാസ് എഴുതി എന്നിരിക്കട്ടെ. ഇതിനെ എങ്ങനെ വേറെ ഒരു ക്ലാസിൽ ഒരു വൃത്തത്തിന്റെ വിസ്തീർണ്ണം കണക്കാക്കാൻ ഉപയോഗിക്കാം? കാൽക്കുലേറ്റർ ക്ലാസ് com.techvidya.util പാക്കേജിലാണ് ഉള്ളതെന്ന് കരുതുക. ഈ ക്ലാസിൽ നാം സ്താഴെപ്പറയുന്ന ഉദാഹരണം നോക്കൂ

package com.tutorial.util;
import com.tutorial.util.Calculator;

public class AreaOfCircle{
     float r;
     final float PI=3.14;

     public float calculateArea(){
          Calculator calc=new Calculator(); 
          float area = PI * calc.square(r); //πr2 വൃത്തത്തിന്റെ വിസ്തീർണ്ണം
          return area;
     }
}

3. ആക്സസ് മോഡിഫയറുകൾ

ക്ലാസുകൾക്ക് public, package-protected (ഒന്നും നൽകിയില്ലെങ്കിൽ) public, private, protected, package protected എന്നിവയാണ് പ്രധാനപ്പെട്ട ആക്സസ് മോഡിഫയറുകൾ. ഇവ ഒരു ക്ലാസ്, അകത്തുള്ള വേരിയബിളുകൾ, മെത്തേഡുകൾ എന്നിവ മറ്റൊരു ക്ലാസിൽ നിന്നോ മെത്തേഡിൽ നിന്നോ വിളിക്കാനുള്ള കഴിവിനെ നിയന്ത്രിക്കുന്നു. ഉദാഹരണത്തിന് നമ്മൾ പബ്ലിക്കായി ഡിക്ലയർ ചെയ്യുന്ന ഒരു വേരിയബിളോ മെത്തേഡോ ക്ലാസോ മറ്റു ക്ലാസുകൾക്ക് സ്വതന്ത്രമായി ഉപയോഗിക്കാം. എന്നാൽ പ്രൊട്ടെക്റ്റഡ് ആയി നിർവചിക്കപ്പെട്ടിട്ടുള്ളവ അതേ ക്ലാസിൽ ഉപയോഗിക്കാമെങ്കിലും അതിന്റെ സബ്‌ക്ലാസിനും പാക്കേജിൽ തന്നെയുള്ള മറ്റുക്ലാസുകളിലും മാത്രമേ ഉപയോഗിക്കാനാവൂ. പ്രൈവറ്റായവ ആ ക്ലാസിൽ മാത്രമേ നേരിട്ടുപയോഗിക്കാൻ സാധിക്കൂ. അവയേ മറ്റൊരു ക്ലാസിലോ പാക്കേജിലോ ഉപയോഗിക്കണമെങ്കിൽ പ്രൈവറ്റ് മെമ്പർ ഉള്ള ക്ലാസിൽ ഒരു പബ്ലിക്ക് മെത്തേഡ് സഹായിക്കണം. ആക്സസ് മോഡിഫയർ ഒന്നും കൊടുത്തില്ലെങ്കിൽ അതിനെ പാക്കേജ് പ്രൊട്ടക്റ്റഡ് മോഡായി കണക്കാ‍ക്കാം. താഴെക്കൊടുത്തിരിക്കുന്ന ടേബിളിൽ ആക്സസ് മോഡിഫയറുകൾ നൽകിയാൽ ഒരു മെമ്പർ ആക്സസ് ചെയ്യപ്പെടാവുന്ന സ്ഥലങ്ങൾ കൊടുത്തിരിക്കുന്നു

മോഡിഫയർ	അതേ ക്ലാസിൽ	അതേ പാക്കേജിൽ	സബ്‌ക്ലാസിൽ	മറ്റെല്ലായിടത്തും
public	ഉപയോഗിക്കാം	ഉപയോഗിക്കാം	ഉപയോഗിക്കാം	ഉപയോഗിക്കാം
protected	ഉപയോഗിക്കാം	ഉപയോഗിക്കാം	ഉപയോഗിക്കാം	സാധ്യമല്ല
no modifier	ഉപയോഗിക്കാം	ഉപയോഗിക്കാം	സാധ്യമല്ല	സാധ്യമല്ല
private	ഉപയോഗിക്കാം	സാധ്യമല്ല	സാധ്യമല്ല	സാധ്യമല്ല

4. ക്ലാസിന്റെ പേര്

ഇത് സാധാരണ ശൈലി അനുസരിച്ച് MyClassName എന്ന രീതിയിലാണ് എഴുതുക. myclass, MYClass എന്നെല്ലാം എഴുതിയാലും കുഴപ്പമില്ലെങ്കിലും, നല്ലത് പൊതുവേ അവലംബിക്കുന്ന ശൈലികളിൽ എഴുതി ശീലിക്കുന്നതാണ്.

5. വേരിയബിളുകൾ

ഇതിലാണ് നമ്മുടെ ഡാറ്റ സൂക്ഷിക്കുന്നത്. വീട്ടിലെ അടുക്കളയിൽ പലവ്യഞ്ജനങ്ങളിട്ടു വെക്കുന്ന ചെറിയ പാത്രങ്ങൾ കണ്ടിട്ടില്ലേ? വേരിയബിളുകളെ അതിനോടുപമിക്കാം. ഒരു പ്രത്യേക വിഭാഗത്തിൽ (അല്ലെങ്കിൽ ഡാറ്റാ ടൈപ്പിൽ) പെടുന്ന ഒബ്ജക്റ്റുകളെ താൽക്കാലികാവശ്യത്തിനു സൂക്ഷിക്കാൻ നമ്മൾ ഉപയോഗിക്കുന്ന മെമ്മറി ലൊക്കേഷന്റെ പേരാണ് വേരിയബിൾ. ഉപ്പിന്റെ പാത്രത്തിൽ നാം മുളകുപൊടി വെക്കാറില്ലെന്നതു പോലെ തന്നെ, വേരിയബിളുകൾ മുൻ‌നിശ്ചയിച്ച ഡാറ്റാടൈപ്പിലെ ഒബ്ജക്റ്റുകൾ മാത്രം സൂക്ഷിക്കുന്നു. ഉദാഹരണത്തിന്,

String myName="വിക്കിബുക്സ്";

എന്ന് നാം പറയുമ്പോൾ name എന്ന വേരിയബിൾ ഒരു String ഒബ്ജക്റ്റ് സൂക്ഷിക്കും എന്ന് നാം കമ്പൈലറിന് പറഞ്ഞു കൊടുക്കുന്നു. അതുകൊണ്ട് തന്നെ, നാം

String name=3.14;

എന്നു പറഞ്ഞാൽ ശരിയാവുമോ? ഇത് കമ്പൈൽ ചെയ്യാൻ നോക്കിയാൽ കമ്പൈലർ ഇത് ഒരു ഇൻ‌കമ്പാറ്റിബിൾ ടൈപ്പ് ആണെന്ന് പറയും. കോഡെഴുതുമ്പോൾ നിർവചിക്കുന്ന ചെയ്യുന്ന ഡാറ്റാടൈപ്പുകൾ കമ്പാറ്റിബിൾ ആണോ എന്ന് പ്രത്യേകം ശ്രദ്ധിക്കണം. മുകളിൽ പറഞ്ഞ ആക്സസ് മോഡിഫയറുകൾ ഇവയ്ക്കും ബാധകമാണ്.

6. മെത്തേഡുകൾ

മെത്തേഡുകൾ അഥവാ ഫങ്ഷനുകൾ നമ്മൾ സംഭരിച്ചു വെച്ചിരിക്കുന്ന ഡാറ്റയെ നമുക്കാവശ്യമുള്ള രീതിയിൽ മാറ്റുന്നതിനും, നാം ചെയ്യാനുദ്ദേശിക്കുന്നകാര്യങ്ങൾ സ്റ്റെപ്പുകളായി നടപ്പിലാക്കുന്നതിനുമുള്ള വഴിയാണ്. ഉദാഹരണത്തിന്,

public int add(int a, int b){
return (a+b);
}

എന്ന കോഡ് രണ്ട് സംഖ്യകൾ കൂട്ടി വില തിരിച്ചു കൊടുക്കുന്ന ഒരു മെത്തേഡാണ്.

7. ബ്രേസുകൾ ({,})

എല്ലാ കോഡ് സെഗ്മന്റുകളേയും നാം ബ്ലോക്കുകളിലാക്കി തിരിക്കുന്നതു പോലെ ഒരു ക്ലാസിന്റെ ഉള്ളിലുള്ളവയെല്ലാം ചേർത്ത് ഒരു ബ്ലോക്കാക്കാനാണ് ബ്രേസുകൾ ഉപയോഗിക്കുന്നത്. അകത്തെ മെത്തേഡുകളും, അതിനുള്ളിലെ ബ്ലോക്കുകളുമെല്ലാം ഇതിനകത്തെ നെസ്റ്റഡ് ബ്ലോക്കുകളായാണ് നിർ‌വ്വചിക്കുന്നത്.

8. ഇമ്പ്ലിമെറ്റ് ചെയ്യുന്ന ഇന്റർഫേസുകളും എക്സ്റ്റൻഡ് ചെയ്യുന്ന ക്ലാസുകളും.

ഒരിക്കൽ എഴുതി, ടെസ്റ്റ് ചെയ്ത് ബഗ്ഗുകൾ ഇല്ല്ലാതാക്കിയ കോഡിനെ പുനരുപയോഗം ചെയ്യാനും, ഒരു ക്ലാസിൽ ഉള്ള മെത്തേഡുകളുടെ സ്വഭാവം മാറ്റാനും, പുതിയത് ചേർക്കാനും ഉപയോഗിക്കുന്ന ഒരു വഴിയാണ് ഇൻ‌ഹെറിറ്റൻസ്. ഇൻ‌ഹെറിറ്റൻസ് നടപ്പിലാക്കാനുള്ള ജാവയിലെ വഴിയാണ് extends, implements എന്നീ കീവേഡുകൾ. ഒരു ക്ലാസിനെ നമ്മൾ എക്സ്റ്റെന്റ് ചെയ്യുകയും ഒരു ഇന്റർഫേസിനെ ഇമ്പ്ലിമെന്റ്റ് ചെയ്യുകയും ചെയ്യും. ഇതിനേപ്പറ്റി കൂടുതലായി നമുക്കു പിന്നീട് മനസ്സിലാക്കാം.

class MyNewClass extends TheSuperClass implements SomeInterface {
//ഫീൽഡ്, മെത്തേഡ്, ഓവർ റൈഡിങ്ങ് ഫങ്ഷൻസ് മുതലായവ
}

ആദ്യത്തെ അദ്ധ്യായത്തിലെ ഉദാഹരണം ഒന്നുകീടി നോക്കൂ. ക്ലാസിന്റെ പ്രധാന ഘടകങ്ങൾ ഇപ്പോൾ കുറച്ചു കൂട്രി വ്യക്തമായി മനസ്സിലാവുന്നില്ലേ?