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

红太狼 2023-01-16 02:16 36阅读 0赞

**目录**

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

1.1 抽象工厂模式结构图：

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

1.3 抽象工厂模式的优缺点

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

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

2.1建造者模式结构图

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

2.3 建造者模式的优缺点

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

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

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

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

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

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

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

## 1.1 抽象工厂模式结构图： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70][]

图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()

![20210423113700182.png][]

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

## 2.1建造者模式结构图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 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等硬件设备，根据图中的“产品等级结构--产品族”示意图，使用抽象工厂模式实现计算机设备创建过程并绘制出相应的类图。（画出模式结构图，并进行解析） #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 2][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 3][]

图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();
    
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70]: /images/20221022/d4754c67763c4f9ca0f7080fca7b9971.png
[20210423113700182.png]: /images/20221022/76b93a0b2f2a4693997793cb2d7403cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 1]: /images/20221022/17e305823f6c4da7a2943649bd3112d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 2]: /images/20221022/01747464c6bf4ec6b621c6fc88a973dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 3]: /images/20221022/6b0df05234564ec3b2c864ab0d848df3.png