对象的多态性

对象多态性

主要分为两种类型：
向上转型：子类对象–>父类对象
对于向上转型，程序会自动完成 格式：
对象向上转型： 父类 父类对象 = 子类实例 ；
向下转型：父类对象–>子类对象
对于向下转型时：必须明确的指明要转型的子类类型。
对象向下转型：子类 子类对象 = (子类)父类实例 ;

1.1 向上转型

格式 父类 父类实例 = 子类实例

class A     //定义类A
{
    public void fun1()  //定义fun1()方法
    {
        System.out.println("A--fun1()方法>") ;
    }
    public void fun2() //定义fun2()方法
    {
        this.fun1() ;   //调用fun1()方法
    }
}
class B extends A   //定义类B 继承 类A
{
    public void fun1() //覆写父类方法
    {
        System.out.println("B-->fun1()方法") ;
    }
    public void fun3() //定义fun3()方法
    {
        System.out.println("B-->fun3()方法") ;
    }
}
public class PolDemo01
{
    public static void main(String[] args)
    {
        B b = new B() ; //实例化子类B对象
        b.fun1() ;
        A a = b ;       //向上转型关系
        a.fun1() ;
        a.fun2() ;
    }
}

以上程序，是通过子类进行父类对象的实例化操作，则如果调用的方法被子类覆写过，则肯定调用被覆写过的方法。
注意点：
转型之后，操作的是父类对象，所以无法找到在子类中新增加的新方法。

1.2 向下转型

将父类对象变为子类对象，称为向下转型，向下转型需要采用强制的手段。 格式 子类 子类实例 = (子类) 父类实例

class A     //定义类A
{
    public void fun1()  //定义fun1()方法
    {
        System.out.println("A--fun1()方法>") ;
    }
    public void fun2() //定义fun2()方法
    {
        this.fun1() ;   //调用fun1()方法
    }
}
class B extends A   //定义类B 继承 类A
{
    public void fun1() //覆写父类方法
    {
        System.out.println("B-->fun1()方法") ;
    }
    public void fun3() //定义fun3()方法
    {
        System.out.println("B-->fun3()方法") ;
    }
}
public class PolDemo02
{
    public static void main(String[] args)
    {
        A a = new B() ;     //向上转型关系    父类 父类实例 = 子类实例
        B b = (B) a ;       //向下转型关系 子类 子类实例 = (子类)父类实例
        b.fun1() ;
        b.fun2() ;
        b.fun3() ;
    }
}

在子类B中存在三个方法，所以都可以调用 。
注意点
如果要产生对象的向下转型，必须先产生对象的向上转型关系 (A a = new B())表示建立关系。

2.1对象多态性应用

要求：设计一个方法，此方法可以接收A类的任意子类对象，并调用方法 。

class A     //定义类A
{
    public void fun1()  //定义fun1()方法
    {
        System.out.println("A--fun1()方法>") ;
    }
    public void fun2() //定义fun2()方法
    {
        this.fun1() ;   //调用fun1()方法
    }
}
class B extends A   //定义类B 继承 类A
{
    public void fun1() //覆写父类方法
    {
        System.out.println("B-->fun1()方法") ;
    }
    public void fun3() //定义fun3()方法
    {
        System.out.println("B-->fun3()方法") ;
    }
}
class C extends A   //定义类B 继承 类A
{
    public void fun1() //覆写父类方法
    {
        System.out.println("C-->fun1()方法") ;
    }
    public void fun4() //定义fun3()方法
    {
        System.out.println("C-->fun4()方法") ;
    }
}
public class PolDemo03
{
    public static void main(String[] args)
    {
        A a = new B() ;     //向上转型关系    父类 父类实例 = 子类实例
        B b = (B) a ;       //向下转型关系 子类 子类实例 = (子类)父类实例
        C c = new C() ;     //实例化子类C对象
        run(b) ;
        run(c) ;
    }
    public static void run(A a)  //定义一个方法  向上转型
    {
        a.fun1() ;          //调用父类中方法
    }
}

以上代码 不管有多少子类，都可以简洁完成