जावा फ़ंक्शन कैसे लिखें जो एकाधिक डेटा प्रकारों के मान देता है?

Question

उदाहरण के लिए, मैं एक ऐसा फ़ंक्शन बनाना चाहता हूं जो किसी भी संख्या (ऋणात्मक, शून्य, या सकारात्मक) को वापस कर सके।

हालांकि, कुछ अपवादों के आधार पर, मैं समारोह BooleanFALSE

वापस जाने के लिए वहाँ एक रास्ता एक समारोह है कि एक intया एक Boolean लौट सकते हैं लिखने के लिए है चाहते हैं?

---

ठीक है, इसलिए इसे बहुत सारी प्रतिक्रियाएं मिली हैं। मैं समझता हूं कि मैं बस गलत तरीके से समस्या का सामना कर रहा हूं और मुझे throw विधि में कुछ प्रकार की अपवाद होना चाहिए। बेहतर उत्तर पाने के लिए, मैं कुछ उदाहरण कोड प्रदान करने जा रहा हूं। कृपया मजाक न करें :)

public class Quad { 

    public static void main (String[] args) { 

    double a, b, c; 

    a=1; b=-7; c=12; 
    System.out.println("x = " + quadratic(a, b, c, 1)); // x = 4.0 
    System.out.println("x = " + quadratic(a, b, c, -1)); // x = 3.0 


    // "invalid" coefficients. Let's throw an exception here. How do we handle the exception? 
    a=4; b=4; c=16; 
    System.out.println("x = " + quadratic(a, b, c, 1)); // x = NaN 
    System.out.println("x = " + quadratic(a, b, c, -1)); // x = NaN 

    } 

    public static double quadratic(double a, double b, double c, int polarity) { 

    double x = b*b - 4*a*c; 

    // When x < 0, Math.sqrt(x) retruns NaN 
    if (x < 0) { 
     /* 
     throw exception! 
     I understand this code can be adjusted to accommodate 
     imaginary numbers, but for the sake of this example, 
     let's just have this function throw an exception and 
     say the coefficients are invalid 
     */ 
    } 

    return (-b + Math.sqrt(x) * polarity)/(2*a); 

    } 

} 

Answer 1

नहीं, आप जावा में ऐसा नहीं कर सकते हैं।

हालांकि आप Object वापस कर सकते हैं। और किसी ऑब्जेक्ट को लौटकर आप तकनीकी रूप से java.lang.Integer या java.lang.Boolean जैसे व्युत्पन्न क्लास को वापस कर सकते हैं। हालांकि, मुझे नहीं लगता कि यह सबसे अच्छा विचार है।

Answer 2

नहीं। सबसे अच्छा आप कर सकते हैं एक वर्ग के उदाहरण पर वापसी जो उन सभी चीजों को संभालती है जिन्हें आप वापस करना चाहते हैं।

कुछ

public class ReturnObj { 
    public bool yesno; // yes or no 
    public int val; // for int values 
    public String mode; // mode describing what you returned, which the caller will need to understand. 
} 

तरह जाहिर है, आप नाम के साथ खेलने के लिए की जरूरत है ....

इसके अलावा, यह एक कोड गंध की तरह लगता है। आप योग्यता के आधार पर आप जिस मार्ग को चाहते हैं उसे अर्हता प्राप्त करके आप इस तरह कुछ करने की आवश्यकता को दूर करने में सक्षम हो सकते हैं, और उसके बाद योग्यता के आधार पर एक इंटीरियर प्राप्त करने के लिए बूलियन या विशिष्ट फ़ंक्शन प्राप्त करने के लिए एक विशिष्ट फ़ंक्शन को कॉल कर सकते हैं।

Answer 3

नहीं, एक ग्राहक के लिए एक वापसी संदर्भ।

आप एक प्रतिक्रिया ऑब्जेक्ट लिख सकते हैं जो एक बूलियन और एक int को एक साथ जोड़ता है और मूल्यों को आपके whim के अनुसार सेट करता है।

लेकिन अगर मैं एक उपयोगकर्ता था तो मुझे लगता है कि आपका डिज़ाइन उलझन में था।

Answer 4

एक ऐसा फ़ंक्शन लिखें जो Object देता है। क्या यह या तो Boolean या Integer रैपर ऑब्जेक्ट्स लौटा है। फिर इसका उपयोग करने के लिए उदाहरण का उपयोग करें।

Answer 5

यह आप जो करना चाहते हैं उसके आधार पर यह सबसे अच्छा समाधान नहीं हो सकता है, लेकिन समस्या को हल करने का एक आसान तरीका यह हो सकता है कि फ़ंक्शन संभावित अंतर (जैसे RETURNED_FALSE/TRUE) के बाहर एक int या निरंतर लौटाए। और उसके लिए जाँच करें।

Answer 6

आप तकनीकी रूप से ऐसा कर सकता है:

public <T> T doWork() 
{ 
    if(codition) 
    { 
     return (T) new Integer(1); 
    } 
    else 
    { 
     return (T) Boolean.FALSE; 
    } 
} 

फिर इस कोड संकलन होगा:

int x = doWork(); // the condition evaluates to true 
boolean test = doWork(); 

लेकिन अगर विधि गलत प्रकार देता है आप सबसे निश्चित रूप से क्रम अपवाद लग सकता है। आपको प्राइमेटिव्स के बजाय वस्तुओं को भी वापस करना होगा क्योंकि टी java.lang में मिटा दिया गया है।ऑब्जेक्ट, जिसका मतलब है कि लौटा हुआ प्रकार ऑब्जेक्ट (यानी एक ऑब्जेक्ट) होना चाहिए। उपर्युक्त उदाहरण एक आदिम रिटर्न प्रकार प्राप्त करने के लिए ऑटोबॉक्सिंग का उपयोग करता है।

मैं निश्चित रूप से इस दृष्टिकोण की अनुशंसा नहीं करता क्योंकि आईएमओ आपको अपवाद हैंडलिंग के उपयोग का मूल्यांकन करने की आवश्यकता है। आप असाधारण मामलों में अपवाद पकड़ते हैं यदि आप उस अपवाद के साथ कुछ कर सकते हैं (यानी पुनर्प्राप्ति, जारी रखें, पुनः प्रयास करें, आदि)। अपवाद अपवाद अपेक्षित वर्कफ़्लो में हैं, इसका एक हिस्सा नहीं है।

Answer 7

मेरे शिक्षक एक TryParse सी # जावा में विधि की तरह के लिए एक शांत विचार था आशा है कि यह मदद करता है

import java.util.Scanner; 

public class Program { 
    static Scanner scanner = new Scanner(System.in); 
    public static void main(String[] args) { 
     System.out.println("Enter number"); 
     String input = scanner.next(); 
     int[] num ={0}; 
     if(tryParse(input,num)) 
      System.out.println(num[0] * num[0]); 
    } 
    static boolean tryParse(String inputString,int[] outputInt){ 
     try{ 
      outputInt[0] = Integer.parseInt(inputString); 
      return true; 
     }catch(Exception e){ 
      return false; 
     } 
    } 
} 

Answer 8

inout मापदंडों केवल वस्तुओं है कि उत्परिवर्तित किया जा सकता है के लिए काम करते हैं। स्ट्रिंग इनआउट पैरामीटर के लिए, स्ट्रिंग्स के बजाय स्ट्रिंगबिल्डर में पास करें, फिर उनके मानों को प्रतिस्थापित करें।

Answer 9

आईईईई फ्लोटिंग प्वाइंट

अधिकांश भाषाओं अपवाद या संघ प्रकार के बिना अपने विशिष्ट उदाहरण संभाल लेंगे क्योंकि आईईईई चल बिन्दु NaN के लिए एक प्रतिनिधित्व भी शामिल है। जावा में, Double.NaN का उपयोग करें:

public static double quadratic(double a, double b, double c, int polarity) { 
    double x = b*b - 4*a*c; 

    // When x < 0, Math.sqrt(x) retruns NaN 
    if (x < 0) { 
     return Double.NaN; 
    } 
    return (-b + Math.sqrt(x) * polarity)/(2*a); 
} 

कि अपने सटीक उत्पादन है कि आप चाहते थे पैदा करता है:

x = 4.0 
x = 3.0 
x = NaN 
x = NaN 

अपवाद

अपवाद को सुलझाने इसी तरह की समस्याओं के पुराने जावा मार्ग हैं:

public static double quadratic(double a, double b, double c, int polarity) { 
    double x = b*b - 4*a*c; 
    // When x < 0, Math.sqrt(x) returns NaN 
    if (x < 0) { 
     throw new Exception("NaN") 
    } 
    return (-b + Math.sqrt(x) * polarity)/(2*a); 
} 

यहां अपवाद के लिए आपका ग्राहक कोड है।

a=1; b=-7; c=12; 

// x = 4.0 
try { 
    System.out.println("x = " + quadratic(a, b, c, 1)); 
} catch (Exception iae) { 
    System.out.println("Oopsie: " + iae.getMessage()); 
} 

// x = 3.0 
try { 
    System.out.println("x = " + quadratic(a, b, c, -1)); 
} catch (Exception iae) { 
    System.out.println("Oopsie: " + iae.getMessage()); 
} 

// "invalid" coefficients. 
a=4; b=4; c=16; 

// Oopsie: NaN 
try { 
    System.out.println("x = " + quadratic(a, b, c, 1)); 
} catch (Exception iae) { 
    System.out.println("Oopsie: " + iae.getMessage()); 
} 

// Oopsie: NaN 
try { 
    System.out.println("x = " + quadratic(a, b, c, -1)); 
} catch (Exception iae) { 
    System.out.println("Oopsie: " + iae.getMessage()); 
} 

संघ प्रकार

वास्तव में करने के लिए या एक विधि से पारित या असंबद्ध प्रकार लौटने के लिए, आप संघ प्रकार जो जावा वास्तव में समर्थन नहीं करता है चाहता हूँ।

public static Or<Double,String> quadratic(double a, double b, 
              double c, int polarity) { 
    double x = b*b - 4*a*c; 

    // When x < 0, Math.sqrt(x) retruns NaN 
    if (x < 0) { 
     return Or.bad("NaN"); 
    } 
    return Or.good((-b + Math.sqrt(x) * polarity)/(2*a)); 
} 

@Test public void testQuadradic() { 
    double a, b, c; 
    a=1; b=-7; c=12; 

    // x = Good(4.0) 
    System.out.println("x = " + quadratic(a, b, c, 1)); 

    // x = 3.0 
    System.out.println(
      (String) quadratic(a, b, c, -1) 
        .match(good -> "x = " + good, 
          bad -> "Oopsie: " + bad)); 

    // "invalid" coefficients. 
    a=4; b=4; c=16; 

    // x = Bad("NaN") 
    System.out.println("x = " + quadratic(a, b, c, 1)); 

    // Oopsie: NaN 
    System.out.println(
      (String) quadratic(a, b, c, -1) 
        .match(good -> "x = " + good, 
          bad -> "Oopsie: " + bad)); 
} 

निष्कर्ष

अपने विशिष्ट उदाहरण के लिए, सिर्फ फ्लोटिंग उपयोग प्वाइंट: लेकिन Paguro Union Types जो आप इस (या उपयोग करते हुए) की तरह जावा में उपयोग कर सकते हैं प्रदान करता है। अधिक सामान्य समाधान के लिए, मुझे यूनियन प्रकार अपवादों से अधिक उपयोगी लगता है। आप यूनियन प्रकारों को तर्क के रूप में तर्क के रूप में उपयोग कर सकते हैं जो दो अलग-अलग इनपुट ले सकता है जिनमें कोई सामान्य इंटरफ़ेस या पूर्वज नहीं है। वे कार्यात्मक प्रोग्रामिंग के लिए भी अधिक अनुकूल हैं।

Answer 10

मैं कहूंगा कि यह संभव है। लेकिन सीधे नहीं।

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

अपने मान नीचे दिए गए मानचित्र पर जोड़ें। और इसे अपनी कुंजी के साथ प्राप्त करें!

public static HashMap returnAnyType(){ 
    String x = "This"; 
    int a = 9; 

    HashMap myMap = new HashMap(); 
    myMap.put("stringVal", x); 
    myMap.put("intVal", a); 
    return myMap; 
} 

String theStringFromTheMap = (String) returnAnyType().get("stringVal"); 
int theIntFromTheMap = (Integer) returnAnyType().get("intVal"); 

System.out.println("String : " + theStringFromTheMap + " is great !"); 
System.out.println("Integer: " + theIntFromTheMap + 10); 

आउटपुट (दोनों एक ही विधि से लौटाए जाते हैं):

 
String : This is great! 
Integer: 19 

नोट:
यह एक अच्छा अभ्यास नहीं है। लेकिन जब कभी इसकी आवश्यकता होती है तो यह मदद करता है!