PHP Design Patterns - State Pattern_PHP Tutorial-PHP Tutorial-php.cn

PHP Design Patterns - State Pattern_PHP Tutorial

WBOY

Release： 2016-07-13 09:51:01

Original

872 people have browsed it

PHP Design Pattern - State Pattern

The State pattern allows changing the behavior of an object when its intrinsic state changes, making the object appear to have changed its class. The state pattern mainly solves the situation when the conditional expression that controls the state of an object is too complex. By transferring the state judgment logic to a series of classes representing different states, complex judgment logic can be simplified.

UML class diagram:

Character:

Context environment (Work): It defines the interface required by the client program and maintains an instance of a specific state role, and delegates state-related operations to the current specific object for processing.

Abstract state (State): Define an interface to encapsulate the behavior related to a specific state using the context environment.

Concrete state (AmState): implements the interface defined by abstract state.

Core code:

<!--?php
/**
 * Created by PhpStorm--->
 * User: Jang
 * Date: 2015/6/10
 * Time: 10:34
 */

//状态接口
interface IState
{
    function WriteCode(Work $w);
}

//上午工作状态
class AmState implements IState
{
    public function WriteCode(Work $w)
    {
        if($w->hour<=12)
        {
            echo 当前时间：{$w->hour}点，上午工作；犯困，午休。
;
        }
        else
        {
            $w->SetState(new PmState());
            $w->WriteCode();
        }
    }
}

//下午工作状态
class PmState implements IState
{
    public function WriteCode(Work $w)
    {
        if($w->hour<=17)
        {
            echo 当前时间：{$w->hour}点，下午工作状态还不错，继续努力。
;
        }
        else
        {
            $w->SetState(new NightState());
            $w->WriteCode();
        }
    }
}

//晚上工作状态
class NightState implements IState
{

    public function WriteCode(Work $w)
    {
        if($w->IsDone)
        {
            $w->SetState(new BreakState());
            $w->WriteCode();
        }
        else
        {
            if($w->hour<=21)
            {
                echo 当前时间：{$w->hour}点，加班哦，疲累至极。
;
            }
            else
            {
                $w->SetState(new SleepState());
                $w->WriteCode();
            }
        }
    }
}

//休息状态
class BreakState implements IState
{

    public function WriteCode(Work $w)
    {
        echo 当前时间：{$w->hour}点，下班回家了。
;
    }
}

//睡眠状态
class SleepState implements IState
{

    public function WriteCode(Work $w)
    {
        echo 当前时间：{$w->hour}点，不行了，睡着了。
;
    }
}

//工作状态
class Work
{
    private $current;
    public function Work()
    {
        $this->current = new AmState();
    }

    public $hour;

    public $isDone;

    public function SetState(IState $s)
    {
        $this->current = $s;
    }

    public function WriteCode()
    {
        $this->current->WriteCode($this);
    }
}

Copy after login

Call the client test code:

//-------------------------状态模式-------------------------
require_once ./State/State.php;

$emergWork = new Work();
$emergWork->hour = 9;
$emergWork->WriteCode();
$emergWork->hour = 10;
$emergWork->WriteCode();
$emergWork->hour = 13;
$emergWork->WriteCode();
$emergWork->hour=14;
$emergWork->WriteCode();
$emergWork->hour = 17;
$emergWork->WriteCode();

$emergWork->IsDone = true;
$emergWork->IsDone = false;

$emergWork->hour = 19;
$emergWork->WriteCode();

$emergWork->hour = 22;
$emergWork->WriteCode();

Copy after login

Applicable scenarios:

1. The behavior of an object depends on its state, and it must change its behavior according to the state at run time.

2. An operation contains a huge multi-branch structure, and these branches are determined by the state of the object.

Advantages

1. The state pattern localizes the behavior related to a specific state and separates the behavior of different states.

2. All state-related code exists in a ConcereteState, so it is easy to add new states and transitions by defining new subclasses.

3. The state mode reduces mutual dependence by dividing various state transfer logic into subclasses of State.

Disadvantages

Leading to more ConcreteState subclasses

Welcome to follow my video course, the address is as follows, thank you.

PHP object-oriented design patterns