Question

我试图找出访问抽象类的私有字段的正确方法，然后在扩展抽象类的类中使用它。

以下是我的抽象类

流程类（摘要）：

public abstract class Process implements Runnable {
  private final Properties props;
  private final String processName;

  public Process(String processName, Properties props) {
    this.processName = processName;
    this.props = props;
  }

  public abstract void shutdown();

  public Properties getProps() {
    return props;
  }

  public String getProcessName() {
    return processName;
  }
}

以下是我如何扩展上面的抽象类并使用props属性对象的一种方法。

ProcessA课程：

public class ProcessA extends Process {
  private ProcessConsumer<byte[], byte[]> consumer;

  public ProcessA(String processName, Properties props) {
    super(processName, props);
  }

  @Override
  public void run() {
    // is this the right way?
    String processName = getProcessName();
    Properties props = getProps();
    consumer = new ProcessConsumer<>(props);

    // .. some other code with try catch block
    // using processName and consumer
  }

  @Override
  public void shutdown() {
    consumer.wakeup();
  }
}

以下是我如何扩展上面的抽象类并使用属性对象的第二种方法。

ProcessB课程：

public class ProcessB extends Process {
  private final ProcessConsumer<byte[], byte[]> consumer;

  public ProcessB(String processName, Properties props) {
    super(processName, props);
    // is this the right way to use props object?
    this.consumer = new ProcessConsumer<>(props);
  }

  @Override
  public void run() {
    String processName = getProcessName();

    // .. some other code with try catch block
    // using processName and consumer
  }

  @Override
  public void shutdown() {
    consumer.wakeup();
  }
}

我想在制作props对象时使用ProcessConsumer属性，但我很困惑使用props对象的正确方法是什么？我应该在run方法中的抽象类上调用getProps方法，然后使用它吗？或者只是把它放在构造函数中并在那里构建它？

有什么区别，什么是正确的方式？

Answer 1

扩展抽象类时，子类继承私有字段，但它们不可访问。因为私有字段只能在其定义的类的范围内访问。

因此，要初始化您使用super的私有字段，以及访问它们。您可以将super视为this的母亲：

public abstract class AbstractProcess{
    private final String processName;
    public AbstractProcess(String name){
        processName = name;
    }

    public String getName(){
        return processName;
    }

}




public class MyProcess extends AbstractProcess{

     public MyProcess(ProcessName name){
        //like you did is true
        super(name);

     }

    //now to access them
    public String getName(){
        return super.getName();
    }

}

此外，您可以使用protected遍历整个私有+继承事物。 protected字段类似于私有field，但是由子类继承并可访问。所以你可以打电话给this.someProtectedField（注意它不是＆＃34; getter＆＃34;函数）而不是super.getSomePrivateField()

我希望这就是你所要求的，而且我已经说清楚了。

Answer 2

你的两个解决方案都可行。但我会使用完全其他解决方案：

 public abstract class Process implements Runnable {
    private final Properties props;
    private final String processName;

    public Process(String processName, Properties props) {
        this.processName = processName;
        this.props = props;
    }

    protected abstract void shutdown();
    protected abstract void run(String processName, Properties props);

    @Override
    public final void run() {
        run(processName, props);
    }

}

public class ProcessA extends Process {
    private ProcessConsumer<byte[], byte[]> consumer;

    public ProcessA(String processName, Properties props) {
        super(processName, props);
    }

    @Override
    public void shutdown() {
        consumer.wakeup();
    }

    @Override
    protected void run(String processName, Properties props) {
        consumer = new ProcessConsumer<>(props);
    }
}

所以Process只有一个公共方法，你使run方法最终，所以没有人可以覆盖它。你可以通过另一种方法得到params。

访问抽象类字段的正确方法？

2 个答案: