有人可以解释我这种多态性的输出吗？

继承人的代码：有人可以解释我这种多态性的输出吗？

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

在数据1 = 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(); 
     }

你去那里。

来源

2013-08-23 Ajinkya

你为什么认为它应该是'10'？ –

为什么'Data1'必须是10？ –

它是20，因为您重新声明了该字段，因此它使用的是声明字段的值，而不是超类中字段的值。实际上你应该尝试避免重复的字段名称（超类和子类中存在的字段名称），因为它可能会避免很多混淆。 –

类字段不会被继承。请注意，您在A和B这两个类中都有相同的int data字段。这叫做Hiding。

来源

2013-08-23 17:20:50

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

来源

2013-08-23 17:21:39 user2704561

为了“感觉”多态的，我们需要改变你的代码位的功率：

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();

现在很容易看到的最后一个循环将polimorphism多么美丽worksL

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

打印：

In A 10 
In B 20 
In A 10

所有我们知道的是，数组中存放它们的子对象A的类型 - 我们可以依靠每个对象来调用“正确”的方法show()。这是多态！

来源

2013-08-23 17:22:21 alfasin

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.

这可以在Hiding fields

因此可以发现，它打印20.

来源

2013-08-23 17:28:47

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

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

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

PPS。我发布了这个教程，向你展示这门语言是如何工作的，但总的来说，它是而不是是一个好主意，它可以让其他类可以直接读写的类中存在公共字段。见Why use getters and setters?

来源

2013-08-23 17:30:37 ajb

除非你犯了一个错字，下面两行基本一致：

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-23 17:33:09 KidTempo

你居然没覆盖方法....

`System.out.println（“Data1 =”+ b.data）;

的System.out.println（“数据2 =” + b.data）;`

为这两条线“数据”值将被通过从类B. 的数据变量取出现在，类B扩展了A类，这意味着类A中的所有成员都将在类B中继承。因此，变量i（类A）将继承，并且在类B中我们有它自己的局部变量i ...... show1 ）类的方法也将在类B中继承。因此，通过使用类B的引用变量（b），我们可以访问show1（）方法以及show2（）方法。

来源

2013-08-23 19:25:01 user2712154

有人可以解释我这种多态性的输出吗？

回答

相关问题