抽象工厂模式（Java、Python）、建造者模式（Java、Python）
目录
一、试画出抽象工厂模式的模式结构图，并对模式进行分析
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 抽象工厂模式结构图：
图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();
}
}