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

നെസ്റ്റഡ് ക്ലാസുകൾ

ഈ അദ്ധ്യായത്തിൽ നമുക്ക് നെസ്റ്റഡ് ക്ലാസുകളെക്കുറിച്ച് പഠിക്കാം. ഒരു ക്ലാസിനകത്ത് നിർവ്വചിക്കപ്പെടുന്ന ഒരു ക്ലാസിനെയാണ് നെസ്റ്റഡ് ക്ലാസ് എന്നു വിളിക്കുന്നത്. നെസ്റ്റഡ് ക്ലാസുകൾ പൊതുവായി ഉപയോഗിക്കപ്പെടുന്നത് ഒരു ക്ലാസിൽ മാത്രം ഉപയോഗിക്കുന്ന ക്ലാസുകളെ ഒന്നിച്ചു കൂട്ടം തിരിച്ചു വെയ്ക്കാനും, എൻ‌കാപ്സുലേഷൻ ഉറപ്പു വരുത്താനും, കോഡ് കൂടുതൽ പുനർവായനക്കും മെയിന്റെയിൻ ചെയ്യാൻ സഹായകമാവാനുമാണ്. നെസ്റ്റഡ് ക്ലാസ് ഉപയോഗിക്കാൻ പതിവുപോലെ <പുറത്തെ ക്ലാസ്>.<അകത്തെ ക്ലാസ്> എന്നുപയോഗിക്കുന്നു.

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

class MyClass {
//ഇത് ഒരു സാധാരണ ഇന്നർ ക്ലാസാണ്
    class MyInnerClass {
        
    }
//ഇത് സ്റ്റാറ്റിക്ക് നെസ്റ്റഡ് ക്ലാസ്
    static class MyStaticInnerClass {
        
    }     
}

ഈ ക്ലാസുകൾ ഉപയോഗിക്കാൻ താഴെക്കാണുന്ന രീതി ഉപയോഗിക്കാം

സ്റ്റാറ്റിക്ക് ക്ലാസാണെങ്കിൽ അതിനെ ക്ലാസിന്റെ പേരുപയോഗിച്ച് നിർമ്മിക്കാം

MyClass.MyStaticInnerClass mystaticinner = MyClass.MyStaticInnerClass();

സ്റ്റാറ്റിക്കല്ലാത്തവ ഉപയോഗിക്കാൻ നമുക്ക് MyClass ഇൻസ്റ്റാൻഷിയേറ്റ് ചെയ്തേ മതിയാവൂ. ഉദാഹരാണത്തിന്,

MyClass.MyInnerClass innerclass = MyClass.new MyInnerClass();

ഇതു കൂടാതെ രണ്ടു തരത്തിലുള്ള നെസ്റ്റഡ് ക്ലാസുകളും കൂടി ജാവയിൽ ലഭ്യമാണ് - ലോക്കൽ ക്ലാസുകളും അനോനിമസ് ക്ലാസുകളും. ഇവ ഒരു മെത്തേഡിനകത്താണ് നിർവചിക്കപ്പെടുന്നത്. ലോക്കൽ ക്ലാസിനെ ഒരു സാധാരണ ക്ലാസു പോലെ നിർവചിക്കുമ്പോൾ അനോനിമസ് ക്ലാസിന് ഒരു നാമം ഉണ്ടാകില്ല. അനോനിമസ് ക്ലാസിന്റെ ഒരു ഉപയോഗം താഴെക്കാണാം. ഇത് അഡ്വാൻസ്ഡ് ജാവയിൽ സാ‍ധാരണയായി ഉപയോഗിച്ചുകാണാം.

new Thread(new Runnable() {
  public void run() {
      //ചെയ്യാനുള്ളതെന്തെന്നാൽ അത്
  }
}).start();

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

ജാവയുടെ യൂസർ ഇന്റർഫേസ് ഡിസൈനുകളിലും പ്രോഗ്രാമിങ്ങുകളിലും അനോനിമസ് ഇന്നർ ക്ലാസുകൾക്ക് സ്ഥാനമുണ്ട്. ഇവന്റ് ഹാന്റ്ലറുകൾ ഇവയുടെ ഉപയോഗങ്ങളിലൊന്നാൺ്. താഴത്തെ ഉദാഹരണം കാണൂ:

button.addActionListener(new ActionListener() {
  // ഇതാണ് അനോനിമസ് ഇന്നർ ക്ലാസ്
  public void actionPerformed(ActionEvent e) {
    System.out.println("Somebody clicked me!!");
  }
});

ഒരു പ്രോഗ്രാമിൽ ഇന്നർ ക്ലാസ് വേണോ സ്റ്റാറ്റിക്ക് നെസ്റ്റഡ് ക്ലാസ് വേണോ എന്നുള്ളത് നെസ്റ്റഡ് ക്ലാസിന് ഉപയോഗിക്കേണ്ടി വരുന്ന പുറത്തെ ക്ലാസിലെ ഡാറ്റയ്ക്ക് അനുസൃതമാണ്. പുറത്തെ ക്ലാസിലെ ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ വേണമെങ്കിൽ ഇന്നർ ക്ലാസുകൾ തന്നെ വേണം. മറിച്ച് സ്റ്റാറ്റിക്ക് വേരിയബിളുകൾ പ്രോഗ്രാമിൽ ഉപയോഗിക്കുന്ന ഒബ്ജക്റ്റുകളുടെ എണ്ണം കുറക്കാൻ സഹായിക്കും.

ഈ പ്രോഗ്രാം നോക്കുക

public class Tutorial {

 private static String staticNested = "I am a static string";
 private String nested = "I am regular"; 
 
 public static void main(String[] args) {
  Tutorial tv = new TechVidya();
  Tutorial.NestedClass nestedclass = tv.new NestedClass();
  Tutorial.StaticNestedClass statnestedclass = new TechVidya.StaticNestedClass();
  
 }
 
 class NestedClass{
  NestedClass(){
    System.out.println(nested);
          System.out.println(staticNested);
  }
 }
 static class StaticNestedClass{
  StaticNestedClass(){
    //System.out.println(nested);
          System.out.println(staticNested);
  }
 }
  
}

ഇത് റൺ ചെയ്തു നോക്കൂ. എന്ത് കിട്ടി? ഇനി സ്റ്റാറ്റിക്ക് ഇന്നർ ക്ലാസിലെ കമന്റ് ചെയ്തിരിക്കുന്ന ലൈൻ അൺ കമന്റ് ചെയ്ത് കമ്പൈൽ ചെയ്യാൻ ശ്രമിച്ചു നോക്കൂ. എന്ത് സംഭവിച്ചു, എന്തുകൊണ്ട്?