设计模式-工厂模式（简单工厂、工厂方法、抽象工厂）

叁歲伎倆 2022-12-24 00:39 265阅读 0赞

### 文章目录 ###

*  简单工厂
 *  工厂方法
 *  抽象工厂

# 简单工厂 #

--------------------

简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是**由一  
个工厂对象决定创建出哪一种产品类的实例**。定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)。当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。  
由于创建实例的方法通常为静态(static)方法，因此简单工厂模式又被成为静态工厂方法模式(Static Factory Method)。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70]

*  Product表示产品接口，也可用抽象类实现，封装产品间共有的属性。
 *  ConcreteProduct\*表示具体的实际产品。
 *  Factory表示工厂，工厂根据需要来创建相应的产品。

这样一来，当添加新的产品C时，只需要修改工厂部分代码即可，而传统方法需要在每一个创建产品的地方都进行修改。可以理解为把具体的产品创建封装成一个工厂类。

举个例子，大富翁的地图创建：

*  AbstractBlock是接口，表示抽象的地块，包括方法printBlock()打印地块。
 *  Empty、Prison、Park实现上述接口，表示空地(\*)、监狱(&)和公园(\#)。
 *  SimpleFactory是创建地块的简单工厂。

类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 1]

代码：

1.  产品接口

public interface AbstractBlock { 
        public void printBlock();
    }

1.  产品接口实现子类

public class Empty implements AbstractBlock{ 
        @Override
        public void printBlock() { 
            System.out.print("* ");
        }
    }

public class Park implements AbstractBlock{ 
        @Override
        public void printBlock() { 
            System.out.print("# ");
        }
    }

public class Prison implements AbstractBlock{ 
        @Override
        public void printBlock() { 
            System.out.print("& ");
        }
    }

1.  简单工厂类

public class SimpleFactory { 
        public AbstractBlock getBlock(String type){  //根据传参创建不同的地块
            if(type.equalsIgnoreCase("Empty")){ 
                return new Empty();
            } else if(type.equalsIgnoreCase("Park")){ 
                return new Park();
            } else if(type.equalsIgnoreCase("Prison")){ 
                return new Prison();
            }
            return null;
        }
    }

1.  调用工厂

public class Map { 
        public void getMap(){ 
            SimpleFactory simpleFactory=new SimpleFactory();  //实例化工厂
            ArrayList<AbstractBlock> map=new ArrayList<AbstractBlock>();  //地块集合
    
            String []types=new String[3];
            types[0]="Empty";
            types[1]="park";
            types[2]="Prison";
            Random rd = new Random();
            for(int i=1;i<=12;i++){   //随机用工厂创建地块并放入集合
                int tt = rd.nextInt(types.length);
                map.add(simpleFactory.getBlock(types[tt]));
            }
            //地图大小写死了，不是重点
            for(int i=0;i<12;i++){ 
                map.get(i).printBlock();
                if(i==3||i==5||i==7)
                    System.out.println();
                if(i==4||i==6)
                    System.out.print(" ");
            }
        }
    }

1.  测试

public class MonoPoly { 
        public static void main(String[] args) { 
            Map map=new Map();
            map.getMap();
        }
    }

1.  运行结果  
    ![在这里插入图片描述][20201127233500516.png]

# 工厂方法 #

--------------------

不难发现，当增加新的产品时需要对简单工厂类修改，或创建多个简单工厂。（比如增加一个法院地块）  
工厂方法进一步解耦合，把工厂类抽象，不再负责所有实例的创建，而是把具体的创建工作交给了子类去完成，实例化延迟到子类加载，由子类来决定要实例化的类。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 2]  
抽象化工厂类，把具体实例化工作交给其子类实现。

代码：

1.  工厂接口

public interface AbstractFactory { 
        public AbstractBlock createBlock();
    }

1.  工厂实现子类

public class EmptyFactory implements AbstractFactory { 
        @Override
        public AbstractBlock createBlock() { 
            return new Empty();
        }
    }

public class ParkFactory implements AbstractFactory { 
        @Override
        public AbstractBlock createBlock() { 
            return new Park();
        }
    }

public class PrisonFactory implements AbstractFactory { 
        @Override
        public AbstractBlock createBlock() { 
            return new Prison();
        }
    }

> （插播反爬信息 ）博主CSDN地址：[https://wzlodq.blog.csdn.net/][https_wzlodq.blog.csdn.net]

1.  产品接口

public interface AbstractBlock { 
        public void printBlock();
    }

1.  产品实现子类

public class Empty implements AbstractBlock { 
        @Override
        public void printBlock() { 
            System.out.print("* ");
        }
    }

public class Park implements AbstractBlock { 
        @Override
        public void printBlock() { 
            System.out.print("# ");
        }
    }

public class Prison implements AbstractBlock { 
        @Override
        public void printBlock() { 
            System.out.print("& ");
        }
    }

1.  调用

public class Map { 
        public void getMap() { 
            ArrayList<AbstractBlock> map=new ArrayList<AbstractBlock>();  //地块集合
            AbstractFactory abstractFactory;
    
            Random rd = new Random();
            for(int i=1;i<=12;i++){   //随机用工厂创建地块并放入集合
                int tt = rd.nextInt(3);
                if(tt==0)abstractFactory=new EmptyFactory();
                else if(tt==1)abstractFactory=new ParkFactory();
                else abstractFactory=new PrisonFactory();
                map.add(abstractFactory.createBlock());
            }
            //地图大小写死了，不是重点
            for(int i=0;i<12;i++){ 
                map.get(i).printBlock();
                if(i==3||i==5||i==7)
                    System.out.println();
                if(i==4||i==6)
                    System.out.print(" ");
            }
        }
    }

1.  测试

public class MonoPoly { 
        public static void main(String[] args) { 
            Map map=new Map();
            map.getMap();
        }
    }

运行结果：  
![在这里插入图片描述][20201129194745452.png]

# 抽象工厂 #

--------------------

不难发现当创建新的产品接口时，也需要对工厂方法修改，或创建多个工厂方法。（比如增加魔法地块簇，对应组产品魔法公园、魔法空地、魔法监狱等）  
抽象工厂将工厂方法进一步抽象。定义了一个接口用于创建相关或有依赖关系的对象簇，而无需指明具体的类。可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 3]  
把工厂类抽象后，对应不同子类工厂（普通/魔法），生产对应的一组产品。最后调用时统一调用抽象接口即可，不必知道具体对象，面向接口编程。

1.  产品接口

public interface AbstractBlock { 
        void printBlock();
    }

1.  产品抽象子类-普通产品

public abstract class NormalAbstractBlock implements AbstractBlock { 
        public abstract void printBlock();
    }

2.2普通空地

public class NormalEmpty extends NormalAbstractBlock { 
        public void printBlock() { 
            System.out.print("* ");
        }
    }

2.3普通公园

public class NormalPark  extends NormalAbstractBlock { 
        public void printBlock() { 
            System.out.print("# ");
        }
    }

2.4普通监狱

public class NormalPrison extends NormalAbstractBlock { 
        public void printBlock() { 
            System.out.print("& ");
        }
    }

1.  产品抽象子类-魔法产品

public abstract class MagicAbstractBlock implements AbstractBlock { 
        public abstract void printBlock();
    }

3.2魔法空地

public class MagicEmpty  extends MagicAbstractBlock { 
        public void printBlock() { 
            System.out.print("e ");
        }
    }

3.3魔法公园

public class MagicPark extends MagicAbstractBlock { 
        public void printBlock() { 
            System.out.print("g ");
        }
    }

3.4魔法监狱

public class MagicPrison extends MagicAbstractBlock { 
        public void printBlock() { 
            System.out.print("p ");
        }
    }

1.  工厂接口

public interface AbstractFactory { 
        AbstractBlock getEmpty();
        AbstractBlock getPrison();
        AbstractBlock getPark();
    }

1.  工厂实现子类-普通工厂

public class NormalFactory implements  AbstractFactory { 
        public AbstractBlock getEmpty() {  return new NormalEmpty(); }
        public AbstractBlock getPrison() {  return new NormalPrison(); }
        public AbstractBlock getPark() {  return new NormalPark(); }
    }

1.  工厂实现子类-魔法工厂

public class MagicFactory implements AbstractFactory { 
        public AbstractBlock getEmpty() {  return new MagicEmpty(); }
        public AbstractBlock getPrison() { return new MagicPrison(); }
        public AbstractBlock getPark() {  return new MagicPark(); }
    }

1.  调用

public class Map { 
        public void getMap(AbstractFactory af){ 
            ArrayList<AbstractBlock> map=new ArrayList<AbstractBlock>();
            map.add(af.getEmpty());
            map.add(af.getPrison());
            map.add(af.getPark());
            Random rd = new Random(3);
            int col=12;
            for(int i=1;i<=col;i++){ 
                int tt = rd.nextInt(3);
                map.get(tt).printBlock();
                if(i==4||i==6||i==8)
                    System.out.println();
                if(i==5||i==7)
                    System.out.print(" ");
            }
        }
    }

1.  测试

public class Monopoly { 
        public void play(){ 
            Map map=new Map();
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入指令（1输出普通地图，2输出魔法地图）");
            int order;
            order  = scan.nextInt();
            if(order == 1){ 
                map.getMap(new NormalFactory());
            }else{ 
                map.getMap(new MagicFactory());
            }
        }
    }

运行结果：  
![在这里插入图片描述][20201129205314702.png]  
![在这里插入图片描述][20201129205332954.png]

> **原创不易，请勿转载**（本不富裕的访问量雪上加霜 ）  
> 博主首页：[https://wzlodq.blog.csdn.net/][https_wzlodq.blog.csdn.net]  
> 微信公众号：`吾仄lo咚锵`  
> *如果文章对你有帮助，记得一键三连❤*

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70]: /images/20221120/5edb088dd8c04a45b6bdecaaf1e3e878.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 1]: /images/20221120/e12653ad5adb40aa96f282373ea1fc2f.png
[20201127233500516.png]: /images/20221120/b30333252229485a85e0d53316534dd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 2]: /images/20221120/d7731050acc44e2bb42afa618cad08b8.png
[https_wzlodq.blog.csdn.net]: https://wzlodq.blog.csdn.net/
[20201129194745452.png]: /images/20221120/f4c5d7a2236d4be59a5462b433505410.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 3]: /images/20221120/a5bc87dbe8b2420aa481791aa5c3a026.png
[20201129205314702.png]: /images/20221120/ede0dca05d134a0ca64ef8d0ad99227b.png
[20201129205332954.png]: /images/20221120/0c51398d124a4ffa9049d0c20fdda287.png