नमुने: अडॅप्टर, प्रॉक्सी, ब्रिज

"हॅलो, मित्रा!"

"हाय, बिलाबो!"

"आमच्याकडे अजून थोडा वेळ आहे, म्हणून मी तुम्हाला आणखी तीन नमुन्यांबद्दल सांगेन."

"आणखी तीन? एकूण किती आहेत?"

"सध्या डझनभर लोकप्रिय नमुने आहेत, परंतु "यशस्वी उपाय" ची संख्या अमर्यादित आहे."

"मी बघतो. तर मला अनेक डझन नमुने शिकायचे आहेत?"

"जोपर्यंत तुम्हाला प्रोग्रामिंगचा खरा अनुभव येत नाही तोपर्यंत ते तुम्हाला जास्त काही देणार नाहीत."

"तुम्हाला थोडा अधिक अनुभव मिळेल आणि नंतर, एका वर्षात, या विषयाकडे परत या आणि त्यांना अधिक खोलवर समजून घेण्याचा प्रयत्न करा. किमान दोन डझन सर्वात लोकप्रिय डिझाइन नमुने."

"दुसऱ्याच्या अनुभवाचा वापर न करणे आणि त्याऐवजी 110 व्या वेळी काहीतरी शोधणे हे पाप आहे."

"मी सहमत आहे."

"मग सुरुवात करूया."

अडॅप्टर (किंवा रॅपर) नमुना

"कल्पना करा की तुम्ही चीनमध्ये आलात आणि तुम्हाला असे आढळले की इलेक्ट्रिकल आउटलेट वेगळ्या मानकांचे पालन करतात. छिद्र गोल नसून सपाट आहेत. या प्रकरणात, तुम्हाला अॅडॉप्टरची आवश्यकता असेल."

"प्रोग्रामिंगमध्येही असेच काही घडू शकते. क्लासेस सारख्याच पण वेगळ्या इंटरफेसवर चालतात. त्यामुळे आम्हाला त्यांच्यामध्ये अडॅप्टर बनवावे लागेल."

"हे असे दिसते:"

interface Time
{
 int getSeconds();
 int getMinutes();
 int getHours();
}

interface TotalTime
{
 int getTotalSeconds();
}

"समजा आमच्याकडे दोन इंटरफेस आहेत: वेळ  आणि  एकूण वेळ ."

"टाइम इंटरफेस तुम्हाला getSeconds (),  getMinutes () आणि  getHours () पद्धती वापरून वर्तमान वेळ मिळवू देतो ."

" टोटलटाइम इंटरफेस तुम्हाला मध्यरात्रीपासून चालू क्षणापर्यंत गेलेल्या सेकंदांची संख्या मिळवू देतो."

"आपल्याकडे TotalTime ऑब्जेक्ट असल्यास आपण काय करावे , परंतु आपल्याला टाइम ऑब्जेक्टची आवश्यकता आहे किंवा त्याउलट?"

"आम्ही यासाठी अडॅप्टर क्लासेस लिहू शकतो. उदाहरणार्थ:"

class TotalTimeAdapter implements Time
{
 private TotalTime totalTime;
 public TotalTimeAdapter(TotalTime totalTime)
 {
  this.totalTime = totalTime;
 }

 int getSeconds()
 {
  return totalTime.getTotalSeconds() % 60; // seconds
 }

 int getMinutes()
 {
  return totalTime.getTotalSeconds() / 60; // minutes
 }

 int getHours()
 {
  return totalTime.getTotalSeconds() / (60 * 60); // hours
 }
}

TotalTime totalTime = TimeManager.getCurrentTime();
Time time = new TotalTimeAdapter(totalTime);
System.out.println(time.getHours() + " : " + time.getMinutes () + " : " +time.getSeconds());

"आणि दुसऱ्या दिशेने अडॅप्टर:"

class TimeAdapter implements TotalTime
{
 private Time time;
 public TimeAdapter(Time time)
 {
  this.time = time;
 }

 int getTotalSeconds()
 {
  return time.getHours() * 60 * 60 + time.getMinutes() * 60 + time.getSeconds();
 }
}

Time time = new Time();
TotalTime totalTime = new TimeAdapter(time);
System.out.println(time.getTotalSeconds());

"अहो. मला ते आवडते. पण काही उदाहरणे आहेत का?"

"नक्कीच! उदाहरण म्हणून, InputStreamReader हे क्लासिक अडॅप्टर आहे. ते InputStream ला रीडरमध्ये रूपांतरित करते."

"कधीकधी या पॅटर्नला रॅपर देखील म्हणतात, कारण नवीन वर्ग दुसर्या ऑब्जेक्टला 'रॅप' करतो."

"तुम्ही येथे इतर काही मनोरंजक गोष्टी वाचू शकता ."

प्रॉक्सी नमुना

"प्रॉक्सी पॅटर्न हा काहीसा रॅपर पॅटर्नसारखाच आहे. पण त्याचा उद्देश इंटरफेसमध्ये रूपांतरित करणे हा नसून प्रॉक्सी क्लासमध्ये साठवलेल्या मूळ ऑब्जेक्टवर प्रवेश नियंत्रित करणे हा आहे. शिवाय, मूळ क्लास आणि प्रॉक्सी या दोन्हींचा सहसा समान इंटरफेस असतो, जे मूळ वर्गाच्या ऑब्जेक्टला प्रॉक्सी ऑब्जेक्टसह बदलणे सोपे करते."

"उदाहरणार्थ:"

interface Bank
{
 public void setUserMoney(User user, double money);
 public int getUserMoney(User user);
}

class CitiBank implements Bank
{
 public void setUserMoney(User user, double money)
 {
  UserDAO.updateMoney(user, money);
 }

 public int getUserMoney(User user)
 {
  return UserDAO.getMoney(user);
 }
}

class BankSecurityProxy implements Bank
{
 private Bank bank;
 public BankSecurityProxy(Bank bank)
 {
  this.bank = bank;
 }
 public void setUserMoney(User user, double money)
 {
  if (!SecurityManager.authorize(user, BankAccounts.Manager))
  throw new SecurityException("User can’t change money value");

  bank.setUserMoney(user, money);
 }

 public int getUserMoney(User user)
 {
  if (!SecurityManager.authorize(user, BankAccounts.Manager))
  throw new SecurityException("User can’t get money value");

  return bank.getUserMoney(user);
 }
}

"वरील उदाहरणामध्ये, आम्ही बँक इंटरफेस आणि सिटीबँक वर्गाचे वर्णन केले आहे, या इंटरफेसची अंमलबजावणी."

"इंटरफेस तुम्हाला वापरकर्त्याच्या खात्यातील शिल्लक मिळवू किंवा बदलू देतो."

आणि मग आम्ही BankSecurityProxy तयार केले , जे बँक इंटरफेस देखील लागू करते आणि वेगळ्या बँक इंटरफेसचा संदर्भ संग्रहित करते. वापरकर्ता खाते मालक आहे की बँक व्यवस्थापक आहे हे या वर्गाच्या पद्धती तपासतात. तसे नसल्यास, सुरक्षा अपवाद टाकला जातो."

"हे सरावात कसे कार्य करते ते येथे आहे:"

User user = AuthManager.authorize(login, password);
Bank bank = BankFactory.createUserBank(user);
bank.setUserMoney(user, 1000000);

User user = AuthManager.authorize(login, password);
Bank bank = BankFactory.createUserBank(user);
bank = new BankSecurityProxy(bank);
bank.setUserMoney(user, 1000000);

"पहिल्या उदाहरणात, आम्ही बँक ऑब्जेक्ट तयार करतो आणि त्याला सेटयूझरमनी पद्धत म्हणतो.

"दुसऱ्या उदाहरणात, आम्ही मूळ बँक ऑब्जेक्ट एका BankSecurityProxy ऑब्जेक्टमध्ये गुंडाळतो. त्याचा इंटरफेस समान असतो, त्यामुळे त्यानंतरचा कोड जसा होता तसाच काम करत राहतो. पण आता प्रत्येक वेळी पद्धत कॉल केल्यावर सुरक्षा तपासणी केली जाईल."

"छान!"

"हो. तुमच्याकडे अशा अनेक प्रॉक्सी असू शकतात. उदाहरणार्थ, तुम्ही आणखी एक प्रॉक्सी जोडू शकता जी खात्यातील शिल्लक खूप मोठी आहे की नाही हे तपासते. बँक व्यवस्थापक स्वतःच्या खात्यात खूप पैसे ठेवण्याचा निर्णय घेऊ शकतो आणि निधीसह क्युबाला फरार होऊ शकतो. ."

"आणखी काय... ऑब्जेक्ट्सच्या या सर्व साखळींची निर्मिती बँकफॅक्टरी क्लासमध्ये ठेवली जाऊ शकते, जिथे आपण आपल्याला आवश्यक असलेल्या सक्षम/अक्षम करू शकता."

" BufferedReader समान तत्त्व वापरून कार्य करते. ते वाचक आहे , परंतु ते अतिरिक्त कार्य करते."

"हा दृष्टीकोन तुम्हाला विविध «पीस» मधून आवश्यक कार्यक्षमतेसह ऑब्जेक्ट «एकत्रित» करू देतो."

"अरे, मी जवळजवळ विसरलोच आहे. मी तुम्हाला जे दाखवले त्यापेक्षा प्रॉक्सी जास्त प्रमाणात वापरल्या जातात. तुम्ही इतर उपयोगांबद्दल येथे वाचू शकता ."

ब्रिज पॅटर्न

"कधीकधी जेव्हा एखादा प्रोग्राम चालतो तेव्हा एखाद्या वस्तूची कार्यक्षमता लक्षणीयरीत्या बदलणे आवश्यक असते. उदाहरणार्थ, समजा तुमच्याकडे गाढवाच्या पात्रासह एक गेम आहे जो नंतर जादूगाराने ड्रॅगनमध्ये बदलला आहे. ड्रॅगनची वागणूक आणि गुणधर्म पूर्णपणे भिन्न आहेत, परंतु ते आहे. तीच वस्तू!"

"आम्ही एक नवीन वस्तू तयार करू शकत नाही आणि ती पूर्ण करू शकत नाही?"

"नेहमीच नाही. समजा तुमचा गाढव अनेक वर्णांचा मित्र असेल किंवा कदाचित तो अनेक जादूच्या प्रभावाखाली असेल किंवा तो काही विशिष्ट शोधांमध्ये गुंतलेला असेल. दुसऱ्या शब्दांत, ऑब्जेक्ट आधीपासूनच बर्‍याच ठिकाणी वापरात असेल — आणि इतर बर्‍याच वस्तूंशी जोडलेले आहे. त्यामुळे या प्रकरणात, फक्त नवीन ऑब्जेक्ट तयार करणे हा पर्याय नाही."

"बरं, मग काय करता येईल?"

"ब्रिज पॅटर्न हा सर्वात यशस्वी उपायांपैकी एक आहे."

"या पॅटर्नमध्ये ऑब्जेक्टचे दोन ऑब्जेक्ट्समध्ये विभाजन करणे समाविष्ट आहे: एक «इंटरफेस ऑब्जेक्ट» आणि «अंमलबजावणी ऑब्जेक्ट»."

"इंटरफेस आणि त्याची अंमलबजावणी करणारा वर्ग यात काय फरक आहे?"

"इंटरफेस आणि वर्गासह, आपण एका ऑब्जेक्टसह समाप्त होतो. परंतु येथे - आपल्याकडे दोन आहेत. हे उदाहरण पहा:"

class User
{
 private UserImpl realUser;

 public User(UserImpl impl)
 {
  realUser = impl;
 }

 public void run() //Run
 {
  realUser.run();
 }

 public void fly() //Fly
 {
  realUser.fly();
 }
}

class UserImpl
{
 public void run()
 {
 }

 public void fly()
 {
 }
}

"आणि नंतर तुम्ही UserImpl चे अनेक उपवर्ग घोषित करू शकता, उदाहरणार्थ UserDonkey (गाढव) आणि UserDragon (ड्रॅगन)."

"सर्व समान, हे कसे कार्य करेल हे मला खरोखर समजत नाही."

"बरं, असं काहीतरी:"

class User
{
 private UserImpl realUser;

 public User(UserImpl impl)
 {
  realUser = impl;
 }

 public void transformToDonkey()
 {
  realUser = new UserDonkeyImpl();
 }

 public void transformToDragon()
 {
  realUser = new UserDragonImpl();
 }
}

User user = new User(new UserDonkey()); // Internally, we're a donkey
user.transformToDragon(); // Now we're a dragon internally

"तर हे प्रॉक्सीसारखे काहीतरी आहे."

"हो, पण प्रॉक्सीमध्ये मुख्य ऑब्जेक्ट कुठेतरी स्वतंत्रपणे संग्रहित केला जाऊ शकतो, आणि कोड त्याऐवजी प्रॉक्सीसह कार्य करतो. येथे आम्ही म्हणत आहोत की प्रत्येकजण मुख्य ऑब्जेक्टसह कार्य करतो, परंतु त्याचे भाग अंतर्गत बदलतात."

"आह. धन्यवाद. याबद्दल अधिक वाचण्यासाठी तुम्ही मला लिंक द्याल का?"

"अर्थात, अमिगो, माझा मित्र. हा घ्या: ब्रिज पॅटर्न ."