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

സ്റ്റാറ്റിക്ക് വേരിയബിളും മെത്തേഡും

ഈ അദ്ധ്യായത്തിൽ നമുക്ക് സ്റ്റാറ്റിക്ക് വേരിയബിളുകൾ, സ്റ്റാറ്റിക്ക് മെത്തേഡുകൾ തുടങ്ങിയവയേക്കുറിച്ച് കൂടുതൽ മനസ്സിലാക്കാം. ഒരു ഒബ്ജക്റ്റ് നിർമ്മിക്കാതെ തന്നെ നമുക്കു ഉപയോഗിക്കാൻ സാധിക്കുന്ന അല്ലെങ്കിൽ ഒരു ഒബ്ജക്റ്റിന്റെ ജീവിത ചക്രവും നിയന്ത്രിക്കാത്ത ഒരു വിഭാഗമാണ് സ്റ്റാറ്റിക്ക് മെത്തേഡുകളും വേരിയബിളുകളും.

സ്റ്റാറ്റിക്ക് വേരിയബിൾ (അല്ലെങ്കിൽ ക്ലാസ് വേരിയബിൾ)

മുൻപ് വിശദീകരിച്ചത് പോലെ ഒരു ക്ലാസിലെ എല്ലാ ഒബ്ജക്റ്റുകളും പൊതുവായി ഉപയോഗിക്കുന്ന, എന്നാൽ ഒരു ഒബ്ജക്റ്റിന്റേയും സ്വന്തമല്ലാ‍ത്ത ഒരു വേരിയബിളാണ് സ്റ്റാറ്റിക്ക് വേരിയബിൾ. ഉദാഹരണത്തിന്, നമുക്ക് ഒരു ക്ലാസിന്റെ എത്ര ഒബ്ജറ്റുകൾ നിർമ്മിക്കപ്പെടുന്നുണ്ടെന്നറിയാൻ ഒരു കൌണ്ട് വേരിയബിൾ വെക്കണമെന്നിരിക്കട്ടെ. ഈ ഉദാഹരണം കാണൂ

public InterestClass{
    double P; //മെംബർ വേരിയബിൾ
    float rate;//മെംബർ വേരിയബിൾ
    int term;//മെംബർ വേരിയബിൾ
    static int COUNT;
    InterestClass(double P, float rate, int term){ //കൺസ്ട്രക്ടർ
        this.P = P;
        this.rate = rate;
        this.term = term;
        InterestClass.COUNT++;
    }
   // Other methodes here
}

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

  InterestClass inclass=new InterestClass(10,10,10);
  System.out.println(inclass.COUNT);
  System.out.println(InterestClass.COUNT);

എന്ന് ഉപയോഗിച്ചാൽ 1,1 എന്നുതന്നെ ഉത്തരം ലഭിക്കും. എന്നിരുന്നാലും, സ്റ്റാറ്റിക്ക് വേരിയബിളിനെ തിരിച്ചറിയാൻ ഉപകരിക്കാനായി ആദ്യത്തെ വഴി ഉപയോഗിക്കുന്നതാണ് പൊതുവേ പിന്തുടർന്നു വരുന്നത്.

സ്റ്റാറ്റിക്ക് വേരിയബിൾ ഉപകാരപ്രദമാവുന്നത് നമ്മുടെ ക്ലാസിന്റെ ഇപ്പോഴത്തെ അവസ്ഥ എല്ലാ ഒബ്ജക്റ്റുകൾക്കും ഒരേപോലെ ഉപയോഗിക്കേണ്ടി വരുമ്പോഴാണ്. ഫ്ലാഗുകൾ ഒരു നല്ല ഉദാഹരണമാണ്. സാധാരണ ഇൻസ്റ്റൻസ് വേരിയബിളുകൾക്ക് ഓരോ ഒബ്ജക്റ്റ് (ഇൻസ്റ്റൻസ്) നിർമ്മിക്കപ്പെടുമ്പോഴും മെമ്മറി നീക്കിവെക്കപ്പെടുന്നുണ്ട്. എന്നാൽ ക്ലാസ് വേരിയബിളിന് മെമ്മറി ഒരിക്കൽ മാത്രമേ നീക്കിവെക്കപ്പെടുകയുള്ളൂ. അത് അവസാനത്തെ ഒബ്ജക്റ്റ് ഇൻസ്റ്റൻസ് ഇല്ലാതാവുന്നതു വരെ നിലനിൽക്കുകയും ചെയ്യും

സ്റ്റാറ്റിക്ക് മെത്തേഡുകൾ (അഥവാ ക്ലാസ് മെത്തേഡുകൾ)

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

സാധാരണയായി നമ്മൾക്ക് നേരിടേണ്ടിവരുന്ന ഒരു അവസ്ഥയാണ് ഒരു സ്ട്രിങ്ങ് രൂപത്തിലുള്ള ഒരു സംഖ്യയെ ഇന്റിജർ ആക്കുക എന്നത്. ഇതിനായി java.lang.Integer എന്ന ക്ലാസിലെ parseInt എന്ന സ്റ്റാറ്റിക്ക് മെത്തേഡ് നമ്മളെ സഹായിക്കും Integer.parseInt("23") എന്ന ക്ലാസ് മെത്തേഡ് കാൾ നമുക്ക് 23 എന്ന ഇന്റിജർ വേരിയബിൾ റിട്ടേൺ വിലയായി നൽകും. ജാവയുടെ ലാങ്ങ് പാക്കേജിനകത്തെ നംബർ സബ് പാക്കേജിൽ ഇന്റിജർ പോലെത്തന്നെ മറ്റ് പ്രാധമിക ഡാറ്റാടൈപ്പുകൾക്കും ക്ലാസുകൾ ഉണ്ട്. അവയെല്ലാം തന്നെ സ്റ്റാറ്റിക്ക് മെത്തേഡുകൾ നല്ലവണ്ണം ഉപയോഗിക്കുന്നുണ്ട് (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Number.html നോക്കുക)

ഇതിൽ കണ്ടതെല്ലാം ചേർത്തൊരു പ്രോഗ്രാമെഴുതിയാലോ?

public class InterestClass {
    double P;
    float rate;
    int term;
    static int COUNT;
    InterestClass(double P, float rate, int term){
     this.P = P;
        this.rate = rate;
        this.term = term;
        InterestClass.COUNT++;
    }

    static int getCount(){
        return COUNT;
    }
 }

public class Example {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  InterestClass inclass=new InterestClass(10,10,10);
  System.out.println("First Object created");
  //Using object.StaticVariable
  System.out.println(inclass.COUNT);
  //Using Class.StaticVariable
  System.out.println(InterestClass.COUNT);
  //Using Class.staticMethode
  System.out.println(InterestClass.getCount());
  //Using object. staticMethode
  System.out.println(inclass.getCount());
  
  InterestClass inclass1=new InterestClass(10,30,10);
  System.out.println("Second Object created");  
  System.out.println(inclass.COUNT);
  System.out.println(InterestClass.COUNT);
  System.out.println(InterestClass.getCount());
  System.out.println(inclass.getCount());
  
  System.out.println("Parsing a string to integer");
  System.out.println(Integer.parseInt("23"));
  }
}

ഇത് റൺ ചെയ്തു കഴിയുമ്പോൾ

First Object created
1
1
1
1
Second Object created
2
2
2
2
Parsing a string to integer
23

എന്ന് ലഭിക്കും.

സ്റ്റാറ്റിക്ക് മെത്തേഡുകൾ ഉപയോഗിക്കുമ്പോൾ പ്രത്യേകം ശ്രദ്ധിക്കുക. ഇവയ്ക്ക് സ്റ്റാറ്റിക്ക് അല്ലാത്ത മെംബർമാരെ ഉപയോഗിക്കുവാനോ, ഇവയെ this ഉപയോഗിച്ച് നേരിട്ട് ആക്സസ് ചെയ്യാനോ പറ്റില്ല. ഒരു വേരിയബിളോ മെത്തേഡോ സ്റ്റാറ്റിക്ക് ആക്കുന്നതിനു മുന്നേ നല്ലവണ്ണം ആലോചിച്ച് അതു ഉപയോഗിക്കപ്പെടേണ്ടി വരുന്ന അവസ്ഥകളെ അപഗ്രഥിക്കുന്നത് നന്നായിരിക്കും.