[Design Patterns] 01. Creational Patterns

def main():


    # 希望 connect_to 可以处理各种数据库文件，那就返回合适的工厂类，包含许多方法

    xml_factory = connect_to('data/person.xml')

    xml_data = xml_factory.parsed_data

    liars = xml_data.findall(".//{}[{}='{}']".format('person','lastName', 'Liar'))

    print('found: {} persons'.format(len(liars)))

    for liar in liars:

        print('first name: {}'.format(liar.find('firstName').text))

        print('last name: {}'.format(liar.find('lastName').text))

        [print('phone number ({})'.format(p.attrib['type']),

               p.text) for p in liar.find('phoneNumbers')]

    print()



    json_factory = connect_to('data/donut.json')

    json_data = json_factory.parsed_data

    print('found: {} donuts'.format(len(json_data)))

    for donut in json_data:

        print('name: {}'.format(donut['name']))

        print('price: ${}'.format(donut['ppu']))

        [print('topping: {} {}'.format(t['id'], t['type'])) for t in donut['topping']]

if else 实现的缺陷 - 简单工厂模式

connection_factory(filepath) 初始化了一个 ”特定的类“，并返回。

同时也就意味着：添加一个产品需要修改下面的函数，这不是很符合“开闭原则”。

Figure, 简单工厂模式

# factory：根据参数返回合适的工厂产品

def connection_factory(filepath):

    if filepath.endswith('json'):

        connector = JSONConnector

    elif filepath.endswith('xml'):

        connector = XMLConnector

    else:

        # 因为有“为保证安全”的connect_to层

        raise ValueError('Cannot connect to {}'.format(filepath))
　　 
    # 这里返回的已经是一个”实例”

    return connector(filepath)

def connect_to(filepath):

    factory = None

    try:

        factory = connection_factory(filepath)  # 简单模式下，只有一个工厂

    except ValueError as ve:

        print(ve)

    return factory

多个工厂生产各自的产品

Figure, 工厂方法

三、类图符号

类图符号的学习，参考：类图

类名(Class)：每个类都必须有一个名字，类名是一个字符串。
属性(Attributes)：属性是指类的性质，即类的成员变量。类可以有任意多个属性，也可以没有属性。
操作(Operations)：操作是类的任意一个实例对象都可以使用的行为，操作是类的成员方法。

关联关系 (Association)

将一个类的对象作为另一个类的属性。

单向关联

双向关联

多重性关联关系

聚合关系 (Aggregation) 和组合关系 (Composition)

前者是弱关系；后者是强关系；

组合关系，表示整体与部分的关系。

但是与聚合不同此关系是整体与部分是同生共死关系，即如果整体对象销毁了部分也会被销毁。

依赖关系 (Dependency)

Driver是一个整体，Car也是整体，这不是整体与部分关系。

Driver中使用了Car的move方法，从而形成了“依赖关系”。

泛化关系 (Generalization)

继承(extends)关系，父类与子类关系。

实现关系 (Realization)

类实现（implements）了接口。当多个类有类似的行为方式的时候我们通常会使用接口。

四、抽象工厂

抽象工厂

首先，“游戏开始play” 的过程是对外“屏蔽的“。

接着，得到的工厂所包含的方法是统一的。

class GameEnvironment:

　　def __init__(self, factory):

        self.hero     = factory.make_character()

        self.obstacle = factory.make_obstacle()

　　def play(self):

        self.hero.interact_with(self.obstacle)　　# 建立好产品之间的关系

def main():
    name = input("Hello. What's your name? ")

    valid_input = False

    while not valid_input:

        valid_input, age = validate_age(name)

    game = FrogWorld if age < 18 else WizardWorld　　# <---- 工厂类。

    environment = GameEnvironment(game(name))       # <---- 抽象工厂的"工厂"是"类"；参数也是类！

    environment.play()

与工厂方法的区别

Goto: 抽象工厂模式和工厂模式的区别？【三种枪的例子比较不错】

重要的两个问题：

1. 增加一个新工厂，只要实现这个类即可。
2. 增加一个新产品，只要为类添加新方法即可。

"抽象工厂"的工厂是类；"工厂方法"的工厂是方法。

抽象工厂的工厂类就做一件事情生产产品。生产的产品给客户端使用，绝不给自己用。

普通工厂产出是一个产品（实例），抽象工厂产出是一个抽象（接口）。

区别在于，若添加一个新的产品，前者是修改工厂，后者是创建新工厂（符合“闭合原则”）。

其实，抽象工厂多了一个“抽象的部分”从而间接调用“参数类（产品）”的方法。

End.