ජාවා තුල Inner Classes හි භාවිතය

අපි අද පාඩමෙන් කතාකරන්න යන්නේ ජාවා inner classes පිලිබඳවයි. පරිගණක භාෂාවක් ලෙසට ජාවා වැනි භාෂාවක් හොඳින් අධ්‍යයනය කිරීම ඉතාම වැදගත්. ඒ මොකද, OOP සංකල්ප පැහැදිලිව අවබෝධ කරගැනීමට ජාවා අධ්‍යයනය මහත් රුකුලක් වන නිසා.
අපි දැන් සරළ රූප සටහනක් මගින් මෙම inner class සංකල්පය අවබෝධ කරගනිමු.

දැන් අපි ඉහත රූපසටහන විස්තරාත්මකව අධ්‍යයනය කරමු.
class B යනු class A හි inner class එකකි එනම් මෙහිදී class B හි outer class එක වන්නේ class A වෙයි. එමෙන්ම class C ද class A හි inner class එකකි. class D යනු class C හි ද inner class එකකි. එනම් class D හි outer class එක වන්නේ class C ය, class C හි outer class එක class A ය. දැන් ඔබට මෙහිදී සිදුවන්නේ කුමක්ද යන්න පැහැදිලි ඇතැයි සිතමි. outer class සහ inner class ගැන පැහැදිලි දල අවබෝධයක් පාඩමේ පහත කොටසට අවශ්‍ය නිසා මෙහිදී එය පැහැදිලි කරගන්න.

අපි දැන් බලමු inner classes වල ප්‍රධාන ලක්ෂණ මොනවාද කියලා.

► Outer class වලට ඒවායේ inner classes import කිරීමකින් තොරව භාවිතා කල හැකිය. උදා : ඉහත සටහනේ class A ට ඕනෑම විටක class B භාවිතා කල හැකිය(objects සෑදිය හැකිය)

► නමුත් inner classes භාවිතා කල හැක්කේ ඒවායේ outer class වලට පමනි. ඉන් පරිභාහිර කිසිඳු class එකකට සෘජුව අදාල inner classes භාවිතා කල නොහැක. උදා : class A ට පරිබාහිර වෙනත් කිසිඳු class එකකට class B access කල නොහැක.

►Inner class එකක් යනු එහි outer class එකෙහි member කෙනෙක් ලෙස සැලකිය හැක.

►Inner class එකකට එහි outer class එකෙහි ඕනෑම attributes හෝ methods සෘජුව access කල හැක.

►නමුත් Outer class එකකට එහි inner classes වල  attributes හෝ methods සෘජුව access කල නොහැක. එම inner class වලින් object සෑදීමෙන් අනතුරුව ඒ හරහා එම methods සහ attribute access කල හැක.

inner classes ආදර්ශනය කිරීමට ලියන ලද පහත වැඩසටහන සැලකිල්ලෙන් අධ්‍යයනය කරන්න.

/**  
*class  : InnerClsDemo  
*Author : Kanishka Dilshan  
*Purpose: Demonstrate how inner classes are manipulated
*Blog   : http://javaxclass.blogspot.com  
*/  

public class InnerClsDemo{
 public static void main(String args[]){
  Report rpt1=new Report("Sri Lanka","I love my country","End of the DOC");
  rpt1.print();
 }
}

class Report {
 String headerTxt;
 String bodyTxt;
 String footerTxt;
 
 public Report(String h,String b,String f){
  headerTxt=h;
  bodyTxt=b;
  footerTxt=f;
 }
 
 public void print(){
  Header h=new Header();
  Body b=new Body();
  Footer f=new Footer();
  h.print();
  b.print();
  f.print();
 }
 
 //inner class 1: Header
 class Header{
  public void print(){
   System.out.println("-----------------------------");
   System.out.println("------This is The Header-----");
   System.out.println("\t"+headerTxt);
   System.out.println("-----------------------------");   
  }
 }
 //inner class 2: Body
 class Body{
  public void print(){
   System.out.println("-                           -");
   System.out.println("-                           -");
   System.out.println("------This is The Body-------");   
   System.out.println("\t"+bodyTxt);   
   System.out.println("-                           -");   
  }
 }
 //inner class 3: Footer
 class Footer{
  public void print(){
   System.out.println("------This is The Footer-----");
   System.out.println("\t"+footerTxt);
   System.out.println("-----------------------------");       
  }
 } 
}

output:

අපි ඉහත ඉගෙනගත් inner classes මූලධර්ම මගින් ඔබට ඉහත වැඩසටහන පැහැදිලි කරගත හැකිය.

inner classes compile කිරීමෙන් අනතුරුව file system එකේ තැන්පත් වන ආකාරය දැන් බලමු.

outer class එක වන Report class එක Report.class ලෙස පවතින බව ඔබට පෙනෙනවා ඇති. එම Report නම් outer class එකෙහි inner classes වන Header , Body සහ Footer classes පිලිවෙලින් Report$Header.class , Report$Body.class සහ Report$Footer.class ලෙස පවතින බවත් පෙනෙනවා ඇති. එනම් inner class එකට අදාල class file එකට නම ලැබී ඇත්තේ එහි outer class එකට ඇති සම්බන්දය විද්‍යාමන කරවමිනි. 
(OuterClassName$InnerClassName.class)

මීලඟ පාඩමෙන් අපි ජාවා interface පිලිබඳව සාකච්ඡා කරමු.