Question

现在，我有一个Preprocessor类，它生成一堆实例变量映射，以及一个Service类，它有一个setPreprocessor(Preprocessor x)方法，所以{的一个实例{1}}类能够访问预处理器生成的映射。

目前，我的Service课程需要连续调用三种方法;为简单起见，我们称他们为Service，executePhaseOne和executePhaseTwo。这三个方法中的每一个都实例化/修改executePhaseThree个实例变量，其中一些是指向Service实例的Service对象的指针。

我的代码现在有这个结构：

Preprocessor

为了更好地组织我的代码，我想将每个Preprocessor preprocessor = new Preprocessor(); preprocessor.preprocess(); Service service = new Service(); service.setPreprocessor(preprocessor); service.executePhaseOne(); service.executePhaseTwo(); service.executePhaseThree();调用放在它自己的executePhaseXXX()的单独子类中，并保留父类{{1}中所有阶段的公共数据结构}。然后，我想在Service父类中有一个Service方法，它连续执行所有三个阶段：

execute()

编辑：

问题是，如何在Service父类中编写class ServiceChildOne extends Service { public void executePhaseOne() { // Do stuff } } class ServiceChildTwo extends Service { public void executePhaseTwo() { // Do stuff } } class ServiceChildThree extends Service { public void executePhaseThree() { // Do stuff } }方法？我有：

execute()

但是，我的Service，public void execute() { ServiceChildOne childOne = new ServiceChildOne(); ServiceChildTwo childTwo = new ServiceChildTwo(); ServiceChildThree childThree = new ServiceChildThree(); System.out.println(childOne.preprocessor); // prints null childOne.executePhaseOne(); childOne.executePhaseTwo(); childOne.executePhaseThree(); }和childOne个对象无法访问位于父类childTwo中的childThree实例变量......我怎么能解决这个问题呢？

Answer 1

对protected的{{1}}实例变量使用Preprocessor修饰符，如下所示：

Service

然后public class Service { protected Preprocessor preprocessor; }的每个子类都有一个Service。

Answer 2

您的preprocessor应该是protected或public，以便能够获得孩子的访问权限。您可以阅读有关修饰符here的信息。

<强>更新

new ServiceChildOne(new Preprocessor());
.....

class ServiceChildOne extends Service {

    public ServiceChildOne(Preprocessor preprocessor) {
       super.preprocessor = preprocessor;
    }

    public void executePhaseOne() {
        // Do stuff
    }
}

Answer 3

您可以在getPreprocessorInstance()类中提供Service之类的方法，以返回Preprocessor实例

Answer 4

看起来你的问题是你没有一个，而是四个Service的不同实例 - 每个实例都有自己的未初始化的基类变量副本。

目前我能想到的唯一解决方案是，首先，将您的服务成员变量设置为静态的相当差的设计 - 实际上，这意味着您一次只能拥有一个版本的服务。在我看来，更好的解决方案是不使处理阶段成为子类，而是使它们成为独立的类，将Service的实例作为参数。

编辑：有关快速示例，Service类可能如下所示：

class Service
{
    public Service() { ... }
    public Preprocessor getPreprocessor() { ... }
    public void setPreprocessor(Preprocessor preprocessor { ... }
    public Type2 getVariable2() { ... }
    public void setVariable2(Type2 variable2) { ... }
        ...
}

并且阶段类看起来像：

class ServicePhaseOne
{
    private Service m_dataHost;

    public ServicePhaseOne(Service dataHost)
    {
        m_dataHost = dataHost;
    }

    public void executePhaseOne()
    {
        // Do phase 1 stuff
    }
}

......等等阶段2和阶段3。

execute（）方法如下所示：

public void execute()
{
    ServicePhaseOne phaseOne = new ServicePhaseOne(this);
    ServicePhaseTwo phaseTwo = new ServicePhaseTwo(this);
    ServicePhaseThree phaseThree = new ServicePhaseThree(this);
    phaseOne .executePhaseOne();
    phaseTwo .executePhaseTwo();
    phaseThree .executePhaseThree();
}

从子类实例访问父类实例变量

4 个答案: