浅谈工厂模式（初来乍到，意气风发）

Hello Everyone!

今天我想和我同样喜欢java的朋友们分享一下我学习java设计模式之工厂模式的一点小总结，希望大家对我这样一个初学者指点迷津，谢谢

一.引子

   我们都知道，对于规模较大的程序来说，模块之间的联系以及模块内部的独立性尤为重要，简而言之一句话，做到“高内聚，低耦合”。这种设计提高了模块的复用性、功能更改的灵活性以及系统后期的维护性。那么，我们怎么做到这一点呢，java中提供了23种设计模式（可以理解为经验总结的编程设计方式和思想）供编程人员使用，在这里我只简单谈一下工厂设计模式。

二.工厂设计模式

   *目的：工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，

达到提高灵活性的目的；

   *分类：简单工厂模式（SimpleFactory）

          工厂方法模式（FactoryMethod）

          抽象工厂模式（AbstractFactory）

1.简单工厂模式

（又称静态工厂方法模式，可以理解为工厂方法的一种特例）

   以下是一个汽车生产车间生产不同牌子的汽车，并且由客户指定买哪种牌子的汽车的过程：

package SimpleFactory;
//定义接口，抽象产品类
interface Car{
    public void drive();
}
//定义工厂类
public class Factory {
    public static Car driveCar(String str){
        if(str.equalsIgnoreCase("奥迪")){
            return new Aodi();
        }else if(str.equalsIgnoreCase("宝马")){
            return new Baoma();
        }return null;
    }
}
//定义具体产品类，继承抽象产品类接口
class Aodi implements Car{
    public void drive(){
        System.out.println("买奥迪车");
    }
}
class Baoma implements Car{
    public void drive(){
        System.out.println("买宝马车");
    }
}

package SimpleFactory;
public class Test{
    public static void main(String[] args) {
        Car car=Factory.driveCar("宝马");
        car.drive();
        Car car1=Factory.driveCar("奥迪");
        car1.drive();
    }
}

   由例子看出：

   当顾客想要买一辆新车的时候，只要符合抽象产品类，那么只要通知工厂类知道就可以被客户使了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分就不太理想，因为每增加一中牌子的车，都要在工厂类中增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。这个例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。但由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会使我们这些程序员累坏了:(

于是工厂方法模式作为我么的救世主出现了。

2.工厂方法模式

 相对于简单工厂方法的改进：

 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工         厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

仍以上述例子为例：

     

package FactoryMethod;
//定义接口，抽象产品类
interface Car {
    public void buy();
}
//实现接口，具体实现类
class Aodi implements Car{
    public void buy(){
        System.out.println("买奥迪车");
    }
}
class Baoma implements Car{
    public void buy(){
        System.out.println("买宝马车");
    }
}
//定义接口，抽象工厂类
interface Buy{
    public Car  buyCar();
}
//实现接口，具体工厂类
class BuyAodi implements Buy{
    public Car buyCar(){
        return  new Aodi();
    }
}
class BuyBaoma implements Buy{
    public Car buyCar(){
        return  new Baoma();
    }
}
/*//定义工厂类
public class Factory {
    public static Car driveCar(String str){
        if(str.equalsIgnoreCase("奥迪")){
            return new Aodi();
        }else if(str.equalsIgnoreCase("宝马")){
            return new Baoma();
        }return null;
    }
}*/
//定义具体产品类，继承抽象产品类接口

package FactoryMethod;
public class Test{
    public static void main(String[] args) {
        Buy buy=new BuyAodi();
        Car car=buy.buyCar();
        car.buy();
    }
}

   可以看出，工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。

   也可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类。

   那我们是否一定要在代码中遍布工厂呢？简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。

   面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制――这在Spring 中

完美的体现了出来。

3.抽象工厂模式

   先来认识下什么是产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。还是让我们用一个例子来形象地说明一下吧：

   奥迪车有跑车，也有自行车（例子而已哈），宝马车有跑车同样也有自行车，那么这两种不同牌子的跑车就属于一个产品族，同样两个牌子的自行车也属于一个产品族。

   可以说，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。

   抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象，而且使用抽象工厂模式还要满足一下条件：

1) 系统中有多个产品族，而系统一次只可能消费其中一族产品。

2) 同属于同一个产品族的产品一起使用。

//定义接口，抽象动物工厂类
public interface IAnimalFactory {
　　　ICat createCat();
　　　IDog createDog();
}
//具体实现类，创建黑色动物这一产品族的对象，包括黑猫和黑狗
public class BlackAnimalFactory implements IAnimalFactory {
    public ICat createCat() {
        return new BlackCat();
　　　}
　　　public IDog createDog() {
        return new BlackDog();
    }
}
//具体实现类，创建白色动物这一产品族的对象，包括白猫和白狗
public class WhiteAnimalFactory implements IAnimalFactory {
    public ICat createCat() {
        return new WhiteCat();
    }
    public IDog createDog() {
        return new WhiteDog();
    }
}
//定义接口，抽象产品类
public interface ICat {
    void eat();
}
//定义接口，抽象产品类
public interface IDog {
    void eat();
}
//产品的具体实现类，包括每一个具体的产品类的定义
public class Blackcat implements ICat {
    public void eat() {
        System.out.println("The black cat is eating!");
    }
}
public class WhiteCat implements ICat {
    public void eat() {
        System.out.println("The white cat is eating! ");
    }
}
public class BlackDog implements IDog {
    public void eat() {
        System.out.println("The black dog is eating");
    }
}
public class WhiteDog implements IDog {
    public void eat() {
        System.out.println("The white dog is eating!");
    }
}

public static void main(String[] args) {
    IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
    ICat blackCat = blackAnimalFactory.createCat();
　　　blackCat.eat();//he black cat is eating!
    IDog blackDog = blackAnimalFactory.createDog();
    blackDog.eat();//The black dog is eating!
                                                                                                                                                                                                                                                                                                                                                                                                                                              
    IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
    ICat whiteCat = whiteAnimalFactory.createCat();
    whiteCat.eat();//The white cat is eating!
    IDog whiteDog = whiteAnimalFactory.createDog();
    whiteDog.eat();//The white dog is eating!
}

（就到这里啦，晚安）