/*

 多态时，

 成员的特点：

 1，成员变量。

     编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

     运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

     简单说：编译和运行都参考等号的左边。哦了。

     作为了解。

 覆盖只发生在函数上，和变量没关系。

 Fu f = new Zi();

 System.out.println(f.num);//是父类，答案是3

 没根据f的值（子类对象的地址）去找，而是根据f的类型去找。

 开发时不可能出现这样的情况，我父类有了，我子类就直接拿来用了，而且用的时候一般都已经向下转型了。

 2，成员函数(非静态)。

     编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。

     运行时：参考的是对象所属的类中是否有调用的函数。

     简单说：编译看左边，运行看右边。

     因为成员函数存在覆盖特性。

 Fu f = new Zi();//

 f.show();

 输出的是子类里面的show方法

 依赖的是对象，有对象才有成员函数，必须动态的绑定到指定的对象上，所以运行的时候是看子类，而编译的时候检查语

 法错误，所以编译的时候检查父类，所以看父类。

 编译检查语法错误，运行时根据引用指向的地址运行。

 3，静态函数。

         编译时：参考引用型变量所属的类中的是否有调用的静态方法。

         运行时：参考引用型变量所属的类中的是否有调用的静态方法。

         简单说，编译和运行都看左边。

         其实对于静态方法，是不需要对象的。直接用类名调用即可。

 Fu f = new Zi();//

 f.show();

 这里最后输出的是父类的show里面的内容，因为静态成员不需要对象，直接是被类名指向，都指向存静态方法的方法区，

 而那个里面存的就是父类的show。

 Zi z = new Zi();//

 z.show();

 这里的zi是继承fu的，show方法是静态的

 输出的是子类里面的show

 其实可以理解为静态函数不具备多态性，多态性是对象的多态性，然后静态函数不涉及对象

 父类对象引用，就是指向父类的静态函数

 子类对象引用，就是指向子类的对象函数

 */

 class Fu

 {

 //    int num = 3;

     void show()

     {

         System.out.println("fu show");

     }

     static void method()

     {

         System.out.println("fu static method");

     }

 }

 class Zi extends Fu

 {

 //    int num = 4;

     void show()

     {

         System.out.println("zi show");

     }

     static void method()

     {

         System.out.println("zi static method");

     }

 }

 class  DuoTaiDemo3

 {

     public static void main(String[] args)

     {

         Fu.method();

         Zi.method();

 //这个的实质是父类对象指向子类引用，就是有点像指针，f的值是子类对象的地址。

         Fu f = new Zi();//

 //        f.method();//输出是父类的静态

 //        f.show();//编译的时候检查的是父类，运行的时候以子类为主，show被覆盖，运行的子类的show

         //输出是子类的show，

 //        System.out.println(f.num);//是父类，答案是3

 //        Zi z = new Zi();

 //        System.out.println(z.num);//是子类，答案是4

     }

 }