Antes de tudo, li a resposta útil de erickson para"Por que não consigo definir um método estático em uma interface Java?". Esta questão não é sobre o "porquê", mas sobre o "como então?".

Edit: meu exemplo original foi mal posicionado, mas vou deixar abaixo.

Embora agora eu esteja convencido de que, na maioria dos casos, o que eu quero fazer é um exagero, há um cenário em que isso pode ser necessário:

Eu vou pegar oParametricFunction exemplo novamente. Agora vamos assumir uma função complicada, como aFunções de Bessel, onde uma tabela de pesquisa é apropriada. Isso precisa ser inicializado, para que as duas opções passem os parâmetros diretamente ao construtor ou forneçam uminit(double[] parameters). Este último tem a desvantagem de quegetValue(double x) deve verificar a inicialização de todas as chamadas (ou oArrayIndexOutOfBoundsException deve ser considerado como verificação de inicialização); portanto, para aplicativos de tempo crítico, prefiro o método construtor:

interface ParametricFunction {
  public double getValue(double x);
}

class BesselFunction implements ParametricFunction {
  public BesselFunction(double[] parameters) { ... }
  public double getValue(double x) { ... }
}

O que toca em outro problema, a impossibilidade de construtores em interfaces. Qual seria uma boa solução lá? Claro que eu poderia usar oinit(double[] parameters) abordagem, mas mencionei minha razão pela qual não.
(Edit: OK, aqui seria uma classe abstrata que implementa a interface)

Agora vamos assumir oParametricFunction permite apenas determinados parâmetros, por exemplo inteiros positivos. Como verificar a validade dos parâmetros transmitidos ao construtor? Jogando umIllegalArgument-exception seria uma possibilidade, mas umcheckParametersValidity(double[] parameters) parece muito mais conveniente. Mas a verificação dos parâmetros precisa ser feita antes da construção, por isso deve ser um método estático. E é aí que eu realmente gostaria de saber uma maneira de garantir que todas as classes que implementam oParametricFunction A interface define esse método estático.

Eu sei que este exemplo é bastante artificial, e a razão para não simplesmente usar uminit método através da interface é discutível, eu ainda gostaria de saber a resposta. Considere uma questão acadêmica se você não gosta.

(exemplo original)

Então, basicamente, quero que uma interface forneça os métodos usuais e, por exemplo, umagetSimilarObject método. Para um exemplo (inventado)

public interface ParametricFunction {
  /** @return f(x) using the parameters */
  static abstract public double getValue(double x, double[] parameters);

  /** @return The function's name */
  static abstract public String getName();

  /** @return Whether the parameters are valid  [added on edit] */
  static abstract public boolean checkParameters(double[] parameters);
}

e depois

public class Parabola implements ParametricFunction {
  /** @return f(x) = parameters[0] * x² + parameters[1] * x + parameters[2] */
  static public double getValue(double x, double[] parameters) {
    return ( parameters[2] + x*(parameters[1] + x*parameters[0]));
  }
  static public String getName() { return "Parabola"; }
  // edit:
  static public boolean checkParameters(double[] parameters) {
    return (parameters.length==3);
  }
}

Como isso não é permitido no atual padrão Java, qual é a coisa mais próxima disso?

A idéia por trás disso é colocar váriosParametricFunctions em um pacote e use o Reflection para listar todos, permitindo que o usuário escolha, por exemplo qual traçar. Obviamente, poderia-se fornecer uma classe loader contendo uma matriz dos recursos disponíveis.ParametricFunctions, mas toda vez que um novo é implementado, é preciso lembrar de adicioná-lo também.

edit: Um exemplo para chamá-lo é

public double evaluate(String fnName, double x, double parameters) throws (a lot) {
  Class<ParametricFunction> c = (Class<ParametricFunction>) ClassLoader.getSystemClassLoader().loadClass(fnName);
  Method m = c.getMethod("getValue", x, parameters);
  return ((double) m.invoke(null));
}

e chamandoevaluate("Parabola", 1, new double[]{1,2,0});.