Showing posts with label Software Design Patterns. Show all posts
Showing posts with label Software Design Patterns. Show all posts

Monday, April 15, 2024

ইনহেরিটেন্স ও কম্পোজিশন

Inheritance & Composition: Design patterns এ আমরা অসংখ্যবার inheritance ও composition এর মুখোমুখি হয়েছি। এই দু'টি term এবং আরো কিছু জরুরি term এর উপর ছোট আলোচনার দায় অনুভব করছি,নাহলে design patterns নিয়ে আলোচনা অসম্পূর্ণ থেকে যাবে। বিদ্যমান software ব্যবহার করে নতুন software তৈরির উপায় হচ্ছে inheritance ও composition। Inheritance এ base class/super class এর member গুলো subclass/derived class ব্যবহার করতে পারে। এটিকে "is-a" relationship হিসেবেও উল্লেখ করা হয়। কারণ derived class এর object কিন্তু superclass এরও object ("Every object of derived class is also an object of the inherited/superclass ")। উদাহরণে class B হল class A এর subclass এবং Bএর say() মেথড call করলে তা superclass A এর des() মেথডকে call করছে।

উদাহরণ:
class A {
constructor(){}
des(){return " A is here!";}
}
class B extends A{
constructor(){
super();
}
say(){document. write("Inside B:");
return super.des();}
}
var s=new B();
document.write(s.say());

Composition এ এক বা একাধিক class কে অন্য class এর definition এ ব্যবহার করা হয়। এটিকে " has-a" relationship হিসেবেও উল্লেখ করা হয়। কারণ নতুন যেই class তৈরি করা হচ্ছে (Composite class,এটিকে Composite design pattern এর সাথে মেলাবেন না) তাতে অন্য class(Composed class) এর member আছে ("Objects of composite class have objects of composed class as members")।উদাহরণে class C তে class A এর object কে member হিসেবে নিচ্ছে আর C এর tell() মেথডে Aএর des() মেথডকে ব্যবহার করা হচ্ছে।

উদাহরণ:
class A {
constructor(){}
des(){return " A is here!";}
}
class C{
a=new A();
constructor (){}
tell(){
document. write("Inside C:");
return this.a.des();}
}
var e=new C();
document. write(e.tell());

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Thursday, April 11, 2024

শেষ থেকে হোক শুরু

"'Design Patterns:Elements Of Reusable Object-Oriented Software'"( by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides) বইয়ে যে ২৩ টি Patterns এর কথা উল্লেখ করা হয়েছিল তার সবই এখানে সহজ ভাষায় তুলে ধরার চেষ্টা করা হয়েছে।এর বাইরেও আরো উল্লেখ করার মত Patterns রয়েছে তবে আলোচনা আর লম্বা না করে এখানেই ইতি টানতে হচ্ছে। প্রয়োজনে পরে এদের কয়েকটি নিয়ে আলোচনা হতে পারে।

Patterns এর উদ্দেশ্য বা Goal এর উপর নির্ভর করে এদের তিন ভাগে ভাগ করা হয়েছে। Creational Patterns মূলতঃ objects/ class instance গঠন প্রক্রিয়া নিয়ে কাজ করে থাকে। Structural Patterns মূলতঃ class /objectএর গঠনকে কিভাবে সাজানো হবে/Composition সে বিষয়ে আলোকপাত করে। আর Behavioral Patterns মূলতঃ বিভিন্ন objects নিজেদের মধ্যে কিভাবে যোগাযোগ করবে আর তাদের মধ্যে দায়িত্ব/কাজ/behavior কিভাবে বন্টন করা হবে সে বিষয়টি ব্যাখ্যা করে।

(আরো জানতে Patternটির উপর ক্লিক করুন)


Creational Structural Behavioral
ফ্যাক্টরি মেথড,
আ্যবস্ট্রাক্ট ফ্যাক্টরি,
বিল্ডার,
প্রোটোটাইপ,
সিঙ্গলটন
এডাপ্টার,
ব্রিজ,
কম্পোজিট,
ডেকোরেটর,
ফাসাদ ,
প্রক্সি
ইন্টারপ্রেটার,
টেমপ্লেট মেথড,
চেইন অব রেসপন্সেবিলিটি,
কমান্ড,
আইটেরটর,
মেডিয়েটর,
মেমেন্টো,
ফ্লাইওয়েট,
অবজার্ভার,
স্টেট,
স্ট্র্যাটেজি,
ভিজিটর

আবার Patterns এর ব্যাপ্তি/প্রভাব(Scope) অনুযায়ি এদের দু'দলে ভাগ করা যায়: Patterns এর প্রয়োগ কি class এর উপর নাকি object এর উপর। Class Patterns মূলতঃ কাজ করে থাকে Class ও Subclass এর মধ্যকার সম্পর্ক নিয়ে যেটি হয়ে থাকে inheritance (ভবিষ্যতে আলোচনা করা হবে) এর মাধ্যমে। এ সম্পর্ক অপরিবর্তনীয়। আর Object Patterns মূলতঃ objects এর সম্পর্ক নিয়ে কাজ করে থাকে যা run timeএ আবার পরিবর্তন করা যায়।

Class Object
ফ্যাক্টরি মেথড,
এডাপ্টার,
ইন্টারপ্রেটর,
টেমপ্লেট মেথড
আ্যবস্ট্রাক্ট ফ্যাক্টরি,
বিল্ডার,
প্রোটোটাইপ,
সিঙ্গলটন,
এডাপ্টার,
ব্রিজ,
কম্পোজিট,
ডেকোরেটর,
ফাসাদ,
প্রক্সি,
চেইন অব রেসপন্সিবিলিটি,
কমান্ড,
আইটেরটর,
মেডিয়েটর,
মেমেন্টো,
ফ্লাইওয়েট,
অবজার্ভার,
স্টেট,
স্ট্র্যাটেজি,
ভিজিটর

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Friday, April 5, 2024

ভিজিটর

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Visitor:এটি objectsএ বিভিন্ন behavior যোগ করতে সাহায্য করে objectsএর নিজ নিজ class এর ভেতর কোন পরিবর্তন না ঘটিয়ে। দু'টি প্রধান উপাদান হচ্ছে: Visitor ও Visitable Element(যার object এর উপর behavior যোগ করা হবে)। এক্ষেত্রে behaviors গুলো নানা methods আকারে Visitor class এ থাকে। আর Visitable Element class এ object এর গঠন কিরকম হবে তা নিয়ে ব্যস্ত থাকে আর তার accept() মেথড থাকে যা Visitor object কে argument হিসেবে নেয় এবং প্রযোজ্য Visitor methodকে ব্যবহার করে। উদাহরণে Cost এবং CostWithVat হল Visitor class ProdVisitor এর implementation। আর Banana ও Milk হচ্ছে Visitable Elements class এর উদাহরণ। Runtime এ আমরা Cost কেমন দেখতে চাই ---VAT সহ না VAT ছাড়া--তাই এখানে দেখানো হচ্ছে। এটি করতে গিয়ে আমাদের Banana ও Milk class এ কোন পরিবর্তন করতে হয়নি।

উদাহরণ:
class ProdVisitor{
constructor(){}
vstBanana(banana){}
vstMilk(milk){}
}
class Cost extends ProdVisitor{
constructor(){super();}
vstBanana(banana) {
return banana.price * banana. qty;
}
vstMilk(milk) {
return milk.price * milk.qty;
}
}
class CostWithVat extends ProdVisitor{
constructor(){super();}
vstBanana(banana) {
var a=0.15*(banana.price * banana. qty);
return (banana.price * banana. qty)+a;
}
vstMilk(milk) {
var m=0.15*(milk.price*milk.qty);
return (milk.price * milk.qty)+m;
}
}
class Banana {
constructor (p,q){
this.price=p;
this.qty=q;
}
accept (visitor){
return visitor.vstBanana(this);
}
}
class Milk{
constructor (p,q){
this.price=p;
this.qty=q;
}
accept (visitor){
return visitor.vstMilk(this);
}
}
var b=new Banana(10,1);
var l=new Milk(25,1);
var cost=new Cost();
var vcost=new CostWithVat();
var bcost=b.accept(cost);
var mvcost=l.accept (vcost);
document.write(bcost);
document.write(mvcost);

চেষ্টা করা যাক:ProdVisitor এর বিকাশ ঘটাতে এতে CostWithDelivery class নামে নতুন class যোগ করি যা cost এর সাথে বাড়তি ৫০ টাকা যোগ করবে delivery charge হিসেবে। Program টি নতুন করে আবার লিখি।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Thursday, April 4, 2024

ফ্লাইওয়েট

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Flyweight:এটি Structural Design Pattern দলের। Memory consumption কমানোর জন্য এটি ব্যবহার করা হয়। এটি object এর intrinsic state (যা পরিবর্তন করা যায় না এবং share করা যায়) কে extrinsic state(যা unique এবং context এর উপর নির্ভর করে) থেকে আলাদা করে। উদাহরণে Address কিভাবে Address Book এ জমা রাখা হয় তা দেখানো হয়েছে। Address class এ name, city ও phone members হচ্ছে এর intrinsic state। আর des() এ sl নামে যে serial number দেয়া হচ্ছে তা extrinsic state। এখানে চাইলেই যখন খুশি name,city আর phone change করা যাবে না। কিন্তু user চাইলেই serial number পরিবর্তন করতে পারবে । AddBook class এর getAdd() এর মাধ্যমে user এর কাছ থেকে name,city ও phone number নিচ্ছে আর তা যদি নিজস্ব Address Book(যা Map/Dictionary data structure এবং এখানে শুধু book নামে পরিচিত)এ থাকে তবে তা return করছে নাহলে নতুন একটি Address object বানিয়ে তা book এ জমা করে return করছে।

উদাহরণ:
class Address {
constructor(name ,city,phone) {
this.name= name;
this.city= city;
this.phone = phone;
}
des(sl) {
document.write(`Sl no.:${sl} Name: ${this.name} ,City: ${this.city}, Phone: ${this.phone}
`);
}
}
class AddBook{
constructor() {
this.book = {};
}
getAdd(n, c, p) {
var key = `${n}-${c}-${p}`;
if (!this.book[key]) {
this.book[key] = new Address(n,c,p);
}
return this.book[key];
}
}
var b = new AddBook();
var firstAdd = b.getAdd('Unk','Noville', 12);
var secondAdd= b.getAdd('Bumb', 'Transzia',14);
firstAdd.des(1);
secondAdd.des(2);

চেষ্টা করা যাক: আরেকটি program লিখি Friends নামে। এখানে শুধু name আর address নামে দু'টি members থাকবে যা intrinsic state নির্দেশ করে। আর des() এ pseudo নামে একটি argument pass করা হবে যা Friends দের pseudo name কে বোঝাবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Sunday, March 31, 2024

বিল্ডার

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Builder: এটি object এর গঠনকে তার প্রতিনিধিত্ব থেকে আলাদা করে। সাধারণত object যদি complex হয়ে থাকে তবে সেটির creation এর ভার দেয়া হয় অন্য আরেকটি class/interfaceকে যা Builder নামে পরিচিত।এতে creation এর দরকারি methods থাকে। Concrete Builder এটিকে implement এর কাজ করে থাকে আর object এর বিভিন্ন রুপের গঠন প্রক্রিয়ার সাথে জড়িত । আরেকটি class থাকে যা Director নামে পরিচিত যা মূলত: object এর গঠন কাজকে তদারক করে থাকে Builder object এর সাহায্যে। উদাহরণে Lamp গঠন প্রক্রিয়াকে তুলে ধরা হয়েছে। এখানে BedLampBuilder class টি Bed Lamp গঠন করছে আর Director তা তদারক করছে। buildStand() আর buildShade() methods ঠিক করছে Lamp এর Stand আর Shade কি ধরণের হবে। Director এর constructor এ তিনটি argument দেয়া হয়েছে : একটি Builder object আর দু'টি হল user এর সরবরাহ করা string arguments, যা Stand আর Shade কিরকম হবে তা বলে দিচ্ছে।

উদাহরণ:
class Lamp{
constructor(){
this.l=" ";
this.s=" ";
}
Stand(t){this.l=t;}
Shade(s){this.s=s;}
des(){document.write(this.l+ ", "+this.s);}
}
class Builder{
constructor(){}
buildShade(s){}
buildStand(t){}
getLamp(){}
}
class BedLampBuilder extends Builder{
w=null;
constructor(){
super();
var q=new Lamp ();
this.w=q;
}
buildStand(t){this.w.Stand(t);}
buildShade(s){ this.w.Shade(s);}
getLamp(){return this.w;}
}
class Director{
constructor(b,s,c){
this.b=b;
this.b.buildStand(s);
this.b.buildShade(c);
}
getL(){
var a=this.b.getLamp();
return a;
}
}
var d=new Director(new BedLampBuilder(),"Black Stand","Yellow Shade");
d.getL().des();

চেষ্টা করা যাক:Progrgram টি আবার লিখি। এবার Table Lamp এর জন্য।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Thursday, March 28, 2024

প্রোটোটাইপ

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Prototype: এটি Creational Design Pattern দলের। এর মাধ্যমে আনকোড়া নতুন object তৈরির বদলে আগে থেকে বিদ্যমান object এর copy তৈরি করা হয়। আর copy করার কাজটি করা হয় clone() এর সাহায্যে। যখন নতুন object তৈরি করা বেশ সময় সাপেক্ষ তখন এই pattern বেশ কাজে দেয়।Subclass নির্ভরতা কমিয়ে নতুন behavior যোগ করতে এবং runtime এ প্রয়োজন অনুযায়ি object তৈরি করতে এই pattern বেশ কাজে দেয়। উদাহরণে Cycle তৈরির জন্য যেসব Parts এর দরকার হয় তার Prototype আগে থেকে তৈরি করে রেখে একেবারে runtime এ Cycle object তৈরির সময় এদেরকে ব্যবহার করা হয়েছে। এখানে Parts হচ্ছে Prototype interface আর Cycle, Wheel,Frame ও BackSeat হচ্ছে এর implementation । এদের সবার clone() নামক method আছে যা ঐ class এর instance/object তৈরি করে return করছে। Cycle class এ addWheel(),addFrame() ও addBackSeat() নামক method গুলো ঐ objectকে জুড়ে দেবার কাজ করছে। CycleFact হল Cycle object assemble করার interface আর ProtoFact হচ্ছে এর implementation। ProtoFact এর method গুলোর (getWheel(),getFrame() ইত্যাদি) মাধ্যমে যেসব objects কে ProtoFact এ argument হিসেবে pass করা হয়েছিল তাদেরকে clone() করে copy করা হচ্ছে ।Cycle আমরা কেমন চাই-- Back seat সহ না Back seat ছাড়া --তার উপর নির্ভর করে আমরা runtimeএ প্রয়োজন অনুযায়ি argument দিতে পারি ProtoFact এ। এজন্য ProtoFact এ দু'ধরণের constructor রয়েছে। Runtimeএ এটি না করলে আমাদের Factory method এর মত CycleWithBackSeat এবং CycleNoBackSeat নামে আলাদা subclass তৈরি করতে হত। এই Prototype pattern ব্যবহারের ফলে আমাদের Subclassing এর উপর বেশি নির্ভর করতে হচ্ছে না আর আমরা runtime এ দরকার অনুযায়ি object যোগ/বাদ দিতে পারছি। যেমন: BackSeat দরকার নেই বলে এর object আমরা runtime-এ ProtoFact এ argument হিসেবে দেইনি।উদাহরণে Back seat ছাড়া Cycle assemble করা হয়েছে।

উদাহরণ:
class Parts{
constructor(){}
clone(){}
des(){document.write("Parts");}
}
class Wheel extends Parts{
constructor(){super();}
clone(){return new Wheel(this);}
des(){document.write("Wheel");}
}
class Frame extends Parts{
constructor(){super();}
clone(){return new Frame(this);}
des(){document.write("Frame & seat");}
}
class BackSeat extends Parts{
constructor(){super();}
clone(){return new BackSeat(this);}
des(){document.write("Back seat");}
}
class Cycle extends Parts{
w=null;
f=null;
b=null;
constructor(){super();}
addWheel(w){this.w=w;}
addFrame(f){this.f=f;}
addBackSeat(b){this.b=b;}
clone(){return new Cycle(this);}
des(){document.write("Cycle:");
this.w.des();
this.f.des();
this.b.des();
}
}
class CycleFact{
constructor(){}
makeCycle(){ return new Cycle();}
getBackSeat(){return new BackSeat();}
getFrame(){return new Frame();}
getWheel(){return new Wheel();}
}
class ProtoFact extends CycleFact{
constructor(c,w,f,b){super();
this.c=c;this.w=w; this.f=f;this.b=b;}
static trio(c,w,f,b){
return new ProtoFact(c,w,f,null);
}
static whole(c,w,f,b){
return new ProtoFact(c,w,f,b);
}
makeCycle(){ return this.c.clone();}
getBackSeat(){return this.b.clone();}
getFrame(){return this.f.clone();}
getWheel(){return this.w.clone();}
}
var p=new ProtoFact(new Cycle (),new Wheel(),new Frame());
var a=p.makeCycle();
var w=p.getWheel();
var f=p.getFrame();
a.addWheel(w);
a.addFrame(f);
a.des();

চেষ্টা করা যাক:Progrgram টি আবার লিখি। এবার Cycle এ Back seat থাকবে। দরকারি পরিবর্তন যোগ করি।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Saturday, March 23, 2024

মেমেন্টো

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Memento:এটি objects এর ভেতরের অবস্থা প্রকাশ করে দেয়। object এর পূর্বের অবস্থা পুনরুদ্ধারে এই design pattern এর ব্যবহার করা হয়। এটি Behavioral Design Pattern দলের। এর প্রধান অংশ হচ্ছে:

  • Originator: যার ভেতরের অবস্থা আমাদের বিবেচনার বিষয়।
  • Caretaker:যে Originator এর উপর কাজ করে;তার ভেতরের পরিবর্তনকে পূর্বের অবস্থায় নিয়ে যেতে চায়।
  • Memento:এটি সাধারণ object; এর উপর Caretaker এর কোন প্রভাব নেই; নাম শুনেই বোঝা যাচ্ছে এটি অতীতের কোন জিনিস বা ঘটনাকে নির্দেশ করছে।
উদাহরণে Memento class B এর member হচ্ছে একটি integer এবং getInt() এর মাধ্যমে সেটি integerটিকে return করছে। Originator class A তার set() এর মাধ্যমে তার অবস্থা ঠিক করছে আর store() এর সাহায্যে তা Memento object এ রুপান্তর করছে আর getB() এর মাধ্যমে প্রযোজ্য Memento object এর integer কে প্রকাশ করে দিচ্ছে।Caretaker তার add() এর সাহায্যে Originator object এর রুপান্তর করা Memento object জমা করছে নিজের array তে। getState() এর মাধ্যমে user এর সরবরাহ করা index নিয়ে পূর্বের দরকারি Memento object কে পুনরুদ্ধার করছে।

উদাহরণ:
//memento
class B{
constructor(c){this.c=c;}
getInt(){ return this.c;}
}
//originator
class A{
constructor(){}
set(a){this.a=a;}
store(){
var b=new B(this.a);
return b;
}
getB(k){
this.a=k.getInt();
document.write(this.a);
}
}
//caretaker
class Caretaker {
constructor(){this.s=[];}
add(item){
this.s.push(item);
}
getState(ind){
return this.s[ind];
}
}
var c=new Caretaker ();
var a=new A();
a.set(2);
c.add(a.store());
a.set(3);
c.add(a.store());
a.set(4);
c.add(a.store());
a.getB(c.getState(2));

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Thursday, March 21, 2024

কম্পোজিট

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Composite:যখন objects দের মাঝের সম্পর্ককে part-whole সম্পর্কে রূপ দেয়া যায় এবং user কোন পার্থক্য করতে চায় না সাধারণ object এবং অনেক objects এর composition এর মাঝে তখন Composite Design Pattern ব্যবহার করা হয়। প্রধান অংশগুলো হচ্ছে: Component(composition এ objects এর interface গঠন করে এবং সব class এর জন্য common behavior [এখানে des()] implement করে),Leaf(Composition এর leaf objects কে প্রতিনিধিত্ব করে; leaf/part object এর কোন সন্তান নেই), Composite(যেসব Component objects র সন্তান আছে তাদের behavior কে define করা এবং সন্তানদের ধারণ করা )। উদাহরণে Pen ও Pencil হচ্ছে PencilBox নামের Composite class এর parts/leaves। আবার এরা সবাই Component Item কে implement করছে। তবে Pen ও Pencil সরাসরি implement করছে আর Composite class PencilBox অনুরোধকে forward করছে তার child components এর কাছে।

উদাহরণ:
*/ //component
class Item{
constructor(){}
des(){}
}
//leaf
class Pen extends Item{
constructor(){super();}
des() {
document.write("Pen");
}
}
//leaf
class Pencil extends Item{
constructor(){super();}
des() {
document.write("Pencil");
}
}
//composite
class PencilBox extends Item{
constructor(){
super();
this.a=[];
}
add(s){
this.a.push(s);
}
remove (index){
this.a.splice(index,1);
}
des(){
document.write("Pencil Box:");
for(var k=0;k < this.a.length ; k++)
{
this.a[k].des();
}
}
}
var z=new Pen();
var c=new Pencil();
var b=new PencilBox();
b.add(c);
b.add(z);
b.des();
b.remove(0);
b.des();

চেষ্টা করা যাক:Bookshelf নামে একটি program লিখি। আগের মতই Item হচ্ছে আমাদের Component আর এবার leaf হচ্ছে Book, Exercisebook ও Notebook। Composite হচ্ছে Bookshelf। আগের মতই সবার des() method থাকবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Sunday, March 17, 2024

অবজার্ভার

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Observer:যখন দেখা যায় Objectsদের মধ্যে একটির উপর বাকিরা নির্ভর করে এবং একটির অবস্থার পরিবর্তনের জন্য বাকিদের অবস্থার পরিবর্তনের দরকার পড়ে তখন Observer Design Pattern এর প্রয়োজন পড়ে। এটি Behavioral Design Pattern দলের। প্রধান Components হচ্ছে: Subject এবং Observer। Subject object তার মাঝে এক ঝাক Observer object কে ধারণ করে। Subject object এর যেকোন পরিবর্তন ঘটলে তা Observer object এর method(এখানে update()) এর মাধ্যমে সবাইকে জানিয়ে দেয়া হয়। এটি Publisher-Subscriber নামেও পরিচিত। উদাহরণে class Notifier হচ্ছে আমাদের subject আর MemIntface হচ্ছে Observer Interface আর Member হচ্ছে এর implementation। Notifier এর constructorএ array এর সাহায্যে একগুচ্ছ Observer object সংরক্ষণ করা হচ্ছে। add() আর unsubscribe() হচ্ছে arrayতে item যোগ এবং বাদ দিতে যথাক্রমে push() ও splice() এর মত array methods প্রয়োগ করছে। notifyall() এর মাধ্যমে সকল Observer objectএর update() এর মাধ্যমে পরিবর্তন সম্পর্কে জানানো হচ্ছে। newChange() এ parameter হিসেবে পরিবর্তন টি কি সেটি pass/দেয়া হচ্ছে,তারপর নতুন পরিবর্তনটি কি সেটি constructor এ ঠিক করে সবাইকে notify করা হচ্ছে notifyall() এর মাধ্যমে।

উদাহরণ:
//Observer
class MemIntface{
constructor(){}
update(b){}
}
class Member extends MemIntface{
constructor(c){
super();
this.c=c;
}
getS(){return this.c;}
update(b){
document.write("Dear Mr. "+this.getS()+" a change called '"+b+"' has taken place in our organization.
");
}
}
//Subcject
class Notifier{
constructor(z){
this.z=z;
this.a=[];
this.l=" ";
}
add(m){ this.a.push(m);
}
unsubscribe(integ)
{
this.a.splice(integ,1);
}
notifyall(){
for(var j=0;j < this.a.length ; j++){
this.a[j].update(this.l);
}
}
newChange(b){
this.l=b;
this.notifyall();
}
}
var m=new Member("A");
var z=new Member("B");
var t=new Member("C");
var k=new Notifier("h");
k.add(m);
k.add(z);
k.add (t);
k.unsubscribe(1);
k.newChange("PQR");

চেষ্টা করা যাক:একটি Club তার member দের তার নতুন ফোন নাম্বার পরিবর্তন সম্পর্কে জানাবে। এখানে Subject হচ্ছে Club আর Member আগের মতই Observer। newChange() এর বদলে newPhone() নামের method থাকবে। বাকি সব আগের মতই থাকবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Friday, March 15, 2024

আইটেরেটর

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Iterator: এটি Behavioral Design Pattern দলের। Aggregate object যেমন List এর ভেতরকার জিনিস প্রকাশ না করে ক্রম অনুযায়ী item গুলো একে একে প্রবেশের উপায় বের করে এই pattern। List এবং ক্রম অনুযায়ী item গুলো একে একে প্রবেশ করার (traversal) কাজ দুটিকে আলাদা দু'টি interface এ ফেলা হয়। এদের একটি List interface এবং অপরটি হলো Iterator interface। Aggregate object এর নানাবিধ traversal পেতে এই pattern ব্যবহার করা যায় (যেমন সবশেষ item থেকে প্রথম item এ যাওয়া)। এছাড়া একই Iterator interface কে ভিন্ন Aggregate object এর traversal এর কাজেও এই pattern ব্যবহার করা যায়। এখানে কোন Abstract class ব্যবহার করা হয়নি। আমরা চাইলে List ও Iterator এর জন্য দু'টি abstract class নিয়ে দরকারি method ভেতরে জুড়ে দিয়ে তারপর subclassing এর মাধ্যমে interface দু'টির বিকাশ ঘটাতে পারি। যেমন List interface এর Product এবং Beverage নামের দু'টি subclass থাকতে পারে। উদাহরণে ProductList classটির constructor একটি list কে initialize করছে তারপর add() এর সাহায্যে user থেকে item নিয়ে list এর push() কে call করছে । getIterator() নামক factory method এর সাহায্যে ListIterator object তৈরি করছে। ListIterator এর constructorএ list object কে parameter হিসেবে নিচ্ছে আর indexকে initialize করছে। hasNext() দেখছে index কি list এর length এর চেয়ে ছোট কি না; ছোট হলে traversal এর কাজটা চলতে থাকবে। first() প্রথম এবং last() শেষ item কে return করছে। next() একটি থেকে আরেকটি itemএ নিয়ে যাচ্ছে index increment এর সাহায্যে।

উদাহরণ:
class ProductList {
constructor() {
this.list = [];
}
add(item) {
this.list.push(item);
}
getIterator() {
return new ListIterator(this);
}
}
class ListIterator {
constructor(list) {
this.list = list.list;
this.index = 0;
}
hasNext() {
return this.index < this.list.length;
}
first(){return this.list[0];}
last(){return this.list[this.list.length-1];}
next() {
return this.list[this.index++];
}
}
const Product = new ProductList();
Product.add("Milk");
Product.add("Pudding");
Product.add("Butter");
const iterator = Product.getIterator();
while (iterator.hasNext()) {
document. write(iterator.next());
}
document. write(Product.getIterator().first());
document. write(Product.getIterator().last());

চেষ্টা করা যাক: ProducList এর মত BeverageList নিয়ে program টি লিখি। ListIterator এ কেবল জোড় index এর item দেখানোর জন্য একটি method() জুড়ে দিয়ে program টি আবার লিখি।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia,www.geeksforgeeks.org,আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও https://www.geeksforgeeks.org/iterator-method-javascript-design-pattern/ এ ব্যবহৃত program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Wednesday, March 13, 2024

সিঙ্গলটন

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Singleton:এটি Creational Design Pattern দলের। এক্ষেত্রে একটি ক্লাসের কেবল একটি instance তৈরি করা হয়। উদাহরণে Person এর constructor এ শর্ত জুড়ে দেয়া আছে যে একের বেশি instance তৈরি করলে বার্তা দেখাবে যে এই class এর কেবল একটি instance সম্ভব। তারপরও কেউ যদি instance/object তৈরি করতে চায় তবে comment out(/*…*/ উঠিয়ে দেই) করে এবং throw কে comment এর মধ্যে ফেলে অগ্রসর হতে পারে। তবে সেক্ষেেত্রেও নতুন instance একই object কে নির্দেশ করবে। উদাহরণে p ও q একই object কে বোঝাচ্ছে।Strict equality operator(===) এক্ষেত্রে true নির্দেশ করছে যা বলছে দু'জনে একই objectকে refer করছে।আর যদি আমরা comment out না করে current set up থাকি তবে দ্বিতীয় instance (q) তৈরির সময় আমাদেরকে অপারগতার বার্তা দেখাবে। এখানে দু'টি private field রয়েছে(s ও obj) , এর মাঝে obj আবার static যাকে Class Person এর মাধ্যমে access করতে হবে।

উদাহরণ:
class Person{
#s="Hi
";
static #obj=null;
constructor(){
if (Person.#obj){
throw document.write("Only one instance can be created!
");
/*
return Person.#obj;
*/
}
Person.#obj=this;
}
getS(){ return this.#s;}
show (){
document.write(this.getS());
}
}
var p=new Person();
p.show();
var q=new Person();
q.show();
/*
document. write(p===q);
if(p===q){
document. write("
Since p and q have pointed to the same object,singleton class Person works!");
}
else{
document. write("
p and q are not same as they pointed to different objects!");
}
*/

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia,www.stackoverflow.com,আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও https://stackoverflow.com/questions/1479319/simplest-cleanest-way-to-implement-a-singleton-in-javascriptএ ব্যবহৃত program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Monday, March 11, 2024

মেডিয়েটর

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Mediator: এটি Behavioral Design Pattern দলের।এখানে objects নিজেদের মধ্যে communicate না করে mediator এর মাধ্যমে communicate করে।এখানে objects দের মধ্যে সরাসরি নির্ভরশীলতা কমিয়ে loose coupling কে উৎসাহিত করা হয়েছে আর objectsদের মধ্যে Communication এর ভার দেয়া হয়েছে Mediator class কে। প্রধান তিনটি components হচ্ছেঃ Mediator,Concrete Mediator( Mediator এর implementation) এবং Colleague (যার objects এর মধ্যে সরাসরি যোগাযোগ হবে না)। উদাহরণে Colleague class O এর methods হচ্ছে message() ও received ()।একই নামে Mediatorএও দু'টি method আছে তবে তারা parameter হিসেবে O এর object নেয়। A এর object তৈরি করে যখন message () কে ডাকা হয়েছে তখন প্রথমে Mediator এর message () কে ডাকা হয়েছে তারপর ভেতরের বার্তা দেখানো হচ্ছে। C এর object যখন received() কে call করছে তখন একই রকম ব্যাপার ঘটছে।

উদাহরণ:
class O{
constructor(m){this.m=m;}
id(){}
message(){}
received (){}
}
class A extends O{
constructor(s,m){super(m);
this.s=s;}
id(){return this.s;}
message(){
this.m.message(this);
document.write(this.id()+": Hello there! How are you?");
}
received(){
this.m.received(this);
document.write(this.id()+": Fine! Thank you!");
}
}
class C extends O{ constructor(s,m){super(m); this.s=s;}
id(){return this.s;}
message(){
this.m.message(this);
document.write(this.id()+": Hello there! How are you?");
}
received(){
this.m.received(this);
document.write(this.id()+": Fine! Thank you!");
}
}
class M{
constructor (){}
message(O){}
received(O){}
}
class ConcreteM extends M{
constructor(){super ();}
message(O){
document.write(" Mediator forwards a message from "+O.id()+" to others."); }
received(O){
document.write(" Mediator receives a message sent by "+O.id()+" for others.");
}
}
var m=new ConcreteM();
var a=new A("obj1",m);
var s=new A("obj2",m);
a.message();
s.received();

চেষ্টা করা যাক: একটি অফিসের বিভিন্ন বিভাগের মধ্যে বার্তা আদান-প্রদান হচ্ছে । PABX হচ্ছে এখানে Mediator আর Department হচ্ছে Colleague interfaceআর A ও C হচ্ছে তার implementation। সবার sent() ও received () নামের method থাকবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia,www.geeksforgeeks.org,আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Saturday, March 9, 2024

ইন্টারপ্রেটার

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Interpreter:অক্ষর আর ধ্বনি নিয়ে হয় শব্দ আর অনেক শব্দ নিয়ে হয় বাক্য। আবার বাক্যে শব্দের ব্যবহার ,বাক্য গঠন , সময়/কাল অনুযায়ী বাক্যের ধরণ এসব বিষয় ঠিক করতে তৈরি করা হয়েছে ব্যাকরণ। কাজেই ভাষার ব্যাকরণটি বুঝতে পারলে আমরা বাক্যের অর্থ আর কোন কাল/সময়কে নির্দেশ করছে সেটি বুঝতে পারি। ঠিক তেমনিভাবে program লিখতে গিয়ে আমরা যদি তার ভেতরের ব্যাকরণগুলিকে সুনির্দিষ্ট করতে পারি এবং তা ব্যাখ্যা করবার জন্য কোন interpreter এর সাহায্য নেই তবে সেটি হয়ে দাঁড়ায় আমাদের Interpreter Design Pattern। উদাহরণে চিহ্ন দিয়ে ডানে/বামে যাবার দিক নির্দেশনা দেয়া হচ্ছে। যে চিহ্ন ব্যবহার করা হচ্ছে তার প্রত্যেকটিকে এক একটি নিয়ম/ব্যাকরণ হিসেবে ধরা যায়। এজন্য “->” এই নিয়মটি/ব্যাকরণকে ব্যাখ্যা করা হচ্ছে “ Go right” এবং “<-” এটিকে ব্যাখ্যা/interpret করা হচ্ছে “ Go left” হিসেবে। ABS class এই নিয়মগুলির একটি abstract class যার method হচ্ছে interpret() আর Right ও Left হচ্ছে তার implementation। Context class টিতে interpret() এ কোন ব্যাখ্যা বা interpretation যাবে তা দেয়া আছে যথাক্রমে right() ও left() নামক method দু'টিতে। Context class এর object এ একটি string variable দেয়া আছে যাকে বলা হবে ডান/বামে যাবার কথা। Client class এর object এ Context এর object আর string variable pass করা হচ্ছে ডান/বামের চিহ্ন বোঝানোর জন্য।ABS class টিতেও Context এর object pass করা হয়েছে। Client এ প্রথমে ABS class এর object গঠন করা হয়েছে ,পরে চিহ্ন/string variable অনুযায়ী প্রযোজ্য subclass এর object assign করা হয়েছে এবং তার interpret () কে invoke করা হয়েছে। এখানে Open-Closed Principle এর প্রয়োগ হচ্ছে। আমরা চাইলে "U" নামে (যার interpretation হচ্ছে "Make a U-turn") subclass যোগ করে ABS interface এর বিকাশ ঘটাতে পারি। Interpreter Design Pattern কে Behavioral Design Pattern এর দলে ফেলা হয়।

উদাহরণ:
class Context{
constructor(c){this.c=c;}
plain(c){return new Context(" ");}
special (c){return new Context(c);}
right(){
return this.c+" Go right";
}
left(){
return this.c+" Go left";
}
}
class ABS{
constructor(t){this.t=t;}
interpret(){
}
}
class Right extends ABS{
constructor(t){super(t);}
interpret(){
return this.t.right();
}
}
class Left extends ABS{
constructor(t){super(t);}
interpret(){
return this.t.left();
}
}
class Client{
constructor (c){
this.c=c;}
transInter(s){
var a=new ABS(this.c);
if(s=="->")
{
a=new Right(this.c);
return a.interpret ();
}
else if(s=="<-")
{
a=new Left(this.c);
return a.interpret ();
}
else{
return "Sorry, not defined.\n";
}
}
}
var c=new Context("w");
var a=new Client(c);
document.write(a.transInter("->"));

চেষ্টা করা যাক: একটি program লিখি যা একটি সংখ্যাকে decimal ও percentage এ প্রকাশ করবে। Context class এবার argument হিসেবে নিবে একটি integer আর method হিসেবে থাকবে decimal() আর percent() যেখানে decimal আর percent বের করবার নিয়ম দেয়া আছে । আর ABS class এর implementation হিসেবে Decimal ও Percentage নামের দুটি subclass থাকবে। যাদের interpret() মেথড থাকবে যেখান থেকে Context এর object এর মাধ্যমে প্রযোজ্য ব্যখ্যা কে call করা হবে। ABS class এ কিন্তু Context এর object দেয়া আছে। Client class ও Context এর object নিচ্ছে আর তার interpret() method একটি string variable নিচ্ছে argument হিসেবে যেটি “dec” বা “percent” নামক string এর সাথে মিলে গেলে প্রযোজ্য object গঠন করে interpret() method invoke করবে। নচেৎ “Sorry,not defined!” বার্তা দেখাবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Monday, March 4, 2024

আ্যব্সট্রাক্ট ফ্যাক্টরি

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Abstract Factory: এটি তৈরি করে এমন এক interface যা একই ধরণের object গঠন করতে সাহায্য করে। এটি ব্যবহার করতে হয় যখন একটি system আলাদা থাকবে object গঠন ও প্রতিনিধিত্ব থেকে। একই ধরণের product এর objects কে একসাথে ব্যবহারের জন্য design করতে হলেও এর ব্যবহার করতে হয়।এটি client/user কে আলাদা করে class implementation থেকে। client /user কেবল abstract interface এর মাধ্যমে object কে manipulate করতে পারে। উদাহরণে Product এবং Shop interface দু'টির implementation হচ্ছে যথাক্রমে Pastry ও Flour এবং PastryShop ও Grocery। PastryShop এর des() মেথডে Pastry এর object গঠন করে তার des() methodকে ডাকা হচ্ছে। একই ঘটনা ঘটছে Grocery তে Flour objectকে ঘিরে। Shopmaker class এর সাহায্যে client কেবল shop() মেথডের মাধ্যমে যে ধরণের shop চায় তা string argument এর মাধ্যমে জানিয়ে দিবে। এখানে আগে থেকে shop abstract class এর object তৈরি করা আছে। string argument অনুযায়ী সংশ্লিষ্ট class object তৈরি করে তা assign করা হবে abstract object কে। Default হিসেবে PastryShop এর object গঠন করা হয়েছে। কাজেই এখানে client/user কে Product ও Shop এর Implementations থেকে আলাদা করা হয়েছে।এটি Creational Design Pattern দলের।

উদাহরণ:
class Product{
constructor (){}
des(){}
}
class Pastry extends Product{
constructor(){super();}
des(){
return " Pastry and cakes.";
}
}
class Flour extends Product{
constructor (){super();}
des(){
return " Flour";
}
}
class Shop{
constructor(){}
des(){}
}
class PastryShop extends Shop {
constructor(){super();}
des(){
var p=new Pastry();
document.write("Pastry shop sells "+p.des()+"
"); }
}
class Grocery extends Shop {
constructor(){super();}
des(){
var f=new Flour();
document.writeln("Grocery sells "+f.des()+"
");
}
}
class ShopMaker{
constructor (){}
shop(s){
var a=new Shop();
if( s=="pastry") {
a=new PastryShop();
return a;
}
else if(s=="grocery"){
a=new Grocery();
return a;
}
else{
a=new Pastry ();
return a;
}
}
}
var s=new ShopMaker();
var k=s.shop("grocery");
k.des();

চেষ্টা করা যাকঃ Rack ও Item নামের দু'টি interface বানাই যাদের যথাক্রমে BookShelf ও ShoeRack এবং Book ও Shoe নামের subclass থাকবে। এদের des() মেথড থাকবে। BookShelf এর des() দেখাবে "On bookshelf, we keep books." বার্তা আর ShoeRack এর des() দেখাবে "On shoerack, we keep shoes." বার্তা। RackMaker নামে আরেকটি class থাকবে যেটির rack() মেথড client/user এর পছন্দ অনুযায়ী Rack object তৈরি করবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Sunday, March 3, 2024

ডেকোরেটর

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Decorator: এটি object এ বাড়তি বৈশিষ্ট্য/দায়িত্ব যোগ করে থাকে।নাম শুনেই বোঝা যায় এটি objectকে decorate করছে।program এ বৈশিষ্ট্য বাড়াতে এটি subclassing এর বিকল্প হিসেবে কাজ করে।এই বৈশিষ্ট্য/দায়িত্ব যোগ করবার ঘটনাটি ঘটে মূলতঃ runtime এ । Decorator class টি মূল class/Component class টিকে মুড়ে ফেলে বলে একে wrapper ও বলা হয়।
উদাহরণে Greet এর subclass হল CoGreet,Decorator ও AddDecorator। Decorator ও AddDecorator subclass এর constructor এ CoGreet কে reference হিসেবে নেয়া হয়েছে। Decorator এর des() method এ Cogreet এর des() method এর সাথে বাড়তি বৈশিষ্ট্য(যেটি user দিবে) যোগ করা হচ্ছে। AddDecorator এ আবার বৈশিষ্ট্য যোগ হচ্ছে এর উপর।কাজেই এখানে CoGreet এর des() method কে Decorator ও AddDecorator এর বাড়তি বৈশিষ্ট্য দিয়ে মুড়ে দেয়া হচ্ছে।runtime এ Decorator object এ ‘~~~’ এবং AddDecorator object এ ‘####’ দু'টি নকশা CoGreet object এ যোগ করা হয়েছে। User এর খুশিমত নকশা এখানে runtime এ যোগ করা যাচ্ছে ,আলাদা করে subclass করতে হচ্ছে না।Structural Design Pattern এর দলে Decorator পরে।

উদাহরণ:
class Greet{
constructor(){}
des(){}
}
class CoGreet extends Greet{
s="Hello! Decorator example!";
d=03;
m=03;
y=2024;
constructor(){
super();
}
des(){
document.write(this.s+this.d+"/"+this.m+"/"+this.y);
}
}
class Decorator extends Greet{
constructor(a,r){
super();
this.a=a;
this.r=r;
}
des() {
return this.r.des()+this.a;
}
}
class AddDecorator extends Greet{
constructor(a,r){
super();
this.a=a;
this.r=r;
}
des() {
return this.r.des()+this.a;
}
}
var g= new CoGreet();
var s=new Decorator("~~~~~~~~~~~~~~~~~",g);
var w=new AddDecorator("####################", s);
document.write(w.des());

চেষ্টা করা যাক: একটি program লিখি যেখানে নাম ও নামের নিচে ‘πππππ’ নকশা দেখা যাবে। Name নামের interface থাকবে যার subclass হিসেবে থাকবে FullName ও Decorator। এদের des() নামের method থাকবে। দ্বিতীয়বার program run করবার সময় 'πππππ'বাদ দিয়ে পছন্দমত নকশা যোগ করি।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Saturday, March 2, 2024

কমান্ড

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Command: এই pattern এ কোন class কোন কাজ সরাসরি নিজে না করে কোন command object এর মাধ্যমে করে এবং এটি কাজটি করতে পারে এমন objectকে আলাদা করে(decouple) কাজটি করবার জন্য বলছে এমন object থেকে ।আর class এর method গুলো আলাদা Command object এর মাধ্যমে সম্পন্ন করা হয়। চারটি অংশ রয়েছে এই pattern এ:

  • Command: যেটি Receiver object এর method কে call করছে।Command subclass এ Receiver object জমা থাকে। Receiver object আর কাজটির মধ্যে binding তৈরি করে দেয়।
  • Receiver: যার method command object করে দিচ্ছে।
  • Invoker:এটি জানে কিভাবে request করতে হয় command execute করবার জন্য। Command interface সম্পর্কে জানে তবে subclass/concrete Command সম্পর্কে জানে না।
  • Client: যে Receiver,Command এবং Invoker class সম্পর্কে জানে এবং ঠিক করে দেয় কোন Receiver object কে কোন Command object এ দিতে হবে আর কোন Commandটি Invoker দিয়ে করাতে হবে।

উদাহরণে TV Receiver class এর On() আর Off() নামের method দুটি TVOn আর TVOff নামের দুটি Command subclass এর perform () method এর মাধ্যমে সম্পন্ন করা হচ্ছে। Command subclass দু'টিতে Receiver class TV object আছে।TVOn subclassএ TV object আর On() method এর মধ্যে একটি binding তৈরি হয়েছে যা perform() এর মাধ্যমে বোঝা যাচ্ছে। আবার TVOff subclassএ একই ঘটনা ঘটছে Off() method কে ঘিরে। Invoker এর set() methodএ Command interface কে argument হিসেবে pass করা হয়েছে । আর action() method প্রযোজ্য Command object এর perform () method কে সংশ্লিষ্ট কাজ করার অনুরোধ করছে।

উদাহরণ:
class Command{
constructor(){}
perform(){}
}
//Receiver
class TV{
constructor(){}
on(){
document. write("Tv is on.
");
}
off(){
document. write("Tv is off.
");
}
}
class TVOn extends Command{
constructor( a){super();
this.a=a;}
perform(){
this.a.on();
}
}
class TVOff extends Command{
constructor(a){super();
this.a=a;}
perform(){
this.a.off();
}
}
class Invoker{
constructor(){}
set(a){this.a=a;}
action(){
this.a.perform();
}
}
//Client/User decides here
var k=new Invoker();
var t=new TV();
var s=new TVOn(t);
k.set(s);
k.action();

চেষ্টা করা যাক: BedSwitch নামে একটি program লিখতে হবে। BedSwitch নামের Receiver এ on() এবং off() নামে দু'টি method থাকবে। Command নামের abstract class এর SwtichOn এবং SwitchOff নামের subclass থাকবে।এদের সবার perform() নামক method থাকবে। আগের মতই Invoker থাকবে যার set() ও action() নামের method থাকবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Wednesday, February 28, 2024

প্রক্সি

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃ class,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Proxy: Proxy pattern এ সাধারণত একটি proxy object প্রতিস্থাপন করে আসল object কে। আসল object এ প্রবেশাধিকার নিয়ন্ত্রণের জন্য এমনটি করা হয়। এছাড়া কিছু বাড়তি functionality ও এটি যোগ করে আসল object টিতে। Client/User এই proxy object এর মাধ্যমে real object এর সাথে যোগাযোগ করে।

  • Remote proxy(আসল object যেটি অন্য এক address এ আছে তার local copy তৈরি করা)
  • Virtual proxy( object আকারে বড় হলে load করতে সমস্যা হতে পারে এজন্য তার minimum কিছু feature নিয়ে proxy object নিয়ন্ত্রণ করা)
  • Protection proxy( অন্য object a প্রবেশ নিয়ন্ত্রণ করা)
হচ্ছে Proxy pattern এর নানা ব্যবহার। উদাহরণে Proxy object এর show() method একটি নির্দিষ্ট digit এর উপর ভিত্তি করে Real object এর show() method দেখাচ্ছে নচেৎ একটি নির্দিষ্ট বার্তা দেখাচ্ছে।

উদাহরণঃ(script tags এর মাঝে নিচের কোড বসবে)

class Demo{
show(){}
}
class Real extends Demo{
constructor(a){super(a);}
static plain(a){return new Demo(0);}
static special (a){return new Demo(a);}
show(){
document. write("Demo...");
}
}
class Proxy extends Demo{
constructor(){super();}
static plain(a){return new Demo(0);}
static special (a){return new Demo(a);}
show(a){
if(a==3){
var r=new Real(a);
r.show();
}
else
{
document.write("Sorry!no demo.");
}
}
}
var p=new Proxy();
p.show (1);

চেষ্টা করা যাকঃ Message interface তৈরি করতে হবে যার RealMessage ও Proxy subclass থাকবে। Proxy'র show() method একটি string variable নিবে argument হিসেবে। যদি string variable আগে থেকে নির্দিষ্ট করে রাখা variable এর সাথে মিলে যায় তবে RealMessage এর বার্তা দেখাবে নচেৎ অন্য বার্তা দেখাবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও আমার তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Tuesday, February 27, 2024

স্টেট

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃ class,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

State Pattern:এটি object কে তার অবস্থার পরিবর্তনের সাথে সাথে behavior পরিবর্তন করতে দেয়। যখন behavior অবস্থার(state) উপর নির্ভর করে এবং run-time এ object কে তার behavior পরিবর্তন করতে হয় তখন State pattern ভাল ফল দেয়। আবার কোন program এ যদি অসংখ্য state কে if-else অথবা switch statements দিয়ে একটি class এর ভেতর প্রকাশ করা হয় তবে এটি জটিল হয়ে পড়ে এবং ভবিষ্যতে একে modify করাও কঠিন হয়ে পরে। আলাদা interface তৈরি করে প্রতিটি subclass যদি এক একটি state কে প্রতিনিধিত্ব করে এবং ঐ state এর সাথে জড়িত behavior কি হবে তা ঠিক করে দেয় তবে program কে ভবিষ্যতে আরো বিকাশের সুযোগ তৈরি হয়।এসব ক্ষেত্রেও State pattern বেশ কাজে দেয়।State pattern Behavioral Design Pattern এর দলে পরে।
উদাহরণে Bakery interface তার subclass Regular, Cookies,Muffin,ChocoCake এর মাধ্যমে bakery item এর state গুলো প্রকাশ করছে আর disp() method ঐ state এর behavior সম্পর্কে বলছে। Context নামে একটি class তৈরি করে তার attribute হিসেবে State object ব্যবহার করা হয়েছে। আর run-time এ set() method এর মাধ্যমে internal state পরিবর্তনের সুযোগ রাখা হয়েছে। Client/User এই Context class এর মাধ্যমে State object এর সাথে কাজ করবে। উদাহরণে Context এ current state হিসেবে Bakery তে ঠিক করা হয়েছে Regular state,যেটির behavior হচ্ছে Flat bread বানানো। এরপর run-time এ set() এর সাহায্যে State পরিবর্তন করে ChocoCake ঠিক করা হয়েছে,ফলে behaviorও পরিবর্তিত হয়ে Chocolate cake বানানোতে চলে গেছে।

উদাহরণঃ(script tags এর মাঝে নিচের কোড বসবে)

class Bakery{
constructor(){}
disp(){}
}
class Context{
constructor(a){this.a=a;}
set(c){this.a=c;}
request(){
this.a.disp();
}
}
class Regular extends Bakery{
constructor (){super();}
disp(){
document. write("Flat bread");
}
};
class Cookies extends Bakery{
constructor(){super();}
disp(){
document.write("Cookies");
}
}
class Muffin extends Bakery {
constructor(){super();}
disp(){
document.write("Muffin");
}
}
class ChocoCake extends Bakery{
constructor(){super ();}
disp(){
document.write("Chocolate cake");
}
}
var r =new Regular();
var c=new Context(r);
c.request();
var cc=new ChocoCake();
c.set(cc);
c.request();

চেষ্টা করা যাকঃ একটি program লিখি। CCTV নামে একটি interface যার Right,Left,Straight আর Rotate নামে subclass থাকবে আর সবার des() নামের method থাকবে যা behavior নির্দেশ করে। আগের মতই Context নামে class থাকবে। সবার আগে Context ছাড়া শুধু CCTV নামে একটি class এর ভেতর switch statements ব্যবহার করে Right,Left,Straight এই state গুলোকে ব্যবহার করে program টি লিখি। পরে State pattern ব্যবহার করে program টি লিখি।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও লেখকের তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

ব্রিজ

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃclass,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Bridge Pattern: এটি আলাদা করে abstraction কে implementation থেকে। এটি structural design pattern এর দলে পরে। ধরা যাক একটি শার্ট কিনতে হবে। শার্ট কি ধরণের হবে –সাধারণ না প্রিন্টেড এটি বিবেচনার বিষয়। আবার শার্টের আকার ও বিবেচনার বিষয়। এখন Shirt interface কে implement করতে যেয়ে আমাদের inheritance এর উপর নির্ভর করলে PlainMedium,PlainLarge,PrintedMedium এবং PrintedLarge এর মত subclass তৈরি করতে হবে। এখন শার্টের অন্য ধরণ (যেমন: Stripes) যোগ করলেও আমাদের আকারের বিষয়টি মাথায় রেখে StripesMedium ও StripesLarge subclass করতে হবে। এখানে inheritance ধরণ আর আকার এর মাঝে এক binding সম্পর্ক তৈরি করে দিচ্ছে । কাজেই এই জটিলতা এড়াতে এখানে ধরণ ও আকার এর জন্য Shirt ও Size নামে আলাদা দুটি interface তৈরি করতে হবে আর Size object কে Shirt class এ attribute হিসেবে ব্যবহার করতে হবে( Composition এর উদাহরণ)।এখানে Size কাজ করছে bridge এর। এখন run-time এ Shirt object গঠনের সময় যেই Size দরকার তার object দিয়ে দিলেই হবে। দরকার পড়লে Shirt ও Size class দু'টির বিকাশ ঘটানো যায় ( যেমন:Shirt এ Printed ও Size এ Small নামে দু'টি subclass যোগ করা যায়) স্বাধীনভাবে,program এ কোন সমস্যা/ জটিলতা না বাড়িয়ে।

উদাহরণঃ(script tags এর মাঝে নিচের কোড বসবে)

class Size{
constructor(){}
des(){}
}
class Shirt{
constructor(a){ this.a=a;}
des(){}
getA(){ return this.a;}
}
class Plain extends Shirt{
constructor(a){super(a);}
des(){
document. write("Plain Shirt:");
super.getA().des();}
}
class Printed extends Shirt{
constructor(a){super(a);}
des(){
document. write("Printed Shirt:");
super.getA().des();}
}
class Medium extends Size{
constructor(){super();}
des(){
document. write("Medium size is chosen.");
}
}
class Large extends Size{
constructor (){super();}
des(){
document. write("Large size is chosen.");
}
}
var m=new Medium();
var p=new Plain(m);
p.des();
var t=new Printed(m);
t.des();

চেষ্টা করা যাকঃ Online courseএ ভর্তির জন্য Duration কে মাথায় নিয়ে একটি program লিখি। Online এর attribute হচ্ছে Duration class। Individual ও Group নামে Online class এর দু'টি subclass থাকবে ।আর Short ও Long নামে Duration এর দু'টি subclass থাকবে । সবার des() নামক method থাকবে।ঠিকভাবে কাজ করলে এটি নিচের বার্তা দেখাবে:

Individual/Group course:
Long/Short duration is chosen.

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও লেখকের তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com

Sunday, February 25, 2024

স্ট্র্যাটেজি

কাদের জন্যঃ Object-oriented programming language সম্পর্কে ধারণা আছে এমন মানুষ।

যা প্রয়োজনঃ class,inheritance,composition,JavaScript সম্পর্কে পূর্ব ধারণা।

Strategy pattern:এটি একগুচ্ছ algorithms এর মাঝ থেকে program চালানোর সময়(run time) একটিকে নির্বাচনের কাজ করে থাকে। এটি Behavioral pattern এর দলে পড়ে। এখানে Behavior কে Class থেকে আলাদা করা হয়। Strategy pattern এ method কে inherit করা যাবে না। যেমন: Gym এর সদস্যদের বকেয়া চেয়ে message পাঠাতে হবে। এজন্য সাধারণ,বিশেষ ও কিশোর সদস্যদের জন্য দরকার আলাদা আলাদা সম্ভাষণযুক্ত message। একারণে Message নামে আলাদা একটি interface তৈরি করে সদস্যদের ধরণ অনুযায়ী subclass গঠন করা হয়েছে। say() method এর মাধ্যমে Message দেয়া হচ্ছে। বৃদ্ধ (Old) নামে আলাদা class গঠন করে Message class এর বিকাশ ঘটানো যায় তবে এর কাঠামো change করা যাবে না। এটি হলো Open/Closed principle এর উদাহরণ যা আমরা SOLID principle এ জেনেছি।Gym নামে আরেকটি interface গঠন করে তার subclass GymManager এ Message এর attribute ব্যবহার করা হয়েছে,যা composition এর উদাহরণ। remind() method এ ঐ Message subclass এর method call করা হয়েছে। GymManager এর object এ program চালানোর সময় Message এর যেই subclass দরকার তার object গঠন করে দিয়ে দেয়া হয়েছে। তারপর GymManager এর object তার method remind () কে ব্যবহার করেছে। উদাহরণে run time এ Special () এর object তৈরি করে pass করা হয়েছে GymManager এর object এ।

উদাহরণঃ(script tags এর মাঝে নিচের কোড বসবে)
class Message{
constructor (){}
say(){ document. write(" Respective message goes here.");
}
}
class Special extends Message{
constructor(){super ();}
say(){ document.write("Dear Special Member,Greetings from Gym Y. Please clear your dues!");
}
}
class Regular extends Message {
constructor(){super();}
say(){ document.write ("Dear Member,Greetings from Gym Y. Please clear your dues!");
}
}
class Ado extends Message{
constructor(){super ();}
say(){ document. write ("Hello there!Greetings from Gym Y. Please clear your dues!");
}
}
class Gym{
constructor(){}
remind(){}
}
class GymManager extends Gym{
constructor(a){super();
this.a=a;}
static plain(a){ return new Context(" ");}
static messCon(a){return new Context(a);}
remind(){
this.a.say();
}
}
a= new Special();
c=new GymManager(a);
c.remind();

চেষ্টা করা যাকঃ Online Food Manager নতুন,সাধারণ ও বিশেষ সদস্যদের জন্য New Product(৩ টি implementation) সম্পর্কে জানাবে।

কৃতজ্ঞতাঃ এই লেখা তৈরি করতে দরকারি তথ্য নেয়া হয়েছে Wikipedia, আকর বই "'Design Patterns:Elements Of Reusable Object-Oriented Software' by Eric Gamma,Richard Helm,Ralph Johnson and John Vlissides(Addisson-Wesley.1994)" ও লেখকের তৈরি করা নানা program থেকে।
মন্তব্য ও যোগাযোগঃ mrh4478@gmail.com