Java基础系列16-面向对象之多态

x33g5p2x  于2021-12-18 转载在 其他  
字(3.5k)|赞(0)|评价(0)|浏览(468)

一. 多态的概述

多态是某一个事物,在不同时刻表现出来的不同状态。

举例:
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种,也可以把猫称为动物
  动物 d = new 猫();
  水在不同时刻的状态

多态的前提和体现:

  1. 有继承关系
  2. 有方法重写
  3. 有父类引用指向子类对象

二.多态中成员的访问特点

成员变量访问特点
  编译看左边,运行看左边
成员方法访问特点
  编译看左边,运行看右边

代码:
duotai1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类 多态中成员访问特点
  7. *
  8. * 为什么成员变量和成员方法的访问不一样呢?
  9. * 因为成员方法有重写,而变量没有。
  10. *
  11. */
  12. public class duotai1 {
  13. public int age = 40;
  14. public void eat() {
  15. System.out.println("吃东西");
  16. }
  17. }

duotai2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类子类-猫 多态中成员访问特点
  7. *
  8. */
  9. public class duotai2 extends duotai1 {
  10. public int age = 20;
  11. public int weight = 10;
  12. @Override
  13. public void eat() {
  14. System.out.println("猫吃鱼");
  15. }
  16. public void playGame() {
  17. System.out.println("猫捉迷藏");
  18. }
  19. }

duotai3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类测试类 多态中成员访问特点
  7. *
  8. */
  9. public class duotai3 {
  10. public static void main(String[] args) {
  11. //由父类引用指向子类对象
  12. duotai1 a = new duotai2();
  13. System.out.println(a.age);
  14. //System.out.println(a.weight);//不能访问
  15. a.eat();
  16. //a.playGame();//不能访问
  17. }
  18. }

三. 多态的好处和弊端

多态的好处:
  提高了程序的扩展性
多态的弊端:
  不能访问子类特有功能
  那么如何访问子类的特有功能呢?
    通过多态中的转型

多态转型代码:
duotai_animal

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类 多态的好处和弊端
  7. */
  8. public class duotai_animal {
  9. public int age = 40;
  10. public void eat() {
  11. System.out.println("吃东西");
  12. }
  13. }

duotai_cat

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物子类-猫类 多态的好处和弊端
  7. */
  8. public class duotai_cat extends duotai_animal {
  9. @Override
  10. public void eat() {
  11. System.out.println("猫吃鱼");
  12. }
  13. }

duotai_dog

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物子类-狗类 多态的好处和弊端
  7. */
  8. public class duotai_dog extends duotai_animal {
  9. @Override
  10. public void eat() {
  11. System.out.println("狗吃骨头");
  12. }
  13. public void lookDoor() {
  14. System.out.println("狗看门");
  15. }
  16. }

duotai_pig

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物子类-猪类 多态的好处和弊端
  7. */
  8. public class duotai_pig extends duotai_animal {
  9. @Override
  10. public void eat() {
  11. System.out.println("猪吃白菜");
  12. }
  13. }

duotai_operator

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类的操作类 多态的好处和弊端
  7. */
  8. public class duotai_operator {
  9. public void userAnimal(duotai_cat cat) {
  10. cat.eat();
  11. }
  12. public void userAnimal(duotai_dog dog) {
  13. dog.eat();
  14. dog.lookDoor();
  15. }
  16. public void userAnimal(duotai_pig pig) {
  17. pig.eat();
  18. }
  19. }

duotai_test1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类的测试类 多态的好处和弊端
  7. */
  8. public class duotai_test1 {
  9. public static void main(String[] args) {
  10. //由父类引用指向子类对象
  11. duotai_operator ao = new duotai_operator();
  12. duotai_cat c = new duotai_cat();
  13. duotai_dog d = new duotai_dog();
  14. duotai_pig p = new duotai_pig();
  15. ao.userAnimal(c);
  16. ao.userAnimal(d);
  17. ao.userAnimal(p);
  18. }
  19. }

测试记录:

  1. 猫吃鱼
  2. 狗吃骨头
  3. 狗看门
  4. 猪吃白菜

四. 多态中的转型问题

向上转型
  从子到父
  父类引用指向子类对象
向下转型
  从父到子
  父类引用转为子类对象

代码:
duotai_animal

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物类 多态中的转型问题
  7. */
  8. public class duotai_animal {
  9. public int age = 40;
  10. public void eat() {
  11. System.out.println("吃东西");
  12. }
  13. }

Java_study

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物子类-猫类 多态中的转型问题
  7. */
  8. public class duotai_cat extends duotai_animal {
  9. @Override
  10. public void eat() {
  11. System.out.println("猫吃鱼");
  12. }
  13. public void playGame() {
  14. System.out.println("猫捉迷藏");
  15. }
  16. }

duotai_test2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 动物子类-猫类 多态中的转型问题
  7. */
  8. public class duotai_test2 {
  9. public static void main(String[] args) {
  10. duotai_animal a = new duotai_animal();
  11. a.eat();
  12. //a.playGame();
  13. /*
  14. 不能访问
  15. 多态的弊端:无法访问子类特有方法
  16. 现在我就想使用子类特有方法,怎么办呢?
  17. 创建子类对象就可以了
  18. */
  19. duotai_cat c1 = new duotai_cat();
  20. c1.eat();
  21. c1.playGame();
  22. /*
  23. 现在代码虽然可以访问子类的特有功能,但是不合理
  24. 因为我们发现内存中有两个猫类的对象
  25. 这个时候,我们得想办法把多态中的猫对象还原
  26. 这个时候就需要使用多态中的转型了
  27. 父类引用转为子类对象
  28. */
  29. duotai_animal a2 = new duotai_cat();
  30. duotai_cat c2 = (duotai_cat)a2;
  31. c2.eat();
  32. c2.playGame();
  33. }
  34. }

测试记录:

  1. 吃东西
  2. 猫吃鱼
  3. 猫捉迷藏
  4. 猫吃鱼
  5. 猫捉迷藏

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115209518

相关文章