Question

伪代码

提供的片段将被视为伪代码。如果有一种不同的解决方案是标准解决此问题的方法，我愿意接受。

这与预期用法有关：

一些澄清：

每个应用程序只使用一个配置。它不会在运行时更改。
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);
    }
}

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

2 个答案: