简单工厂模式、工厂方法模式、抽象工厂模式区别和联系

其他 2020-03-21 19:30:01 阅读次数: 0

1. 简单工厂模式

简单工厂模式，按照我在现实中的理解是:生产统一规格的商品，当然了，你可以生产其他商品的东西，假设我们生产的是汽车~那么我们可以生产一下汽车
那么我们既然说到了统一规格就需要定义一个接口,代码如下:


package com.robam.factory.simple;

/**
 * @author Zerox
 * @date 2018/12/24 10:04
 */
public interface Car {

    /**
     * 上面我们已经说到了,这里面我们定义的是规格
     *  a.要求必须是几个轱辘
     *  b.要求必须是汽油类
     *  c.要求必须有安全气囊
     *
     *  工厂工厂~什么是工厂？生产商品~生产统一规格的商品
     *  那么就我们这个造车车间估计也就能生产个汽车了~自行车恐怕都生产不了
     *  没那么大规格的自行车~烧油，四个轱辘的，还配有安全气囊！原谅我的贫穷。。。我真的没见过
     * @return
     */
    Car getCar();
}



package com.robam.factory.simple;

/**
 * @author Zerox
 * @date 2018/12/24 10:12
 */
public class AudiCar implements Car{

    /**
     * 生产一辆奥迪车
     * @return
     */
    @Override
    public Car getCar() {

        return new AudiCar();
    }
}



package com.robam.factory.simple;

/**
 * @author Zerox
 * @date 2018/12/24 10:11
 */
public class BenzCar  implements Car{
    /**
     * 生产一辆奔驰车
     *
     * @return
     */
    @Override
    public Car getCar() {
        return new BenzCar();
    }
}



package com.robam.factory.simple;

/**
 * @author Zerox
 * @date 2018/12/24 10:10
 */
public class BmwCar implements Car{

    /**
     * 生产一辆宝马车
     * @return
     */
    @Override
    public Car getCar() {
        return new BmwCar();
    }
}



package com.robam.factory.simple;

import com.sun.org.apache.bcel.internal.generic.RETURN;

/**
 * @author Zerox
 * @date 2018/12/24 10:13
 */
public class SimpleFactory {


    public Car getMyCar(String carName) {

        if (carName.equalsIgnoreCase("Audi")) {
            return new AudiCar();
        } else if (carName.equalsIgnoreCase("Benz")) {
            return new BenzCar();
        } else if (carName.equalsIgnoreCase("BMW")) {
            return new BmwCar();
        } else {
            System.out.println("不好意思~本公司没有!");
            return null;
        }
    }
}
  • 1.测试类代码如下

package com.robam.factory.simple;

import org.junit.Test;

/**
 * @author Zerox
 * @date 2018/12/24 10:16
 */
public class SimpleFactoryTest {

    @Test
    public void testSimpleFactory() {

        SimpleFactory simpleFactory = new SimpleFactory();
        System.out.println(simpleFactory.getMyCar("audi"));

        System.out.println(simpleFactory.getMyCar("benz"));

        System.out.println(simpleFactory.getMyCar("bmw"));
    }
}

优点: 使用者和开发端完全隔离,就好比我们去买猪肉~从不关心这个猪到底怎么成长的

缺点: 缺点也是很明显的,那就是如果我们新加入一个四驱车的话，那么需要去修改SimpleFactory中的方法,违背了开闭原则(对扩展开放,对修改关闭)

2. 工厂方法模式

工厂方法模式，上面所说的我们也知道了,其实我们仔细一想有点小夸张，就是我没有见过一个工厂能生产这么多的车！既能产宝马，又能产奔驰~只要是符合标准的都能生产！
显然，这样的工厂是不存在的现实中的情况是宝妈有宝马的生产工厂，奔驰有奔驰的生产工厂，我家的自行车恩。。好吧，确实是我在二手市场买零件回来组装的，这也说明了
我家只能是一个自行车加工厂

上面我们已经说到了规格不能改变,所以还是需要有一个通用的接口Car()，之后需要把各自的车辆按照品牌分配到各自的车间就可以了,那么话又说回来了，车都有标准了，工厂可能会没有标准么？
显然是有的，工厂会有什么标准呢？
a.车间安全标准
b.车间排气标准
代码如下


package com.robam.factory.factory_method;

import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 10:32
 */
public interface Factory {


    /**
     *   a.车间安全标准
     *   b.车间排气标准
     *
     *
     * @return 按照该标准所生产的汽车
     */
    Car getCarByFactoryStandard();
}



package com.robam.factory.factory_method;

import com.robam.factory.simple.AudiCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 10:34
 */
public class AudiFactory implements Factory{

    /**
     * 奥迪车间产奥迪
     *
     * @return
     */
    @Override
    public Car getCarByFactoryStandard() {

        return new AudiCar();
    }
}



package com.robam.factory.factory_method;

import com.robam.factory.simple.BenzCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 10:38
 */
public class BenzFactory implements Factory{

    /**
     * 奔驰车间产奔驰
     *
     * @return
     */
    @Override
    public Car getCarByFactoryStandard() {

        return new BenzCar();
    }
}



package com.robam.factory.factory_method;

import com.robam.factory.simple.BmwCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 10:39
 */
public class BmwFactory implements Factory{

    /**
     * 别摸我车间产别摸我
     *
     * @return
     */
    @Override
    public Car getCarByFactoryStandard() {

        return new BmwCar();
    }
}



package com.robam.factory.factory_method;

import org.junit.Test;

/**
 * @author Zerox
 * @date 2018/12/24 10:40
 */
public class MethodFactoryTest {

    @Test
    public void testFactoryMethod() {

        /** 产奥迪*/
        Factory car = new AudiFactory();
        System.out.println(car);

        /** 产奔驰*/
        car = new BenzFactory();
        System.out.println(car);

        /** 产宝马*/
        car = new BmwFactory();
        System.out.println(car);


    }
}

优点: 可以看出完美解决了上面说到的"开闭原则",如果你想要新加一个产品类的话，只需要去实现Factory接口就可以了。

缺点: 客户点可以知道后面的代码逻辑,以前是封装起来的(在SimpleFactory中)，现在完全暴露在了客户端

３. 抽象工厂模式

抽象工厂模式，该怎么说呢？我是这样子理解的，当我们在一系列产品中挑选一个产品时候(该系列产品同属于一家公司或者工厂生产)，那么就需要做到根据我们自己的需求从这一些列产品中
生产出对应的，我们所想要的产品(我的认知是，抽象工厂模式将以上两种模式结合起来了)


package com.robam.factory.abstract_factory;

import com.robam.factory.simple.AudiCar;
import com.robam.factory.simple.BenzCar;
import com.robam.factory.simple.BmwCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 11:05
 */
public abstract class AbstractFactory {

    abstract  Car getCar();

    Car getMyCar(String carName) {

        if (carName.equalsIgnoreCase("Audi")) {
            return new AudiCar();
        } else if (carName.equalsIgnoreCase("Benz")) {
            return new BenzCar();
        } else if (carName.equalsIgnoreCase("BMW")) {
            return new BmwCar();
        } else {
            System.out.println("不好意思~本公司没有!");
            return null;
        }
    }
}



package com.robam.factory.abstract_factory;

import com.robam.factory.simple.AudiCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 11:07
 */
public class AudiFactory extends AbstractFactory{

    @Override
    Car getCar() {
        return new AudiCar();
    }
}



package com.robam.factory.abstract_factory;

import com.robam.factory.simple.BenzCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 11:08
 */
public class BenzFactory extends AbstractFactory{

    @Override
    Car getCar() {
        return new BenzCar();
    }
}



package com.robam.factory.abstract_factory;

import com.robam.factory.simple.BmwCar;
import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 11:08
 */
public class BmwFactory extends AbstractFactory{

    @Override
    Car getCar() {
        return new BmwCar();
    }
}




package com.robam.factory.abstract_factory;

import com.robam.factory.simple.Car;

/**
 * @author Zerox
 * @date 2018/12/24 11:11
 */
public class DefaultFactory extends AbstractFactory{


    private AudiFactory defaultFactory = new AudiFactory();
    @Override
    Car getCar() {
        return defaultFactory.getCar();
    }
}

优点: 整合了简单工厂模式和工厂方法模式中的优点,如果说我们不这样做还是采用上面的工厂方法模式的话，如果我们需要加一个条件轮胎的供应商，如果加到工厂方法模式的话，就需要每个
工厂实现类都加上轮胎供应商的这个方法,如果我们在抽象工厂模式中，完全可以只在抽象类中将方法实现，客户端只需要将参数传进来即可！

      发明抽象工厂方法模式的人好厉害！厉害厉害！

      下个阶段，争取应用到项目中

代码github地址: [email protected]:xueh0430/design_model.git

*如果有问题欢迎指出

好一个迷途小书童
发布了32 篇原创文章 · 获赞 26 · 访问量 3万+
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_27416233/article/details/85242373
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022