Simple object oriented console calculator
Exception handling

try {
    ...          
} catch (InputMismatchException ime) {
     System.out.println("invalid input");
} finally {
     if (operator != '+' &amp; operator != '-' &amp; operator != '*' &amp; operator != '/') {
         throw new InputMismatchException();
     }
     Calculator calculator = new Calculator(firstNum, secondNum,    operator);
     ...
}


That's pretty weird.

It makes no sense to continue the computation if the Scanner throws. What is the point of having a finally block that throws the same exception? I would rather let the exception pass through instead of catching and rethrowing (the original exception is likely to contain a more meaningful message, too).

Variable scope

Try and use the narrowest possible scope. For instance, here:

Calculator calc = new Calculator(6.0, 2.0, '+');

@Test
void addsTwoNumbers() {
     assertEquals(8.0, calc.makeCalculation());
}


there's no point in making calc a field. It can (and should) be just a local variable in the addsTwoNumbers() method. The same is true for other calc's and test methods.

Class design

I don't think that the Calculator is a good name for your class. I would expect a calculator to be able to be instantiated once and then evaluate results of different expression. Something like this:

Calculator calculator = new Calculator();
double sum = calculator.evaluateExpression(x, y, '+');
double difference = caclulator.evaluateExpression(x, y, '-');


I'd change it this way or rename this class to Expression.

Object reuse

Creating four new objects for each operation per each expression evaluation can be costly and is unreasonable because the operation are stateless.

You can use a static factory to reuse the same Operation objects in different expressions.