Java设计模式学习之工厂模式

简单工厂模式

我直接上代码代码里有很详细的注解

//简单工厂模式 是由一个工厂对象决定创建出哪种产品

class Factory1
{
         publicstatic void main(String[] args)
         {
                   //通过工厂方法生产白面包
                   BreadMakerwhite=BreadFactory.createBreadMaker(0);
                   white.GetMaker();
                   //通过工厂方法生产黑面包
                   BreadMakerblack=BreadFactory.createBreadMaker(1);
                   black.GetMaker();
                   //通过工厂方法生产绿面包
                   BreadMakergreen=BreadFactory.createBreadMaker(2);
                   green.GetMaker();
         }       
}
//面包类抽象类
abstract class BreadMaker
         {
                   //得到面包抽象方法
                   abstractpublic void GetMaker();
                  
         }
         //白面包类 继承抽象类  覆写抽象方法
         classWhiteBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了白面包");
                   }
         }
//黑面包类
         classBlackBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了黑面包");
                   }
         }
         //绿面包类
         classGreenBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了绿面包");
                   }
         }
         //面包生产方法  通过静态方法BreadMakercreateBreadMaker(int breadType)决定生产哪种面包
         classBreadFactory
         {
                   publicstatic BreadMaker createBreadMaker(int breadType)
                   {
                            BreadMakerbreadMaker=null;
                            switch(breadType)
                            {
                                     case0:
                                                breadMaker=new WhiteBread();
                                     break;
                                     case1:
                                                breadMaker=new BlackBread();
                                     break;
                                     case2:
                                                breadMaker=new GreenBread();
                                     break;
                                     default:
                                               break;
                            }
                            returnbreadMaker;
                   }
         }
 
 
//有一个问题  当需要增加面包类型时  就需要修改BreadFactory类 增加case分支 这样违反了开闭原则。
//下面就有了工厂方法模式 定义一个用于创建的接口 让子类决定实例化哪个类 工厂方法//使得一个类的实例化延迟到其子类

工厂方法模式

//工厂方法模式 定义一个用于创建的接口
//让子类决定实例化哪个类 工厂方法使得一个类的实例化延迟到其子类
class Factory2
{
         publicstatic void main(String[] args)
         {
                   IFactorywhiteBreadMakerFactory=new WhiteBreadMakerFactory();
                   BreadMakerwhite=whiteBreadMakerFactory.createBreadMaker();
                   white.GetMaker();
 
                   IFactoryblackBreadMakerFactory=new BlackBreadMakerFactory();
                   BreadMakerblack=blackBreadMakerFactory.createBreadMaker();
                   black.GetMaker();
 
                   IFactorygreenBreadMakerFactory=new GreenBreadMakerFactory();
                   BreadMakergreen=greenBreadMakerFactory.createBreadMaker();
                   green.GetMaker();
                  
                   IFactoryblueBreadMakerFactory=new BlueBreadMakerFactory();
                   BreadMakerblue=blueBreadMakerFactory.createBreadMaker();
                   blue.GetMaker();
         }
}
 
//面包类抽象类
abstract class BreadMaker
         {
                   //得到面包抽象方法
                   abstractpublic void GetMaker();
                  
         }
         //白面包类 继承抽象类  覆写抽象方法
         classWhiteBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了白面包");
                   }
         }
//黑面包类
         classBlackBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了黑面包");
                   }
         }
         //绿面包类
         classGreenBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了绿面包");
                   }
         }
 
         //蓝面包类  新增加
         classBlueBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了蓝面包");
                   }
         }
 
//工厂方法接口
interface IFactory
{
         publicBreadMaker createBreadMaker();
}
//白面包工厂类
class WhiteBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new WhiteBread();
                   returnbreadMaker;
         }
}
//黑面包工厂类
class BlackBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new BlackBread();
                   returnbreadMaker;
         }
}
//绿面包工厂类
class GreenBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new GreenBread();
                   returnbreadMaker;
         }
}
//蓝面包工厂类
class BlueBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new BlueBread();
                   returnbreadMaker;
         }
}
 
 
//通过上面的例子 看以看出  当增加新产品时  在工厂方法模式时  只要相应的增加新增产品的类
// 和工厂类  这样就能很好的符合开闭原则  当然  每增加一个产品 需要增加相应对方类和工厂类 也增加了额外的工作量
// 但是有一个问题 当我们需要增加一个类型的产品 比如披萨  但是我们可以重新利用之前已有的工厂，比如工厂
//的机器、设备等   那该如何呢。 如果按照工厂方法模式 那就需要增加披萨类 和披萨的工厂方法  而且这个工厂是新建的
//如要重新买设备 那该多浪费
// 基于此  提出了抽象工厂模式  比如 生产白面包的工厂还能生产白披萨 那么就节约设备资金啦， 也就是节约了代码量

抽象工厂模式

//抽象工厂模式
class Factory3
{
         publicstatic void main(String[] args)
         {
                   IFactorywhiteBreadMakerFactory=new WhiteBreadMakerFactory();
                   BreadMakerwhiteBread=whiteBreadMakerFactory.createBreadMaker();
                   whiteBread.GetMaker();
                   PizzawhitePizza=whiteBreadMakerFactory.createPizza();
                   whitePizza.GetMaker();
 
                   IFactoryblackBreadMakerFactory=new BlackBreadMakerFactory();
                   BreadMakerblackBread=blackBreadMakerFactory.createBreadMaker();
                   blackBread.GetMaker();
                   PizzablackPizza=blackBreadMakerFactory.createPizza();
                   blackPizza.GetMaker();
                  
                   IFactorygreenBreadMakerFactory=new GreenBreadMakerFactory();
                   BreadMakergreenBread=greenBreadMakerFactory.createBreadMaker();
                   greenBread.GetMaker();
                   PizzagreenPizza=greenBreadMakerFactory.createPizza();
                   greenPizza.GetMaker();
 
                   //另一种类实例化的方法 反射
                   try
                   {
                            Class<?>c=Class.forName("WhiteBreadMakerFactory");
                   try
                            {                          
                            whiteBreadMakerFactory=(IFactory)c.newInstance();
                            whitePizza=whiteBreadMakerFactory.createPizza();
                            whitePizza.GetMaker();
                            }
                            catch(Exception ee)
                            {
                            }
                   }
                   catch(ClassNotFoundException e)
                   {
                   }
                  
         }
}
 
//面包类抽象类
abstract class BreadMaker
         {
                   //得到面包抽象方法
                   abstractpublic void GetMaker();
                  
         }
         //白面包类 继承抽象类  覆写抽象方法
         classWhiteBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了白面包");
                   }
         }
//黑面包类
         classBlackBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了黑面包");
                   }
         }
         //绿面包类
         classGreenBread extends BreadMaker
         {
                   publicvoid GetMaker()
                   {
                            System.out.println("做出了绿面包");
                   }
         }
 
  //新增的披萨类
 abstract class Pizza{
         abstractvoid GetMaker();
  }
 
         //白披萨
         classWhitePizza extends Pizza
         {
                   publicvoid GetMaker(){
                            System.out.println("做出了白披萨");
                   }
         }
 
         //黑披萨
         classBlackPizza extends Pizza
         {
                   publicvoid GetMaker(){
                            System.out.println("做出了黑披萨");
                   }
         }
 
         //绿披萨
         classGreenPizza extends Pizza
         {
                   publicvoid GetMaker(){
                            System.out.println("做出了绿披萨");
                   }
         }
 
//工厂方法接口
interface IFactory
{
         publicBreadMaker createBreadMaker();
 
         publicPizza createPizza();  //新增 生产披萨方法
}
//白面包工厂类
class WhiteBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new WhiteBread();
                   returnbreadMaker;
         }
 
         publicPizza createPizza(){
                   returnnew WhitePizza();
         }
}
//黑面包工厂类
class BlackBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new BlackBread();
                   returnbreadMaker;
         }
 
         publicPizza createPizza(){
                   returnnew BlackPizza();
         }
}
//绿面包工厂类
class GreenBreadMakerFactory implementsIFactory
{
         public  BreadMaker createBreadMaker()
         {
                   BreadMakerbreadMaker=new GreenBread();
                   returnbreadMaker;
         }
 
         publicPizza createPizza(){
                   returnnew GreenPizza();
         }
}
 
//从以上代码可以看出 当我们新增一类产品时 而且该类产品能够重用工厂的资源 那么用抽象工厂方法 能够
//很好的解决这个问题
 
//工厂各方法比较
//1.简单工厂模式比较简单 分离了客户端和后台逻辑 使得客户端无需关心后台的实现 去除了客户端与具体产品
//的依赖  增强了移植性能 但是其违背了开闭原则，添加新产品时将会非常麻烦。
//2.工厂方法模式 易于添加新产品 后台模块符合开闭原则 但是新产品的添加会大量的新增类，增加了工作量
//3.抽象工厂模式 分离了具体的类 客户端直接操作抽象接口。
 
//对于工厂模式， 需要灵活应用 在不同的场合运用不同的模式 这样将会使我们的代码更加健壮、并且更易维护和拓展.

学习自 刘径舟老师 张玉华老师编著的《设计模式其实很简单》