Java 在不知道变量类型的情况下计算变量的算术表达式

我有一个使用（*/+-）运算符的算术表达式。变量有三种类型：整数、浮点或双精度。变量的类型将通过在命令行中写入单词“double”、“float”或“integer”来选择。我已经写了程序，但我不喜欢我的代码

import java.io.BufferedReader;
import java.io.InputStreamReader;

class Work {

    InitializeForType init;
    String calculate_for;
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    void  go() {
        try {
            calculate_for = bufferedReader.readLine();
            if (calculate_for.equals("double")){init = new InitializeForType<Double>();init.setA(1.23);}
            if (calculate_for.equals("float")){init = new InitializeForType<Float>();init.setA(1.23f);}
            if (calculate_for.equals("integer")){init = new InitializeForType<Integer>();init.setA(1);}
        } catch (java.io.IOException io) {
            System.out.println("ERROR!");
        }
        System.out.println(calculate(init.A));
    }


    private String calculate(Object a) {

        boolean is_double = a instanceof Double;
        boolean is_float = a instanceof Float;

        return "(arctg(2*c)/d + 2)/(d + a - 1) " +  " = (arctg(" + 2 *
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) + ")/" + a + " + 2)/(" + a + " + " + a + " - 1)" + " = (" + Math.atan(2 *
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a)))) + "/" + a + " + 2)/(" + a + " + " + a + " - 1)" + " = (" + (Math.atan(2 *
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a)))) /
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) + 2) + ")/(" + (
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) +
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) - 1.0) + ")" + " = " + (Math.atan(2 *
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a)))) /
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) + 2) / (
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) +
            (is_double ? toDouble(a) : (is_float ? toFloat(a) : toInt(a))) - 1.0);
    }

    private Double toDouble(Object ob) {
        return Double.parseDouble(ob.toString());
    }

    private Float toFloat(Object ob) {
        return Float.parseFloat(ob.toString());
    }

    private Integer toInt(Object ob) {
        return Integer.parseInt(ob.toString());
    }

    private static class InitializeForType<someType> {
        someType A;
        void setA(someType a) {
            this.A = a;
        }
    }
}

导入java.io.BufferedReader；
导入java.io.InputStreamReader；
课堂作业{
InitializeForType init；
字符串计算_；
BufferedReader BufferedReader=新的BufferedReader（新的InputStreamReader（System.in））；
void go（）{
试一试{
计算=bufferedReader.readLine（）的_；
if（calculate_for.equals（“double”）{init=new InitializeForType（）；init.setA（1.23）；}
if（calculate_for.equals（“float”）{init=new InitializeForType（）；init.setA（1.23f）；}
if（calculate_for.equals（“integer”）{init=new InitializeForType（）；init.setA（1）；}
}捕获（java.io.io异常io）{
System.out.println（“错误！”）；
}
System.out.println（calculate（init.A））；
}
私有字符串计算（对象a）{
布尔值为_double=double的一个实例；
布尔值为浮点数=浮点数的一个实例；
返回“（arctg（2*c）/d+2）/（d+a-1）”+“=（arctg（“+2*
这句话的意思是：“+a+”/“+a+”+2/（“+a+”+“+a+”-1）”+”=（“+Math.atan（2*
这句话的意思是：“+”/“+a+”+2/（“+a+”+“+a+”-1）”+”=（“+”）（数学）*
（是双重的吗？托福（a）：（是浮动的吗？托福（a）：托福（a）））/
这句话的意思是：“+2+”/”（“+2”）(
（是双浮式还是双浮式（a）：（是浮式还是浮式（a）：toInt（a）））+
这句话的意思是：1.0“+”+”=“+”（数学术语2*
（是双重的吗？托福（a）：（是浮动的吗？托福（a）：托福（a）））/
（是双浮式还是双浮式？）+2）(
（是双浮式还是双浮式（a）：（是浮式还是浮式（a）：toInt（a）））+
（是双倍的托福（a）：（是浮动的托福（a）：托福（a））-1.0）；
}
专用双toDouble（对象ob）{
返回Double.parseDouble（ob.toString（））；
}
私有浮点toFloat（对象ob）{
返回Float.parseFloat（ob.toString（））；
}
私有整数toInt（对象ob）{
返回Integer.parseInt（ob.toString（））；
}
私有静态类InitializeForType{
A型；
空刚毛（a型）{
这个A=A；
}
}
}

---

我不希望代码的算术部分重复三次。我写得像

（是双精度的吗？toDouble（a）：（是浮动的吗？toFloat（a）：toInt（a））

。。。。我知道这很愚蠢，但它很有效。

为什么不使用String.valueOf（a）而不是。。是双重的吗？是浮动的吗？是浮动的吗

---

为什么不使用String.valueOf（a）而不是。。是双重的吗？是浮动的吗？是浮动的吗

---

如果您希望代码更加枯燥，那么您需要一个面向对象的解决方案。 然后使用多态性处理每个特殊情况

您所做的是使用标志和过程编程。这并不可怕；它只是不容易阅读或灵活。如果需要将字符串值添加到此程序中，该怎么办？嗯，你现在必须修改所有内容

---

希望这能为您提供一些指导，而不必重写整个程序。

如果您希望代码更加枯燥，您需要一个面向对象的解决方案。 然后使用多态性处理每个特殊情况

您所做的是使用标志和过程编程。这并不可怕；它只是不容易阅读或灵活。如果需要将字符串值添加到此程序中，该怎么办？嗯，你现在必须修改所有内容

---

希望这能为您提供一些指导，而不必重写整个程序。

这不是更适合吗？整个

是双重的
业务是不必要的。您可以在不知道其类型的情况下解析
a
。你为什么要把你知道的已经是双精度的东西再解析一遍呢？听说过铸造吗？此外，所有数字类型都扩展了
number
。您可以调用
（（Number）a）.doubleValue（）
，因为您的三元表达式无论如何都会升级为double。即使您出于某种原因确实需要三元表达式，也无需重复它。只要把它存储在一个变量中就行了。@Artemis提问者这样说，但其核心是一个问题，询问如何用给定的语言做某事。提问者可以不用他们的实际代码，因为这是不相关的，并用一个更简单的通用示例提问。尽管有一个工作程序，asker没有一个具体要求的工作示例。这不是更适合吗？整个
是双重的
业务是不必要的。您可以在不知道其类型的情况下解析
a
。你为什么要把你知道的已经是双精度的东西再解析一遍呢？听说过铸造吗？此外，所有数字类型都扩展了
number
。您可以调用
（（Number）a）.doubleValue（）
，因为您的三元表达式无论如何都会升级为double。即使您出于某种原因确实需要三元表达式，也无需重复它。只要把它存储在一个变量中就行了。@Artemis提问者这样说，但其核心是一个问题，询问如何用给定的语言做某事。提问者可以不用他们的实际代码，因为这是不相关的，并用一个更简单的通用示例提问。尽管有一个工作程序，asker没有一个具体的工作示例