Wednesday, June 23, 2010

ජාවා static members කියන්නේ මොනවාද? මොකටද යොදාගන්නේ?

Static කියන්නේ ස්ථිතික කියන එකනේ සරලව කිව්වොත් පැතිරීයන ස්වභාවය නැති කියන එක ඉතින් මේ ස්ථිතික ස්වභාවය ජාවා වැඩසටහන් වලට ලබාදීමට තමයි මෙම static ලක්ෂණය  ජාවා වලට හඳුන්වාදී තිබෙන්නේ. මේ සඳහා static නම් keyword එක භාවිතා වනවා. සාමාන්‍යයෙන් static modifier එක යොදා ඇති fields බැඳී තිබෙන්නේ class එක සමගයි. static members වර්ග දෙකක් තිබෙනවා ඒ තමයි
  1.  Class variables
  2. Class methods
අපි දැන් class variables ගැන බලමු. ඔබ දන්නවා සමාන්‍ය instance variable නම් object එකකට එක බැගින් තිබෙනවා. උදාහරණයක් ලෙස Student class එකේ studentName එක instance variable එකක්. එනිසා එය Student object එකකට අනන්‍ය(unique) ලෙස පවතිනවා. සරලව කිව්වොත් සෑම object එකකටම studentName කියල වෙන වෙනම instance පවතිනවා. නමුත් කිසියම් static variable එකක් නැත්නම් class variable එකක් Student class එකේ තියනවා නම් සෑම object එකකටම එක බැගින් static members නෑ. එකම memory location එකක ඇති variable එකක් ලෙසටයි පවතින්නේ. සෑම object එකක්ම එය share කරගැනීම සිදුවෙනවා. එනම් object 1000ක් තිබුනොත් instance variable නම් 1000ක් පවතිනවා නමුත් static variable නම් පවතින්නේ එකම එකයි. පහත ඉදිරිපත්කර ඇති උදාහරණය අධ්‍යයනය කිරීමෙන් ඔබට මේ ගැන අවබෝධ කරගැනීමට පහසු වේවි.

උදාහරණයට කලින් static methods නැතහොත් class methods ගැනත් බලලම ඉඳිමු. static methods පොදුවේ භාවිතා වන්නේ class එකෙන් objects සෑදීමෙන් තොරව අදාල method එක භාවිතා කිරීමටයි. class එකක් තුල ඇති static variable හි අගයන් පිටතට ගැනීමට(access කිරීමට) මෙම static methods භාවිතා කලයුතු වනවා. මෙම static methods invoke(call) කිරීම සිදුවන්නේ class එකේ නම හරහායි.

දැන් අපි static සංකල්පය යොදාගැනීමට භාවිතා කරන syntax ගැන අධ්‍යයනය කරමු.
Syntax 1 : Declaring a static variable
[access modifier] static [datatype] [variable__name]  ;
 ex: private static int studID; 
Syntax 2 : Declaring a static method
[access modifier] static [datatype] [method__name]() 
ex: public static int getSum()

දැන් අපි උදාහරණය බලමු
/** 
*class  : StaticDemo 
*Author : Kanishka Dilshan 
*Purpose: introduce static keyword in Java 
*Blog   : http://javaxclass.blogspot.com 
*/ 

class Student {
 private String name;
 private int studId;
 private static int numberOfStudents;

 public Student(String name){
  this.name=name;
  //generate a new ID and increment the total value by 1
  studId=1000+(numberOfStudents++);
 }
 
 public static int getNumberOfStuds(){
  return numberOfStudents;
 }
 
 public void showStudDetails(){
  System.out.println("Name : " + name);
  System.out.println("stID : " + studId);
 }
}


public class StaticDemo{
 public static void main(String args[]){
  Student std1=new Student("Sajith");
  Student std2=new Student("Kanishka");
  Student std3=new Student("Ravindu");
  Student std4=new Student("Sathiranga");

  std1.showStudDetails();
  std2.showStudDetails();
  std3.showStudDetails();
  std4.showStudDetails();
  System.out.println("Total students : " + Student.getNumberOfStuds());
  
 }
}
ප්‍රතිඵලය:
පැහැදිලි කිරීම:
මෙහි name හා studId යන ඒවා instance variable වේ. numberOfStudents යන්න static variable එකකි. student ලා කීයක් ඉන්නවද කියන තමයි numberOfStudents එකේ තබාගන්නේ එය object එකින් එකට වෙනස් වන අගයක් නොවේ. එනිසයි අපි numberOfStudents යන්න static ලෙස යොදාගෙන තිබෙන්නේ. තවද මෙහි getNumberOfStuds() යන method එකත් static මොකද එයත් object එකින් එකට වෙනස් වන්නේ නැහැ(මින් අදහස් කිරීමට උත්සාහ කලේ ඔබ්ජෙක්ට් සඳහා අනන්‍ය ptoperties එම මෙතඩ් එක තුලින් පිවිසිය(access) නොහැකිය යන්නයි.) අනික එම method එක numberOfStudents නම් static variable එකත් access කරනවා. එම නිසා එය static විය යුතුයි. එමනිසා class එකේ නමයොදාගෙන call කිරීම කලහැකියි 41 වන පේලියේදී ඔබට මෙය දැකගත හැකියි.
තවත් OOP සංකල්ප අපි ඉදිරි පාඩමකදී සාකච්ඡා කරමු. 

Friday, June 18, 2010

ජාවාහි එන Wrapper classes යනු මොනවාද..?

ඔබ දන්නවා ජාවා වැඩසටහන තිබෙනවා මූලික දත්ත ආකාර(primitive data types) 8ක්. ජාවාහි සෑම තැනකටම පොදු ඔබ්ජෙක්ට් ඔරියන්ටඩ් ගතිය මෙම primitive data types තුල නැති බව බැලූ බැල්මටම පෙනෙනවා. මෙම wrapper classes නිර්මාණය කර ඇත්තේ මෙම primitive data type 8 සඳහා objects සෑදීමේ හැකියාව ලබාදීමටයි. එම නිසා ජාවා 1.0 සංස්කරණයේ සිටම මෙම primitive data types 8 සඳහා wrapper class 8ක් පැමිණෙනවා මේවා java.lang පැකේජයේ අන්තර්ගත වන නිසා වැඩසටහනකට විශේෂයෙන් import කිරීමට අවශ්‍ය නැහැ.

මෙම  wrapper classes යොදාගෙන ජාවාහි ඉතා වැදගත් කාර්‍යභාරයක් කරගැනීමට පුලුවන්. data types convert කිරීම මෙවායේ සුලභ යෙදීමක්.  මීට අමතරව එම දත්ත ආකාරය ගැන වැඩි විස්තර මෙම wrapper classes යොදාගනිමින් අපට ලබාගන්නටද පුලුවන්.

Primitive type Wrapper class

boolean

Boolean

char

Character

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double


අපි දැන් බලමු wrapper class යොදගෙන ලියන ලද සරල වැඩසටහනක්.

public class Wrapper{
 public static void main(String args[]){
  Integer num1=new Integer(23);
  Integer num2=new Integer(34);
  Integer tot1=new Integer(num1+num2);
  Integer tot2=num1+num2;
  
  System.out.println("tot1 : " + tot2);
  System.out.println("tot2 : " + tot1);
 }
}
ඉහත වැඩසටහන නිරීක්ෂණයෙන් ඔබට පෙනෙනවා ඇති ක්‍රම 2කකට අපි num1 හා num2 හි එකතුව ලබාගෙන තිබෙනවා. ජාවා 1.5 න් පසු සංස්කරණ වලදී නම් මෙම 2 ක්‍රම 2ම දෝශ රහිතයි නමුත් ඊට පෙර සංස්කරණයන්හි 2වන ක්‍රමය එනම් 6 වන පේලියේ ඇති ක්‍රමය දෝශ සහගතයි. Integer class type එක ඇති ඔබ්ජෙක්ට් එකකට int primitive type එකක් assign කිරීම ඇත්තටම වරදක්. නමුත් ජාවා 1.5න් පසු සංස්කරණ වලදී එලෙස assign කර ඇති අගය සුදුසු wrapper class type එකට convert කිරීමෙන් අනතුරුවයි assign කිරීම සිදුකරන්නේ. මෙය autoboxing ලෙසත් හඳුන්වනවා.

දැන් අපි බලමු මෙම wrapper classes භාවිතාකර data types convert කරන ආකාරය. මේ සඳහා ලියන ලද සරළ ජාවා වැඩසටහන බලමු.
public class Wrapper{
 public static void main(String args[]){
  String str1="23.44";
  String str2="44.76";
  float val1=Float.parseFloat(str1);
  float val2=Float.parseFloat(str2);

  System.out.println("str1 \t => " + str1);
  System.out.println("str2 \t => " + str2);
  System.out.println("String Data\t=> "+str1+str2);
  System.out.print("float  Data\t=> ");
  System.out.println(val1+val2);
 }
}
 line 5 හා line6 දී සිදුකර ඇත්තේ str1 හා str2 යන String data val1 හා val2 ලෙස float ඩේටා බවට පත්කිරීමයි. ඒ ආකාරයට wrapper class අටේම ඇති parseXXX methods (parseInt(),parseFloat(),parseDouble()...) දත්ත භාවිතා කර අපිට අවශ්‍ය data type වලට convert කරගන්න පුලුවන්.

දැන් අපි wrapper classes භාවිතා කර යම් data type එකකට දැරිය හැකි උපරිම හා අවම අගයන් ලබාගැනීමට වැඩසටහනක් ලියමු.
public class Wrapper{
 public static void main(String args[]){
  
  System.out.println("Byte wrapper"+"\t_______________");
  System.out.println("Max value : "+Byte.MAX_VALUE);
  System.out.println("Min value : "+Byte.MIN_VALUE);
  System.out.println();

  System.out.println("Integer wrapper"+"\t_______________");
  System.out.println("Max value : "+Integer.MAX_VALUE);
  System.out.println("Min value : "+Integer.MIN_VALUE);  
  System.out.println();

  System.out.println("Long wrapper"+"\t_______________");
  System.out.println("Max value : "+Long.MAX_VALUE);
  System.out.println("Min value : "+Long.MIN_VALUE); 
  System.out.println();
  
  System.out.println("Float wrapper"+"\t_______________");
  System.out.println("Max value : "+Float.MAX_VALUE);
  System.out.println("Min value : "+Float.MIN_VALUE); 
  System.out.println(); 
  
  System.out.println("Double wrapper"+"\t_______________");
  System.out.println("Max value : "+Double.MAX_VALUE);
  System.out.println("Min value : "+Double.MIN_VALUE); 
  System.out.println();
 }
}
ප්‍රථිඵලය:

Source: Java Documentation

Thursday, June 17, 2010

ජාවා වැඩසටහනකින් Keyboard Inputs ලබාගන්නා අයුරු :: (Accessing the standard input stream)

ජාවා භාවිත යෙදුම්(Java Aplications)  Desktop applications හා Console applications  වශයෙන් මූලික ආකාර 2ක් තිබෙනවා .  Desktop applications සඳහා textbox වැනි component භාවිතාකර user inputs ලබාගන්න පුලුවන් මේ සඳහා awt හා swing ලෙස ජාවා පැකේජ 2ක් හඳුන්වාදී තිබෙනවා. නමුත් console application යනු console එක(windows වලදී command prompt එක) ක්‍රියාකරන ආකාරය අනුව කොන්සෝල් එකෙදී inputs ලබාගැනීමට වන්නේ keyboad එක මගින් ලබාදෙන string එකක් වශයෙන්. අපි අද පාඩමෙන් අධ්‍යයනය කරන්නේ කොන්සෝල් එක මගින් user input එකක් ලබාගන්නා අයුරුයි.

Saturday, June 12, 2010

ජාවා වස්තු පාදක ක්‍රමලේඛනය VI (Inheritance) :: 1 කොටස

Inheritance යනු ජාවාහි එන ප්‍රභල සංකල්පයක්. එමෙන්ම වස්තු පාදක වැඩසටහන් (OOP programs) ලිවීමේදී මෙය බොහෝ විට භාවිතා වනවා. C++ වැනි අනෙකුත් OOP සඳහා සහය දක්වන පරිගණක භාෂා වලත් මෙම සංකල්පය සඳහා සහය දැක්වුවද C++ හා Java අතර inheritance හිදී යම් වෙනස්කම් පවතිනවා.

දැම් අපි බලමු මොකක්ද මේ inheritance ක්‍රියාවලිය කියල,  Inheritance  යනු යම් class එකකකින් සාදන ලද වස්තුන්(objects) වෙනත් class එකකට අයත් objects වල ගුණාංගයන්ද අයත් කර ගැනීමේදී සිදුකරන ක්‍රියාවලියයි. එම නිසා මෙහිදී අදාල ලක්ෂණ අත් කරගත් class එක සහ ලක්ෂණ අත් කරගැනීමට බඳුන් වූ class එක සඳහා පොදු ලක්ෂණ එකක් හෝ කිහිපයක් පවතිනවා. අදාල ලක්ෂණ අත් කරගත් class එක child class එක නොහොත් sub class එක ලෙසත් ලක්ෂණ අත් කරගැනීමට බඳුන් වූ class එක parent class එක නොහොත් super class එක ලෙසත් හැඳින්වෙනවා.  මෙම ක්‍රියාවලියේදී extends නම් ජාවා keyword එක භාවිතා වනවා. යම් class එකක් Inherite කිරීමෙන් සාදන ලද නව class එක එහි parent class එකෙහි attributes සහ behaviour යනාදිය උකහා ගන්නා නිසා මෙහිදී ඉබේම software re-usability නම් සංකල්පයද ක්‍රියාත්මක වනවා. නමුත් inherite කිරීමෙන් සාදාගන්නා ලද නව class එකෙහි එහි parent class එකේ නොමැති attributes සහ behaviours අන්තර්ගත වීමට පුලුවන්.

ජාවා තුල inheritance සංකල්පය ක්‍රියාවට නැංවීමේදී දැන ගතයුතු කරුණු.

  •  ► අලුතින් සාදන සෑම class එකක්ම අනිවාර්‍යයෙන්ම වෙනත් class එකක් extend (inherit) කල යුතුය.
  • extend කරන්නේ කුමන class එකක්ද යන්න විශේෂයෙන් සඳහන් කර නැති විට Object යන class එක inherit වීම සිදුවේ. Object යනු ජාවා class hierarchy එකේ උඩින්ම ඇති super class එකයි.
  •  ► inherit කිරීමකදී කිසිවිටෙකත් constructors උකහා ගැනීම සිදුනොවේ. සියලුම constructors එය define කරන ලද class එක සඳහා වීශේෂ වේ. (constructor පිලිබඳ අපි මීට පෙර පාඩමකින් සාකච්ඡා කර තිබේ එම පාඩම සඳහා මෙතන click කරන්න)
  •  ► යම්කිසි sub class එකක් construct වීමේදී එම class එකෙහි super class එකෙහි constructor එක මුලින්ම call වීම සිදුවේ.
  • ජාවාහිදී ඕනෑම class එකකට තිබිය හැක්කේ එක් parent class එකක් පමණි. එනම් multiple inheritance සඳහා ජාවා සහය නොදක්වයි. එමනිසා multiple inheritance මගින් සිදුවන කාර්‍යය ජාවාහිදී සිදුකරන්නේ interfaces භාවිතයෙනි. අපි ඉදිරි පාඩමකින් ජාවා interfaces පිලිබඳ අධ්‍යයනය කරමු. ජාවා multiple inheritance සඳහා සහාය නොදැක්වුවද C++ වලදී නම් multiple inheritance සඳහා ඉඩකඩ සලසා තිබේ.
Syntax for extending/inheriting a class
class SubClassName extends SuperClassName
දැන් අපි මෙම inheritance සංකල්පය හොඳින් වටහා ගැනීම සඳහා සරල ජාවා වැඩසටහනක් ලියමු.
එම ජාවා වැඩසටහන සඳහා අපි පහත hierarchy එක භාවිතා කරමු.
Cube.java
/**
 *class  : Cube
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */


class Cube {
 protected int length;
 protected int width;
 protected int height;
 
 public Cube(int l,int w,int h){
  length=l;
  width=w;
  height=h;
 }
 
 public void setLength(int l){
  length=l; 
 }
 
 public void setWidth(int w){
  width=w; 
 } 
 
 public void setHeight(int h){
  width=h; 
 }
 
 public int getVolume(){
  return(length*width*height);
 }

 public void showInfo(){
  System.out.println("Length \t:"+this.length);
  System.out.println("Width  \t:"+this.width);
  System.out.println("Height \t:"+this.height);
  System.out.println("Volume \t:"+getVolume());
 }
}
ColorCube.java
/**
 *class  : ColorCube
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */

class ColorCube extends Cube {
 String color;
 
 public ColorCube(int l,int w,int h,String color){
  //constructing the parent
  super(l,w,h);
  this.color=color;
 }
 
 public void setColor(String color){
  this.color=color;
 }
 
 public void showInfo(){
  super.showInfo();
  System.out.println("Color \t:"+this.color);
 }
}
InheritanceDemo.java
/**
 *class  : InheritanceDemo
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */

class InheritanceDemo {
 public static void main(String args[]){
  Cube cube1=new Cube(3,7,5);
  ColorCube ccb1=new ColorCube(2,9,4,"Blue");
  
  cube1.showInfo();
  System.out.println("_____________________________");
  ccb1.showInfo();
  
  System.out.println("\nMaking changes to cube objects....");
  cube1.setWidth(8);
  ccb1.setColor("Yellow");
  ccb1.setHeight(6); //this methods is inherited by the Cube class
  System.out.println("New info. of modified objects\n");  
  cube1.showInfo();
  System.out.println("_____________________________");
  ccb1.showInfo();  
 }
}
Output :
ඉහත ජාවා වැඩසටහන අධ්‍යයනයෙන් ඔබට inheritance පිලිබඳ තවදුරටත් වටහාගත හැකිවනු ඇත.එහි class variables සඳහා protected access එකක් ලබාදීමෙන් සිදුකරන්නේ එම data members සඳහා ප්‍රවේශවීම(access) අදාල class එක තුලදී සහ එහි sub classes වලට පමණක් සීමා කිරීමයි.

දැන් අපි Inheritance හිදී සිදුවන ක්‍රියාවලිය සියුම්ව වටහා ගැනීමට සුදුසු ජාවා වැඩසටහනක් අධ්‍යයනය කරමු.
InherianceStudy.java
/**
 *class  : InherianceStudy
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */

class Parent {
 protected int i,j;
 
 public Parent(){
  System.out.println("Using the default constructor of Parent class..");
  i=0;
  j=0;
 }
 
 public Parent(int i,int j){
  System.out.println("Using the integer constructor of Parent class..");
  this.i=i;
  this.j=j;
 }
 
 public void showMessage(String msg){
  System.out.println("A message from Parent class..");
  System.out.println("Message : "+msg);
 }
}

class Child extends Parent {
 protected String text;
 
 public Child(){
  System.out.println("Using the default constructor of Child class..");
 }
 
 public Child(int i,int j,String t){
  super(i,j);
  System.out.println("Using the integer constructor of Child class..");
  this.text=t;
 }
 
 public void showMessage(){
  showMessage("Java programming is very interesting!!");
  System.out.println("A message from Child class..");
  System.out.println("Message : "+text);
 }
}

class InherianceStudy {
 public static void main(String args[]){
  System.out.println("Creating Parent objects...");
  System.out.println("_________________________________________________\n");
  Parent p1=new Parent();
  Parent p2=new Parent(2,5);
  System.out.println("\nCreating Child objects...");
  System.out.println("_________________________________________________\n");
 
  Child c1=new Child();
  Child c2=new Child(3,-1,"Java is owned by Sun Microsystems");
  System.out.println("\nShowing messages..");
  System.out.println("_________________________________________________\n");
  c2.showMessage();
 }
}
Output:

ඉහත ජාවා කේතය දී ඇති ප්‍රතිඵලය සමග සැසඳීමෙන් ඔබට Inheritance සංකල්පය ගැන හොඳ අවබෝධයක් ලබා ගැනීමට පුලුවන්.  Sub class එකකින් object එකක් සාදන සෑම විටම එහි super class එකත් construct වීම සිදුවන බව දැන් ඔබට වටහා ගත හැකිවිය යුතුයි.

මෙම පාඩමේ උදාහරණ download කරගැනීමට පහත Link එක භාවිතා කරන්න.

Thursday, June 3, 2010

ජාවා වස්තු පාදක ක්‍රමලේඛනය V (Data Encapsulation/ Data Hiding)

 data සහ methods තනි ඒකකයකට සංක්ෂිප්ත කිරීම data encapsulation ලෙස හඳුන්වන්න පුලුවන්. මෙහි තනි ඒකකය ලෙස දක්වා ඇත්තේ ජාවා class එකකි.  ජාවා class එකක ඉතාම සිත් ගන්නා සුලු ලක්ෂණයක් ලෙසටද data encapsulation දැක්විය හැකියි. මෙහිදී සිදුකරන්නේ පිටතින් දත්ත සඳහා සෘජුව පිවිසීමට(access) ඉඩ නොදී methods භාවිතා කොට ඒ සඳහා අතුරු මුහුනතක් සැකසීමයි. data hiding ලෙස හැඳින්වෙන්නේද මෙම සංකල්පයමයි. මෙම සංකල්පය ක්‍රියාවට නංවන ලද object එකක් අපට black box එකක් ලෙස හැඳින්විය හැකි අතර මෙහිදී එහි අභ්‍යන්තර ක්‍රියාවලිය ගැන සවිස්තර අවබෝධයක් නැතිව එහි සපයා ඇති methods ගැන පමණක් අවබෝධයක් ලබාගැනීමෙන් පසු අදාල කාර්‍ය කිරීමට හැකිය.

Data Encapsulation සංකල්පය ක්‍රියාවට නැංවීම සඳහා අනුගමනය කලයුතු නීතිරීති.

1 ) Encapsulate කරන ලද object එකක අභ්‍යන්තර දත්ත(internal data) කිසි විටෙකත් වෙනත් පරිභාහිර object එකක් මහින් සෘජුව මෙහෙයවීම වැළැක්විය යුතුය.
2 ) දත්ත මෙහෙයවීම(manipulate) සඳහා accessor methods හා mutator methods භාවිතා කල යුතුය.
  • Accessor Methods - අභ්‍යන්තර දත්ත වලට අදාල අගයන් පිටතට ලබාදීමට යොදාගනී. එමෙන්ම අභ්‍යන්තර දත්ත(internal data) ප්‍රදර්ශනය කිරීමක් වැනි ක්‍රියාවලටද යොදාගනී. සාමාන්‍යයෙන් accessor method එකක නම ආරම්භ වනුයේ get යන උපසර්ගයෙනි(prefix).
උදා :  getUserName(); , showErr();
  • Mutator Methods - අභ්‍යන්තර දත්ත සඳහා අගයන් සෙට් කිරීම මෙම methods භාවිතයෙන් සිදුකෙරේ. මෙහිදී නව දත්ත වල වලංගු භාවය(validity) සහ සම්පූර්ණත්වය (integrity) සහතික කල හැකිය. සාමාන්‍යයෙන් mutator method එකක නම ආරම්භ වනුයේ set යන උපසර්ගයෙනි(prefix).
උදා : setWallpaper(String imagePath);

දැන් අපි data encapsulation/data hiding සංකල්පය හොඳින් අවබෝධ කරගැනීම සඳහා උදාහරණයක් බලමු. 
 
Cylinder.java
/**
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate encapsulation in Java
 *Blog   : http://javaxclass.blogspot.com
 */

public class Cylinder{
 //radius and height are private members
  
 private double radius,height;
 
 public Cylinder(double rad,double ht){
  radius=rad;
  height=ht;
 }
 
 //mutator methods
 public void setRadius(double rad){
  radius=rad;
 }
 
 public void setHeight(double ht){
  height=ht;
 }
 
 //accessor methods
 public double getVolume(){
  return (Math.PI*radius*radius*height);
 }
 
 public double getSurface(){
  return (2*Math.PI*radius*(height+radius));
 }
}
දැන් අපි ඉහත Cylinder class එක භාවිතා කිරීමට සරළ වැඩසටහනක් ලියමු.
EncapDemo.java
public class EncapDemo{
 public static void main(String args[]){
  Cylinder c1=new Cylinder(4.23,12.56);
  //invoking accessor methods
  double surf1=c1.getSurface();
  double vol1=c1.getVolume();
  System.out.println("Volume of c1  : " + vol1 );
  System.out.println("Surface of c1 : " + surf1 );
  
  //invoking mutator methods
  System.out.println("Modifying the cylinder object..");
  c1.setRadius(23.11);
  c1.setHeight(5.46);
  double surf2=c1.getSurface();
  double vol2=c1.getVolume();  
  System.out.println("Volume of c1  : " + vol2 );
  System.out.println("Surface of c1 : " + surf2 );  
  
 }
}
Output :

Cylinder class එකෙහි data members සියල්ලම private ලෙසද පිටතින් invoke කරන methods සියල්ලම public ලෙසටද යොදා ඇත. එනිසා මෙහිදි Cylinder object එකක internal data භාහිරින් access(ප්‍රවේශනය) කල නොහැක. තවද අදාල දත්ත මෙහෙයවීම සඳහා accessor සහ mutator methods යොදා ඇත. එමනිසා මෙම Cylinder class එක encapsulate කරන ලද ඒකකයකි.