将常量类作为参数传递并存储它

Question

伪代码

提供的 sn-ps 将被视为伪代码。如果有不同的解决方案是解决此问题的标准方法，我持开放态度。

这是关于预期用途的：

一些澄清：

• 每个应用程序将使用一个且仅一个配置。它不会在运行时更改。
• Main.java 不允许@Override。
• Configuration.java 不能是 Interface，因为应为未覆盖的字段提供默认值。
• Configuration.java 将从其当前的两个领域大幅增长。使构建器模式变得非常混乱。

Configuration.java

public class Configuration
{
    public static int getFoo () { return 1; }
    public static int getBar () { return 2; }
}

UserDefinedConfiguration.java

public class UserDefinedConfiguration extends Configuration
{
    @Override
    public static int getFoo () { return 3; }
}

Main.java

public final class Main {
    private final Configuration config;

    // default configuration
    public Main () {
        this (Configuration.class);
    }

    // user-defined configuration
    public Main (Class<? extends Configuration> config) {
        this.config = config;
    }

    // dummy-test
    public void printFoo () {
        System.out.println(config.getFoo());
    }
}

现在回到主要问题，如何做到这一点？如果没有（或通过Configuration）getFoo() 应该返回1，如果通过UserDefinedConfiguration 然后3。

实现它的一种方法是存储Configuration 的实例。但是，当所有 getter 都是 static 时，它感觉是多余的。也不将它们设为static 也没有多大意义。

注意：This is taken into account.

Answer 1

除非使用脏反射，否则恐怕您将不得不使用实例而不是类。来自@JonSkeet：

单例允许访问单个创建的实例 - 该实例 （或者更确切地说，对该实例的引用）可以作为参数传递 到其他方法，并视为普通对象。

静态类只允许静态方法。

这正是您想要做的：将配置作为参数传递。

---

我将创建一个定义默认值的抽象类：

public abstract class Configuration {
  public int getFoo() { return 1; }
  public int getBar() { return 2; }
}

然后，每个具体配置一个单例：

public final class DefaultConfiguration extends Configuration {
  public static final Configuration INSTANCE = new DefaultConfiguration();
  private DefaultConfiguration() {}
  // nothing to override, use the default values
}

public final class UserDefinedConfiguration extends Configuration {
  public static final Configuration INSTANCE = new UserDefinedConfiguration();
  private UserDefinedConfiguration() {}
  @Override public int getFoo() { return 3; } // specific `foo` value
}

最后，在你的Main：

public class Main {
  private final Configuration config;
  public Main() { this(DefaultConfiguration.INSTANCE); }
  public Main(Configuration config) { this.config = config; }
}

---

另外，请注意 Java 8 允许在接口中实现默认方法； Configuration 可以是一个接口：

public interface Configuration {
    default int getFoo() { return 1; }
    default int getBar() { return 2; }
}

Answer 2

所以本质上，你需要一个类型而不是一个实例的多态性。在 Java 中，这通常使用泛型类型来完成：

class GenericMain<T extends Configuration>
{
    private final T config;
}

而且由于 Java 不允许默认的泛型参数，您必须定义另一个类来指定默认值：

class DefaultMain extends GenericMain<Configuration>
{
}

这些与您的 Main () 和 Main (Class<? extends Configuration> config) 构造函数一对一匹配。

---

或者，您可以存储Configuration 的实例并执行以下操作：

public class Configuration
{
    private final int foo = 1;
    private final int bar = 2;

    public final int getFoo () { return foo; }
    public final int getBar () { return bar; }

    public Configuration () {}

    protected Configuration (int foo) {
        this.foo = foo;
    }
}

public class UserDefinedConfiguration extends Configuration
{
    public UserDefinedConfiguration() {
        super(3);
    }
}