[老人的讨论帖]你知道为什么嘛？

Question

好久没来CSDN了，忙，迷茫的芒~~ 不说废话，直接上代码：
//问题1：输出是什么？为什么？class A {
   public int i = 10;
}class B extends A{
   public int i = 20;
}public class TestPolm{
   public static void main(String args[]){
      B b = new B();
      A a = b;
      
      System.out.println(b.i);
      System.out.println(a.i);
   }
}//问题2：输出是什么？为什么？class A {
   private int i = 10;
   
   public void printI(){
    System.out.println(i);
   }
}class B extends A{
   private int i = 20;
}public class TestPolm{
   public static void main(String args[]){
      B b = new B();
      A a = b;
      
      b.printI();
      a.printI();
   }
}
//问题3：输出是什么？为什么？class A {
   private int i = 10;
   
   public void printI(){
    System.out.println(i);
   }
}class B extends A{
   private int i = 20;
   
   public void printI(){
    System.out.println(i);
   }
}public class TestPolm{
   public static void main(String args[]){
      B b = new B();
      A a = b;
      
      b.printI();
      a.printI();
   }
}

Answer 1

第一个问题，
----------------
20
10
----------------因为变量是没有多态的，说白了，A.i和B.i是两个不同的成员变量。
函数才有重写这一说。

Answer 2

很经典的问题
我想应该是
第一题20  10
第二题10  10
第三题20  20
我就去想A是动物B是猫，b是猫，a是不认识猫，把猫当动物看

Answer 3

第三个问题，
都输出20.
因为对象引用a,b都是指向派生类的对象的。调用方法会多态到派生类的重写方法内。
都是访问的B.i = 20这个变量。我上面7#那个写错了，是A.i = 10

Answer 4

现在理解了……第二个：因为被调用的只有 基类的方法。那么基类都是访问 A.i = 10 这个变量。第三个：多态，两次其实都是在运行B这个类的print

Answer 5

1.20,10 因为字段没有重写的概念，属性还是跟随自己的类型（拥有自己的内存空间）
2.一开始做错了。。以为是20，20。后来发现原来是B继承A的方法（不是重写），方法打印还是父类自己的i（print方法内的this引用还是A类型的）3.20，20，因为方法被重写了，类B的方法区只有重写的方法print，当然this引用是B类型的。打印自己的属性i楼主我这样理解是否对呢？请指教~

Answer 6

1.20 10
A类的i没有被覆盖2.10 10
B类没有重写printI方法，所以执行的还是父类的方法3.20 20
B类重写printI方法，打印自己的i变量

Answer 7

全部都是20.因为这所有的代码里，只创建过B的对象，所以，A完全可以被忽略掉。A a=b;并不能改变b之为B的本质。

Answer 8

class A {
   private int i = 10;
}class B extends A{
   public int i = 20;
}
// B具有A.i的拥有权，但是没有使用权class A {
   public int i = 10;
}class B extends A{
   public int i = 20;
}
//那么这样呢？

Answer 9

很经典的问题 
我想应该是 
第一题20  10   都是打印各自的变量i;
第二题10  10   都是调用A类的printI方法，打印A类的i
第三题20  20   多态调用，都是调用B类的printI方法，打印B类的i

Answer 10

楼主这一大堆说明：
1.类在被创建实例的时候就已经决定了能使用哪些方法，哪些变量。
2.当有继承关系时，同名变量不会被覆盖，而是会放在一个堆栈中。
3.当有继承关系时，方法的寻找路径是先本类，找不到找父类...
4.当有继承关系时，方法调用 this指向的变量 的寻找路径是先方法所在的类，找不到找父类...

Answer 11

1.变量没有多态  10 10
2.输出的变量是“就近原则”，两个都是调用a的println() 所以
3.输出的变量是“就近原则”，两个都是调用b的println() 所以个人理解

Answer 12

1.20 10 因为i是变量，A中的i没有被覆盖2.10 10 因为B类没有重写printI方法，执行的还是父类的方法3.20 20 因为B类重写printI方法

Answer 13

第一个：20，10//当  B b = new B(); 的时候，由于B继承了A，它会先得到父类的值，然后再得到子类中的值，不存在重写父类方法，在这里打印的属性为各自的值。
 
 
第二个：10，10//由于B继承了A，所以会继承父类的方法，当子类中没有重写父类方法时默认调用父类方法，所以b打印出来为10第三个：20，20//经过断点调试看到，当运行时实际打印的都是B中的printI(),但是B中的i具有两个值，1=10，1=20，因为B 继承了A，B继承A，B重写了父类中所有的方法。所以最后printI的都是B中的数据。我理解不深刻。
是通过测试，断点调试看到它的运行步骤的。
如果写错了希望大家帮我改正。
谢谢。

Answer 14

 b.printI();
      a.printI();
有这种方法吗？

Answer 15

顶 顶  dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd

Answer 16

这样的结果又是多少呢？？？
class A {
   public int i = 10;
   
   public void say(){
    System.out.println(" 这是一个A类方法");
    }
}class B extends A{
   public int i = 20;
   
   public void say(){
    System.out.println("这是一个B类方法");
}}public class ooDemo05{
   public static void main(String args[]){
      B b = new B();
      A a = b;
      b.say();
      a.say();
      System.out.println(a instanceof B);
      System.out.println(a instanceof A);
      System.out.println(b.i);
      System.out.println(a.i);
   }
}

Answer 17

第一题 20  10 不知道什么原因？
第二题 10  10 第二天public方法被覆盖
第三题 20  20  不知道什么原因？

Answer 18

我还好啊 呵呵 谢谢关心第二题 就是B类没有实现父类的方法 a.printI()和b.printI()都会找到父类也就是A类中的printI方法 尽管他们都是B的实例  但是能向上转型  像楼上说的  猫是动物

Answer 19

 b.say();//这是一个B类方法
      a.say();//这是一个B类方法
      System.out.println(a instanceof B);//true
      System.out.println(a instanceof A);//true
      System.out.println(b.i);//20
      System.out.println(a.i);//10