java设计模式-工厂模式(五)

我就是我 2024-04-19 15:10 63阅读 0赞

> 首先，工厂模式是为了解耦：把对象的创建和使用的过程分开。就是Class A 想调用 Class B ，那么A只是调用B的方法，而至于B的实例化，就交给工厂类。  
> 其次，工厂模式可以降低代码重复。如果创建对象B的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。我们可以这些创建对象B的代码放到工厂里统一管理。既减少了重复代码，也方便以后对B的创建过程的修改维护。（当然，我个人觉得也可以把这些创建过程的代码放到类的构造函数里，同样可以降低重复率，而且构造函数本身的作用也是初始化对象。不过，这样也会导致构造函数过于复杂，做的事太多，不符合java 的设计原则。）  
> 由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。同理，想把所有调用B的地方改成B的子类B1，只需要在对应生产B的工厂中或者工厂的方法中修改其生产的对象为B1即可，而不需要找到所有的new B（）改为new B1()。  
> 另外，因为工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。

工厂模式的一些适用场景：  
1.对象的创建过程/实例化准备工作很复杂，需要很多初始化参数，查询数据库等  
2.类本身有好多子类，这些类的创建过程在业务中容易发生改变，或者对类的调用容易发生改变

# 一、简单工厂(静态工厂) #

比如某天想吃一碗面了，于是就找个小面馆。服务员会问你吃啥？有山西刀削面、兰州拉面、还有泡面。它们都有共同的父类:面  
定义抽象类或接口:面

/**
     * 产品面食的抽象类
     */
    public abstract class INoodles {
        /**描述每种面条啥样的*/
        public abstract void desc();
    }

山西刀削面出场

/**
     * 山西刀削面
     */
    public class DaoXiaoNoodles extends INoodles{
        @Override
        public void desc() {
            System.out.println("山西刀削面劲道");
        }
    }

兰州拉面出场

/**
     * 兰州拉面
     */
    public class LanZhouNoodles extends INoodles{
        @Override
        public void desc(){
            System.out.println("正宗兰州拉面好吃不贵");
        }
    }

泡面出场(此处虚构,谁有病有面馆点泡面呢)

/**
     * 泡面
     */
    public class PaoNoodles extends INoodles{
        @Override
        public void desc() {
            System.out.println("泡面好吃 可不要贪杯");
        }
    }

你说那就来玩兰州拉面吧，然后服务员就告诉后厨或者点餐app端一点，兰州拉面一碗。  
后厨收到消息，是兰州拉面。噼里啪啦一顿做。

/**
     * 简单工厂:后厨就相当于一个工厂生产面
     */
    public class SimpleNoodlesFactory {
        public static final String DAOXIAO = "daoxiao";
        public static final String LANZHOU = "lanzhou";
        public static final String PAO = "pao";
        /**生产面条*/
        public static INoodles createNoodles(String type) throws Exception {
            INoodles noodles = null;
            try{
                switch (type){
                    case DAOXIAO:noodles = new DaoXiaoNoodles();break;
                    case LANZHOU:noodles = new LanZhouNoodles();break;
                    case PAO:noodles = new PaoNoodles();break;
                    default:
                        System.out.println("不支持");break;
                }
            }catch (Exception e){
                System.out.println("创建异常");
                throw e;
            }
            return noodles;
        }
    }

一会就好，服务员不用关注面是怎么做出来的。（复杂的过程不用知道，提高了服务员的效率）

public class TestMain {
        public static void main(String[] args){
            try {
                //点餐 创建兰州拉面
                INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.LANZHOU);
                noodles.desc();
                //创建山西刀削面
                //noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.DAOXIAO);
                //noodles.desc();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

特点:它后厨是一个具体的类，非接口或抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。create()方法通常是静态的，所以也称之为静态工厂。  
如果此时又来一个人，想吃陕西裤带面,后厨一看不会做啊。还得重新学习新技能。  
所以缺点就出来了:  
1 扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）2 不同的产品需要不同额外参数的时候 不支持。

# 二、工厂方法 #

> 工厂方法 定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使得一个类的实例化延迟到了子类  
> 工厂方法在简单工厂的基础上再包了一层工厂，所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定  
> 这回后厨里一个人专门做山西刀削面，一个专门做兰州拉面，他们的共同点特征会做面。  
> 定义一个做面接口

/**
     * 创建面条的接口，具体由工厂子类实现
     */
    public interface INoodlesFactory {
        public INoodles create();
    }

山西刀削面师傅

/**
     * 山西刀削面全职
     */
    public class DaoXiaoNoodlesFactory implements INoodlesFactory{
        @Override
        public INoodles create() {
            return new DaoXiaoNoodles();
        }
    }

兰州拉面专有师傅

/**
     * 兰州拉面专有师傅
     */
    public class LanZhouNoodlesFactory implements INoodlesFactory{
        @Override
        public INoodles create() {
            return new LanZhouNoodles();
        }
    }

客户想吃啥，服务员就找专门的师傅更专业

public class TestMain1 {
        public static void main(String[] args) {
            //比如你想吃兰州拉面,可以到兰州专用师傅做
            INoodlesFactory noodlesFactory = new LanZhouNoodlesFactory();
            INoodles noodles = noodlesFactory.create();
            noodles.desc();
    
            //比如你想吃山西刀削面,可以到刀削专用师傅做
            noodlesFactory = new DaoXiaoNoodlesFactory();
            noodles = noodlesFactory.create();
            noodles.desc();
        }
    }

如果此时想吃陕西裤带面，后厨不会让之前的师傅再学，而是直接找个专门做裤带面的师傅来专门做。  
这样的好处:  
1.可以一定程度上解耦，消费者和产品实现类隔离开，只依赖产品接口(抽象产品)，产品实现类如何改动与消费者完全无关。  
2.可以一定程度增加扩展性，若增加一个产品实现，只需要实现产品接口，修改工厂创建产品的方法，消费者可以无感知（若消费者不关心具体产品是什么的情况）。  
3.可以一定程度增加代码的封装性、可读性。清楚的代码结构，对于消费者来说很少的代码量就可以完成很多工作。

# 三、抽象工厂 #

> 抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。  
> 所谓产品族，是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如实木家具的桌子、椅子、书柜组成一个家族，塑料家具厂的桌子、椅子、书柜组成一个家族。而这两个家族都来自于三个产品等级：桌子、椅子、书柜。一个等级结构是由相同的结构的产品组成

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA1MDkwNTI_size_16_color_FFFFFF_t_70]  
抽象工厂模式面对的是一个组合体，如果将这一点排除的话，其他方面看起来，二者还是相似的。  
工厂方法模式面对的目标一般都是单类的，目标就是桌子这一类商品。  
如果是这样的呢：生产的是桌椅组合，目标的一套商品，每一套商品中的每类商品的种类的不同的，不同的组合形成不同的套装。  
这种情况下，就需要使用抽象工厂模式  
桌子接口：Desk

public interface Desk {
        String getType();
    }

木质桌子：WoodenDesk

public class WoodenDesk implements Desk{
        @Override
        public String getType() {
            return "木质桌子";
        }
    }

塑料桌子：PlasticDesk

public class PlasticDesk implements Desk{
        @Override
        public String getType() {
            return "塑料桌子";
        }
    }

椅子接口：Chair

public interface Chair {
        String getType();
    }

木质椅子：WoodenChair

public class WoodenChair implements Chair{
        @Override
        public String getType() {
            return "木质椅子";
        }
    }

塑料椅：PlasticChair

public class PlasticChair implements Chair{
        @Override
        public String getType() {
            return "塑料椅";
        }
    }

家具工厂接口：FurnitureFactory

public interface FurnitureFactory {
        /**生产桌子*/
        Desk createDesk();
        /**生产椅子*/
        Chair createChair();
    }

木质家具工厂：WoodenFurnitureFactory

public class WoodenFurnitureFactory implements FurnitureFactory{
        @Override
        public Desk createDesk() {
            return new WoodenDesk();
        }
    
        @Override
        public Chair createChair() {
            return new WoodenChair();
        }
    }

塑料家具工厂：PlasticFurnitureFactory

public class PlasticFurnitureFactory implements FurnitureFactory{
        @Override
        public Desk createDesk() {
            return new PlasticDesk();
        }
    
        @Override
        public Chair createChair() {
            return new PlasticChair();
        }
    }

测试类：Clienter

public class Clienter {
        public static void main(String[] args) {
            FurnitureFactory factory = new PlasticFurnitureFactory();
            FurnitureFactory factory1 = new WoodenFurnitureFactory();
            //需要哪个产品族自己选择
            Desk desk = factory.createDesk();
            Chair chair = factory.createChair();
            System.out.println(desk.getType());
            System.out.println(chair.getType());
        }
    }

这里在目标每添加一种组合时，就需要新建一个工厂实现来对应，这一点满足开闭原则，不会修改已有类。  
但是有一种情况，会导致修改原有类，那就是当目标需要在家具中新增一种家具类型的时候，比如例子中，家具组合中只包含桌子和椅子，如果再添加一种书柜，那么所有的工厂包括工厂接口都面临修改。  
优点:使切换产品族变得容易,因为一个具体的工厂实现代表的是一个产品族，比如上面例子的从木质家具到塑料家具只需要切换一下具体工厂。  
缺点:不太容易扩展新的产品,如果需要给整个产品族添加一个新的产品，比如 添加个书柜，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。  
参考:https://www.cnblogs.com/betterboyz/p/9355777.html  
https://www.lmlphp.com/user/542/article/item/36338/ 特此感谢两位作者。  
源码地址:https://gitee.com/lifengit/javapatterns

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA1MDkwNTI_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/0417abadfccd480d9c5cfd18e1a6164a.png