简单工厂模式、工厂模式以及抽象工厂模式

电玩女神 2021-08-19 12:39 439阅读 0赞

### [Java中的简单工厂模式][Java] ###

举两个例子以快速明白Java中的简单工厂模式：  
  
女娲抟土造人  
话说：“天地开辟，未有人民，女娲抟土为人。”女娲需要用土造出一个个的人，但在女娲造出人之前，人的概念只存在于女娲的思想里面。  
女娲造人，这就是简单工厂模式的应用。  
  
　　首先，在这个造人的思想里面，有几个重要的角色：女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。  
　　1.）女娲是一个工厂类，也就是简单工厂模式的核心角色。

2.）具休的一个个的人，包括张三，李四等。这些人便是简单工厂模式里面的具体产品角色  
　　3.）抽象的人是最早只存在于女娲的头脑里的一个想法，女娲按照这个想法造出的一个个具体的人，便都符合这个抽象的人的定义。换言之，这个抽象的想法规定了所有具体的人必须都有的接口（特征或者功能）  
　　　其UML类图出下所示：

![format_png][]

理解了上面的这些东西，再来理解下面的例子，对照理解，相信看完这篇文章，便对java简单工厂模式有一个很好的理解：  
  
  
有一个农场公司，专门向市场销售各类水果，在这个系统里需要描述下列水果：  
　　　　　葡萄　Grape  
　　　　　草莓　Stuawberry  
　　　　　苹果　Apple  
水果与其他植物不同，最终可以采摘食用，那么一个自然的做法是建立一个各种水果都适用的接口，以便与其他农场里的植物区分开来，

![format_png 1][]

此时，则是为水果类声明了一个接口，表现在代码上：

public   interface  Fruit {
          // 生长
           void  grow();
           // 收获
           void  harvest();
           // 种植
            void  plant();
     }

水果接口规定出所有的水果必须实现的接口，包括任何水果类必须具备的方法plant(),grow(),和harvest();  
  
Apple类是水果类的一种，因此它实现了水果接口所声明的所有方法。另处，由于苹果是多年生植物，因此多出一个treeAge性质，描述苹果的树龄。代码如下所示：

package  fac;
    
    public   class  Apple  implements  Fruit { // 通过implements实现接口Fruit
         private   int  treeAge;
        
         public   void  grow() {
            log( " Apple is growing " );
        }
        
         public   void  harvest() {
            log( " Apple has been harvested " );
        }
        
         public   void  plant() {
            log( " Apple ha been planted " );
        }
        
         public   static   void  log(String msg) {
            System.out.println(msg);
        }
        
         public   int  getTreeAge() {
             return  treeAge;
        }
        
         public   void  setTreeAge( int  treeAge) {
             this .treeAge = treeAge;
        }

同理，葡萄　Grape：

package fac;
    
    public class Grape implements Fruit{
        private boolean seedless;
        public void grow(){
            log("Grape is growing.");
        }
        
        public void harvest(){
            log("Grape has been harvested");
        }
        
        public void plant(){
            log("Grape ha been planted");
        }
        
        public static void log(String msg){
            System.out.println(msg);
        }
    
        public boolean isSeedless() {
            return seedless;
        }
    
        public void setSeedless(boolean seedless) {
            this.seedless = seedless;
        }
        
    
    }

草莓　Stuawberry：

package fac;
    
    public class Strawberry implements Fruit{
        public void grow(){
            log("Strawberry is growing");
        }
        
        public void harvest(){
            log("Strawberry has been harvested");
        }
        
        public void plant(){
            log("Strawberry has been planted");
        }
        
        public static void log(String msg){
            System.out.println(msg);
        }
    }

农场园丁也是系统的一部分，由一个类来代表，FruitGardener类，代码如下：

package fac;
    
    public class FruitGardener{
        public static Fruit factory(String which)throws Exception{
            if(which.equalsIgnoreCase("apple")){
                return new Apple();
            }else if(which.equalsIgnoreCase("strawberry")){
                return new Strawberry();
            }else if (which.equalsIgnoreCase("grape")){
                return new Grape();
            }else{
                throw new Exception("Bad fruit request");
            }
        }
    }

这时有人来果园玩，和园丁说，给我们介绍下你的水果吧。于是园丁：

package fac;
    
    public class People {
    
        public static void main(String[] args) throws Exception {
            FruitGardener fg=new FruitGardener();
            Fruit ap=fg.factory("Apple");
            ap.grow();
            Fruit gp=fg.factory("Grape");
            gp.plant();
            
            Fruit dd=fg.factory("ddd");//抛出Bad fruit request异常
        }    
    
    }

（注：以上代码在JDK5.0，Myeclise3.2下编译通过）

类比两个例子，园丁就相当于女娲，而水果就相当于具体的人，接口水果类就相当于存在于类女娲思想里的人的抽象概念。  
  
由以上两个例子可得出，简单工厂模式需要由以下角色组成：  
　　　　　　接口  
                        接口的实现类（简单工厂模式里面的具体产品角色）  
                        工厂  
  
理解了以下两个例子，再来看第三个例子：  
注意对比以下三个实例的不同  
实例１：

package org.jzkangta.factorydemo01;
    //定义接口
    interface Car{
        public void run();
        public void stop();
    }
    //具体实现类
    class Benz implements Car{
        public void run(){
            System.out.println("Benz开始启动了。。。。。");
        }
        public void stop(){
            System.out.println("Benz停车了。。。。。");
        }
    }
    //具体实现类
    class Ford implements Car{
        public void run(){
            System.out.println("Ford开始启动了。。。");
        }
        public void stop(){
            System.out.println("Ford停车了。。。。");
        }
    }
    //工厂
    class Factory{
        public static Car getCarInstance(){
            return new Ford();
        }
    }
    public class FactoryDemo01 {
    
        public static void main(String[] args) {
            Car c=Factory.getCarInstance();
            c.run();
            c.stop();
    
        }
    
    }

实例二：

package fac;
    
    
    //定义接口
    interface Car{
        public void run();
        public void stop();
    }
    //具体实现类
    class Benz implements Car{
        public void run(){
            System.out.println("Benz开始启动了。。。。。");
        }
        public void stop(){
            System.out.println("Benz停车了。。。。。");
        }
    }
    
    class Ford implements Car{
        public void run(){
            System.out.println("Ford开始启动了。。。");
        }
        public void stop(){
            System.out.println("Ford停车了。。。。");
        }
    }
    //工厂
    class Factory{
        public static Car getCarInstance(String type){
            Car c=null;
            if("Benz".equals(type)){
                c=new Benz();
            }
            if("Ford".equals(type)){
                c=new Ford();
            }
            return c;
        }
    }
    
    
    public class FactoryDemo02 {
    
        public static void main(String[] args) {
            Car c=Factory.getCarInstance("Benz");
            if(c!=null){
                c.run();
                c.stop();
            }else{
                System.out.println("造不了这种汽车。。。");
            }
            
    
        }
    
    }

实例三：

interface Car{
        public void run();
        public void stop();
    }
    
    class Benz implements Car{
        public void run(){
            System.out.println("Benz开始启动了。。。。。");
        }
        public void stop(){
            System.out.println("Benz停车了。。。。。");
        }
    }
    
    class Ford implements Car{
        public void run(){
            System.out.println("Ford开始启动了。。。");
        }
        public void stop(){
            System.out.println("Ford停车了。。。。");
        }
    }
    
    class Toyota implements Car{
        public void run(){
            System.out.println("Toyota开始启动了。。。");
        }
        public void stop(){
            System.out.println("Toyota停车了。。。。");
        }
    }
    
    class Factory{
        public static Car getCarInstance(String type){
            Car c=null;
            try {
                c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型　
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        
            return c;
        }
    }
    public class FactoryDemo03 {
    
        public static void main(String[] args) {
            Car c=Factory.getCarInstance("Toyota");
            if(c!=null){
                c.run();
                c.stop();
            }else{
                System.out.println("造不了这种汽车。。。");
            }
            
    
        }
    
    }

对比三个实例：  
实例一，虽然实现了简单工厂，但每次只能得到一种汽车，如果我们想换一种，就得修改工厂，太不方便，而实例二则改变了这种情况，便 得我们可以按照我们的需要更换汽车，但我们所更换的汽车必须是实现类中有的，如果我们想要增加一种汽车的时候，我们还是得更改工厂，通过改进，实例三利用 反射机制，得到汽车类型，这样当我们需要增加一种新的汽车时，就无需要再修改工厂，而只需要增加要实现的类即可。也就是说要增加什么样的汽车直接增加这个 汽车的类即可，而无需改变工厂。从而达到了工厂分离的效果。

### 二、工厂模式 ###

工厂方法模式是对简单工厂模式进一步的解耦，因为在工厂方法模式中是一个子类对应一个工厂类，而这些工厂类都实现于一个抽象接口。这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。

这时上面那个例子的结构图为：

1. 首先定义一个工厂接口：

import org.zero01.operation.Operation;  
   
public interface Factory \{  
   
    public Operation createOperation() ;  
   
\}  
2. 然后是具体的工厂类：

// 加法类工厂  
public class AddFactory implements Factory\{  
   
    public Operation createOperation() \{  
        System.out.println("加法运算");  
        return new Add();  
    \}  
\}  
   
// 减法类工厂  
public class SubFactory implements Factory\{  
   
    public Operation createOperation() \{  
        System.out.println("减法运算");  
        return new Sub();  
    \}  
\}  
........  
3. 运算类跟简单工厂一样。

4. 客户端代码：

public class Client \{  
   
    public static void main(String\[\] args) throws Exception \{  
   
        // 使用反射机制实例化工厂对象，因为字符串是可以通过变量改变的  
        Factory addFactory = (Factory) Class.forName("org.zero01.factory.AddFactory").newInstance();  
        Factory subFactory=(Factory) Class.forName("org.zero01.factory.SubFactory").newInstance();  
   
        // 通过工厂对象创建相应的实例对象  
        Operation add = addFactory.createOperation();  
        Operation sub = subFactory.createOperation();  
   
        System.out.println(add.getResult(1, 1));  
        System.out.println(sub.getResult(1, 1));  
    \}  
\}  
比较：

工厂模式中，要增加产品类时也要相应地增加工厂类，客户端的代码也增加了不少。工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。

你想要加功能，本来是改工厂类的，而现在是修改客户端。而且各个不同功能的实例对象的创建代码，也没有耦合在同一个工厂类里，这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开-闭原则的缺点，又保持了封装对象创建过程的优点。

但工厂方法模式的缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

# 抽象工厂模式： #

工厂方法模式引入工厂等级结构，解决了简单工厂模式中工厂类职责过重的问题，但由于工厂方法模式中每个工厂只创建一类具体类的对象，这将会导致系统当中的工厂类过多，这势必会增加系统的开销。此时，我们可以考虑将一些相关的具体类组成一个“具体类族”，由同一个工厂来统一生产，这就是我们本文要说的“抽象工厂模式”的基本思想。

接着来看我们抽象方法模式一文中我们说的例子，我们现在有这么一个场景；现在用户的需求变多了，除了要求不同的形状之外，我们还要求创建不同颜色的形状，比如圆形，我们要求红色的圆形、赤橙黄绿青蓝紫等各种各样颜色的圆形。按照我们抽象方法模式的设计方案，那么我们就需要实现各种颜色的形状并实现这些颜色的形状对应的工厂类，这样一来我们系统中会增多非常多的工厂类。看起来如下：

//具体类的抽象接口  
public interface Shape \{  
    //接口方法  
\}  
//具体类Circle  
public class Circle implements Shape \{  
    //接口方法实现  
\}  
//具体类红色圆  
public class RedCircle implements Shape \{  
    //接口方法实现  
\}  
//...各种颜色的圆...  
//具体类Triangle  
public class Triangle implements Shape \{  
//接口方法实现  
\}  
//具体类红色Triangle  
public class RedTriangle implements Shape \{  
//接口方法实现  
\}  
//...各种颜色的Triangle...  
//工厂接口  
public interface ShapeFactory \{  
    Shape getShape();  
\}  
//CircleFactory  
public class CircleFactory implements ShapeFactory \{  
    //返回实例  
\}  
//RedCircleFactory  
public class RedCircleFactory implements ShapeFactory \{  
    //返回实例  
\}  
//...各种颜色的Circle的工厂...  
//TriangleFactory   
public class TriangleFactory implements ShapeFactory \{  
    //返回实例  
\}  
//RedTriangleFactory   
public class RedTriangleFactory implements ShapeFactory \{  
    //返回实例  
\}  
//...各种颜色的Triangle的工厂...

那么我们有没有办法对当前的设计方案进行优化，减少一些工厂类的产生呢？我们下面对当前的系统做进一步抽象。以形状为类的级别、颜色为族来对当前系统作进一步改善。

![è¿éåå¾çæè¿°][70]

首先我们要以形状为等级、颜色为族来对系统进行进一步抽象。  
等级抽象

进行等级抽象我们需要将不同的形状声明为抽象类（等级划分）并实现公共的抽象接口（Shape），然后具体的实现类继承自对应的抽象类；

//形状公共接口  
public interface Shape \{  
    void draw();  
\}  
//圆形抽象类Circle  
public abstract class Circle implements Shape \{  
    public abstract void draw();  
\}  
//长方形抽象类Rectange  
public abstract class Rectange implements Shape \{  
    public abstract void draw();  
\}  
//其他图形抽象类... ...

具体的实现类继承自对应的抽象类，继承自不同的抽象类就相当于将类划分为不同的等级，如：

//具体颜色的Circle实现  
public class BlueCircle extends Circle \{  
    @Override  
    public void draw() \{  
        System.out.println("绘制蓝色的圆");  
    \}  
\}  
public class RedCircle extends Circle \{  
    @Override  
    public void draw() \{  
        System.out.println("绘制红色的圆");  
    \}  
\}

//具体颜色的Rectange实现  
public class RedRectange extends Rectange\{  
    @Override  
    public void draw() \{  
        System.out.println("绘制红色长方形");  
    \}  
\}  
public class BlueRectange extends Rectange \{  
    @Override  
    public void draw() \{  
        System.out.println("绘制蓝色长方形");  
    \}  
\}

**具体类族抽象**

具体类族的划分我们以颜色为基础，不同类族的对象我们通过对应的具体工厂来创建。所以首先我们需要定义一个抽象工厂，具体工厂（族）实现抽象工厂的方法来生成一组具体对象。

//抽象工厂ShapeFactory   
public interface ShapeFactory \{  
    Shape getCircle();  
    Shape getRectange();  
\}

//RedShapeFactory（他所代表的是红色形状这一族）  
public class RedShapeFactory implements ShapeFactory \{  
    @Override  
    public Shape getCircle() \{  
        return new RedCircle();  
    \}

@Override  
    public Shape getRectange() \{  
        return new RedRectange();  
    \}  
\}

//BlueShapeFactory（他所代表的是兰色形状这一族）  
public class BlueShapeFactory implements ShapeFactory \{  
    @Override  
    public Shape getCircle() \{  
        return new BlueCircle();  
    \}

@Override  
    public Shape getRectange() \{  
        return new BlueRectange();  
    \}  
\}

//...其他族...

等级以及族类划分完成之后，我么的客户端在使用时只需要知道抽象工厂（ShapeFactory ）以及具体工厂（如BlueShapeFactory ）就可以获得指定族的所有形状。

public class TestDemo \{  
    public static void main(String\[\] args) \{  
        ShapeFactory redShapeFactory = new RedShapeFactory();  
        Shape circle = redShapeFactory.getCircle();  
        circle.draw();  
        Shape rectangle = redShapeFactory.getRectange();  
        rectangle.draw();

ShapeFactory greenShapeFactory = new GreenShapeFactory();  
        Shape greenCircle = greenShapeFactory.getCircle();  
        greenCircle.draw();  
    \}  
\}

从上面的例子我们就可以知道，抽象工厂模式为创建一组对象提供了一种解决方案。 与工厂方法模式相比， 抽象工厂模式中的具体工厂不只是创建一种具体对象， 它负责创建一组（族）具体对象。

抽象工厂模式定义（Abstract Factory Pattern）

提供一个创建一系列相关或者相互依赖对象的接口，而无需知道他们的具体类，抽象工厂模式也称Kit模式，它属于类创建型模式。

在抽象工厂模式中，每个具体工厂都提供了多个工厂方法用于创建多种不同类型的具体对象，这些被创建的对象就构成一个族。

抽象工厂模式包含的角色

抽象工厂：声明一组用于创建一族产品的方法，每个方法对应一种对象；在抽象工厂中声明了多个工厂方法， 用于创建不同类型的对象， 抽象工厂可以是接口， 也可以是抽象类或者具体类，具体实现可参考上例中的ShapeFactory；

具体工厂：具体工厂实现了抽象工厂，每个工厂方法返回一个具体对象，一个具体工厂所创建的具体对象构成一个族。具体实现可参考上例中的RedShapeFactory；

抽象类接口：提供一组所有类都具有的业务方法。

抽象类：用于实现抽象接口所定义的业务方法，但是该角色对于抽象接口定义的方法只做抽象实现，即所有实现都被定义为抽象方法，最终的具体实现全部交给具体类实现。引入该角色主要是为了根据声明不同的抽象类，将类区分为不同的等级结构。

具体类：该角色继承抽象类，主要用于实现抽象类中声明的抽象方法，完成不同等级结构，不同族的业务方法的具体实现。

根据我们上面对抽象工厂模式的描述，我们大致能够明白，如果我们在上例的基础上想要增加绿色或者其他颜色的图形时，我们只需要增加一个绿色产品工厂（GreenShapeFactory），同时继承不同的图形抽象类实现不同颜色的图形具体类即可，看起来如下：

//GreenShapeFactory  
public class GreenShapeFactory implements ShapeFactory \{  
    @Override  
    public Shape getCircle() \{  
        return new GreenCircle();  
    \}

@Override  
    public Shape getRectange() \{  
        return new GreenRectange();  
    \}

//GreenRectange   
public class GreenRectange extends Rectange \{  
    @Override  
    public void draw() \{  
        System.out.println("绘制绿色长方形");  
    \}  
\}

//GreenCircle  
public class GreenCircle extends Circle\{  
    @Override  
    public void draw() \{  
        System.out.println("绘制绿色圆");  
    \}  
\}

我们增加这些拓展，并不会影响到原来的代码，这看起来是符合“开闭原则”的；但是我们再深入思考一下，如果我们现在想增加一个新的图形，比如说三角形（Triangle）。而对于我们目前所做的设计来讲，我们将三角形（Triangle）放到任何一个等级机构（即继承自任何一个图形抽象类，如Circle）都显得有些格格不入。但是我们如果在系统之中增加一个三角形（Triangle）的抽象类并实现不同颜色的三角形（Triangle）类之后我们会发现，我们需要修改所有的抽象工厂，这并不符合“开闭原则”。即在抽象工厂模式中，我们只能够对族进行拓展，在对族进行拓展的情况下，时符合“开闭原则”的，如上例中增加不同颜色的指定图形；但是对类的等级结构做拓展，是不符合“开闭原则”的；

因此使用抽象工厂模式要求设计人员在设计之初就能够全面考虑， 不会在设计完成之后向系统中增加新的等级结构， 也不会删除已有的等级结构， 否则将会导致系统出现较大的修改， 为后续维护工作带来诸多麻烦。

小结

抽象工厂模式是工厂方法模式的进一步延伸， 由于它提供了功能更为强大的工厂类并且具备较好的可扩展性， 在软件开发中得以广泛应用， 尤其是在一些框架和API类库的设计中， 例如在Java语言的AWT（ 抽象窗口工具包） 中就使用了抽象工厂模式， 它使用抽象工厂模式来实现在不同的操作系统中应用程序呈现与所在操作系统一致的外观界面。 抽象工厂模式也是在软件开发中最常用的设计模式之一。

优点

抽象工厂模式隔离了具体类的生成， 使得客户并不需要知道什么被创建。 由于这种隔离，更换一个具体工厂就变得相对容易， 所有的具体工厂都实现了抽象工厂中定义的那些公共接口， 因此只需改变具体工厂的实例， 就可以在某种程度上改变整个软件系统的行为。

当一个族中的多个对象被设计成一起工作时， 它能够保证客户端始终只使用同一个族中的对象。

增加新的族很方便， 无须修改已有系统， 符合“开闭原则”。

缺点

增加新的等级结构麻烦， 需要对原有系统进行较大的修改， 甚至需要修改抽象层代码，这显然会带来较大的不便， 违背了“开闭原则”。  
使用场景

一个系统不应当依赖于具体类实例如何被创建、 组合和表达的细节， 这对于所有类型的工厂模式都是很重要的， 用户无须关心对象的创建过程， 将对象的创建和使用解耦；

系统中有多于一个的族， 而每次只使用其中某一族。 可以通过配置文件等方式来使得用户可以动态改变族， 也可以很方便地增加新的族。

属于同一个族的对象将在一起使用， 这一约束必须在系统的设计中体现出来。 同一个族中的对象可以是没有任何关系的对象， 但是它们都具有一些共同的约束， 如同一操作系统下的按钮和文本框， 按钮与文本框之间没有直接关系， 但它们都是属于某一操作系统的， 此时具有一个共同的约束条件： 操作系统的类型。

等级结构稳定， 设计完成之后， 不会向系统中增加新的等级结构或者删除已有的等级结构。  
转载自：[https://blog.csdn.net/u012156116/article/details/80857255\#commentBox][https_blog.csdn.net_u012156116_article_details_80857255_commentBox]  作者：[cosmos\_lee][cosmos_lee]

[https://www.cnblogs.com/thesnail/p/4024109.html][Java] 作者：[雪夜蓝风][Link 1]

[https://blog.csdn.net/zyhlwzy/article/details/80707488][https_blog.csdn.net_zyhlwzy_article_details_80707488] 作者：[RonTech][]

[Java]: https://www.cnblogs.com/thesnail/p/4024109.html
[format_png]: /images/20210518/81648d8f2d274b49bd27dfbb46b4b349.png
[format_png 1]: /images/20210518/5494ad24b8134497912c216e944488e8.png
[70]: /images/20210518/50dc2d1de2eb438e9fe334109e1bc96d.png
[https_blog.csdn.net_u012156116_article_details_80857255_commentBox]: https://blog.csdn.net/u012156116/article/details/80857255#commentBox
[cosmos_lee]: https://blog.csdn.net/u012156116
[Link 1]: https://home.cnblogs.com/u/thesnail/
[https_blog.csdn.net_zyhlwzy_article_details_80707488]: https://blog.csdn.net/zyhlwzy/article/details/80707488
[RonTech]: https://blog.csdn.net/zyhlwzy