再次理解面向对象的第三大特征------多态

废话不多说，直接上代码。

//多态

package temp_01;

class Grand_Father

{

    public void Talk()

    {

        System.out.println("Grandfather is talking!");

    }

    public void Walk()

    {

        System.out.println("Grandfather is walking!");

    }

}

//Father继承Grand_Father类,继承其Talk、Walk方法，第一层继承

class Father extends Grand_Father

{

    public void Talk()

    {

        System.out.println("Father is talking!");

    }

    public void Walk()

    {

        System.out.println("Father is walking!");

    }

}

//Son继承Father类,继承其Talk、Walk方法，第二层继承

class Son extends Father

{

    public void Talk()

    {

        //在子类的方法中可以通过super访问其父类中被子类覆写的方法（特别是私有方法要用super关键字），

        //（在子类的构造方法中的第一句就默认隐含了一个super()语句。）只能访问其直接父类的方法。

        super.Talk();

        System.out.println("Son is talking!");

    }

    public void Walk()

    {

        super.Walk();

        System.out.println("Son is walking!");

    }

    public void School()

    {

        System.out.println("Son study at xxx school!");

    }

}

public class polymorphic {

    public static void main(String[] args) 

    {

        //Grand_Father gf = new Grand_Father();

        //Father f = (Father)gf;

        //强制向下转型,在运行的时候报错，因为父类用其本身的类实例化自己的对象，但它自己并不知道谁是自己的子类

        //用子类的类型去实例化父类的对象，父类才知道自己拥有这样一个子类。

        //f.Talk();

        //f.Walk();

        Grand_Father gf = new Father();//向上转型

        gf.Talk();

        gf.Walk();

        

        Father f = new Son();//向上转型

        f.Talk();

        f.Walk();

        //没有f.School()方法---即丢失了精度

        Son s = new Son();

        s.School();

        //1、向上转型，父类对象通过子类对象去实例化，不需要进行强制转换，但是会丢失精度。

        //2、向下转型，父类的对象可以转换为子类对象，需要强制转型，但并非所有的父类对象都可以转换为子类对象。

    }

}

运行结果：

run：

Father is talking!

Father is walking!

Father is talking!

Son is talking!

Father is walking!

Son is walking!

Son study at xxx school!