इस तरह की एक बड़ी वस्तु को तोड़ने शुरू करने का एक तरीका है कि पहले एक दूसरे से संबंधित बड़ी वस्तु द्वारा प्रबंधित फ़ील्ड या गुणों का एक अच्छा सबसेट ढूंढें और जो ऑब्जेक्ट के अन्य फ़ील्ड या गुणों से बातचीत नहीं करते हैं । फिर, केवल उन फ़ील्ड का उपयोग करके एक नई, छोटी वस्तु बनाएं। यही है, सभी बड़ी कक्षा से नई छोटी कक्षा में तर्क को स्थानांतरित करें। मूल बड़ी कक्षा में, एक प्रतिनिधिमंडल विधि बनाएं जो अनुरोध के साथ बस पास हो। यह एक अच्छा पहला कदम है जिसमें केवल बड़ी वस्तु को बदलना शामिल है। यह विधियों की संख्या को कम नहीं करता है, लेकिन यह बड़ी कक्षा में आवश्यक तर्क की मात्रा को बहुत कम कर सकता है।
ऐसा करने के कुछ दौर के बाद, आप नए, छोटी वस्तुओं पर सीधे अन्य वस्तुओं की ओर इशारा करते, बल्कि पहले से बड़ा उद्देश्य यह है कि सब कुछ के बीच में था से गुज़रते हुए प्रतिनिधिमंडल के कुछ दूर करने के लिए शुरू कर सकते हैं।
उदाहरण के लिए Wikipedia's Delegation pattern चर्चा देखें।
एक साधारण उदाहरण के रूप में, यदि आपके पास किसी कंपनी में कर्मचारियों का प्रतिनिधित्व करने के लिए एक कर्मचारी वस्तु है, तो आप पेरोल से संबंधित मूल्यों का ट्रैक रखने के लिए पेरोल ऑब्जेक्ट बना सकते हैं, एक रेटिंग ऑब्जेक्ट को कर्मचारी रेटिंग का ट्रैक रखने के लिए, एक पुरस्कार ऑब्जेक्ट जीतने वाले पुरस्कारों का ट्रैक रखने के लिए ऑब्जेक्ट करें, और इसी तरह।
बुद्धि के लिए
, यदि आप एक बड़े वर्ग के लिए निम्न विधियों, प्रत्येक युक्त व्यापार तर्क, कई अन्य तरीकों के बीच युक्त साथ बाहर शुरू कर दिया:
...
public boolean isManagement() { ... }
public boolean isExecutive() { ... }
public int getYearsOfService() { ... }
public Date getHireDate() { ... }
public int getDepartment() { ... }
public BigDecimal getBasePay() { ... }
public BigDecimal getStockShares() { ... }
public boolean hasStockSharePlan() { ... }
...
तो इस बड़े वस्तु सकता है, इसके निर्माता में, एक नए बनाने
// Newly added variables, initialized in the constructor (or as appropriate)
private final StaffType staffType;
private final PayInformation payInformation;
private final PayInformation payInformation;
...
public boolean isManagement() { return staffType.isManagement(); }
public boolean isExecutive() { return staffType.isExecutive(); }
public int getYearsOfService() { return staffInformation.getYearsOfService(); }
public Date getHireDate() { return staffInformation.getHireDate(); }
public int getDepartment() { return staffInformation.getDepartment(); }
public BigDecimal getBasePay() { return payInformation.getBasePay(); }
public BigDecimal getStockShares() { return payInformation.getStockShares(); }
public boolean hasStockSharePlan() { return payInformation.hasStockSharePlan(); }
...
जहां पूर्ण: निर्मित ऑब्जेक्ट StaffType
और एक नव निर्मित वस्तु PayInformation
और एक नव निर्मित वस्तु StaffInformation
, और शुरू में बड़ा वस्तु में इन विधियों की तरह लग रहे हैं तर्क जो कि बड़ी वस्तु में होता था, इन तीन नई छोटी वस्तुओं में स्थानांतरित हो गया है। इस परिवर्तन के साथ, आप बड़े ऑब्जेक्ट का उपयोग करने वाले किसी भी चीज़ को छूए बिना छोटे ऑब्जेक्ट को छोटे हिस्सों में तोड़ सकते हैं। हालांकि, जैसा कि आप समय के साथ ऐसा करते हैं, आप पाएंगे कि बड़ी वस्तु के कुछ ग्राहकों को केवल विभाजित घटकों में से किसी एक तक पहुंच की आवश्यकता हो सकती है। इन ग्राहकों के लिए, बड़ी वस्तु का उपयोग करके और विशिष्ट वस्तु को प्रतिनिधि देने के बजाय, वे छोटी वस्तु का प्रत्यक्ष उपयोग कर सकते हैं। लेकिन अगर यह रिफैक्टरिंग कभी नहीं होती है, तो आपने अलग-अलग वर्गों में असंबद्ध वस्तुओं के व्यावसायिक तर्क को अलग करके चीजों में सुधार किया है।
"मूल बड़ी कक्षा में, एक प्रतिनिधिमंडल विधि बनाएं जो" <- एक विधि "या प्रत्येक के लिए विधियों को आसानी से पास करे भगवान ऑब्जेक्ट के विघटित कार्यों का? – grigoryvp
@ नरक का ईई: मैंने आपके प्रश्न का उत्तर देने के लिए अपना उत्तर बढ़ाया। – Eddie
स्टाफ टाइप के अंदर कोड बहुत मुश्किल समय होगा भगवान ऑब्जेक्ट के तरीकों तक पहुंचना। आपको निर्भरता की आवश्यकता होगी कि भगवान ऑब्जेक्ट के संदर्भ को स्टाफ टाइप पर वापस डालें। जावा में ऐसी चीजों को करने का यह अनुशंसित तरीका है? – grigoryvp