java - जावा में जेनेरिक कंस्ट्रक्टर किस उद्देश्य से काम करते हैं?




generics constructor (4)

यह सुविधा मुझे क्या करने देती है?

कम से कम तीन दो चीजें हैं जो आपको ऐसा करने देती हैं जो आप अन्यथा नहीं कर सकते हैं:

  1. उदाहरण के लिए, तर्कों के प्रकारों के बीच संबंधों को व्यक्त करें:

    class Bar {
        <T> Bar(T object, Class<T> type) {
            // 'type' must represent a class to which 'object' is assignable,
            // albeit not necessarily 'object''s exact class.
            // ...
        }
    }
  2. <वापस ले लिया>

  3. जैसा कि @Lino ने पहले देखा, यह आपको यह व्यक्त करने देता है कि तर्क दो या दो से अधिक असंबंधित प्रकारों के संयोजन के साथ संगत होना चाहिए (जो कि समझ में आ सकता है जब सभी लेकिन अधिकांश एक इंटरफ़ेस प्रकार हैं)। एक उदाहरण के लिए लिनो का जवाब देखें।

जैसा कि सभी जानते हैं कि आप प्रकार तर्क का उपयोग करके जावा में एक सामान्य वर्ग हो सकते हैं:

class Foo<T> {
    T tee;
    Foo(T tee) {
        this.tee = tee;
    }
}

लेकिन आप जेनेरिक कंस्ट्रक्टर भी रख सकते हैं, जिसका अर्थ है कंस्ट्रक्टर, जो स्पष्ट रूप से अपने जेनेरिक प्रकार के तर्क प्राप्त करते हैं, उदाहरण के लिए:

class Bar {
    <U> Bar(U you) {
        // Why!?
    }
}

मैं उपयोग के मामले को समझने के लिए संघर्ष कर रहा हूं। यह सुविधा मुझे क्या करने देती है?


आपके द्वारा प्रदान किए गए उदाहरण में यह स्पष्ट है कि U वर्ग के निर्माणकर्ता में कोई भूमिका नहीं निभाता है, क्योंकि यह प्रभावी रूप से रनटाइम में एक Object बन जाता है:

class Bar {
    <U> Bar(U you) {
        // Why!?
    }
}

लेकिन कहते हैं कि मैं चाहता था कि मेरा निर्माता केवल उन प्रकारों को स्वीकार करे जो कुछ अन्य वर्ग या इंटरफ़ेस का विस्तार करते हैं, जैसा कि नीचे देखा गया है:

class Foo<T extends Baz> {
    <U extends Bar> Foo(U u) {
        // I must be a Bar!
    }
}

ध्यान दें कि कक्षा में पहले से ही उपयोग में एक अलग सामान्य प्रकार है; यह आपको वर्ग परिभाषा में एक अलग, असंबंधित सामान्य प्रकार का उपयोग करने की अनुमति देता है।

दी, मैंने ऐसा कुछ कभी नहीं किया है, और मैंने इसे उपयोग में कभी नहीं देखा है, लेकिन यह संभव है!


दरअसल, यह कंस्ट्रक्टर है

class Bar {
    <U> Bar(U you) {
        // Why!?
    }
}

एक सामान्य विधि की तरह है। अगर आपके पास इस तरह के कई निर्माता तर्क हैं, तो यह बहुत अधिक समझ में आता है:

class Bar {
    <U> Bar(U you, List<U> me) {
        // Why!?
    }
} 

फिर आप बाधा को लागू कर सकते हैं, कि उनके पास कंपाइलर के साथ एक ही समय है। पूरे वर्ग के लिए यू को एक सामान्य बनाने के बिना।


मैं जिस केस के बारे में सोच रहा हूं वह यह हो सकता है कि कुछ एक ऐसी वस्तु चाहता है जो 2 प्रकारों से प्राप्त हो। उदाहरण 2 interfaces लागू interfaces :

public class Foo {

    public <T extends Bar & Baz> Foo(T barAndBaz){
        barAndBaz.barMethod();
        barAndBaz.bazMethod();
    }
}

हालांकि मैंने इसे कभी भी उत्पादन में इस्तेमाल नहीं किया है।





constructor