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

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

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://haidsoft.com/107820.html