第二阶段-Java面向对象：【第三章 多态】

代码：Fu fu = new zi;

我们按照上面给出格式来写一段代码（Zi继承Fu类）

A：成员变量

编译看左边，运行看左边

B：构造方法

创建子类对象的时候，访问父类的构造方法，对父类的

数据进行初化

C；成员方法

编译看左边，运行看右边

D；静态方法

编译看左边，运行看右边

看左边即在左边即父类中寻找，看右边即在子类中寻找

多态的好处：

A：提高了代码的维护性（继承保护）

B：提高了代码的扩展性（由多态保证）

Eg：例如一个程序中 狗 猫 猪 都继承于动物类（Eg：AnimalTool）

分别写出对应的行为方法（Eg：eat() ）

而将调用动物功能的代码 写入动物操作工具类

但是添加新的动物时，每次都需要修改工具类

为了优化代码，将工具类中 每一个动物的操作代码名字

写为动物总称，添加新动物后，只需要在Demo中创建 新动物的对象 然后直接调用这个总的动物操作工具类

  
  
class Animal {
     public void eat() {
         System.out.println("eat");
     }
 }
 
 class Dog extends Animal {
     public void eat() {
         System.out.println("狗吃肉");
     }
 }
 
 class Cat extends Animal {
     public void eat() {
         System.out.println("猫吃肉");
     }
 }
 
 
 class AnimalTool {
     private AnimalTool() {}
     
 //调用猫的功能
     public static void useCat(Cat c) {
         c.eat();
     }
     
 //调用狗的功能
     public static void useDog(Dog d) {
         d.eat();
     }
     
 //把所有的可能都归为动物类
     public static void useAnimal(Animal a) {
         a.eat(); 还可以写其他方法
     }
 }

  
  
public class DuoTaiDemo {
     public static void main(String[] args) {
         
 /*
 * 直接创对象调用对应方法
 */
         
 //我养了一只狗
         Dog d = new Dog();
         d.eat();
         
 //我又养了一只狗
         Dog d2 = new Dog();
         d2.eat();
         
         
 /*
 * 创对象、使用动物操作类调用对应方法（）
 */
         Dog d3 = new Dog();
         Dog d4 = new Dog();
         AnimalTool.useDog(d3);
         AnimalTool.useDog(d4);
         
 //我喜欢猫
 //定义一个猪类，它要继承自动物，提一个eat()方法
 //并且还得再工具类中添加该类方法的调用（即类似前面useDog()）这样无疑很麻烦
         
         Cat c = new Cat();
         Cat c2= new Cat();
         AnimalTool.useCat(c);
         AnimalTool.useCat(c2);
         
 //推荐使用多态
         AnimalTool.useAnimal(c);
         AnimalTool.useAnimal(c2);
     }

多态的弊端：

不能使用子类的特有功能

如果想使用：

·创建子类对象调用方法即可（可以但是很多时候不合理，而且太占内存）

·把父类的引用强制转换为子类的引用（向下转型）

对象间的转型问题：

向上转型：

Fu f = new Zi();

向下转型：

Zi z = (Zi)f;   要求f必须能够转为Zi

  
  
class Fu {
     public void show() {
         System.out.println("show Fu");
     }
 }
 
 class Zi {
     public void show() {
         System.out.println("show Zi");
     }
     
     public void method() {
         System.out.println("method Zi");
     }
 }
 
 class DuoTaiDemo2 {
     public static void main(String[] args) {
         Fu fu = new Zi();
         fu.show();
 //fu.method(); 错误，不能使用子类特有功能
         
 //通过转型可以使用子类特有功能
         
 //创建子类对象
 //可以但是不推荐
         Zi zi = new Zi();
         zi.show();
         zi.method();
         
 //要求f必须能够转为Zi
 //推荐（）
         Zi zi2 = (Zi)fu;
     }
 }