Saturday, July 31, 2010

Java වැඩසටහන් සඳහා User Interfaces සැකසීම :: Swing පැකේජය හැඳින්වීම III කොටස

JRadioButton
විකල්ප කිහිපයක් දී ඇති විටදී ඉන් එක් විකල්පයක් තෝරාගැනීමට අවකාශ සැලසීමට මෙම component එක යොදාගත හැක. උදාහරණයක් පහත ඉදිරිපත් කර ඇත. Mr,Mrs,Ms,Dr යන විකල්ප වලින් එකක් පමණක් තෝරාගැනීමට මෙහිදී සිදුවේ. මෙම පාඩමෙන් සිදුකෙරෙන්නේ JRadioButton එකක් සාදාගන්නා ආකාරය පමණි. මේවායේ event handling සිදුකිරීම ඉදිරි පාඩම් වලදී සාකච්ඡා කෙරේ.
JRadioButtonDemo.java
import javax.swing.*;
import java.awt.*;

public class JRadioButtonDemo extends JFrame{
 
 public JRadioButtonDemo(){
   setTitle("JRadioButton Demo");
   setLayout(new FlowLayout(FlowLayout.LEADING  ));
   setSize(300,300);
   JRadioButton jrb_mr=new JRadioButton("Mr");
   JRadioButton jrb_mrs=new JRadioButton("Mrs");
   JRadioButton jrb_ms=new JRadioButton("Ms");
   JRadioButton jrb_dr=new JRadioButton("Dr");
   //grouping
   ButtonGroup btnGroup=new ButtonGroup();
   btnGroup.add(jrb_mr);
   btnGroup.add(jrb_mrs);
   btnGroup.add(jrb_ms);
   btnGroup.add(jrb_dr);
   //add them to the JFrame
   add(jrb_mr);
   add(jrb_mrs);
   add(jrb_ms);
   add(jrb_dr);
   setVisible(true);
 }

 public static void main(String args[]){
  new JRadioButtonDemo();
 }
}
Output:

line14:
මෙහිදී අපි සාදාගත් JRadioButton ටික group කිරීම සිදුකෙරේ. මේවා group නොකලහොත් Mr, Mrs, Ms, Dr යන විකල්පයන්ගෙන් එකක් හෝ කිහිපයක් තේරීම සිදුකල හැකිය. නමුත් JRadioButton යෙදීමේ අරමුණ මෙය නොවන නිසා සාමාන්‍යයෙන් JRadioButtons group කිරීම සිදුවේ.

JList
කිසියම් elements ප්‍රමාණයක් පහත ආකාරයට දැක්වීමට JList නම් swing component එක භාවිතාකෙරේ.
උදා: JListDemo.java

import javax.swing.*;
import java.awt.*;

public class JListDemo extends JFrame{
 
 public JListDemo(){
   setTitle("JList Demo");
   setLayout(new FlowLayout(FlowLayout.LEADING  ));
   setSize(300,300);
   
   DefaultListModel dlm=new DefaultListModel();
   JList countries=new JList(dlm);
   dlm.addElement("Sri Lanka");
   dlm.addElement("India");
   dlm.addElement("Japan");
   dlm.addElement("Usa");
   dlm.addElement("UK");
   
   add(countries); 
   setVisible(true);
 }
   
   public static void main(String args[]){
  new JListDemo();
   } 
}
JList එක construct කරගැනීමට පෙර DefaultListModel එකක් සාදාගැනීම කල යුතුයි. පසුව අපි සාදාගත් JList එකට දත්ත add කිරීම්ට JList එක clear කිරීමට, JList එකෙන් elements ඉවත් කිරීම මෙම DefaultListModel object එක හරහා සිදුවේ.Line11 දී මෙම DefaultListModel object එකක් සාදාගෙන ඇත. 

Line12: මෙහිදී අපි සාදාගත් DefaultListModel object එක සහ JList එක සම්බන්ද කිරීම සිදුකෙරේ.

දැන් අපි JList එක හා සම්බන්ද වැදගත් method කිහිපයක් සලකා බලමු.

JList Methods
විස්තරය
int getSelectedIndex()  user විසින් list එකීහි මේ වනවිට select කර ඇති item එකෙහි index එක ලබාදේ.
void setSelectedIndex()  Program එක තුලින් list එකෙහි item එකක් select කර ඇති ලෙසට දක්වයි.
Object getSelectedValue()  user විසින් list එකීහි මේ වනවිට select කර ඇති item එක ලබාදේ
boolean isSelectedIndex(int idx)  ලබාදෙන int value එකක් select වී ඇති item එකේ index value එක නම් true ලෙසටද නැතිනම් false ලෙසටද return කරයි
setModel(ListModel model)  සකස් කරගත් ListModel object එකක් JList එක හා සම්බන්ද කිරීමට යොදාගැනේ
DefaultListModel Methods
විස්තරය
void add(int index, Object element)  ලබාදෙන index අගයකට(location එකකට) item එකක් ඇතුලු කිරීම සිදුකරයි
void addElement(Object obj)  list එකේ අගට item එකක් ඇතුලු කිරීම සිදුකරයි
int capacity()  දැනට list එකේ capacity එක නොහොත් items ගනණ ලබාදේ
void clear()  list එකේ ඇති සියලු items clear කිරීම සිදුකරයි.
boolean  contains(Object obj)  ලබදෙන Object එකක් list එක තුල අන්තර්ගත වේනම් true ලෙසද නැත්නම් false ලෙසටද ලබාදේ.
Object elementAt(int index)  ලබාදෙන index එකක ඇති value එක ලබාදේ
boolean isEmpty()  list එක empty නම් true ලෙසටද නැත්නම් false ලෙසටද ලබාදේ
Object remove(int index)  ලබාදෙන index එකක ඇති item එක ඉවත්කරයි
void removeAllElements()  list එක තුල ඇති සියලු items ඉවත් කරයි

JList එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.
DefaultListModel එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

JList එකට scroll bar යෙදීමට අවශ්‍ය නම් JScrollPane එකක් යොදාගත හැකිය. එය සිදුකරන අයුරු පහත දැක්වේ.
import javax.swing.*;
import java.awt.*;

public class JListDemo extends JFrame{
 
 public JListDemo(){
   setTitle("JList Demo");
   setLayout(new FlowLayout(FlowLayout.LEADING  ));
   setSize(300,300);
   
   DefaultListModel dlm=new DefaultListModel();
   JList countries=new JList(dlm);  
   
   JScrollPane scrollP=new JScrollPane(countries);
   scrollP.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

   dlm.addElement("Sri Lanka");
   dlm.addElement("India");
   dlm.addElement("Japan");
   dlm.addElement("Usa");
   dlm.addElement("Canada");
   dlm.addElement("Australlia");
   dlm.addElement("Italy");
   dlm.addElement("South Affrica");
   dlm.addElement("Thailand");
   
   add(scrollP); 
   setVisible(true);
 }
   
   public static void main(String args[]){
  new JListDemo();
   } 
}
Output:
පහත ජාවා ඇප්ලට් එක භාවිතයෙන් ඔබට ඉහත සඳහන් කල methods හි ක්‍රියාකාරීත්වය පහසුවෙන් වටහාගත හැකිවෙතැයි සිතමි.
පාඩමේ භාවිතා කර ඇති මූලාශ්‍ර කේත(source codes) බාගත කරගැනීම සඳහා පහත ලින්ක් එක භාවිතා කරන්න.

Friday, July 23, 2010

Java වැඩසටහන් සඳහා User Interfaces සැකසීම :: Swing පැකේජය හැඳින්වීම II කොටස

අපි ඉහත කලින් පාඩමේදී සාකච්ඡා කලේ JLabel, JButton හා JTextField පිලිබඳවයි. මෙම පාඩමෙන් තවත් swing components කිහිපයක් පිලිබඳවා සාකච්ඡා කරමු.

JTextArea

මෙය JTextField සඳහා බොහෝ සමාන වුවද මෙහි lines කිහිපයකින් යුතු user inputs ගත හැක. එනම් address එකක් හෝ කිසියම් description එකක් ගැනීමේදී මෙය භාවිතා කල හැක.
JTextArea(int rows, int columns)
JTextArea(String text)
JTextArea(String text, int rows, int columns)
උදා;

අපිට අවශ්‍ය නම් මෙම JTextArea සඳහා scrollbar යෙදිය හැක. මේ සඳහා කල යුත්තේ JScrollPane එකක් තුලට JTextArea එක දැමීමයි. මෙය සිදුකරන අයුරු පහත දැක්වේ.
import javax.swing.*;
import java.awt.*;
class JTextAreaDemo extends JFrame{

 public JTextAreaDemo(){
  setTitle("JTextArea Demo");
  JTextArea jtxt=new JTextArea(10,20);
  JScrollPane scrollpane=new JScrollPane(jtxt);
  
  setLayout(new FlowLayout());
  setSize(300,300);
  setVisible(true);
  add(new JLabel("Description :"));
  add(scrollpane);
 }
 
 public static void main(String args[]){
  new JTextAreaDemo();
 }
}
Output:
JScrollPane එකෙහි constructor එකට(line 8) JTextArea object එක වන jtxt object එක ලබාදීම මගින් scrollpane එකට textarea එක ඇතුලුකිරීම සිදුකර ඇත.

JTextArea එකෙහි method ලෙස getText(),setText() බහුලව යෙදේ.


JCheckBox

විකල්ප 1ක් හෝ කීපයක් තේරීමට ඉඩලබාදිය යුතුවිට මෙය භාවිතා කෙරේ. 

isSelected()method එක භාවිතා කර යම් CheckBox එකක් select කර ඇත්දැයි පරීක්ෂා කල හැක. Event handling පාඩමේදී JCheckBox පිලිබඳ වැඩිදුරටත් සාකච්ඡා කෙරේ.
JCheckBox එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.
 

Java වැඩසටහන් සඳහා User Interfaces සැකසීම :: Swing පැකේජය හැඳින්වීම I කොටස

අතුරු මුහුණත්(Graphical User Interfaces) යනු යම් පරිගණක වැඩසටහනක් භාවිතා කිරීම පහසු කරවන්නක්. සාමාන්‍ය පරිගණක පරිශීලකයෙක් නම් මේ වකවානුවේ බොහෝ දුරට භාවිතා කරනුයේ මෙවැනි වැඩසටහන්. ජාවා පරිගණක භාෂාව යොදාගෙන මෙවැනි GUI සහිත වැඩසටහන් සැකසීමට විශේෂ පහසුකම් ලබාදී තිබෙනවා. මේ සඳහා යොදාගත හැකි ප්‍රධාන ජාවා පැකේජ 2ක තමයි
  • AWT (Abstract Window Toolkit)
  • Swing
විශේෂ හේතූන් කිහිපයක් නිසා Swing පැකේජය භාවිතා කිරීම ප්‍රයෝජනවත් වනවා. ඉන් ප්‍රධානම හේතුව වන්නේ swing පැකේජය pure Java වලින් ලියැවුනු එකක් වීම. එම නිසා සුවිශේෂ වාසි කිහිපයක් අදාල වැඩසටහනට ලැබෙනවා. මීට අමතරව AWT සහය දක්වන සියලුම පහසුකම් සඳහා swing ද සහය දක්වනවා. AWT හි නොමැති පහසුකම් ගනණාවක්ද swing හි අඩංගු වනවා.
AWT සහ Swing හි වාසි අවාසි පිලිබඳ වැඩි විස්තර කියවීම සඳහා මෙම ලින්ක් එක භාවිතා කරන්න.

Friday, July 16, 2010

ජාවා interface සංකල්පය සහ එහි යෙදීම්

Interface එකක් කිව්වාම එකපාරටම මතක් වෙන්නෙ GUI එකක් නැත්නම් web form එකක් නේ. නමුත් මෙම පාඩමේදී අපි සලකා බලන්නේ වස්තු පාදක සංකල්පයක් වන interface සංකල්පය පිලිබඳවයි. මෙම සංකල්පයත් ජාවා ක්‍රමලේඛනයේ යෙදීමේදී බහුල වශයෙන් භාවිතා වන්නක්. මෙම පාඩමේදී පෙර පාඩම වන "ජාවා තුල Abstract Classes යොදාගන්නා අයුරු" යන පාඩමේදී උගත් කරුණු වැදගත් වන නිසා අවශ්‍ය නම් නැවත එය අධ්‍යයනය කරන්න.

interface එකක ඇති ප්‍රධාන ලක්ෂණ ගැන අපි සලකා බලමු.
  • interface එකක් යනු සම්පූර්ණයෙන්ම abstract class එකකි.

  • interface එකක ඇති methods සියල්ලම අර්ථදක්වා(define) ඇත්තේ method body එකකින් තොරවය(මෙයට හේතුව interface එක fully abstract වීමයි. එමනිසා මෙහි methods සියල්ලක්ම abstract වේ) 

  • interface එකක් තුල class variables (උදා : private int age;) පැවතිය නොහැක. නමුත් final attributes පැවතිය හැක(උදා: private final SIZE=512;)
මීලඟට අපි සලකා බලමු ලියන ලද interface එකක් භාවිතා කිරීමේදී සැලකිය යුතු කරුණු.
  • class එකකට අවශ්‍ය නම් interface එකකට වැඩි ප්‍රමාණයක් භාවිතා කල හැක. එනම් class එකකට අවශ්‍ය නම් interface එකකට වැඩි ප්‍රමාණයක් implement කල හැක. මේ සඳහා implement keyword එක භාවිතාවේ.

  • යම් class එකක් interface එකක් implement කර ඇත්නම් එම interface එකෙහි ඇති සියලුම methods override කිරීම අනිවාර්‍යයෙන්ම කල යුතුය.

  • class එක abstract නම් එසේ අවශ්‍ය නොවේ.

  • class වලදී මෙන් inheritance සංකල්පය interface සඳහාද භාවිතා කල හැක. එනම් interface එකකදී වෙනත් interface එකක් extend කල හැක.

  • multiple inheritance නම් සංකල්පය C++ වලදී මෙන් java තුලදී කිරීමට ඉඩදී නොමැති වුවද, මෙම interface සංකල්පය යොදාගෙන එම ක්‍රියාවලිය ඉටුකරගත හැක.

අපි දැන් බලමු interface එකක් ලිවීම සඳහා භාවිතා වන syntax එක
interface MyInterface {
 
 final int VAL=512;
 
 void myMethod1();
 int myMethod2();
 ......................
 ...................... 
}
දැන් අපි බලමු interface සංකල්පයේ යෙදීම් ආදර්ශනය කිරීමට ලියන ලද සරල වැඩසටහනක්
/**    
*class  : CarControllerDemo    
*Author : Kanishka Dilshan    
*Purpose: Describe interface concept in Java  
*Blog   : http://javaxclass.blogspot.com    
*/ 

interface CarController{
 final float MAX_SPEED=320f;
 
 void accelerate(); //accelerate the car
 void applyBreak(); //apply breaks
}

class BMW implements CarController{
 private String model;
 private float speed;
 
 public BMW(String model){
  this.model=model;
  speed=0f;
 }
 public void accelerate(){
 //implementing accelerate() method in the interface
  if(speed < MAX_SPEED)
   speed+=15;
 }
 
 public void applyBreak(){
 //implementing applyBreak() method in the interface
  if(!((speed-20) < 0))
   speed-=20;
  else
   speed=0;   
 }
 
 public void showDetails(){
  System.out.println("Car model : "+model);
  System.out.println("Speed     : "+speed);
 }
}

//another car called Nissan implements CarController interface
class Nissan implements CarController{
 private String model;
 private float speed;
 
 public Nissan(String model){
  this.model=model;
  speed=0f;
 }
 public void accelerate(){
 //implementing accelerate() method in the interface
  if(speed < MAX_SPEED)
   speed+=15;
 }
 
 public void applyBreak(){
 //implementing applyBreak() method in the interface
  if(!((speed-25) < 0))
   speed-=25;
  else
   speed=0;
 }
 
 public void showDetails(){
  System.out.println("Car model : "+model);
  System.out.println("Speed     : "+speed);
 }
}


public class CarControllerDemo{
 public static void main(String args[]){
  //creating BMW car object
  BMW car1=new BMW("BMW M6");
  Nissan car2=new Nissan("Altima Sedan");
  
  //accelerate car1 twice
  car1.accelerate();
  car1.accelerate();
  //applyBreak() for car1
  car1.applyBreak();
  car1.showDetails();
  
  //accelerate car2 4 times
  car2.accelerate();
  car2.accelerate();   
  car2.accelerate();
  car2.accelerate(); 
  //applyBreak() for car2
  car2.applyBreak();  
  car2.showDetails();
 }
}
Output:

පැහැදිලි කිරීම:
ඉහත උදාහරණයේ Line8 සිට Line13 දක්වා ඇත්තේ define කරන ලද interface එකයි. BMW සහ Nissan යන class තුලදී implement කර ඇත්තේ එම interface එක තුල ඇති accelerate() සහ applybreak() යන methods දෙකයි. මීට පෙර පාඩම් වලදී උගත් සිද්ධාන්ත භාවිතා කරමින් ඉහත කේතයේ අනෙකුත් කොටස් අවබෝධ කිරීම ඔබගේ කාර්‍යයකි. 

ජාවා ක්‍රමලේඛන භාෂාව යොදාගෙන වැඩසටහන් ලිවීමේදී පහත අවස්ථා වලදී මෙම interface භාවිතය ප්‍රායෝගිකව දැකගත හැකිය.
  • Event handling
  • Database connectivity
මෙම පාඩමත් සමග ජාවා වල මූලික OOP සංකල්ප කොටස අවසන් වේ. ඉදිරි පාඩම් වලදී ජාවහි අතුරු මුහුණත් සැකසීම පිලිබඳ අධ්‍යයනය කරමු.

Saturday, July 10, 2010

ජාවා තුල Abstract Classes යොදාගන්නා අයුරු

වස්තු පාදක(OO) ජාවා වැඩසටහන් ලිවීමේදී බහුල වශයෙන් යෙදෙන සංකල්පයක් තමයි abstraction කියන්නේ මේ සඳහා ජාවා පරිගණක භාෂාව තුල පහසුකම් සපයාතිබෙනවා. 

අපි මුලින්ම බලමු abstract class එකක ලක්ෂණ මොනවාද කියල.
  • Abstract class වලින් කිසිවිටෙකත් objects සෑදිය නොහැක.

  • Abstract class එකක් extend කර(inherit කර) පසුව සාදනු ලබන class වලට හොඳ පදනමක් සැපයීම.

  • Generic (පොදු) ස්වභාවයකින් යුතුවීම.  එනම් abstract class එකෙහි child class වලට පොදු ලක්ෂණ එතුල කැටිවී තිබීම(උදාහරණය මගින් විස්තර කර ඇත.)

  • Parent class එකෙහි Abstract methods ඇත්න්නම් එහි sub class නොහොත් child classes වලදී එම abstract methods අනිවාර්‍යයෙන්ම override කල යුතුය(override කරනවා යන්නෙහි සරල අදහස නම් අදාල abstract method එකෙහි body එක implement කල යුතු බවයි) 
දැන් අපි උදාහරණය බලමු
class : AbstractDemo.java
/**   
*class  : AbstractDemo   
*Author : Kanishka Dilshan   
*Purpose: Describe abstract concept in Java 
*Blog   : http://javaxclass.blogspot.com   
*/   

abstract class Shape{
 protected int color;
 protected Point pos; //position
 
 public void setColor(int color){
  this.color=color;
 }
 
 public int getColor(){
  return color;
 }
 
 public void setPos(Point p){
  pos=p;
 }
 
 public Point getPos(){
  return pos;
 }
 
 abstract public float getArea();
  /* This method is defined as abstract since
     it cannot be implemented since Shape is a  
     common class(abstract class) */
}

class Rectangle extends Shape {
 /*since this clsaa inherits Shape class
  *the getArea() method must be overrided
  */
  //thease are properties specific to a Rectangle
  private float width,height;
  
  public Rectangle(float w,float h,Point p,int col){
  super.color=col;
  super.pos=p;
  this.width=w;
  this.height=h;
  }
  
  public float getArea(){
  return (width*height);
  } 
}

class Circle extends Shape {
 /*since this clsaa inherits Shape class
  *the getArea() method must be overrided
  */
  private float radius;
  
  public Circle(float rad,Point p,int col){
  super.color=col;
  super.pos=p;  
  this.radius=rad;
  }
  
  public float getArea(){
  return (float)(Math.PI*Math.pow(radius,2));
  }   
}

class Point{
 //class definition for represent a Point
 protected int xPos;
 protected int yPos;
 public Point(int x,int y){
  xPos=x;
  yPos=y;
 }
 
 public int getX(){
  return xPos;
 } 
 
 public int getY(){
  return yPos;
 }
}


public class AbstractDemo{
 //main method
 public static void main(String args[]){
  Rectangle rect1=new Rectangle(12.0f,7.5f,new Point(10,-3),255);
  Circle c1=new Circle(4.3f,new Point(3,8),100);
  
  //let's prnint object details for rect1
  println("rect1 belongs to    : "+ rect1.getClass().toString());
  println("colour val of rect1 : "+ rect1.getColor());
  println("x position of rect1 : "+ rect1.getPos().getX());
  println("y position of rect1 : "+ rect1.getPos().getY());
  println("area of rect1       : "+ rect1.getArea() );
  
  println("-----------------------------------------");
  //let's prnint object details for c1
  println("c1 belongs to       : "+ c1.getClass().toString());
  println("colour val of c1    : "+ c1.getColor());
  println("x position of c1    : "+ c1.getPos().getX());
  println("y position of c1    : "+ c1.getPos().getY());
  println("area of c1          : "+ c1.getArea() );
 }
 
 public static void println(Object o){
  System.out.println(o);
 }

}
output :
අපි දැන් ඉහත code එක විස්තරාත්මකව අධ්‍යයනය කරමු
අපි abstract class එක ලෙස මෙහිදී යොදාගෙන තිබෙන්නේ Shape නම් class එකයි. එයට හේතුව වනුයේ Circle සහ Rectangle යන class දෙකටම පොදු ලක්ෂණ Shape තුල අන්තර්ගත වන නිසයි. 

Line 28
abstract public float getArea();
මෙහි getArea() නම් method එක abstract ලෙස සටහන් කර ඇත්තේ එය Shape හි sub classes වලට (specific) අනන්‍ය නිසා Shape class එක තුල implement කල නොහැකි නිසාය.

Line 48 - 50
public float getArea(){
  return (width*height);
  }
මෙහිදී Rectangle class එකෙහි super class එක වන Shape class එකෙහි ඇති abstract method එක implement කර ඇත. super class එකෙහි abstract method යම් ප්‍රමාණයක් ඇත්නම් ඒ සියල්ලම එහි subclasses වලදී implement කිරීම අනිවාර්‍ය වේ.
මෙම පාඩමෙන් අප ලබාගත් දැණුම මීලඟ පාඩම වන interfaces පාඩමේදී අත්‍යාවශ්‍ය වන නිසා මෙය හොඳින් අධ්‍යයනය කරන්න.

මෙහි ගැටලු සහගත තැනක් වේ නම් email එකක් මගින් දන්වන්න නැත්නම් comment එකක් ලෙස හෝ ඉදිරිපත් කරන්න.

පාඩමේ භාවිතා කර ඇති මූලාශ්‍ර කේත(source codes) බාගත කරගැනීම සඳහා පහත ලින්ක් එක භාවිතා කරන්න.

Saturday, July 3, 2010

ජාවා තුල 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 පිලිබඳව සාකච්ඡා කරමු.