This article mainly introduces the definition and usage of state mode in PHP. Interested friends can refer to it. I hope it will be helpful to everyone.

DefinitionState pattern, also known as Pattern of Objects for State, state pattern is the behavior pattern of objects. The state pattern allows an object to change its behavior when its internal state changes. This object looks like it has changed its class

UML diagram

Main role in the state patternAbstract state role (State): Define an interface or abstract class State to encapsulate the behavior corresponding to a specific state of the environment object
Concrete State (ConcreteState) role: Each state class implements a state of the environment (Context) Corresponding behavior
Environment (Context) role: Define the interface that the client is interested in, and retain an instance of a specific state class. An instance of this specific state class gives the current state of this environment object

Usage scenarioConsider the application of an online voting system to control that the same user can only cast one vote , if a user votes repeatedly and votes more than 5 times, it is determined to be malicious vote brushing. If a user votes more than 8 times, he needs to be added to the blacklist.

To use the state mode to implement, first of all, the various states of the voting process must be Defined, according to the above description, it can be roughly divided into four states: normal voting, malicious voting, and blacklist voting. Then create a voting management object (equivalent to Context)

UML diagram

Sample code

 <?php 
  
 /** 
  * 抽象狀態(tài)類 
  * @author wzy 
  * 
  */ 
 interface VoteState 
 { 
  
  /** 
   * 需要實現(xiàn)的公共方法 
   */ 
  public function vote (); 
 } 
  
 /** 
  * 具體狀態(tài)——正常投票 
  * 
  * @author wzy 
  *   
  */ 
 class NormalVoteState implements VoteState 
 { 
  
  public function vote () 
  { 
   echo "這是一個正常投票!"; 
  } 
 } 
  
 /** 
  * 具體狀態(tài)——惡意投票 
  * 
  * @author wzy 
  *   
  */ 
 class RepeatVoteState implements VoteState 
 { 
  
  public function vote () 
  { 
   echo "這是一個惡意投票!"; 
  } 
 } 
  
 /** 
  * 具體狀態(tài)——黑名單投票 
  * 
  * @author wzy 
  *   
  */ 
 class BlockVoteState implements VoteState 
 { 
  
  public function vote () 
  { 
   echo "這是一個黑名單投票!"; 
  } 
 } 
  
 /** 
  * Context角色 
  */ 
 class VoteManager 
 { 
  
  /** 
   * 投票數(shù)量 
   * 
   * @var int 
   */ 
  private $vote_count; 
  
  /** 
   * 狀態(tài)類實例 
   * 
   * @var object 
   */ 
  private $voteInstance; 
  
  /** 
   * 構(gòu)造函數(shù)，初始化成員屬性 
   * 
   * @param int $count    
   */ 
  public function __construct ($count = 1) 
  { 
   $this->vote_count = $count; 
  } 
  
  /** 
   * 客戶端調(diào)用的接口函數(shù) 
   */ 
  public function setState ($count) 
  { 
   if (! is_null($count)) { 
    $this->vote_count = $count; 
   } 
   if ($this->vote_count < 5) { 
    $this->voteInstance = new NormalVoteState(); 
   } else 
    if ($this->vote_count < 8) { 
     $this->voteInstance = new RepeatVoteState(); 
    } else { 
     $this->voteInstance = new BlockVoteState(); 
    } 
    
   $this->voteInstance->vote(); 
  } 
 } 
  
 /** 
  * 模擬客戶端操作 
  */ 
  
 $object = new VoteManager(); 
 $object->setState(1); 
 echo "<br>"; 
 $object->setState(6); 
 echo "<br>"; 
 $object->setState(10);

Review state mode
State and BehaviorThe so-called state of an object usually refers to the value of the attribute of the object instance; and behavior refers to the function of the object. To be more specific, most behaviors can be mapped to methods

The function of the state mode is to separate the behavior of the state, and call the functions corresponding to different states by maintaining changes in the state. That is to say, state and behavior are related, and their relationship can be described as: state determines behavior

Because the state is changed during runtime, because the behavior will also change according to the change of state during runtime Change

Environment and state processing objectsIn the state model, the environment (Context) is the object that holds the state, but the environment itself does not handle the behavior related to the state, but handles the state. The function of the state is delegated to the state processing class corresponding to the state.

In specific state processing, it is often necessary to obtain the data of the environment (Context) itself. You can consider using abstract classes instead of interfaces, which may be more convenient. Passing of parameters

The client generally only interacts with the environment (Context). The client can use the state object to configure an environment (Context). Once the configuration is completed, it no longer needs to deal with the state object. The client is usually not responsible for state maintenance during operation, nor is it responsible for which specific state processing object is used later

Summary: The above is the entire content of this article, I hope it can help Everyone’s learning helps.

Related recommendations:

php uses ftp to implement file upload and download functions

PHP implements arrays Detailed explanation of deduplication methods

Detailed explanation of commonly used methods for PHP mysqli transaction operations

The above is the detailed content of Definition and usage of state pattern in PHP. For more information, please follow other related articles on the PHP Chinese website!