Fatal编程技术网
  • java/
  • 如何编写返回多种数据类型值的Java函数？

如何编写返回多种数据类型值的Java函数？

java methods

如何编写返回多种数据类型值的Java函数？,java,methods,overloading,Java,Methods,Overloading,例如，我想创建一个可以返回任何数字（负、零或正）的函数 但是，基于某些异常，我希望函数返回BooleanFALSE 有没有一种方法可以编写一个可以返回int或布尔值的函数 好的，这已经收到了很多回复。我知道我只是错误地处理了这个问题，我应该在方法中抛出某种异常。为了得到更好的答案，我将提供一些示例代码。请不要开玩笑：） 公共类四元组{ 公共静态void main（字符串[]args）{ 双a、b、c； a=1；b=7；c=12； System.out.println（“x=+二次（a，b，c，

例如，我想创建一个可以返回任何数字（负、零或正）的函数

但是，基于某些异常，我希望函数返回
Boolean
FALSE

有没有一种方法可以编写一个可以返回
int
或
布尔值的函数



好的，这已经收到了很多回复。我知道我只是错误地处理了这个问题，我应该在方法中抛出某种异常。为了得到更好的答案，我将提供一些示例代码。请不要开玩笑：）


公共类四元组{
公共静态void main（字符串[]args）{
双a、b、c；
a=1；b=7；c=12；
System.out.println（“x=+二次（a，b，c，1））；//x=4.0
System.out.println（“x=+二次（a，b，c，-1））；//x=3.0
//“无效”系数。让我们在这里抛出一个异常。我们如何处理该异常？
a=4；b=4；c=16；
System.out.println（“x=+二次（a，b，c，1））；//x=NaN
System.out.println（“x=+二次（a，b，c，-1））；//x=NaN
}
公共静态双二次（双a、双b、双c、int极性）{
双x=b*b-4*a*c；
//当x<0时，Math.sqrt（x）将运行NaN
if（x<0）{
/*
抛出异常！
我理解此代码可以调整以适应
虚数，但为了这个例子，
让我们让这个函数抛出一个异常
假设系数无效
*/
}
返回（-b+数学sqrt（x）*极性）/（2*a）；
}
}

否。您最好返回一个类的实例，该类处理您可能希望返回的所有内容

差不多


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.
}


显然，你需要玩弄这些名字


而且，这似乎是一种代码气味。您可以通过限定函数外部所需的路径，然后调用特定函数来获取布尔值，或者调用特定函数来获取int值，这取决于限定条件
 否，向客户返回一个参考

您可以编写一个响应对象，将布尔值和int值封装在一起，并根据您的突发奇想设置值


但是，如果我是一个用户，我会认为您的设计令人困惑。
不，您不能在Java中这样做


您可以返回一个
对象。通过返回一个对象，您可以从技术上返回一个派生类，如
java.lang.Integer
或
java.lang.Boolean
。但是，我认为这不是最好的主意。
编写一个返回
对象的函数。让它返回
布尔值
或
整数
包装对象。然后使用instanceof确定要使用哪一个。
这可能不是最好的解决方案，具体取决于您想做什么，但解决问题的一个简单方法可能是让函数返回一个可能范围之外的int或常量（例如返回的\u FALSE/TRUE），然后检查该值。
从技术上讲，您可以这样做：


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


但是，如果方法返回错误的类型，您很可能会遇到运行时异常。您还必须返回对象而不是原语，因为T被擦除为java.lang.Object，这意味着返回的类型必须扩展对象（即是对象）。上面的示例使用自动装箱来实现基本返回类型


我当然不会推荐这种方法，因为IMO需要评估异常处理的使用情况。如果可以对异常执行某些操作（即恢复、持久化、重试等），则可以在异常情况下捕获异常。异常是预期工作流的一个异常，而不是它的一部分。
我的老师有一个很酷的想法，在java中使用一个类似tryParse C的方法，希望它能有所帮助


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;
        }
    }
}



inout参数仅适用于可以变异的对象。对于字符串输入输出参数，传入StringBuilders而不是字符串，然后替换（）它们的值。
IEEE浮点值
大多数语言都会处理您的特定示例，不会出现异常或联合类型，因为IEEE浮点包含NaN的表示。在Java中，使用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);
}


例外情况
例外情况是解决类似问题的旧Java方法：


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);
}


联合类型
要真正地向方法传递或从方法返回不相关的类型，您需要Java不真正支持的联合类型。但是Paguro提供了您可以在Java中使用的方法（使用或）：


公共静态或二次（双a、双b、，
双c，int极性）{
双x=b*b-4*a*c；
//当x<0时，Math.sqrt（x）将运行NaN
if（x<0）{
返回或。坏（“NaN”）；
}
返回或.good（（-b+数学sqrt（x）*极性）/（2*a））；
}
@测试公共void testQuadradic（）{
双a、b、c；
a=1；b=7；c=12；
//x=良好（4.0）
System.out.println（“x=+二次（a，b，c，1））；
//x=3.0
System.out.println(
（弦）二次（a，b，c，-1）
.match（好->“x=”+好，
坏->糟糕：“+坏”）；
//“无效”系数。
a=4；b=4；c=16；
//x=坏（“NaN”）
System.out.println（“x=+二次（a，b，c，1））；
//哎呀，楠
System.out.println(
（弦）二次（a，b，c，-1）
.match（好->“x=”+好，
坏->糟糕：“+坏”）；
}


结论

对于您的特定示例，只需使用浮点。对于更一般的解决方案，我发现联合类型比异常更有用。您可以使用联合类型作为方法的参数，该方法可能接受两个没有公共接口或祖先的不同输入。它们对函数式编程也更友好。
我认为这是可能的。但不是直接的

我还没有完成报告中给出的程序

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));
}



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

    HashMap<String, Object> 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: " + Math.addExact(theIntFromTheMap, 10));


String : This is great!
Integer: 19

import org.json.JSONObject;



JSONObject retval = new JSONObject();
double x = b*b - 4*a*c;
if(x < 0){
    retval.put("result", false);
}
else{
    retval.put("result", x);
}