设计模式

单例模式（可用于窗体程序）
一个类只能够实例化一个对象

在设计的时候我们假设我们需要一个类完成在内存中只有一份的功能，我们该如何做呢？

解决办法是：我们将构造函数设置成 private ，让构造函数只能在内部被调用，而外部不能调用。这样，这个类就不能被外部用 new 的方式建立多个实例了。

以人为例：

class ren
{
        private static $dx;//用来储存生成的对象
        //私有的构造函数
        private function __construct()
        {
                
        }
        //生成对象的方法
        public static function duixiang()
        {
            if(empty(self::$dx))
            {
                self::$dx=new ren();    
            }
                return self::$dx;
        }
}

$r = Ren::DuiXiang();
$r->name = "张三";

$r1 = Ren::DuiXiang();

var_dump($r1);

在里面我们用empty来判断里面是否为空，如果为空就将其添加进去，不为空就返回。

好处：无论获取多少次，返回的都是同一个对象。不会额外的去重复创建自己的复本。大大的节省了系统资源的浪费。

工厂模式

class suan
{
    public $a;
    public $b;
    
    function jia()
    {
        return $this->a+$this->b;
    }
    function jian()
    {
        return $this->a-$this->b;
    }
}

这种的方式安全性不好

class YunSuan
{
    public $a;
    public $b;
    
    function Suan()
    {
    }
}

class Jia extends YunSuan
{
    function Suan()
    {
        return $this->a+$this->b;
    }
}

class Jian extends YunSuan
{
    function Suan()
    {
        return $this->a-$this->b;
    }
}
$s = new Jian();
$s->a=10;
$s->b=5;
echo $s->Suan();

扩展性好相对安全

工厂类

class YunSuan
{
    public $a;
    public $b;
    
    function Suan()
    {
    }
}

class Jia extends YunSuan
{
    function Suan()
    {
        return $this->a+$this->b;
    }
}

class Jian extends YunSuan
{
    function Suan()
    {
        return $this->a-$this->b;
    }
}

class GongChang
{
    static function ShengChan($f)
    {
        switch($f)
        {
            case "+":
                return new Jia();
                break;
            case "-":
                return new Jian();
                break;
        }
    }
}

$r = GongChang::ShengChan("-");
$r->a=10;
$r->b=5;
echo $r->Suan();