Java中多态性中的成员访问功能[重复]

Question

public class A {
    public int a = 10;
    public void show() {

    }
}

public class B extends A{
    public int a = 20;
    public int b = 10;

    @Override
    public void show() {
        System.out.println(this.a);
    }

    public static void main(String[] args) {
        A a = new B();
        a.show();
        System.out.println(a.a);
    }
}

看上面的代码，我使用父class A引用指向子class B object (A a = new B())，但是当我在main方法中打印a.a(System.out.println(a.a))时，它打印10，因为成员变量a被赋值了10 在父 class A 中。但是当我在show 方法中打印this.a(System.out.println(this.a))（在子类中重写）时，show 方法打印this.a (System.out.println(this.a))，它打印20，我很困惑。我认为结果应该是一样的。 可以看到输出如下图：

20
10

提前致谢！

Answer 1

我相信多态性的最佳实践不是重写变量，因为它会导致致命错误。如果您的问题是关于“多态性：操作方法”的，这个答案可能会有所帮助：

    //create class A, as you did:
    public class A {
        public int a; //note that we do not initialize the value here
        public void show() {
    
        }
    }

    //extend class B from class A, as you did:
    public class B extends A {
        public int b; //note that we only need to declare variable b

        @Override
        public void show() {
            System.out.println(this.a);
        }
    }

    //in the main class:
    public static void main(String[] args) {
        B a = new B();
        a.a = 20;
        a.b = 10;
        a.show();
    }

Answer 2

在java中只有方法被覆盖，变量没有。因此，父类的变量不会被子类的变量覆盖。这是Java中的设计决策。其中一个问题是父类方法可以执行而不用担心子类变量......即它有助于not breaking parent classes code...

一个例子如下：

public class Parent {
  String someVar; // note this: it is "String" type
  String getSomeVar() {
  }
}

public class Child extends Parent {
  int someVar; // same name but different type, this would break the code if
  // java permit "variable overriding" feature
}

你可以清楚地看到父母的类型和孩子的类型是不同的。我想，你现在可以理解为什么变量覆盖会很危险了……

更新：

@helloWorld，看了你最后的评论，看来你误解了overriding的想法。

特别是，我为您准备了一个示例。用 cmets 阅读以下代码：

class A {
    public int a = 10;

    public void show () {
        System.out.println("Inside A: " + this.a);
    }
}

class B extends A {
    public int a = 20;
    public int b = 10;

    @Override
    public void show() {
        System.out.println("Inside B: " + this.a);
    }
}

B b = new B();
A a = b;

b.show(); // prints "Inside B: 20", it should print "20", so it's okay
a.show(); // prints "Inside B: 20", so, method in 'A' is overrided by class 'B', cause, in normal definition it should print "10"

System.out.println("value of b.a: " + b.a); // prints "value of b.a: 20", it should print '20', so it's okay
System.out.println("value of a.a: " + a.a); // prints "value of a.a: 10", it is not overrided by class 'B', but notice 'a.show()' method was overrided

所以，我想，你已经明白了，覆盖意味着：当 parent/super class's reference 使用 something(a method/variable) 时，但在 parent/super 类的 particular method/variable 的实现存在时获得 child class's 中定义的行为，是称为覆盖...

您也可以阅读this。

关于this:

this 绑定到an object。它总是习惯于access，只有那个特定的class's scope，即在那个class中声明的variables/methods。因此，要在child 中访问parent，您需要使用super。