PHP设计模式——工厂模式（Factory Pattern）

 工厂模式（Factory Pattern）分为三类

简单工厂模式（Simple Factory）

简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。简单工厂模式是通过一个静态方法创建对象的。

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
interface  people {
    function  marry();
}
class man implements people{
    function marry() {
        echo '送玫瑰，送戒指！<br>';
    }
}
  
class women implements people {
    function marry() {
        echo '穿婚纱！<br>';
    }
}
  
class SimpleFactoty {
    // 简单工厂里的静态方法
    static function createMan() {
        return new man;
    }
    static function createWomen() {
        return new women;
    }
     
}
  
$man = SimpleFactoty::createMan();
$man->marry();
$man = SimpleFactoty::createWomen();
$man->marry();

 

工厂方法模式（Factory Method）

定义一个创建对象的接口，让子类决定哪个类实例化。 他可以解决简单工厂模式中的封闭开放原则问题。

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
interface  people {
    function marry();
}
class man implements people{
    function marry() {
        echo '送玫瑰，送戒指！<br>';
    }
}
  
class women implements people {
    function marry() {
        echo '穿婚纱！<br>';
    }
}
  
interface  createMan {  // 注意了，这里是简单工厂本质区别所在，将对象的创建抽象成一个接口。
    function create();
  
}
class FactoryMan implements createMan{
    function create() {
        return  new man;
    }
}
class FactoryWomen implements createMan {
    function create() {
        return new women;
    }
}
  
class  Client {
    // 简单工厂里的静态方法
    function test() {
        $Factory =  new  FactoryMan;
        $man = $Factory->create();
        $man->marry();
         
        $Factory =  new  FactoryWomen;
        $man = $Factory->create();
        $man->marry();
    }
}
  
$f = new Client;
$f->test();

抽象工厂模式（Abstract Factory）

抽象工厂：提供一个创建一系列相关或相互依赖对象的接口。
注意：这里和工厂方法的区别是：一系列，而工厂方法则是一个。

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
interface  people {
    function  marry();
}
class Oman implements people{
    function marry() {
        echo '美女，我送你玫瑰和戒指！<br>';
    }
}
class Iman implements people{
    function marry() {
        echo '我偷偷喜欢你<br>';
    }
}
  
class Owomen implements people {
    function marry() {
        echo '我要穿婚纱！<br>';
    }
}
  
class Iwomen implements people {
    function marry() {
        echo '我好害羞哦！！<br>';
    }
}
  
interface  createMan {  // 注意了，这里是本质区别所在，将对象的创建抽象成一个接口。
    function createOpen(); //分为 内敛的和外向的
    function createIntro(); //内向
  
}
class FactoryMan implements createMan{
    function createOpen() {
        return  new  Oman;
    }
    function createIntro() {
        return  new Iman;
    }
}
class FactoryWomen implements createMan {
    function createOpen() {
        return  new  Owomen;
    }
    function createIntro() {
        return  new Iwomen;
    }
}
  
class  Client {
    // 简单工厂里的静态方法
    function test() {
        $Factory =  new  FactoryMan;
        $man = $Factory->createOpen();
        $man->marry();
         
        $man = $Factory->createIntro();
        $man->marry();
         
         
        $Factory =  new  FactoryWomen;
        $man = $Factory->createOpen();
        $man->marry();
         
        $man = $Factory->createIntro();
        $man->marry();
         
    }
}
  
$f = new Client;
$f->test();

 

 

Tags:

发表评论