Question

我想在一个抽象类中实现一个方法，该类由继承的类调用并使用它们的值。

例如：

abstract class MyClass{
    String value = "myClass";
    void foo(){System.out.println(this.value);}
}

public class childClass{
    String value="childClass";
    void foo(){super.foo();}
}

public static void main(String[] args){
    new childClass.foo();
}

这将输出“myClass”，但我真正想要的是输出“childClass”。这样我就可以在类中实现一个“通用”方法，当由其他类扩展时，它将使用这些类中的值。

我可以将值作为函数参数传递，但我想知道是否可以实现我所描述的“架构”。

由继承类调用的超级方法，它使用来自调用者的值本身，而不是通过参数传递值。

Answer 1

你可以这样做：

abstract class MyClass {

    protected String myValue() {
        return "MyClass";
    }

    final void foo() {
        System.out.println(myValue());
    }
}

public class ChildClass extends MyClass {
    @Override
    protected String myValue() {
        return "ChildClass";
    }
}

等等

Answer 2

这是一个组合优于继承的地方

public class Doer{
   private Doee doee;

   public Doer(Doee doee){
       this.doee = doee;
   }
   public void foo(){
       System.out.println(doee.value);
   }
}

public abstract class Doee{
    public String value="myClass"
}

public ChildDoee extends Doee{
    public String= "childClass"
}

...

//Excerpt from factory
new Doer(new ChildDoee);

Answer 3

您只希望value中的MyClass与childClass的实例不同。
为此，请更改childClass构造函数中的值：

public class childClass {
    public childClass() {
        value = "childClass";
    }
}

编辑：

如果你不能覆盖/替换构造函数，添加一个实例块（在构造函数之后执行，甚至是未声明的“默认”构造函数）：

public class childClass {
    {
        value = "childClass";
    }
}

Answer 4

我相信你在问这是否可行：

public class MyClass {
  void foo() {
    if (this instanceof childClass) // do stuff for childClass
    else if (this intanceof anotherChildClass) // do stuff for that one
  }
}

所以答案是“是的，它是可行的”，但非常建议反对a）尝试重新实现多态而不是使用它b）违反抽象类和具体类之间的分离。

使用来自儿童的值的超级课程

4 个答案:

编辑：