public class Calculator {
  private Calculator() {
    throw new UnsupportedOperationException("Don't even try");
  }

  public static Result calculate(Input input) {
    ...
  }
}

public class Calculator {
  private final Input input;
  private Calculator(Input input) {
    this.input = input;
  }

  private Result calculateImpl() {
    ...
  }

  public static Result calculate(Input input) {
    final Calculator calc = new Calculator(input);
    ...
    return calc.calculateImpl();
  }
}

public class Calculator {
  private final Input input;
  private Calculator(Input input) {
    this.input = input;
  }

  private Result calculateImpl() {
    ...
  }

  @Deprecated("use calculate(input, Options.defaultOptions())")
  public static Result calculate(Input input) {
    return calculate(input, Options.defaultOptions());
  }

  public static Result calculate(Input input, Options options) {
    if (!options.useFeatureA() && !options.useFeatureB())
      return new Calculator.calculate();
    DataStream ds =
      options.useFeatureA() ? new FancyStream(input.stream()) : input.stream();
    return new BetterImpl(options.useFeatureB().process(ds);
  }
}

public interface MyCalculator {
  public Result calculate(Input input);
}

class MyProg {
  private final MyCalculator calc;

  MyProg(MyCalculator calc) {
    this.calc = calc;
  }

  void doSomething(Input input) {
    for (int i = 0; i < 10; i++) {
      calculator.calculate(input);
    }
  }
}

public class BasicCalculator implements MyCalculator {
  @override
  public Result calculate(Input input) {
    return Calculator.calculate(input);
  }
}

final class MyCalculators {
  private MyCalculators() {
    throw new UnsupportedOperationException("Why do you want this?");
  }

  /** 
   * A basic implementation of the calculator that just delegates all
   * computation to the standard library implementation Calculator.
   */
  public MyCalculator basicCalculator =
    new MyCalculator() {
      @override
      public Result calculate(Input input) {
        return Calculator.calculate(input);
      }
    }
}

• Какой API используется для доступа к функциональности, предоставляемой модулем вычисления?
  
• Как реализуется функциональность, предоставляемая модулем вычисления?
  
• Какой API требуется для параметризации работы нашего алгоритма?
  
• Как реализовать требуемый функционал в нашем конкретном контексте использования?

public interface MyCalculator {
  public Result calculate(Input input);
}

public class BasicCalculator implements MyCalculator {
  @override
  public Result calculate(Input input) {
    return Calculator.calculate(input);
  }
}

/**
 * An implementation of the calculator that logs input and output of the operations performed
 * by another implementation of the calculator.
 */
public final class LoggingCalculator implements MyCalculator {
  private final MyCalculator peer;
  private final Logger logger;

  /**
   * Creates a new calculator.
   * @param peer the actual calculation logic.
   * @param logger logger to write information about the calls.
   */
  public LoggingCalculator(MyCalculator peer, Logger logger) {
    this.peer = peer;
    this.logger = logger;
  }

  
  @override
  public Result calculate(Input input) {
    logger.info("Calling the calculate method with input {}".format(input));
    try {
      final Result res = peer.calculate(input);
      logger.info("Got the result of {}".format(res));
      return res;
    } catch (RuntimeException e) {
      logger.error("Internal error on calling calculate with the input {}".format(input), e);
      throw e;
    } catch (Error e) {
      logger.fatal("Fatal error calling calculate with input {}".format(input), e);
      throw e;
    }
  }
}

/** 
 * An implementation of calculator that collects some basic stats about the calls to the calculation method.
 * Use `metrics` of this instance to get access to the metrics exporter.
 */
public final class MetricsCalculator implements MyCalculator {
  private final MyCalculator peer;
  private final long slowpokeLimit;
  private final AtomicLong startCount = new AtomicLong();
  private final AtomicLong successCount = new AtomicLong();
  private final AtomicLong failureCount = new AtomicLong();
  private final AtomicLong slowpokeCount = new AtomicLong();
 
  /** 
   * Creates a new calculator that collects basic metrics.
   * @param peer actual calculation logics (for which metrics are collected).
   * @param slowpokeLimitMs time limit (in milliseconds) after which the calculation will be
   *   marked as "slow". "Slow" calls contribute to both successful and slow operation counters.
   */
  public MetricsCalculator(MyCalculator peer, long slowpokeLimitMs) {
    this.peer = peer;
    this.slowpokeLimit = slowpokeLimitMs;
  }


  public final MetricsExporter metrics = new MetricsExporter() {
    @Override
    public void writeTo(MetricsWriter writer) {
      writer.addValue("started", startCount.get());
      writer.addValue("successes", successCount.get());
      writer.addValue("failures", failureCount.get());
      writer.addValue("slowpokes", slowpokeCount.get());
    }
  }

  @override
  public Result calculate(Input input) {
    startCount.incrementAndGet();
    final long startTime = System.currentTimeMillis();
    try {
      final Result res = peer.calculate(input);
      final endTime = System.currentTimeMillis();
      successCount.incrementAndGet();
      if (endTime - startTime > slowpokeLimit)
        slowpokeCount.incrementAndGet();
    } catch (RuntimeException e) {
      failureCount.incrementAndGet();
      throw e;
    } catch (Error e) {
      failureCount.incrementAndGet();
      throw e;
    }
  }
}

case class Parameters private(...)

object Parameters {
  def someConfig(param1: Int, param2: Int, param3: Int, param5: Int = 42): Parameters = ...
  def someOtherConfig(param1: Int, param2: Int, param3: Int, param4: String, param5: Int = 42, param6: Int, param7: Int): Parameters = ...
}

static int Calculate(int x);

static int Calculate(int x, int y, int z, double a, out string c);

static int Calculate(int x, int y, int z, double a, out string c)
{
   int tmp1 = CalculateSomething(x, y, z);
   int tmp2 = CalculateSomethingElse(tmp1, z, a);
   c = CalculateSomeAuxiliaryOutput(tmp1, tmp2);
   return tmp2;
}

class Calculator
{
    readonly int X, Y, Z, A;
    public string C{get; private set;}
    public Calculator(int x, int y, int z, double a) {...}

    private int CalculateSomething();

    public int Calculate()
    {
       int tmp1 = CalculateSomething();
       int tmp2 = CalculateSomethingElse(tmp1);
       CalculateSomeAuxiliaryOutput(tmp1, tmp2);
       return tmp2;
    }

}

            for (;;)
            {
                caclulator = GetCaclulator();
                caclulator.Calculate(data);
            }

var result = Calculator.Сalculate(data)

var result = Сalculate(data)

var calculator = new Calculator();
var result = calculator.calculate(data);

E>var result = Calculator.Сalculate(data)
E>

E>var result = Сalculate(data)
E>

E>var calculator = new Calculator();
E>var result = calculator.calculate(data);
E>

var result = new Calculator().calculate(data);

Only a Sith deals in absolutes
Of course, there are exceptions to my dislike of static methods. True utility classes that do not pose any risk to bloat are excellent cases for static methods — System.Convert as an example. If your project is a one-off with no requirements for future maintenance, the overall architecture really isn't very important — static or non static, doesn't really matter — development speed does, however.

SP>В общем, какой язык, такие и программисты

name : string;