设计模式——工厂模式

从现实入手

还记得前面讲到过的简单工厂模式吗？
在客户端（main中）的时候仍然需要用到AnimalFactory.getAnimale(0) 来对动物种类进行选择，则当新增加动物种类的时候，不得不在原工厂类AnimalFactory 中进行代码的改动，这相当于在后台进行改
动。
现在我们要解决的就是去掉Factory中的switch语句和任何判断的逻辑，仅仅利用继承或者多态在客户端实现对动物的选择。

首先定义动物的基本性质（吃，叫，跑，睡）。
interface Animal{
    public void eat();
    public void shout();
    public void run();
    public void sleep();
}

然后实现物种多样化

class Dog implements Animal{

    @Override
    public void eat() {
        System.out.println("dog eat");
    }

    @Override
    public void shout() {
        System.out.println("dog shout");

    }

    @Override
    public void run() {
        System.out.println("dog run");

    }

    @Override
    public void sleep() {
        System.out.println("dog sleep");

    }
}

class Cat implements Animal{

    @Override
    public void eat() {
        System.out.println("cat eat");

    }

    @Override
    public void shout() {
        System.out.println("cat shout");

    }

    @Override
    public void run() {
        System.out.println("cat run");

    }

    @Override
    public void sleep() {
        System.out.println("cat sleep");

    }
}

至此，与简单工厂模式没有任何区别。重点如下：
将工厂虚拟化，使得具体的工厂生产具体的动物，而所有的具体工厂都应该具有抽象工厂的特性（属性或者方法）。这个抽象的工厂如下：

interface Factory{
    public Animal getAnimal();
}

对于上述的动物，需要有对应的动物工厂：

class DogFactory implements Factory{

    @Override
    public Animal getAnimal() {
        return new Dog();
    }
}

class CatFactory implements Factory{

    @Override
    public Animal getAnimal() {
        return new Cat();
    }
}

最终，客户端所要实现的东西即为：

public static void main(String[] args){
        Factory dogFac = new DogFactory();
        Animal dog = dogFac.getAnimal();
        Factory catFac = new CatFactory();
        Animal cat = catFac.getAnimal();

    }

而不是简单工厂方法中的：

public static void main(String[] args){
        List<Animale> zoo = new ArrayList<Animale>();
        for(int i=0;i<4;i++)
            zoo.add(AnimalFactory.getAnimale(0));
        for(int i=0;i<2;i++)
            zoo.add(AnimalFactory.getAnimale(1));
        for(int i=0;i<4;i++)
            zoo.add(AnimalFactory.getAnimale(2));
        for(int i=0;i<2;i++)
            zoo.add(AnimalFactory.getAnimale(3));

        for(Animale animale:zoo){
            //animale....
        }
    }

这样做的好处是，充分体现了面向接口编程而不是面向实现编程。面向接口，相当于将具体的实现插入到了这个接口。即便实现的东西有问题（DogFactory or CatFactory）,直接把它替换掉，或者修改对应的实现类即可；如果需要增加新的物种（山羊，母鸡等等），只需要在Factory接口上插入GoatFactory或者ChickenFactory即可。
其实按照这个思路，Animal 这个接口的实现也可以理解为在Animal的接口上插入各种具体的动物。

打个比方：就好比计算机的主板上本身有各种各样的插口，内存的、硬盘的、cpu的等等，这些都是接口；接口上插的是对应的实现，比如内存条，硬盘和不同规格的cpu。当这些实现坏了，就直接拔下来换个好的插上，就相当于上述例子中Factory接口上的DogFactory有问题，那么直接修改DogFactory即可，而不用动CatFactory，更不用动主板main方法。
试想如果计算机的主板上不是插口，而是直接焊接的各种原件，那么当任何一个坏掉之后，都需要对主板进行修理，那么这个损失将是巨大的。换言之，在简单工厂模式中，改动任何一个动物（增加、删除）都会使得Factory类进行修改同时，客户端main中的逻辑也可能需要修改。

综上所述，工厂模式的的确确很好的体现了面向接口编程的思想，也更好的利用多态，将类和类之间有效的解耦，是一款经典的设计模式。