程序包管理--9月10日作业

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

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文档在下面的附件中