java基础_多态

多     态

 

 

在面向对象的程序设计语言中，多态是继数据抽象和继承之后的第三种基本特征。

多态出现的目的是消除类型之间的耦合关系。继承允许将对象视为它本身的类型或其基类型来加以处理，它允许将多种类型(从同一种类型继承下来的)视为同一种类型来处理，而同一份代码也就可以毫无差异的运行在这些不同的类型之上了。多态方法调用允许一种类型表现出与其他相似类型之间的区别(只要他们都是从同一基类继承下来的)。

·转型

class Father {

    void fun() {

       System.out.println("Father fun()");

    }

}

class Child extends Father {

    //继承之后本来已经拥有了一个fun()的方法，覆盖了父类的fun()方法

    void fun() {

       System.out.println("Child fun()");

    }

}

 

public class PolymorphicTest {

   

    //传一个Father的引用进来，并且调用它的fun()方法

    public static void play(Father fa) {

       fa.fun();

    }

 

    public static void main(String[] args) {

 

       Child child = new Child();

       //本来应该传一个Father类型的引用进去，但这里传进去的是一个Child的引用

       //也是可以正常运行的，这就叫做：向上转型

       play(child);

       //~~输出：Child fun()

      

       //按照常规的用法是Father fa = new Father();

       //但这里去Father的引用指向了Child，由于Child是从Father继承下来的，

       //所以也是可以这样来new的，这就叫做：多态

       Father fa = new Child();

       play(fa);

       //~~也输出：Child fun()

    }

}

在以上例子中的PolymorphicTest类中的play方法里应该传入的是一个Father类型的引用，但是在main函数里调用play方法时却传入的是一个Child对象的引用，这样做之所以能正常运行是因为Child继承了Father。

·多态例子

例子:现有一个People的对象，People分为kid、young、old三个阶段，每个阶段都有一个talk的方法说出自己所在的阶段，通过多态的方式来向上转型为People。

class People {

    void talk() {

       System.out.println("I'm a People");

    }

}

class Kid extends People {

    void talk() {

       System.out.println("I'm a kid");

    }

}

class Young extends People {

    void talk() {

       System.out.println("I'm a young people");

    }

}

class Old extends People {

    void talk() {

       System.out.println("I'm a old people");

    }

}

public class PeopleTest {

   

    public static void play(People p) {

       p.talk();

    }

 

    public static void main(String[] args) {

       //定义一个People的引用指向People对象

       People people = new People();

       //定义一个People的引用指向Kid对象，多态

       People kid = new Kid();

       //定义一个People的引用指向Young对象，多态

       People young = new Young();

       //定义一个People的引用指向Old对象，多态

       People old = new Old();

      

       play(people);

       //~~输出：I'm a People

       play(kid);

       //~~输出：I'm a kid

       play(young);

       //~~输出：I'm a young people

       play(old);

       //~~输出：I'm a old people

    }

}

·域与静态方法及初始化

class Base {

    public Base() {

       System.out.println("Base Object is constructor");

    }

    public static String staticGet() {

       return "Base staticGet";

    }

    public String dynamicGet() {

       return "Base dynamicGet";

    }

}

class Sub extends Base {

    public Sub() {

       System.out.println("Sub Object is constructor");

    }

    public static String staticGet() {

       return "Sub staticGet";

    }

    public String dynamicGet() {

       return "Sub dynamicGet";

    }

}

public class FieldTest {

 

    public static void main(String[] args) {

 

       //向上转型

       //在这里构造一个Base的对象来指向它的子类Sub

       //注意：在构造子类先构造父类

       Base base = new Sub();

      

       System.out.println(base.staticGet());

       //~~输出：Base staticGet

       System.out.println(base.dynamicGet());

       //~~输出：Sub dynamicGet

    }

}

注意以上例子的输出结果。虽然进行了相应的转型，但在调用static静态方法时还是调用的父类的。在构造子类之前先构造其父类。

 源代码及相应的work文档在下面的附件中