जावा में ओओपी: विधि चेनिंग के साथ वर्ग विरासत

Question

मेरे पास एक अभिभावक वर्ग है, जो चेनर विधियों के संग्रह को परिभाषित करता है (विधियां जो "यह" लौटाती हैं)। मैं कई बाल वर्गों को परिभाषित करना चाहता हूं जिनमें उनके स्वयं के चेनर विधियां हों, लेकिन यह मूल विधियों को "ओवरराइड" भी करती है ताकि अभिभावक वर्ग की बजाय बाल वर्ग का एक उदाहरण लौटाया जा सके।

मैं प्रत्येक बच्चे वर्ग में एक ही तरीके को दोहराना नहीं चाहता हूं, यही कारण है कि मेरे पास एक अभिभावक वर्ग है जिसमें सभी बाल वर्ग साझा करने के तरीके शामिल हैं। धन्यवाद।

class Chain { 
    public Chain foo(String s){ 
    ... 
    return this; 
    } 
} 

class ChainChild extends Chain { 
    //I don't want to add a "foo" method to each child class 
    /* 
    public ChildChain foo(String s){ 
    ... 
    return this; 
    } 
    */ 

    public ChainChild bar(boolean b){ 
    ... 
    return this; 
    } 
} 

ChainChild child = new ChainChild(); 
child.foo().bar(); //compile error: foo() returns a "Chain" object which does not define the bar() method. 

Answer 1

माता पिता वर्ग कि this रिटर्न अभी भी बच्चे वर्ग की वस्तु के लिए एक संदर्भ वापस आ जाएगी में एक तरीका। आप केवल माता-पिता वर्ग के किसी ऑब्जेक्ट के रूप में इसका इलाज कर पाएंगे (जब तक कि आप इसे नहीं निकालते) लेकिन यह वास्तव में इसके मूल प्रकार का होगा।

आप इस तरह जेनरिक उपयोग करने पर विचार कर सकता है:

// This seems a bit too contrived for my liking. Perhaps someone else will have a better idea. 
public class Parent<T extends Parent<T>> { 
    T foo() { 
     return (T) this; 
    } 
} 

public class Child extends Parent<Child> { 
    public void bar() { 
     Child c = foo(); 
    } 
} 

Answer 2

तुम बस यह डाली कर सकते हैं।

ChainChild child = new ChainChild(); 
((ChainChild) child.foo()).bar(); 

आप की कोशिश कर सकते:

public ? extends Chain foo() { 
    return this; 
} 

लेकिन मुझे यकीन है कि मदद मिलेगी, भले ही वह संकलित नहीं हूँ।

Answer 3

मैंने आपकी जरूरतों के आधार पर जेनरिक का उपयोग करके यह नमूना लिखा है।

class Parent { 
    public <T extends Parent> T foo() { 
     return (T)this; 
    } 
} 

class Child extends Parent { 

} 

class AnotherChild extends Parent { 

} 

public class Test { 
    public static void main(String[] args) { 

     Parent p = new Child(); 
     System.out.println(p); 
     Child c = p.foo(); 
     System.out.println(c); 
     //throws ClassCastException here since Child is not AnotherChild 
     AnotherChild ac = p.foo(); 
     System.out.println(ac); 
    } 
} 

Answer 4

यहाँ OldCurmudgeon की विधि पर एक सुधार है:

public class Parent<This extends Parent<This>> { 

    @SuppressWarnings("unchecked") 
    private final This THIS = (This)this; 

    public This foo() { 
     //... 
     return THIS; 
    } 

    public This bar() { 
     //... 
     return THIS; 
    }  
} 

public class Child extends Parent<Child> { 

    // you can override super with covariant return type 
    @Override 
    public Child bar() { 
     super.bar(); 

     return this; 
    } 
} 


Child child = 
new Child() 
.foo() 
.bar(); 

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

यह प्रत्येक विधि में अनचेक कास्ट हटा देता है और कोड को स्पष्ट बनाता है।

आप इसके बजाय बच्चे को लौटकर माता-पिता के तरीकों को ओवरराइड कर सकते हैं (कॉन्वेंट रिटर्न प्रकार)।