设计模式 工厂模式

In |

2020-06-05_5eda16d590209.jpeg

工厂模式

工厂模式三大类
1、简单工厂模式(静态工厂方法模式)
2、工厂方法模式
3、抽象工厂模式(Kit模式)

简单工厂模式

  • 介绍

简单工厂模式是一种创建型设计模式，它提供了一个简单的工厂类来创建对象，而无需暴露对象的创建逻辑。简单工厂模式通常包含一个抽象工厂类、一个抽象产品类和多个具体产品类。

  • 角色
角色 说明
Factory 抽象工厂类，负责创建具体产品的实例
Product 抽象产品类，定义产品子类的公共接口
ConcreteProduct 具体产品类，实现 Product 父类的接口功能，也可添加自定义的功能
  • 角色示例
类名 担任角色 说明
Poultry 抽象工厂 抽象家禽类，定义家禽子类的公共接口
Cat 具体产品 猫类，实现家禽类的接口功能，也可添加自定义的功能
Dog 具体产品 狗类，实现家禽类的接口功能，也可添加自定义的功能
Duck 具体产品 鸭类，实现家禽类的接口功能，也可添加自定义的功能
Pasture 抽象产品 牧场类，负责饲养具体家禽的实例
  • UML 类图

简单工厂模式.png

  • 创建 Pasture.php，内容如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
<?php 
interface Poultry
{
    public function breed();
}

class Cat implements Poultry
{
    public function breed()
    {
        echo "I am cat, I can breed.".PHP_EOL;
    }
}

class Dog implements Poultry
{
    public function breed()
    {
        echo "I am dog, I can breed.".PHP_EOL;
    }
}

class Duck implements Poultry
{
    public function breed()
    {
        echo "I am duck, I can breed.".PHP_EOL;
    }
}

class Pasture
{
    public static function feedPoultry($name){
        switch ($name) {
          case 'cat':
            return (new Cat)->breed();
            break;
          case 'dog':
            return (new Dog)->breed();
            break;
          case 'duck':
            return (new Duck)->breed();
            break;
        }
    }
}

$cat = Pasture::feedPoultry('cat');
$dog = Pasture::feedPoultry('dog');
$duck = Pasture::feedPoultry('duck');
  • 执行
1
2
3
4
$ php Pasture.php
I am cat, I can breed.
I am dog, I can breed.
I am duck, I can breed.

工厂方法模式

  • 介绍

工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但让子类决定实例化哪个类。换句话说，工厂方法模式允许子类决定实例化的类，而不是在父类中硬编码创建对象的逻辑。

  • 角色
角色 说明
Product 抽象产品类，定义产品子类的公共接口
ConcreteProduct 具体产品类，实现 Product 父类的接口功能，也可添加自定义的功能
Factory 抽象工厂类，负责创建具体产品的实例
ConcreteFactory 具体工厂类，实现 Factory 父类的接口功能，也可添加自定义的功能
  • 角色示例
类名 担任角色 说明
Livestock 抽象产品 抽象家畜类，定义家畜子类的公共接口
Sheep 具体产品 羊类，实现家畜类的接口功能，也可添加自定义的功能
Cow 具体产品 牛类，实现家畜类的接口功能，也可添加自定义的功能
Pasture 抽象工厂 抽象牧场类，定义牧场子类的公共接口
SheepPasture 具体工厂 羊牧场类，实现牧场类的接口功能，也可添加自定义的功能
CowPasture 具体工厂 牛牧场类，实现牧场类的接口功能，也可添加自定义的功能
  • UML 类图

工厂方法模式.png

  • 创建 Livestock.php，内容如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<?php 
interface Livestock{
    public function breed();
}

class Sheep implements Livestock
{
    public function breed(){
        echo "I am sheep, I can breed.".PHP_EOL;
    }
}

class Cow implements Livestock
{
    public function breed(){
        echo "I am cow, I can breed.".PHP_EOL;
    }
}

interface Pasture
{
    public function feedLivestock();
}

class SheepPasture implements Pasture
{
    public function feedLivestock()
    {
        return new Sheep();
    }
}

class CowPasture implements Pasture
{
    public function feedLivestock()
    {
        return new Cow();
    }
}

$sheep = SheepPasture::feedLivestock();
$sheep->breed();

$cow = CowPasture::feedLivestock();
$cow->breed();
  • 执行
1
2
3
$ php Pasture.php
I am sheep, I can breed.
I am cow, I can breed.

抽象工厂模式

  • 介绍

抽象工厂模式是一种创建型设计模式，它提供了一种接口，用于创建相关或依赖对象的家族，而不需要明确指定它们的具体类。它是工厂方法模式的扩展。

  • 角色

| 角色 | 说明 |
| ———— | ———— | ———— |
|Factory|抽象工厂类，负责创建具体产品的实例|
|ConcreteFactory|具体工厂类，实现 Factory 父类的接口功能，也可添加自定义的功能|
|Product|抽象产品类，定义产品子类的公共接口|
|ConcreteProduct|具体产品类，实现 Product 父类的接口功能，也可添加自定义的功能|

  • 角色示例
类名 担任角色 说明
Pastoral 抽象工厂 抽象牧区类，定义牧区子类的公共接口
XinJiangPastoral 具体工厂 新疆牧区类，实现牧区类的接口功能，也可添加自定义的功能
QingHaIPastoral 具体工厂 青海牧区类，实现牧区类的接口功能，也可添加自定义的功能
Sheep 抽象产品 抽象羊类，定义羊子类的公共接口
Lambskin 具体产品 羔皮羊类，实现羊类的接口功能，也可添加自定义的功能
TibetanSheep 具体产品 藏羊类，实现羊类的接口功能，也可添加自定义的功能
Cow 抽象产品 抽象牛类，定义牛子类的公共接口
Yak 具体产品 耗牛类，实现牛类的接口功能，也可添加自定义的功能
Cattle 具体产品 黄牛类，实现牛类的接口功能，也可添加自定义的功能
  • UML 类图

抽象工厂模式.png

  • 创建 Pastoral.php，内容如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
<?php 

interface Sheep{
    public function run();
}

class Lambskin implements Sheep
{
    public function run()
    {
        echo "I am lambskin, I can run.".PHP_EOL;
    }
}

class TibetanSheep implements Sheep
{
    public function run()
    {
        echo "I am tibetanSheep, I can run.".PHP_EOL;
    }
}

interface Cow{
    public function jump();
}

class Yak implements Cow
{
    public function jump()
    {
        echo "I am yak, I can jump.".PHP_EOL;
    }
}

class Cattle implements Cow
{
    public function jump()
    {
        echo "I am cattle, I can jump.".PHP_EOL;
    }
}

interface Pastoral{
    public function feedSheep();
    public function feedCow();
}

class XinJiangPastoral implements Pastoral
{
    public function feedSheep()
    {
        return new Lambskin();
    }

    public function feedCow()
    {
        return new Yak();
    }

}

class QingHaIPastoral implements Pastoral
{
    public function feedSheep()
    {
        return new TibetanSheep();
    }

    public function feedCow()
    {
        return new Cattle();
    }
}

$xinJiangPastoral = new XinJiangPastoral();
$lambskin = $xinJiangPastoral->feedSheep();
$lambskin->run();

$yak = $xinJiangPastoral->feedCow();
$yak->jump();

$qingHaIPastoral = new QingHaIPastoral();
$tibetanSheep = $qingHaIPastoral->feedSheep();
$tibetanSheep->run();

$cattle = $xinJiangPastoral->feedCow();
$cattle->jump();
  • 执行
1
2
3
4
5
$ php Pastoral.php
I am lambskin, I can run.
I am yak, I can jump.
I am tibetanSheep, I can run.
I am yak, I can jump.
-------------本文结束感谢您的阅读-------------
0%