Java中的变量继承

Question

我有一个 Super 类和一堆子类。我希望在每个子类中都有一个具有相同名称的字段，但我不希望它在超类中定义，或者至少我不想使用该值。这就是我现在所拥有的

public abstract class Big {

    public String tellMe = "BIG";

    public Big() {}

    public void theMethod() {
        System.out.println ("Big was here: " + tellMe() + ", " + tellMe);
    }
    public String tellMe() {
        return tellMe;
    }
}

public class Little extends Big{

    public String tellMe = "little";
    public Little(){}

    public String tellMe() {
        return "told you";
    }
    public static void main(String [] args) {
        Little l = new Little();
        l.theMethod();
    }
}

当我运行 Little 时，这是输出

Big 在这里：告诉过你，BIG

我不确定为什么在tellMe 指的是“BIG”时打印出“告诉你”。怎么可能两者都是真的？

我的问题是我希望方法 tellMe() 在 Big 中，并在所有子类中定义变量 tellMe（它将实际返回）。我可以让它工作的唯一方法是正如我所写的那样，通过重写每个子类中的 tellMe() 方法。但这不是违背了继承的全部目的吗？？？请帮忙

编辑：我不在我的子类中使用构造函数。我想要的只是一个可以在所有子类中设置的字段和一个使用这些值的超类中的方法。我不明白为什么这是不可能的，因为每个子类都必须实现它，所以这是有道理的......如果这根本不可能，请告诉我

Answer 1

与方法不同，字段不是虚拟的。因此，在层次结构中声明与另一个类中的字段同名的字段是一个坏主意。 theMethod 中引用的字段总是来自Big （即，当您声明具有相同名称的字段时，它只是在替换类的范围内隐藏旧字段，但不会替换它)。

一种解决方案是重写从当前类获取字段的方法：

在theMethod 中，将tellMe 字段替换为getTellMe()，并为所有类覆盖getTellMe() 以返回正确的值（或隐藏超类字段的字段）。

Answer 2

您可以在Little的构造函数中覆盖Big.tellMe的值。

摆脱：

public String tellMe = "little";

并将Little 构造函数更改为：

public Little(){
    tellMe = "little";
}

此时，您也可以摆脱Little.tellMe()。

Answer 3

您正在做的是隐藏超类字段，而不是覆盖它，如Java documentation states。 并且还表示这样做不是一个好主意。

因此，动态查找不会像方法那样工作。如果从子类中读取变量，它将采用“其”字段值。 在头等舱，另一个。

你可以在 Java 中覆盖的是行为，所以我建议的是 定义一个方法

public String tellMe() {
  return "Whatever";
}

您可以在子类中覆盖以返回您需要的任何字符串。

Answer 4

您可以在 Big 中创建一个函数，而不是在 Big 中定义 tellMe（因为您说您不想在 Big 中定义/使用该值）：

public abstract String tellMeString();

并像这样在每个子类中定义它（对于 Little）：

public String tellMeString()
{
    return "Little";
}

那么该方法就可以执行了：

System.out.println ("Big was here: " + tellMe() + ", " + tellMeString());

在这种情况下，您根本不必定义变量“tellMe”，只需在每个子类中覆盖 tellMeString 即可返回不同的字符串。

Answer 5

字段未按预期继承。您可以从子类访问超类的字段（除非它是私有的）。但是您不能“覆盖”字段。这就是为什么在超类Big 中实现的方法使用的tellMe 使用在同一类中定义的变量。

如果你想要继承使用方法。例如，您可以实现方法“tellMe()”，在超类中返回"BIG"，在子类中返回"little"：

class Big {
    protected String tellMe() {
        return "BIG";
    }
}
class Little {
    @Override
    protected String tellMe() {
        return "Little";
    }
}

您也可以在构造函数中初始化变量tellMe：

class Big {
    private String tellMe;
    public Big() {
        this("BIG");
    }
    protected Big(String tellMe) {
        this.tellMe = tellMe;
    }
    protected String tellMe() {
        return "BIG";
    }
}
class Little {
    public Little() {
         super("Little");
    }
}

现在new Little().tellMe() 将返回“Little”：超类中的变量在构造对象时被初始化；超类中定义的方法返回了这个变量。

Answer 6

方法可以被覆盖，字段在它们被调用的范围内是可见的。

static class Big {
    String field = "BIG";
    String bark()   { return "(big bark)"; }

    void doIt() {
        System.out.format("field(%s) bark(%s)\n", field,bark());
    }
    void doIt2()    {
        System.out.format("2:field(%s) bark(%s)\n", field,bark());
    }
}

static class Small extends Big {
    String field = "small";
    String bark()   { return "(small bark)"; }
    void doIt2()    {
        System.out.format("2:field(%s) bark(%s)\n", field,bark());
    }
}

public static void main(String... args) {

    Big b = new Big();
    b.doIt();
    b.doIt2();

    Small s = new Small();
    s.doIt();
    s.doIt2();
}

输出是：

field(BIG) bark((big bark))
2:field(BIG) bark((big bark))
field(BIG) bark((small bark))
2:field(small) bark((small bark))

由于 doIt() 是在 Big 类中定义的，所以它总是会看到 Big 版本的字段。 doIt2() 在 Big 中定义，但在 Small 中被覆盖。 Big.doIt2() 看到的是 Big 版本的字段，Small.doIt2() 版本看到的是 Small 版本的字段。

正如其他人指出的那样，这样做是一个非常糟糕的主意 - 更好的方法是在子类构造函数中设置新值，或者使用被覆盖的方法。