Java සමග Software Design Patterns (1 කොටස)

කිසියම් පරිගණක භාෂාවක් යොදාගෙන මෘදුකාංග නිපදවීමේදී අප විසින් කිසියම් සැලසුමක් මුලින් සකස් කල යුතු වනවා. මෙහිදී අදාල සැලැස්ම ඉතා හොඳ එකක් වීම ඉතා වැදගත්. හොඳ මෘදුකාංග සැලසුමක් නිසා කේතකරණය මෙන්ම මෘදුකාංගයේ නව යාවත් කාලීන කිරීම් පුලුල් කිරීම් ආදිය පහසු වීම සිදුවනවා.
හොඳ design එකක් සාදාගැනීම සඳහා භාවිතාකරන එක තාක්ෂණයක් තමයි software design patterns කියල කියන්නෙ. කිසියම් මෘදුකාංගයක් සැලකීමේදී එහි design pattern 1කට වැඩි සංබ්‍යාවක් තිබීමට පුලුවන්.
software design pattern සඳහා වන Wikipedia හි අර්ථ දැක්වීම

"A general reusable solution to a commonly occurring problem in software design"

සරළව විස්තර කරන්නේ නම්. design pattern එකක් යනු විවිධ අවස්ථාවන් සඳහා යොදාගත හැකිවන පටිදි කිසියම් ගැටලුවක් විසඳන ආකාරයයි. එම නිසා ඕනෑම software pattern එකක් සැලකූ විට ඒය design pattern එකක් නොවිය හැකියි.
උදා: algorithm(sorting,encrypting,compressing..etc) සහ data structures(queues, linked lists, stacks...etc) යන ඒවා design patterns ලෙස නොසැලකේ.

පහත දැක්වෙන ආකාරයට design patterns වර්ග කල හැකිය

creational design

object සෑදීම විධිමත් ලෙස කලමනාකරණය කිරීමට යොදාගැනේ

structural design

විධිමත් ලෙස objects එකලස් කිරීම සඳහා යොදාගැනේ

behavioral design patterns

flow control සහ algorithms කලමණාකරනය කිරීම සඳහා යොදාගැනේ

අපි දැන් බලමු singleton design pattern එක පිලිබඳව.

Singleton Design Pattern

මෙය creational pattern ආකාරයට අයත් වේ. සාමාන්‍යයෙන් class එකක් සැලකූ විට object 1ක් හෝ ඊට වැඩි ගනණක් සෑදිය හැකිය. class එකකින් instance එකක් පමණක් ලබාගන්නා අන්දම මෙමගින් පැහැදිලි කෙරේ.

class structure

මෙහිදී Singleton class එක සඳහා subclasses නොමැති නම් Singleton constructor එක private ලෙස දැක්විය යුතුය.

මෙහිදී Singleton එක access කල හැක්කේ getInstance() static method එක හරහා වේ. එනම් Singleton එකෙන් object create කිරීම කල හැක්කේ getInstance() method එක හරහා පමණි.

Sample Code:

/**     
*class  : Singleton  
*Author : Kanishka Dilshan     
*Purpose: Showing how to implement Singleton design pattern
*Blog   : http://javaxclass.blogspot.com     
*/ 

class Singleton {
 private static Singleton instance=null;
 
 protected Singleton(){
  
 }
 
 public static Singleton getInstance(){
  if(instance==null){
   instance=new Singleton();
  }
  return instance;
 }
}

දැන් අපි බලමු Singleton design pattern එක යොදාගෙන සරල වැඩසටහනක් ලියන අයුරු.

/**     
*class  : PrinterSingleton  
*Author : Kanishka Dilshan     
*Purpose: Showing how to use Singleton design pattern
*Blog   : http://javaxclass.blogspot.com     
*/ 

class PrinterSingleton {
 private static PrinterSingleton instance=null;
 int jobsCount;
 private PrinterSingleton(){
  jobsCount=0;
 }
 
 public static PrinterSingleton getInstance(){
  if(instance==null){
   instance=new PrinterSingleton();
  }
  return instance;
 }
 
 public void addNewJob(){
  jobsCount++;
 }
 
 public int getJobsCount(){
  return jobsCount;
 }
}


public class SingletonTest {
 public static void main(String args[]){
  PrinterSingleton p1=PrinterSingleton.getInstance();
  PrinterSingleton p2=PrinterSingleton.getInstance();
  
  p1.addNewJob();
  p1.addNewJob();
  p1.addNewJob();
  
  System.out.println("p1 job count "+p1.getJobsCount());
  System.out.println("p2 job count "+p2.getJobsCount());
  
  if(p1.equals(p2)){
   System.out.println("p1 and p2 are same object");
  }
 }
}

output:

Singleton design pattern එක වැඩිදියුණු කරමින් Coupleton design එකක්(exactly 2 instances) implement කරන අයුරු මීලඟට බලමු.

/**     
*class  : CoupletonTest, Coupleton  
*Author : Kanishka Dilshan     
*Purpose: Showing how to implement coupleton design pattern
*Blog   : http://javaxclass.blogspot.com     
*/

class Coupleton{
 private static Coupleton _instance1=null;
 private static Coupleton _instance2=null;
 private String ins_name;
 private Coupleton(String insName){
  this.ins_name=insName;
 }
 
 public static Coupleton getInstance(int instanceNo,String ins_name){
  if(instanceNo==1){
   if(_instance1==null){
    _instance1=new Coupleton(ins_name);
   }
   return _instance1;
  }else if(instanceNo==2){
   if(_instance2==null){
    _instance2=new Coupleton(ins_name);
   }
   return _instance2;  
  }else{
   return null;
  }
 }
 
 public String getInsName(){
  return ins_name;
 }
 
}

public class CoupletonTest{
 public static void main(String args[]){
  Coupleton c1=Coupleton.getInstance(1,"My Coupleton1");
  Coupleton c2=Coupleton.getInstance(2,"My Coupleton2");
  Coupleton c3=Coupleton.getInstance(1,"My CoupletonX");
  Coupleton c4=Coupleton.getInstance(2,"My CoupletonY");
  System.out.println("c1 instance name : "+c1.getInsName());
  System.out.println("c2 instance name : "+c2.getInsName());
  System.out.println("c3 instance name : "+c3.getInsName());
  System.out.println("c4 instance name : "+c4.getInsName());
 }
}

output: