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

മെത്തേഡുകൾ

ഈ ആദ്ധ്യായത്തിൽ മെത്തേഡുകളെക്കുറിച്ച് നമുക്കു കുറച്ചുകൂടി കാണാം. മുൻപു പറഞ്ഞതു പോലെ, മെത്തേഡുകളാണ് നമുക്കു ചെയ്യേണ്ട ഓപ്പറേഷനുകൾ നിർ‌വഹിക്കുന്നത്. രണ്ട് സംഖ്യകൾ തമ്മിൽ കൂട്ടുന്നതു മുതൽ സാറ്റലൈറ്റ് നിയന്ത്രണം വരെയുള്ള കാര്യങ്ങൾ നമുക്ക് മെത്തേഡുകളിൽ എഴുതാവുന്നതാണ്. ഒരു മെത്തേഡിന്റെ പൊതുവായ ശൈലി താഴെക്കാണാം

<ആക്സസ് മോഡിഫയർ> <റിട്ടേൺ ടൈപ്പ്> പേര് (<ഇൻപുട്ട് വേരിയബിൾ1>, <ഇൻപുട്ട് വേരിയബിൾ2>.....){
// ഫങ്ഷനകത്ത് ചെയ്യേണ്ട കാര്യങ്ങൾ

}

ഉദാഹരണത്തിന്

private double calcSimpleInterest(double P, float rate, int term){
       
       double interest = P*rate*term; //പലിശ കണക്കാക്കുന്നു
       return interest; //ഈ മെത്തേഡിനെ വിളിക്കുന്ന മെത്തേഡിലേക്ക് 
                        //കണക്കാക്കിയ വില തിരിച്ചു കൊടുക്കുന്നു. 

}

ഇതിന്റെ ഡിക്ലറേഷൻ നോക്കൂ. ആദ്യത്തെ പ്രൈവറ്റ് എന്ന കീവേഡാണ് ഇതിലെ ആക്സസ് മോഡിഫയർ. അതിനു ശേഷം വരുന്ന ഡബിൾ, ഈ മെത്തേഡ് തിരിച്ചുകൊടുക്കുന്നത് ഒരു ഡബിൾ വിലയാണെന്ന് പറയുന്നു. ഇതാണ് റിട്ടേൺ ടൈപ്പ്. calcSimpleInterest എന്നതാണ് മെത്തേഡിന്റെ പേര്. ബ്രാക്കറ്റിനകത്തെ പി, റേറ്റ്, ടേം എന്നിവ ഇൻപുട്ട് പരാമീറ്ററുകളാണ്. അവയാണ് മെത്തേഡിനകത്ത് പ്രോസസ് ചെയ്യേണ്ട ഡാറ്റ.

ഇനി ഇതിനെ മറ്റൊരു മെത്തേഡിൽ എങ്ങനെ ഉപയോഗിക്കും? താഴെയുള്ള ഉദാഹരണം നോക്കൂ

public int interestTable(){ 
//This function will list the interest gained over a 10 year investment
     double P; 
     float rate;

     //input the Principal and rate

     for(int i=1;i<=10;i++){
         double interest = calcSimpleInterest(P, rate, i);
         System.out.println("Year: "+i+" - Interest: "+ interest);
     }

     return 0;
}

ഇവിടെ System.out.println("Year: "+i+" - Interest: "+ interest); എന്നത് ജാവയിലെ സിസ്റ്റം പാക്കേജിൽ കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യാനുപയോഗിക്കുന്ന മെത്തേഡാണ്. നമ്മൾ ഇത് സർവ്വസാധാരണമായി ഉപയോഗിക്കുന്ന ഒരു മെത്തേഡുമാണ്. ഒരു മെത്തേഡിന്റെ പരാമീറ്ററായി മറ്റൊരു മെത്തേഡ് കോൾ കൊടുക്കുന്നതും സാധാരണയാണ്. ഉദാഹരണാത്തിന്, System.out.println("Year: "+i+" - Interest: "+calcSimpleInterest(P, rate, i)); എന്നു കൊടുത്താലും ശരിയാവും. ഇത് പ്രോഗ്രാമിന്റെ റീഡബിലിറ്റിയെ ബാധിക്കുമെങ്കിലും, ഒരു വേരിയബിൾ കുറയ്കാൻ സഹായിക്കും.

ഓവർലോഡിങ്ങ്=

ഒരേ ക്ലാസിനകത്ത് ഒരേ പേരിൽ, വ്യത്യസ്ഥങ്ങളായ ഇൻ‌പുട്ട് പരാമീറ്ററുകൾ സ്വീകരിക്കുന്ന മെത്തേഡുകൾ ഉണ്ടാ‍കാം. ഇതിനെ മെത്തേഡ് ഓവർലോഡിങ്ങ് എന്നു വിളിക്കുന്നു. മുകളിലെ ഉദാഹരണത്തിലെ

private double calcSimpleInterest(double P, float rate, int term) എന്ന മെത്തേഡ് നമുക്ക് പല സന്ദർഭങ്ങളിലും വ്യത്യസ്ത വിലകൾ സ്വീകരിക്കാവുന്ന രീതിയിൽ വേണ്ടി വന്നേക്കാം. റേറ്റ് പ്രിൻസിപ്പലും ടേമിലും അടിസ്ഥാനമാക്കി calcSimpleInterest എന്ന മെത്തേഡിനകത്ത് തീരുമാനിക്കുന്ന ഒരു അവസ്ഥയുണ്ടെങ്കിൽ private double calcSimpleInterest(double P, int term) എന്നൊരു മെത്തേഡ് ആവശ്യമായി വരും. അപ്പോൾ നാം ഒരേ ക്ലാസിൽ രണ്ടിനേയും നിർവചിക്കും. മെത്തേഡ് വിളിക്കപ്പെടുമ്പോൾ അതിലേക്ക് നൽകുന്ന പരാമീറ്ററുകൾ അനുസരിച്ച് ജാവ ഏത് മെത്തേഡ് ഉപയോഗിക്കണമെന്ന് റൺ ടൈമിൽ തീരുമാനിക്കും

ഇനി നമുക്ക് ചില പ്രത്യേക മെത്തേഡുകളെ കാണാം:

main മെത്തേഡ്=

ഒരു ക്ലാസ് എക്സിക്ക്യൂട്ട് ചെയ്യുമ്പോൾ ജാവയുടെ റൺ ടൈം എൻ‌വയേണ്മെന്റ് ആദ്യം എക്സിക്യൂട്ട് ചെയ്യുന്ന മെത്തേഡാണ് മെയിൻ മെത്തേഡ്. ക്ലാസ് ഫയലിന്റെ അതേ പേരിലുള്ള ക്ലാസിൽ തന്നെയാവണം മെയിൻ മെത്തേഡ് എഴുതേണ്ടത്.

സാധാരണ മെത്തേഡ് സിഗ്നേച്ചർ താഴെക്കൊടുക്കുന്നു:

public static void main(String Args[]){

//steps

}

ഇതിൽ Args എന്ന സ്ട്രിങ്ങ് അറേ നമ്മൾ കമാൻഡ് ലൈനിൽ കൊടുക്കുന്ന വിലകളുടെ ലിസ്റ്റ് ആണ്. ഉദാഹരണത്തിന്, നാം ഒരു ജാവ ക്ലാസ് കമാൻഡ് ലൈനിൽ നിന്ന് റൺ ചെയ്യുന്നു എന്നിരിക്കട്ടെ,

C:\>java AddTwoNumbers 5 6

5,6 എന്നിവ Args[0], Args[1] എന്നീ അറേ ലൊക്കേഷനുകളിൽ നിന്നും ലഭിക്കും. കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ ഏത് ഡാറ്റാ ടൈപ്പായാലും മെയിൻ മെത്തേഡിനകത്ത് അതൊരു സ്ട്രിങ്ങ് ആറേയിലായിരിക്കും ലഭിക്കുക. മെയിൻ മെത്തേഡിനകത്താണ് നമ്മൾ സാധാരണ പ്രധാനപ്പെട്ട ക്ലാസുകളുടെ ഒബ്ജക്റ്റുകൾ നിർമ്മിച്ച് നിയന്ത്രണം അതിനു നൽകാറ്‌. ഇതാണ് നമ്മുടെ പ്രോഗ്രാമിൽ എക്സിക്യൂട്ട് ചെയ്തു തുടങ്ങുന്നതും ഏറ്റവും അവസാനം ടെർമിനേറ്റ് ചെയ്യപ്പെടുന്നതുമായ എക്സിക്യൂഷൻ ത്രെഡ്.

കൺസ്ട്രക്റ്റർ ഒരു ക്ലാസിന്റെ ഒബ്ജക്റ്റുകൾ നിർമ്മിക്കപ്പെടുമ്പോൾ അതിനെ ഇനിഷ്യലൈസ് ചെയ്യാനായി ഉപയോഗിക്കപ്പെടുന്ന പ്രത്യേക മെത്തേഡാണ് കൺസ്ട്രക്ടർ. അത് ഉൾക്കൊള്ളുന്ന ക്ലാസിന്റെ തന്നെ പേരിൽ ഒരു റിട്ടേൺ ടൈപ്പും ഇല്ലാത്ത മെത്തേഡാണ് ഒരു കൺസ്ട്രക്ടർ. കൺസ്ട്രക്ടർ ഒരു ഒബ്ജക്റ്റ് നിർമ്മിക്കപ്പെടുമ്പോൾ ആദ്യം വിളിക്കപ്പെടും. കൺസ്ട്രക്ടറുകൾ പൊതുവേ ക്ലാസിന്റെ മെംബർ വേരിയബിളുകൾ ഇനിഷ്യലൈസ് ചെയ്യാനും, ഡാറ്റാബേസ് കണക്ഷനുകൾ നിർമ്മിക്കാനും തുടങ്ങി ക്ലാസിന്റെ ശരിയായ പ്രവർത്തനത്തിനു വേദിയൊരുക്കുന്ന എന്തിനും ഉപയോഗ്യമാണ്. നാം കൺസ്ട്രക്ടർ നിർവചിക്കാത്ത പക്ഷം, കമ്പൈലർ സ്വയം ഒരു പരമീറ്ററുകളൊന്നുമില്ലാ‍ത്ത ഒരു കൺസ്ട്രക്ടർ കമ്പൈൽ ചെയ്ത ക്ലാസിലേക്ക് ചേർക്കും.

ഉദാഹരണത്തിന് നമ്മുടെ നേരത്തേയുള്ള പലിശ കണക്കാക്കുന്നത് ഒരു ക്ലാസ് ആണെന്നു കരുതുക. അതിന്റെ വേരിയബിളുകളായി പി, ടേം, റേറ്റ് എന്നിവയുണ്ടെങ്കിൽ

public InterestClass{
    double P;
    float rate;
    int term;

    InterestClass(double P, float rate, int term){
        this.P = P;
        this.rate = rate;
        this.term = term;
    }
 //Other stuff   

}

എന്നത് ഒരു കൺസ്ട്രക്ടറിന്റെ ഉദാഹരണമാണ്. നേരത്തെ കണ്ട ഉദാഹരണങ്ങൾ ചേർത്ത് ഒരു ക്ലാസുണ്ടാക്കിയാലോ?

public InterestClass{
    double P; //മെംബർ വേരിയബിൾ
    float rate;//മെംബർ വേരിയബിൾ
    int term;//മെംബർ വേരിയബിൾ

    InterestClass(double P, float rate, int term){ //കൺസ്ട്രക്ടർ
        this.P = P;
        this.rate = rate;
        this.term = term;
    }

    public int interestTable(){ 
         //This function will list the interest gained over a 10 year investment
         double P; 
         float rate;


         for(int i=1;i<=10;i++){
             double interest = calcSimpleInterest(P, rate, i);
             System.out.println("Year: "+i+" - Interest: "+ interest);
         } 

         return 0;
    }

    private double calcSimpleInterest(double P, float rate, int term){
       
       double interest = P*rate*term; //പലിശ കണക്കാക്കുന്നു
       return interest; //ഈ മെത്തേഡിനെ വിളിക്കുന്ന മെത്തേഡിലേക്ക് 
                        //കണക്കാക്കിയ വില തിരിച്ചു കൊടുക്കുന്നു. 

    }
//മെയിൻ മെത്തേഡ്. ഇതാണാദ്യം വിളിക്കപ്പെടുക
    public static void main(String Args[]){

         InterestClass inter = new InterestClass(4300.23, 0.06, 15);

         inter.interestTable();

    }

}