java8-3 多态的好处和弊端以及多态的理解

Posted 2020-08-08 卡拉瓦

多态的好处：
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)

猫狗案例代码

  1 class Animal {
  2     public void eat(){
  3         System.out.println("eat");
  4     }
  5     
  6     public void sleep(){
  7         System.out.println("sleep");
  8     }
  9 }
 10 
 11 class Dog extends Animal {
 12     public void eat(){
 13         System.out.println("狗吃肉");
 14     }
 15     
 16     public void sleep(){
 17         System.out.println("狗站着睡觉");
 18     }
 19 }
 20 
 21 class Cat extends Animal {
 22     public void eat() {
 23         System.out.println("猫吃鱼");
 24     }
 25     
 26     public void sleep() {
 27         System.out.println("猫趴着睡觉");
 28     }
 29 }
 30 
 31 class Pig extends Animal {
 32     public void eat() {
 33         System.out.println("猪吃白菜");
 34     }
 35     
 36     public void sleep() {
 37         System.out.println("猪侧着睡");
 38     }
 39 }
 40 
 41 //针对动物操作的工具类
 42 class AnimalTool {
 43     private AnimalTool(){}
 44 
 45     /*
 46     //调用猫的功能
 47     public static void useCat(Cat c) {
 48         c.eat();
 49         c.sleep();
 50     }
 51     
 52     //调用狗的功能
 53     public static void useDog(Dog d) {
 54         d.eat();
 55         d.sleep();
 56     }
 57     
 58     //调用猪的功能
 59     public static void usePig(Pig p) {
 60         p.eat();
 61         p.sleep();
 62     }
 63     */
 64     public static void useAnimal(Animal a) {
 65         a.eat();
 66         a.sleep();
 67     }
 68     //把所有的可能都归为动物类
 69 }
 70 
 71 class DuoTaiDemo2 {
 72     public static void main(String[] args) {
 73         //我喜欢猫，就养了一只
 74         Cat c = new Cat();
 75         c.eat();
 76         c.sleep();
 77         
 78         //我很喜欢猫，所以，又养了一只
 79         Cat c2 = new Cat();
 80         c2.eat();
 81         c2.sleep();
 82         
 83         //我特别喜欢猫，又养了一只
 84         Cat c3 = new Cat();
 85         c3.eat();
 86         c3.sleep();
 87         //...
 88         System.out.println("--------------");
 89         //问题来了,我养了很多只猫，每次创建对象是可以接受的
 90         //但是呢?调用方法，你不觉得很相似吗?仅仅是对象名不一样。
 91         //我们准备用方法改进
 92         //调用方式改进版本
 93         //useCat(c);
 94         //useCat(c2);
 95         //useCat(c3);
 96         
 97         //AnimalTool.useCat(c);
 98         //AnimalTool.useCat(c2);
 99         //AnimalTool.useCat(c3);
100         
101         AnimalTool.useAnimal(c);
102         AnimalTool.useAnimal(c2);
103         AnimalTool.useAnimal(c3);
104         System.out.println("--------------");
105         
106         //我喜欢狗
107         Dog d = new Dog();
108         Dog d2 = new Dog();
109         Dog d3 = new Dog();
110         //AnimalTool.useDog(d);
111         //AnimalTool.useDog(d2);
112         //AnimalTool.useDog(d3);
113         AnimalTool.useAnimal(d);
114         AnimalTool.useAnimal(d2);
115         AnimalTool.useAnimal(d3);
116         System.out.println("--------------");
117         
118         //我喜欢宠物猪
119         //定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类方法调用
120         Pig p = new Pig();
121         Pig p2 = new Pig();
122         Pig p3 = new Pig();
123         //AnimalTool.usePig(p);
124         //AnimalTool.usePig(p2);
125         //AnimalTool.usePig(p3);
126         AnimalTool.useAnimal(p);
127         AnimalTool.useAnimal(p2);
128         AnimalTool.useAnimal(p3);
129         System.out.println("--------------");
130         
131         //我喜欢宠物狼，老虎，豹子...
132         //定义对应的类，继承自动物，提供对应的方法重写，并在工具类添加方法调用
133         //前面几个必须写，我是没有意见的
134         //但是，工具类每次都改，麻烦不
135         //我就想，你能不能不改了
136         //太简单：把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?
137         //改用另一种解决方案。
138         
139     }
140     
141     /*
142     //调用猫的功能
143     public static void useCat(Cat c) {
144         c.eat();
145         c.sleep();
146     }
147     
148     //调用狗的功能
149     public static void useDog(Dog d) {
150         d.eat();
151         d.sleep();
152     }
153     */
154 }

2、

多态的弊端：
不能使用子类的特有功能。

我就想使用子类的特有功能?行不行?
行。

怎么用呢?
A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题：
向上转型：
Fu f = new Zi();
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的.(所属关系)

多态的问题理解：
class 孔子爹 {
public int age = 40;

public void teach() {
System.out.println("讲解JavaSE");
}
}

class 孔子 extends 孔子爹 {
public int age = 20;

public void teach() {
System.out.println("讲解论语");
}

public void playGame() {
System.out.println("英雄联盟");
}
}

//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
//向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语
//k爹.playGame(); //这是儿子才能做的


//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
//向下转型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟

2、向下转型中有可能的异常：
ClassCastException:类型转换异常
一般在多态的向下转型中容易出现