设计模式 - 工厂模式、建造者模式，就该这样学！

已于 2024-05-19 22:55:46 修改
阅读量3.5k 收藏 16
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： 设计模式 建造者模式
于 2023-10-08 09:45:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CYK_byte/article/details/133666996
本文详细介绍了Java中的工厂模式（包括简单工厂和工厂方法）、建造者模式以及两者之间的区别，强调了这些模式如何帮助解耦对象创建和扩展，以及它们各自的适用场景和优缺点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一、创建型模式

一句话概括

1.1、工厂模式

1.1.1、简单工厂模式 / 静态工厂模式（非 23 种经典设计模式）

概述

案例

1.1.2、工厂方法模式

概念

使用场景

案例

1.2、建造者模式

1.2.1、概念

1.2.2、案例

1.2.3、建造者模式扩展：链式编程底层

1.3、工厂方法模式 VS 建造者模式

一、创建型模式

一句话概括

创建型模式：教你如果创建对象.

1.1、工厂模式

1.1.1、简单工厂模式 / 静态工厂模式（非 23 种经典设计模式）

概述

简单工厂不是一种设计模式，反而比较像是一种编程习惯.

简单工厂包含一下角色：

  • 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品 ：实现或者继承抽象产品的子类
  • 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品

案例

需求：设计汽车制造系统，可以制造 SUV 和 BMW 两种车型

思路：

  • 抽象产品：创建一个汽车 Car接口 来规范
  • 具体产品：分别创建 SUV 和 BMW 两个类去实现 Car接口.
  • 具体工厂：提供了创建 Car的方法（方法可以是静态，也可以是非静态.  静态表示静态工厂，非静态表示简单工厂），该方法会根据用户传入的汽车类型创建出对应的车.

如下代码：

//抽象产品
interface Car {

    fun start()
    fun stop()
    fun honk()

}

//具体产品
class SUV: Car {

    override fun start() {
        println("SUV start ...")
    }

    override fun stop() {
        println("SUV stop ...")
    }

    override fun honk() {
        println("SUV honk ...")
    }

}

//具体产品
class BMW: Car {

    override fun start() {
        println("BMW start ...")
    }

    override fun stop() {
        println("BMW stop ...")
    }

    override fun honk() {
        println("BMW honk ...")
    }

}

//具体工厂
class CarFactory {

    companion object {
        fun createCar(type: String)= type.let {
            when (it) {
                "SUV" -> SUV()
                "BMW" -> BMW()
                else -> throw RuntimeException("car type undefine!")
            }
        }
    }

}

//测试
fun main() {
    val sCar = CarFactory.createCar("SUV")
    sCar.start()
    sCar.honk()
    sCar.stop()

    val bCar = CarFactory.createCar("BMW")
    bCar.start()
    bCar.honk()
    bCar.stop()
}

优点：

解耦合：将对象的创建和业务逻辑层分开，避免将来修改客户端代码.  如果要实现新产品，直接修改工厂类，不需要再原客户端代码，更容易扩展.

缺点：

违背“开闭原则”：增加新产品时还需要修改工厂类代码.

1.1.2、工厂方法模式

概念

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

工厂方法模式包含以下角色：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂 方法来创建产品。
  • 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同 具体工厂之间一一对应。
使用场景

当一个对象的创建过程过于复杂，并且有多个地方都需要创建该对对象时，使用 工厂方法模式 可以提高代码复用，并且创建时无需关心产品的创建过程.

案例

需求：设计一个制造汽车系统，可以创建 SUV 和 BMW 两种车型.

//抽象产品
interface Car {

    fun start()
    fun stop()
    fun honk()

}

//具体产品
class SUV: Car {

    override fun start() {
        println("SUV start ...")
    }

    override fun stop() {
        println("SUV stop ...")
    }

    override fun honk() {
        println("SUV honk ...")
    }

}

//具体产品
class BMW: Car {

    override fun start() {
        println("BMW start ...")
    }

    override fun stop() {
        println("BMW stop ...")
    }

    override fun honk() {
        println("BMW honk ...")
    }

}

interface CarFactory {
    fun createCar(): Car
}

class SUVFactory: CarFactory {

    override fun createCar() = SUV()

}

class BMWFactory: CarFactory {

    override fun createCar() = BMW()

}

fun main() {
    val suvFactory = SUVFactory()
    val suv = suvFactory.createCar()
    suv.start()
    suv.honk()
    suv.stop()

    val bmwFactory = BMWFactory()
    val bmw = bmwFactory.createCar()
    bmw.start()
    bmw.honk()
    bmw.stop()
}

与简单工厂模式的区别：

  • 简单工厂模式是直接提供具体工厂，创建产品的方法通过用户传入的指定参数，来得到不同的具体实体.
  • 工厂方法模式将 工厂 进行了一层抽象，并且一个具体产品对应一个具体工厂.

总的来讲，如果将来出现了新的产品，简单工厂模式还需要修改工厂类的方法，而工厂方法模式只需要创建新的产品和工厂即可，无需修改原来的代码（复合开闭原则）.  但是简单工厂比工厂方法模式使用更简单~

如果产品不多的情况下，适合使用简单工厂，反之更适合工厂方法模式

优点：

使用便利：用户只需要知道具体的工厂名称就可以拿到产品，无须知道产品的具体创建过程.

满足“开闭原则”：当需要添加新的产品时，无需对原工厂进行修改，只需要添加具体的产品类和工厂即可.

缺点：

“类爆炸”：每增加一个产品就需要增加一个具体产品类和一个对应的具体工厂类，增加系统复杂度.

1.2、建造者模式

1.2.1、概念

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。例如电脑的主机由 cpu、内存、主板、显卡 构成，用户只需要指定主机的类型就可以得到相应的主机，无需知道内部的具体构造细节.

建造者模式包含如下角色：

  • 抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
  • 具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体 创建方法。在构造过程完成后，提供产品的实例。
  • 产品类（Product）：要创建的复杂对象。
  • 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产 品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

1.2.2、案例

生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质 的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。

/**
 * 产品类：自行车类
 */
public class Bike {

    //车架
    private String frame;
    //车座
    private String seat;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }

}

/**
 * 抽象建造者类
 */
public abstract class Builder {

    //这里只是一个空架子，还需要具体实现
    protected Bike bike = new Bike();

    //自行车的组成部分
    public abstract void buildFrame();
    public abstract void buildSeat();

    //构建自行车
    public abstract Bike createBike();

}

/**
 * 具体建造者类：捷安特建造者类
 */
public class GiantBuilder extends Builder{

    @Override
    public void buildFrame() {
        this.bike.setFrame("碳纤维车架");
    }

    @Override
    public void buildSeat() {
        this.bike.setSeat("橡胶车座");
    }

    @Override
    public Bike createBike() {
        return this.bike;
    }

}

/**
 * 具体建造者类：摩拜建造者类
 */
public class MobikeBuilder extends Builder {

    @Override
    public void buildFrame() {
        this.bike.setFrame("铝合金车架");
    }

    @Override
    public void buildSeat() {
        this.bike.setSeat("真皮车座");
    }

    @Override
    public Bike createBike() {
        return this.bike;
    }

}

/**
 * 指挥者类
 */
public class Director {

    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    /**
     * 指导构造
     * @return
     */
    public Bike construct() {
        //开始构建
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }

}

/**
 * 测试类
 */
public class Client {

    public static void main(String[] args) {
        //建造捷安特自行车
        showBike(new GiantBuilder());
        //建造摩拜自行车
        showBike(new MobikeBuilder());
    }

    private static void showBike(Builder builder) {
        Director director = new Director(builder);
        Bike bike = director.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }

}

优点：

解耦合：客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得 相同的创建过程可以创建不同的产品对象。

易扩展，符合开闭原则：如果有新的需求，通过实现一个新的建造者就可以完成，基本上不用修改其他代码.

缺点：

如果产品之间的差异性比较大，则不适合使用，因此使用范围受到一定的限制.

使用场景：

创建对象的过程比较负责，由多个部件构成，但构建的顺序是稳定的.

产品的构建过程和最终的表示是独立的.

1.2.3、建造者模式扩展：链式编程底层

a）Java 如下

建造者模式除了上述用途以外，在开发中还有一种常用的使用方式，就是当一个类构造器需要传入多个参数，此时创建这个类的实例，代码的可读性就会非常差，而且很容易引入新的错误. 此时就可以使用 链式编程底层 的方式对 建造者模式进行重构.

 重构后代码如下：

public class Phone {

    private String cpu;
    private String screen;
    private String memory;
    private String mainBoard;

    //私有构造，只对内提供
    private Phone(Builder builder) {
        this.cpu = builder.cpu;
        this.screen = builder.screen;
        this.memory = builder.memory;
        this.mainBoard = builder.mainBoard;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainBoard='" + mainBoard + '\'' +
                '}';
    }

    //链式编程构建
    public static class Builder {
        private String cpu;
        private String screen;
        private String memory;
        private String mainBoard;

        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder screen(String screen) {
            this.screen = screen;
            return this;
        }

        public Builder memory(String memory) {
            this.memory = memory;
            return this;
        }

        public Builder mainBoard(String mainBoard) {
            this.mainBoard = mainBoard;
            return this;
        }

        public Phone build() {
            return new Phone(this);
        }
    }

}

public class Client {

    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .cpu("intel")
                .screen("三星屏幕")
                .mainBoard("华硕")
                .memory("金士顿")
                .build();
        System.out.println(phone);
    }

}

重构后使用起来更加方便，提高开发效率.  但是从软件设计上，对程序员的要求比较高.

b）Kotlin 如下
 

data class User (
    val id: Long,
    val username: String,
    val password: String,
    val age: Int?,
) {

    object Builder {
        private var id: Long? = null
        private var username: String? = null
        private var password: String? = null
        private var age: Int? = null

        fun id(id: Long) = this.apply { this.id = id }
        fun username(username: String) = this.apply { this.username = username }
        fun password(password: String) = this.apply { this.password = password }
        fun age(age: Int) = this.apply { this.age = age }

        fun build(): User {
            requireNotNull(id) { "id is required" }
            require(!username.isNullOrBlank()) { " username is required" }
            require(!password.isNullOrBlank()) { " password is required" }
            return User(id!!, username!!, password!!, age)
        }

    }

}

fun main() {
    val u = User.Builder
        .id(1)
        .username("cyk")
        .password("1111")
        .age(19)
        .build()
    println(u)
}

1.3、工厂方法模式 VS 建造者模式

工厂方法模式注重是整体对象的创建方式；而建造者模式注重的是部件一步一步的创建出一个复杂对象的过程 .

比如我要制造一个超人，如果使用工厂方法模式，直接产生出来就是一个力大无穷、能飞，内裤外穿的超人；而如果使用建造者模式，则需要组装 手、头、脚、躯干、裤头... 一个超人就诞生了.

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈亦康

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值