Member Avatar for Samyx

I am trying to implement an interface so that the main program would work.

Any light? I am having a difficult time trying to understand interface :/

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.
    public void printName (String a);//{

	//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 {

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

}
  • 2 Contributors
  • 1 Reply
  • 103 Views
  • 9 Hours Discussion Span
  • Latest Post Latest Post by javaAddict

Dani AI

Generated

There are two issues to fix before implementing the classes suggested by .

First, the interface method signature for the name is wrong for how main calls it: main invokes printName() with no arguments and uses its return value. Change the interface so printName returns a String and takes no parameters. After that, implement the concrete operator, iterator and factory classes as follows.

A compact, modern approach is:

  • ArithmeticOperatorImpl stores a name and a binary operation, implements operate and printName, and overrides equals/hashCode (or rely on the factory to return the same instance for the same operator).
  • OpIterator.iterate(...) treats numIterations as the number of startValue operands (so numIterations==1 returns startValue; numIterations==4 computes op(start, op(start, op(start, start)))).
  • OperatorFactory.get(...) returns cached instances (use a concurrent map) so Test 2's equality check succeeds.

Example implementations:

public class ArithmeticOperatorImpl implements ArithmeticOperator {
    private final String name;
    private final java.util.function.DoubleBinaryOperator op;
    public ArithmeticOperatorImpl(String name, java.util.function.DoubleBinaryOperator op) {
        this.name = name; this.op = op;
    }
    @Override public double operate(double a, double b) { return op.applyAsDouble(a, b); }
    @Override public String printName() { return name; }
    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ArithmeticOperatorImpl)) return false;
        return name.equals(((ArithmeticOperatorImpl)o).name);
    }
    @Override public int hashCode() { return name.hashCode(); }
}
public class OpIterator implements OperatorIterator {
    @Override
    public double iterate(ArithmeticOperator op, double startValue, int numIterations) {
        if (numIterations < 1) throw new IllegalArgumentException("numIterations must be >= 1");
        double result = startValue;
        for (int i = 1; i < numIterations; i++) result = op.operate(startValue, result);
        return result;
    }
}
public class OperatorFactory {
    private static final java.util.Map<String, ArithmeticOperator> CACHE = new java.util.concurrent.ConcurrentHashMap<>();
    public static ArithmeticOperator get(String name) {
        if (name == null) throw new IllegalArgumentException("name==null");
        String key = name.toLowerCase();
        return CACHE.computeIfAbsent(key, k -> {
            switch (k) {
                case "add":  return new ArithmeticOperatorImpl("add",  (a,b)->a+b);
                case "sub":  return new ArithmeticOperatorImpl("sub",  (a,b)->a-b);
                case "mult": return new ArithmeticOperatorImpl("mult", (a,b)->a*b);
                case "div":  return new ArithmeticOperatorImpl("div",  (a,b)->a/b);
                default: throw new IllegalArgumentException("Unknown operator: " + name);
            }
        });
    }
}

Notes: handle numIterations < 1 explicitly; division by zero with doubles yields Infinity/NaN so validate if you want exceptions; use the factory cache so add2.equals(add) is true. These classes will make the posted main output match the expected TESTs (e.g., repeated-add gives multiplication, repeated-mult gives exponentiation).

Member Avatar for javaAddict 
public class ArithmeticOperatorImpl implements ArithmeticOperator {
  ....
}
public class OpIterator implements OperatorIterator {
  ....
}

Then create the OperatorFactory class that creates ArithmeticOperatorImpl objects and returns them based on the input

Edited by javaAddict because: n/a
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.