抽象工厂模式（Java、Python）、建造者模式（Java、Python）

最新推荐文章于 2024-07-29 14:22:26 发布

璩明哲

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量1.1k

点赞数 3

分类专栏：设计模式文章标签：抽象工厂模式建造者模式 java python

本文链接：https://blog.csdn.net/newlinfeng/article/details/116047376

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、试画出抽象工厂模式的模式结构图，并对模式进行分析

1.1 抽象工厂模式结构图：

1.2 抽象工厂模式的实现（Java）

1.3 抽象工厂模式的优缺点

1.4 抽象工厂模式的实现（Python）

二、试画出建造者模式的模式结构图，并对模式进行分析。

三、计算机包括内存（RAM）,CPU等硬件设备，根据图中的“产品等级结构--产品族”示意图，使用抽象工厂模式实现计算机设备创建过程并绘制出相应的类图。（画出模式结构图，并进行解析）

3.1计算机设备创建程序模式结构图

3.2计算机设备创建程序实现

建造者模式与抽象工厂模式相似，也用来创建复杂对象。两者的区别在于，建造者模式着重一步步构造一个复杂对象(顺序)，而抽象工厂模式着重于多个系列的产品对象。

一、试画出抽象工厂模式的模式结构图，并对模式进行分析

1.1 抽象工厂模式结构图：

图1 抽象工厂模式的模式结构图

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

由图1可知，抽象工厂模式包含以下4个角色：

AbstactFactory(抽象工厂)：声明一组用于创建一族产品的方法，每个方法对应一种对象；在抽象工厂中声明了多个工厂方法，用于创建不同类型的对象，抽象工厂可以是接口，在这里是接口的形式；
ConcreteFactory1/2(具体工厂)：具体工厂实现了抽象工厂，每个工厂方法返回一个具体对象，一个具体工厂所创建的具体对象构成一个族；
AbstactProductA/B(抽象产品)：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品；
ProductA1/A2/B1/B2(具体产品)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

1.2 抽象工厂模式的实现（Java）

抽象工厂提供产品的生产方法。即，抽象工厂接口代码如下：

interface AbstractFactory{

    public void createProductA();

    public void createProductB();

}

具体工厂实现了产品的生成方法。对应具体产品类的代码如下,以具体工厂ConcreteFactory1为例：

class ConcreteFactory1 implements AbstractFactory{

    public ProductA2 createProductA()

    {

        return new AbstractProductA2();

    }

    public ProductaB2 createProductB()

    {

        return new AbstractProductB2();

    }

}

抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品；同样的以接口AbstractProductA为例：

interface AbstractProductA{

    public void use();

}

对于实现AbstractProductA接口的ProductA1/A2类,使用该工厂进行创建。其代码如下，以ProductA1类为例子：

public class ProductA1 implements AbstractProductA{

public void use(){

    //加工实现产品A

}

}

1.3 抽象工厂模式的优缺点

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。在很多软件系统中需要更换界面主题，要求界面中的按钮、文本框、背景色等一起发生改变时，可以使用抽象工厂模式进行设计。

优点：

抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用；
当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式；
增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：

在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便；
开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。

1.4 抽象工厂模式的实现（Python）

#!/usr/bin/env python
# _*_ coding: utf-8 _*_
# @Time : 
# @Author :
# @Version：V 0.1
# @File : 抽象工厂模式.py
# @desc : 定义一个工厂类接口，让工厂子类来创建一系列相关或相互依赖的对象

from abc import ABCMeta,abstractmethod

# --------抽象产品--------
class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass


class CPU(metaclass=ABCMeta):
    @abstractmethod
    def show_cpu(self):
        pass


class OS(metaclass=ABCMeta):
    @abstractmethod
    def show_os(self):
        pass


# --------抽象工厂--------
class PhoneFactory(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass


# --------具体产品--------
class SmallShell(PhoneShell):
    def show_shell(self):
        print("普通手机小手机壳")


class BigShell(PhoneShell):
    def show_shell(self):
        print("普通手机大手机壳")


class AppleShell(PhoneShell):
    def show_shell(self):
        print("苹果手机壳")


class SnapDragonCPU(CPU):
    def show_cpu(self):
        print("骁龙CPU")


class MediaTekCPU(CPU):
    def show_cpu(self):
        print("联发科CPU")


class AppleCPU(CPU):
    def show_cpu(self):
        print("苹果CPU")


class Android(OS):
    def show_os(self):
        print("Android操作系统")


class IOS(OS):
    def show_os(self):
        print("IOS系统")


# --------具体工厂--------
class MiFactory(PhoneFactory):
    def make_cpu(self):
        return SnapDragonCPU()

    def make_os(self):
        return Android()

    def make_shell(self):
        return BigShell()


class HuaweiFactory(PhoneFactory):
    def make_cpu(self):
        return MediaTekCPU()

    def make_os(self):
        return Android()

    def make_shell(self):
        return SmallShell()


class IPhoneFactory(PhoneFactory):
    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return IOS()

    def make_shell(self):
        return AppleShell()


# --------客户端--------
class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell

    def show_info(self):
        print("手机信息")
        self.cpu.show_cpu()
        self.os.show_os()
        self.shell.show_shell()

def make_phone(factory):
    cpu = factory.make_cpu()
    os = factory.make_os()
    shell = factory.make_shell()
    return Phone(cpu, os, shell)

p1 = make_phone(MiFactory())
p1.show_info()

二、试画出建造者模式的模式结构图，并对模式进行分析。

2.1建造者模式结构图

图2 建造者模式的模式结构图

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示；建造者模式是一步一步创建一个复杂的对象，它允许用户只铜鼓欧指定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。建造者模式术语对象创建模式。

由图2可知，建造者模式包含以下4个角色：

Director(指挥者)：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息；
Builder(抽象建造者)：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法；
ConcreteProduct1/2(具体建造者)：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应；
Product(产品)：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个部件。

2.2 建造者模式的实现（Java）

Director(指挥者)，调用建造者中的方法完成复杂对象的创建，即其代码如下：

class Director{

    private Builder builder;

    public Director(Builder builder){

        this.builder=builder;

    }

   

    public Product construct(){

        builder.buildPartA();

        builder.buildPartB();

        builder.buildPartC();

        return builder.getResult();

    }

}

Builder(抽象建造者)：包含创建产品各个子部件的抽象方法，其代码如下：

abstract class Builder{

    //创建产品对象

    protected Product product=new Product();

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    //返回产品对象

    public Product getResult(){

        return product;

    }

}

ConcreteProduct1/2(具体建造者)实现了抽象创建者接口，具体代码如下：

public class ConcreteBuilder extends Builder{

    public void buildPartA(){

        product.setPartA("build PartA");

    }

    public void buildPartB(){

        product.setPartA("build PartB");

    }

    public void buildPartC(){

        product.setPartA("build PartC");

    }

}

在客户端代码中，开发只需要关心工厂类即可，不同的具体工厂可以创建不同的产品。其客户端代码片段如下：

public class Demo{

    public static void main(String[] args){

        Builder builder=new ConcreteBuilder();

        Director director=new Director(builder);

        Product product=director.construct();

        product.show();

    }

}

2.3 建造者模式的优缺点

建造者模式包含如下四个角色：抽象建造者为创建一个产品对象的各个部件指定抽象接口；具体建造者实现了抽象建造者接口，实现各个部件的构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象；产品角色是被构建的复杂对象，包含多个组成部件；指挥者负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。

优点：

在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象；
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象；
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程；
增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

缺点：

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制；
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

2.4 建造者模式的实现（Python）

#!/usr/bin/env python
# _*_ coding: utf-8 _*_
# @Time : 
# @Author : 
# @Version：V 0.1
# @File : 建造者模式.py
# @desc : 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
from abc import ABCMeta, abstractmethod


class Player:
    def __init__(self, face=None, body=None, arm=None, leg=None):
        self.face = face
        self.body = body
        self.arm = arm
        self.leg = leg

    def __str__(self):
        return "%s, %s, %s, %s" %(self.face, self.body, self.arm, self.leg)


class PlayerBuilder(metaclass=ABCMeta):
    @abstractmethod
    def build_face(self):
        pass

    @abstractmethod
    def build_body(self):
        pass

    @abstractmethod
    def build_arm(self):
        pass

    @abstractmethod
    def build_leg(self):
        pass


class SexyGirlBuilder(PlayerBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "漂亮脸蛋"

    def build_body(self):
        self.player.body = "苗条"

    def build_arm(self):
        self.player.arm = "漂亮胳膊"

    def build_leg(self):
        self.player.leg = "大长腿"


class Monster(PlayerBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "怪兽脸"

    def build_body(self):
        self.player.body = "怪兽苗条"

    def build_arm(self):
        self.player.arm = "怪兽胳膊"

    def build_leg(self):
        self.player.leg = "怪兽长腿"


class PlayerDirector:  #控制组装顺序
    def builder_player(self, builder):
        builder.build_body()
        builder.build_face()
        builder.build_arm()
        builder.build_leg()
        return builder.player


# 客户端
builder = SexyGirlBuilder()
director = PlayerDirector()
p = director.builder_player(builder)
print(p)

三、计算机包括内存（RAM）,CPU等硬件设备，根据图中的“产品等级结构--产品族”示意图，使用抽象工厂模式实现计算机设备创建过程并绘制出相应的类图。（画出模式结构图，并进行解析）

3.1计算机设备创建程序模式结构图

图3 计算机设备创建的模式结构图

程序设计一个CPU接口，继承它的子类用于生产CPU，Mac生产的CPU建立MacCpu继承它，Pc上产的CPU建立PcCpu继承它。同理一个RAM接口，分别由Mac和Pc的厂家的MacRam和PcRam继承，即可生产RAM，建立一个接口AbstractFactory，用来描述生产产品，里面包含生产CPU和生产RAM方法，继承继承该接口的类都是每一个厂家的工厂，即如图所示，MacFactory为Mac的工厂，它可以生产他们厂的CPU和RAM，PcFactory也是如此。

3.2计算机设备创建程序实现

//定义抽象产品类CPU

public interface CPU {

    void create();

}

//定义抽象产品类RAM

public interface RAM {

    void create();

}

//定义具体产品类PcCPU

public class PcCPU implements CPU{

    public void create() {

        System.out.println(" Win CPU is working");

        System.out.println(" Win CPU is working");

    }

}

//定义具体产品类PcRAM

public class PcRAM implements RAM {

    public void create() {

    System.out.println("Win RAM is working");

    }

}

//定义具体产品类MacCPU

public class MacCPU implements CPU{

    public void create() {

    System.out.println("Mac CPU is working");

    }

}

//定义具体产品类MacRAM

public class MacRAM implements RAM{

    public void create() {

    System.out.println("Mac RAM is working");

    }

}

//定义抽象工厂接口ComputerFactory

interface ComputerFactory {

    CPU produceCPU();

    RAM produceRAM();

}

//定义客户端类ComputerPartsClient

public class ComputerPartsClient {

    public static void main(String args[]) {

        ComputerFactory factory;

        CPU cpu;

        RAM ram;

        factory = new PcFactory();

        cpu = factory.produceCPU();

        cpu.create();

        ram = factory.produceRAM();

        ram.create();

        ComputerFactory factory1;

        factory1 = new MacFactory();

        cpu = factory1.produceCPU();

        cpu.create();

        ram = factory1.produceRAM();

        ram.create();

    }

}

//定义具体工厂类PcFactory

public class PcFactory implements ComputerFactory {

    public PcCPU produceCPU() {

        System.out.println("请使用PC产品族的CPU");

        return new PcCPU();

    }

    public PcRAM produceRAM() {

        System.out.println("请使用PC产品族的RAM");

        return new PcRAM();

    }

}



//定义具体工厂类MacFactory

public class MacFactory implements ComputerFactory{

    public MacCPU produceCPU() {

        System.out.println("请使用Mac产品族的CPU");

        return new MacCPU();

    }

    public MacRAM produceRAM() {

        System.out.println("请使用Mac产品族的RAM");

        return new MacRAM();

    }

}

璩明哲

关注

3
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
抽象工厂模式（Java、Python）、建造者模式（Java、Python）

目录一、试画出抽象工厂模式的模式结构图，并对模式进行分析1.1 抽象工厂模式结构图：1.2 抽象工厂模式的实现（Java）1.3 抽象工厂模式的优缺点1.4 抽象工厂模式的实现（Python）二、试画出建造者模式的模式结构图，并对模式进行分析。2.1建造者模式结构图2.2 建造者模式的实现（Java）2.3 建造者模式的优缺点三、计算机包括内存（RAM）,CPU等硬件设备，根据图中的“产品等级结构--产品族”示意图，使用抽象工厂模式实现计算机设备创建过程并绘制出相应的
复制链接

扫一扫