public class DuoTai {

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

class A
{
        int x=10;       
       
        public static void f()
        {
                System.out.println("A");
        }
}

class B extends A
{
        int x=20;       
       
        public static void f()
        {
                System.out.println("B");
        }
}
/*
执行结果是：
A
10
*/
以上这个程序为何会这个结果，可否给个内存图，谢谢！

你的程序是java的hide机制不是override机制。多态是继承关系中方法间的一种关系吧，而且方法不能使static修饰的，否则就是hide机制。

楼上说的对，这个实际上是子类可以通过重新定义，隐藏其父类中也可访问到的具有相同名字的静态方法或者成员变量。其实，在毕老师的视频中，也提到了这方面，他这么讲的：多态中，当父类的引用对象指向子类的实例对象时，成员变量和静态成员方法：无论编译和运行都参考左边（即参考引用星变量所属的类）。一样的道理。

class DuoTai {
        public static void main(String[] args)
        {
                A a = new B();
                                //刚看这个代码，我感觉输出的是B 10
                                //再一看,你定义的是静态的方法，你要明确一点，静态访问是不需要创建对象的
                                //可以直接通过类名访问的，所以在重写中，静态方法虽然形式上被重写，但内在并没有重写               
a.f();
                System.out.println(a.x);
        }
}
class A
{
        int x=10;        
        
        public static void f()
        {
                System.out.println("A");
        }
}
class B extends A
{
        int x=20;        
        
        public static void f()
        {
                System.out.println("B");
        }
}

多态中：父类引用指向子类对象的时候。
1、在多态中，成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败。
在运行时期，参阅的是对象所属类中是否有调用的方法。如果有，运行自己的。
        
简单总结就是，（非静态）成员函数在多态调用时，编译看左边，运行看右边。

2、在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类).

3、在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

父类引用指向子类对象，对于静态方法调用的时候，父类走父类，子类走子类。

在多态中，当父类和子类出现重名的成员变量的特点，无论是编译还是运行，都参考左边引用型变量所属类的指向。


public static void main(String[] args)
        {
                A a = new B();
                a.f();//此部分输出为A。
                System.out.println(a.x);//a.x指向的也是父类中的x=10;
        }


建议观看毕老师第08天05-面向对象（多态中成员的特点）。

class DuoTai {

        public static void main(String[] args)
        {
                A a = new B();//父类引用指向子类对象               
                a.f();
                System.out.println(a.x);
        }
}

class A
{
        int x=10;        
        
        public static void f()//静态方法      
       {
                System.out.println("A");
        }
}

class B extends A
{
        int x=20;        
        
        public static void f()//静态方法      
        {
                System.out.println("B");
        }
}
//静态优先于对象，加载时会先存着，调用也不需要对象，可以直接用类名调用，如A.f()或B.f()
//若建立对象，会调用引用型变量所属的类中的方法，如楼主写的A a=new B(),那么a.f()就调用类A中的f()方法

//在多态中，成员变量的特点是无论编译和运行，都参考引用型变量所属的类，也就是父类

给你一个我们毕老师的总结;
成员变量：
        编译时：参考引用型变量所属的类中是否有调用的成员变量，有编译通过，没有编译失败
        运行是：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
        简单说：编译和运行都参考等号左边。
c成员函数：
        编译时：参考引用型变量所属的类中是否有调用的函数，有，编译通过，没有编译失败。
        运行是：参考的是对象所属的类中是否有调用调用的函数。
        简单说：编译看左边，运行看右边，
        （因为成员函数存在覆盖特性）
静态函数：
        编译时：参考引用型变量所属的类中是否有调用静态方法
        运行时：参考引用型变量所属的类中是否有调用静态方法。
        简单说：编译和运行都看左边。
        （其实对于静态方法，是不需要对象的。可以直接用类名调用）

我觉得可以用一句话总结：成员变量和静态方法不具备多态特性。

jiyixuan 发表于 2012-5-4 01:10
多态中：父类引用指向子类对象的时候。
1、在多态中，成员函数的特点：
在编译时期，参阅引用型变量所属的 ...

这个是其然，而我想的是为什么会是这样子哦，不过还是谢谢哦

马浩 发表于 2012-5-4 01:16
class DuoTai {

        public static void main(String[] args)

有点眉目了，我再捉摸下，谢谢！

你的程序是java的hide机制不是override机制。多态是继承关系中方法间的一种关系吧，而且方法不能使static修饰的，否则就是hide机制。
多态中：父类引用指向子类对象的时候。
1、在多态中，成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败。
在运行时期，参阅的是对象所属类中是否有调用的方法。如果有，运行自己的。
         
简单总结就是，（非静态）成员函数在多态调用时，编译看左边，运行看右边。

2、在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类).

3、在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

父类引用指向子类对象，对于静态方法调用的时候，父类走父类，子类走子类。

在多态中，当父类和子类出现重名的成员变量的特点，无论是编译还是运行，都参考左边引用型变量所属类的指向。


public static void main(String[] args)
        {
                 A a = new B();
                 a.f();//此部分输出为A。
                 System.out.println(a.x);//a.x指向的也是父类中的x=10;
         }


建议观看毕老师第08天05-面向对象（多态中成员的特点）。