多态（二）--例子

有一个动物类，1.0版本只有吃、睡得方法。
而1.1时代动物类就有了很多子类，这些子类都有他们各自吃睡得方法，但是行为跟父类是一样的，属于方法的重载。

因为动物太多了，我可以每次都去创建对象，但是每次调用对象的方法都是相同的过程，所以1.2时代，我可以把这个过程抽取出来，放在另外一个工具类中，把我每次调用方法的过程都封装到工具类中。
在这个工具类中，这些方法处理参数不同，其他的都相同。

我又发现这些参数有一个共同的父类Animal，而参数调用的方法父类中都有，所以在1.3时代，我用多态的特点把这些参数换成父类，让父类的引用去调用子类的方法，这样多个方法就变成了一个方法了。

/1.0版本的动物类/
class Animal {
public void eat(){
System.out.println(“eat”);
}

public void sleep(){
    System.out.println("sleep");
}

}

/1.1版本动物的子类/
class Dog extends Animal {
public void eat(){
System.out.println(“狗吃肉”);
}

public void sleep(){
    System.out.println("狗站着睡觉");
}

}

class Cat extends Animal {
public void eat() {
System.out.println(“猫吃鱼”);
}

public void sleep() {
    System.out.println("猫趴着睡觉");
}

}

class Pig extends Animal {
public void eat() {
System.out.println(“猪吃白菜”);
}

public void sleep() {
    System.out.println("猪侧着睡");
}

}

//1.2时代：针对动物操作的工具类
class AnimalTool {
private AnimalTool(){}

/*
//调用猫的功能
public static void useCat(Cat c) {
    c.eat();
    c.sleep();
}

//调用狗的功能
public static void useDog(Dog d) {
    d.eat();
    d.sleep();
}

//调用猪的功能
public static void usePig(Pig p) {
    p.eat();
    p.sleep();
}
*/

//把所有的可能都归为动物类
public static void useAnimal(Animal a) {
    a.eat();
    a.sleep();
}

}

class DuoTaiDemo2 {
public static void main(String[] args) {
//我喜欢猫，就养了一只
Cat c = new Cat();
c.eat();
c.sleep();

    //我很喜欢猫，所以，又养了一只
    Cat c2 = new Cat();
    c2.eat();
    c2.sleep();

    //我特别喜欢猫，又养了一只
    Cat c3 = new Cat();
    c3.eat();
    c3.sleep();
    //...
    System.out.println("--------------");
    //问题来了,我养了很多只猫，每次创建对象是可以接受的
    //但是呢?调用方法，你不觉得很相似吗?仅仅是对象名不一样。
    //我们准备用方法改进
    //调用方式改进版本
    //useCat(c);
    //useCat(c2);
    //useCat(c3);

    //AnimalTool.useCat(c);
    //AnimalTool.useCat(c2);
    //AnimalTool.useCat(c3);

    AnimalTool.useAnimal(c);
    AnimalTool.useAnimal(c2);
    AnimalTool.useAnimal(c3);
    System.out.println("--------------");

    //我喜欢狗
    Dog d = new Dog();
    Dog d2 = new Dog();
    Dog d3 = new Dog();
    //AnimalTool.useDog(d);
    //AnimalTool.useDog(d2);
    //AnimalTool.useDog(d3);
    AnimalTool.useAnimal(d);
    AnimalTool.useAnimal(d2);
    AnimalTool.useAnimal(d3);
    System.out.println("--------------");

    //我喜欢宠物猪
    //定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类方法调用
    Pig p = new Pig();
    Pig p2 = new Pig();
    Pig p3 = new Pig();
    //AnimalTool.usePig(p);
    //AnimalTool.usePig(p2);
    //AnimalTool.usePig(p3);
    AnimalTool.useAnimal(p);
    AnimalTool.useAnimal(p2);
    AnimalTool.useAnimal(p3);
    System.out.println("--------------");

    //我喜欢宠物狼，老虎，豹子...
    //定义对应的类，继承自动物，提供对应的方法重写，并在工具类添加方法调用
    //前面几个必须写，我是没有意见的
    //但是，工具类每次都改，麻烦不
    //我就想，你能不能不改了
    //太简单：把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?
    //改用另一种解决方案。

}

/*
//调用猫的功能
public static void useCat(Cat c) {
    c.eat();
    c.sleep();
}

//调用狗的功能
public static void useDog(Dog d) {
    d.eat();
    d.sleep();
}
*/

}