मैं जेनरिक के लिए बहुत नया हूं, इसलिए क्षमा करें यदि उत्तर स्पष्ट है।

मेरे पास एक फ़ंक्शन अधिकतम है जो किसी सरणी में अधिकतम मान पाता है। मैं एक सामान्य सरणी ई [] का उपयोग करने की कोशिश कर रहा हूं ताकि वस्तुओं की किसी भी सरणी को इसमें पारित किया जा सके, लेकिन इसका परीक्षण करने की कोशिश में मैंने पाया है कि (जब तक कि मैं कुछ गलत नहीं कर रहा हूं) यह वास्तव में केवल ई ले रहा है [] सरणियाँ ... जो आईडीई मुझे बताती रहती है कि मैं नहीं बना सकता।

import java.lang.reflect.Array;

public class Max {
public static <E extends Comparable<E>> E max(E[] list) {

    E comp1 = null;

    for (E e : list) {
        for (int j = 0; j < list.length; j++) {
            comp1 = list[0];
            if (comp1.compareTo(e) > 0) {
                comp1 = e;
            }
        }
    }
    return comp1;
}

public static <E> void main (String[] args) {
    Boat boat = new Boat(1,2);
    Soda pepsi = new Soda(1,2);
    Comparable<E>[] oa = new Comparable[100];
    Object[] boats = new Boat[20];
    Object[] objects = new Object[1];
    Object stuff = null;

    final E[] a = (E[]) Array.newInstance(1,1);
    E e1 = (E) boat;
    E e2 = (E) pepsi;
    E e3 = (E) stuff;
    
    E[] es = {e1,e2,e3};

    Comparable<E>[][] es = {oa};

    System.out.println((String) max(objects[0]));
    }
}

जैसा कि आप नीचे की मुख्य विधि से देख सकते हैं, मैंने ऑब्जेक्ट्स, ऑब्जेक्ट एरे, और तुलनीय ऑब्जेक्ट्स और उक्त ऑब्जेक्ट्स के एरेज़ का उपयोग करने का प्रयास किया है। max() उन सभी को अस्वीकार कर देता है, जोर देकर कहता है कि यह केवल ई [] प्रकार प्राप्त करता है। यह इस त्रुटि के हिस्से के रूप में देता है: "कारण: प्रकार चर (ओं) ई का कोई उदाहरण मौजूद नहीं है ताकि ऑब्जेक्ट ई [] के अनुरूप हो।" मेरा लक्ष्य यहां वस्तुओं की किसी भी सरणी के साथ अधिकतम() विधि का परीक्षण करना है, लेकिन ऐसा लगता है कि मैं गलत समझता हूं कि सरणी के मामले में जेनेरिक कैसे काम करते हैं। किसी भी मदद या स्पष्टीकरण की सराहना की जाएगी।

0
wombatpandaa 7 फरवरी 2021, 05:36

2 जवाब

सबसे बढ़िया उत्तर

आमतौर पर:

  • आपकी सामान्य विधि को सामान्य प्रकारों का उपयोग करना चाहिए।
  • जो कुछ भी बुला रहा है उसे ठोस प्रकारों का उपयोग करना चाहिए।

आपकी अधिकतम विधि में तर्क त्रुटियाँ थीं, लेकिन जेनरिक का इसका उपयोग सही था।

चूंकि आपकी मुख्य विधि इसके लिए सरणियाँ पास कर रही थी, इसलिए मुख्य विधि में जेनरिक का उपयोग नहीं करना चाहिए था।

public class Max {
    public static <E extends Comparable<E>> E max(E[] list) {
    
        E comp1 = list[0];
    
        for (E e : list) {
            if (comp1.compareTo(e) < 0) {
                comp1 = e;
            }
        }
        return comp1;
    }
    
    public static void main (String[] args) {
        String[] words = {"Don't", "overcomplicate", "your", "generics"};
        Integer[] ints = {5, 14, 4, 8};
        
        System.out.println(max(words));
        System.out.println(max(ints));
    }
}
0
Chris Foley 7 फरवरी 2021, 05:56

आप यहां दो अलग-अलग ई संस्करणों के साथ काम कर रहे हैं। प्रत्येक विधि ई के अपने स्वयं के संस्करण को परिभाषित करती है, और अधिकतम में केवल एक ही तुलनात्मक रूप से विस्तारित होता है। मुख्य विधि को सामान्य बनाना वैसे भी कोई मतलब नहीं है, क्योंकि इनपुट हमेशा एक स्ट्रिंग सरणी होगी, इसलिए इसे हटा दें, और वास्तव में तुलनीय प्रकार के किसी भी सरणी के साथ अपनी मुख्य विधि का परीक्षण करें, उदा। डोरी।

यह संकलित करना चाहिए:

public class Max {
    public static <E extends Comparable<E>> E max(E[] list) {

        E comp1 = null;

        for  (E e : list) {
            for (int j = 0; j < list.length; j++) {
                comp1 = list[0];
                if (comp1.compareTo(e) > 0) {
                    comp1 = e;
                }
            }
        }
        return comp1;
    }

    public static void main (String[] args) {
        System.out.println(max(args));
    }
}
0
Sean Patrick Floyd 7 फरवरी 2021, 05:43