java - 从构造函数调用抽象方法的安全替代方案

Question

我知道这是一个坏主意，并且会导致错误。问题是，我需要“预期的”行为。

“低”:

// simplified example
abstract class Low {        
    String name;

    public Low(String name) {
        this.name = name;
    }       

    public Low(int id) {
        this.name = getNameForId(id);
    }  

    public Low() {} // will be loaded later

    @Override
    public String toString()
    {
        return name;
    }   

    public void load(InputStream in) {
        // --- grab ID from stream ---
        this.name = getNameForId(id);
    }

    protected abstract String getNameForId(int id);
}

和“高”:

class High extends Low {        
    public High(int id) { super(id); }      
    public High(String name) { super(name); } 
    public High() {} // will be loaded later

    @Override
    protected String getNameForId(int id)
    {
        return Registry.getName(id);
    }
}

请注意，在这种特殊情况下，它会正常工作。但一旦重写方法需要使用某个字段，它就会崩溃。

如何做得更好？

Answer 1

您希望将 ID 名称的加载与 Low 和 High 对象分开。引入一个接口(interface)，用于加载给定 ID 的名称。

public interface NameProvider
{
  String getNameForId(String id);
}

为每个名称来源添加具体实现。

public class InputStreamNameProvider implements NameProvider
{
  private InputStream inputStream;

  // Constructor 

  public String getNameForId(String id)
  {
     // return name loaded via inputStream
  }
}

public class RegistryNameProvider implements NameProvider
{
  public String getNameForId(String id)
  {
     return Registry.getName(id);
  }
}

然后，您可以向 Low 添加一个新的构造函数，该构造函数将 NameProvider 和 String id 作为参数

public Low(NameProvider provider, String id)
{
  this(provider.getNameForId(id));
}

甚至在构造 Low 或 High 实例之前使用名称提供程序。主要思想是将 ID 的名称加载与 Low 和 High 对象分开。