设计模式－工厂模式

工厂模式：

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

工厂模式属于设计模式的创建型 设计模式。
一般分为： 产品类 工厂类

一. 简单工厂模式 （是工厂方法的一种特例）
二. 工厂方法模式

产品类：

abstract class  Animal{    abstract void run();}class Dog extends Animal{ void run(){     system.out.printf("dog  run "); }}class Pig extends Animal{    void run(){        system.out.printf("pig run");    }}

工厂类：

 class Factory{    public Animal  getAnimal(string animalType){            if(animalType ==null){                return null;            }            if("dog".equalsIgnoreCase(animalType) ){                return new Dog();            }            if("pig".equalsIgnoreCase(animalType)){                return new Pig();            }        }    }

测试代码：

1.普通实现代码（不使用 设计模式）

class Test{        public void main(string args[]){            Dog dog= new Dog();            Pig pig=new Pig();            dog.run();            pig.run();        }}

2.普通实现代码（加点抽象）

class Test{    public void main(string args[]){        Animal dog=new Dog();        Animal pig=new Pig();        dog.run();        pig.run();    }   }class Test{    public void main(string args[]){        Animal animal=new dog();        //Animal animal=new pig();          animal.run();    }}

3 . 工厂方法实现代码

class Test{    public void main (string args[]){        Factory factory=new Factory();        Animal animal=factory.getAnimal("dog");        animal.run();    }}

现在我们来对比 上面三种实现方式：
1 .普通实现代码 2 普通实现加点抽象 3 工厂方法 以下简称 1 2 3

1 是我们最常用的， 我们在开始学习java 的时候 都是这样做，但是随着我们不再做练习级别的编程，而是过渡 到项目的时候， 1的这种方式会导致 耦合很严重（类与类模块与模块太过依赖）
我们希望在实例产品的时候，是不用关注到 具体具体的产品的细节。 1 2 都关注到了具体的产品。 3 则使用工厂，对我们屏蔽了 产品的细节。 我们只要关注到工厂就行。

3 则只需要 工厂类 但是我们可以看到。 3也是有缺陷的。首先需要破坏 开闭原则 因为需要传参 来确定 实例话的类。我们如果添加一种新的产品 还需要对 工厂进行改动
可以看到 1 2 3 是一直在进化。但是3 还是不够满足我们的需求。

三. 抽象工厂模式：

产品类:

abstract Fruit{    abstract  void eat();}class Apple  extends Fruit{    void eat(){        system.out.printf("Apple eat");    }}class Pear extends Fruit{    void eat(){        system.out.printf("Pear eat");    }}

4 .工厂类：

 abstract Factory{        abstract Fruit CreatFruit();        abstract Animal CreatAnimal();  }class DefaultFactory abstract Factory{    Fruit CreatFruit(){        return new Dog();       }    Animal CreatAnimal(){        return new Apple();    }}

测试类:

class Test{    public void main(){        Factory factory=new DefaultFactory();        Fruit fruit=factory.CreatFruit();        Animal animal=factory.CreatAnimal();    }}

对比 3 4 我们可以看到，如果添加一个 新的产品， 我们只需要 再实现一个 子类 继承抽象工厂类 奇就可以了，也不会破坏 开闭原则

以上如有 错误，欢迎指正。

参考：

http://blog.csdn.net/jason0539/article/details/23020989
http://www.javatpoint.com/abstract-factory-pattern
http://www.cnblogs.com/forlina/archive/2011/06/21/2086114.html