额，老湿间的多态的知识点我知道，成员变量，静态变量，静态方法都是编译看左边，运行看右边，非静态方法是编译看左边，运行看右边。但是下面的这道题我凌乱了。。。

1. class Super
   
2. {
   
3. int i=0;
   
4. public Super(String a)
   
5. {
   
6. System.out.println("A");
   
7. i=1;
   
8. }
   
9. public Super()
   
10. {
    
11. System.out.println("B");
    
12. i+=2;
    
13. }
    
14. }
    
15. 
    
16. class Demo extends Super
    
17. {
    
18. public Demo(String a)
    
19. {
    
20. 
    
21. System.out.println("C");
    
22. i=5;
    
23. }
    
24. public static void main(String[] args)
    
25. {
    
26. int i=4;
    
27. Super d = new Demo("A");
    
28. System.out.println(d.i);
    
29. }
    
30. }

复制代码

Super d = new Demo("A");这句不是多态吗，super的引用d指向之类Demo的对象啊，
System.out.println(d.i);所以输出的应该是父类的成员变量i啊，但是输出的却是子类的成员变量i，
所以贴出来希望大家解惑(⊙o⊙)…

因为i是Super成员变量  
当执行到这一句
System.out.println("C");

i=5;
所以结果会是5；
你可以在Demo中定义一个这样的成员变量那么打印结果就是你想要的了

class Super

{

int i=0;

public Super(String a)

{

System.out.println("A");

i=1;
}

public Super(){

{

System.out.println("B");

i+=2;

}

}

public class Demo extends Super

{

public Demo(String a)

{
super();  //这里其实省略了父类的构造函数，此时打印了一个B，继承了父类成员变量i,然后通过i+=2;将i的值赋值为2
System.out.println("C");  //接着打印了一个C

i=5;  //最后将父类中的i的值赋值为5
}

public static void main(String[] args)

{

int i=4;

Super d = new Demo("A");//此处调用Demo的构造函数

System.out.println(d.i);

}

}
这道题是因为子类中没有成员变量i,所以对i的操作都是在改变父类中的值，这样就可以理解了。

1. class Super
   
2. {
   
3.         int i=0;
   
4.         public Super(String a)
   
5.         {
   
6.                 System.out.println("A");
   
7.                 i=1;
   
8.         }
   
9.         public Super()
   
10.         {
    
11.                 System.out.println("B");
    
12.                 i+=2;
    
13.         }
    
14. }
    
15. 
    
16. class Demo extends Super
    
17. {
    
18.         //int i; //打开这句，结果大不一样。
    
19.         public Demo(String a)
    
20.         {
    
21.                 //super();//改成super("a"),结果又不一样。
    
22.                 System.out.println("C");
    
23.                 i=5;
    
24.         }
    
25. 
    
26.         public static void main(String[] args)
    
27.         {
    
28.                 int i=4;
    
29.                 Super d = new Demo("A");
    
30.                 System.out.println(d.i);
    
31.         }
    
32. }
    
33. 
    
34. /*
    
35.         由于Demo类继承了Super类，当创建对象时，
    
36.         其实在Demo的省略了super()这个方法，如果在Super类中，
    
37.         没有默认构造方法，会报错，楼主可以注释掉那个无参的构造方法,
    
38.         此时需要显示super(参数)调用父类显示的有参构造方法;
    
39. 
    
40.         1.题中隐式的调用了默认构造方法，此时输出了B，
    
41.         2.由于Demo中没有定义i，此时，Demo构造方法中的i，代表的是父类的i,i=5,也是对于父类的i赋值的。
    
42.           若在Demo类中声明一个成员变量i,那这个i就为子类的i,i赋值为对子类赋值。
    
43.         3.d.i调用的仍然是父类的i,若Demo中没有声明i，结果为5，若Demo声明了i，结果为2.
    
44. 
    
45. */

复制代码

hacket 发表于 2013-4-21 15:36

ls，输出b和c我都理解，就是i的数值问题。。子类继承父类，不是Super的成员变量i被Demo继承了吗？

吴刚 发表于 2013-4-21 16:22
ls，输出b和c我都理解，就是i的数值问题。。子类继承父类，不是Super的成员变量i被Demo继承了吗？ ...

class Demo extends Super
{
        public MultiStatementDemo(String a)
        {
                System.out.println("C");
                i = 5;
        }

1.最原始的情况，是父类有i声明，而子类没有，所以这个i=5,用的是父类的，main的那个i是在局部变量，和这里没有关系。

class Demo extends Super
{

       int i;
        public MultiStatementDemo(String a)
        {
                System.out.println("C");
                i = 5;
                //super.i=5;
        }
2.Demo类加上i了，此时i=5，其实省略了this关键字，指的是Demo类的成员变量i，就是对Demo类中成员变量赋值，输出d.i时，调用的还是父类的，只是父类的i在父类

   构造方法已经初始化为2了，故加上i，输出2。不过，若在Demo类中加上i的同时，又在i前面加上super，意思就是调用父类的i，d.i又为5了。

明白了吗？

卧槽，好像想通了，Demo继承了Super中的i，但是子类中的i和父类中的i是共有的，可以这样理解吗，然后Demo的构造函数修改了i的值，结果Super和Demo中的i全部都是5，接着如果在Demo中也定义了i的值，那么Super和Demo中的i就各自在自己的定义域中才有用，我这样理解可以吗、、。、

谢谢楼上几位的解答。。。{:soso_e115:}

如果问题未解决，请继续追问，如果问题解决了，请将问题分类改为“已解决”，谢谢