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

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();
  }
}

我想在制作ProcessConsumer对象中使用props属性，但是我很困惑使用props对象的正确方法是什么？我应该在运行方法中的抽象类上调用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（请注意，它不是" Getter"功能），而不是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);
    }
}

因此，该过程只有一种公共方法，您将进行运行方法最终，因此没有人可以覆盖它。您可以在其他运行方法中获得参数。