Java设计模式之工厂模式

前面我们讲了单例模式，现在我们继续我们的解读。被问到了解什么设计模式时，我们会说到工厂模式。毕竟我们在接触设计模式的时候数据库连接是工厂模式已经被说了太多次了。

更加深入的理解，工厂模式可以分为简单工厂，工厂和抽象工厂。实现的复杂度也是逐步提升的。它们之间的区别又是什么呢？下面我们一一介绍。

首先我们先说简单工厂，简单工厂我们可以通过唯一标识来区别。直接上代码吧。这样讲太过于干燥了。

int productNo;
        public SimpleFactory(int productNo) //构造工厂时告知工厂产品标识
        {
            this.productNo = productNo;
        }
 
        public IProduct GetProduct()
        {
            switch (productNo) //根据产品标识生产产品
            {
                default:
                    return new ProductA();
                case 1:
                    return new ProductA();
                case 2:
                    return new ProductB();
            }
 
         }
 
 
    }
 
    //产品A
    class ProductA: IProduct
    {
        //产品属性
        //......
    }
 
    //产品B
    class ProductB : IProduct
    {
        //产品属性
        //......
    }
    //产品接口
    interface IProduct
    {
        //产品方法
        //......
    }

已经实现了工厂模式，很开心。有没有？那么问题来了。我们现在添加一个产品 P,那么我们的switch又要添加一条了。每当我们需要添加一个产品的时候都要去添加，这样维护的成本太高了。简单工厂存在这样的问题，工厂出现了。

 interface IFactory //工厂接口
    {
        IProduct GetProduct();
    }
 
    //A工厂类
    public class FactoryA: IFactory
    {
        IProduct productA;
        public FactoryA()
        {
            this.productA = new ProductA();
        }
 
        public IProduct GetProduct() //A工厂生产A产品
        {
            return this.productA;
        }
    }
 
    //B工厂类
    public class FactoryB : IFactory
    {
        IProduct productB;
        public FactoryB()
        {
            this.productB = new ProductB();
        }
 
        public IProduct GetProduct() //B工厂生产B产品
        {
            return this.productB;
        }
    }
 
    //产品接口
    public interface IProduct
    {
        //产品方法
        //......
    }
 
    //产品A
    public class ProductA : IProduct
    {
        //产品属性
        //......
    }
 
    //产品B
    public class ProductB : IProduct
    {
        //产品属性
        //......
    }

工厂模式中将工厂类分开，产品不再是在同一工厂中生产，对不对。即使添加一个产品只需要添加一个产品类和产品工厂了。感觉自己到了人生巅峰？
如今的品牌，不都是单线作战了。生产线可能从手机，洗衣机，电冰箱到电饭煲等等。那这样的话，工厂模式是不是又不能适应我们的需求了呢？这时候抽象工厂就出现了。

/工厂接口，即抽象工厂
        interface IFactory
        {
            IFridge CreateFridge();
            IAirCondition CreateAirCondition();
        }
 
 
        //A的工厂，生产A的产品族
        public class AFactory : IFactory
        {
  
            public IAirCondition CreateAirCondition()
            {
                return new AAirCondition(); //A的工厂生产三星的空调
              
            }
 
            public IFridge CreateFridge()
            {
                return new AFridge(); //A的工厂生产三星的冰箱
            }
        }
 
        //B的工厂，生产B的产品族
 
        public class GreeFactry : IFactory
        {
            public IAirCondition CreateAirCondition()
            {
                return new BAirCondition(); //B的工厂生产格力的空调
            }
 
            public IFridge CreateFridge()
            {
                return new BFridge(); //B的工厂生产格力的冰箱
            }
        }
 
        //冰箱产品接口
        public interface IFridge
        {
            //冰箱产品接口
            //冰箱的action
        }
 
        //空调接口
        public interface IAirCondition
        {
            //空调产品接口
            //空调的action
        }
 
        //A的冰箱
        public class AFridge: IFridge
        {
           //A冰箱的action和property
        }
        //B的冰箱
        public class BFridge : IFridge
        {
             //格力冰箱的action和property
        }
 
        //A的空调
        public class AAirCondition : IAirCondition
        {
           //A空调的action和property
        }
        //B的空调
        public class BAirCondition : IAirCondition
        {
            //格力空调的action和property
        }

抽象工厂模式就解决了我们产品族和产品结构的问题了。

简单工厂，工厂和抽象工厂总结：

1.工厂的实现复杂度逐步提升。

2.简单工厂通过构造传入的标识符来生产产品。所有的产品都是在同一个工厂中生产的。维护的难度会随着产品的增加而增加。

3.工厂模式无法解决产品族和产品结构的问题。

4.抽象工厂中，一个工厂可以生产多个产品，它们是同一个产品族。不同的产品族派生自不同的抽象产品或者产品接口。

工厂模式就讲完了。