Java继承将公共getter移动到父级

Question

我有子课程，使用组合与类也是孩子。如何在每个子类中使用类似的getter，而不是将组合类的getter移动到父类。

public class child1 extends Parent {
   private CoolObjectTypeAAA coolObject;
   //coolObject getter
}

public class child2 extends Parent {
   private CoolObjectTypeBBB coolObject;
   //coolObject getter
}

public class CoolObjectTypeAAA extends CoolObject {
}

public class CoolObjectTypeBBB extends CoolObject {
}

public abstract class Parent {
    //would like to have a single CoolObject getter here in parent that returns the appropriate cool object of each child.
}

这是可能的还是我需要在每个儿童班中都有类似的吸气剂？

Answer 1

这个怎么样：

abstract class Parent<T extends CoolObject> {
    protected T mCoolObject;
    public Parent(T coolObject) {
        mCoolObject = coolObject;
    }

    public T getCoolObject() {
        return mCoolObject;
    }
}

class Child1 extends Parent<CoolObjectTypeAAA> {
    public Child1(CoolObjectTypeAAA coolObject) {
        super(coolObject);
    }
    public void demoType() {
        // This type checks as the return type of getCoolObject() has been refined to CoolObjectTypeAAA
        CoolObjectTypeAAA co = this.getCoolObject();
    }
}

class Child2 extends Parent<CoolObjectTypeBBB> {
    public Child2(CoolObjectTypeBBB coolObject) {
        super(coolObject);
    }
    public void demoType() {
        // This type checks as the return type of getCoolObject() has been refined to CoolObjectTypeBBB
        CoolObjectTypeBBB co = this.getCoolObject();
    }
}

abstract class CoolObject { }

class CoolObjectTypeAAA extends CoolObject { }

class CoolObjectTypeBBB extends CoolObject { }

基本上你让子类指定它使用的CoolObject的任何特定子类型，以便它可以优化getter的返回类型，但是你可以在超类中实现getter。

Answer 2

我建议看看abstract factory pattern，因为这似乎是你想要完成的。正确实现它涉及多个抽象类和许多子类，但它并不像看起来那么令人生畏。

你要做的事情基本上看起来像是一个紧凑的版本，但它通常不是一个很好的方法，因为它导致难以遵循在父类和子类之间来回跳转的OO意大利面条代码。

请记住，您已将Parent定义为抽象的原因。

我怀疑你的目标是最大化代码重用，通常当我看到这种代码时，因为有一些常见的“CoolObject”初始化代码，你不想在子类中复制。

在这种情况下，通常最好在父类中编写一个通用的“CoolObject”私有或受保护的初始化程序，但仍然在子类中构造特定类型的CoolObject，然后在从子类返回之前通过父类方法初始化它。

在这种情况下，由于它是一个getter，除了返回私有对象之外，可能没有任何其他内容。如果是这种情况，那么最好的方法是在Parent中将泛型getter定义为abstract，然后在每个子节点中重新定义。这个问题的主要问题是，无论您在何处使用此代码，都需要不断地对您期望的特定CoolObject类型进行类型转换。

因此，即使你在Parent中提供抽象的CoolObject getter或具体的CoolObject getter，你也可能最终想要为特定的CoolObject类型提供具体的getter实现。

在设计这样的东西时要记住的是它将如何被使用。

如果目标是提供各种类型的CoolObject的抽象，那么您基本上使用策略模式。在这种情况下，不需要能够将变量转换为CoolObject的子类型。在这种情况下，非特定类型的getter（抽象或具体）是可行的。

但是，拥有Parent的两个特定子类，并不觉得这就是你想要的。我再次建议看看abstract factory pattern，因为这看起来更像你想做的事情。