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

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

下面是我的抽象类

过程类（摘要）：

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

Properties对象的一种方法

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

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

公共类进程扩展进程{
私人消费者；
公共进程A（字符串进程名、属性道具）{
超级（进程名、道具）；
}
@凌驾
公开募捐{
//这条路对吗？
字符串processName=getProcessName（）；
Properties=getProps（）；
消费者=新流程消费者（道具）；
//…使用try-catch块的其他代码
//使用processName和consumer
}
@凌驾
公共空间关闭（）{
consumer.wakeup（）；
}
}

下面是我如何扩展上述抽象类并使用properties对象的第二种方法

ProcessB类：

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

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

公共类ProcessB扩展进程{
私人最终消费者；
publicprocessB（字符串processName、属性props）{
超级（进程名、道具）；
//这是使用道具对象的正确方法吗？
this.consumer=新流程消费者（道具）；
}
@凌驾
公开募捐{
字符串processName=getProcessName（）；
//…使用try-catch块的其他代码
//使用processName和consumer
}
@凌驾
公共空间关闭（）{
consumer.wakeup（）；
}
}

我想在制作

ProcessConsumer

对象时使用

props

属性，但我不知道使用

props

对象的正确方法是什么？我应该在run方法中调用抽象类上的

getProps

方法，然后使用它吗？或者只是把它放在构造器中，然后在那里构建它

---

什么是区别，什么是正确的方法？

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

因此，要初始化私有字段，您可以使用

super

，以及访问它们。您可以将

super

视为此

的母亲：

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
绕过整个私有+继承的问题。受保护的
字段类似于私有
字段
，但由子类继承和访问。因此，您可以只调用
this.someProtectedField
（注意它不是一个“getter”函数），而不是
super.getSomePrivateField（）

我希望这就是您要问的，并且我已经说得很清楚了。
当您扩展抽象类时，子类继承私有字段，但它们不可访问。因为私有字段只能在定义它们的类的范围内访问

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

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
绕过整个私有+继承的问题。受保护的
字段类似于私有
字段
，但由子类继承和访问。因此，您可以只调用
this.someProtectedField
（注意它不是一个“getter”函数），而不是
super.getSomePrivateField（）

我希望这就是你要问的，并且我已经说得很清楚了。
你的两种解决方案都能奏效。
但我会使用完全不同的解决方案：

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

公共抽象类进程实现可运行{
私人最终财产道具；
私有最终字符串processName；
公共进程（字符串processName、属性props）{
this.processName=processName；
this.props=props；
}
受保护的抽象无效关机（）；
受保护的抽象无效运行（字符串processName、属性props）；
@凌驾
公开最终作废运行（）{
运行（进程名、道具）；
}
}
公共类ProcessA扩展了进程{
私人消费者；
公共进程A（字符串进程名、属性道具）{
超级（进程名、道具）；
}
@凌驾
公共空间关闭（）{
consumer.wakeup（）；
}
@凌驾
受保护的无效运行（字符串processName、属性props）{
消费者=新流程消费者（道具）；
}
}

所以这个过程只有一个公共方法，
您将run方法设置为final，因此没有人可以覆盖它。
您可以在另一个run方法中获得参数。
两个解决方案都可以工作。
但我会使用完全不同的解决方案：

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

公共抽象类进程实现可运行{
私人最终财产道具；
私有最终字符串processName；
公共进程（字符串processName、属性props）{
this.processName=processName；
this.props=props；
}
受保护的抽象无效关机（）；
受保护的抽象无效运行（字符串processName、属性props）；
@凌驾
公开最终作废运行（）{
运行（进程名、道具）；
}
}
公共类ProcessA扩展了进程{
私人消费者；
公共进程A（字符串进程名、属性道具）{
超级（进程名、道具）；
}
@凌驾
公共空间关闭（）{
consumer.wakeup（）；
}
@凌驾
受保护的无效运行（字符串processName、属性props）{
消费者=新流程消费者（道具）；
}
}

所以这个过程只有一个公共方法，
您将run方法设置为final，因此没有人可以覆盖它。
您可以在另一个run方法中获得参数。
这不是我要问的。我的问题是如何访问抽象c的
道具