Question

我想根据她所调用的类使用一个常量的方法。很抱歉这个错误的解释，这是一个例子：

public class Mom{
   public void execute(parameters){
      // Some actions
       String nf = String.format(C_CARS)
   }
}

public class Son1 extends Mom{
   private static final String C_CARS=" myFormat " 
}


public class Son2 extends Mom{
   private static final String C_CARS=" myFormat2 " 
}

public static void main(String[] args){
   Son1 son1=new Son1();
   Son2 son2=new Son2();
   son1().execute(myparameters);
   son2().execute(myparameters);
}

我想做那样的事，有办法吗？这里的问题是C_CARS在Mom Class中是未知的。

Answer 1

这不是继承在Java中的工作方式。

您需要保证Mom的所有实例都有值。通过实例方法执行此操作，例如

 public abstract class Mom{
   public void execute(parameters){
     String nf = String.format(getCCars());
   }
   protected abstract String getCCars();
 }

然后在子类中实现：

class Son1 extends Mom {
  @Override protected String getCCars() {
    return "something";
  }
}

你的面向对象设计有一些东西。

请记住：Son1类的每个实例也是Mom的实例。但在现实世界中，大多数儿子都不是母亲。

extends在这里使用不正确。

Answer 2

您无法以这种方式覆盖变量。改为使用方法：

abstract public class Mom {
    abstract protected String cCars();

    public void execute(parameters){
       // Some actions
       String nf = String.format(cCars())
    }
}

public class Son1 extends Mom{
    private static final String C_CARS=" myFormat ";

    @Override
    protected String cCars() {
        return C_CARS;
    }
}

或者，您可以在Mom中提供默认实现，然后无需将类和方法抽象化。

Answer 3

不要使用static，这会带来麻烦。

public class Mom {
    private final String cCars;
    protected Mom(String cCars) {
        this.cCars = cCars;
    }
    public void execute(parameters){
        // Some actions
        String nf = String.format(cCars)
    }
}

public class Son1 extends Mom {
    public Son1() {
        super(" myFormat ");
    }
}


public class Son2 extends Mom {
    public Son2() {
        super(" myFormat2 ");
    }
}

Answer 4

这不起作用，因为超类无法访问其子类的成员。此外，您不能覆盖变量，就像您可以覆盖方法。请尝试使用以下代码：

public static abstract class Mom {
    public void execute() {
        System.out.println(getCCars());
    }

    abstract String getCCars();
}

public static class Son1 extends Mom {

    @Override
    String getCCars() {
        return " myFormat ";
    }
}

public static class Son2 extends Mom {

    @Override
    String getCCars() {
        return " myFormat2 ";
    }
}

public static void main(String[] args) {
    Son1 son1 = new Son1();
    Son2 son2 = new Son2();
    son1.execute();
    son2.execute();
}

这就是你在java中的方式。

我已经测试了上面的代码。它会编译并产生所需的结果。

Answer 5

标记为static的字段属于类而不是实例。此外，C_CARS中的Son1与C_CARS中的Son2无任何关联。

实现这一目标的一种方法是：
```
class Mom {
    public abstract String getCCars();
}
```
然后Mom的每个方兴都必须覆盖getCCars()方法。

您还可以在cCars的构造函数中接受字符串Mom。然后，每个方兴都必须调用Mom中定义的超级构造函数：

class Mom {

    final String cCars;

    Mom(String cCars) {
        this.cCars = cCars;
    }

    void execute(String parameters) {
        System.out.println(this.cCars);
    }
}

class Son1 {

    Son1() {
        super("MyFormat"); // We have to call the super constructor
    }
}

在类extends中使用静态值

5 个答案: