class Fu
{
        int num=4;
        void show()
        {
           System.out.println("showFu");
        }
}
class Zi extends Fu
{
        int num=5;
        void show()
        {
           System.out.println("showZi");
        }
}
class  T
{
        public static void main(String[] args)
        {
                Fu f=new Zi();//这句代码该如何理解？
                Zi z=new Zi();
                System.out.println(f.num);
                System.out.println(z.num);
                f.show();
                z.show();
        }
}
为什么输出结果是：
4
5
？

class Fu
{
         int num=4;
         void show()
         {
            System.out.println("showFu");
         }
}
class Zi extends Fu
{
         int num=5;
         void show()
         {
            System.out.println("showZi");
         }
}
class  T
{
         public static void main(String[] args)
        {
                 Fu f=new Zi();//这句代码该如何理解？在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。


                 Zi z=new Zi();
                 System.out.println(f.num);
                 System.out.println(z.num);
                 f.show();
                 z.show();
         }
}
为什么输出结果是：
4
5
？希望对你有帮助，建议看毕老师第八条的视频，讲的多态和继承。

class Fu
{
        int num=4;
        void show()
        {
           System.out.println("showFu");
        }
}
class Zi extends Fu
{
        int num=5;
        void show()
        {
           System.out.println("showZi");
        }
}
class  T
{
        public static void main(String[] args)
        {
                Fu f=new Zi();//这句是对象的多态，父类引用指向子类对象
                Zi z=new Zi();
                System.out.println(f.num);//这句话是输出父类引用的成员变量
     //多态中成员变量的特点：无论编译和运行，都参考左边(引用类型变量所属的类)。
   //输出4
                System.out.println(z.num);//子类引用指向子类对象，调用子类自身的成员变量
// 输出5
                f.show();//父类引用指向子类对象，由于子类把show方法重写，所以执行子类的show方法。如果没有重写该方法他会执行父类的该方法
//在多态中非静态成员函数的特点：
//在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
//在运行时期：参阅对象所属的类中是否有调用的方法。
//简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

//输出 showZi
                z.show();//子类对象指向子类引用，调用自身方法
//输出showZi
        }
}
为什么输出结果是：
4
5
showZi
showZi

其实f是Fu的类变量，当然所有的赋值和初始化都是针对Fu的，所以num=4
new zi只是在调用zi的方法和构造函数。
继承就是儿子没有的东西，向老子要，对外界说是自己买的。
儿子有的东西，老子没有，闪一边去。
儿子老子都有的东西，各玩各的。
                                    

class Fu
{
        int num=4;
        void show()
        {
           System.out.println("showFu");
        }
}
class Zi extends Fu
{
        int num=5;
        void show()
        {
           System.out.println("showZi");
        }
}
public class  cc
{
        public static void main(String[] args)
        {
                Fu f=new Zi();//这句代码该如何理解？----------》》》这是面向父类编程，多态
                //比如：  我要一个动物，你可以给我一个小狗啊小猫之类的都行，  也就是动物类对象可以指向它的子类对象（猫，狗）
                //例如：动物  dw = new 动物();
                       动物 dw = new 猫();
                       动物 dw = new 狗();
                       都可以。  
               
                                成员变量不存在覆盖
                                在多态中，成员变量的特点：
                                无论编译和运行，都参考左边(引用型变量所属的类)。
                Zi z=new Zi();
                System.out.println(f.num);   
                System.out.println(z.num);

        编译看左边，只要父类有show()方法编译就通过，但是运行的时候执行的却是子类的show()方法。
                f.show();
                z.show();
        }
        
}

父类引用指向子类对象。成员函数编译看左边，运行看右边；静态成员函数和变量编译和运行都看左边。建议楼主仔细看视频

我想你已经是知道是你的代码时跟多态有关，那我就针对多态结合你的代码分析一下；
首先多态特性是：可以使用父类类型的引用指向子类的对象，该引用只能调用父类中定义的方法和变量；如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法（动态连接、动态调用）；变量不能被重写（覆盖），”重写“的概念只针对方法，如果子类中出现与父类同名的变量，子类的变量会隐藏父类的同名变量，这时候可以认为子类同名变量只属于子类自己的，父类还拥有自己的与子类同名的变量。在你的代码中，父类类型引用f指向了子类对象，形成多态，根据多态的特性f中num还是父类的值4，调用show方法的时候将调用子类重写父类的方法。
其实可以这样理解：父类的成员方法具有多态性，成员变量不具备多态性。