ජාවා වස්තු පාදක ක්‍රමලේඛනය 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 කරන ලද ඒකකයකි.