Question

您好我需要创建以下接口。你能回答一个问题吗？我应该创建一个变量来保存运算符的值和两个操作数的值吗？如果是这样，是否应该使用我的main方法在接口内或类内部创建它们？

interface ArithmeticOperator {

    // Returns the result of applying the operator to operands a and b.
    double operate (double a, double b);

    // Return a String that is the name of this operator.
    String printName ();
}


interface OperatorIterator {

    // Apply the operator op repeatedly to the startValue, for numIterations
    // times, e.g., for numIterations=4 you would return
    //    op (startValue, op (startValue, op (startValue, startValue)))
    double iterate (ArithmeticOperator op, double startValue, int numIterations);

}


public class Exam1 implements ArithmeticOperator, OperatorIterator{

    public double operate(double a, double b) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public String printName() {
        String operator ="";
        if(operator.equals("+"))
            return "Add";
        else if(operator.equals("-"))
            return "Sub";
        else if(operator.equals("/"))
            return "Div";
        else if(operator.equals("*"))
            return "Mult";
        else
            return "Unknown Operator";
    }

    public double iterate(ArithmeticOperator op, double startValue, int numIterations) {
        throw new UnsupportedOperationException("Not supported yet.");
    }



    public static void main (String[] argv)
    {
        // Test 1:
        System.out.println ("TEST 1:");
        ArithmeticOperator add = OperatorFactory.get ("add");
        System.out.println ("  1 " + add.printName() + " 2 = " + add.operate (1,2));
        ArithmeticOperator sub = OperatorFactory.get ("sub");
        System.out.println ("  3 " + sub.printName() + " 2 = " + sub.operate (3,2));
        ArithmeticOperator mult = OperatorFactory.get ("mult");
        System.out.println ("  3 " + mult.printName() + " 2 = " + mult.operate (3,2));
        ArithmeticOperator div = OperatorFactory.get ("div");
        System.out.println ("  3 " + div.printName() + " 2 = " + div.operate (3,2));

        // Test 2:
        System.out.println ("TEST 2:");
        ArithmeticOperator add2 = OperatorFactory.get ("add");
        ArithmeticOperator sub2 = OperatorFactory.get ("sub");
        System.out.println ("  Does add2==add? " + add2.equals(add));
        System.out.println ("  Does add2==sub2? " + add2.equals(sub2));

        // Test 3:
        System.out.println ("TEST 3:");
        OperatorIterator opIter = new OpIterator ();
        System.out.println ("  3 * 8 = " + opIter.iterate(add, 3, 8));
        System.out.println ("  3 ^ 4 = " + opIter.iterate(mult, 3, 4));
    }


}

Answer 1

您使用接口来定义合同。该变量由具体实现处理，例如，

public class Add implements ArithmeticOperator(){ 
   @Override double operate (double a, double b){ return a+b;}
}

如果你想要一些更多的行为作为基础，你可以使用抽象类。

Answer 2

操作数的值由调用者作为参数传递给您的方法。运算符似乎隐含在ArithmeticOperator的具体实现中。由ArithmeticOperator的子类来定义操作体，这是操作员“活着”的地方。

请注意，它本身不需要“存储”;这只是逻辑。

例如：

public class PlusOperator implements ArithmeticOperator {
    double operate(double a, double b) {
        return a+b;
    }
}

在printName方法中，您需要检查ArithmeticOperator的实际类型，而不是String（您没有，但不需要））。

像：

if (op instanceof PlusOperator) {
    System.out.println("+");
}

Answer 3

运算符似乎是无状态存在，只是进行一些计算并返回结果。所以答案不是，不要将它存储在对象状态（或变量）中。你需要什么呢？

Answer 4

决定你的变量是否可变。如果是 - 那么在类中声明它，如果是不可变的 - 在接口中。接口变量默认为final。

Answer 5

接口不是抽象类。

需要

接口来定义类之间的通用协议，其中通用协议仅指从其他类可见的方法签名，因此它们能够执行的操作。接口不能“保持”值。

抽象类更强大，它们用于定义类之间的公共部分，无论是procol还是实现。您可以将预定义的行为与抽象方法混合在一起，让子类实现它们。

这是什么意思？

这意味着当您想要为类提供相同的方法时使用接口，但是如果要定义公共行为，则应使用抽象类或父类来声明特定的实现。

在您的示例中，您可以让类类型成为您的实际操作类型：

interface ArithmeticOperation
{
  public double operate(double a, double b);
}

class AddOperation implements ArithmeticOperation
{
  public double operate(double a, double b)
  {
    return a + b;
  }
}

您还可以将子类用于特定事物（请注意，以下示例很简单且不太适合）：

class PowerOperation implements UnaryOperation
{
  public double operate(double a)
  {
    return a*a;
  }
}

class CubeOperation extends PowerOperation
{
  public double operate(double a)
  {
    return super.operate(a)*a;
  }
}

你应该尽量避免链接 IFs 打印出来，这是因为你的类已经知道它们是什么类型所以你可以委托给他们这项工作：

class AddOperation{ public String printVal() { return "ADD"; } }
class SubOperation{ public String printVal() { return "SUB"; } }

Java接口问题

5 个答案: