黑马程序员技术交流社区

标题: 【Java基础交流】之【一张贴搞定多态调用】!! [打印本页]

作者: 传奇查    时间: 2015-11-18 17:41
标题: 【Java基础交流】之【一张贴搞定多态调用】!!
感觉对你有用就给个鼓励吧~~
多态的概念:
  1. package cn.fuxi.jiekou;
  2. /**
  3. * 多态:某一类事物的多种存在形态
  4. *
  5. * 例:动物中猫,狗.
  6. * 猫这个对象对应的类型时猫类型:猫 c = new 猫();
  7. * 同时猫也是动物中的一种,可以把猫称为动物:动物 c = new 猫();
  8. * 动物是猫和狗具体事物中抽取出来的父类型.
  9. * 父类型引用指向了子类对象.
  10. *
  11. * 多态性简单说就是一个对象对应着不同类型.
  12. *
  13. * 体现:父类或者接口的引用指向或者接收自己的子类对象.
  14. * 作用:多态的存在提高了程序的扩展性和后期的可维护性.
  15. * 前提:
  16. * 1.需要存在继承或者实现关系.
  17. * 2.需要有覆盖操作.
  18. *
  19. * 好处:提高了代码的扩展性,前期定义的代码可以使用后期的内容.
  20. * 弊端:前期定义的内容不能使用(调用)后期子类的特有内容.
  21. */

  22. abstract class Animal{
  23.         abstract void eat();
  24. }

  25. class Dog extends Animal{
  26.         void eat(){
  27.                 System.out.println("狗吃骨头");
  28.         }
  29.         void lookHome(){
  30.                 System.out.println("狗看家");
  31.         }
  32. }

  33. class Cat extends Animal{
  34.         void eat(){
  35.                 System.out.println("猫吃猫粮");
  36.         }
  37.         void catchMouse(){
  38.                 System.out.println("猫捉老鼠");
  39.         }
  40. }

  41. class Pig extends Animal{
  42.         void eat(){
  43.                 System.out.println("猪吃饲料");
  44.         }
  45.         void gongDi(){
  46.                 System.out.println("猪会拱地");
  47.         }
  48. }

  49. public class InterfaceDemo5 {
  50.         public static void main(String[] args) {
  51.                 Animal c = new Cat();
  52.                 Dog d = new Dog();
  53.                 method(c);//猫吃猫粮
  54.                 method(d);//狗吃骨头
  55.                 method(new Pig());//猪吃饲料
  56.                 //自动类型提升,猫对象提升到了动物类型.但是特有功能无法访问,作用就是限制对特有功能的访问.
  57.                 //向上转型,将子类型隐藏,就不能使用子类特有方法了
  58.                 //c.catchMouse();报错
  59.                 //如果还想用具体动物猫的特有功能,可以向下转型(强转为猫)
  60.                 Cat c1 = (Cat)c;
  61.                 c.eat();
  62.                 c1.catchMouse();
  63.                 //注意:对应转型,自始至终都是子类对象在做类型的变化.
  64.                 Animal dog = new Dog();
  65.                 Cat e = (Cat)dog;//编译不报错,但是运行报错,Dog无法转换成Cat
  66.                 e.eat();//无法运行,编译不报错
  67.         }
  68.         public static void method(Animal a){
  69.                 a.eat();
  70.                 }
  71. }
复制代码

运行结果:
猫吃猫粮
Exception in thread "main" 狗吃骨头
猪吃饲料
猫吃猫粮
猫捉老鼠
java.lang.ClassCastException: cn.fuxi.jiekou.Dog cannot be cast to cn.fuxi.jiekou.Cat
at cn.fuxi.jiekou.InterfaceDemo5.main(InterfaceDemo5.java:70)



多态应用案列:
  1. package cn.fuxi.jiekou;
  2. //毕老师和毕姥爷的故事
  3. class BiLaoYe{
  4.         void teacher(){
  5.                 System.out.println("管理");
  6.         }
  7.         void fishing(){
  8.                 System.out.println("钓鱼");
  9.         }
  10. }
  11. class BiLaoShi extends BiLaoYe{
  12.         void teacher(){
  13.                 System.out.println("java");
  14.         }
  15.         void movie(){
  16.                 System.out.println("看电影");
  17.         }
  18. }

  19. public class DuoTai {
  20.         public static void main(String[] args) {
  21.                 BiLaoShi bs = new BiLaoShi();
  22.                 bs.teacher();
  23.                 bs.movie();
  24.                 //多态调用时,只能用重写过的父类的功能,不能用自己特有的功能
  25.                 BiLaoYe by = new BiLaoShi();
  26.                 by.teacher();
  27.                 by.fishing();
  28.                 //如果要用自己特有的功能,可以把类型转换为自己.
  29.                 BiLaoShi by1 =(BiLaoShi)by;
  30.                 by1.movie();
  31.         }
  32. }
复制代码

运行结果:
java
看电影
java
钓鱼
看电影


转换前的类型判断:
  1. package cn.fuxi.duotai;
  2. /**
  3. * P.S. instanceof:用于判断对象的具体类型,只能用于引用数据类型判断,通常在向下转型前用于健壮性的判断.
  4. */
  5. class Animal{
  6.         void eat(){}
  7.         void sleep(){}
  8. }
  9. class Cat extends Animal{
  10.         void eat(){
  11.                 System.out.println("猫吃猫粮");
  12.         }
  13.         void catchMouse(){
  14.                 System.out.println("猫捉老鼠");
  15.         }
  16. }
  17. class Dog extends Animal{
  18.         void eat(){
  19.                 System.out.println("狗吃骨头");
  20.         }
  21.         void lookHome(){
  22.                 System.out.println("狗会看家");
  23.         }
  24. }
  25. public class InstanceofDemo {

  26.         public static void main(String[] args) {
  27.                 Animal a = new Cat();
  28.                 method(a);
  29.                 method(new Cat());
  30.                 method(new Dog());
  31.         }
  32.         public static void method(Animal a){
  33.                 a.eat();
  34.                 if(a instanceof Cat){
  35.                         Cat c =(Cat)a;
  36.                         c.catchMouse();
  37.                 }
  38.                 else if(a instanceof Dog){
  39.                         Dog d = (Dog)a;
  40.                         d.lookHome();
  41.                 }
  42.         }
  43. }
复制代码
运行结果:
猫吃猫粮
猫捉老鼠
猫吃猫粮
猫捉老鼠
狗吃骨头
狗会看家

多态特点汇总:
  1. package cn.fuxi.duotai;
  2. /**
  3. * 多态时,成员的特点:
  4. * 1.成员变量
  5. * 编译时:参考引用型变量所属的类中是否有调用的成员变量?有,编译通过,没有,编译失败.
  6. * 运行是:参考引用型变量所属的类中是否有调用的成员变量?并运行该所属类中的成员变量.
  7. * 简单说:编译和运行都参考等号的左边.(成员变量全用爹的)
  8. *
  9. * 2.成员函数(非静态)
  10. * 编译时:参考引用型变量所属的类中是否有调用的函数.有,编译通过.没有,编译失败.
  11. * 运行时:参考的是对象所属的类中是否有调用的函数.
  12. * 简单说:编译看左边,运行看右边.(自己有用自己,没有就借爹的)
  13. *
  14. * 3.静态函数
  15. * 编译时:参考的是对象所属的类中是否有调用的函数.
  16. * 运行时:参考的是对象所属的类中是否有调用的函数.
  17. * 简单说:编译和运行都砍左边.(静态全用爹的)
  18. */

  19. class Fu{
  20.         int num = 3;
  21.         void show(){
  22.                 System.out.println("fu show");
  23.         }
  24.         static void method(){
  25.                 System.out.println("fu static method");
  26.         }
  27. }
  28. class Zi extends Fu{
  29.         int num = 4;
  30.         void show(){
  31.                 System.out.println("zi show");
  32.         }
  33.         static void method(){
  34.                 System.out.println("zi static method");
  35.         }
  36. }
  37. public class DuoTaiDemo {
  38.         public static void main(String[] args) {
  39.                 //Zi z = new Zi();
  40.                 //System.out.println(z.num);
  41.                 Fu f = new Zi();
  42.                 System.out.println(f.num);
  43.                 f.show();
  44.                 f.method();
  45.                 Fu.method();
  46.                 //Zi.method();
  47.         }
  48. }
复制代码

运行结果:
3
zi show
fu static method
fu static method



感觉对你有用就给个鼓励吧~~


作者: 洋葱头头    时间: 2015-11-18 17:54
没用  我都会了
作者: 传奇查    时间: 2015-11-18 21:21
洋葱头头 发表于 2015-11-18 17:54
没用  我都会了

您是大神呀!已经博士后毕业了~我们还是努力奋斗的小学渣~
作者: 袁有福123    时间: 2015-11-18 22:51
很棒  !将这些全部都写在一起  起到了对比的效果 更能清楚明白的看出其中的区别所在 非常好!赞!
作者: oup    时间: 2015-11-18 23:18
楼主总结得非常不错!
作者: mlxg    时间: 2015-11-18 23:29
有心,赞一个!!!
作者: DoubleUUU    时间: 2015-11-19 00:13
多态已然弄懂,现在突破多线程




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