1、单例模式
一个类只能输出一个对象
要实现的效果：无论调用多少次，只能输出同一个对象；
class Ren
{
private static $dx; //用来存储生成的对象 设置为静态是因为 静态方法只能调用静态成员
public $name;
//私有的构造函数----直接限制在类外生成对象，所以不行
/*private function __construct()
{
}*/
//生成对象的方法
public static function DuiXiang() //设置为静态是因为：不能new新的对象
{
if(empty(self::$dx)) //判断是否为空，如果空，则new一个新的对象
{
self::$dx = new Ren();
}
return self::$dx; //否则，返回原对象
}
}
$r = Ren::DuiXiang();
$r->name = "张三";
$r1 = Ren::DuiXiang();
var_dump($r1); //返回的值和 var_dump($r)一样
2、工厂模式
计算a+b， a-b的值
第一种方式： 安全性不高
class suan
{
public $a;
public $b;
function jia()
{
return $this->a+$this->b;
}
function jian()
{
return $this->a-$this->b;
}
}
$s=new suan();
$s->a=10;
$s->b=5;
echo $s->jia();
第二种方式：可拓展性高
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 Jia(); //求减法 $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();