浅谈几个面向对象设计模式

面向过程还是面向对象？

“面向过程” (Procedure Oriented)是一种以过程为中心的编程思想
“面向对象” (Object Oriented,简称OO)是一种以事物为中心的编程思想。

面向过程与面向对象本质的区别在于抽象方式的不同，面向过程抽象的是事物的过程，面向对象抽象的是事物的参与者。相较于面向过程，面向对象更能适应这个复杂多变的世界

什么是模式?

在软件世界中,每个开发机构就像是一个部落,而一个模式就是对部落的某种共同记忆的一种有形表现。

项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因

几个核心

健壮性，高内聚，低耦合，效率，可维护，可扩展，安全性等，参考：设计模式原则

企业模式

• 视图层包括系统用户实际看到和交互的界面。它负责显示用户请求的结果及传递新的请求给系统
• 命令和控制层处理用户请求。它委托业务逻辑层处理和满足请求，然后选择最合适的视图显示给用户
• 业务逻辑层负责根据请求执行业务操作。它执行需要的计算并整理结果数据
• 数据层负责保存和获取系统中的持久信息

企业模式.png

单例模式

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例

单例模式.jpg

 //样例
class Preferences
{

    private static $instance = null;

    private function __construct()
    {
    }

    public static function getInstance()
    {
        if (self::$instance == null) {
            self::$instance = new Preferences();
        }
        return self::$instance;
    }

}

观察者模式

观察者模式的核心是把客户元素（观察者）从一个中心类（主体）中分离出来。当主体知道事件发生时，观察者需要被通知到。同时我们并不希望将主体与观察者之间的关系进行硬编码。

观察者模式.jpg

//样例
interface Observable
{
    function attach(Observer $observer);

    function detach(Observer $observer);

    function notify();
}

class Login implements Observable
{
    private $observers;

    //...

    function __construct()
    {
        $this->observers = array();
    }

    function attach(Observer $observer)
    {
        $this->observers[] = $observer;
    }

    function detach(Observer $observer)
    {
        $newobservers = array();
        foreach ($this->observers as $obs) {
            if (($obs !== $observer)) {
                $newobservers[] = $obs;
            }
        }
        $this->observers = $newobservers;
    }

    function notify()
    {
        foreach ($this->observers as $obs) {
            $obs->update($this);
        }
    }

    function handleLogin($user, $pass, $ip)
    {
        //登陆处理
        //...
        $ret = '处理结果';
        $this->notify();
        return $ret;
    }

    function getStatus()
    {
        return $status;//返回状态
    }
}

//...
interface Observer
{
    function update(Obervable $observable);
}

abstract class LoginObserver implements Observer
{
    private $login;

    function __construct(Login $login)
    {
        $this->login = $login;
        $login->attach($this);
    }

    function update(Obervable $observable)
    {
        if ($observable === $this->login) {
            $this->doUpdate($observable);
        }
    }

    abstract function doUpdate(Login $login);
}

class SecurityMonitore extends LoginObserver
{
    function doUpdate(Login $login)
    {
        $status = $login->getStatus();
        //根据状态做相应操作
        //...
    }
}

class GeneralLogger extends LoginObserver
{
    function doUpdate(Login $login)
    {
        $status = $login->getStatus();
        //根据状态做相应操作
        //...
    }
}

class PartnershopTool extends LoginObserver
{
    function doUpdate(Login $login)
    {
        $status = $login->getStatus();
        //根据状态做相应操作
        //...
    }
}

工厂模式

面向对象设计强调“抽象类高于实现”。也就是说我们要尽量一般化而不是特殊化，工厂模式解决了当代码关注于抽象类型时如何创建对象实例的问题。

工厂模式.png

//样例
abstract class ApptEncoder{
    abstract function encode();
}

class BloggsApptEncoder extends ApptEncoder{
    function encode(){
        return "Appointment data encoded in BloggsCal format\n";
    }
}

class MegaApptEncoder extends ApptEncoder{
    function encode(){
        return "Appointment data encoded in MegaCal format\n";
    }
}

class CommsManager{

    const BLOGGS = 1;
    const MEGA = 2;
    private $model = 1;

    function __construct( $model ){
        $this->model = $model;
    }

    function getApptEncoder(){
        switch ( $this->$model ) {
            case ( self::BLOGGS ):
                return new BloggsApptEncoder();
                break;
            default:
                return new MegaApptEncoder();
                break;
        }
    }
}