0

继承人的代码：

class A{
    int data=10;
    void show1(){
        System.out.println("In A="+data);
    }
}

class B extends A{
    int data=20;
    void show2(){
        System.out.println("In B="+data);
    }



}


public class Overriding4 {
    public static void main(String args[]){
        B b=new B();
        System.out.println("Data1="+b.data);
        System.out.println("Data2="+b.data);
        b.show1();
        b.show2();
    }
}

这是输出：

Data1=20
Data2=20
In A=10
In B=20

Data1=20 的输出应该是 10 ，而不是 20 ......但我想我在这里遗漏了一些东西。请在这件事上给予我帮助

好的，感谢您的帮助，但有一个新疑问：如果我将主要方法更改为：

 public static void main(String args[]){
            A a=new B();
            System.out.println("Data1="+a.data);
            System.out.println("Data2="+a.data);
            a.show1();
            a.show2();
        }

你去吧。

4

7 回答 7

1

类字段不会被继承。请注意，您int data在两个类A和B. 这称为隐藏。

于 2013-08-23T17:20:50.537 回答
1 
Within a class, a field that has the same name as a field in the superclass hides
the superclass's field, even if their types are different.

这可以在隐藏字段中找到

因此，它打印 20。

于 2013-08-23T17:28:47.330 回答
1

为了“感受”多态性的力量，我们需要稍微修改一下你的代码：

class A {

    int data=10;
    void show(){
        System.out.println("In A="+data);
    }
}

class B extends A {

    int data=20;

    @Override
    void show(){
        System.out.println("In B="+data);
    }

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

现在，您可以看到两者a和b都被声明为类型A- 但赋值是不同之处。此外，我们可以创建一个 A 类型的数组，并将它与两种类型（A以及B）的对象一起容纳：

A[] arr = new A[3];

// 让我们添加一些东西；

arr[0] = new A(); 
arr[1] = new B();
arr[2] = new A();

现在很容易看出美丽的多态是如何工作的

for (int i=0; i<arr.length; i++){
   arr[i].show();
}

最后一个循环将打印：

In A 10
In B 20
In A 10

我们所知道的是，数组包含的对象是 - 的子类型，A我们可以指望每个对象调用“正确”的show()方法。这就是多态！

于 2013-08-23T17:22:21.733 回答
0

由于您已经覆盖了 B 类中的数据变量，因此它将打印最新的值。由于您在 B 类中将“数据”重估为 20，这就是它将显示的内容。

于 2013-08-23T17:21:39.073 回答
0

除非你打错字，否则下面两行基本相同：

System.out.println("Data1="+b.data);
System.out.println("Data2="+b.data);

像这样可视化对象可能会有所帮助：

A {
  [A.data = 10];  <-- this is overridden and cannot be accessed directly
  show1() => 10;
  B {
    B.data => 20;
    show2() => 20;
  }
}
于 2013-08-23T17:33:09.323 回答
0

您实际上没有覆盖这些方法....

`System.out.println("Data1="+b.data);

System.out.println("Data2="+b.data);`

对于这两行，“数据”值将从 B 类的数据变量中获取。现在，B 类扩展了 A 类，这意味着 A 类的所有成员都将在 B 类中继承。所以变量 i(属于类A) 将被继承并且在 B 类内部我们有它自己的局部变量 i......show1() 类 A 的方法也将在 B 类中被继承。所以通过使用 B 类的引用变量 (b) 我们可以访问 show1() 方法和 show2() 方法。

于 2013-08-23T19:25:01.580 回答
0

类的对象B有两个字段，都名为data，但正如 Luiggi 暗示的那样，其中一个是隐藏的。如果您想取回它，请使用演员表：

public class Overriding4 {
    public static void main(String args[]){
        B b=new B();
        System.out.println("Data1="+((A)b).data);  // like this  
        System.out.println("Data2="+b.data);
        b.show1();
        b.show2();
    }
}

产生：

Data1=10
Data2=20
In A=10
In B=20

PS您可以在作业的任一侧使用演员表：

public class Overriding4 {
    public static void main(String args[]){
        B b=new B();
        ((A)b).data *= 10;
        System.out.println("Data1="+((A)b).data);  
        System.out.println("Data2="+b.data);
        b.show1();
        b.show2();
    }
}

Data1=100
Data2=20
In A=100
In B=20

聚苯乙烯。我发布这篇文章是为了向您展示该语言是如何工作的，但一般来说，在其他类可以直接读写的类中拥有公共字段并不是一个好主意。请参阅为什么使用 getter 和 setter？

于 2013-08-23T17:30:37.590 回答