设计模式

php关键字

abstract(抽象) :

用abstract修饰的类表示这个类是一个抽象类，用abstract修饰的方法表示这个方法是一个抽象方法。
抽象方法是只有方法声明，而没有方法的实现内容。
抽象类不能被实例化，通常是将抽象方法做为子类方法重写使用的，且要把继承的抽象类里的方法都实现。

interface (接口):

如果一个抽象类里的所有方法都是抽象方法，且没有声明变量，所有成员都是public权限，那么这种特殊的抽象类就叫 接口
interface即PHP接口，并用关键字implements来实现接口中方法，且必须完全实现

implements(实施，实现) :
implements是实现多个接口，接口的方法一般为空，必须重写才能使用

extends(继承) :
extends是继承某个类，继承之后可以使用父类的方法，也可以重写父类的方法，如果类被声明为final，则不能被继承

1.工厂模式分类

工厂模式具体可分为三类模式：简单工厂模式，工厂方法模式，抽象工厂模式；

1.1. 简单工厂模式

又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类.

优点: 实现对象的创建和对象的使用分离,将对象的创建交给专门的工厂类负责.

缺点: 工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂.

php示例代码:

#Factory.class.php
";
      }
  }
  class Dog
  {
      function __construct()
      {
          echo "I am Dog class 
";
      }
  }
  class Factory
  {
      public static function CreateAnimal($name){
          
          if ($name == 'cat') {
              return new Cat();
          } elseif ($name == 'dog') {
              return new Dog();
          }
      }
  }

  $cat = Factory::CreateAnimal('cat');
  $dog = Factory::CreateAnimal('dog');

1.2. 工厂方法模式

此模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作延迟到其工厂子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当系统需要新增一个产品，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，使系统的扩展性变得很好，符合面向对象编程的开闭原则;

php示例代码

#ConcreteFactory.class.php：
";
    }
    public function say(){
        echo "I am Cat class 
";
    }
}
class Dog implements Animal
{
    public function run(){
        echo "I'm running fast 
";
    }
    public function say(){
        echo "I am Dog class 
";
    }
}
abstract class Factory{
    abstract static function createAnimal();
}
class CatFactory extends Factory
{
    public static function createAnimal()
    {
        return new Cat();
    }
}
class DogFactory extends Factory
{
    public static function createAnimal()
    {
        return new Dog();
    }
}

$cat = CatFactory::createAnimal();
$cat->say();
$cat->run();

$dog = DogFactory::createAnimal();
$dog->say();
$dog->run();
//I am Cat class 
//I ran slowly 
//I am Dog class 
//I'm running fast 

1.3. 抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
此模式是对工厂方法模式的进一步扩展。在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。

php示例代码：

 #AbstructFactory.class.php
";
  }

  public function watch()
  {
      echo "I'm watching Haier TV 
";
  }
}

class LenovoTv implements TV
{
  public function open()
  {
      echo "Open Lenovo TV 
";
  }

  public function watch()
  {
      echo "I'm watching Lenovo TV 
";
  }
}

interface PC{
  public function work();
  public function play();
}

class LenovoPc implements PC
{
  public function work()
  {
      echo "I'm working on a Lenovo computer 
";
  }
  public function play()
  {
      echo "Lenovo computers can be used to play games 
";
  }
}

class HaierPc implements PC
{
  public function work()
  {
      echo "I'm working on a Haier computer 
";
  }
  public function play()
  {
      echo "Haier computers can be used to play games 
";
  }
}

abstract class Factory{
  abstract public static function createPc();
  abstract public static function createTv();
}

class HaierFactory extends Factory
{
    public static function createTv()
    {
        return new HaierTv();
    }

    public static function createPc()
    {
        return new HaierPc();
    }

}

class LenovoFactory extends Factory
{
    public static function createTv()
    {
        return new LenovoTv();
    }

    public static function createPc()
    {
        return new LenovoPc();
    }

}

$haierFactory = new HaierFactory();
$haierTv = $haierFactory->createTv();
$haierTv->open();
$haierTv->watch();

$haierPc = $haierFactory->createPc();
$haierPc->work();
$haierPc->play();

$lenovoFactory = new LenovoFactory();
$lenovoPc = $lenovoFactory->createPc();
$lenovoPc->work();
$lenovoPc->play();

$lenovoTv = $lenovoFactory->createTv();
$lenovoTv->open();
$lenovoTv->watch();

2.单例模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例.

单例模式是一种常见的设计模式，在计算机系统中，线程池、缓存、日志对象、对话框、打印机、数据库操作、显卡的驱动程序常被设计成单例。
单例模式有以下3个特点：
1．只能有一个实例。
2．必须自行创建这个实例。
3．必须给其他对象提供这一实例。

为什么要使用PHP单例模式？

PHP一个主要应用场合就是应用程序与数据库打交道的场景，在一个应用中会存在大量的数据库操作，针对数据库句柄连接数据库的行为，使用单例模式可以避免大量的new操作。因为每一次new操作都会消耗系统和内存的资源。

然而，PHP在语言级别上没有办法让某个对象常驻内存。在PHP中，所有的变量都是页面级的，无论是全局变量，不过,在实际应用中同一个页面中可能会存在多个业务逻辑,这时单例模式就起到了很重要的作用,有效的避免了重复 ,虽然有时候会有些鸡肋。
在不使用单例的情况下我们在一个类里面操作数据库可能是这样的：

db = mysqli_connect( '127.0.0.1', 'root', '123456', 'testdb');
  }
    
  //私有化克隆函数，防止外界克隆对象
  private function __clone() {}
    
  //单例访问统一入口
  public static function getInstance()
  {
    if(!(self::$instance instanceof self))
    {
      self::$instance = new self();
    }
    return self::$instance;
  }
  //数据库查询操作
  public function getinfo()
  {
    $sql = "select * from testtb";
    $res = mysqli_query($this->db,$sql);
    while($row = mysqli_fetch_array($res)) {
      echo $row['testcol'] . '
';
    }
    mysqli_free_result($res);
  }
}
$mysqli = Db::getInstance();
$mysqli->getinfo();
?>

所以总结如下
1.需要一个保存类的唯一实例的静态成员变量（通常为$_instance私有变量）
2.构造函数和克隆函数必须声明为私有的，这是为了防止外部程序new类从而失去单例模式的意义
3.必须提供一个访问这个实例的公共的静态方法（通常为getInstance方法），从而返回唯一实例的一个引用

PHP单例模式的缺点
众所周知，PHP语言是一种解释型的脚本语言，这种运行机制使得每个PHP页面被解释执行后，所有的相关资源都会被回收。也就是说，PHP在语言级别上没有办法让某个对象常驻内存，这和asp.net、Java等编译型是不同的，比如在Java中单例会一直存在于整个应用程序的生命周期里，变量是跨页面级的，真正可以做到这个实例在应用程序生命周期中的唯一性。然而在PHP中，所有的变量无论是全局变量还是类的静态成员，都是页面级的，每次页面被执行时，都会重新建立新的对象，都会在页面执行完毕后被清空，这样似乎PHP单例模式就没有什么意义了，所以PHP单例模式我觉得只是针对单次页面级请求时出现多个应用场景并需要共享同一对象资源时是非常有意义的。

3.策略模式

策略的计算加减乘除

interface Math
{
    public function  cal($a,$b);
}
class addMath implements  Math
{
    public function cal($a,$b)
    {
        echo $a+$b;
    }
}
class subMath implements  Math
{
    public function cal($a,$b)
    {
        echo $a-$b;
    }
}
class divMath implements  Math
{
    public function cal($a,$b)
    {
        echo $a/$b;
    }
}
class mulMath implements  Math
{
    public function cal($a,$b)
    {
        echo $a*$b;
    }
}


class  Cmath
{
    protected $cal =null;
    public function __construct($type)
    {
        $caltype = $type.'Math';
        $this->cal = new $caltype;
//      return 
    }
    public function cal($a,$b)
    {
        $this->cal->cal($a,$b);
    }
    
}
$para1 = $_POST['para1'];
$para2 = $_POST['para2'];

$type = $_POST['cal'];
$cmath = new Cmath($type);
$cmath->cal($para1, $para2);