隐藏类的实例变量

Question

我想知道为什么 Java 对于具有相同名称的实例变量的超类和子类有这种奇怪的行为。

假设我们有以下类定义：

class Parent {
    int var = 1;
}

class Child extends Parent {
    int var = 2;
}

通过这样做，我们应该隐藏了超类的变量 var。如果我们没有明确指定通过 super 调用访问 Parent 的 var 的方法，那么我们永远无法访问< code>var 来自子实例。

但是当我们进行强制转换时，这种隐藏机制就会崩溃：

Child child = new Child();
Parent parent = (Parent)child;
System.out.println(parent.var); // prints out 1, instead of 2

这不是完全规避了字段隐藏的全部意义吗？如果真是这样的话，那这个想法岂不是完全没用了？

编辑：我特别指的是这篇文章 Java 教程。它提到

子类内，超类中的字段不能被引用 就其简单的名字而言。相反，该字段必须通过超级访问...

从我读到的内容来看，这似乎暗示 Java 开发人员在执行此操作时考虑到了某种技术。尽管我同意这是一个相当模糊的概念，并且一般来说可能是不好的做法。

Answer 1

在 Java 中，数据成员不是多态的。这意味着 Parent.var 和 Child.var 是两个不同的变量，但碰巧具有相同的属性姓名。您在任何意义上都没有“重写”派生类中的 var ；正如您自己发现的那样，这两个变量都可以彼此独立地访问。

最好的方法实际上取决于您想要实现的目标：

1. 如果 Parent.var 对 Child 不可见，请将其设置为 private 。
2. 如果 Parent.var 和 Child.var 是两个逻辑上不同的变量，请为它们指定不同的名称以避免混淆。
3. 如果 Parent.var 和 Child.var 在逻辑上是同一变量，则为它们使用一个数据成员。

Answer 2

字段隐藏的“要点”仅仅是指定代码的行为，该行为为变量提供与其超类中的变量相同的名称。

它并不是要用作真正隐藏信息的技术。这是通过将变量设为私有来完成的......我强烈建议在几乎所有情况下使用私有变量。字段是一个实现细节，应该对所有其他代码隐藏。

Answer 3

这种情况称为变量隐藏，当子类和父类都有同名变量时，子类的变量会隐藏父类的变量，这个过程称为变量隐藏。

在Java中，变量不是多态的，变量隐藏与方法覆盖不同

虽然变量隐藏看起来像覆盖变量，类似于方法覆盖，但事实并非如此，覆盖仅适用于方法，而隐藏适用于变量。

在方法重写的情况下，重写的方法完全取代了继承的方法，因此当我们尝试通过持有子类的对象从父类的引用访问该方法时，子类中的方法将被调用。

但是在变量隐藏中，子类隐藏了继承的变量而不是替换，因此当我们尝试通过持有子对象从父类的引用访问变量时，将从父类访问该变量。

public static void main(String[] args) throws Exception {

    Parent parent = new Parent();
    parent.printInstanceVariable(); // Output - "Parent`s Instance Variable"
    System.out.println(parent.x); // Output - "Parent`s Instance Variable"

    Child child = new Child();
    child.printInstanceVariable();// Output - "Child`s Instance Variable, Parent`s Instance Variable"
    System.out.println(child.x);// Output - "Child`s Instance Variable"

    parent = child; // Or parent = new Child();
    parent.printInstanceVariable();// Output - "Child`s Instance Variable, Parent`s Instance Variable"
    System.out.println(parent.x);// Output - Parent`s Instance Variable

    // Accessing child's variable from parent's reference by type casting
    System.out.println(((Child) parent).x);// Output - "Child`s Instance Variable"
}

正如我们在上面看到的，当子类中的实例变量与超类中的实例变量具有相同的名称时，则从引用类型中选择实例变量。

在子级和父级中声明具有相同名称的变量会造成混乱，我们应该始终避免这种情况，这样就不会造成混乱。这就是为什么我们也应该始终坚持 一般准则创建 POJO 并声明具有私有访问权限的变量，并提供适当的 get/set 方法来访问它们。

您可以阅读我的文章 什么是变量阴影和隐藏在Java中。

Answer 4

Java 中的属性不是多态的，无论如何声明公共属性并不总是一个好主意。对于您正在寻找的行为，最好使用私有属性和访问器方法，如下所示：

class Parent {

    private int var = 1;

    public int getVar() {
        return var;
    }

    public void setVar(int var) {
        this.var = var;
    }

}

class Child extends Parent {

    private int var = 2;

    public int getVar() {
        return var;
    }

    public void setVar(int var) {
        this.var = var;
    }

}

现在，在测试它时，我们得到了所需的结果，2：

Child child = new Child();
Parent parent = (Parent)child;
System.out.println(parent.getVar());

Answer 5

当你进行转换时，你有效地告诉编译器“我更了解”——它暂停了正常的强类型推理规则，并给你带来了怀疑的好处。

通过说 Parent Parent = (Parent)child; 您是在告诉编译器“将此对象视为 Parent 的实例”。

另一方面，您将 OO 的“信息隐藏”原则（好！）与字段隐藏副作用（通常是坏的）混淆了。

Answer 6

正如您所指出的：

我们应该隐藏超类的变量 var

这里的要点是变量不会像方法那样被重写，所以当你直接调用Child.var时strong> 您直接从 Child 类调用变量，而当您调用 Parent.var 时，您正在从 Parent 类调用变量，无论它们是否具有相同的名称。

作为旁注，我想说这确实令人困惑，不应该被允许作为有效的语法。