黑马程序员技术交流社区

标题: 多态总结 [打印本页]
作者: a80C51    时间: 2015-9-10 21:33
标题: 多态总结
1,定义
        相同类型的变量，调用同一个方法时，呈现出多种不同的行为特征。
2，父类多态的体现
        a，父类的引用指向了自己的子类对象
        b，父类的引用也可以接收自己子类的对象
3，多态的前提
        a，类与类之间有关系，要么继承，要么实现；
        b，类与类之间存在覆盖。
4，多态的好处
        大大提高程序的扩展性。
5，多态的弊端
        只能使用父类的引用访问父类中的成员。
6，类型转换
        class Cats extends Animal
        {}
        Animal a = new Cats();//类型提升，向上提升。
        Cats c = (Cats)a;//强制将父类的引用，转成子类。
        强制类型转换的注意事项
        1，基本类型之前的转换只能在数值类型（整型、字符型和浮点型）之间进行。
        2，引用类型之间的转换只能在具有继承关系的两个类型之间进行。
7，instanceof关键字
        作用：避免出现ClassCastException异常。
        用法：前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类。
        读法：判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是，则返回true，否则返回false。
        注意事项：
        运算符前面操作数的编译时类型要么与后面的类型相同，要么与后面的类具有父子类继承关系。
8，多态始终都是子类在做着变化。
9，多态中成员的特点
        只有非静态的成员方法，才会有如下原则：
        编译时看左边，运行时看右边。
        换言之，编译时期。要看引用型变量所属的类中是否有调用方法；
        而运行时，要参考对象所属的类中是否有调用的方法。
        而对于其他成员，则只看左边即可。
10，接口类型的引用变量指向它自己子类的对象。
       
相应例子如下：
接口相关：
  1. interface PCI
  2. {
  3.         public abstract void open();
  4.         public abstract void close();
  5. }

  7. class NetCard implements PCI
  8. {
  9.         public void open()
  10.         {
  11.                 System.out.println("NetCard is open!!!!");
  12.         }
  13.         public void close()
  14.         {
  15.                 System.out.println("NetCard is close!!!!");
  16.         }
  17. }

  19. class SoundCard implements PCI
  20. {
  21.         public void open()
  22.         {
  23.                 System.out.println("SoundCard is open!!!!!!!!");
  24.         }
  25.        
  26.         public void close()
  27.         {
  28.                 System.out.println("SoundCard is close!!!!!");
  29.         }
  30. }

  32. class MainBoard
  33. {
  34.         public void run()
  35.         {
  36.                 System.out.println("the MainBoard is running!!!");
  37.         }
  38.        
  39.         public void usePCI(PCI p)
  40.         {
  41.                 if(p == null)
  42.                         System.out.println("nothing is here!!!");
  43.                
  44.                 p.open();
  45.                 p.close();
  46.         }
  47. }

  49. public class myMainBoard
  50. {
  51.         public static void main(String[] args)
  52.         {
  53.                 MainBoard mb = new MainBoard();
  54.                
  55.                 mb.run();
  56.                
  57.                 mb.usePCI(new NetCard());//接口类型的引用变量指向它自己子类的对象.
  58.                 mb.usePCI(new SoundCard());//接口类型的引用变量指向它自己子类的对象.
  59.         }
  60. }
复制代码


其他与多态相关
  1. class BaseClass
  2. {
  3.         //父类的实例成员变量
  4.         public int booksNums = 6;
  5.        
  6.         public void base()
  7.         {
  8.                 System.out.println("父类的普通方法");
  9.         }
  10.        
  11.         public void test()
  12.         {
  13.                 System.out.println("父类被覆盖的方法");
  14.         }
  15.        
  16.         public static void testStaticMethod()
  17.         {
  18.                 System.out.println("父类的静态方法");
  19.         }
  20. }

  22. class SubClass extends BaseClass
  23. {
  24.         //子类的实例成员变量
  25.         public int booksNums = 8;
  26.        
  27.         public void test()
  28.         {
  29.                 System.out.println("子类覆盖父类的方法");
  30.         }
  31.        
  32.         public void sub()
  33.         {
  34.                 System.out.println("子类的普通方法");
  35.         }
  36.        
  37.         public static void testStaticMethod()
  38.         {
  39.                 System.out.println("子类覆盖父类的静态方法");
  40.         }
  41. }

  43. public class PolymorphismClass
  44. {
  45.         public static void main(String[] args)
  46.         {
  47.                 //父类的引用指向自己子类的对象
  48.                 BaseClass bs = new SubClass();//类型提升
  49.                
  50.                 //对于多态中的成员变量，无论编译和运行，都参考左边。
  51.                 System.out.println(bs.booksNums);
  52.                
  53.                 //对于多态中的非静态方法，编译时，参考左边；运行时，参考右边
  54.                 bs.test();
  55.                 //因此，如下语句报错
  56.                 //bs.sub();
  57.                
  58.                 //对于多态中的静态方法，编译和运行时，都参考右边
  59.                 bs.testStaticMethod();
  60.                
  61.                 SubClass sb = (SubClass)bs;//强制将父类的引用，转成子类。
  62.                 sb.sub();
  63.                
  64.                 //instanceof使用注意事项：
  65.                 //运算符前面操作数的编译时类型要么与后面的类型相同，要么与后面的类具有父子类继承关系。
  66.                 if(sb instanceof BaseClass)
  67.                         System.out.println("sb is a instance of BaseClass");
  68.                 //如下会引起编译错误
  69.                 //if(sb instanceof String)
  70.                         //System.out.println("sb is a instance of Object");
  71.         }
  72. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2