जावा कमांड पैटर्न उदाहरण रननेबल क्लास के साथ: क्या रिसीवर गुम है?

Question

Examples of GoF Design Patterns in Java's core libraries सवाल से, यह लिखा गया कि

java.lang.Runnable के सभी कार्यान्वयन कमान पैटर्न के उदाहरण हैं।

कमान पैटर्न की मेरी समझ के अनुसार,

ग्राहक कॉल Invoker =>InvokerConcreteCommand =>ConcreteCommand कॉल रिसीवर विधि है, जो लागू करता है सार कॉल कमांड विधि।

के रूप में नीचे दिखाया गया है this article से काम कर example

कमान पैटर्न यूएमएल आरेख पर एक नज़र डालें।

public class ThreadCommand{ 
    public static void main(String args[]){ 
     Thread t = new Thread(new MyRunnable()); 
     t.start(); 
    } 
} 
class MyRunnable implements Runnable{ 
    public void run(){ 
     System.out.println("Running:"+Thread.currentThread().getName()); 
    } 
} 

1. ThreadCommandग्राहक
2. Runnable इंटरफेस है कमान
है:



इस कोड पर एक नज़र डालें

3. MyRunnableConcreteCommmand
4. थ्रेडstart() विधि बुला ConcreteCommand implementaiton (जो कहता है run() विधि)

रिसीवर यहाँ याद आ रही है साथ Invoker है? या क्या MyRunnable ConcreteCommand और रिसीवर की संयुक्त भूमिका निभाता है?

Answer 1

रिसीवर C/C++, जिसमें विधि लागू किया जा करने के लिए इस पर लागू करने की वस्तु से अलग किया जाता का एक अवशेष है। आप प्रतिबिंब का उपयोग कर एक विधि पारित करके जावा में उस व्यवहार को लागू कर सकते हैं; लेकिन जैसा कि आपने अनुमान लगाया है, अधिक idiomatic जावा दृष्टिकोण कंक्रीट कमांड और रिसीवर को एक ऑब्जेक्ट के रूप में इलाज करना है।

Answer 2

रिसीवर नहीं चाहेंगे ... रन विधि में

System.out.println("Running:"+Thread.currentThread().getName()); 

कॉल। क्योंकि जब रननेबल चलता है तो वह करने के लिए कार्रवाई प्राप्त होती है।

Answer 3

एक उत्तर यहां पोस्ट किया गया है और इसे तुरंत लेखक द्वारा हटा दिया गया था। उत्तर पढ़ने के दौरान, मुझे समाधान मिला है।

मैं बस एक छोटे से परिवर्तन के साथ कमांड पैटर्न यूएमएल आरेख में उदाहरण को ऊपर परिवर्तित कर सकता हूं।

मैं MyRunnable (ConcreteCommand) को रिसीवर वस्तु पारित कर सकते हैं।

अब मैंने अपना कोड नीचे दिया है।

public class ThreadCommand{ 
    public static void main(String args[]){ 
     Receiver r = new AC(); 
     Thread t = new Thread(new MyRunnable(r)); 
     t.start(); 
    } 
} 
class MyRunnable implements Runnable{ 
    private Receiver receiver; 
    public MyRunnable(Receiver r){ 
     this.receiver = r; 
    } 
    public void run(){ 
     receiver.execute(); 
    } 
} 
interface Receiver{ 
    public void execute(); 
} 
class AC implements Receiver{ 
    public void execute(){ 
     System.out.println("I am AC"); 
    } 
} 
class Fan implements Receiver{ 
    public void execute(){ 
     System.out.println("I am Fan"); 
    } 
} 

आउटपुट:

java ThreadCommand 
I am AC 

Answer 4

मैं अपने दो सेंट दे करना चाहते हैं ...

मूल कमान पैटर्न Receiver वस्तुओं से Command वस्तुओं को अलग करती है क्योंकि दो सेट की जिम्मेदारी अलग हैं।

Receiver के पास व्यवसाय तर्क एप्लिकेशन का मालिक है। इन प्रकारों को पैटर्न के बाहर मौजूद होना चाहिए। एक व्यावहारिक मामले में Receiver एस कमांड से पहले कोड बेस में पहले ही मौजूद थे।

उदाहरण के लिए, एक बैंक आवेदन करने के लिए सोच, एक रिसीवर निम्न प्रकार से किया जा सकता है:

public class Account { 
    private final double balance; 
    // Construct omissis 
    public Account deposit(double amount) { 
     // Deposit code 
    } 
    public Account withdraw(double amount) { 
     // Withdraw code 
    } 
} 

आदेश डिजाइन पैटर्न के उद्देश्य से एक एक एकीकृत देने का है, ऑब्जेक्ट्स (यानी रिसीवर) पर संचालन निष्पादित करने के लिए सजातीय और मानक तरीका। उन्हें परवाह नहीं है कि असली व्यापार तर्क कैसे करें। यह कोड कार्यान्वयन कोड तर्क के पुन: प्रयोज्यता को सीमित करेगा।

इस कारण से, Command के कार्यान्वयन को जानकारी को Receiver पर अग्रेषित करना होगा। यह एक उदाहरण का पालन करता है।

public class DepositCommand implements Command { 
    private final Account account; 
    // An instance of Command should reprenset only a single request 
    private final double amount; 
    public DepositCommand(Account account, double amount) { 
     this.account = account; 
     this.amount = amount; 
    } 

    public void execute() { 
     account.deposit(amount); 
    } 

    // Omissis.. 
} 

निष्कर्ष में, इम्हो, स्वीकृत उत्तर में मौजूद बयान सही नहीं है।

रिसीवर सी/सी ++ का एक अवशेष है जिसमें आमंत्रित करने की विधि वस्तु से अलग करने के लिए इसे अलग करती है।