设计模式

 1class Single {
 2    private $name;//声明一个私有的实例变量
 3    private function __construct(){//声明私有构造方法为了防止外部代码使用new来创建对象。
 4    
 5    }
 6
 7    static public $instance;//声明一个静态变量（保存在类中唯一的一个实例）
 8    static public function getinstance(){//声明一个getinstance()静态方法，用于检测是否有实例对象
 9        if(!self::$instance) self::$instance = new self();
10        return self::$instance;
11    }
12
13    public function setname($n){ $this->name = $n; }
14    public function getname(){ return $this->name; }
15}
16
17$oa = Single::getinstance();
18$ob = Single::getinstance();
19$oa->setname('hello php world');
20$ob->setname('good morning php');
21echo $oa->getname();//good morning php
22echo $ob->getname();//good morning php

 1<?php
 2SimpleFactoty::creatA();
 3SimpleFactoty::creatB();
 4SimpleFactoty::creatC();
 5
 6// or
 7
 8SimpleFactoty::creat("A");
 9SimpleFactoty::creat("B");
10SimpleFactoty::creat("C");

 1<?php
 2interface  people
 3{
 4    function marry();
 5}
 6
 7class man implements people
 8{
 9    function marry()
10    {
11        echo '送玫瑰，送戒指！';
12    }
13}
14
15class women implements people
16{
17    function marry()
18    {
19        echo '穿婚纱！';
20    }
21}
22
23class SimpleFactoty
24{
25    // 简单工厂里的静态方法
26    static function createMan()
27    {
28        return new     man;
29    }
30
31    static function createWomen()
32    {
33        return new     women;
34    }
35
36}
37
38SimpleFactoty::createMan()->marry();
39// 送玫瑰，送戒指！
40SimpleFactoty::createWomen()->marry();
41// 穿婚纱！

1<?php
2FactoryA::create();
3FactoryB::create();
4FactoryC::create();
5?>

 1<?php
 2interface  people
 3{
 4    function marry();
 5}
 6
 7class man implements people
 8{
 9    function marry()
10    {
11        echo '送玫瑰，送戒指！';
12    }
13}
14
15class women implements people
16{
17    function marry()
18    {
19        echo '穿婚纱！';
20    }
21}
22
23interface  createMan
24{  // 注意了，这里是简单工厂本质区别所在，将对象的创建抽象成一个接口。
25    function create();
26}
27
28class FactoryMan implements createMan
29{
30    function create()
31    {
32        return new man;
33    }
34}
35
36class FactoryWomen implements createMan
37{
38    function create()
39    {
40        return new women;
41    }
42}
43
44FactoryMan::create()->marry();
45//送玫瑰，送戒指！
46FactoryWomen::create()->marry();
47//穿婚纱！
48?>

1<?php
2FactoryA::create();
3FactoryB::change();
4FactoryC::change();
5FactoryD::delete();
6?>

 1<?php
 2interface  people
 3{
 4    function marry();
 5}
 6
 7class Oman implements people
 8{
 9    function marry()
10    {
11        echo '美女，我送你玫瑰和戒指！';
12    }
13}
14
15class Iman implements people
16{
17    function marry()
18    {
19        echo '我偷偷喜欢你';
20    }
21}
22
23class Owomen implements people
24{
25    function marry()
26    {
27        echo '我要穿婚纱！';
28    }
29}
30
31class Iwomen implements people
32{
33    function marry()
34    {
35        echo '我好害羞哦！！';
36    }
37}
38
39interface  createMan
40{  // 注意了，这里是本质区别所在，将对象的创建抽象成一个接口。
41    function createOpen(); //分为 内敛的和外向的
42
43    function createIntro(); //内向
44}
45
46class FactoryMan implements createMan
47{
48    function createOpen()
49    {
50        return new  Oman;
51    }
52
53    function createIntro()
54    {
55        return new Iman;
56    }
57}
58
59class FactoryWomen implements createMan
60{
61    function createOpen()
62    {
63        return new  Owomen;
64    }
65
66    function createIntro()
67    {
68        return new Iwomen;
69    }
70}
71
72FactoryMan::createOpen()->marry();  //美女，我送你玫瑰和戒指！
73FactoryMan::createIntro()->marry(); //我偷偷喜欢你
74
75FactoryWomen::createOpen()->marry();    //我要穿婚纱！
76FactoryWomen::createIntro()->marry();   //我好害羞哦！！
77?>