Question

public class Operations {

    private int add;
    private int sub;
    private int mul;
    private int div;
    private double sqrt;

    public void setadd(int a, int b) {
        add = a + b;
    }

    public void setsub(int a, int b) {
        sub = a - b;
    }

    public void setmul(int a, int b) {
        mul = a * b;
    }

    public void setdiv(int a, int b) {
        div = a / b;
    }

    public void setsqrt(double sqt) {
        sqrt = Math.sqrt(sqt);
    }

    public int getadd() {
        return add;
    }

    public int getsub() {
        return sub;
    }

    public int getmul() {
        return mul;
    }

    public int getdiv() {
        return div;
    }

    public double getsqrt() {
        return sqrt;
    }

}

我是否必须使用这个或Java的原型，这是不必要的，我如何在这里使用静态方法而不是setter和getter ..我正在尝试计算器..我的方法是否正常？< / p>

Answer 1

我真的不明白设置和获取的重点，为什么不让你的计算器这样：

public class Calculator {
public int add(int a, int b){
    return a + b;
}
public int sub(int a , int b){
    return a - b;
}
public int mul(int a, int b){
    return a * b;
}
public int div(int a, int b){
    return a/b;
}
public double sqrt(double sqt){
    return Math.sqrt(sqt);
}

Answer 2

进行Calculator类的所有操作（加法，乘法，除法等）静态方法：

   class Calculator{

     public static int add(int a, int b){
           return a+b;
     }
     ...

Answer 3

你的方法都错了，因为你错误地模拟了你的操作。它不应该包含其结果，它应该只执行一个操作，而不是所有操作。操作对象应该是不可变的，它应该在给定两个操作数的情况下产生对特定操作的答案。你也应该将二元运算与一元分开。

interface BinaryOp {
    double calculate(double left, double right);
}
interface UnaryOp {
    double calculate(double operand);
}
private static final BinaryOp ADD = new BinaryOp() {
    double calculate(double left, double right) {
        return left + right;
    }
};
private static final BinaryOp SUB = new BinaryOp() {
    double calculate(double left, double right) {
        return left - right;
    }
};
private static final BinaryOp MUL = new BinaryOp() {
    double calculate(double left, double right) {
        return left * right;
    }
};
private static final BinaryOp DIV = new BinaryOp() {
    double calculate(double left, double right) {
        return left / right;
    }
};
private static final UnaryOp SQRT = new UnaryOp() {
    double calculate(double operand) {
        return Math.sqrt(operand);
    }
};

现在您可以按名称组织运营商：

private static final Map<String,BinaryOp> opByName = new HashMap<String,BinaryOp>();
static {
    opByName.put("+", ADD);
    opByName.put("-", SUB);
    opByName.put("*", MUL);
    opByName.put("/", DIV);
}

使用此地图，您可以使用您的操作为您执行计算：

String op = "+";
double left = 123;
double right = 456;
double res = opByName.get(op).calculate(left, right);

Answer 4

回答尚未回答的部分问题：

你不需要java中的原型。

Answer 5

这对于一两个枚举来说非常有用：

enum BinOp {
    ADD {
        @Override
        public int eval(int leftArg, int rightArg) {
            return leftArg + rightArg;
        }
        @Override
        public String symbol() {
            return "+";
        }
    },
    SUBTRACT {
        @Override
        public int eval(int leftArg, int rightArg) {
            return leftArg - rightArg;
        }
        @Override
        public String symbol() {
            return "-";
        }
    }
    // etc.
    ;
    public abstract int eval(int leftArg, int rightArg);
    public abstract String symbol();
}

对于一元运算符（目前只有SQRT）的类似枚举。

您可以按如下方式使用这些：

int left = 3;
int right = 2;
for (BinOp op : BinOp.values()) {
    System.out.println("The value of "
        + left + " " + op.symbol() + " " + right " is "
        + op.eval(left, right)
    );
}

静态方法或setter或getter？

5 个答案: